summaryrefslogtreecommitdiff
path: root/src/ftgl/FTFont
diff options
context:
space:
mode:
Diffstat (limited to 'src/ftgl/FTFont')
-rw-r--r--src/ftgl/FTFont/FTBitmapFont.cpp106
-rw-r--r--src/ftgl/FTFont/FTBitmapFontImpl.h62
-rw-r--r--src/ftgl/FTFont/FTBufferFont.cpp349
-rw-r--r--src/ftgl/FTFont/FTBufferFontImpl.h81
-rw-r--r--src/ftgl/FTFont/FTExtrudeFont.cpp89
-rw-r--r--src/ftgl/FTFont/FTExtrudeFontImpl.h81
-rw-r--r--src/ftgl/FTFont/FTFont.cpp552
-rw-r--r--src/ftgl/FTFont/FTFontGlue.cpp227
-rw-r--r--src/ftgl/FTFont/FTFontImpl.h162
-rw-r--r--src/ftgl/FTFont/FTOutlineFont.cpp129
-rw-r--r--src/ftgl/FTFont/FTOutlineFontImpl.h73
-rw-r--r--src/ftgl/FTFont/FTPixmapFont.cpp131
-rw-r--r--src/ftgl/FTFont/FTPixmapFontImpl.h60
-rw-r--r--src/ftgl/FTFont/FTPolygonFont.cpp89
-rw-r--r--src/ftgl/FTFont/FTPolygonFontImpl.h60
-rw-r--r--src/ftgl/FTFont/FTTextureFont.cpp267
-rw-r--r--src/ftgl/FTFont/FTTextureFontImpl.h152
17 files changed, 2670 insertions, 0 deletions
diff --git a/src/ftgl/FTFont/FTBitmapFont.cpp b/src/ftgl/FTFont/FTBitmapFont.cpp
new file mode 100644
index 0000000..ebf3f1e
--- /dev/null
+++ b/src/ftgl/FTFont/FTBitmapFont.cpp
@@ -0,0 +1,106 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "config.h"
+
+#include "FTGL/ftgl.h"
+
+#include "FTInternals.h"
+#include "FTBitmapFontImpl.h"
+
+
+//
+// FTBitmapFont
+//
+
+
+FTBitmapFont::FTBitmapFont(char const *fontFilePath) :
+ FTFont(new FTBitmapFontImpl(this, fontFilePath))
+{}
+
+
+FTBitmapFont::FTBitmapFont(unsigned char const *pBufferBytes,
+ size_t bufferSizeInBytes) :
+ FTFont(new FTBitmapFontImpl(this, pBufferBytes, bufferSizeInBytes))
+{}
+
+
+FTBitmapFont::~FTBitmapFont()
+{}
+
+
+FTGlyph* FTBitmapFont::MakeGlyph(FT_GlyphSlot ftGlyph)
+{
+ return new FTBitmapGlyph(ftGlyph);
+}
+
+
+//
+// FTBitmapFontImpl
+//
+
+
+template <typename T>
+inline FTPoint FTBitmapFontImpl::RenderI(const T* string, const int len,
+ FTPoint position, FTPoint spacing,
+ int renderMode)
+{
+ // Protect GL_BLEND
+ glPushAttrib(GL_COLOR_BUFFER_BIT);
+
+ // Protect glPixelStorei() calls (also in FTBitmapGlyphImpl::RenderImpl)
+ glPushClientAttrib(GL_CLIENT_PIXEL_STORE_BIT);
+
+ glPixelStorei(GL_UNPACK_LSB_FIRST, GL_FALSE);
+ glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+
+ glDisable(GL_BLEND);
+
+ FTPoint tmp = FTFontImpl::Render(string, len,
+ position, spacing, renderMode);
+
+ glPopClientAttrib();
+ glPopAttrib();
+
+ return tmp;
+}
+
+
+FTPoint FTBitmapFontImpl::Render(const char * string, const int len,
+ FTPoint position, FTPoint spacing,
+ int renderMode)
+{
+ return RenderI(string, len, position, spacing, renderMode);
+}
+
+
+FTPoint FTBitmapFontImpl::Render(const wchar_t * string, const int len,
+ FTPoint position, FTPoint spacing,
+ int renderMode)
+{
+ return RenderI(string, len, position, spacing, renderMode);
+}
+
diff --git a/src/ftgl/FTFont/FTBitmapFontImpl.h b/src/ftgl/FTFont/FTBitmapFontImpl.h
new file mode 100644
index 0000000..7f733d6
--- /dev/null
+++ b/src/ftgl/FTFont/FTBitmapFontImpl.h
@@ -0,0 +1,62 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __FTBitmapFontImpl__
+#define __FTBitmapFontImpl__
+
+#include "FTFontImpl.h"
+
+class FTGlyph;
+
+class FTBitmapFontImpl : public FTFontImpl
+{
+ friend class FTBitmapFont;
+
+ protected:
+ FTBitmapFontImpl(FTFont *ftFont, const char* fontFilePath) :
+ FTFontImpl(ftFont, fontFilePath) {};
+
+ FTBitmapFontImpl(FTFont *ftFont, const unsigned char *pBufferBytes,
+ size_t bufferSizeInBytes) :
+ FTFontImpl(ftFont, pBufferBytes, bufferSizeInBytes) {};
+
+ virtual FTPoint Render(const char *s, const int len,
+ FTPoint position, FTPoint spacing,
+ int renderMode);
+
+ virtual FTPoint Render(const wchar_t *s, const int len,
+ FTPoint position, FTPoint spacing,
+ int renderMode);
+
+ private:
+ /* Internal generic Render() implementation */
+ template <typename T>
+ inline FTPoint RenderI(const T *s, const int len,
+ FTPoint position, FTPoint spacing, int mode);
+};
+
+#endif // __FTBitmapFontImpl__
+
diff --git a/src/ftgl/FTFont/FTBufferFont.cpp b/src/ftgl/FTFont/FTBufferFont.cpp
new file mode 100644
index 0000000..e48e2ab
--- /dev/null
+++ b/src/ftgl/FTFont/FTBufferFont.cpp
@@ -0,0 +1,349 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "config.h"
+
+#include <wchar.h>
+
+#include "FTGL/ftgl.h"
+
+#include "FTInternals.h"
+#include "FTBufferFontImpl.h"
+
+
+//
+// FTBufferFont
+//
+
+
+FTBufferFont::FTBufferFont(char const *fontFilePath) :
+ FTFont(new FTBufferFontImpl(this, fontFilePath))
+{}
+
+
+FTBufferFont::FTBufferFont(unsigned char const *pBufferBytes,
+ size_t bufferSizeInBytes) :
+ FTFont(new FTBufferFontImpl(this, pBufferBytes, bufferSizeInBytes))
+{}
+
+
+FTBufferFont::~FTBufferFont()
+{}
+
+
+FTGlyph* FTBufferFont::MakeGlyph(FT_GlyphSlot ftGlyph)
+{
+ FTBufferFontImpl *myimpl = dynamic_cast<FTBufferFontImpl *>(impl);
+ if(!myimpl)
+ {
+ return NULL;
+ }
+
+ return myimpl->MakeGlyphImpl(ftGlyph);
+}
+
+
+//
+// FTBufferFontImpl
+//
+
+
+FTBufferFontImpl::FTBufferFontImpl(FTFont *ftFont, const char* fontFilePath) :
+ FTFontImpl(ftFont, fontFilePath),
+ buffer(new FTBuffer())
+{
+ load_flags = FT_LOAD_NO_HINTING | FT_LOAD_NO_BITMAP;
+
+ glGenTextures(BUFFER_CACHE_SIZE, idCache);
+
+ for(int i = 0; i < BUFFER_CACHE_SIZE; i++)
+ {
+ stringCache[i] = NULL;
+ glBindTexture(GL_TEXTURE_2D, idCache[i]);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+ }
+
+ lastString = 0;
+}
+
+
+FTBufferFontImpl::FTBufferFontImpl(FTFont *ftFont,
+ const unsigned char *pBufferBytes,
+ size_t bufferSizeInBytes) :
+ FTFontImpl(ftFont, pBufferBytes, bufferSizeInBytes),
+ buffer(new FTBuffer())
+{
+ load_flags = FT_LOAD_NO_HINTING | FT_LOAD_NO_BITMAP;
+
+ glGenTextures(BUFFER_CACHE_SIZE, idCache);
+
+ for(int i = 0; i < BUFFER_CACHE_SIZE; i++)
+ {
+ stringCache[i] = NULL;
+ glBindTexture(GL_TEXTURE_2D, idCache[i]);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+ }
+
+ lastString = 0;
+}
+
+
+FTBufferFontImpl::~FTBufferFontImpl()
+{
+ glDeleteTextures(BUFFER_CACHE_SIZE, idCache);
+
+ for(int i = 0; i < BUFFER_CACHE_SIZE; i++)
+ {
+ if(stringCache[i])
+ {
+ free(stringCache[i]);
+ }
+ }
+
+ delete buffer;
+}
+
+
+FTGlyph* FTBufferFontImpl::MakeGlyphImpl(FT_GlyphSlot ftGlyph)
+{
+ return new FTBufferGlyph(ftGlyph, buffer);
+}
+
+
+bool FTBufferFontImpl::FaceSize(const unsigned int size,
+ const unsigned int res)
+{
+ for(int i = 0; i < BUFFER_CACHE_SIZE; i++)
+ {
+ if(stringCache[i])
+ {
+ free(stringCache[i]);
+ stringCache[i] = NULL;
+ }
+ }
+
+ return FTFontImpl::FaceSize(size, res);
+}
+
+
+static inline GLuint NextPowerOf2(GLuint in)
+{
+ in -= 1;
+
+ in |= in >> 16;
+ in |= in >> 8;
+ in |= in >> 4;
+ in |= in >> 2;
+ in |= in >> 1;
+
+ return in + 1;
+}
+
+
+inline int StringCompare(void const *a, char const *b, int len)
+{
+ return len < 0 ? strcmp((char const *)a, b)
+ : strncmp((char const *)a, b, len);
+}
+
+
+inline int StringCompare(void const *a, wchar_t const *b, int len)
+{
+ return len < 0 ? wcscmp((wchar_t const *)a, b)
+ : wcsncmp((wchar_t const *)a, b, len);
+}
+
+
+inline char *StringCopy(char const *s, int len)
+{
+ if(len < 0)
+ {
+ return strdup(s);
+ }
+ else
+ {
+#ifdef HAVE_STRNDUP
+ return strndup(s, len);
+#else
+ char *s2 = (char*)malloc(len + 1);
+ memcpy(s2, s, len);
+ s2[len] = 0;
+ return s2;
+#endif
+ }
+}
+
+
+inline wchar_t *StringCopy(wchar_t const *s, int len)
+{
+ if(len < 0)
+ {
+#if defined HAVE_WCSDUP
+ return wcsdup(s);
+#else
+ len = (int)wcslen(s);
+#endif
+ }
+
+ wchar_t *s2 = (wchar_t *)malloc((len + 1) * sizeof(wchar_t));
+ memcpy(s2, s, len * sizeof(wchar_t));
+ s2[len] = 0;
+ return s2;
+}
+
+
+template <typename T>
+inline FTPoint FTBufferFontImpl::RenderI(const T* string, const int len,
+ FTPoint position, FTPoint spacing,
+ int renderMode)
+{
+ const float padding = 3.0f;
+ int width, height, texWidth, texHeight;
+ int cacheIndex = -1;
+ bool inCache = false;
+
+ // Protect blending functions, GL_BLEND and GL_TEXTURE_2D
+ glPushAttrib(GL_COLOR_BUFFER_BIT | GL_ENABLE_BIT);
+
+ // Protect glPixelStorei() calls
+ glPushClientAttrib(GL_CLIENT_PIXEL_STORE_BIT);
+
+ glEnable(GL_BLEND);
+ glEnable(GL_TEXTURE_2D);
+ glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // GL_ONE
+
+ // Search whether the string is already in a texture we uploaded
+ for(int n = 0; n < BUFFER_CACHE_SIZE; n++)
+ {
+ int i = (lastString + n + BUFFER_CACHE_SIZE) % BUFFER_CACHE_SIZE;
+
+ if(stringCache[i] && !StringCompare(stringCache[i], string, len))
+ {
+ cacheIndex = i;
+ inCache = true;
+ break;
+ }
+ }
+
+ // If the string was not found, we need to put it in the cache and compute
+ // its new bounding box.
+ if(!inCache)
+ {
+ // FIXME: this cache is not very efficient. We should first expire
+ // strings that are not used very often.
+ cacheIndex = lastString;
+ lastString = (lastString + 1) % BUFFER_CACHE_SIZE;
+
+ if(stringCache[cacheIndex])
+ {
+ free(stringCache[cacheIndex]);
+ }
+ // FIXME: only the first N bytes are copied; we want the first N chars.
+ stringCache[cacheIndex] = StringCopy(string, len);
+ bboxCache[cacheIndex] = BBox(string, len, FTPoint(), spacing);
+ }
+
+ FTBBox bbox = bboxCache[cacheIndex];
+
+ width = static_cast<int>(bbox.Upper().X() - bbox.Lower().X()
+ + padding + padding + 0.5);
+ height = static_cast<int>(bbox.Upper().Y() - bbox.Lower().Y()
+ + padding + padding + 0.5);
+
+ texWidth = NextPowerOf2(width);
+ texHeight = NextPowerOf2(height);
+
+ glBindTexture(GL_TEXTURE_2D, idCache[cacheIndex]);
+
+ // If the string was not found, we need to render the text in a new
+ // texture buffer, then upload it to the OpenGL layer.
+ if(!inCache)
+ {
+ buffer->Size(texWidth, texHeight);
+ buffer->Pos(FTPoint(padding, padding) - bbox.Lower());
+
+ advanceCache[cacheIndex] =
+ FTFontImpl::Render(string, len, FTPoint(), spacing, renderMode);
+
+ glBindTexture(GL_TEXTURE_2D, idCache[cacheIndex]);
+
+ glPixelStorei(GL_UNPACK_LSB_FIRST, GL_FALSE);
+ glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
+ glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+
+ /* TODO: use glTexSubImage2D later? */
+ glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, texWidth, texHeight, 0,
+ GL_ALPHA, GL_UNSIGNED_BYTE, (GLvoid *)buffer->Pixels());
+
+ buffer->Size(0, 0);
+ }
+
+ FTPoint low = position + bbox.Lower();
+ FTPoint up = position + bbox.Upper();
+
+ glBegin(GL_QUADS);
+ glNormal3f(0.0f, 0.0f, 1.0f);
+ glTexCoord2f(padding / texWidth,
+ (texHeight - height + padding) / texHeight);
+ glVertex2f(low.Xf(), up.Yf());
+ glTexCoord2f(padding / texWidth,
+ (texHeight - padding) / texHeight);
+ glVertex2f(low.Xf(), low.Yf());
+ glTexCoord2f((width - padding) / texWidth,
+ (texHeight - padding) / texHeight);
+ glVertex2f(up.Xf(), low.Yf());
+ glTexCoord2f((width - padding) / texWidth,
+ (texHeight - height + padding) / texHeight);
+ glVertex2f(up.Xf(), up.Yf());
+ glEnd();
+
+ glPopClientAttrib();
+ glPopAttrib();
+
+ return position + advanceCache[cacheIndex];
+}
+
+
+FTPoint FTBufferFontImpl::Render(const char * string, const int len,
+ FTPoint position, FTPoint spacing,
+ int renderMode)
+{
+ return RenderI(string, len, position, spacing, renderMode);
+}
+
+
+FTPoint FTBufferFontImpl::Render(const wchar_t * string, const int len,
+ FTPoint position, FTPoint spacing,
+ int renderMode)
+{
+ return RenderI(string, len, position, spacing, renderMode);
+}
+
diff --git a/src/ftgl/FTFont/FTBufferFontImpl.h b/src/ftgl/FTFont/FTBufferFontImpl.h
new file mode 100644
index 0000000..15557f6
--- /dev/null
+++ b/src/ftgl/FTFont/FTBufferFontImpl.h
@@ -0,0 +1,81 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __FTBufferFontImpl__
+#define __FTBufferFontImpl__
+
+#include "FTFontImpl.h"
+
+class FTGlyph;
+class FTBuffer;
+
+class FTBufferFontImpl : public FTFontImpl
+{
+ friend class FTBufferFont;
+
+ protected:
+ FTBufferFontImpl(FTFont *ftFont, const char* fontFilePath);
+
+ FTBufferFontImpl(FTFont *ftFont, const unsigned char *pBufferBytes,
+ size_t bufferSizeInBytes);
+
+ virtual ~FTBufferFontImpl();
+
+ virtual FTPoint Render(const char *s, const int len,
+ FTPoint position, FTPoint spacing,
+ int renderMode);
+
+ virtual FTPoint Render(const wchar_t *s, const int len,
+ FTPoint position, FTPoint spacing,
+ int renderMode);
+
+ virtual bool FaceSize(const unsigned int size,
+ const unsigned int res);
+
+ private:
+ /**
+ * Create an FTBufferGlyph object for the base class.
+ */
+ FTGlyph* MakeGlyphImpl(FT_GlyphSlot ftGlyph);
+
+ /* Internal generic Render() implementation */
+ template <typename T>
+ inline FTPoint RenderI(const T *s, const int len,
+ FTPoint position, FTPoint spacing, int mode);
+
+ /* Pixel buffer */
+ FTBuffer *buffer;
+
+ static const int BUFFER_CACHE_SIZE = 16;
+ /* Texture IDs */
+ GLuint idCache[BUFFER_CACHE_SIZE];
+ void *stringCache[BUFFER_CACHE_SIZE];
+ FTBBox bboxCache[BUFFER_CACHE_SIZE];
+ FTPoint advanceCache[BUFFER_CACHE_SIZE];
+ int lastString;
+};
+
+#endif // __FTBufferFontImpl__
+
diff --git a/src/ftgl/FTFont/FTExtrudeFont.cpp b/src/ftgl/FTFont/FTExtrudeFont.cpp
new file mode 100644
index 0000000..9e8eb72
--- /dev/null
+++ b/src/ftgl/FTFont/FTExtrudeFont.cpp
@@ -0,0 +1,89 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "config.h"
+
+#include "FTGL/ftgl.h"
+
+#include "FTInternals.h"
+#include "FTExtrudeFontImpl.h"
+
+
+//
+// FTExtrudeFont
+//
+
+
+FTExtrudeFont::FTExtrudeFont(char const *fontFilePath) :
+ FTFont(new FTExtrudeFontImpl(this, fontFilePath))
+{}
+
+
+FTExtrudeFont::FTExtrudeFont(const unsigned char *pBufferBytes,
+ size_t bufferSizeInBytes) :
+ FTFont(new FTExtrudeFontImpl(this, pBufferBytes, bufferSizeInBytes))
+{}
+
+
+FTExtrudeFont::~FTExtrudeFont()
+{}
+
+
+FTGlyph* FTExtrudeFont::MakeGlyph(FT_GlyphSlot ftGlyph)
+{
+ FTExtrudeFontImpl *myimpl = dynamic_cast<FTExtrudeFontImpl *>(impl);
+ if(!myimpl)
+ {
+ return NULL;
+ }
+
+ return new FTExtrudeGlyph(ftGlyph, myimpl->depth, myimpl->front,
+ myimpl->back, myimpl->useDisplayLists);
+}
+
+
+//
+// FTExtrudeFontImpl
+//
+
+
+FTExtrudeFontImpl::FTExtrudeFontImpl(FTFont *ftFont, const char* fontFilePath)
+: FTFontImpl(ftFont, fontFilePath),
+ depth(0.0f), front(0.0f), back(0.0f)
+{
+ load_flags = FT_LOAD_NO_HINTING;
+}
+
+
+FTExtrudeFontImpl::FTExtrudeFontImpl(FTFont *ftFont,
+ const unsigned char *pBufferBytes,
+ size_t bufferSizeInBytes)
+: FTFontImpl(ftFont, pBufferBytes, bufferSizeInBytes),
+ depth(0.0f), front(0.0f), back(0.0f)
+{
+ load_flags = FT_LOAD_NO_HINTING;
+}
+
diff --git a/src/ftgl/FTFont/FTExtrudeFontImpl.h b/src/ftgl/FTFont/FTExtrudeFontImpl.h
new file mode 100644
index 0000000..c2ddf27
--- /dev/null
+++ b/src/ftgl/FTFont/FTExtrudeFontImpl.h
@@ -0,0 +1,81 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __FTExtrudeFontImpl__
+#define __FTExtrudeFontImpl__
+
+#include "FTFontImpl.h"
+
+class FTGlyph;
+
+class FTExtrudeFontImpl : public FTFontImpl
+{
+ friend class FTExtrudeFont;
+
+ protected:
+ FTExtrudeFontImpl(FTFont *ftFont, const char* fontFilePath);
+
+ FTExtrudeFontImpl(FTFont *ftFont, const unsigned char *pBufferBytes,
+ size_t bufferSizeInBytes);
+
+ /**
+ * Set the extrusion distance for the font.
+ *
+ * @param d The extrusion distance.
+ */
+ virtual void Depth(float d) { depth = d; }
+
+ /**
+ * Set the outset distance for the font. Only implemented by
+ * FTOutlineFont, FTPolygonFont and FTExtrudeFont
+ *
+ * @param o The outset distance.
+ */
+ virtual void Outset(float o) { front = back = o; }
+
+ /**
+ * Set the outset distance for the font. Only implemented by
+ * FTExtrudeFont
+ *
+ * @param f The front outset distance.
+ * @param b The back outset distance.
+ */
+ virtual void Outset(float f, float b) { front = f; back = b; }
+
+ private:
+ /**
+ * The extrusion distance for the font.
+ */
+ float depth;
+
+ /**
+ * The outset distance (front and back) for the font.
+ */
+ float front, back;
+};
+
+#endif // __FTExtrudeFontImpl__
+
diff --git a/src/ftgl/FTFont/FTFont.cpp b/src/ftgl/FTFont/FTFont.cpp
new file mode 100644
index 0000000..a7206fb
--- /dev/null
+++ b/src/ftgl/FTFont/FTFont.cpp
@@ -0,0 +1,552 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "config.h"
+
+#include "FTInternals.h"
+#include "FTUnicode.h"
+
+#include "FTFontImpl.h"
+
+#include "FTBitmapFontImpl.h"
+#include "FTExtrudeFontImpl.h"
+#include "FTOutlineFontImpl.h"
+#include "FTPixmapFontImpl.h"
+#include "FTPolygonFontImpl.h"
+#include "FTTextureFontImpl.h"
+
+#include "FTGlyphContainer.h"
+#include "FTFace.h"
+
+
+//
+// FTFont
+//
+
+
+FTFont::FTFont(char const *fontFilePath)
+{
+ impl = new FTFontImpl(this, fontFilePath);
+}
+
+
+FTFont::FTFont(const unsigned char *pBufferBytes, size_t bufferSizeInBytes)
+{
+ impl = new FTFontImpl(this, pBufferBytes, bufferSizeInBytes);
+}
+
+
+FTFont::FTFont(FTFontImpl *pImpl)
+{
+ impl = pImpl;
+}
+
+
+FTFont::~FTFont()
+{
+ delete impl;
+}
+
+
+bool FTFont::Attach(const char* fontFilePath)
+{
+ return impl->Attach(fontFilePath);
+}
+
+
+bool FTFont::Attach(const unsigned char *pBufferBytes, size_t bufferSizeInBytes)
+{
+ return impl->Attach(pBufferBytes, bufferSizeInBytes);
+}
+
+
+bool FTFont::FaceSize(const unsigned int size, const unsigned int res)
+{
+ return impl->FaceSize(size, res);
+}
+
+
+unsigned int FTFont::FaceSize() const
+{
+ return impl->FaceSize();
+}
+
+
+void FTFont::Depth(float depth)
+{
+ return impl->Depth(depth);
+}
+
+
+void FTFont::Outset(float outset)
+{
+ return impl->Outset(outset);
+}
+
+
+void FTFont::Outset(float front, float back)
+{
+ return impl->Outset(front, back);
+}
+
+
+void FTFont::GlyphLoadFlags(FT_Int flags)
+{
+ return impl->GlyphLoadFlags(flags);
+}
+
+
+bool FTFont::CharMap(FT_Encoding encoding)
+{
+ return impl->CharMap(encoding);
+}
+
+
+unsigned int FTFont::CharMapCount() const
+{
+ return impl->CharMapCount();
+}
+
+
+FT_Encoding* FTFont::CharMapList()
+{
+ return impl->CharMapList();
+}
+
+
+void FTFont::UseDisplayList(bool useList)
+{
+ return impl->UseDisplayList(useList);
+}
+
+
+float FTFont::Ascender() const
+{
+ return impl->Ascender();
+}
+
+
+float FTFont::Descender() const
+{
+ return impl->Descender();
+}
+
+
+float FTFont::LineHeight() const
+{
+ return impl->LineHeight();
+}
+
+
+FTPoint FTFont::Render(const char * string, const int len,
+ FTPoint position, FTPoint spacing, int renderMode)
+{
+ return impl->Render(string, len, position, spacing, renderMode);
+}
+
+
+FTPoint FTFont::Render(const wchar_t * string, const int len,
+ FTPoint position, FTPoint spacing, int renderMode)
+{
+ return impl->Render(string, len, position, spacing, renderMode);
+}
+
+
+float FTFont::Advance(const char * string, const int len, FTPoint spacing)
+{
+ return impl->Advance(string, len, spacing);
+}
+
+
+float FTFont::Advance(const wchar_t * string, const int len, FTPoint spacing)
+{
+ return impl->Advance(string, len, spacing);
+}
+
+
+FTBBox FTFont::BBox(const char *string, const int len,
+ FTPoint position, FTPoint spacing)
+{
+ return impl->BBox(string, len, position, spacing);
+}
+
+
+FTBBox FTFont::BBox(const wchar_t *string, const int len,
+ FTPoint position, FTPoint spacing)
+{
+ return impl->BBox(string, len, position, spacing);
+}
+
+
+FT_Error FTFont::Error() const
+{
+ return impl->err;
+}
+
+
+//
+// FTFontImpl
+//
+
+
+FTFontImpl::FTFontImpl(FTFont *ftFont, char const *fontFilePath) :
+ face(fontFilePath),
+ useDisplayLists(true),
+ load_flags(FT_LOAD_DEFAULT),
+ intf(ftFont),
+ glyphList(0)
+{
+ err = face.Error();
+ if(err == 0)
+ {
+ glyphList = new FTGlyphContainer(&face);
+ }
+}
+
+
+FTFontImpl::FTFontImpl(FTFont *ftFont, const unsigned char *pBufferBytes,
+ size_t bufferSizeInBytes) :
+ face(pBufferBytes, bufferSizeInBytes),
+ useDisplayLists(true),
+ load_flags(FT_LOAD_DEFAULT),
+ intf(ftFont),
+ glyphList(0)
+{
+ err = face.Error();
+ if(err == 0)
+ {
+ glyphList = new FTGlyphContainer(&face);
+ }
+}
+
+
+FTFontImpl::~FTFontImpl()
+{
+ if(glyphList)
+ {
+ delete glyphList;
+ }
+}
+
+
+bool FTFontImpl::Attach(const char* fontFilePath)
+{
+ if(!face.Attach(fontFilePath))
+ {
+ err = face.Error();
+ return false;
+ }
+
+ err = 0;
+ return true;
+}
+
+
+bool FTFontImpl::Attach(const unsigned char *pBufferBytes,
+ size_t bufferSizeInBytes)
+{
+ if(!face.Attach(pBufferBytes, bufferSizeInBytes))
+ {
+ err = face.Error();
+ return false;
+ }
+
+ err = 0;
+ return true;
+}
+
+
+bool FTFontImpl::FaceSize(const unsigned int size, const unsigned int res)
+{
+ if(glyphList != NULL)
+ {
+ delete glyphList;
+ glyphList = NULL;
+ }
+
+ charSize = face.Size(size, res);
+ err = face.Error();
+
+ if(err != 0)
+ {
+ return false;
+ }
+
+ glyphList = new FTGlyphContainer(&face);
+ return true;
+}
+
+
+unsigned int FTFontImpl::FaceSize() const
+{
+ return charSize.CharSize();
+}
+
+
+void FTFontImpl::Depth(float depth)
+{
+ ;
+}
+
+
+void FTFontImpl::Outset(float outset)
+{
+ ;
+}
+
+
+void FTFontImpl::Outset(float front, float back)
+{
+ ;
+}
+
+
+void FTFontImpl::GlyphLoadFlags(FT_Int flags)
+{
+ load_flags = flags;
+}
+
+
+bool FTFontImpl::CharMap(FT_Encoding encoding)
+{
+ bool result = glyphList->CharMap(encoding);
+ err = glyphList->Error();
+ return result;
+}
+
+
+unsigned int FTFontImpl::CharMapCount() const
+{
+ return face.CharMapCount();
+}
+
+
+FT_Encoding* FTFontImpl::CharMapList()
+{
+ return face.CharMapList();
+}
+
+
+void FTFontImpl::UseDisplayList(bool useList)
+{
+ useDisplayLists = useList;
+}
+
+
+float FTFontImpl::Ascender() const
+{
+ return charSize.Ascender();
+}
+
+
+float FTFontImpl::Descender() const
+{
+ return charSize.Descender();
+}
+
+
+float FTFontImpl::LineHeight() const
+{
+ return charSize.Height();
+}
+
+
+template <typename T>
+inline FTBBox FTFontImpl::BBoxI(const T* string, const int len,
+ FTPoint position, FTPoint spacing)
+{
+ FTBBox totalBBox;
+
+ /* Only compute the bounds if string is non-empty. */
+ if(string && ('\0' != string[0]))
+ {
+ // for multibyte - we can't rely on sizeof(T) == character
+ FTUnicodeStringItr<T> ustr(string);
+ unsigned int thisChar = *ustr++;
+ unsigned int nextChar = *ustr;
+
+ if(CheckGlyph(thisChar))
+ {
+ totalBBox = glyphList->BBox(thisChar);
+ totalBBox += position;
+
+ position += FTPoint(glyphList->Advance(thisChar, nextChar), 0.0);
+ }
+
+ /* Expand totalBox by each glyph in string */
+ for(int i = 1; (len < 0 && *ustr) || (len >= 0 && i < len); i++)
+ {
+ thisChar = *ustr++;
+ nextChar = *ustr;
+
+ if(CheckGlyph(thisChar))
+ {
+ position += spacing;
+
+ FTBBox tempBBox = glyphList->BBox(thisChar);
+ tempBBox += position;
+ totalBBox |= tempBBox;
+
+ position += FTPoint(glyphList->Advance(thisChar, nextChar),
+ 0.0);
+ }
+ }
+ }
+
+ return totalBBox;
+}
+
+
+FTBBox FTFontImpl::BBox(const char *string, const int len,
+ FTPoint position, FTPoint spacing)
+{
+ /* The chars need to be unsigned because they are cast to int later */
+ return BBoxI((const unsigned char *)string, len, position, spacing);
+}
+
+
+FTBBox FTFontImpl::BBox(const wchar_t *string, const int len,
+ FTPoint position, FTPoint spacing)
+{
+ return BBoxI(string, len, position, spacing);
+}
+
+
+template <typename T>
+inline float FTFontImpl::AdvanceI(const T* string, const int len,
+ FTPoint spacing)
+{
+ float advance = 0.0f;
+ FTUnicodeStringItr<T> ustr(string);
+
+ for(int i = 0; (len < 0 && *ustr) || (len >= 0 && i < len); i++)
+ {
+ unsigned int thisChar = *ustr++;
+ unsigned int nextChar = *ustr;
+
+ if(CheckGlyph(thisChar))
+ {
+ advance += glyphList->Advance(thisChar, nextChar);
+ }
+
+ if(nextChar)
+ {
+ advance += spacing.Xf();
+ }
+ }
+
+ return advance;
+}
+
+
+float FTFontImpl::Advance(const char* string, const int len, FTPoint spacing)
+{
+ /* The chars need to be unsigned because they are cast to int later */
+ return AdvanceI((const unsigned char *)string, len, spacing);
+}
+
+
+float FTFontImpl::Advance(const wchar_t* string, const int len, FTPoint spacing)
+{
+ return AdvanceI(string, len, spacing);
+}
+
+
+template <typename T>
+inline FTPoint FTFontImpl::RenderI(const T* string, const int len,
+ FTPoint position, FTPoint spacing,
+ int renderMode)
+{
+ // for multibyte - we can't rely on sizeof(T) == character
+ FTUnicodeStringItr<T> ustr(string);
+
+ for(int i = 0; (len < 0 && *ustr) || (len >= 0 && i < len); i++)
+ {
+ unsigned int thisChar = *ustr++;
+ unsigned int nextChar = *ustr;
+
+ if(CheckGlyph(thisChar))
+ {
+ position += glyphList->Render(thisChar, nextChar,
+ position, renderMode);
+ }
+
+ if(nextChar)
+ {
+ position += spacing;
+ }
+ }
+
+ return position;
+}
+
+
+FTPoint FTFontImpl::Render(const char * string, const int len,
+ FTPoint position, FTPoint spacing, int renderMode)
+{
+ return RenderI((const unsigned char *)string,
+ len, position, spacing, renderMode);
+}
+
+
+FTPoint FTFontImpl::Render(const wchar_t * string, const int len,
+ FTPoint position, FTPoint spacing, int renderMode)
+{
+ return RenderI(string, len, position, spacing, renderMode);
+}
+
+
+bool FTFontImpl::CheckGlyph(const unsigned int characterCode)
+{
+ if(glyphList->Glyph(characterCode))
+ {
+ return true;
+ }
+
+ unsigned int glyphIndex = glyphList->FontIndex(characterCode);
+ FT_GlyphSlot ftSlot = face.Glyph(glyphIndex, load_flags);
+ if(!ftSlot)
+ {
+ err = face.Error();
+ return false;
+ }
+
+ FTGlyph* tempGlyph = intf->MakeGlyph(ftSlot);
+ if(!tempGlyph)
+ {
+ if(0 == err)
+ {
+ err = 0x13;
+ }
+
+ return false;
+ }
+
+ glyphList->Add(tempGlyph, characterCode);
+
+ return true;
+}
+
diff --git a/src/ftgl/FTFont/FTFontGlue.cpp b/src/ftgl/FTFont/FTFontGlue.cpp
new file mode 100644
index 0000000..b23e787
--- /dev/null
+++ b/src/ftgl/FTFont/FTFontGlue.cpp
@@ -0,0 +1,227 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Éric Beets <ericbeets@free.fr>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "config.h"
+
+#include "FTInternals.h"
+
+static const FTPoint static_ftpoint;
+static const FTBBox static_ftbbox;
+
+FTGL_BEGIN_C_DECLS
+
+#define C_TOR(cname, cargs, cxxname, cxxarg, cxxtype) \
+ FTGLfont* cname cargs \
+ { \
+ cxxname *f = new cxxname cxxarg; \
+ if(f->Error()) \
+ { \
+ delete f; \
+ return NULL; \
+ } \
+ FTGLfont *ftgl = (FTGLfont *)malloc(sizeof(FTGLfont)); \
+ ftgl->ptr = f; \
+ ftgl->type = cxxtype; \
+ return ftgl; \
+ }
+
+// FTBitmapFont::FTBitmapFont();
+C_TOR(ftglCreateBitmapFont, (const char *fontname),
+ FTBitmapFont, (fontname), FONT_BITMAP);
+
+// FTBufferFont::FTBufferFont();
+C_TOR(ftglCreateBufferFont, (const char *fontname),
+ FTBufferFont, (fontname), FONT_BUFFER);
+
+// FTExtrudeFont::FTExtrudeFont();
+C_TOR(ftglCreateExtrudeFont, (const char *fontname),
+ FTExtrudeFont, (fontname), FONT_EXTRUDE);
+
+// FTOutlineFont::FTOutlineFont();
+C_TOR(ftglCreateOutlineFont, (const char *fontname),
+ FTOutlineFont, (fontname), FONT_OUTLINE);
+
+// FTPixmapFont::FTPixmapFont();
+C_TOR(ftglCreatePixmapFont, (const char *fontname),
+ FTPixmapFont, (fontname), FONT_PIXMAP);
+
+// FTPolygonFont::FTPolygonFont();
+C_TOR(ftglCreatePolygonFont, (const char *fontname),
+ FTPolygonFont, (fontname), FONT_POLYGON);
+
+// FTTextureFont::FTTextureFont();
+C_TOR(ftglCreateTextureFont, (const char *fontname),
+ FTTextureFont, (fontname), FONT_TEXTURE);
+
+// FTCustomFont::FTCustomFont();
+class FTCustomFont : public FTFont
+{
+public:
+ FTCustomFont(char const *fontFilePath, void *p,
+ FTGLglyph * (*makeglyph) (FT_GlyphSlot, void *))
+ : FTFont(fontFilePath),
+ data(p),
+ makeglyphCallback(makeglyph)
+ {}
+
+ ~FTCustomFont()
+ {}
+
+ FTGlyph* MakeGlyph(FT_GlyphSlot slot)
+ {
+ FTGLglyph *g = makeglyphCallback(slot, data);
+ FTGlyph *glyph = g->ptr;
+ // XXX: we no longer need g, and no one will free it for us. Not
+ // very elegant, and we need to make sure no one else will try to
+ // use it.
+ free(g);
+ return glyph;
+ }
+
+private:
+ void *data;
+ FTGLglyph *(*makeglyphCallback) (FT_GlyphSlot, void *);
+};
+
+C_TOR(ftglCreateCustomFont, (char const *fontFilePath, void *data,
+ FTGLglyph * (*makeglyphCallback) (FT_GlyphSlot, void *)),
+ FTCustomFont, (fontFilePath, data, makeglyphCallback), FONT_CUSTOM);
+
+#define C_FUN(cret, cname, cargs, cxxerr, cxxname, cxxarg) \
+ cret cname cargs \
+ { \
+ if(!f || !f->ptr) \
+ { \
+ fprintf(stderr, "FTGL warning: NULL pointer in %s\n", #cname); \
+ cxxerr; \
+ } \
+ return f->ptr->cxxname cxxarg; \
+ }
+
+// FTFont::~FTFont();
+void ftglDestroyFont(FTGLfont *f)
+{
+ if(!f || !f->ptr)
+ {
+ fprintf(stderr, "FTGL warning: NULL pointer in %s\n", __FUNCTION__);
+ return;
+ }
+ delete f->ptr;
+ free(f);
+}
+
+// bool FTFont::Attach(const char* fontFilePath);
+C_FUN(int, ftglAttachFile, (FTGLfont *f, const char* path),
+ return 0, Attach, (path));
+
+// bool FTFont::Attach(const unsigned char *pBufferBytes,
+// size_t bufferSizeInBytes);
+C_FUN(int, ftglAttachData, (FTGLfont *f, const unsigned char *p, size_t s),
+ return 0, Attach, (p, s));
+
+// void FTFont::GlyphLoadFlags(FT_Int flags);
+C_FUN(void, ftglSetFontGlyphLoadFlags, (FTGLfont *f, FT_Int flags),
+ return, GlyphLoadFlags, (flags));
+
+// bool FTFont::CharMap(FT_Encoding encoding);
+C_FUN(int, ftglSetFontCharMap, (FTGLfont *f, FT_Encoding enc),
+ return 0, CharMap, (enc));
+
+// unsigned int FTFont::CharMapCount();
+C_FUN(unsigned int, ftglGetFontCharMapCount, (FTGLfont *f),
+ return 0, CharMapCount, ());
+
+// FT_Encoding* FTFont::CharMapList();
+C_FUN(FT_Encoding *, ftglGetFontCharMapList, (FTGLfont* f),
+ return NULL, CharMapList, ());
+
+// virtual bool FTFont::FaceSize(const unsigned int size,
+// const unsigned int res = 72);
+C_FUN(int, ftglSetFontFaceSize, (FTGLfont *f, unsigned int s, unsigned int r),
+ return 0, FaceSize, (s, r > 0 ? r : 72));
+
+// unsigned int FTFont::FaceSize() const;
+// XXX: need to call FaceSize() as FTFont::FaceSize() because of FTGLTexture
+C_FUN(unsigned int, ftglGetFontFaceSize, (FTGLfont *f),
+ return 0, FTFont::FaceSize, ());
+
+// virtual void FTFont::Depth(float depth);
+C_FUN(void, ftglSetFontDepth, (FTGLfont *f, float d), return, Depth, (d));
+
+// virtual void FTFont::Outset(float front, float back);
+C_FUN(void, ftglSetFontOutset, (FTGLfont *f, float front, float back),
+ return, FTFont::Outset, (front, back));
+
+// void FTFont::UseDisplayList(bool useList);
+C_FUN(void, ftglSetFontDisplayList, (FTGLfont *f, int l),
+ return, UseDisplayList, (l != 0));
+
+// float FTFont::Ascender() const;
+C_FUN(float, ftglGetFontAscender, (FTGLfont *f), return 0.f, Ascender, ());
+
+// float FTFont::Descender() const;
+C_FUN(float, ftglGetFontDescender, (FTGLfont *f), return 0.f, Descender, ());
+
+// float FTFont::LineHeight() const;
+C_FUN(float, ftglGetFontLineHeight, (FTGLfont *f), return 0.f, LineHeight, ());
+
+// void FTFont::BBox(const char* string, float& llx, float& lly, float& llz,
+// float& urx, float& ury, float& urz);
+extern "C++" {
+C_FUN(static FTBBox, _ftglGetFontBBox, (FTGLfont *f, char const *s, int len),
+ return static_ftbbox, BBox, (s, len));
+}
+
+void ftglGetFontBBox(FTGLfont *f, const char* s, int len, float c[6])
+{
+ FTBBox ret = _ftglGetFontBBox(f, s, len);
+ FTPoint lower = ret.Lower(), upper = ret.Upper();
+ c[0] = lower.Xf(); c[1] = lower.Yf(); c[2] = lower.Zf();
+ c[3] = upper.Xf(); c[4] = upper.Yf(); c[5] = upper.Zf();
+}
+
+// float FTFont::Advance(const char* string);
+C_FUN(float, ftglGetFontAdvance, (FTGLfont *f, char const *s),
+ return 0.0, Advance, (s));
+
+// virtual void Render(const char* string, int renderMode);
+extern "C++" {
+C_FUN(static FTPoint, _ftglRenderFont, (FTGLfont *f, char const *s, int len,
+ FTPoint pos, FTPoint spacing, int mode),
+ return static_ftpoint, Render, (s, len, pos, spacing, mode));
+}
+
+void ftglRenderFont(FTGLfont *f, const char *s, int mode)
+{
+ _ftglRenderFont(f, s, -1, FTPoint(), FTPoint(), mode);
+}
+
+// FT_Error FTFont::Error() const;
+C_FUN(FT_Error, ftglGetFontError, (FTGLfont *f), return -1, Error, ());
+
+FTGL_END_C_DECLS
+
diff --git a/src/ftgl/FTFont/FTFontImpl.h b/src/ftgl/FTFont/FTFontImpl.h
new file mode 100644
index 0000000..36c3bf8
--- /dev/null
+++ b/src/ftgl/FTFont/FTFontImpl.h
@@ -0,0 +1,162 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __FTFontImpl__
+#define __FTFontImpl__
+
+#include "FTGL/ftgl.h"
+
+#include "FTFace.h"
+
+class FTGlyphContainer;
+class FTGlyph;
+
+class FTFontImpl
+{
+ friend class FTFont;
+
+ protected:
+ FTFontImpl(FTFont *ftFont, char const *fontFilePath);
+
+ FTFontImpl(FTFont *ftFont, const unsigned char *pBufferBytes,
+ size_t bufferSizeInBytes);
+
+ virtual ~FTFontImpl();
+
+ virtual bool Attach(const char* fontFilePath);
+
+ virtual bool Attach(const unsigned char *pBufferBytes,
+ size_t bufferSizeInBytes);
+
+ virtual void GlyphLoadFlags(FT_Int flags);
+
+ virtual bool CharMap(FT_Encoding encoding);
+
+ virtual unsigned int CharMapCount() const;
+
+ virtual FT_Encoding* CharMapList();
+
+ virtual void UseDisplayList(bool useList);
+
+ virtual float Ascender() const;
+
+ virtual float Descender() const;
+
+ virtual float LineHeight() const;
+
+ virtual bool FaceSize(const unsigned int size,
+ const unsigned int res);
+
+ virtual unsigned int FaceSize() const;
+
+ virtual void Depth(float depth);
+
+ virtual void Outset(float outset);
+
+ virtual void Outset(float front, float back);
+
+ virtual FTBBox BBox(const char *s, const int len, FTPoint, FTPoint);
+
+ virtual FTBBox BBox(const wchar_t *s, const int len, FTPoint, FTPoint);
+
+ virtual float Advance(const char *s, const int len, FTPoint);
+
+ virtual float Advance(const wchar_t *s, const int len, FTPoint);
+
+ virtual FTPoint Render(const char *s, const int len,
+ FTPoint, FTPoint, int);
+
+ virtual FTPoint Render(const wchar_t *s, const int len,
+ FTPoint, FTPoint, int);
+
+ /**
+ * Current face object
+ */
+ FTFace face;
+
+ /**
+ * Current size object
+ */
+ FTSize charSize;
+
+ /**
+ * Flag to enable or disable the use of Display Lists inside FTGL
+ * <code>true</code> turns ON display lists.
+ * <code>false</code> turns OFF display lists.
+ */
+ bool useDisplayLists;
+
+ /**
+ * The default glyph loading flags.
+ */
+ FT_Int load_flags;
+
+ /**
+ * Current error code. Zero means no error.
+ */
+ FT_Error err;
+
+ private:
+ /**
+ * A link back to the interface of which we are the implementation.
+ */
+ FTFont *intf;
+
+ /**
+ * Check that the glyph at <code>chr</code> exist. If not load it.
+ *
+ * @param chr character index
+ * @return <code>true</code> if the glyph can be created.
+ */
+ bool CheckGlyph(const unsigned int chr);
+
+ /**
+ * An object that holds a list of glyphs
+ */
+ FTGlyphContainer* glyphList;
+
+ /**
+ * Current pen or cursor position;
+ */
+ FTPoint pen;
+
+ /* Internal generic BBox() implementation */
+ template <typename T>
+ inline FTBBox BBoxI(const T *s, const int len,
+ FTPoint position, FTPoint spacing);
+
+ /* Internal generic Advance() implementation */
+ template <typename T>
+ inline float AdvanceI(const T *s, const int len, FTPoint spacing);
+
+ /* Internal generic Render() implementation */
+ template <typename T>
+ inline FTPoint RenderI(const T *s, const int len,
+ FTPoint position, FTPoint spacing, int mode);
+};
+
+#endif // __FTFontImpl__
+
diff --git a/src/ftgl/FTFont/FTOutlineFont.cpp b/src/ftgl/FTFont/FTOutlineFont.cpp
new file mode 100644
index 0000000..9ebc9a0
--- /dev/null
+++ b/src/ftgl/FTFont/FTOutlineFont.cpp
@@ -0,0 +1,129 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "config.h"
+
+#include "FTGL/ftgl.h"
+
+#include "FTInternals.h"
+#include "FTOutlineFontImpl.h"
+
+
+//
+// FTOutlineFont
+//
+
+
+FTOutlineFont::FTOutlineFont(char const *fontFilePath) :
+ FTFont(new FTOutlineFontImpl(this, fontFilePath))
+{}
+
+
+FTOutlineFont::FTOutlineFont(const unsigned char *pBufferBytes,
+ size_t bufferSizeInBytes) :
+ FTFont(new FTOutlineFontImpl(this, pBufferBytes, bufferSizeInBytes))
+{}
+
+
+FTOutlineFont::~FTOutlineFont()
+{}
+
+
+FTGlyph* FTOutlineFont::MakeGlyph(FT_GlyphSlot ftGlyph)
+{
+ FTOutlineFontImpl *myimpl = dynamic_cast<FTOutlineFontImpl *>(impl);
+ if(!myimpl)
+ {
+ return NULL;
+ }
+
+ return new FTOutlineGlyph(ftGlyph, myimpl->outset,
+ myimpl->useDisplayLists);
+}
+
+
+//
+// FTOutlineFontImpl
+//
+
+
+FTOutlineFontImpl::FTOutlineFontImpl(FTFont *ftFont, const char* fontFilePath)
+: FTFontImpl(ftFont, fontFilePath),
+ outset(0.0f)
+{
+ load_flags = FT_LOAD_NO_HINTING;
+}
+
+
+FTOutlineFontImpl::FTOutlineFontImpl(FTFont *ftFont,
+ const unsigned char *pBufferBytes,
+ size_t bufferSizeInBytes)
+: FTFontImpl(ftFont, pBufferBytes, bufferSizeInBytes),
+ outset(0.0f)
+{
+ load_flags = FT_LOAD_NO_HINTING;
+}
+
+
+template <typename T>
+inline FTPoint FTOutlineFontImpl::RenderI(const T* string, const int len,
+ FTPoint position, FTPoint spacing,
+ int renderMode)
+{
+ // Protect GL_TEXTURE_2D, glHint(), GL_LINE_SMOOTH and blending functions
+ glPushAttrib(GL_ENABLE_BIT | GL_HINT_BIT | GL_LINE_BIT
+ | GL_COLOR_BUFFER_BIT);
+
+ glDisable(GL_TEXTURE_2D);
+ glEnable(GL_LINE_SMOOTH);
+ glHint(GL_LINE_SMOOTH_HINT, GL_DONT_CARE);
+ glEnable(GL_BLEND);
+ glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // GL_ONE
+
+ FTPoint tmp = FTFontImpl::Render(string, len,
+ position, spacing, renderMode);
+
+ glPopAttrib();
+
+ return tmp;
+}
+
+
+FTPoint FTOutlineFontImpl::Render(const char * string, const int len,
+ FTPoint position, FTPoint spacing,
+ int renderMode)
+{
+ return RenderI(string, len, position, spacing, renderMode);
+}
+
+
+FTPoint FTOutlineFontImpl::Render(const wchar_t * string, const int len,
+ FTPoint position, FTPoint spacing,
+ int renderMode)
+{
+ return RenderI(string, len, position, spacing, renderMode);
+}
+
diff --git a/src/ftgl/FTFont/FTOutlineFontImpl.h b/src/ftgl/FTFont/FTOutlineFontImpl.h
new file mode 100644
index 0000000..38b4d26
--- /dev/null
+++ b/src/ftgl/FTFont/FTOutlineFontImpl.h
@@ -0,0 +1,73 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __FTOutlineFontImpl__
+#define __FTOutlineFontImpl__
+
+#include "FTFontImpl.h"
+
+class FTGlyph;
+
+class FTOutlineFontImpl : public FTFontImpl
+{
+ friend class FTOutlineFont;
+
+ protected:
+ FTOutlineFontImpl(FTFont *ftFont, const char* fontFilePath);
+
+ FTOutlineFontImpl(FTFont *ftFont, const unsigned char *pBufferBytes,
+ size_t bufferSizeInBytes);
+
+ /**
+ * Set the outset distance for the font. Only implemented by
+ * FTOutlineFont, FTPolygonFont and FTExtrudeFont
+ *
+ * @param outset The outset distance.
+ */
+ virtual void Outset(float o) { outset = o; }
+
+ virtual FTPoint Render(const char *s, const int len,
+ FTPoint position, FTPoint spacing,
+ int renderMode);
+
+ virtual FTPoint Render(const wchar_t *s, const int len,
+ FTPoint position, FTPoint spacing,
+ int renderMode);
+
+ private:
+ /**
+ * The outset distance for the font.
+ */
+ float outset;
+
+ /* Internal generic Render() implementation */
+ template <typename T>
+ inline FTPoint RenderI(const T *s, const int len,
+ FTPoint position, FTPoint spacing, int mode);
+};
+
+#endif // __FTOutlineFontImpl__
+
diff --git a/src/ftgl/FTFont/FTPixmapFont.cpp b/src/ftgl/FTFont/FTPixmapFont.cpp
new file mode 100644
index 0000000..5638ac8
--- /dev/null
+++ b/src/ftgl/FTFont/FTPixmapFont.cpp
@@ -0,0 +1,131 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "config.h"
+
+#include "FTGL/ftgl.h"
+
+#include "FTInternals.h"
+#include "FTPixmapFontImpl.h"
+
+
+//
+// FTPixmapFont
+//
+
+
+FTPixmapFont::FTPixmapFont(char const *fontFilePath) :
+ FTFont(new FTPixmapFontImpl(this, fontFilePath))
+{}
+
+
+FTPixmapFont::FTPixmapFont(const unsigned char *pBufferBytes,
+ size_t bufferSizeInBytes) :
+ FTFont(new FTPixmapFontImpl(this, pBufferBytes, bufferSizeInBytes))
+{}
+
+
+FTPixmapFont::~FTPixmapFont()
+{}
+
+
+FTGlyph* FTPixmapFont::MakeGlyph(FT_GlyphSlot ftGlyph)
+{
+ return new FTPixmapGlyph(ftGlyph);
+}
+
+
+//
+// FTPixmapFontImpl
+//
+
+
+FTPixmapFontImpl::FTPixmapFontImpl(FTFont *ftFont, const char* fontFilePath)
+: FTFontImpl(ftFont, fontFilePath)
+{
+ load_flags = FT_LOAD_NO_HINTING | FT_LOAD_NO_BITMAP;
+}
+
+
+FTPixmapFontImpl::FTPixmapFontImpl(FTFont *ftFont,
+ const unsigned char *pBufferBytes,
+ size_t bufferSizeInBytes)
+: FTFontImpl(ftFont, pBufferBytes, bufferSizeInBytes)
+{
+ load_flags = FT_LOAD_NO_HINTING | FT_LOAD_NO_BITMAP;
+}
+
+
+template <typename T>
+inline FTPoint FTPixmapFontImpl::RenderI(const T* string, const int len,
+ FTPoint position, FTPoint spacing,
+ int renderMode)
+{
+ // Protect GL_TEXTURE_2D and GL_BLEND, glPixelTransferf(), and blending
+ // functions.
+ glPushAttrib(GL_ENABLE_BIT | GL_PIXEL_MODE_BIT | GL_COLOR_BUFFER_BIT);
+
+ // Protect glPixelStorei() calls (made by FTPixmapGlyphImpl::RenderImpl).
+ glPushClientAttrib(GL_CLIENT_PIXEL_STORE_BIT);
+
+ glEnable(GL_BLEND);
+ glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+ glDisable(GL_TEXTURE_2D);
+
+ GLfloat ftglColour[4];
+ glGetFloatv(GL_CURRENT_RASTER_COLOR, ftglColour);
+
+ glPixelTransferf(GL_RED_SCALE, ftglColour[0]);
+ glPixelTransferf(GL_GREEN_SCALE, ftglColour[1]);
+ glPixelTransferf(GL_BLUE_SCALE, ftglColour[2]);
+ glPixelTransferf(GL_ALPHA_SCALE, ftglColour[3]);
+
+ FTPoint tmp = FTFontImpl::Render(string, len,
+ position, spacing, renderMode);
+
+ glPopClientAttrib();
+ glPopAttrib();
+
+ return tmp;
+}
+
+
+FTPoint FTPixmapFontImpl::Render(const char * string, const int len,
+ FTPoint position, FTPoint spacing,
+ int renderMode)
+{
+ return RenderI(string, len, position, spacing, renderMode);
+}
+
+
+FTPoint FTPixmapFontImpl::Render(const wchar_t * string, const int len,
+ FTPoint position, FTPoint spacing,
+ int renderMode)
+{
+ return RenderI(string, len, position, spacing, renderMode);
+}
+
diff --git a/src/ftgl/FTFont/FTPixmapFontImpl.h b/src/ftgl/FTFont/FTPixmapFontImpl.h
new file mode 100644
index 0000000..321f4a6
--- /dev/null
+++ b/src/ftgl/FTFont/FTPixmapFontImpl.h
@@ -0,0 +1,60 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __FTPixmapFontImpl__
+#define __FTPixmapFontImpl__
+
+#include "FTFontImpl.h"
+
+class FTGlyph;
+
+class FTPixmapFontImpl : public FTFontImpl
+{
+ friend class FTPixmapFont;
+
+ protected:
+ FTPixmapFontImpl(FTFont *ftFont, const char* fontFilePath);
+
+ FTPixmapFontImpl(FTFont *ftFont, const unsigned char *pBufferBytes,
+ size_t bufferSizeInBytes);
+
+ virtual FTPoint Render(const char *s, const int len,
+ FTPoint position, FTPoint spacing,
+ int renderMode);
+
+ virtual FTPoint Render(const wchar_t *s, const int len,
+ FTPoint position, FTPoint spacing,
+ int renderMode);
+
+ private:
+ /* Internal generic Render() implementation */
+ template <typename T>
+ inline FTPoint RenderI(const T *s, const int len,
+ FTPoint position, FTPoint spacing, int mode);
+};
+
+#endif // __FTPixmapFontImpl__
+
diff --git a/src/ftgl/FTFont/FTPolygonFont.cpp b/src/ftgl/FTFont/FTPolygonFont.cpp
new file mode 100644
index 0000000..83c3ad1
--- /dev/null
+++ b/src/ftgl/FTFont/FTPolygonFont.cpp
@@ -0,0 +1,89 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "config.h"
+
+#include "FTGL/ftgl.h"
+
+#include "FTInternals.h"
+#include "FTPolygonFontImpl.h"
+
+
+//
+// FTPolygonFont
+//
+
+
+FTPolygonFont::FTPolygonFont(char const *fontFilePath) :
+ FTFont(new FTPolygonFontImpl(this, fontFilePath))
+{}
+
+
+FTPolygonFont::FTPolygonFont(const unsigned char *pBufferBytes,
+ size_t bufferSizeInBytes) :
+ FTFont(new FTPolygonFontImpl(this, pBufferBytes, bufferSizeInBytes))
+{}
+
+
+FTPolygonFont::~FTPolygonFont()
+{}
+
+
+FTGlyph* FTPolygonFont::MakeGlyph(FT_GlyphSlot ftGlyph)
+{
+ FTPolygonFontImpl *myimpl = dynamic_cast<FTPolygonFontImpl *>(impl);
+ if(!myimpl)
+ {
+ return NULL;
+ }
+
+ return new FTPolygonGlyph(ftGlyph, myimpl->outset,
+ myimpl->useDisplayLists);
+}
+
+
+//
+// FTPolygonFontImpl
+//
+
+
+FTPolygonFontImpl::FTPolygonFontImpl(FTFont *ftFont, const char* fontFilePath)
+: FTFontImpl(ftFont, fontFilePath),
+ outset(0.0f)
+{
+ load_flags = FT_LOAD_NO_HINTING;
+}
+
+
+FTPolygonFontImpl::FTPolygonFontImpl(FTFont *ftFont,
+ const unsigned char *pBufferBytes,
+ size_t bufferSizeInBytes)
+: FTFontImpl(ftFont, pBufferBytes, bufferSizeInBytes),
+ outset(0.0f)
+{
+ load_flags = FT_LOAD_NO_HINTING;
+}
+
diff --git a/src/ftgl/FTFont/FTPolygonFontImpl.h b/src/ftgl/FTFont/FTPolygonFontImpl.h
new file mode 100644
index 0000000..47b35a6
--- /dev/null
+++ b/src/ftgl/FTFont/FTPolygonFontImpl.h
@@ -0,0 +1,60 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __FTPolygonFontImpl__
+#define __FTPolygonFontImpl__
+
+#include "FTFontImpl.h"
+
+class FTGlyph;
+
+class FTPolygonFontImpl : public FTFontImpl
+{
+ friend class FTPolygonFont;
+
+ protected:
+ FTPolygonFontImpl(FTFont *ftFont, const char* fontFilePath);
+
+ FTPolygonFontImpl(FTFont *ftFont, const unsigned char *pBufferBytes,
+ size_t bufferSizeInBytes);
+
+ /**
+ * Set the outset distance for the font. Only implemented by
+ * FTOutlineFont, FTPolygonFont and FTExtrudeFont
+ *
+ * @param depth The outset distance.
+ */
+ virtual void Outset(float o) { outset = o; }
+
+ private:
+ /**
+ * The outset distance (front and back) for the font.
+ */
+ float outset;
+};
+
+#endif // __FTPolygonFontImpl__
+
diff --git a/src/ftgl/FTFont/FTTextureFont.cpp b/src/ftgl/FTFont/FTTextureFont.cpp
new file mode 100644
index 0000000..4e385ea
--- /dev/null
+++ b/src/ftgl/FTFont/FTTextureFont.cpp
@@ -0,0 +1,267 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "config.h"
+
+#include <cassert>
+#include <string> // For memset
+
+#include "FTGL/ftgl.h"
+
+#include "FTInternals.h"
+
+#include "../FTGlyph/FTTextureGlyphImpl.h"
+#include "./FTTextureFontImpl.h"
+
+
+//
+// FTTextureFont
+//
+
+
+FTTextureFont::FTTextureFont(char const *fontFilePath) :
+ FTFont(new FTTextureFontImpl(this, fontFilePath))
+{}
+
+
+FTTextureFont::FTTextureFont(const unsigned char *pBufferBytes,
+ size_t bufferSizeInBytes) :
+ FTFont(new FTTextureFontImpl(this, pBufferBytes, bufferSizeInBytes))
+{}
+
+
+FTTextureFont::~FTTextureFont()
+{}
+
+
+FTGlyph* FTTextureFont::MakeGlyph(FT_GlyphSlot ftGlyph)
+{
+ FTTextureFontImpl *myimpl = dynamic_cast<FTTextureFontImpl *>(impl);
+ if(!myimpl)
+ {
+ return NULL;
+ }
+
+ return myimpl->MakeGlyphImpl(ftGlyph);
+}
+
+
+//
+// FTTextureFontImpl
+//
+
+
+static inline GLuint NextPowerOf2(GLuint in)
+{
+ in -= 1;
+
+ in |= in >> 16;
+ in |= in >> 8;
+ in |= in >> 4;
+ in |= in >> 2;
+ in |= in >> 1;
+
+ return in + 1;
+}
+
+
+FTTextureFontImpl::FTTextureFontImpl(FTFont *ftFont, const char* fontFilePath)
+: FTFontImpl(ftFont, fontFilePath),
+ maximumGLTextureSize(0),
+ textureWidth(0),
+ textureHeight(0),
+ glyphHeight(0),
+ glyphWidth(0),
+ padding(3),
+ xOffset(0),
+ yOffset(0)
+{
+ load_flags = FT_LOAD_NO_HINTING | FT_LOAD_NO_BITMAP;
+ remGlyphs = numGlyphs = face.GlyphCount();
+}
+
+
+FTTextureFontImpl::FTTextureFontImpl(FTFont *ftFont,
+ const unsigned char *pBufferBytes,
+ size_t bufferSizeInBytes)
+: FTFontImpl(ftFont, pBufferBytes, bufferSizeInBytes),
+ maximumGLTextureSize(0),
+ textureWidth(0),
+ textureHeight(0),
+ glyphHeight(0),
+ glyphWidth(0),
+ padding(3),
+ xOffset(0),
+ yOffset(0)
+{
+ load_flags = FT_LOAD_NO_HINTING | FT_LOAD_NO_BITMAP;
+ remGlyphs = numGlyphs = face.GlyphCount();
+}
+
+
+FTTextureFontImpl::~FTTextureFontImpl()
+{
+ if(textureIDList.size())
+ {
+ glDeleteTextures((GLsizei)textureIDList.size(),
+ (const GLuint*)&textureIDList[0]);
+ }
+}
+
+
+FTGlyph* FTTextureFontImpl::MakeGlyphImpl(FT_GlyphSlot ftGlyph)
+{
+ glyphHeight = static_cast<int>(charSize.Height() + 0.5);
+ glyphWidth = static_cast<int>(charSize.Width() + 0.5);
+
+ if(glyphHeight < 1) glyphHeight = 1;
+ if(glyphWidth < 1) glyphWidth = 1;
+
+ if(textureIDList.empty())
+ {
+ textureIDList.push_back(CreateTexture());
+ xOffset = yOffset = padding;
+ }
+
+ if(xOffset > (textureWidth - glyphWidth))
+ {
+ xOffset = padding;
+ yOffset += glyphHeight;
+
+ if(yOffset > (textureHeight - glyphHeight))
+ {
+ textureIDList.push_back(CreateTexture());
+ yOffset = padding;
+ }
+ }
+
+ FTTextureGlyph* tempGlyph = new FTTextureGlyph(ftGlyph, textureIDList[textureIDList.size() - 1],
+ xOffset, yOffset, textureWidth, textureHeight);
+ xOffset += static_cast<int>(tempGlyph->BBox().Upper().X() - tempGlyph->BBox().Lower().X() + padding + 0.5);
+
+ --remGlyphs;
+
+ return tempGlyph;
+}
+
+
+void FTTextureFontImpl::CalculateTextureSize()
+{
+ if(!maximumGLTextureSize)
+ {
+ maximumGLTextureSize = 1024;
+ glGetIntegerv(GL_MAX_TEXTURE_SIZE, (GLint*)&maximumGLTextureSize);
+ assert(maximumGLTextureSize); // If you hit this then you have an invalid OpenGL context.
+ }
+
+ textureWidth = NextPowerOf2((remGlyphs * glyphWidth) + (padding * 2));
+ textureWidth = textureWidth > maximumGLTextureSize ? maximumGLTextureSize : textureWidth;
+
+ int h = static_cast<int>((textureWidth - (padding * 2)) / glyphWidth + 0.5);
+
+ textureHeight = NextPowerOf2(((numGlyphs / h) + 1) * glyphHeight);
+ textureHeight = textureHeight > maximumGLTextureSize ? maximumGLTextureSize : textureHeight;
+}
+
+
+GLuint FTTextureFontImpl::CreateTexture()
+{
+ CalculateTextureSize();
+
+ int totalMemory = textureWidth * textureHeight;
+ unsigned char* textureMemory = new unsigned char[totalMemory];
+ memset(textureMemory, 0, totalMemory);
+
+ GLuint textID;
+ glGenTextures(1, (GLuint*)&textID);
+
+ glBindTexture(GL_TEXTURE_2D, textID);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+
+ glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, textureWidth, textureHeight,
+ 0, GL_ALPHA, GL_UNSIGNED_BYTE, textureMemory);
+
+ delete [] textureMemory;
+
+ return textID;
+}
+
+
+bool FTTextureFontImpl::FaceSize(const unsigned int size, const unsigned int res)
+{
+ if(!textureIDList.empty())
+ {
+ glDeleteTextures((GLsizei)textureIDList.size(), (const GLuint*)&textureIDList[0]);
+ textureIDList.clear();
+ remGlyphs = numGlyphs = face.GlyphCount();
+ }
+
+ return FTFontImpl::FaceSize(size, res);
+}
+
+
+template <typename T>
+inline FTPoint FTTextureFontImpl::RenderI(const T* string, const int len,
+ FTPoint position, FTPoint spacing,
+ int renderMode)
+{
+ // Protect GL_TEXTURE_2D, GL_BLEND and blending functions
+ glPushAttrib(GL_ENABLE_BIT | GL_COLOR_BUFFER_BIT);
+
+ glEnable(GL_BLEND);
+ glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // GL_ONE
+
+ glEnable(GL_TEXTURE_2D);
+
+ FTTextureGlyphImpl::ResetActiveTexture();
+
+ FTPoint tmp = FTFontImpl::Render(string, len,
+ position, spacing, renderMode);
+
+ glPopAttrib();
+
+ return tmp;
+}
+
+
+FTPoint FTTextureFontImpl::Render(const char * string, const int len,
+ FTPoint position, FTPoint spacing,
+ int renderMode)
+{
+ return RenderI(string, len, position, spacing, renderMode);
+}
+
+
+FTPoint FTTextureFontImpl::Render(const wchar_t * string, const int len,
+ FTPoint position, FTPoint spacing,
+ int renderMode)
+{
+ return RenderI(string, len, position, spacing, renderMode);
+}
+
diff --git a/src/ftgl/FTFont/FTTextureFontImpl.h b/src/ftgl/FTFont/FTTextureFontImpl.h
new file mode 100644
index 0000000..c9cf22b
--- /dev/null
+++ b/src/ftgl/FTFont/FTTextureFontImpl.h
@@ -0,0 +1,152 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __FTTextureFontImpl__
+#define __FTTextureFontImpl__
+
+#include "FTFontImpl.h"
+
+#include "FTVector.h"
+
+class FTTextureGlyph;
+
+class FTTextureFontImpl : public FTFontImpl
+{
+ friend class FTTextureFont;
+
+ protected:
+ FTTextureFontImpl(FTFont *ftFont, const char* fontFilePath);
+
+ FTTextureFontImpl(FTFont *ftFont, const unsigned char *pBufferBytes,
+ size_t bufferSizeInBytes);
+
+ virtual ~FTTextureFontImpl();
+
+ /**
+ * Set the char size for the current face.
+ *
+ * @param size the face size in points (1/72 inch)
+ * @param res the resolution of the target device.
+ * @return <code>true</code> if size was set correctly
+ */
+ virtual bool FaceSize(const unsigned int size,
+ const unsigned int res = 72);
+
+ virtual FTPoint Render(const char *s, const int len,
+ FTPoint position, FTPoint spacing,
+ int renderMode);
+
+ virtual FTPoint Render(const wchar_t *s, const int len,
+ FTPoint position, FTPoint spacing,
+ int renderMode);
+
+ private:
+ /**
+ * Create an FTTextureGlyph object for the base class.
+ */
+ FTGlyph* MakeGlyphImpl(FT_GlyphSlot ftGlyph);
+
+ /**
+ * Get the size of a block of memory required to layout the glyphs
+ *
+ * Calculates a width and height based on the glyph sizes and the
+ * number of glyphs. It over estimates.
+ */
+ inline void CalculateTextureSize();
+
+ /**
+ * Creates a 'blank' OpenGL texture object.
+ *
+ * The format is GL_ALPHA and the params are
+ * GL_TEXTURE_WRAP_S = GL_CLAMP
+ * GL_TEXTURE_WRAP_T = GL_CLAMP
+ * GL_TEXTURE_MAG_FILTER = GL_LINEAR
+ * GL_TEXTURE_MIN_FILTER = GL_LINEAR
+ * Note that mipmapping is NOT used
+ */
+ inline GLuint CreateTexture();
+
+ /**
+ * The maximum texture dimension on this OpenGL implemetation
+ */
+ GLsizei maximumGLTextureSize;
+
+ /**
+ * The minimum texture width required to hold the glyphs
+ */
+ GLsizei textureWidth;
+
+ /**
+ * The minimum texture height required to hold the glyphs
+ */
+ GLsizei textureHeight;
+
+ /**
+ *An array of texture ids
+ */
+ FTVector<GLuint> textureIDList;
+
+ /**
+ * The max height for glyphs in the current font
+ */
+ int glyphHeight;
+
+ /**
+ * The max width for glyphs in the current font
+ */
+ int glyphWidth;
+
+ /**
+ * A value to be added to the height and width to ensure that
+ * glyphs don't overlap in the texture
+ */
+ unsigned int padding;
+
+ /**
+ *
+ */
+ unsigned int numGlyphs;
+
+ /**
+ */
+ unsigned int remGlyphs;
+
+ /**
+ */
+ int xOffset;
+
+ /**
+ */
+ int yOffset;
+
+ /* Internal generic Render() implementation */
+ template <typename T>
+ inline FTPoint RenderI(const T *s, const int len,
+ FTPoint position, FTPoint spacing, int mode);
+};
+
+#endif // __FTTextureFontImpl__
+
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-08 00:33:18 +0000