Added bFTGL to extern and updated the Makefiles. I'm guessing there will

need to be tweaks but it seems to work on my linux box.  I haven't
touched any of the other build systems so those will need to be done.

We probably don't need all of this stuff but I figured better to add a little
too much then to little.

Kent

64 files changed, 7127 insertions, 5 deletions

diff --git a/extern/Makefile b/extern/Makefile
index 4bd348c6735..458d19f357b 100644
--- a/extern/Makefile
+++ b/extern/Makefile
@@ -34,17 +34,13 @@ include nan_definitions.mk
 
 SOURCEDIR = extern
 DIR = $(OCGDIR)/extern
-DIRS = qhull/src solid
+DIRS = qhull/src solid bFTGL/src
 
 TARGET =
 ifneq ($(OS),irix)
   TARGET=solid
 endif
 
-# include nan_subdirs.mk
-
-# .PHONY: qhull solid solid_with_qhull
-
 all::
 	@[ -d $(OCGDIR)/extern ] || mkdir -p $(OCGDIR)/extern
 	@for i in $(DIRS); do \
diff --git a/extern/bFTGL/COPYING.txt b/extern/bFTGL/COPYING.txt
new file mode 100644
index 00000000000..92b8903ff3f
--- /dev/null
+++ b/extern/bFTGL/COPYING.txt
@@ -0,0 +1,481 @@
+		  GNU LIBRARY GENERAL PUBLIC LICENSE
+		       Version 2, June 1991
+
+ Copyright (C) 1991 Free Software Foundation, Inc.
+    		    59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the library GPL.  It is
+ numbered 2 because it goes with version 2 of the ordinary GPL.]
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+  This license, the Library General Public License, applies to some
+specially designated Free Software Foundation software, and to any
+other libraries whose authors decide to use it.  You can use it for
+your libraries, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if
+you distribute copies of the library, or if you modify it.
+
+  For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you.  You must make sure that they, too, receive or can get the source
+code.  If you link a program with the library, you must provide
+complete object files to the recipients so that they can relink them
+with the library, after making changes to the library and recompiling
+it.  And you must show them these terms so they know their rights.
+
+  Our method of protecting your rights has two steps: (1) copyright
+the library, and (2) offer you this license which gives you legal
+permission to copy, distribute and/or modify the library.
+
+  Also, for each distributor's protection, we want to make certain
+that everyone understands that there is no warranty for this free
+library.  If the library is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original
+version, so that any problems introduced by others will not reflect on
+the original authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that companies distributing free
+software will individually obtain patent licenses, thus in effect
+transforming the program into proprietary software.  To prevent this,
+we have made it clear that any patent must be licensed for everyone's
+free use or not licensed at all.
+
+  Most GNU software, including some libraries, is covered by the ordinary
+GNU General Public License, which was designed for utility programs.  This
+license, the GNU Library General Public License, applies to certain
+designated libraries.  This license is quite different from the ordinary
+one; be sure to read it in full, and don't assume that anything in it is
+the same as in the ordinary license.
+
+  The reason we have a separate public license for some libraries is that
+they blur the distinction we usually make between modifying or adding to a
+program and simply using it.  Linking a program with a library, without
+changing the library, is in some sense simply using the library, and is
+analogous to running a utility program or application program.  However, in
+a textual and legal sense, the linked executable is a combined work, a
+derivative of the original library, and the ordinary General Public License
+treats it as such.
+
+  Because of this blurred distinction, using the ordinary General
+Public License for libraries did not effectively promote software
+sharing, because most developers did not use the libraries.  We
+concluded that weaker conditions might promote sharing better.
+
+  However, unrestricted linking of non-free programs would deprive the
+users of those programs of all benefit from the free status of the
+libraries themselves.  This Library General Public License is intended to
+permit developers of non-free programs to use free libraries, while
+preserving your freedom as a user of such programs to change the free
+libraries that are incorporated in them.  (We have not seen how to achieve
+this as regards changes in header files, but we have achieved it as regards
+changes in the actual functions of the Library.)  The hope is that this
+will lead to faster development of free libraries.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.  Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library".  The
+former contains code derived from the library, while the latter only
+works together with the library.
+
+  Note that it is possible for a library to be covered by the ordinary
+General Public License rather than by this special one.
+
+		  GNU LIBRARY GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License Agreement applies to any software library which
+contains a notice placed by the copyright holder or other authorized
+party saying it may be distributed under the terms of this Library
+General Public License (also called "this License").  Each licensee is
+addressed as "you".
+
+  A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+  The "Library", below, refers to any such software library or work
+which has been distributed under these terms.  A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language.  (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+  "Source code" for a work means the preferred form of the work for
+making modifications to it.  For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+  Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it).  Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+  
+  1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+  You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+
+  2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) The modified work must itself be a software library.
+
+    b) You must cause the files modified to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    c) You must cause the whole of the work to be licensed at no
+    charge to all third parties under the terms of this License.
+
+    d) If a facility in the modified Library refers to a function or a
+    table of data to be supplied by an application program that uses
+    the facility, other than as an argument passed when the facility
+    is invoked, then you must make a good faith effort to ensure that,
+    in the event an application does not supply such function or
+    table, the facility still operates, and performs whatever part of
+    its purpose remains meaningful.
+
+    (For example, a function in a library to compute square roots has
+    a purpose that is entirely well-defined independent of the
+    application.  Therefore, Subsection 2d requires that any
+    application-supplied function or table used by this function must
+    be optional: if the application does not supply it, the square
+    root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library.  To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License.  (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.)  Do not make any other change in
+these notices.
+
+  Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+  This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+  4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+  If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library".  Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+  However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library".  The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+  When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library.  The
+threshold for this to be true is not precisely defined by law.
+
+  If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work.  (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+  Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+  6. As an exception to the Sections above, you may also compile or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+  You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License.  You must supply a copy of this License.  If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License.  Also, you must do one
+of these things:
+
+    a) Accompany the work with the complete corresponding
+    machine-readable source code for the Library including whatever
+    changes were used in the work (which must be distributed under
+    Sections 1 and 2 above); and, if the work is an executable linked
+    with the Library, with the complete machine-readable "work that
+    uses the Library", as object code and/or source code, so that the
+    user can modify the Library and then relink to produce a modified
+    executable containing the modified Library.  (It is understood
+    that the user who changes the contents of definitions files in the
+    Library will not necessarily be able to recompile the application
+    to use the modified definitions.)
+
+    b) Accompany the work with a written offer, valid for at
+    least three years, to give the same user the materials
+    specified in Subsection 6a, above, for a charge no more
+    than the cost of performing this distribution.
+
+    c) If distribution of the work is made by offering access to copy
+    from a designated place, offer equivalent access to copy the above
+    specified materials from the same place.
+
+    d) Verify that the user has already received a copy of these
+    materials or that you have already sent this user a copy.
+
+  For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it.  However, as a special exception,
+the source code distributed need not include anything that is normally
+distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+  It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system.  Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+  7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+    a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities.  This must be distributed under the terms of the
+    Sections above.
+
+    b) Give prominent notice with the combined library of the fact
+    that part of it is a work based on the Library, and explaining
+    where to find the accompanying uncombined form of the same work.
+
+  8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License.  Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License.  However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+  9. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Library or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+  10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded.  In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+  13. The Free Software Foundation may publish revised and/or new
+versions of the Library General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation.  If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+  14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission.  For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this.  Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+			    NO WARRANTY
+
+  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+
+           How to Apply These Terms to Your New Libraries
+
+  If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change.  You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms of the
+ordinary General Public License).
+
+  To apply these terms, attach the following notices to the library.  It is
+safest to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the library's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library 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
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the library, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the
+  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
+
+  <signature of Ty Coon>, 1 April 1990
+  Ty Coon, President of Vice
+
+That's all there is to it!
diff --git a/extern/bFTGL/README.txt b/extern/bFTGL/README.txt
new file mode 100755
index 00000000000..a679d86c22e
--- /dev/null
+++ b/extern/bFTGL/README.txt
@@ -0,0 +1,51 @@
+FTGL 2.0.11
+16 August 2004
+
+DESCRIPTION:
+
+FTGL is a free open source library to enable developers to use arbitrary
+fonts in their OpenGL (www.opengl.org)  applications.
+Unlike other OpenGL font libraries FTGL uses standard font file formats
+so doesn't need a preprocessing step to convert the high quality font data
+into a lesser quality, proprietary format.
+FTGL uses the Freetype (www.freetype.org) font library to open and 'decode'
+the fonts. It then takes that output and stores it in a format most efficient
+for OpenGL rendering.
+
+Rendering modes supported are
+- Bit maps
+- Antialiased Pix maps
+- Texture maps
+- Outlines
+- Polygon meshes
+- Extruded polygon meshes
+
+FTGL is designed to be used in commercial quality software. It has been
+written with performance, robustness and simplicity in mind.
+
+USAGE:
+
+	FTGLPixmapFont font( "Fonts:Arial");
+
+	font.FaceSize( 72);
+	
+	font.render( "Hello World!");
+
+This library was inspired by gltt, Copyright (C) 1998-1999 Stephane Rehel
+(http://gltt.sourceforge.net)
+Bezier curve code contributed by Jed Soane.
+Demo, Linux port, extrusion code and gltt maintainance by Gerard Lanois
+Linux port by Matthias Kretz
+Windows port by Andrew Ellerton & Max Rheiner
+Bug fixes by Robert Osfield, Marcelo E. Magallon, Markku Rontu, Mark A. Fox,
+Patrick Rogers
+Containers and optimisations by Sebastien Barre
+Autoconf Marcelo E. Magallon.
+
+
+Please contact me if you have any suggestions, feature requests, or problems.
+
+Henry Maddocks
+ftgl@opengl.geek.nz
+http://homepages.paradise.net.nz/henryj/
+
diff --git a/extern/bFTGL/cleanup b/extern/bFTGL/cleanup
new file mode 100755
index 00000000000..c6d24edb287
--- /dev/null
+++ b/extern/bFTGL/cleanup
@@ -0,0 +1,4 @@
+#!/bin/sh -fx
+# script to get rid of the grabage that MAC OSX drops in all the directories
+
+find . -name .DS_Store -print -exec rm {} \;
diff --git a/extern/bFTGL/include/FTBBox.h b/extern/bFTGL/include/FTBBox.h
new file mode 100755
index 00000000000..7ff530166ca
--- /dev/null
+++ b/extern/bFTGL/include/FTBBox.h
@@ -0,0 +1,124 @@
+#ifndef     __FTBBox__
+#define     __FTBBox__
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+//#include FT_GLYPH_H
+#include FT_OUTLINE_H
+
+#include "FTGL.h"
+#include "FTPoint.h"
+
+
+/**
+ * FTBBox is a convenience class for handling bounding boxes.
+ */
+class FTGL_EXPORT FTBBox
+{
+    public:
+        /**
+         * Default constructor. Bounding box is set to zero.
+         */
+        FTBBox()
+        :   lowerX(0.0f),
+            lowerY(0.0f),
+            lowerZ(0.0f),
+            upperX(0.0f),
+            upperY(0.0f),
+            upperZ(0.0f)
+        {}
+        
+        /**
+         * Constructor.
+         */
+        FTBBox( float lx, float ly, float lz, float ux, float uy, float uz)
+        :   lowerX(lx),
+            lowerY(ly),
+            lowerZ(lz),
+            upperX(ux),
+            upperY(uy),
+            upperZ(uz)
+        {}
+        
+        /**
+         * Constructor. Extracts a bounding box from a freetype glyph. Uses
+         * the control box for the glyph. <code>FT_Glyph_Get_CBox()</code>
+         *
+         * @param glyph A freetype glyph
+         */
+        FTBBox( FT_GlyphSlot glyph)
+        :   lowerX(0.0f),
+            lowerY(0.0f),
+            lowerZ(0.0f),
+            upperX(0.0f),
+            upperY(0.0f),
+            upperZ(0.0f)
+        {
+            FT_BBox bbox;
+            FT_Outline_Get_CBox( &(glyph->outline), &bbox);
+
+            lowerX = static_cast<float>( bbox.xMin) / 64.0f;
+            lowerY = static_cast<float>( bbox.yMin) / 64.0f;
+            lowerZ = 0.0f;
+            upperX = static_cast<float>( bbox.xMax) / 64.0f;
+            upperY = static_cast<float>( bbox.yMax) / 64.0f;
+            upperZ = 0.0f;
+            
+        }       
+
+        /**
+         * Destructor
+         */
+        ~FTBBox()
+        {}
+        
+
+        /**
+         * Move the Bounding Box by a vector.
+         *
+         * @param distance The distance to move the bbox in 3D space.
+         */
+        FTBBox& Move( FTPoint distance)
+        {
+            lowerX += distance.x;
+            lowerY += distance.y;
+            lowerZ += distance.z;
+            upperX += distance.x;
+            upperY += distance.y;
+            upperZ += distance.z;
+            return *this;
+        }
+
+        FTBBox& operator += ( const FTBBox& bbox) 
+        {
+            lowerX = bbox.lowerX < lowerX? bbox.lowerX: lowerX; 
+            lowerY = bbox.lowerY < lowerY? bbox.lowerY: lowerY;
+            lowerZ = bbox.lowerZ < lowerZ? bbox.lowerZ: lowerZ; 
+            upperX = bbox.upperX > upperX? bbox.upperX: upperX; 
+            upperY = bbox.upperY > upperY? bbox.upperY: upperY; 
+            upperZ = bbox.upperZ > upperZ? bbox.upperZ: upperZ; 
+            
+            return *this;
+        }
+        
+        void SetDepth( float depth)
+        {
+            upperZ = lowerZ + depth;
+        }
+        
+        
+        /**
+         * The bounds of the box
+         */
+        // Make these ftPoints & private
+        float lowerX, lowerY, lowerZ, upperX, upperY, upperZ;
+    protected:
+    
+    
+    private:
+
+};
+
+
+#endif  //  __FTBBox__
+
diff --git a/extern/bFTGL/include/FTBitmapGlyph.h b/extern/bFTGL/include/FTBitmapGlyph.h
new file mode 100755
index 00000000000..89154a97fac
--- /dev/null
+++ b/extern/bFTGL/include/FTBitmapGlyph.h
@@ -0,0 +1,76 @@
+#ifndef     __FTBitmapGlyph__
+#define     __FTBitmapGlyph__
+
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#include FT_GLYPH_H
+
+#include "FTGL.h"
+#include "FTGlyph.h"
+
+
+/**
+ * FTBitmapGlyph is a specialisation of FTGlyph for creating bitmaps.
+ *
+ * It provides the interface between Freetype glyphs and their openGL
+ * Renderable counterparts. This is an abstract class and derived classes
+ * must implement the <code>Render</code> function. 
+ * 
+ * @see FTGlyphContainer
+ *
+ */
+class FTGL_EXPORT FTBitmapGlyph : public FTGlyph
+{
+    public:
+        /**
+         * Constructor
+         *
+         * @param glyph The Freetype glyph to be processed
+         */
+        FTBitmapGlyph( FT_GlyphSlot glyph);
+
+        /**
+         * Destructor
+         */
+        virtual ~FTBitmapGlyph();
+
+        /**
+         * Renders this glyph at the current pen position.
+         *
+         * @param pen   The current pen position.
+         * @return      The advance distance for this glyph.
+         */
+        virtual float Render( const FTPoint& pen);
+        
+    private:
+        /**
+         * The width of the glyph 'image'
+         */
+        unsigned int destWidth;
+
+        /**
+         * The height of the glyph 'image'
+         */
+        unsigned int destHeight;
+
+        /**
+         * The pitch of the glyph 'image'
+         */
+        unsigned int destPitch;
+
+        /**
+         * Vector from the pen position to the topleft corner of the bitmap
+         */
+        FTPoint pos;
+        
+        /**
+         * Pointer to the 'image' data
+         */
+        unsigned char* data;
+        
+};
+
+
+#endif  //  __FTBitmapGlyph__
+
diff --git a/extern/bFTGL/include/FTBufferGlyph.h b/extern/bFTGL/include/FTBufferGlyph.h
new file mode 100755
index 00000000000..9795f4de5d4
--- /dev/null
+++ b/extern/bFTGL/include/FTBufferGlyph.h
@@ -0,0 +1,76 @@
+#ifndef     __FTBufferGlyph__
+#define     __FTBufferGlyph__
+
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#include FT_GLYPH_H
+
+#include "FTGL.h"
+#include "FTGlyph.h"
+
+
+/**
+ * FTBufferGlyph is a specialisation of FTGlyph for creating pixmaps.
+ * 
+ * @see FTGlyphContainer
+ *
+ */
+class  FTGL_EXPORT FTBufferGlyph : public FTGlyph
+{
+    public:
+        /**
+         * Constructor
+         *
+         * @param glyph The Freetype glyph to be processed
+         */
+        FTBufferGlyph( FT_GlyphSlot glyph, unsigned char* clientBuffer);
+
+        /**
+         * Destructor
+         */
+        virtual ~FTBufferGlyph();
+
+        /**
+         * Renders this glyph at the current pen position.
+         *
+         * @param pen   The current pen position.
+         * @return      The advance distance for this glyph.
+         */
+        virtual float Render( const FTPoint& pen);
+        
+        // attributes
+
+    private:
+        /**
+         * The width of the glyph 'image'
+         */
+        int destWidth;
+
+        /**
+         * The height of the glyph 'image'
+         */
+        int destHeight;
+
+        /**
+         * The pitch of the glyph 'image'
+         */
+        unsigned int destPitch;
+        
+        /**
+         * Vector from the pen position to the topleft corner of the pixmap
+         */
+        FTPoint pos;
+        
+        /**
+         * Pointer to the 'image' data
+         */
+        unsigned char* data;
+        
+        
+        unsigned char* buffer;
+        
+};
+
+
+#endif  //  __FTBufferGlyph__
diff --git a/extern/bFTGL/include/FTCharToGlyphIndexMap.h b/extern/bFTGL/include/FTCharToGlyphIndexMap.h
new file mode 100644
index 00000000000..6e40d3c9574
--- /dev/null
+++ b/extern/bFTGL/include/FTCharToGlyphIndexMap.h
@@ -0,0 +1,130 @@
+#ifndef    __FTCharToGlyphIndexMap__
+#define    __FTCharToGlyphIndexMap__
+
+#include <stdlib.h>
+
+#include "FTGL.h"
+
+/**
+ * Provides a non-STL alternative to the STL map<unsigned long, unsigned long>
+ * which maps character codes to glyph indices inside FTCharmap.
+ * 
+ * Implementation:
+ *   - NumberOfBuckets buckets are considered.
+ *   - Each bucket has BucketSize entries.
+ *   - When the glyph index for the character code C has to be stored, the 
+ *     bucket this character belongs to is found using 'C div BucketSize'. 
+ *     If this bucket has not been allocated yet, do it now.
+ *     The entry in the bucked is found using 'C mod BucketSize'. 
+ *     If it is set to IndexNotFound, then the glyph entry has not been set.
+ *   - Try to mimic the calls made to the STL map API.
+ *
+ * Caveats:
+ *   - The glyph index is now a signed long instead of unsigned long, so
+ *     the special value IndexNotFound (= -1) can be used to specify that the 
+ *     glyph index has not been stored yet.
+ */
+class FTGL_EXPORT FTCharToGlyphIndexMap
+{
+    public:
+  
+        typedef unsigned long CharacterCode;
+        typedef signed long GlyphIndex;
+        
+        enum 
+        {
+            NumberOfBuckets = 256,
+            BucketSize = 256,
+            IndexNotFound = -1
+        };
+
+        FTCharToGlyphIndexMap()
+        {
+            this->Indices = 0;
+        }
+
+        virtual ~FTCharToGlyphIndexMap()
+        {
+            if( this->Indices)
+            {
+                // Free all buckets
+                this->clear();
+        
+                // Free main structure
+                delete [] this->Indices;
+                this->Indices = 0;
+            }
+        }
+  
+        void clear()
+        {
+            if(this->Indices)
+            {
+                for( int i = 0; i < FTCharToGlyphIndexMap::NumberOfBuckets; i++)
+                {
+                    if( this->Indices[i])
+                    {
+                        delete [] this->Indices[i];
+                        this->Indices[i] = 0;
+                    }
+                }
+            }
+        }
+
+        const GlyphIndex find( CharacterCode c)
+        {
+            if( !this->Indices)
+            {
+                return 0;
+            }
+        
+            // Find position of char code in buckets
+            div_t pos = div( c, FTCharToGlyphIndexMap::BucketSize);
+        
+            if( !this->Indices[pos.quot])
+            {
+                return 0;
+            }
+        
+            const FTCharToGlyphIndexMap::GlyphIndex *ptr = &this->Indices[pos.quot][pos.rem];
+            if( *ptr == FTCharToGlyphIndexMap::IndexNotFound)
+            {
+                return 0;
+            }
+        
+            return *ptr;
+        }
+
+        void insert( CharacterCode c, GlyphIndex g)
+        {
+            if( !this->Indices)
+            {
+                this->Indices = new GlyphIndex* [FTCharToGlyphIndexMap::NumberOfBuckets];
+                for( int i = 0; i < FTCharToGlyphIndexMap::NumberOfBuckets; i++)
+                {
+                    this->Indices[i] = 0;
+                }
+            }
+        
+            // Find position of char code in buckets
+            div_t pos = div(c, FTCharToGlyphIndexMap::BucketSize);
+        
+            // Allocate bucket if does not exist yet
+            if( !this->Indices[pos.quot])
+            {
+                this->Indices[pos.quot] = new GlyphIndex [FTCharToGlyphIndexMap::BucketSize];
+                for( int i = 0; i < FTCharToGlyphIndexMap::BucketSize; i++)
+                {
+                    this->Indices[pos.quot][i] = FTCharToGlyphIndexMap::IndexNotFound;
+                }
+            }
+          
+            this->Indices[pos.quot][pos.rem] = g;
+        }
+  
+    private:
+        GlyphIndex** Indices;
+};
+
+
+#endif  //  __FTCharToGlyphIndexMap__
diff --git a/extern/bFTGL/include/FTCharmap.h b/extern/bFTGL/include/FTCharmap.h
new file mode 100644
index 00000000000..74ca6f2cacb
--- /dev/null
+++ b/extern/bFTGL/include/FTCharmap.h
@@ -0,0 +1,136 @@
+#ifndef     __FTCharmap__
+#define     __FTCharmap__
+
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#include FT_GLYPH_H
+
+#include "FTCharToGlyphIndexMap.h"
+
+#include "FTGL.h"
+
+
+/**
+ * FTCharmap takes care of specifying the encoding for a font and mapping
+ * character codes to glyph indices.
+ *
+ * It doesn't preprocess all indices, only on an as needed basis. This may
+ * seem like a performance penalty but it is quicker than using the 'raw'
+ * freetype calls and will save significant amounts of memory when dealing
+ * with unicode encoding
+ *
+ * @see "Freetype 2 Documentation" 
+ *
+ */
+
+class FTFace;
+
+class FTGL_EXPORT FTCharmap
+{
+    public:
+        /**
+         * Constructor
+         */
+        FTCharmap( FTFace* face);
+
+        /**
+         * Destructor
+         */
+        virtual ~FTCharmap();
+
+        /**
+         * Queries for the current character map code.
+         *
+         * @return  The current character map code.
+         */
+        FT_Encoding Encoding() const { return ftEncoding;}
+        
+        /**
+         * Sets the character map for the face.
+         * Valid encodings as at Freetype 2.0.4
+         *      ft_encoding_none
+         *      ft_encoding_symbol
+         *      ft_encoding_unicode
+         *      ft_encoding_latin_2
+         *      ft_encoding_sjis
+         *      ft_encoding_gb2312
+         *      ft_encoding_big5
+         *      ft_encoding_wansung
+         *      ft_encoding_johab
+         *      ft_encoding_adobe_standard
+         *      ft_encoding_adobe_expert
+         *      ft_encoding_adobe_custom
+         *      ft_encoding_apple_roman
+         *
+         * @param encoding  the Freetype encoding symbol. See above.
+         * @return          <code>true</code> if charmap was valid and set
+         *                  correctly. If the requested encoding is
+         *                  unavailable it will be set to ft_encoding_none.
+         */
+        bool CharMap( FT_Encoding encoding);
+        
+        /**
+         * Get the FTGlyphContainer index of the input character.
+         *
+         * @param characterCode The character code of the requested glyph in
+         *                      the current encoding eg apple roman.
+         * @return      The FTGlyphContainer index for the character or zero
+         *              if it wasn't found
+         */
+        unsigned int GlyphListIndex( const unsigned int characterCode);
+
+        /**
+         * Get the font glyph index of the input character.
+         *
+         * @param characterCode The character code of the requested glyph in
+         *                      the current encoding eg apple roman.
+         * @return      The glyph index for the character.
+         */
+        unsigned int FontIndex( const unsigned int characterCode);
+
+        /**
+         * Set the FTGlyphContainer index of the character code.
+         *
+         * @param characterCode  The character code of the requested glyph in
+         *                       the current encoding eg apple roman.
+         * @param containerIndex The index into the FTGlyphContainer of the
+         *                       character code.
+         */
+        void InsertIndex( const unsigned int characterCode, const unsigned int containerIndex);
+
+        /**
+         * Queries for errors.
+         *
+         * @return  The current error code. Zero means no error.
+         */
+        FT_Error Error() const { return err;}
+        
+    private:
+        /**
+         * Current character map code.
+         */
+        FT_Encoding ftEncoding;
+        
+        /**
+         * The current Freetype face.
+         */
+        const FT_Face ftFace;
+        
+        /**
+         * A structure that maps glyph indices to character codes
+         *
+         * < character code, face glyph index>
+         */
+        typedef FTCharToGlyphIndexMap CharacterMap;
+        CharacterMap charMap;
+        
+        /**
+         * Current error code.
+         */
+        FT_Error err;
+        
+};
+
+
+#endif  //  __FTCharmap__
diff --git a/extern/bFTGL/include/FTContour.h b/extern/bFTGL/include/FTContour.h
new file mode 100644
index 00000000000..895d9edeff8
--- /dev/null
+++ b/extern/bFTGL/include/FTContour.h
@@ -0,0 +1,88 @@
+#ifndef     __FTContour__
+#define     __FTContour__
+
+#include "FTPoint.h"
+#include "FTVector.h"
+#include "FTGL.h"
+
+
+/**
+ * FTContour class is a container of points that describe a vector font
+ * outline. It is used as a container for the output of the bezier curve
+ * evaluator in FTVectoriser.
+ *
+ * @see FTOutlineGlyph
+ * @see FTPolyGlyph
+ * @see FTPoint
+ */
+class FTGL_EXPORT FTContour
+{
+    public:
+        /**
+         * Constructor
+         *
+         * @param contour
+         * @param pointTags
+         * @param numberOfPoints
+         */
+        FTContour( FT_Vector* contour, char* pointTags, unsigned int numberOfPoints);
+
+        /**
+         * Destructor
+         */
+        ~FTContour()
+        {
+            pointList.clear();
+        }
+        
+        /**
+         * Return a point at index.
+         *
+         * @param index of the point in the curve.
+         * @return const point reference
+         */
+        const FTPoint& Point( unsigned int index) const { return pointList[index];}
+
+        /**
+         * How many points define this contour
+         *
+         * @return the number of points in this contour
+         */
+        size_t PointCount() const { return pointList.size();}
+
+    private:
+        /**
+         * Add a point to this contour. This function tests for duplicate
+         * points.
+         *
+         * @param point The point to be added to the contour.
+         */
+        inline void AddPoint( FTPoint point);
+        
+        inline void AddPoint( float x, float y);
+        
+        /**
+         * De Casteljau (bezier) algorithm contributed by Jed Soane
+         * Evaluates a quadratic or conic (second degree) curve
+         */
+        inline void evaluateQuadraticCurve();
+
+        /**
+         * De Casteljau (bezier) algorithm contributed by Jed Soane
+         * Evaluates a cubic (third degree) curve
+         */
+        inline void evaluateCubicCurve();
+
+        /**
+         *  The list of points in this contour
+         */
+        typedef FTVector<FTPoint> PointVector;
+        PointVector pointList;
+        
+        /**
+         * 2D array storing values of de Casteljau algorithm.
+         */
+        float controlPoints[4][2];
+};
+
+#endif // __FTContour__
diff --git a/extern/bFTGL/include/FTExtrdGlyph.h b/extern/bFTGL/include/FTExtrdGlyph.h
new file mode 100644
index 00000000000..01e7c9e1d76
--- /dev/null
+++ b/extern/bFTGL/include/FTExtrdGlyph.h
@@ -0,0 +1,71 @@
+#ifndef     __FTExtrdGlyph__
+#define     __FTExtrdGlyph__
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#include FT_GLYPH_H
+
+#include "FTGL.h"
+#include "FTGlyph.h"
+
+class FTVectoriser;
+
+/**
+ * FTExtrdGlyph is a specialisation of FTGlyph for creating tessellated
+ * extruded polygon glyphs.
+ * 
+ * @see FTGlyphContainer
+ * @see FTVectoriser
+ *
+ */
+class FTGL_EXPORT FTExtrdGlyph : public FTGlyph
+{
+    public:
+        /**
+         * Constructor. Sets the Error to Invalid_Outline if the glyphs isn't an outline.
+         *
+         * @param glyph The Freetype glyph to be processed
+         * @param depth The distance along the z axis to extrude the glyph
+         */
+        FTExtrdGlyph( FT_GlyphSlot glyph, float depth);
+
+        /**
+         * Destructor
+         */
+        virtual ~FTExtrdGlyph();
+
+        /**
+         * Renders this glyph at the current pen position.
+         *
+         * @param pen   The current pen position.
+         * @return      The advance distance for this glyph.
+         */
+        virtual float Render( const FTPoint& pen);
+        
+    private:
+        /**
+         * Calculate the normal vector to 2 points. This is 2D and ignores
+         * the z component. The normal will be normalised
+         *
+         * @param a
+         * @param b
+         * @return
+         */
+        FTPoint GetNormal( const FTPoint &a, const FTPoint &b);
+        
+        
+        /**
+         * OpenGL display list
+         */
+        GLuint glList;
+        
+        /**
+         * Distance to extrude the glyph
+         */
+        float depth;
+    
+};
+
+
+#endif  //  __FTExtrdGlyph__
+
diff --git a/extern/bFTGL/include/FTFace.h b/extern/bFTGL/include/FTFace.h
new file mode 100755
index 00000000000..26bb3966462
--- /dev/null
+++ b/extern/bFTGL/include/FTFace.h
@@ -0,0 +1,149 @@
+#ifndef     __FTFace__
+#define     __FTFace__
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#include FT_GLYPH_H
+
+#include "FTGL.h"
+#include "FTPoint.h"
+#include "FTSize.h"
+
+/**
+ * FTFace class provides an abstraction layer for the Freetype Face.
+ *
+ * @see "Freetype 2 Documentation"
+ *
+ */
+class FTGL_EXPORT FTFace
+{
+    public:
+        /**
+         * Opens and reads a face file. Error is set.
+         *
+         * @param filename  font file name.
+         */
+        FTFace( const char* filename);
+
+        /**
+         * Read face data from an in-memory buffer. Error is set.
+         *
+         * @param pBufferBytes  the in-memory buffer
+         * @param bufferSizeInBytes  the length of the buffer in bytes
+         */
+        FTFace( const unsigned char *pBufferBytes, size_t bufferSizeInBytes );
+
+        /**
+         * Destructor
+         *
+         * Disposes of the current Freetype Face.
+         */
+        virtual ~FTFace();
+
+        /**
+         * Attach auxilliary file to font (e.g., font metrics).
+         *
+         * @param filename  auxilliary font file name.
+         * @return          <code>true</code> if file has opened
+         *                  successfully.
+         */
+        bool Attach( const char* filename);
+
+        /**
+         * Attach auxilliary data to font (e.g., font metrics) from memory
+         *
+         * @param pBufferBytes  the in-memory buffer
+         * @param bufferSizeInBytes  the length of the buffer in bytes
+         * @return          <code>true</code> if file has opened
+         *                  successfully.
+         */
+        bool Attach( const unsigned char *pBufferBytes, size_t bufferSizeInBytes);
+
+        /**
+         * Disposes of the face
+         */
+        void Close();
+
+        /**
+         * Get the freetype face object..
+         *
+         * @return pointer to an FT_Face.
+         */
+        FT_Face* Face() const { return ftFace;}
+        
+        /**
+         * Sets the char size for the current face.
+         *
+         * This doesn't guarantee that the size was set correctly. Clients
+         * should check errors.
+         *
+         * @param size      the face size in points (1/72 inch)
+         * @param res       the resolution of the target device.
+         * @return          <code>FTSize</code> object
+         */
+        const FTSize& Size( const unsigned int size, const unsigned int res);
+
+        unsigned int UnitsPerEM() const;
+
+        /**
+         * Get the number of character maps in this face.
+         *
+         * @return character map count.
+         */
+        unsigned int CharMapCount();
+
+        /**
+         * Get a list of character maps in this face.
+         *
+         * @return pointer to the first encoding.
+         */
+        FT_Encoding* CharMapList();
+        
+        /**
+         * Gets the kerning vector between two glyphs
+         */
+        FTPoint KernAdvance( unsigned int index1, unsigned int index2);
+
+        /**
+         * Loads and creates a Freetype glyph.
+         */
+        FT_GlyphSlot Glyph( unsigned int index, FT_Int load_flags);
+
+        /**
+         * Gets the number of glyphs in the current face.
+         */
+        unsigned int GlyphCount() const { return numGlyphs;}
+
+        /**
+         * Queries for errors.
+         *
+         * @return  The current error code.
+         */
+        FT_Error Error() const { return err; }
+        
+    private:
+        /**
+         * The Freetype face
+         */
+        FT_Face* ftFace;
+
+        /**
+         * The size object associated with this face
+         */
+        FTSize  charSize;
+        
+        /**
+         * The number of glyphs in this face
+         */
+        int numGlyphs;
+        
+        FT_Encoding* fontEncodingList;
+
+        /**
+         * Current error code. Zero means no error.
+         */
+        FT_Error err;
+};
+
+
+#endif  //  __FTFace__
diff --git a/extern/bFTGL/include/FTFont.h b/extern/bFTGL/include/FTFont.h
new file mode 100755
index 00000000000..5b3d9e46f68
--- /dev/null
+++ b/extern/bFTGL/include/FTFont.h
@@ -0,0 +1,260 @@
+#ifndef    __FTFont__
+#define    __FTFont__
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+#include "FTFace.h"
+#include "FTGL.h"
+
+class FTGlyphContainer;
+class FTGlyph;
+
+
+/**
+ * FTFont is the public interface for the FTGL library.
+ *
+ * Specific font classes are derived from this class. It uses the helper
+ * classes FTFace and FTSize to access the Freetype library. This class
+ * is abstract and deriving classes must implement the protected
+ * <code>MakeGlyph</code> function to create glyphs of the
+ * appropriate type.
+ *
+ * It is good practice after using these functions to test the error
+ * code returned. <code>FT_Error Error()</code>
+ *
+ * @see     FTFace
+ * @see     FTSize
+ * @see     FTGlyphContainer
+ * @see     FTGlyph
+ */
+class FTGL_EXPORT FTFont
+{
+    public:
+        /**
+         * Open and read a font file. Sets Error flag.
+         *
+         * @param fontname  font file name.
+         */
+        FTFont( const char* fontname);
+        
+        /**
+         * Open and read a font from a buffer in memory. Sets Error flag.
+         * The buffer is owned by the client and is NOT copied by FTGL. The
+         * pointer must be valid while using FTGL.
+         *
+         * @param pBufferBytes  the in-memory buffer
+         * @param bufferSizeInBytes  the length of the buffer in bytes
+         */
+        FTFont( const unsigned char *pBufferBytes, size_t bufferSizeInBytes);
+        
+        /**
+         * Destructor
+         */
+        virtual ~FTFont();
+        
+        /**
+         * Attach auxilliary file to font e.g font metrics.
+         *
+         * Note: not all font formats implement this function.
+         *
+         * @param filename  auxilliary font file name.
+         * @return          <code>true</code> if file has been attached
+         *                  successfully.
+         */
+        bool Attach( const char* filename);
+
+        /**
+         * Attach auxilliary data to font e.g font metrics, from memory
+         *
+         * Note: not all font formats implement this function.
+         *
+         * @param pBufferBytes  the in-memory buffer
+         * @param bufferSizeInBytes  the length of the buffer in bytes
+         * @return          <code>true</code> if file has been attached
+         *                  successfully.
+         */
+        bool Attach( const unsigned char *pBufferBytes, size_t bufferSizeInBytes);
+
+        /**
+         * Set the character map for the face.
+         *
+         * @param encoding      Freetype enumerate for char map code.
+         * @return              <code>true</code> if charmap was valid and
+         *                      set correctly
+         */
+        bool CharMap( FT_Encoding encoding );
+
+        /**
+         * Get the number of character maps in this face.
+         *
+         * @return character map count.
+         */
+        unsigned int CharMapCount();
+
+        /**
+         * Get a list of character maps in this face.
+         *
+         * @return pointer to the first encoding.
+         */
+        FT_Encoding* CharMapList();
+        
+        /**
+         * Set the char size for the current face.
+         *
+         * @param size      the face size in points (1/72 inch)
+         * @param res       the resolution of the target device.
+         * @return          <code>true</code> if size was set correctly
+         */
+        virtual bool FaceSize( const unsigned int size, const unsigned int res = 72);
+        
+        /**
+         * Get the current face size in points.
+         *
+         * @return face size
+         */
+        unsigned int FaceSize() const;
+        
+        /**
+         * Set the extrusion distance for the font. Only implemented by
+         * FTGLExtrdFont
+         *
+         * @param d  The extrusion distance.
+         */
+        virtual void Depth( float d){}
+
+        /**
+         * Get the global ascender height for the face.
+         *
+         * @return  Ascender height
+         */
+        float Ascender() const;
+        
+        /**
+         * Gets the global descender height for the face.
+         *
+         * @return  Descender height
+         */
+        float Descender() const;
+
+        /**
+         * Get the bounding box for a string.
+         *
+         * @param string    a char string
+         * @param llx       lower left near x coord
+         * @param lly       lower left near y coord
+         * @param llz       lower left near z coord
+         * @param urx       upper right far x coord
+         * @param ury       upper right far y coord
+         * @param urz       upper right far z coord
+         */
+        void BBox( const char* string, float& llx, float& lly, float& llz, float& urx, float& ury, float& urz);
+
+        /**
+         * Get the bounding box for a string.
+         *
+         * @param string    a wchar_t string
+         * @param llx       lower left near x coord
+         * @param lly       lower left near y coord
+         * @param llz       lower left near z coord
+         * @param urx       upper right far x coord
+         * @param ury       upper right far y coord
+         * @param urz       upper right far z coord
+         */
+        void BBox( const wchar_t* string, float& llx, float& lly, float& llz, float& urx, float& ury, float& urz);
+
+        /**
+         * Get the advance width for a string.
+         *
+         * @param string    a wchar_t string
+         * @return      advance width
+         */
+        float Advance( const wchar_t* string);
+
+        /**
+         * Get the advance width for a string.
+         *
+         * @param string    a char string
+         * @return      advance width
+         */
+        float Advance( const char* string);
+
+        /**
+         * Render a string of characters
+         * 
+         * @param string    'C' style string to be output.   
+         */
+        virtual void Render( const char* string );
+
+        /**
+         * Render a string of characters
+         * 
+         * @param string    wchar_t string to be output.     
+         */
+        virtual void Render( const wchar_t* string );
+
+        /**
+         * Queries the Font for errors.
+         *
+         * @return  The current error code.
+         */
+        FT_Error Error() const { return err;}
+
+    protected:
+        /**
+         * Construct a glyph of the correct type.
+         *
+         * Clients must overide the function and return their specialised
+         * FTGlyph.
+         *
+         * @param g The glyph index NOT the char code.
+         * @return  An FT****Glyph or <code>null</code> on failure.
+         */
+        virtual FTGlyph* MakeGlyph( unsigned int g) = 0;
+        
+        /**
+         * Current face object
+         */
+        FTFace face;
+        
+        /**
+         * Current size object
+         */
+        FTSize charSize;
+
+        /**
+         * Current error code. Zero means no error.
+         */
+        FT_Error err;
+        
+    private:        
+        /**
+         * Render a character
+         * This function does an implicit conversion on it's arguments.
+         * 
+         * @param chr       current character
+         * @param nextChr   next character
+         */
+        inline void DoRender( const unsigned int chr, const unsigned int nextChr);
+        
+        /**
+         * Check that the glyph at <code>chr</code> exist. If not load it.
+         *
+         * @param chr  character index
+         */
+        inline void CheckGlyph( const unsigned int chr);
+
+        /**
+         * An object that holds a list of glyphs
+         */
+        FTGlyphContainer* glyphList;
+        
+        /**
+         * Current pen or cursor position;
+         */
+        FTPoint pen;
+};
+
+
+#endif  //  __FTFont__
+
diff --git a/extern/bFTGL/include/FTGL.h b/extern/bFTGL/include/FTGL.h
new file mode 100755
index 00000000000..e92bd526012
--- /dev/null
+++ b/extern/bFTGL/include/FTGL.h
@@ -0,0 +1,96 @@
+#ifndef     __FTGL__
+#define     __FTGL__
+
+
+typedef double   FTGL_DOUBLE;
+typedef float    FTGL_FLOAT;
+
+// Fixes for deprecated identifiers in 2.1.5
+#ifndef FT_OPEN_MEMORY
+    #define FT_OPEN_MEMORY (FT_Open_Flags)1
+#endif
+
+#ifndef FT_RENDER_MODE_MONO
+    #define FT_RENDER_MODE_MONO ft_render_mode_mono
+#endif
+
+#ifndef FT_RENDER_MODE_NORMAL
+    #define FT_RENDER_MODE_NORMAL ft_render_mode_normal
+#endif
+
+  
+#ifdef WIN32
+
+    // Under windows avoid including <windows.h> is overrated. 
+    // Sure, it can be avoided and "name space pollution" can be
+    // avoided, but why? It really doesn't make that much difference
+    // these days.
+    #define  WIN32_LEAN_AND_MEAN
+    #include <windows.h>
+
+    #ifndef __gl_h_
+        #include <GL/gl.h>
+        #include <GL/glu.h>
+    #endif
+
+#else
+
+    // Non windows platforms - don't require nonsense as seen above :-)    
+    #ifndef __gl_h_
+        #ifdef __APPLE_CC__
+            #include <OpenGL/gl.h>
+            #include <OpenGL/glu.h>
+        #else
+            #include <GL/gl.h>
+            #include <GL/glu.h>
+        #endif                
+
+    #endif
+
+    // Required for compatibility with glext.h style function definitions of 
+    // OpenGL extensions, such as in src/osg/Point.cpp.
+    #ifndef APIENTRY
+        #define APIENTRY
+    #endif
+#endif
+
+// Compiler-specific conditional compilation
+#ifdef _MSC_VER // MS Visual C++ 
+
+    // Disable various warning.
+    // 4786: template name too long
+    #pragma warning( disable : 4251 )
+    #pragma warning( disable : 4275 )
+    #pragma warning( disable : 4786 )
+
+    // The following definitions control how symbols are exported.
+    // If the target is a static library ensure that FTGL_LIBRARY_STATIC
+    // is defined. If building a dynamic library (ie DLL) ensure the
+    // FTGL_LIBRARY macro is defined, as it will mark symbols for 
+    // export. If compiling a project to _use_ the _dynamic_ library 
+    // version of the library, no definition is required. 
+    #ifdef FTGL_LIBRARY_STATIC      // static lib - no special export required
+    #  define FTGL_EXPORT
+    #elif FTGL_LIBRARY              // dynamic lib - must export/import symbols appropriately.
+    #  define FTGL_EXPORT   __declspec(dllexport)
+    #else
+    #  define FTGL_EXPORT   __declspec(dllimport)
+    #endif 
+
+#else
+    // Compiler that is not MS Visual C++.
+    // Ensure that the export symbol is defined (and blank)
+    #define FTGL_EXPORT
+#endif  
+
+
+// lifted from glext.h, to remove dependancy on glext.h
+#ifndef GL_EXT_texture_object
+    #define GL_TEXTURE_PRIORITY_EXT           0x8066
+    #define GL_TEXTURE_RESIDENT_EXT           0x8067
+    #define GL_TEXTURE_1D_BINDING_EXT         0x8068
+    #define GL_TEXTURE_2D_BINDING_EXT         0x8069
+    #define GL_TEXTURE_3D_BINDING_EXT         0x806A
+#endif
+
+#endif  //  __FTGL__
diff --git a/extern/bFTGL/include/FTGLBitmapFont.h b/extern/bFTGL/include/FTGLBitmapFont.h
new file mode 100755
index 00000000000..12feae00cb6
--- /dev/null
+++ b/extern/bFTGL/include/FTGLBitmapFont.h
@@ -0,0 +1,65 @@
+#ifndef __FTGLBitmapFont__
+#define __FTGLBitmapFont__
+
+#include "FTFont.h"
+#include "FTGL.h"
+
+
+class FTGlyph;
+
+/**
+ * FTGLBitmapFont is a specialisation of the FTFont class for handling
+ * Bitmap fonts
+ *
+ * @see     FTFont
+ */
+class FTGL_EXPORT FTGLBitmapFont : public FTFont
+{
+    public:
+        /**
+         * Open and read a font file. Sets Error flag.
+         *
+         * @param fontname  font file name.
+         */
+        FTGLBitmapFont( const char* fontname);
+
+        /**
+         * Open and read a font from a buffer in memory. Sets Error flag.
+         *
+         * @param pBufferBytes  the in-memory buffer
+         * @param bufferSizeInBytes  the length of the buffer in bytes
+         */
+        FTGLBitmapFont( const unsigned char *pBufferBytes, size_t bufferSizeInBytes);
+
+        /**
+         * Destructor
+         */
+        ~FTGLBitmapFont();
+        
+        /**
+         * Renders a string of characters
+         * 
+         * @param string    'C' style string to be output.   
+         */
+        void Render( const char* string);
+
+        /**
+         * Renders a string of characters
+         * 
+         * @param string    'C' style wide string to be output.  
+         */
+        void Render( const wchar_t* string);
+
+        // attributes
+        
+    private:
+        /**
+         * Construct a FTBitmapGlyph.
+         *
+         * @param g The glyph index NOT the char code.
+         * @return  An FTBitmapGlyph or <code>null</code> on failure.
+         */
+        inline virtual FTGlyph* MakeGlyph( unsigned int g);
+                
+};
+#endif  //  __FTGLBitmapFont__
diff --git a/extern/bFTGL/include/FTGLBufferFont.h b/extern/bFTGL/include/FTGLBufferFont.h
new file mode 100755
index 00000000000..2f74b5cdef9
--- /dev/null
+++ b/extern/bFTGL/include/FTGLBufferFont.h
@@ -0,0 +1,76 @@
+#ifndef     __FTGLBufferFont__
+#define     __FTGLBufferFont__
+
+
+#include "FTFont.h"
+#include "FTGL.h"
+
+
+class FTGlyph;
+
+
+/**
+ * FTGLBufferFont is a specialisation of the FTFont class for handling
+ * Pixmap (Grey Scale) fonts
+ *
+ * @see     FTFont
+ */
+class FTGL_EXPORT FTGLBufferFont : public FTFont
+{
+    public:
+        /**
+         * Open and read a font file. Sets Error flag.
+         *
+         * @param fontname  font file name.
+         */
+        FTGLBufferFont( const char* fontname);
+        
+        /**
+         * Open and read a font from a buffer in memory. Sets Error flag.
+         *
+         * @param pBufferBytes  the in-memory buffer
+         * @param bufferSizeInBytes  the length of the buffer in bytes
+         */
+        FTGLBufferFont( const unsigned char *pBufferBytes, size_t bufferSizeInBytes);
+        
+        
+        void SetClientBuffer( unsigned char* b)
+        {
+            buffer = b;
+        }
+        
+        
+        /**
+         * Destructor
+         */
+        ~FTGLBufferFont();
+        
+        /**
+         * Renders a string of characters
+         * 
+         * @param string    'C' style string to be output.   
+         */
+        void Render( const char* string);
+        
+        /**
+         * Renders a string of characters
+         * 
+         * @param string    wchar_t string to be output.     
+         */
+        void Render( const wchar_t* string);
+
+    private:
+        /**
+         * Construct a FTBufferGlyph.
+         *
+         * @param g The glyph index NOT the char code.
+         * @return  An FTBufferGlyph or <code>null</code> on failure.
+         */
+        inline virtual FTGlyph* MakeGlyph( unsigned int g);
+        
+        unsigned char* buffer;
+};
+
+
+#endif  //  __FTGLBufferFont__
+
diff --git a/extern/bFTGL/include/FTGLExtrdFont.h b/extern/bFTGL/include/FTGLExtrdFont.h
new file mode 100644
index 00000000000..dc784bbb5b0
--- /dev/null
+++ b/extern/bFTGL/include/FTGLExtrdFont.h
@@ -0,0 +1,55 @@
+#ifndef __FTGLExtrdFont__
+#define __FTGLExtrdFont__
+
+#include "FTFont.h"
+#include "FTGL.h"
+
+class FTGlyph;
+
+/**
+ * FTGLExtrdFont is a specialisation of the FTFont class for handling
+ * extruded Polygon fonts
+ *
+ * @see		FTFont
+ * @see		FTGLPolygonFont
+ */
+class FTGL_EXPORT FTGLExtrdFont : public FTFont
+{
+    public:
+        /**
+         * Open and read a font file. Sets Error flag.
+         *
+         * @param fontname  font file name.
+         */
+        FTGLExtrdFont( const char* fontname);
+
+        /**
+         * Open and read a font from a buffer in memory. Sets Error flag.
+         *
+         * @param pBufferBytes  the in-memory buffer
+         * @param bufferSizeInBytes  the length of the buffer in bytes
+         */
+        FTGLExtrdFont( const unsigned char *pBufferBytes, size_t bufferSizeInBytes);
+
+        /**
+         * Destructor
+         */
+        ~FTGLExtrdFont();
+		
+        void Depth( float d) { depth = d;}
+		
+    private:
+        /**
+         * Construct a FTPolyGlyph.
+         *
+         * @param glyphIndex The glyph index NOT the char code.
+         * @return	An FTExtrdGlyph or <code>null</code> on failure.
+         */
+        inline virtual FTGlyph* MakeGlyph( unsigned int glyphIndex);
+		
+        float depth;
+};
+
+
+#endif	//	__FTGLExtrdFont__
+
diff --git a/extern/bFTGL/include/FTGLOutlineFont.h b/extern/bFTGL/include/FTGLOutlineFont.h
new file mode 100755
index 00000000000..a7f4b23092d
--- /dev/null
+++ b/extern/bFTGL/include/FTGLOutlineFont.h
@@ -0,0 +1,64 @@
+#ifndef     __FTGLOutlineFont__
+#define     __FTGLOutlineFont__
+
+
+#include "FTFont.h"
+#include "FTGL.h"
+
+class FTGlyph;
+
+
+/**
+ * FTGLOutlineFont is a specialisation of the FTFont class for handling
+ * Vector Outline fonts
+ *
+ * @see     FTFont
+ */
+class FTGL_EXPORT FTGLOutlineFont : public FTFont
+{
+    public:
+        /**
+         * Open and read a font file. Sets Error flag.
+         *
+         * @param fontname  font file name.
+         */
+        FTGLOutlineFont( const char* fontname);
+        
+        /**
+         * Open and read a font from a buffer in memory. Sets Error flag.
+         *
+         * @param pBufferBytes  the in-memory buffer
+         * @param bufferSizeInBytes  the length of the buffer in bytes
+         */
+        FTGLOutlineFont( const unsigned char *pBufferBytes, size_t bufferSizeInBytes);
+        
+        /**
+         * Destructor
+         */
+        ~FTGLOutlineFont();
+        
+        /**
+         * Renders a string of characters
+         * 
+         * @param string    'C' style string to be output.   
+         */
+        void Render( const char* string);
+        
+        /**
+         * Renders a string of characters
+         * 
+         * @param string    wchar_t string to be output.     
+         */
+        void Render( const wchar_t* string);
+
+    private:
+        /**
+         * Construct a FTOutlineGlyph.
+         *
+         * @param g The glyph index NOT the char code.
+         * @return  An FTOutlineGlyph or <code>null</code> on failure.
+         */
+        inline virtual FTGlyph* MakeGlyph( unsigned int g);
+        
+};
+#endif // __FTGLOutlineFont__
diff --git a/extern/bFTGL/include/FTGLPixmapFont.h b/extern/bFTGL/include/FTGLPixmapFont.h
new file mode 100755
index 00000000000..f781ddf68dd
--- /dev/null
+++ b/extern/bFTGL/include/FTGLPixmapFont.h
@@ -0,0 +1,68 @@
+#ifndef     __FTGLPixmapFont__
+#define     __FTGLPixmapFont__
+
+
+#include "FTFont.h"
+#include "FTGL.h"
+
+
+class FTGlyph;
+
+
+/**
+ * FTGLPixmapFont is a specialisation of the FTFont class for handling
+ * Pixmap (Grey Scale) fonts
+ *
+ * @see     FTFont
+ */
+class FTGL_EXPORT FTGLPixmapFont : public FTFont
+{
+    public:
+        /**
+         * Open and read a font file. Sets Error flag.
+         *
+         * @param fontname  font file name.
+         */
+        FTGLPixmapFont( const char* fontname);
+        
+        /**
+         * Open and read a font from a buffer in memory. Sets Error flag.
+         *
+         * @param pBufferBytes  the in-memory buffer
+         * @param bufferSizeInBytes  the length of the buffer in bytes
+         */
+        FTGLPixmapFont( const unsigned char *pBufferBytes, size_t bufferSizeInBytes);
+        
+        /**
+         * Destructor
+         */
+        ~FTGLPixmapFont();
+        
+        /**
+         * Renders a string of characters
+         * 
+         * @param string    'C' style string to be output.   
+         */
+        void Render( const char* string);
+        
+        /**
+         * Renders a string of characters
+         * 
+         * @param string    wchar_t string to be output.     
+         */
+        void Render( const wchar_t* string);
+
+    private:
+        /**
+         * Construct a FTPixmapGlyph.
+         *
+         * @param g The glyph index NOT the char code.
+         * @return  An FTPixmapGlyph or <code>null</code> on failure.
+         */
+        inline virtual FTGlyph* MakeGlyph( unsigned int g);
+        
+};
+
+
+#endif  //  __FTGLPixmapFont__
+
diff --git a/extern/bFTGL/include/FTGLPolygonFont.h b/extern/bFTGL/include/FTGLPolygonFont.h
new file mode 100755
index 00000000000..54e624a1893
--- /dev/null
+++ b/extern/bFTGL/include/FTGLPolygonFont.h
@@ -0,0 +1,53 @@
+#ifndef     __FTGLPolygonFont__
+#define     __FTGLPolygonFont__
+
+
+#include "FTFont.h"
+#include "FTGL.h"
+
+class FTGlyph;
+
+
+/**
+ * FTGLPolygonFont is a specialisation of the FTFont class for handling
+ * tesselated Polygon Mesh fonts
+ *
+ * @see     FTFont
+ */
+class FTGL_EXPORT FTGLPolygonFont : public FTFont
+{
+    public:
+        /**
+         * Open and read a font file. Sets Error flag.
+         *
+         * @param fontname  font file name.
+         */
+        FTGLPolygonFont( const char* fontname);
+        
+        /**
+         * Open and read a font from a buffer in memory. Sets Error flag.
+         *
+         * @param pBufferBytes  the in-memory buffer
+         * @param bufferSizeInBytes  the length of the buffer in bytes
+         */
+        FTGLPolygonFont( const unsigned char *pBufferBytes, size_t bufferSizeInBytes);
+        
+        /**
+         * Destructor
+         */
+        ~FTGLPolygonFont();
+        
+    private:
+        /**
+         * Construct a FTPolyGlyph.
+         *
+         * @param g The glyph index NOT the char code.
+         * @return  An FTPolyGlyph or <code>null</code> on failure.
+         */
+        inline virtual FTGlyph* MakeGlyph( unsigned int g);
+        
+};
+
+
+#endif  //  __FTGLPolygonFont__
+
diff --git a/extern/bFTGL/include/FTGLTextureFont.h b/extern/bFTGL/include/FTGLTextureFont.h
new file mode 100755
index 00000000000..f0575143f4b
--- /dev/null
+++ b/extern/bFTGL/include/FTGLTextureFont.h
@@ -0,0 +1,151 @@
+#ifndef     __FTGLTextureFont__
+#define     __FTGLTextureFont__
+
+#include "FTFont.h"
+#include "FTVector.h"
+#include "FTGL.h"
+
+class FTTextureGlyph;
+
+
+/**
+ * FTGLTextureFont is a specialisation of the FTFont class for handling
+ * Texture mapped fonts
+ *
+ * @see     FTFont
+ */
+class  FTGL_EXPORT FTGLTextureFont : public FTFont
+{
+    public:
+        /**
+         * Open and read a font file. Sets Error flag.
+         *
+         * @param fontname  font file name.
+         */
+        FTGLTextureFont( const char* fontname);
+        
+        /**
+         * Open and read a font from a buffer in memory. Sets Error flag.
+         *
+         * @param pBufferBytes  the in-memory buffer
+         * @param bufferSizeInBytes  the length of the buffer in bytes
+         */
+        FTGLTextureFont( const unsigned char *pBufferBytes, size_t bufferSizeInBytes);
+        
+        /**
+         * Destructor
+         */
+        virtual ~FTGLTextureFont();
+
+        /**
+            * 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);
+
+        /**
+         * Renders a string of characters
+         * 
+         * @param string    'C' style string to be output.   
+         */
+        virtual void Render( const char* string);
+        
+        /**
+         * Renders a string of characters
+         * 
+         * @param string    wchar_t string to be output.     
+         */
+        virtual void Render( const wchar_t* string);
+
+        
+    private:
+        /**
+         * Construct a FTTextureGlyph.
+         *
+         * @param glyphIndex The glyph index NOT the char code.
+         * @return  An FTTextureGlyph or <code>null</code> on failure.
+         */
+        inline virtual FTGlyph* MakeGlyph( unsigned int glyphIndex);
+                
+        /**
+         * 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 maxTextSize;
+        
+        /**
+         * 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;
+
+};
+
+
+#endif // __FTGLTextureFont__
+
+
diff --git a/extern/bFTGL/include/FTGlyph.h b/extern/bFTGL/include/FTGlyph.h
new file mode 100755
index 00000000000..c38d51e728e
--- /dev/null
+++ b/extern/bFTGL/include/FTGlyph.h
@@ -0,0 +1,89 @@
+#ifndef     __FTGlyph__
+#define     __FTGlyph__
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#include FT_GLYPH_H
+
+#include "FTBBox.h"
+#include "FTPoint.h"
+#include "FTGL.h"
+
+
+/**
+ * FTGlyph is the base class for FTGL glyphs.
+ *
+ * It provides the interface between Freetype glyphs and their openGL
+ * renderable counterparts. This is an abstract class and derived classes
+ * must implement the <code>render</code> function. 
+ * 
+ * @see FTGlyphContainer
+ * @see FTBBox
+ * @see FTPoint
+ *
+ */
+class FTGL_EXPORT FTGlyph
+{
+    public:
+        /**
+         * Constructor
+         */
+        FTGlyph( FT_GlyphSlot glyph);
+
+        /**
+         * Destructor
+         */
+        virtual ~FTGlyph();
+
+        /**
+         * Renders this glyph at the current pen position.
+         *
+         * @param pen   The current pen position.
+         * @return      The advance distance for this glyph.
+         */
+        virtual float Render( const FTPoint& pen) = 0;
+        
+        /**
+         * Return the advance width for this glyph.
+         *
+         * @return  advance width.
+         */
+        float Advance() const { return advance;}
+        
+        /**
+         * Return the bounding box for this glyph.
+         *
+         * @return  bounding box.
+         */
+        const FTBBox& BBox() const { return bBox;}
+        
+        /**
+         * Queries for errors.
+         *
+         * @return  The current error code.
+         */
+        FT_Error Error() const { return err;}
+        
+    protected:
+        /**
+         * The advance distance for this glyph
+         */
+        float advance;
+
+        /**
+         * The bounding box of this glyph.
+         */
+        FTBBox bBox;
+        
+        /**
+         * Current error code. Zero means no error.
+         */
+        FT_Error err;
+        
+    private:
+
+};
+
+
+#endif  //  __FTGlyph__
+
diff --git a/extern/bFTGL/include/FTGlyphContainer.h b/extern/bFTGL/include/FTGlyphContainer.h
new file mode 100755
index 00000000000..de668b61dbd
--- /dev/null
+++ b/extern/bFTGL/include/FTGlyphContainer.h
@@ -0,0 +1,127 @@
+#ifndef     __FTGlyphContainer__
+#define     __FTGlyphContainer__
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#include FT_GLYPH_H
+
+#include "FTGL.h"
+#include "FTBBox.h"
+#include "FTPoint.h"
+#include "FTVector.h"
+
+class FTFace;
+class FTGlyph;
+class FTCharmap;
+
+/**
+ * FTGlyphContainer holds the post processed FTGlyph objects.
+ *
+ * @see FTGlyph
+ */
+class FTGL_EXPORT FTGlyphContainer
+{
+        typedef FTVector<FTGlyph*> GlyphVector;
+    public:
+        /**
+         * Constructor
+         *
+         * @param face      The Freetype face
+         */
+        FTGlyphContainer( FTFace* face);
+
+        /**
+         * Destructor
+         */
+        ~FTGlyphContainer();
+
+        /**
+         * Sets the character map for the face.
+         *
+         * @param encoding      the Freetype encoding symbol. See above.
+         * @return              <code>true</code> if charmap was valid
+         *                      and set correctly
+         */
+        bool CharMap( FT_Encoding encoding);
+
+        /**
+         * Get the font index of the input character.
+         *
+         * @param characterCode The character code of the requested glyph in the
+         *                      current encoding eg apple roman.
+         * @return      The font index for the character.
+         */
+        unsigned int FontIndex( const unsigned int characterCode ) const;
+        
+        /**
+         * Adds a glyph to this glyph list.
+         *
+         * @param glyph         The FTGlyph to be inserted into the container
+         * @param characterCode The char code of the glyph NOT the glyph index.
+         */
+        void Add( FTGlyph* glyph, const unsigned int characterCode);
+
+        /**
+         * Get a glyph from the glyph list
+         *
+         * @param characterCode The char code of the glyph NOT the glyph index      
+         * @return              An FTGlyph or <code>null</code> is it hasn't been
+         * loaded.
+         */
+        const FTGlyph* const Glyph( const unsigned int characterCode) const;
+
+        /**
+         * Get the bounding box for a character.
+         * @param characterCode The char code of the glyph NOT the glyph index      
+         */
+        FTBBox BBox( const unsigned int characterCode) const;
+        
+        /**
+        * Returns the kerned advance width for a glyph.
+        *
+        * @param characterCode     glyph index of the character
+        * @param nextCharacterCode the next glyph in a string
+        * @return                  advance width
+        */
+        float Advance( const unsigned int characterCode, const unsigned int nextCharacterCode);
+        
+        /**
+         * Renders a character
+         * @param characterCode      the glyph to be Rendered
+         * @param nextCharacterCode  the next glyph in the string. Used for kerning.
+         * @param penPosition        the position to Render the glyph
+         * @return                   The distance to advance the pen position after Rendering
+         */
+        FTPoint Render( const unsigned int characterCode, const unsigned int nextCharacterCode, FTPoint penPosition);
+        
+        /**
+         * Queries the Font for errors.
+         *
+         * @return  The current error code.
+         */
+        FT_Error Error() const { return err;}
+
+    private:
+        /**
+         * The FTGL face
+         */
+        FTFace* face;
+
+        /**
+         * The Character Map object associated with the current face
+         */
+        FTCharmap* charMap;
+
+        /**
+         * A structure to hold the glyphs
+         */
+        GlyphVector glyphs;
+
+        /**
+         * Current error code. Zero means no error.
+         */
+        FT_Error err;
+};
+
+
+#endif  //  __FTGlyphContainer__
diff --git a/extern/bFTGL/include/FTLibrary.h b/extern/bFTGL/include/FTLibrary.h
new file mode 100755
index 00000000000..1e5ed6b1a08
--- /dev/null
+++ b/extern/bFTGL/include/FTLibrary.h
@@ -0,0 +1,97 @@
+#ifndef     __FTLibrary__
+#define     __FTLibrary__
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+//#include FT_CACHE_H
+
+#include "FTGL.h"
+
+
+/**
+ * FTLibrary class is the global accessor for the Freetype library.
+ *
+ * This class encapsulates the Freetype Library. This is a singleton class
+ * and ensures that only one FT_Library is in existence at any one time.
+ * All constructors are private therefore clients cannot create or
+ * instantiate this class themselves and must access it's methods via the
+ * static <code>FTLibrary::Instance()</code> function.
+ *
+ * Just because this class returns a valid <code>FTLibrary</code> object
+ * doesn't mean that the Freetype Library has been successfully initialised.
+ * Clients should check for errors. You can initialse the library AND check
+ * for errors using the following code...
+ * <code>err = FTLibrary::Instance().Error();</code>
+ *
+ * @see "Freetype 2 Documentation"
+ *
+ */
+class FTGL_EXPORT FTLibrary
+{
+    public:
+        /**
+         * Global acces point to the single FTLibrary object.
+         * 
+         * @return  The global <code>FTLibrary</code> object.
+         */
+        static FTLibrary& Instance();
+
+        /**
+         * Gets a pointer to the native Freetype library.
+         * 
+         * @return A handle to a FreeType library instance. 
+         */
+        const FT_Library* const GetLibrary() const { return library;}
+        
+        /**
+         * Queries the library for errors.
+         *
+         * @return  The current error code.
+         */
+        FT_Error Error() const { return err;}
+        
+        /**
+         * Destructor
+         *
+         * Disposes of the Freetype library
+         */
+        ~FTLibrary();
+        
+    private:
+        /**
+         * Default constructors.
+         *
+         * Made private to stop clients creating there own FTLibrary
+         * objects.
+         */
+        FTLibrary();
+        FTLibrary( const FT_Library&){}
+        FTLibrary& operator=( const FT_Library&) { return *this; }
+        
+        /**
+         * Initialises the Freetype library
+         *
+         * Even though this function indicates success via the return value,
+         * clients can't see this so must check the error codes. This function
+         * is only ever called by the default c_stor
+         *
+         * @return  <code>true</code> if the Freetype library was
+         *          successfully initialised, <code>false</code>
+         *          otherwise.
+         */
+        bool Initialise();
+        
+        /**
+         * Freetype library handle.
+         */
+        FT_Library* library;
+//      FTC_Manager* manager;
+
+        /**
+         * Current error code. Zero means no error.
+         */
+        FT_Error err;
+        
+};
+
+#endif  //  __FTLibrary__
diff --git a/extern/bFTGL/include/FTList.h b/extern/bFTGL/include/FTList.h
new file mode 100644
index 00000000000..34992168103
--- /dev/null
+++ b/extern/bFTGL/include/FTList.h
@@ -0,0 +1,112 @@
+#ifndef    __FTList__
+#define    __FTList__
+
+#include "FTGL.h"
+
+/**
+* Provides a non-STL alternative to the STL list
+ */
+template <typename FT_LIST_ITEM_TYPE>
+class FTGL_EXPORT FTList
+{
+    public:
+        typedef FT_LIST_ITEM_TYPE value_type;
+        typedef value_type& reference;
+        typedef const value_type& const_reference;
+        typedef size_t size_type;
+
+        /**
+         * Constructor
+         */
+        FTList()
+        :   listSize(0),
+            tail(0)
+        {
+            tail = NULL;
+            head = new Node;
+        }
+
+        /**
+         * Destructor
+         */
+        ~FTList()
+        {
+            Node* next;
+            
+            for( Node *walk = head; walk; walk = next)
+            {
+                next = walk->next;
+                delete walk;
+            }
+        }
+
+        /**
+         * Get the number of items in the list
+         */
+        size_type size() const
+        {
+            return listSize;
+        }
+
+        /**
+         * Add an item to the end of the list
+         */
+        void push_back( const value_type& item)
+        {
+            Node* node = new Node( item);
+            
+            if( head->next == NULL)
+            {
+                head->next = node;
+            }
+
+            if( tail)
+            {
+                tail->next = node;
+            }
+            tail = node;
+            ++listSize;
+        }
+        
+        /**
+         * Get the item at the front of the list
+         */
+        reference front() const
+        {
+            return head->next->payload;
+        }
+
+        /**
+         * Get the item at the end of the list
+         */
+        reference back() const
+        {
+            return tail->payload;
+        }
+
+    private:
+        struct Node
+        {
+            Node()
+            :	next(NULL)
+            {}
+
+            Node( const value_type& item)
+            :	next(NULL)
+            {
+                payload = item;
+            }
+            
+            Node* next;
+            
+            value_type payload;
+        };
+        
+        size_type listSize;
+
+        Node* head;
+        Node* tail;
+};
+
+#endif // __FTList__
+
diff --git a/extern/bFTGL/include/FTOutlineGlyph.h b/extern/bFTGL/include/FTOutlineGlyph.h
new file mode 100644
index 00000000000..7dd0ba042b9
--- /dev/null
+++ b/extern/bFTGL/include/FTOutlineGlyph.h
@@ -0,0 +1,54 @@
+#ifndef		__FTOutlineGlyph__
+#define		__FTOutlineGlyph__
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#include FT_GLYPH_H
+
+#include "FTGL.h"
+#include "FTGlyph.h"
+
+class FTVectoriser;
+
+
+/**
+ * FTOutlineGlyph is a specialisation of FTGlyph for creating outlines.
+ * 
+ * @see FTGlyphContainer
+ * @see FTVectoriser
+ *
+ */
+class FTGL_EXPORT FTOutlineGlyph : public FTGlyph
+{
+    public:
+        /**
+         * Constructor. Sets the Error to Invalid_Outline if the glyphs isn't an outline.
+         *
+         * @param glyph The Freetype glyph to be processed
+         */
+        FTOutlineGlyph( FT_GlyphSlot glyph);
+
+        /**
+         * Destructor
+         */
+        virtual ~FTOutlineGlyph();
+
+        /**
+         * Renders this glyph at the current pen position.
+         *
+         * @param pen	The current pen position.
+         * @return		The advance distance for this glyph.
+         */
+        virtual float Render( const FTPoint& pen);
+        
+    private:		
+        /**
+         * OpenGL display list
+         */
+        GLuint glList;
+	
+};
+
+
+#endif	//	__FTOutlineGlyph__
+
diff --git a/extern/bFTGL/include/FTPixmapGlyph.h b/extern/bFTGL/include/FTPixmapGlyph.h
new file mode 100755
index 00000000000..9d43d6c58b3
--- /dev/null
+++ b/extern/bFTGL/include/FTPixmapGlyph.h
@@ -0,0 +1,68 @@
+#ifndef     __FTPixmapGlyph__
+#define     __FTPixmapGlyph__
+
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#include FT_GLYPH_H
+
+#include "FTGL.h"
+#include "FTGlyph.h"
+
+
+/**
+ * FTPixmapGlyph is a specialisation of FTGlyph for creating pixmaps.
+ * 
+ * @see FTGlyphContainer
+ *
+ */
+class  FTGL_EXPORT FTPixmapGlyph : public FTGlyph
+{
+    public:
+        /**
+         * Constructor
+         *
+         * @param glyph The Freetype glyph to be processed
+         */
+        FTPixmapGlyph( FT_GlyphSlot glyph);
+
+        /**
+         * Destructor
+         */
+        virtual ~FTPixmapGlyph();
+
+        /**
+         * Renders this glyph at the current pen position.
+         *
+         * @param pen   The current pen position.
+         * @return      The advance distance for this glyph.
+         */
+        virtual float Render( const FTPoint& pen);
+        
+        // attributes
+
+    private:
+        /**
+         * The width of the glyph 'image'
+         */
+        int destWidth;
+
+        /**
+         * The height of the glyph 'image'
+         */
+        int destHeight;
+        
+        /**
+         * Vector from the pen position to the topleft corner of the pixmap
+         */
+        FTPoint pos;
+        
+        /**
+         * Pointer to the 'image' data
+         */
+        unsigned char* data;
+        
+};
+
+
+#endif  //  __FTPixmapGlyph__
diff --git a/extern/bFTGL/include/FTPoint.h b/extern/bFTGL/include/FTPoint.h
new file mode 100755
index 00000000000..bb1772c4c18
--- /dev/null
+++ b/extern/bFTGL/include/FTPoint.h
@@ -0,0 +1,85 @@
+#ifndef     __FTPoint__
+#define     __FTPoint__
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#include FT_GLYPH_H
+
+#include "FTGL.h"
+
+/**
+ * FTPoint class is a basic 3 dimensional point or vector.
+ */
+class FTGL_EXPORT FTPoint
+{
+    public:
+        /**
+         * Default constructor. Point is set to zero.
+         */
+        FTPoint()
+        : x(0), y(0), z(0)
+        {}
+        
+        /**
+         * Constructor.
+         *
+         * @param X
+         * @param Y
+         * @param Z
+         */
+        FTPoint( const FTGL_DOUBLE X, const FTGL_DOUBLE Y, const FTGL_DOUBLE Z)
+        : x(X), y(Y), z(Z)
+        {}
+        
+        /**
+         * Constructor. This converts an FT_Vector to an FT_Point
+         *
+         * @param ft_vector A freetype vector
+         */
+        FTPoint( const FT_Vector& ft_vector)
+        : x(ft_vector.x), y(ft_vector.y), z(0)
+        {}
+        
+        /**
+         * Operator +=
+         *
+         * @param point
+         * @return this plus point.
+         */
+        FTPoint& operator += ( const FTPoint& point)
+        {
+            x += point.x;
+            y += point.y;
+            z += point.z;
+        
+            return *this;
+        }
+
+        /**
+         * Operator == Tests for eqaulity
+         *
+         * @param a
+         * @param b
+         * @return
+         */
+        friend bool operator == ( const FTPoint &a, const FTPoint &b);
+
+        /**
+         * Operator != Tests for non equality
+         *
+         * @param a
+         * @param b
+         * @return
+         */
+        friend bool operator != ( const FTPoint &a, const FTPoint &b);
+        
+        /**
+         * The point data
+         */
+        FTGL_DOUBLE x, y, z; // FIXME make private
+        
+    private:
+};
+
+#endif  //  __FTPoint__
+
diff --git a/extern/bFTGL/include/FTPolyGlyph.h b/extern/bFTGL/include/FTPolyGlyph.h
new file mode 100644
index 00000000000..c8faeffceb6
--- /dev/null
+++ b/extern/bFTGL/include/FTPolyGlyph.h
@@ -0,0 +1,55 @@
+#ifndef     __FTPolyGlyph__
+#define     __FTPolyGlyph__
+
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#include FT_GLYPH_H
+
+#include "FTGL.h"
+#include "FTGlyph.h"
+
+class FTVectoriser;
+
+/**
+ * FTPolyGlyph is a specialisation of FTGlyph for creating tessellated
+ * polygon glyphs.
+ * 
+ * @see FTGlyphContainer
+ * @see FTVectoriser
+ *
+ */
+class FTGL_EXPORT FTPolyGlyph : public FTGlyph
+{
+    public:
+        /**
+         * Constructor. Sets the Error to Invalid_Outline if the glyphs isn't an outline.
+         *
+         * @param glyph The Freetype glyph to be processed
+         */
+        FTPolyGlyph( FT_GlyphSlot glyph);
+
+        /**
+         * Destructor
+         */
+        virtual ~FTPolyGlyph();
+
+        /**
+         * Renders this glyph at the current pen position.
+         *
+         * @param pen   The current pen position.
+         * @return      The advance distance for this glyph.
+         */
+        virtual float Render( const FTPoint& pen);
+        
+    private:
+        /**
+         * OpenGL display list
+         */
+        GLuint glList;
+    
+};
+
+
+#endif  //  __FTPolyGlyph__
+
diff --git a/extern/bFTGL/include/FTSize.h b/extern/bFTGL/include/FTSize.h
new file mode 100755
index 00000000000..31f6bb66db1
--- /dev/null
+++ b/extern/bFTGL/include/FTSize.h
@@ -0,0 +1,132 @@
+#ifndef     __FTSize__
+#define     __FTSize__
+
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+#include "FTGL.h"
+
+
+
+/**
+ * FTSize class provides an abstraction layer for the Freetype Size.
+ *
+ * @see "Freetype 2 Documentation"
+ *
+ */
+class FTGL_EXPORT FTSize
+{
+    public:
+        /**
+         * Default Constructor
+         */
+         FTSize();
+        
+        /**
+         * Destructor
+         */
+        virtual ~FTSize();
+        
+        /**
+         * Sets the char size for the current face.
+         *
+         * This doesn't guarantee that the size was set correctly. Clients
+         * should check errors.
+         *
+         * @param face           Parent face for this size object
+         * @param point_size     the face size in points (1/72 inch)
+         * @param x_resolution   the horizontal resolution of the target device.
+         * @param y_resolution   the vertical resolution of the target device.
+         * @return          <code>true</code> if the size has been set. Clients should check Error() for more information if this function returns false()
+         */
+        bool CharSize( FT_Face* face, unsigned int point_size, unsigned int x_resolution, unsigned int y_resolution);
+        
+        /**
+         * get the char size for the current face.
+         *
+         * @return The char size in points
+         */
+        unsigned int CharSize() const;
+        
+        /**
+         * Gets the global ascender height for the face in pixels.
+         *
+         * @return  Ascender height
+         */
+        float Ascender() const;
+        
+        /**
+         * Gets the global descender height for the face in pixels.
+         *
+         * @return  Ascender height
+         */
+        float Descender() const;
+        
+        /**
+         * Gets the global face height for the face.
+         *
+         * If the face is scalable this returns the height of the global
+         * bounding box which ensures that any glyph will be less than or
+         * equal to this height. If the font isn't scalable there is no
+         * guarantee that glyphs will not be taller than this value.
+         *
+         * @return  height in pixels.
+         */
+        float Height() const;
+        
+        /**
+         * Gets the global face width for the face.
+         *
+         * If the face is scalable this returns the width of the global
+         * bounding box which ensures that any glyph will be less than or
+         * equal to this width. If the font isn't scalable this value is
+         * the max_advance for the face.
+         *
+         * @return  width in pixels.
+         */
+        float Width() const;
+        
+        /**
+         * Gets the underline position for the face.
+         *
+         * @return  underline position in pixels
+         */
+        float Underline() const;
+
+        unsigned int XPixelsPerEm() const;
+
+        unsigned int YPixelsPerEm() const;
+
+        /**
+         * Queries for errors.
+         *
+         * @return  The current error code.
+         */
+        FT_Error Error() const { return err; }
+        
+    private:
+        /**
+         * The current Freetype face that this FTSize object relates to.
+         */
+        FT_Face* ftFace;
+        
+        /**
+         *  The Freetype size.
+         */
+        FT_Size ftSize;
+        
+        /**
+         *  The size in points.
+         */
+        unsigned int size;
+        
+        /**
+         * Current error code. Zero means no error.
+         */
+        FT_Error err;
+        
+};
+
+#endif  //  __FTSize__
+
diff --git a/extern/bFTGL/include/FTTextureGlyph.h b/extern/bFTGL/include/FTTextureGlyph.h
new file mode 100755
index 00000000000..389e6f778da
--- /dev/null
+++ b/extern/bFTGL/include/FTTextureGlyph.h
@@ -0,0 +1,89 @@
+#ifndef     __FTTextureGlyph__
+#define     __FTTextureGlyph__
+
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#include FT_GLYPH_H
+
+#include "FTGL.h"
+#include "FTGlyph.h"
+
+
+/**
+ * FTTextureGlyph is a specialisation of FTGlyph for creating texture
+ * glyphs.
+ * 
+ * @see FTGlyphContainer
+ *
+ */
+class FTGL_EXPORT FTTextureGlyph : public FTGlyph
+{
+    public:
+        /**
+         * Constructor
+         *
+         * @param glyph     The Freetype glyph to be processed
+         * @param id        The id of the texture that this glyph will be
+         *                  drawn in
+         * @param xOffset   The x offset into the parent texture to draw
+         *                  this glyph
+         * @param yOffset   The y offset into the parent texture to draw
+         *                  this glyph
+         * @param width     The width of the parent texture
+         * @param height    The height (number of rows) of the parent texture
+         */
+        FTTextureGlyph( FT_GlyphSlot glyph, int id, int xOffset, int yOffset, GLsizei width, GLsizei height);
+
+        /**
+         * Destructor
+         */
+        virtual ~FTTextureGlyph();
+
+        /**
+         * Renders this glyph at the current pen position.
+         *
+         * @param pen   The current pen position.
+         * @return      The advance distance for this glyph.
+         */
+        virtual float Render( const FTPoint& pen);
+        
+    private:
+        /**
+         * The width of the glyph 'image'
+         */
+        int destWidth;
+
+        /**
+         * The height of the glyph 'image'
+         */
+        int destHeight;
+
+        /**
+         * Vector from the pen position to the topleft corner of the pixmap
+         */
+        FTPoint pos;
+        
+        /**
+         * The texture co-ords of this glyph within the texture.
+         */
+        FTPoint uv[2];
+        
+        /**
+         * The texture index that this glyph is contained in.
+         */
+        int glTextureID;
+
+        /**
+         * The texture index of the currently active texture
+         *
+         * We call glGetIntegerv( GL_TEXTURE_2D_BINDING, activeTextureID);
+         * to get the currently active texture to try to reduce the number
+         * of texture bind operations
+         */
+        GLint activeTextureID;
+        
+};
+
+
+#endif  //  __FTTextureGlyph__
diff --git a/extern/bFTGL/include/FTVector.h b/extern/bFTGL/include/FTVector.h
new file mode 100644
index 00000000000..6147f522c08
--- /dev/null
+++ b/extern/bFTGL/include/FTVector.h
@@ -0,0 +1,190 @@
+#ifndef    __FTVector__
+#define    __FTVector__
+
+#include "FTGL.h"
+
+/**
+ * Provides a non-STL alternative to the STL vector
+ */
+template <typename FT_VECTOR_ITEM_TYPE>
+class FTGL_EXPORT FTVector
+{
+    public:
+        typedef FT_VECTOR_ITEM_TYPE value_type;
+        typedef value_type& reference;
+        typedef const value_type& const_reference;
+        typedef value_type* iterator;
+        typedef const value_type* const_iterator;
+        typedef size_t size_type;
+        
+        FTVector()
+        {
+            Capacity = Size = 0;
+            Items = 0;
+        }
+
+        
+        virtual ~FTVector()
+        {
+            clear();
+        }
+        
+        FTVector& operator =(const FTVector& v)
+        {
+            reserve(v.capacity());
+            
+            iterator ptr = begin();
+            const_iterator vbegin = v.begin();
+            const_iterator vend = v.end();
+            
+            while( vbegin != vend)
+            {
+                *ptr++ = *vbegin++;
+            }
+            
+            Size = v.size();
+            return *this;
+        }
+        
+        size_type size() const
+        {
+            return Size;
+        }
+        
+        size_type capacity() const
+        {
+            return Capacity;
+        }
+        
+        iterator begin()
+        {
+            return Items;
+        }
+        
+        const_iterator begin() const
+        {
+            return Items;
+        }
+        
+        iterator end()
+        {
+            return begin() + size(); 
+        }
+        
+        const_iterator end() const
+        {
+            return begin() + size(); 
+        }
+        
+        bool empty() const 
+        { 
+            return size() == 0; 
+        }
+
+        reference operator [](size_type pos) 
+        { 
+            return( *(begin() + pos)); 
+        }
+
+        const_reference operator []( size_type pos) const 
+        { 
+            return( *(begin() + pos)); 
+        }
+        
+        void clear()
+        {
+            if( Capacity)
+            {
+                delete [] Items;
+                Capacity = Size = 0;
+                Items = 0;
+            }
+        }
+
+        void reserve( size_type n)
+        {
+            if( capacity() < n)
+            {
+                expand(n);
+            }
+        }
+
+        void push_back(const value_type& x)
+        {
+            if( size() == capacity())
+            {
+                expand();
+            }
+           
+           ( *this)[size()] = x;
+            ++Size;
+        }
+
+        void resize(size_type n, value_type x)
+        {
+            if( n == size())
+            {
+                return;
+            }
+            
+            reserve(n);
+            iterator begin, end;
+            
+            if( n >= Size)
+            {
+                begin = this->end();
+                end = this->begin() + n;
+            }
+            else
+            {
+                begin = this->begin() + n;
+                end = this->end();
+            }
+        
+            while( begin != end)
+            {
+                *begin++ = x;
+            }
+        
+            Size = n;
+        }
+
+        
+    private:
+        void expand(size_type capacity_hint = 0)
+        {
+            size_type new_capacity =( capacity() == 0) ? 256 : capacity()* 2;
+            if( capacity_hint)
+            {
+                while( new_capacity < capacity_hint)
+                {
+                    new_capacity *= 2;
+                }
+            }
+            
+            value_type *new_items = new value_type[new_capacity];
+            
+            iterator begin = this->begin();
+            iterator end = this->end();
+            value_type *ptr = new_items;
+            
+            while( begin != end)
+            {
+                *ptr++ = *begin++;
+            }
+            
+            if( Capacity)
+            {
+                delete [] Items;
+            }
+        
+            Items = new_items;
+            Capacity = new_capacity;
+        }
+
+        size_type Capacity;
+        size_type Size;
+        value_type* Items;
+};
+
+#endif  //  __FTVector__
diff --git a/extern/bFTGL/include/FTVectoriser.h b/extern/bFTGL/include/FTVectoriser.h
new file mode 100644
index 00000000000..7150560ce07
--- /dev/null
+++ b/extern/bFTGL/include/FTVectoriser.h
@@ -0,0 +1,275 @@
+#ifndef     __FTVectoriser__
+#define     __FTVectoriser__
+
+
+#include "FTContour.h"
+#include "FTList.h"
+#include "FTPoint.h"
+#include "FTVector.h"
+#include "FTGL.h"
+
+
+#ifndef CALLBACK
+#define CALLBACK
+#endif
+
+
+/**
+ * FTTesselation captures points that are output by OpenGL's gluTesselator.
+ */
+class FTGL_EXPORT FTTesselation
+{
+    public:
+        /**
+         * Default constructor
+         */
+        FTTesselation( GLenum m)
+        :	meshType(m)
+        {
+            pointList.reserve( 128);
+        }
+
+        /**
+         *  Destructor
+         */
+        ~FTTesselation()
+        {
+            pointList.clear();
+        }
+
+        /**
+         * Add a point to the mesh.
+         */
+        void AddPoint( const FTGL_DOUBLE x, const FTGL_DOUBLE y, const FTGL_DOUBLE z)
+        {   
+            pointList.push_back( FTPoint( x, y, z));
+        }
+
+        /**
+         * The number of points in this mesh
+         */
+        size_t PointCount() const { return pointList.size();}
+        
+        /**
+         *
+         */
+        const FTPoint& Point( unsigned int index) const { return pointList[index];}
+        
+        /**
+         * Return the OpenGL polygon type.
+         */
+        GLenum PolygonType() const { return meshType;}
+        
+    private:
+        /**
+         * Points generated by gluTesselator.
+         */
+        typedef FTVector<FTPoint> PointVector;
+        PointVector pointList;
+
+        /**
+         * OpenGL primitive type from gluTesselator.
+         */
+        GLenum meshType;
+};
+
+
+/**
+ * FTMesh is a container of FTTesselation's that make up a polygon glyph
+ */
+class FTGL_EXPORT FTMesh
+{
+	typedef FTVector<FTTesselation*> TesselationVector;
+	typedef FTList<FTPoint> PointList;
+
+    public:
+        /**
+         * Default constructor
+         */
+        FTMesh();
+
+        /**
+         *  Destructor
+         */
+        ~FTMesh();
+        
+        /**
+         *
+         */
+        void AddPoint( const FTGL_DOUBLE x, const FTGL_DOUBLE y, const FTGL_DOUBLE z);
+        
+        /**
+         *
+         */
+        FTGL_DOUBLE* Combine( const FTGL_DOUBLE x, const FTGL_DOUBLE y, const FTGL_DOUBLE z);
+        
+        /**
+         *
+         */
+        void Begin( GLenum meshType);
+        
+        /**
+         *
+         */
+        void End();
+        
+        /**
+         *
+         */
+        void Error( GLenum e) { err = e;}
+        
+        /**
+         *
+         */
+        unsigned int TesselationCount() const { return tesselationList.size();}
+
+        /**
+         *
+         */
+        const FTTesselation* const Tesselation( unsigned int index) const;
+        
+        /**
+         *
+         */
+        const PointList& TempPointList() const { return tempPointList;}
+
+        /**
+         * Get the GL ERROR returned by the glu tesselator
+         */
+        GLenum Error() const { return err;}
+
+    private:
+        /**
+         * The current sub mesh that we are constructing.
+         */
+        FTTesselation* currentTesselation;
+        
+        /**
+         * Holds each sub mesh that comprises this glyph.
+         */
+        TesselationVector tesselationList;
+        
+        /**
+         * Holds extra points created by gluTesselator. See ftglCombine.
+         */
+        PointList tempPointList;
+        
+        /**
+         * GL ERROR returned by the glu tesselator
+         */
+        GLenum err;
+
+};
+
+const FTGL_DOUBLE FTGL_FRONT_FACING = 1.0;
+const FTGL_DOUBLE FTGL_BACK_FACING = -1.0;
+
+/**
+ * FTVectoriser class is a helper class that converts font outlines into
+ * point data.
+ *
+ * @see FTExtrdGlyph
+ * @see FTOutlineGlyph
+ * @see FTPolyGlyph
+ * @see FTContour
+ * @see FTPoint
+ *
+ */
+class FTGL_EXPORT FTVectoriser
+{
+    public:
+        /**
+         * Constructor
+         *
+         * @param glyph The freetype glyph to be processed
+         */
+        FTVectoriser( const FT_GlyphSlot glyph);
+
+        /**
+         *  Destructor
+         */
+        virtual ~FTVectoriser();
+
+        /**
+         * Build an FTMesh from the vector outline data. 
+         *
+         * @param zNormal   The direction of the z axis of the normal
+         *                  for this mesh
+         */
+        void MakeMesh( FTGL_DOUBLE zNormal = FTGL_FRONT_FACING);
+        
+        /**
+         * Get the current mesh.
+         */
+        const FTMesh* const GetMesh() const { return mesh;}
+        
+        /**
+         * Get the total count of points in this outline
+         *
+         * @return the number of points
+         */
+        size_t PointCount();
+
+        /**
+         * Get the count of contours in this outline
+         *
+         * @return the number of contours
+         */
+        size_t ContourCount() const { return ftContourCount;}
+
+        /**
+         * Return a contour at index
+         *
+         * @return the number of contours
+         */
+         const FTContour* const Contour( unsigned int index) const;
+
+        /**
+         * Get the number of points in a specific contour in this outline
+         *
+         * @param c     The contour index
+         * @return      the number of points in contour[c]
+         */
+        size_t ContourSize( int c) const { return contourList[c]->PointCount();}
+
+        /**
+         * Get the flag for the tesselation rule for this outline
+         *
+         * @return The contour flag
+         */
+        int ContourFlag() const { return contourFlag;}
+        
+    private:
+        /**
+         * Process the freetype outline data into contours of points
+         */
+        void ProcessContours();
+
+        /**
+         * The list of contours in the glyph
+         */
+        FTContour** contourList;
+
+        /**
+         * A Mesh for tesselations
+         */
+        FTMesh* mesh;
+        
+        /**
+         * The number of contours reported by Freetype
+         */
+        short ftContourCount;
+
+        /**
+         * A flag indicating the tesselation rule for the glyph
+         */
+        int contourFlag;
+
+        /**
+         * A Freetype outline
+         */
+        FT_Outline outline;
+};
+
+
+#endif  //  __FTVectoriser__
diff --git a/extern/bFTGL/license.txt b/extern/bFTGL/license.txt
new file mode 100644
index 00000000000..b9fd0dbb580
--- /dev/null
+++ b/extern/bFTGL/license.txt
@@ -0,0 +1,27 @@
+FTGL
+
+Herewith is a license. I've also chucked in a gnu (see COPYING.txt) license
+for those that are that way inclined. Basically I want you to use this
+software and if you think this license is preventing you from doing so
+let me know. 
+
+Copyright (C) 2001-3 Henry Maddocks
+
+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.
diff --git a/extern/bFTGL/src/FTBitmapGlyph.cpp b/extern/bFTGL/src/FTBitmapGlyph.cpp
new file mode 100755
index 00000000000..5db33f10c79
--- /dev/null
+++ b/extern/bFTGL/src/FTBitmapGlyph.cpp
@@ -0,0 +1,66 @@
+#include    <string>
+
+#include "FTBitmapGlyph.h"
+
+FTBitmapGlyph::FTBitmapGlyph( FT_GlyphSlot glyph)
+:   FTGlyph( glyph),
+    destWidth(0),
+    destHeight(0),
+    data(0)
+{
+    err = FT_Render_Glyph( glyph, FT_RENDER_MODE_MONO);
+    if( err || ft_glyph_format_bitmap != glyph->format)
+    {
+        return;
+    }
+
+    FT_Bitmap bitmap = glyph->bitmap;
+
+    unsigned int srcWidth = bitmap.width;
+    unsigned int srcHeight = bitmap.rows;
+    unsigned int srcPitch = bitmap.pitch;
+    
+    destWidth = srcWidth;
+    destHeight = srcHeight;
+    destPitch = srcPitch;    
+
+    if( destWidth && destHeight)
+    {
+        data = new unsigned char[destPitch * destHeight];
+        unsigned char* dest = data + (( destHeight - 1) * destPitch);
+
+        unsigned char* src = bitmap.buffer;
+
+        for( unsigned int y = 0; y < srcHeight; ++y)
+        {
+            memcpy( dest, src, srcPitch);
+            dest -= destPitch;
+            src += srcPitch;
+        }
+    }
+    
+    pos.x = glyph->bitmap_left;
+    pos.y = static_cast<int>(srcHeight) - glyph->bitmap_top;
+}
+
+
+FTBitmapGlyph::~FTBitmapGlyph()
+{
+    delete [] data;
+}
+
+
+float FTBitmapGlyph::Render( const FTPoint& pen)
+{
+    if( data)
+    {
+        glBitmap( 0, 0, 0.0, 0.0, pen.x + pos.x, pen.y - pos.y, (const GLubyte*)0 );
+
+        glPixelStorei( GL_UNPACK_ROW_LENGTH, destPitch * 8);
+        glBitmap( destWidth, destHeight, 0.0f, 0.0, 0.0, 0.0, (const GLubyte*)data);
+
+        glBitmap( 0, 0, 0.0, 0.0, -pen.x - pos.x, -pen.y + pos.y, (const GLubyte*)0 );
+    }
+    
+    return advance;
+}
diff --git a/extern/bFTGL/src/FTBufferGlyph.cpp b/extern/bFTGL/src/FTBufferGlyph.cpp
new file mode 100755
index 00000000000..27310103152
--- /dev/null
+++ b/extern/bFTGL/src/FTBufferGlyph.cpp
@@ -0,0 +1,59 @@
+#include    "FTBufferGlyph.h"
+
+FTBufferGlyph::FTBufferGlyph( FT_GlyphSlot glyph, unsigned char* b)
+:   FTGlyph( glyph),
+    destWidth(0),
+    destHeight(0),
+    data(0),
+    buffer(b)
+{
+    err = FT_Render_Glyph( glyph, FT_RENDER_MODE_NORMAL);
+    if( err || ft_glyph_format_bitmap != glyph->format)
+    {
+        return;
+    }
+
+    FT_Bitmap bitmap = glyph->bitmap;
+
+    unsigned int srcWidth = bitmap.width;
+    unsigned int srcHeight = bitmap.rows;
+    unsigned int srcPitch = bitmap.pitch;
+    
+    destWidth = srcWidth;
+    destHeight = srcHeight;
+    destPitch = srcPitch;    
+
+    if( destWidth && destHeight)
+    {
+        data = new unsigned char[destPitch * destHeight];
+        unsigned char* dest = data + (( destHeight - 1) * destPitch);
+
+        unsigned char* src = bitmap.buffer;
+
+        for( unsigned int y = 0; y < srcHeight; ++y)
+        {
+            memcpy( dest, src, srcPitch);
+            dest -= destPitch;
+            src += srcPitch;
+        }
+    }
+
+    pos.x = glyph->bitmap_left;
+    pos.y = srcHeight - glyph->bitmap_top;
+}
+
+
+FTBufferGlyph::~FTBufferGlyph()
+{
+    delete [] data;
+}
+
+
+float FTBufferGlyph::Render( const FTPoint& pen)
+{
+    if( data && buffer)
+    {
+    }
+
+    return advance;
+}
diff --git a/extern/bFTGL/src/FTCharmap.cpp b/extern/bFTGL/src/FTCharmap.cpp
new file mode 100644
index 00000000000..f2400eea0f6
--- /dev/null
+++ b/extern/bFTGL/src/FTCharmap.cpp
@@ -0,0 +1,62 @@
+#include "FTFace.h"
+#include "FTCharmap.h"
+
+
+FTCharmap::FTCharmap( FTFace* face)
+:   ftFace( *(face->Face())),
+    err(0)
+{
+    if( !ftFace->charmap)
+    {
+        err = FT_Set_Charmap( ftFace, ftFace->charmaps[0]);
+    }
+    
+    ftEncoding = ftFace->charmap->encoding;
+}
+
+
+FTCharmap::~FTCharmap()
+{
+    charMap.clear();
+}
+
+
+bool FTCharmap::CharMap( FT_Encoding encoding)
+{
+    if( ftEncoding == encoding)
+    {
+        return true;
+    }
+    
+    err = FT_Select_Charmap( ftFace, encoding );
+    
+    if( !err)
+    {
+        ftEncoding = encoding;
+    }
+    else
+    {
+        ftEncoding = ft_encoding_none;
+    }
+        
+    charMap.clear();
+    return !err;
+}
+
+
+unsigned int FTCharmap::GlyphListIndex( unsigned int characterCode )
+{
+    return charMap.find( characterCode);
+}
+
+
+unsigned int FTCharmap::FontIndex( unsigned int characterCode )
+{
+    return FT_Get_Char_Index( ftFace, characterCode);
+}
+
+
+void FTCharmap::InsertIndex( const unsigned int characterCode, const unsigned int containerIndex)
+{
+    charMap.insert( characterCode, containerIndex);
+}
diff --git a/extern/bFTGL/src/FTContour.cpp b/extern/bFTGL/src/FTContour.cpp
new file mode 100644
index 00000000000..6b0cf8a23e1
--- /dev/null
+++ b/extern/bFTGL/src/FTContour.cpp
@@ -0,0 +1,149 @@
+#include "FTContour.h"
+
+static const float BEZIER_STEP_SIZE = 0.2f;
+
+
+void FTContour::AddPoint( FTPoint point)
+{
+    if( pointList.empty() || point != pointList[pointList.size() - 1])
+    {
+        pointList.push_back( point);
+    }
+}
+
+
+void FTContour::AddPoint( float x, float y)
+{
+    AddPoint( FTPoint( x, y, 0.0f));
+}
+
+
+void FTContour::evaluateQuadraticCurve()
+{
+    for( unsigned int i = 0; i <= ( 1.0f / BEZIER_STEP_SIZE); i++)
+    {
+        float bezierValues[2][2];
+
+        float t = static_cast<float>(i) * BEZIER_STEP_SIZE;
+
+        bezierValues[0][0] = (1.0f - t) * controlPoints[0][0] + t * controlPoints[1][0];
+        bezierValues[0][1] = (1.0f - t) * controlPoints[0][1] + t * controlPoints[1][1];
+    
+        bezierValues[1][0] = (1.0f - t) * controlPoints[1][0] + t * controlPoints[2][0];
+        bezierValues[1][1] = (1.0f - t) * controlPoints[1][1] + t * controlPoints[2][1];
+        
+        bezierValues[0][0] = (1.0f - t) * bezierValues[0][0] + t * bezierValues[1][0];
+        bezierValues[0][1] = (1.0f - t) * bezierValues[0][1] + t * bezierValues[1][1];
+    
+        AddPoint( bezierValues[0][0], bezierValues[0][1]);
+    }
+}
+
+void FTContour::evaluateCubicCurve()
+{
+    for( unsigned int i = 0; i <= ( 1.0f / BEZIER_STEP_SIZE); i++)
+    {
+        float bezierValues[3][2];
+
+        float t = static_cast<float>(i) * BEZIER_STEP_SIZE;
+
+        bezierValues[0][0] = (1.0f - t) * controlPoints[0][0] + t * controlPoints[1][0];
+        bezierValues[0][1] = (1.0f - t) * controlPoints[0][1] + t * controlPoints[1][1];
+    
+        bezierValues[1][0] = (1.0f - t) * controlPoints[1][0] + t * controlPoints[2][0];
+        bezierValues[1][1] = (1.0f - t) * controlPoints[1][1] + t * controlPoints[2][1];
+        
+        bezierValues[2][0] = (1.0f - t) * controlPoints[2][0] + t * controlPoints[3][0];
+        bezierValues[2][1] = (1.0f - t) * controlPoints[2][1] + t * controlPoints[3][1];
+        
+        bezierValues[0][0] = (1.0f - t) * bezierValues[0][0] + t * bezierValues[1][0];
+        bezierValues[0][1] = (1.0f - t) * bezierValues[0][1] + t * bezierValues[1][1];
+    
+        bezierValues[1][0] = (1.0f - t) * bezierValues[1][0] + t * bezierValues[2][0];
+        bezierValues[1][1] = (1.0f - t) * bezierValues[1][1] + t * bezierValues[2][1];
+        
+        bezierValues[0][0] = (1.0f - t) * bezierValues[0][0] + t * bezierValues[1][0];
+        bezierValues[0][1] = (1.0f - t) * bezierValues[0][1] + t * bezierValues[1][1];
+    
+        AddPoint( bezierValues[0][0], bezierValues[0][1]);
+    }
+}
+
+
+FTContour::FTContour( FT_Vector* contour, char* pointTags, unsigned int numberOfPoints)
+{
+    for( unsigned int pointIndex = 0; pointIndex < numberOfPoints; ++ pointIndex)
+    {
+        char pointTag = pointTags[pointIndex];
+        
+        if( pointTag == FT_Curve_Tag_On || numberOfPoints < 2)
+        {
+            AddPoint( contour[pointIndex].x, contour[pointIndex].y);
+            continue;
+        }
+        
+        FTPoint controlPoint( contour[pointIndex]);
+        FTPoint previousPoint = ( 0 == pointIndex)
+                                ? FTPoint( contour[numberOfPoints - 1])
+                                : pointList[pointList.size() - 1];
+
+        FTPoint nextPoint = ( pointIndex == numberOfPoints - 1)
+                            ? pointList[0]
+                            : FTPoint( contour[pointIndex + 1]);
+
+        if( pointTag == FT_Curve_Tag_Conic)
+        {
+            char nextPointTag = ( pointIndex == numberOfPoints - 1)
+                                ? pointTags[0]
+                                : pointTags[pointIndex + 1];
+            
+            while( nextPointTag == FT_Curve_Tag_Conic)
+            {
+                nextPoint = FTPoint( static_cast<float>( controlPoint.x + nextPoint.x) * 0.5f,
+                                     static_cast<float>( controlPoint.y + nextPoint.y) * 0.5f,
+                                     0);
+
+                controlPoints[0][0] = previousPoint.x; controlPoints[0][1] = previousPoint.y;
+                controlPoints[1][0] = controlPoint.x;  controlPoints[1][1] = controlPoint.y;
+                controlPoints[2][0] = nextPoint.x;     controlPoints[2][1] = nextPoint.y;
+                
+                evaluateQuadraticCurve();
+                ++pointIndex;
+                
+                previousPoint = nextPoint;
+                controlPoint = FTPoint( contour[pointIndex]);
+                nextPoint = ( pointIndex == numberOfPoints - 1)
+                            ? pointList[0]
+                            : FTPoint( contour[pointIndex + 1]);
+                nextPointTag = ( pointIndex == numberOfPoints - 1)
+                               ? pointTags[0]
+                               : pointTags[pointIndex + 1];
+            }
+            
+            controlPoints[0][0] = previousPoint.x; controlPoints[0][1] = previousPoint.y;
+            controlPoints[1][0] = controlPoint.x;  controlPoints[1][1] = controlPoint.y;
+            controlPoints[2][0] = nextPoint.x;     controlPoints[2][1] = nextPoint.y;
+            
+            evaluateQuadraticCurve();
+            continue;
+        }
+
+        if( pointTag == FT_Curve_Tag_Cubic)
+        {
+            FTPoint controlPoint2 = nextPoint;
+            
+            FTPoint nextPoint = ( pointIndex == numberOfPoints - 2)
+                                ? pointList[0]
+                                : FTPoint( contour[pointIndex + 2]);
+            
+            controlPoints[0][0] = previousPoint.x; controlPoints[0][1] = previousPoint.y;
+            controlPoints[1][0] = controlPoint.x;  controlPoints[1][1] = controlPoint.y;
+            controlPoints[2][0] = controlPoint2.x; controlPoints[2][1] = controlPoint2.y;
+            controlPoints[3][0] = nextPoint.x;     controlPoints[3][1] = nextPoint.y;
+        
+            evaluateCubicCurve();
+            ++pointIndex;
+            continue;
+        }
+    }
+}
diff --git a/extern/bFTGL/src/FTExtrdGlyph.cpp b/extern/bFTGL/src/FTExtrdGlyph.cpp
new file mode 100644
index 00000000000..0b120e68709
--- /dev/null
+++ b/extern/bFTGL/src/FTExtrdGlyph.cpp
@@ -0,0 +1,141 @@
+#include    <math.h>
+
+#include    "FTExtrdGlyph.h"
+#include    "FTVectoriser.h"
+
+
+FTExtrdGlyph::FTExtrdGlyph( FT_GlyphSlot glyph, float d)
+:   FTGlyph( glyph),
+    glList(0),
+    depth(d)
+{
+    bBox.SetDepth( -depth);
+        
+    if( ft_glyph_format_outline != glyph->format)
+    {
+        err = 0x14; // Invalid_Outline
+        return;
+    }
+
+    FTVectoriser vectoriser( glyph);
+    if ( ( vectoriser.ContourCount() < 1) || ( vectoriser.PointCount() < 3))
+    {
+        return;
+    }
+
+    unsigned int tesselationIndex;
+    glList = glGenLists(1);
+    glNewList( glList, GL_COMPILE);
+
+        vectoriser.MakeMesh( 1.0);
+        glNormal3d(0.0, 0.0, 1.0);
+        
+        const FTMesh* mesh = vectoriser.GetMesh();
+        for( tesselationIndex = 0; tesselationIndex < mesh->TesselationCount(); ++tesselationIndex)
+        {
+            const FTTesselation* subMesh = mesh->Tesselation( tesselationIndex);
+            unsigned int polyonType = subMesh->PolygonType();
+
+            glBegin( polyonType);
+                for( unsigned int pointIndex = 0; pointIndex < subMesh->PointCount(); ++pointIndex)
+                {
+                    glVertex3f( subMesh->Point( pointIndex).x / 64.0f,
+                                subMesh->Point( pointIndex).y / 64.0f,
+                                0.0f);
+                }
+            glEnd();
+        }
+        
+        vectoriser.MakeMesh( -1.0);
+        glNormal3d(0.0, 0.0, -1.0);
+        
+        mesh = vectoriser.GetMesh();
+        for( tesselationIndex = 0; tesselationIndex < mesh->TesselationCount(); ++tesselationIndex)
+        {
+            const FTTesselation* subMesh = mesh->Tesselation( tesselationIndex);
+            unsigned int polyonType = subMesh->PolygonType();
+
+            glBegin( polyonType);
+                for( unsigned int pointIndex = 0; pointIndex < subMesh->PointCount(); ++pointIndex)
+                {
+                    glVertex3f( subMesh->Point( pointIndex).x / 64.0f,
+                                subMesh->Point( pointIndex).y / 64.0f,
+                                -depth);
+                }
+            glEnd();
+        }
+        
+        int contourFlag = vectoriser.ContourFlag();
+        
+        for( size_t c = 0; c < vectoriser.ContourCount(); ++c)
+        {
+            const FTContour* contour = vectoriser.Contour(c);
+            unsigned int numberOfPoints = contour->PointCount();
+            
+            glBegin( GL_QUAD_STRIP);
+                for( unsigned int j = 0; j <= numberOfPoints; ++j)
+                {
+                    unsigned int index = ( j == numberOfPoints) ? 0 : j;
+                    unsigned int nextIndex = ( index == numberOfPoints - 1) ? 0 : index + 1;
+                    
+                    FTPoint normal = GetNormal( contour->Point(index), contour->Point(nextIndex));
+                    glNormal3f( normal.x, normal.y, 0.0f);
+                    
+                    if( contourFlag & ft_outline_reverse_fill)
+                    {
+                        glVertex3f( contour->Point(index).x / 64.0f, contour->Point(index).y / 64.0f, 0.0f);
+                        glVertex3f( contour->Point(index).x / 64.0f, contour->Point(index).y / 64.0f, -depth);
+                    }
+                    else
+                    {
+                        glVertex3f( contour->Point(index).x / 64.0f, contour->Point(index).y / 64.0f, -depth);
+                        glVertex3f( contour->Point(index).x / 64.0f, contour->Point(index).y / 64.0f, 0.0f);
+                    }
+                }
+            glEnd();
+        }
+        
+    glEndList();
+}
+
+
+FTExtrdGlyph::~FTExtrdGlyph()
+{
+    glDeleteLists( glList, 1);
+}
+
+
+float FTExtrdGlyph::Render( const FTPoint& pen)
+{
+    if( glList)
+    {
+        glTranslatef( pen.x, pen.y, 0);
+            glCallList( glList);    
+        glTranslatef( -pen.x, -pen.y, 0);
+    }
+    
+    return advance;
+}
+
+
+FTPoint FTExtrdGlyph::GetNormal( const FTPoint &a, const FTPoint &b)
+{
+    float vectorX = a.x - b.x;
+    float vectorY = a.y - b.y;
+                              
+    float length = sqrt( vectorX * vectorX + vectorY * vectorY );
+    
+    if( length > 0.0f)
+    {
+        length = 1 / length;
+    }
+    else
+    {
+        length = 0.0f;
+    }
+    
+    return FTPoint( -vectorY * length,
+                     vectorX * length,
+                     0.0f);
+}
+
diff --git a/extern/bFTGL/src/FTFace.cpp b/extern/bFTGL/src/FTFace.cpp
new file mode 100755
index 00000000000..0385e234d6c
--- /dev/null
+++ b/extern/bFTGL/src/FTFace.cpp
@@ -0,0 +1,154 @@
+#include "FTFace.h"
+#include "FTLibrary.h"
+
+#include FT_TRUETYPE_TABLES_H
+
+FTFace::FTFace( const char* filename)
+:   numGlyphs(0),
+    fontEncodingList(0),
+    err(0)
+{
+    const FT_Long DEFAULT_FACE_INDEX = 0;
+    ftFace = new FT_Face;
+
+    err = FT_New_Face( *FTLibrary::Instance().GetLibrary(), filename, DEFAULT_FACE_INDEX, ftFace);
+
+    if( err)
+    {
+        delete ftFace;
+        ftFace = 0;
+    }
+    else
+    {
+        numGlyphs = (*ftFace)->num_glyphs;
+    }
+}
+
+
+FTFace::FTFace( const unsigned char *pBufferBytes, size_t bufferSizeInBytes)
+:   numGlyphs(0),
+    err(0)
+{
+    const FT_Long DEFAULT_FACE_INDEX = 0;
+    ftFace = new FT_Face;
+
+    err = FT_New_Memory_Face( *FTLibrary::Instance().GetLibrary(), (FT_Byte *)pBufferBytes, bufferSizeInBytes, DEFAULT_FACE_INDEX, ftFace);
+
+    if( err)
+    {
+        delete ftFace;
+        ftFace = 0;
+    }
+    else
+    {
+        numGlyphs = (*ftFace)->num_glyphs;
+    }
+}
+
+
+FTFace::~FTFace()
+{
+    Close();
+}
+
+
+bool FTFace::Attach( const char* filename)
+{
+    err = FT_Attach_File( *ftFace, filename);
+    return !err;
+}
+
+
+bool FTFace::Attach( const unsigned char *pBufferBytes, size_t bufferSizeInBytes)
+{
+    FT_Open_Args open;
+
+    open.flags = FT_OPEN_MEMORY;
+    open.memory_base = (FT_Byte *)pBufferBytes;
+    open.memory_size = bufferSizeInBytes;
+
+    err = FT_Attach_Stream( *ftFace, &open);
+    return !err;
+}
+
+
+void FTFace::Close()
+{
+    if( ftFace)
+    {
+        FT_Done_Face( *ftFace);
+        delete ftFace;
+        ftFace = 0;
+    }
+}
+
+
+const FTSize& FTFace::Size( const unsigned int size, const unsigned int res)
+{
+    charSize.CharSize( ftFace, size, res, res);
+    err = charSize.Error();
+
+    return charSize;
+}
+
+
+unsigned int FTFace::CharMapCount()
+{
+    return (*ftFace)->num_charmaps;
+}
+
+
+FT_Encoding* FTFace::CharMapList()
+{
+    if( 0 == fontEncodingList)
+    {
+        fontEncodingList = new FT_Encoding[CharMapCount()];
+        for( size_t encodingIndex = 0; encodingIndex < CharMapCount(); ++encodingIndex)
+        {
+            fontEncodingList[encodingIndex] = (*ftFace)->charmaps[encodingIndex]->encoding;
+        }
+    }
+    
+    return fontEncodingList;
+}
+
+
+unsigned int FTFace::UnitsPerEM() const
+{
+    return (*ftFace)->units_per_EM;
+}
+
+
+FTPoint FTFace::KernAdvance( unsigned int index1, unsigned int index2)
+{
+    float x, y;
+    x = y = 0.0f;
+
+    if( FT_HAS_KERNING((*ftFace)) && index1 && index2)
+    {
+        FT_Vector kernAdvance;
+        kernAdvance.x = kernAdvance.y = 0;
+
+        err = FT_Get_Kerning( *ftFace, index1, index2, ft_kerning_unfitted, &kernAdvance);
+        if( !err)
+        {   
+            x = static_cast<float>( kernAdvance.x) / 64.0f;
+            y = static_cast<float>( kernAdvance.y) / 64.0f;
+        }
+    }
+    
+    return FTPoint( x, y, 0.0);
+}
+
+
+FT_GlyphSlot FTFace::Glyph( unsigned int index, FT_Int load_flags)
+{
+    err = FT_Load_Glyph( *ftFace, index, load_flags);
+    if( err)
+    {
+        return NULL;
+    }
+
+    return (*ftFace)->glyph;
+}
+
diff --git a/extern/bFTGL/src/FTFont.cpp b/extern/bFTGL/src/FTFont.cpp
new file mode 100755
index 00000000000..c06d883104b
--- /dev/null
+++ b/extern/bFTGL/src/FTFont.cpp
@@ -0,0 +1,271 @@
+#include    "FTFace.h"
+#include    "FTFont.h"
+#include    "FTGlyphContainer.h"
+#include    "FTBBox.h"
+
+
+FTFont::FTFont( const char* fontname)
+:   face( fontname),
+    glyphList(0)
+{
+    err = face.Error();
+    if( err == 0)
+    {
+        glyphList = new FTGlyphContainer( &face);
+    }
+}
+
+
+FTFont::FTFont( const unsigned char *pBufferBytes, size_t bufferSizeInBytes)
+:   face( pBufferBytes, bufferSizeInBytes),
+    glyphList(0)
+{
+    err = face.Error();
+    if( err == 0)
+    {
+        glyphList = new FTGlyphContainer( &face);
+    }
+}
+
+
+FTFont::~FTFont()
+{
+    delete glyphList;
+}
+
+
+bool FTFont::Attach( const char* filename)
+{
+    if( face.Attach( filename))
+    {
+        err = 0;
+        return true;
+    }
+    else
+    {
+        err = face.Error();
+        return false;
+    }
+}
+
+
+bool FTFont::Attach( const unsigned char *pBufferBytes, size_t bufferSizeInBytes)
+{
+    if( face.Attach( pBufferBytes, bufferSizeInBytes))
+    {
+        err = 0;
+        return true;
+    }
+    else
+    {
+        err = face.Error();
+        return false;
+    }
+}
+
+
+bool FTFont::FaceSize( const unsigned int size, const unsigned int res )
+{
+    charSize = face.Size( size, res);
+    
+    if( face.Error())
+    {
+        return false;
+    }
+    
+    if( glyphList != NULL)
+    {
+        delete glyphList;
+    }
+    
+    glyphList = new FTGlyphContainer( &face);
+    return true;
+}
+
+
+unsigned int FTFont::FaceSize() const
+{
+    return charSize.CharSize();
+}
+
+
+bool FTFont::CharMap( FT_Encoding encoding)
+{
+    bool result = glyphList->CharMap( encoding);
+    err = glyphList->Error();
+    return result;
+}
+
+
+unsigned int FTFont::CharMapCount()
+{
+    return face.CharMapCount();
+}
+
+
+FT_Encoding* FTFont::CharMapList()
+{
+    return face.CharMapList();
+}
+
+
+float FTFont::Ascender() const
+{
+    return charSize.Ascender();
+}
+
+
+float FTFont::Descender() const
+{
+    return charSize.Descender();
+}
+
+
+void FTFont::BBox( const char* string,
+                   float& llx, float& lly, float& llz, float& urx, float& ury, float& urz)
+{
+    FTBBox totalBBox;
+
+    if((NULL != string) && ('\0' != *string))
+    {
+        const unsigned char* c = (unsigned char*)string;
+
+        CheckGlyph( *c);
+
+        totalBBox = glyphList->BBox( *c);
+        float advance = glyphList->Advance( *c, *(c + 1));
+        ++c;
+            
+        while( *c)
+        {
+            CheckGlyph( *c);
+            FTBBox tempBBox = glyphList->BBox( *c);
+            tempBBox.Move( FTPoint( advance, 0.0f, 0.0f));
+            totalBBox += tempBBox;
+            advance += glyphList->Advance( *c, *(c + 1));
+            ++c;
+        }
+    }
+
+    llx = totalBBox.lowerX;
+    lly = totalBBox.lowerY;
+    llz = totalBBox.lowerZ;
+    urx = totalBBox.upperX;
+    ury = totalBBox.upperY;
+    urz = totalBBox.upperZ;
+}
+
+
+void FTFont::BBox( const wchar_t* string,
+                   float& llx, float& lly, float& llz, float& urx, float& ury, float& urz)
+{
+    FTBBox totalBBox;
+
+    if((NULL != string) && ('\0' != *string))
+    {
+        const wchar_t* c = string;
+
+        CheckGlyph( *c);
+
+        totalBBox = glyphList->BBox( *c);
+        float advance = glyphList->Advance( *c, *(c + 1));
+        ++c;
+
+        while( *c)
+        {
+            CheckGlyph( *c);
+            FTBBox tempBBox = glyphList->BBox( *c);
+            tempBBox.Move( FTPoint( advance, 0.0f, 0.0f));
+            totalBBox += tempBBox;
+            advance += glyphList->Advance( *c, *(c + 1));
+            ++c;
+        }
+    }
+
+    llx = totalBBox.lowerX;
+    lly = totalBBox.lowerY;
+    llz = totalBBox.lowerZ;
+    urx = totalBBox.upperX;
+    ury = totalBBox.upperY;
+    urz = totalBBox.upperZ;
+}
+
+
+float FTFont::Advance( const wchar_t* string)
+{
+    const wchar_t* c = string;
+    float width = 0.0f;
+
+    while( *c)
+    {
+        CheckGlyph( *c);
+        width += glyphList->Advance( *c, *(c + 1));
+        ++c;
+    }
+
+    return width;
+}
+
+
+float FTFont::Advance( const char* string)
+{
+    const unsigned char* c = (unsigned char*)string;
+    float width = 0.0f;
+
+    while( *c)
+    {
+        CheckGlyph( *c);
+        width += glyphList->Advance( *c, *(c + 1));
+        ++c;
+    }
+    
+    return width;
+}
+
+
+void FTFont::Render( const char* string )
+{
+    const unsigned char* c = (unsigned char*)string;
+    pen.x = 0; pen.y = 0;
+
+    while( *c)
+    {
+        DoRender( *c, *(c + 1));
+        ++c;
+    }
+}
+
+
+void FTFont::Render( const wchar_t* string )
+{
+    const wchar_t* c = string;
+    pen.x = 0; pen.y = 0;
+
+    while( *c)
+    {
+        DoRender( *c, *(c + 1));
+        ++c;
+    }
+}
+
+
+void FTFont::DoRender( const unsigned int chr, const unsigned int nextChr)
+{
+    CheckGlyph( chr);
+
+    FTPoint kernAdvance = glyphList->Render( chr, nextChr, pen);
+    
+    pen.x += kernAdvance.x;
+    pen.y += kernAdvance.y;
+}
+
+
+void FTFont::CheckGlyph( const unsigned int characterCode)
+{
+    if( NULL == glyphList->Glyph( characterCode))
+    {
+        unsigned int glyphIndex = glyphList->FontIndex( characterCode);
+        glyphList->Add( MakeGlyph( glyphIndex), characterCode);
+    }
+}
+
diff --git a/extern/bFTGL/src/FTGLBitmapFont.cpp b/extern/bFTGL/src/FTGLBitmapFont.cpp
new file mode 100755
index 00000000000..7e982a608da
--- /dev/null
+++ b/extern/bFTGL/src/FTGLBitmapFont.cpp
@@ -0,0 +1,66 @@
+#include "FTGLBitmapFont.h"
+#include "FTBitmapGlyph.h"
+
+
+FTGLBitmapFont::FTGLBitmapFont( const char* fontname)
+:   FTFont( fontname)
+{}
+
+
+FTGLBitmapFont::FTGLBitmapFont( const unsigned char *pBufferBytes, size_t bufferSizeInBytes)
+:   FTFont( pBufferBytes, bufferSizeInBytes)
+{}
+
+
+FTGLBitmapFont::~FTGLBitmapFont()
+{}
+
+
+FTGlyph* FTGLBitmapFont::MakeGlyph( unsigned int g)
+{
+    FT_GlyphSlot ftGlyph = face.Glyph( g, FT_LOAD_DEFAULT);
+
+    if( ftGlyph)
+    {
+        FTBitmapGlyph* tempGlyph = new FTBitmapGlyph( ftGlyph);
+        return tempGlyph;
+    }
+
+    err = face.Error();
+    return NULL;
+}
+
+
+void FTGLBitmapFont::Render( const char* string)
+{   
+    glPushClientAttrib( GL_CLIENT_PIXEL_STORE_BIT);
+    glPushAttrib( GL_ENABLE_BIT);
+    
+    glPixelStorei( GL_UNPACK_LSB_FIRST, GL_FALSE);
+    glPixelStorei( GL_UNPACK_ALIGNMENT, 1);
+
+    glDisable( GL_BLEND);
+
+    FTFont::Render( string);
+
+    glPopAttrib();
+    glPopClientAttrib();
+}
+
+
+void FTGLBitmapFont::Render( const wchar_t* string)
+{   
+    glPushClientAttrib( GL_CLIENT_PIXEL_STORE_BIT);
+    glPushAttrib( GL_ENABLE_BIT);
+    
+    glPixelStorei( GL_UNPACK_LSB_FIRST, GL_FALSE);
+    glPixelStorei( GL_UNPACK_ALIGNMENT, 1);
+    
+    glDisable( GL_BLEND);
+
+    FTFont::Render( string);
+
+    glPopAttrib();
+    glPopClientAttrib();
+}
+
diff --git a/extern/bFTGL/src/FTGLBufferFont.cpp b/extern/bFTGL/src/FTGLBufferFont.cpp
new file mode 100755
index 00000000000..b8af0fcb05f
--- /dev/null
+++ b/extern/bFTGL/src/FTGLBufferFont.cpp
@@ -0,0 +1,53 @@
+#include    "FTGLBufferFont.h"
+#include    "FTBufferGlyph.h"
+
+
+FTGLBufferFont::FTGLBufferFont( const char* fontname)
+:   FTFont( fontname),
+    buffer(0)
+{}
+
+
+FTGLBufferFont::FTGLBufferFont( const unsigned char *pBufferBytes, size_t bufferSizeInBytes)
+:   FTFont( pBufferBytes, bufferSizeInBytes),
+    buffer(0)
+{}
+
+
+FTGLBufferFont::~FTGLBufferFont()
+{}
+
+
+FTGlyph* FTGLBufferFont::MakeGlyph( unsigned int g)
+{
+    FT_GlyphSlot ftGlyph = face.Glyph( g, FT_LOAD_NO_HINTING);
+
+    if( ftGlyph)
+    {
+        FTBufferGlyph* tempGlyph = new FTBufferGlyph( ftGlyph, buffer);
+        return tempGlyph;
+    }
+
+    err = face.Error();
+    return NULL;
+}
+
+
+void FTGLBufferFont::Render( const char* string)
+{   
+    if( NULL != buffer)
+    {
+        FTFont::Render( string);
+    }
+}
+
+
+void FTGLBufferFont::Render( const wchar_t* string)
+{   
+    if( NULL != buffer)
+    {
+        FTFont::Render( string);
+    }
+}
+
+
diff --git a/extern/bFTGL/src/FTGLExtrdFont.cpp b/extern/bFTGL/src/FTGLExtrdFont.cpp
new file mode 100644
index 00000000000..37d89333a60
--- /dev/null
+++ b/extern/bFTGL/src/FTGLExtrdFont.cpp
@@ -0,0 +1,35 @@
+#include    "FTGLExtrdFont.h"
+#include    "FTExtrdGlyph.h"
+
+
+FTGLExtrdFont::FTGLExtrdFont( const char* fontname)
+:   FTFont( fontname),
+    depth( 0.0f)
+{}
+
+
+FTGLExtrdFont::FTGLExtrdFont( const unsigned char *pBufferBytes, size_t bufferSizeInBytes)
+:   FTFont( pBufferBytes, bufferSizeInBytes),
+    depth( 0.0f)
+{}
+
+
+FTGLExtrdFont::~FTGLExtrdFont()
+{}
+
+
+FTGlyph* FTGLExtrdFont::MakeGlyph( unsigned int glyphIndex)
+{
+    FT_GlyphSlot ftGlyph = face.Glyph( glyphIndex, FT_LOAD_NO_HINTING);
+
+    if( ftGlyph)
+    {
+        FTExtrdGlyph* tempGlyph = new FTExtrdGlyph( ftGlyph, depth);
+        return tempGlyph;
+    }
+
+    err = face.Error();
+    return NULL;
+}
+
+
diff --git a/extern/bFTGL/src/FTGLOutlineFont.cpp b/extern/bFTGL/src/FTGLOutlineFont.cpp
new file mode 100755
index 00000000000..b9fd187e862
--- /dev/null
+++ b/extern/bFTGL/src/FTGLOutlineFont.cpp
@@ -0,0 +1,66 @@
+#include    "FTGLOutlineFont.h"
+#include    "FTOutlineGlyph.h"
+
+
+FTGLOutlineFont::FTGLOutlineFont( const char* fontname)
+:   FTFont( fontname)
+{}
+
+
+FTGLOutlineFont::FTGLOutlineFont( const unsigned char *pBufferBytes, size_t bufferSizeInBytes)
+:   FTFont( pBufferBytes, bufferSizeInBytes)
+{}
+
+
+FTGLOutlineFont::~FTGLOutlineFont()
+{}
+
+
+FTGlyph* FTGLOutlineFont::MakeGlyph( unsigned int g)
+{
+    FT_GlyphSlot ftGlyph = face.Glyph( g, FT_LOAD_NO_HINTING);
+
+    if( ftGlyph)
+    {
+        FTOutlineGlyph* tempGlyph = new FTOutlineGlyph( ftGlyph);
+        return tempGlyph;
+    }
+
+    err = face.Error();
+    return NULL;
+}
+
+
+void FTGLOutlineFont::Render( const char* string)
+{   
+    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
+
+    FTFont::Render( string);
+
+    glPopAttrib();
+}
+
+
+void FTGLOutlineFont::Render( const wchar_t* string)
+{   
+    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
+
+    FTFont::Render( string);
+
+    glPopAttrib();
+}
+
diff --git a/extern/bFTGL/src/FTGLPixmapFont.cpp b/extern/bFTGL/src/FTGLPixmapFont.cpp
new file mode 100755
index 00000000000..1b35e2ab11d
--- /dev/null
+++ b/extern/bFTGL/src/FTGLPixmapFont.cpp
@@ -0,0 +1,68 @@
+#include    "FTGLPixmapFont.h"
+#include    "FTPixmapGlyph.h"
+
+
+FTGLPixmapFont::FTGLPixmapFont( const char* fontname)
+:   FTFont( fontname)
+{}
+
+
+FTGLPixmapFont::FTGLPixmapFont( const unsigned char *pBufferBytes, size_t bufferSizeInBytes)
+:   FTFont( pBufferBytes, bufferSizeInBytes)
+{}
+
+
+FTGLPixmapFont::~FTGLPixmapFont()
+{}
+
+
+FTGlyph* FTGLPixmapFont::MakeGlyph( unsigned int g)
+{
+    FT_GlyphSlot ftGlyph = face.Glyph( g, FT_LOAD_NO_HINTING);
+
+    if( ftGlyph)
+    {
+        FTPixmapGlyph* tempGlyph = new FTPixmapGlyph( ftGlyph);
+        return tempGlyph;
+    }
+
+    err = face.Error();
+    return NULL;
+}
+
+
+void FTGLPixmapFont::Render( const char* string)
+{   
+    glPushAttrib( GL_ENABLE_BIT | GL_PIXEL_MODE_BIT | GL_COLOR_BUFFER_BIT);
+    glPushClientAttrib( GL_CLIENT_PIXEL_STORE_BIT);
+
+    glEnable(GL_BLEND);
+    glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+    glDisable( GL_TEXTURE_2D);
+
+    FTFont::Render( string);
+
+    glPopClientAttrib();
+    glPopAttrib();
+}
+
+
+void FTGLPixmapFont::Render( const wchar_t* string)
+{   
+    //glPushAttrib( GL_ENABLE_BIT | GL_PIXEL_MODE_BIT | GL_COLOR_BUFFER_BIT);
+   // glPushClientAttrib( GL_CLIENT_PIXEL_STORE_BIT);
+        
+    glEnable(GL_BLEND);
+    glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+    glDisable( GL_TEXTURE_2D);
+
+    FTFont::Render( string);
+
+	glDisable(GL_BLEND);
+   // glPopClientAttrib();
+   // glPopAttrib();
+}
+
+
diff --git a/extern/bFTGL/src/FTGLPolygonFont.cpp b/extern/bFTGL/src/FTGLPolygonFont.cpp
new file mode 100755
index 00000000000..2d4dfa1f26a
--- /dev/null
+++ b/extern/bFTGL/src/FTGLPolygonFont.cpp
@@ -0,0 +1,33 @@
+#include    "FTGLPolygonFont.h"
+#include    "FTPolyGlyph.h"
+
+
+FTGLPolygonFont::FTGLPolygonFont( const char* fontname)
+:   FTFont( fontname)
+{}
+
+
+FTGLPolygonFont::FTGLPolygonFont( const unsigned char *pBufferBytes, size_t bufferSizeInBytes)
+:   FTFont( pBufferBytes, bufferSizeInBytes)
+{}
+
+
+FTGLPolygonFont::~FTGLPolygonFont()
+{}
+
+
+FTGlyph* FTGLPolygonFont::MakeGlyph( unsigned int g)
+{
+    FT_GlyphSlot ftGlyph = face.Glyph( g, FT_LOAD_NO_HINTING);
+
+    if( ftGlyph)
+    {
+        FTPolyGlyph* tempGlyph = new FTPolyGlyph( ftGlyph);
+        return tempGlyph;
+    }
+
+    err = face.Error();
+    return NULL;
+}
+
+
diff --git a/extern/bFTGL/src/FTGLTextureFont.cpp b/extern/bFTGL/src/FTGLTextureFont.cpp
new file mode 100755
index 00000000000..aa6b645d3ab
--- /dev/null
+++ b/extern/bFTGL/src/FTGLTextureFont.cpp
@@ -0,0 +1,178 @@
+#include <string> // For memset
+
+#include "FTGLTextureFont.h"
+#include "FTTextureGlyph.h"
+
+
+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;
+}
+
+
+FTGLTextureFont::FTGLTextureFont( const char* fontname)
+:   FTFont( fontname),
+    maxTextSize(0),
+    textureWidth(0),
+    textureHeight(0),
+    glyphHeight(0),
+    glyphWidth(0),
+    padding(3),
+    xOffset(0),
+    yOffset(0)
+{
+    remGlyphs = numGlyphs = face.GlyphCount();
+}
+
+
+FTGLTextureFont::FTGLTextureFont( const unsigned char *pBufferBytes, size_t bufferSizeInBytes)
+:   FTFont( pBufferBytes, bufferSizeInBytes),
+    maxTextSize(0),
+    textureWidth(0),
+    textureHeight(0),
+    glyphHeight(0),
+    glyphWidth(0),
+    padding(3),
+    xOffset(0),
+    yOffset(0)
+{
+    remGlyphs = numGlyphs = face.GlyphCount();
+}
+
+
+FTGLTextureFont::~FTGLTextureFont()
+{
+    glDeleteTextures( textureIDList.size(), (const GLuint*)&textureIDList[0]);
+}
+
+
+FTGlyph* FTGLTextureFont::MakeGlyph( unsigned int glyphIndex)
+{
+    FT_GlyphSlot ftGlyph = face.Glyph( glyphIndex, FT_LOAD_NO_HINTING);
+    
+    if( ftGlyph)
+    {
+        glyphHeight = static_cast<int>( charSize.Height());
+        glyphWidth = static_cast<int>( charSize.Width());
+        
+        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().upperX - tempGlyph->BBox().lowerX + padding);
+        
+        --remGlyphs;
+        return tempGlyph;
+    }
+    
+    err = face.Error();
+    return NULL;
+}
+
+
+void FTGLTextureFont::CalculateTextureSize()
+{
+    if( !maxTextSize)
+    {
+        glGetIntegerv( GL_MAX_TEXTURE_SIZE, (GLint*)&maxTextSize);
+    }
+    
+    textureWidth = NextPowerOf2( (remGlyphs * glyphWidth) + ( padding * 2));
+    if( textureWidth > maxTextSize)
+    {
+        textureWidth = maxTextSize;
+    }
+    
+    int h = static_cast<int>( (textureWidth - ( padding * 2)) / glyphWidth);
+        
+    textureHeight = NextPowerOf2( (( numGlyphs / h) + 1) * glyphHeight);
+    textureHeight = textureHeight > maxTextSize ? maxTextSize : textureHeight;
+}
+
+
+GLuint FTGLTextureFont::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 FTGLTextureFont::FaceSize( const unsigned int size, const unsigned int res)
+{
+    if( !textureIDList.empty())
+    {
+        glDeleteTextures( textureIDList.size(), (const GLuint*)&textureIDList[0]);
+        remGlyphs = numGlyphs = face.GlyphCount();
+    }
+
+    return FTFont::FaceSize( size, res);
+}
+
+
+void FTGLTextureFont::Render( const char* string)
+{   
+    glPushAttrib( GL_ENABLE_BIT | GL_COLOR_BUFFER_BIT);
+    
+    glEnable(GL_BLEND);
+    glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // GL_ONE
+    
+    FTFont::Render( string);
+
+    glPopAttrib();
+}
+
+
+void FTGLTextureFont::Render( const wchar_t* string)
+{   
+    glPushAttrib( GL_ENABLE_BIT | GL_COLOR_BUFFER_BIT);
+    
+    glEnable(GL_BLEND);
+    glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // GL_ONE
+    
+    FTFont::Render( string);
+    
+    glPopAttrib();
+}
+
diff --git a/extern/bFTGL/src/FTGlyph.cpp b/extern/bFTGL/src/FTGlyph.cpp
new file mode 100755
index 00000000000..c68632949c2
--- /dev/null
+++ b/extern/bFTGL/src/FTGlyph.cpp
@@ -0,0 +1,17 @@
+#include    "FTGlyph.h"
+
+
+FTGlyph::FTGlyph( FT_GlyphSlot glyph)
+:   advance(0.0f),
+    err(0)  
+{
+    if( glyph)
+    {
+        bBox = FTBBox( glyph);
+        advance = static_cast<float>( glyph->advance.x) / 64.0f;
+    }
+}
+
+
+FTGlyph::~FTGlyph()
+{}
diff --git a/extern/bFTGL/src/FTGlyphContainer.cpp b/extern/bFTGL/src/FTGlyphContainer.cpp
new file mode 100755
index 00000000000..2c1881bbfff
--- /dev/null
+++ b/extern/bFTGL/src/FTGlyphContainer.cpp
@@ -0,0 +1,93 @@
+#include    "FTGlyphContainer.h"
+#include    "FTGlyph.h"
+#include    "FTFace.h"
+#include    "FTCharmap.h"
+
+
+FTGlyphContainer::FTGlyphContainer( FTFace* f)
+:   face(f),
+    err(0)
+{
+    glyphs.push_back( NULL);
+    charMap = new FTCharmap( face);
+}
+
+
+FTGlyphContainer::~FTGlyphContainer()
+{
+    GlyphVector::iterator glyphIterator;
+    for( glyphIterator = glyphs.begin(); glyphIterator != glyphs.end(); ++glyphIterator)
+    {
+        delete *glyphIterator;
+    }
+    
+    glyphs.clear();
+    delete charMap;
+}
+
+
+bool FTGlyphContainer::CharMap( FT_Encoding encoding)
+{
+    bool result = charMap->CharMap( encoding);
+    err = charMap->Error();
+    return result;
+}
+
+
+unsigned int FTGlyphContainer::FontIndex( const unsigned int characterCode) const
+{
+    return charMap->FontIndex( characterCode);
+}
+
+
+void FTGlyphContainer::Add( FTGlyph* tempGlyph, const unsigned int characterCode)
+{
+    charMap->InsertIndex( characterCode, glyphs.size());
+    glyphs.push_back( tempGlyph);
+}
+
+
+const FTGlyph* const FTGlyphContainer::Glyph( const unsigned int characterCode) const
+{
+    signed int index = charMap->GlyphListIndex( characterCode);
+    return glyphs[index];
+}
+
+
+FTBBox FTGlyphContainer::BBox( const unsigned int characterCode) const
+{
+    return glyphs[charMap->GlyphListIndex( characterCode)]->BBox();
+}
+
+
+float FTGlyphContainer::Advance( const unsigned int characterCode, const unsigned int nextCharacterCode)
+{
+    unsigned int left = charMap->FontIndex( characterCode);
+    unsigned int right = charMap->FontIndex( nextCharacterCode);
+
+    float width = face->KernAdvance( left, right).x;
+    width += glyphs[charMap->GlyphListIndex( characterCode)]->Advance();
+    
+    return width;
+}
+
+
+FTPoint FTGlyphContainer::Render( const unsigned int characterCode, const unsigned int nextCharacterCode, FTPoint penPosition)
+{
+    FTPoint kernAdvance;
+    float advance = 0;
+    
+    unsigned int left = charMap->FontIndex( characterCode);
+    unsigned int right = charMap->FontIndex( nextCharacterCode);
+
+    kernAdvance = face->KernAdvance( left, right);
+        
+    if( !face->Error())
+    {
+        advance = glyphs[charMap->GlyphListIndex( characterCode)]->Render( penPosition);
+    }
+    
+    kernAdvance.x = advance + kernAdvance.x;
+//  kernAdvance.y = advance.y + kernAdvance.y;
+    return kernAdvance;
+}
diff --git a/extern/bFTGL/src/FTLibrary.cpp b/extern/bFTGL/src/FTLibrary.cpp
new file mode 100755
index 00000000000..29ab5ae2693
--- /dev/null
+++ b/extern/bFTGL/src/FTLibrary.cpp
@@ -0,0 +1,64 @@
+#include    "FTLibrary.h"
+
+
+FTLibrary&  FTLibrary::Instance()
+{
+    static FTLibrary ftlib;
+    return ftlib;
+}
+
+
+FTLibrary::~FTLibrary()
+{
+    if( library != 0)
+    {
+        FT_Done_FreeType( *library);
+
+        delete library;
+        library= 0;
+    }
+
+//  if( manager != 0)
+//  {
+//      FTC_Manager_Done( manager );
+//
+//      delete manager;
+//      manager= 0;
+//  }
+}
+
+
+FTLibrary::FTLibrary()
+:   library(0),
+    err(0)
+{
+    Initialise();
+}
+
+
+bool FTLibrary::Initialise()
+{
+    if( library != 0)
+        return true;
+
+    library = new FT_Library;
+    
+    err = FT_Init_FreeType( library);
+    if( err)
+    {
+        delete library;
+        library = 0;
+        return false;
+    }
+    
+//  FTC_Manager* manager;
+//  
+//  if( FTC_Manager_New( lib, 0, 0, 0, my_face_requester, 0, manager )
+//  {
+//      delete manager;
+//      manager= 0;
+//      return false;
+//  }
+
+    return true;
+}
diff --git a/extern/bFTGL/src/FTOutlineGlyph.cpp b/extern/bFTGL/src/FTOutlineGlyph.cpp
new file mode 100644
index 00000000000..340c7804140
--- /dev/null
+++ b/extern/bFTGL/src/FTOutlineGlyph.cpp
@@ -0,0 +1,57 @@
+#include    "FTOutlineGlyph.h"
+#include    "FTVectoriser.h"
+
+
+FTOutlineGlyph::FTOutlineGlyph( FT_GlyphSlot glyph)
+:   FTGlyph( glyph),
+    glList(0)
+{
+    if( ft_glyph_format_outline != glyph->format)
+    {
+        err = 0x14; // Invalid_Outline
+        return;
+    }
+
+    FTVectoriser vectoriser( glyph);
+
+    size_t numContours = vectoriser.ContourCount();
+    if ( ( numContours < 1) || ( vectoriser.PointCount() < 3))
+    {
+        return;
+    }
+
+    glList = glGenLists(1);
+    glNewList( glList, GL_COMPILE);
+        for( unsigned int c = 0; c < numContours; ++c)
+        {
+            const FTContour* contour = vectoriser.Contour(c);
+            
+            glBegin( GL_LINE_LOOP);
+                for( unsigned int p = 0; p < contour->PointCount(); ++p)
+                {
+                    glVertex2f( contour->Point(p).x / 64.0f, contour->Point(p).y / 64.0f);
+                }
+            glEnd();
+        }
+    glEndList();
+}
+
+
+FTOutlineGlyph::~FTOutlineGlyph()
+{
+    glDeleteLists( glList, 1);
+}
+
+
+float FTOutlineGlyph::Render( const FTPoint& pen)
+{
+    if( glList)
+    {
+        glTranslatef( pen.x, pen.y, 0);
+            glCallList( glList);
+        glTranslatef( -pen.x, -pen.y, 0);
+    }
+    
+    return advance;
+}
+
diff --git a/extern/bFTGL/src/FTPixmapGlyph.cpp b/extern/bFTGL/src/FTPixmapGlyph.cpp
new file mode 100755
index 00000000000..b051a06b6e3
--- /dev/null
+++ b/extern/bFTGL/src/FTPixmapGlyph.cpp
@@ -0,0 +1,109 @@
+#include    "FTPixmapGlyph.h"
+
+FTPixmapGlyph::FTPixmapGlyph( FT_GlyphSlot glyph)
+:   FTGlyph( glyph),
+    destWidth(0),
+    destHeight(0),
+    data(0)
+{
+    err = FT_Render_Glyph( glyph, FT_RENDER_MODE_NORMAL);
+    if( err || ft_glyph_format_bitmap != glyph->format)
+    {
+        return;
+    }
+
+    FT_Bitmap bitmap = glyph->bitmap;
+
+    //check the pixel mode
+    //ft_pixel_mode_grays
+        
+    int srcWidth = bitmap.width;
+    int srcHeight = bitmap.rows;
+    
+   // FIXME What about dest alignment?
+    destWidth = srcWidth;
+    destHeight = srcHeight;
+    
+    if( destWidth && destHeight)
+    {
+        data = new unsigned char[destWidth * destHeight * 4];
+    
+        // Get the current glColor.
+        float ftglColour[4];
+//        glGetFloatv( GL_CURRENT_COLOR, ftglColour);
+		ftglColour[0] = ftglColour[1] = ftglColour[2] = ftglColour[3] = 1.0;
+
+        unsigned char redComponent =   static_cast<unsigned char>( ftglColour[0] * 255.0f);
+        unsigned char greenComponent = static_cast<unsigned char>( ftglColour[1] * 255.0f);
+        unsigned char blueComponent =  static_cast<unsigned char>( ftglColour[2] * 255.0f);
+
+        unsigned char* src = bitmap.buffer;
+
+        unsigned char* dest = data + ((destHeight - 1) * destWidth) * 4;
+        size_t destStep = destWidth * 4 * 2;
+
+        if( ftglColour[3] == 1.0f)
+        {
+            for( int y = 0; y < srcHeight; ++y)
+            {
+                for( int x = 0; x < srcWidth; ++x)
+                {
+                    *dest++ = redComponent;
+                    *dest++ = greenComponent;
+                    *dest++ = blueComponent;
+                    *dest++ = *src++;
+                }
+                dest -= destStep;
+            }
+        }
+        else
+        {
+            for( int y = 0; y < srcHeight; ++y)
+            {
+                for( int x = 0; x < srcWidth; ++x)
+                {
+                    *dest++ = redComponent;
+                    *dest++ = greenComponent;
+                    *dest++ = blueComponent;
+                    *dest++ = static_cast<unsigned char>(ftglColour[3] * *src++);
+                }
+                dest -= destStep;
+            }
+        }
+
+        destHeight = srcHeight;
+    }
+
+    pos.x = glyph->bitmap_left;
+    pos.y = srcHeight - glyph->bitmap_top;
+}
+
+
+FTPixmapGlyph::~FTPixmapGlyph()
+{
+    delete [] data;
+}
+
+#include <math.h>
+float FTPixmapGlyph::Render( const FTPoint& pen)
+{
+    if( data)
+    {
+		float dx, dy;
+		
+		dx= floor( (pen.x + pos.x ) );
+		dy= ( (pen.y - pos.y ) );
+		
+        // Move the glyph origin
+        glBitmap( 0, 0, 0.0f, 0.0f, dx, dy, (const GLubyte*)0);
+
+        glPixelStorei( GL_UNPACK_ROW_LENGTH, 0);
+
+        glDrawPixels( destWidth, destHeight, GL_RGBA, GL_UNSIGNED_BYTE, (const GLvoid*)data);
+        
+        // Restore the glyph origin
+        glBitmap( 0, 0, 0.0f, 0.0f, -dx, -dy, (const GLubyte*)0);
+    }
+
+    return advance;
+}
diff --git a/extern/bFTGL/src/FTPoint.cpp b/extern/bFTGL/src/FTPoint.cpp
new file mode 100755
index 00000000000..e4678bc9564
--- /dev/null
+++ b/extern/bFTGL/src/FTPoint.cpp
@@ -0,0 +1,14 @@
+#include "FTPoint.h"
+
+
+bool operator == ( const FTPoint &a, const FTPoint &b) 
+{
+    return((a.x == b.x) && (a.y == b.y) && (a.z == b.z));
+}
+
+bool operator != ( const FTPoint &a, const FTPoint &b) 
+{
+    return((a.x != b.x) || (a.y != b.y) || (a.z != b.z));
+}
+
+
diff --git a/extern/bFTGL/src/FTPolyGlyph.cpp b/extern/bFTGL/src/FTPolyGlyph.cpp
new file mode 100644
index 00000000000..7e0d695493c
--- /dev/null
+++ b/extern/bFTGL/src/FTPolyGlyph.cpp
@@ -0,0 +1,62 @@
+#include "FTPolyGlyph.h"
+#include "FTVectoriser.h"
+
+
+FTPolyGlyph::FTPolyGlyph( FT_GlyphSlot glyph)
+:   FTGlyph( glyph),
+    glList(0)
+{
+    if( ft_glyph_format_outline != glyph->format)
+    {
+        err = 0x14; // Invalid_Outline
+        return;
+    }
+
+    FTVectoriser vectoriser( glyph);
+
+    if(( vectoriser.ContourCount() < 1) || ( vectoriser.PointCount() < 3))
+    {
+        return;
+    }
+
+    vectoriser.MakeMesh( 1.0);
+    
+    glList = glGenLists( 1);
+    glNewList( glList, GL_COMPILE);
+
+        const FTMesh* mesh = vectoriser.GetMesh();
+        for( unsigned int index = 0; index < mesh->TesselationCount(); ++index)
+        {
+            const FTTesselation* subMesh = mesh->Tesselation( index);
+            unsigned int polyonType = subMesh->PolygonType();
+
+            glBegin( polyonType);
+                for( unsigned int x = 0; x < subMesh->PointCount(); ++x)
+                {
+                    glVertex3f( subMesh->Point(x).x / 64.0f,
+                                subMesh->Point(x).y / 64.0f,
+                                0.0f);
+                }
+            glEnd();
+        }
+    glEndList();
+}
+
+
+FTPolyGlyph::~FTPolyGlyph()
+{
+    glDeleteLists( glList, 1);
+}
+
+
+float FTPolyGlyph::Render( const FTPoint& pen)
+{
+    if( glList)
+    {
+        glTranslatef(  pen.x,  pen.y, 0);
+        glCallList( glList);    
+        glTranslatef( -pen.x, -pen.y, 0);
+    }
+    
+    return advance;
+}
diff --git a/extern/bFTGL/src/FTSize.cpp b/extern/bFTGL/src/FTSize.cpp
new file mode 100755
index 00000000000..5fb8ffba157
--- /dev/null
+++ b/extern/bFTGL/src/FTSize.cpp
@@ -0,0 +1,105 @@
+#include    "FTSize.h"
+
+
+FTSize::FTSize()
+:   ftFace(0),
+    ftSize(0),
+    size(0),
+    err(0)
+{}
+
+
+FTSize::~FTSize()
+{}
+
+
+bool FTSize::CharSize( FT_Face* face, unsigned int point_size, unsigned int x_resolution, unsigned int y_resolution )
+{
+    err = FT_Set_Char_Size( *face, 0L, point_size * 64, x_resolution, y_resolution);
+
+    if( !err)
+    {
+        ftFace = face;
+        size = point_size;
+        ftSize = (*ftFace)->size;
+    }
+    else
+    {
+        ftFace = 0;
+        size = 0;
+        ftSize = 0;
+    }
+    
+    return !err;
+}
+
+
+unsigned int FTSize::CharSize() const
+{
+    return size;
+}
+
+
+float FTSize::Ascender() const
+{
+    return ftSize == 0 ? 0.0f : static_cast<float>( ftSize->metrics.ascender) / 64.0f;
+}
+
+
+float FTSize::Descender() const
+{
+    return ftSize == 0 ? 0.0f : static_cast<float>( ftSize->metrics.descender) / 64.0f;
+}
+
+
+float FTSize::Height() const
+{
+    if( 0 == ftSize)
+    {
+        return 0.0f;
+    }
+    
+    if( FT_IS_SCALABLE((*ftFace)))
+    {
+        return ( (*ftFace)->bbox.yMax - (*ftFace)->bbox.yMin) * ( (float)ftSize->metrics.y_ppem / (float)(*ftFace)->units_per_EM);
+    }
+    else
+    {
+        return static_cast<float>( ftSize->metrics.height) / 64.0f;
+    }
+}
+
+
+float FTSize::Width() const
+{
+    if( 0 == ftSize)
+    {
+        return 0.0f;
+    }
+    
+    if( FT_IS_SCALABLE((*ftFace)))
+    {
+        return ( (*ftFace)->bbox.xMax - (*ftFace)->bbox.xMin) * ( static_cast<float>(ftSize->metrics.x_ppem) / static_cast<float>((*ftFace)->units_per_EM));
+    }
+    else
+    {
+        return static_cast<float>( ftSize->metrics.max_advance) / 64.0f;
+    }
+}
+
+
+float FTSize::Underline() const
+{
+    return 0.0f;
+}
+
+unsigned int FTSize::XPixelsPerEm() const
+{
+    return ftSize == 0 ? 0 : ftSize->metrics.x_ppem;
+}
+
+unsigned int FTSize::YPixelsPerEm() const
+{
+    return ftSize == 0 ? 0 : ftSize->metrics.y_ppem;
+}
+
diff --git a/extern/bFTGL/src/FTTextureGlyph.cpp b/extern/bFTGL/src/FTTextureGlyph.cpp
new file mode 100755
index 00000000000..4b29268f1ce
--- /dev/null
+++ b/extern/bFTGL/src/FTTextureGlyph.cpp
@@ -0,0 +1,82 @@
+#include    "FTTextureGlyph.h"
+
+
+FTTextureGlyph::FTTextureGlyph( FT_GlyphSlot glyph, int id, int xOffset, int yOffset, GLsizei width, GLsizei height)
+:   FTGlyph( glyph),
+    destWidth(0),
+    destHeight(0),
+    glTextureID(id),
+    activeTextureID(0)
+{
+    err = FT_Render_Glyph( glyph, FT_RENDER_MODE_NORMAL);
+    if( err || glyph->format != ft_glyph_format_bitmap)
+    {
+        return;
+    }
+
+    FT_Bitmap      bitmap = glyph->bitmap;
+
+    destWidth  = bitmap.width;
+    destHeight = bitmap.rows;
+    
+    if( destWidth && destHeight)
+    {
+        glPushClientAttrib( GL_CLIENT_PIXEL_STORE_BIT);
+        glPixelStorei( GL_UNPACK_LSB_FIRST, GL_FALSE);
+        glPixelStorei( GL_UNPACK_ROW_LENGTH, 0);
+        glPixelStorei( GL_UNPACK_ALIGNMENT, 1);
+
+        glBindTexture( GL_TEXTURE_2D, glTextureID);
+        glTexSubImage2D( GL_TEXTURE_2D, 0, xOffset, yOffset, destWidth, destHeight, GL_ALPHA, GL_UNSIGNED_BYTE, bitmap.buffer);
+
+        glPopClientAttrib();
+    }
+
+
+//      0    
+//      +----+
+//      |    |
+//      |    |
+//      |    |
+//      +----+
+//           1
+    
+    uv[0].x = static_cast<float>(xOffset) / static_cast<float>(width);
+    uv[0].y = static_cast<float>(yOffset) / static_cast<float>(height);
+    uv[1].x = static_cast<float>( xOffset + destWidth) / static_cast<float>(width);
+    uv[1].y = static_cast<float>( yOffset + destHeight) / static_cast<float>(height);
+    
+    pos.x = glyph->bitmap_left;
+    pos.y = glyph->bitmap_top;
+}
+
+
+FTTextureGlyph::~FTTextureGlyph()
+{}
+
+
+float FTTextureGlyph::Render( const FTPoint& pen)
+{
+    glGetIntegerv( GL_TEXTURE_2D_BINDING_EXT, &activeTextureID);
+    if( activeTextureID != glTextureID)
+    {
+        glBindTexture( GL_TEXTURE_2D, (GLuint)glTextureID);
+    }
+    
+    glBegin( GL_QUADS);
+        glTexCoord2f( uv[0].x, uv[0].y);
+        glVertex2f( pen.x + pos.x,             pen.y + pos.y);
+
+        glTexCoord2f( uv[0].x, uv[1].y);
+        glVertex2f( pen.x + pos.x,             pen.y + pos.y - destHeight);
+
+        glTexCoord2f( uv[1].x, uv[1].y);
+        glVertex2f( pen.x + destWidth + pos.x, pen.y + pos.y - destHeight);
+        
+        glTexCoord2f( uv[1].x, uv[0].y);
+        glVertex2f( pen.x + destWidth + pos.x, pen.y + pos.y);
+    glEnd();
+
+    return advance;
+}
+
diff --git a/extern/bFTGL/src/FTVectoriser.cpp b/extern/bFTGL/src/FTVectoriser.cpp
new file mode 100644
index 00000000000..bb133d025b4
--- /dev/null
+++ b/extern/bFTGL/src/FTVectoriser.cpp
@@ -0,0 +1,225 @@
+#include    "FTVectoriser.h"
+#include    "FTGL.h"
+
+#ifndef CALLBACK
+#define CALLBACK
+#endif
+
+#ifdef __APPLE_CC__    
+    typedef GLvoid (*GLUTesselatorFunction)(...);
+#elif defined( __mips ) || defined( __linux__ ) || defined( __FreeBSD__ ) || defined( __OpenBSD__ ) || defined( __sun ) || defined (__CYGWIN__)
+    typedef GLvoid (*GLUTesselatorFunction)();
+#elif defined ( WIN32)
+    typedef GLvoid (CALLBACK *GLUTesselatorFunction)( );
+#else
+    #error "Error - need to define type GLUTesselatorFunction for this platform/compiler"
+#endif
+
+
+void CALLBACK ftglError( GLenum errCode, FTMesh* mesh)
+{
+    mesh->Error( errCode);
+}
+
+
+void CALLBACK ftglVertex( void* data, FTMesh* mesh)
+{
+    FTGL_DOUBLE* vertex = static_cast<FTGL_DOUBLE*>(data);
+    mesh->AddPoint( vertex[0], vertex[1], vertex[2]);
+}
+
+
+void CALLBACK ftglCombine( FTGL_DOUBLE coords[3], void* vertex_data[4], GLfloat weight[4], void** outData, FTMesh* mesh)
+{
+    FTGL_DOUBLE* vertex = static_cast<FTGL_DOUBLE*>(coords);
+    *outData = mesh->Combine( vertex[0], vertex[1], vertex[2]);
+}
+        
+
+void CALLBACK ftglBegin( GLenum type, FTMesh* mesh)
+{
+    mesh->Begin( type);
+}
+
+
+void CALLBACK ftglEnd( FTMesh* mesh)
+{
+    mesh->End();
+}
+
+
+FTMesh::FTMesh()
+:	currentTesselation(0),
+    err(0)
+{
+    tesselationList.reserve( 16);
+}
+
+
+FTMesh::~FTMesh()
+{
+    for( size_t t = 0; t < tesselationList.size(); ++t)
+    {
+        delete tesselationList[t];
+    }
+    
+    tesselationList.clear();
+}
+
+
+void FTMesh::AddPoint( const FTGL_DOUBLE x, const FTGL_DOUBLE y, const FTGL_DOUBLE z)
+{
+    currentTesselation->AddPoint( x, y, z);
+}
+
+
+FTGL_DOUBLE* FTMesh::Combine( const FTGL_DOUBLE x, const FTGL_DOUBLE y, const FTGL_DOUBLE z)
+{
+    tempPointList.push_back( FTPoint( x, y,z));
+    return &tempPointList.back().x;
+}
+
+
+void FTMesh::Begin( GLenum meshType)
+{
+    currentTesselation = new FTTesselation( meshType);
+}
+
+
+void FTMesh::End()
+{
+    tesselationList.push_back( currentTesselation);
+}
+
+
+const FTTesselation* const FTMesh::Tesselation( unsigned int index) const
+{
+    return ( index < tesselationList.size()) ? tesselationList[index] : NULL;
+}
+
+
+FTVectoriser::FTVectoriser( const FT_GlyphSlot glyph)
+:   contourList(0),
+    mesh(0),
+    ftContourCount(0),
+    contourFlag(0)
+{
+    if( glyph)
+    {
+        outline = glyph->outline;
+        
+        ftContourCount = outline.n_contours;;
+        contourList = 0;
+        contourFlag = outline.flags;
+        
+        ProcessContours();
+    }
+}
+
+
+FTVectoriser::~FTVectoriser()
+{
+    for( size_t c = 0; c < ContourCount(); ++c)
+    {
+        delete contourList[c];
+    }
+
+    delete [] contourList;
+    delete mesh;
+}
+
+
+void FTVectoriser::ProcessContours()
+{
+    short contourLength = 0;
+    short startIndex = 0;
+    short endIndex = 0;
+    
+    contourList = new FTContour*[ftContourCount];
+    
+    for( short contourIndex = 0; contourIndex < ftContourCount; ++contourIndex)
+    {
+        FT_Vector* pointList = &outline.points[startIndex];
+        char* tagList = &outline.tags[startIndex];
+        
+        endIndex = outline.contours[contourIndex];
+        contourLength =  ( endIndex - startIndex) + 1;
+
+        FTContour* contour = new FTContour( pointList, tagList, contourLength);
+        
+        contourList[contourIndex] = contour;
+        
+        startIndex = endIndex + 1;
+    }
+}
+
+
+size_t FTVectoriser::PointCount()
+{
+    size_t s = 0;
+    for( size_t c = 0; c < ContourCount(); ++c)
+    {
+        s += contourList[c]->PointCount();
+    }
+    
+    return s;
+}
+
+
+const FTContour* const FTVectoriser::Contour( unsigned int index) const
+{
+    return ( index < ContourCount()) ? contourList[index] : NULL;
+}
+
+
+void FTVectoriser::MakeMesh( FTGL_DOUBLE zNormal)
+{
+    if( mesh)
+    {
+        delete mesh;
+    }
+        
+    mesh = new FTMesh;
+    
+    GLUtesselator* tobj = gluNewTess();
+
+    gluTessCallback( tobj, GLU_TESS_BEGIN_DATA,     (GLUTesselatorFunction)ftglBegin);
+    gluTessCallback( tobj, GLU_TESS_VERTEX_DATA,    (GLUTesselatorFunction)ftglVertex);
+    gluTessCallback( tobj, GLU_TESS_COMBINE_DATA,   (GLUTesselatorFunction)ftglCombine);
+    gluTessCallback( tobj, GLU_TESS_END_DATA,       (GLUTesselatorFunction)ftglEnd);
+    gluTessCallback( tobj, GLU_TESS_ERROR_DATA,     (GLUTesselatorFunction)ftglError);
+    
+    if( contourFlag & ft_outline_even_odd_fill) // ft_outline_reverse_fill
+    {
+        gluTessProperty( tobj, GLU_TESS_WINDING_RULE, GLU_TESS_WINDING_ODD);
+    }
+    else
+    {
+        gluTessProperty( tobj, GLU_TESS_WINDING_RULE, GLU_TESS_WINDING_NONZERO);
+    }
+    
+    
+    gluTessProperty( tobj, GLU_TESS_TOLERANCE, 0);
+    gluTessNormal( tobj, 0.0f, 0.0f, zNormal);
+    gluTessBeginPolygon( tobj, mesh);
+    
+        for( size_t c = 0; c < ContourCount(); ++c)
+        {
+            const FTContour* contour = contourList[c];
+
+            gluTessBeginContour( tobj);
+            
+                for( size_t p = 0; p < contour->PointCount(); ++p)
+                {
+                    FTGL_DOUBLE* d = const_cast<FTGL_DOUBLE*>(&contour->Point(p).x);
+                    gluTessVertex( tobj, d, d);
+                }
+
+            gluTessEndContour( tobj);
+        }
+        
+    gluTessEndPolygon( tobj);
+
+    gluDeleteTess( tobj);
+}
+
diff --git a/extern/bFTGL/src/Makefile b/extern/bFTGL/src/Makefile
new file mode 100644
index 00000000000..064480fbd16
--- /dev/null
+++ b/extern/bFTGL/src/Makefile
@@ -0,0 +1,62 @@
+#
+# $Id$
+#
+# ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
+#
+# 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 2
+# of the License, or (at your option) any later version. The Blender
+# Foundation also sells licenses for use in proprietary software under
+# the Blender License.  See http://www.blender.org/BL/ for information
+# about this.
+#
+# 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, write to the Free Software Foundation,
+# Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+# The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
+# All rights reserved.
+#
+# The Original Code is: all of this file.
+#
+# Contributor(s): none yet.
+#
+# ***** END GPL/BL DUAL LICENSE BLOCK *****
+#
+#
+
+LIBNAME = ftgl
+DIR = $(OCGDIR)/extern/$(LIBNAME)
+
+CCFLAGS += $(LEVEL_1_CPP_WARNINGS)
+
+CSRCS = 
+CCSRCS =  FTBitmapGlyph.cpp FTCharmap.cpp FTContour.cpp FTExtrdGlyph.cpp \
+	FTFace.cpp FTFont.cpp FTGLBitmapFont.cpp FTGLExtrdFont.cpp \
+        FTGLOutlineFont.cpp FTGLPixmapFont.cpp FTGLPolygonFont.cpp \
+        FTGLTextureFont.cpp FTGlyph.cpp FTGlyphContainer.cpp FTLibrary.cpp \
+        FTOutlineGlyph.cpp FTPixmapGlyph.cpp FTPoint.cpp FTPolyGlyph.cpp \
+        FTSize.cpp FTTextureGlyph.cpp FTVectoriser.cpp
+
+include nan_compile.mk 
+CPPFLAGS += -I../include
+CPPFLAGS += -I$(NAN_FREETYPE)/include -I$(NAN_FREETYPE)/include/freetype2 
+
+install: all debug
+	@[ -d $(NAN_FTGL) ] || mkdir -p $(NAN_FTGL)
+	@[ -d $(NAN_FTGL)/include ] || mkdir -p $(NAN_FTGL)/include
+	@[ -d $(NAN_FTGL)/lib ] || mkdir -p $(NAN_FTGL)/lib
+	@[ -d $(NAN_FTGL)/lib/debug ] || mkdir -p $(NAN_FTGL)/lib/debug
+	@$(NANBLENDERHOME)/intern/tools/cpifdiff.sh $(DIR)/lib$(LIBNAME).a $(NAN_FTGL)/lib/
+#	@$(NANBLENDERHOME)/intern/tools/cpifdiff.sh $(DIR)/debug/lib$(LIBNAME).a $(NAN_FTGL)/lib/debug/
+ifeq ($(OS),darwin)
+	ranlib $(NAN_FTGL)/lib/lib$(LIBNAME).a
+endif
+	@$(NANBLENDERHOME)/intern/tools/cpifdiff.sh ../include/*.h $(NAN_FTGL)/include/
+
diff --git a/extern/bFTGL/win32_vcpp/README_WIN32.txt b/extern/bFTGL/win32_vcpp/README_WIN32.txt
new file mode 100644
index 00000000000..bc92bbb9591
--- /dev/null
+++ b/extern/bFTGL/win32_vcpp/README_WIN32.txt
@@ -0,0 +1,206 @@
+FTGL 1.31
+
+NOTES FOR COMPILING ON WINDOWS 
+
+14 Feb 2002
+
+Ellers, ellers@iinet.net.au
+
+
+
+
+
+SUPPORTED COMPILERS
+
+
+
+I have rebuilt the FTGL project files for Visual C++ (version 6). There are
+
+presently no other compilers or environments supported but feel free to
+
+contribute them. 
+
+
+
+
+
+QUICK GUIDE: COMPILING FTGL
+
+
+
+ - Start up MSVC++ with ftgl.dsw. 
+
+ - Tell MSVC++ where FreeType is. You'll need to do something like this:
+
+ 
+
+     *  select Project>Settings
+
+     *  select ftgl_static (for a start)
+
+     *  select "All Configurations"
+
+     *  go to the tab C++ > PreProcessor
+
+     *  Set additional include directories appropriately. For me it is:
+
+        D:\cots\freetype-2.0.5\include
+
+     *  repeat for all configurations of ftgl_dll
+
+
+
+
+
+QUICK GUIDE: COMPILING/RUNNING SUPPLIED DEMO PROGRAM 
+
+
+
+ - The program expects the first argument to be the name of a truetype file.
+
+   I copied timesbi.ttf from the windows directory to C:\TEMP and then edit
+
+   the settings of the project:
+
+   
+
+    * select Project>Settings
+
+    * select Demo project
+
+    * select panel Debug>General
+
+    * set Program Arguments to be "C:\TEMP\timesbi.ttf"
+
+
+
+
+
+QUICK GUIDE: COMPILING YOUR PROGRAM TO USE FTGL
+
+
+
+ - Choose dynamic or static library linkage
+
+     *  if you want to link to a static FTGL library ensure that 
+
+        FTGL_LIBRARY_STATIC is defined in the preprocessor section
+
+     
+
+
+
+CONFIGURATION / CODE GENERATION / C LIBRARIES
+
+
+
+FTGL can be built in various configurations (inspired by Freetype and libpng):
+
+
+
+ - static library (.lib)
+
+ - dynamic library (.dll)
+
+ 
+
+MSVC++ requires selection of "code generation" option, which seems to be 
+
+mostly to do with which version of the Standard C library is linked with the
+
+library. 
+
+
+
+The following modes are supported:
+
+
+
+ - static/dynamic
+
+ - single threaded (ST) or multithreaded (MT)
+
+   NOTE: the multithreaded DLL (MD) mode was NOT included, as freetype itself
+
+         doesn't support that mode so I figure there's no point yet.
+
+ - debug/release (debug has _d suffix)
+
+ 
+
+So the static multithreaded release library is:
+
+
+
+	ftgl_static_MT.lib
+
+	
+
+The same library built in DEBUG mode:
+
+
+
+	ftgl_static_MT_d.lib
+
+
+
+If you're not sure which one is appropriate (and if you're a novice don't
+
+been too put off...) start with making the decision about debug or release.
+
+This should be easy because if you're building the debug version of your 
+
+app its probably a good idea to link with the debug version of FTGL (but
+
+not compulsory). Once thats done, you may get errors like:
+
+
+
+	LIBCMTD.lib(crt0init.obj) : warning LNK4098: defaultlib "libcmt.lib" conflicts with use of other libs; use /NODEFAULTLIB:library
+
+ 
+
+This will happen, for example, when you link a glut app with an FTGL library
+
+compiled with different codegen options than the GLUT library. 
+
+
+
+MSVC++ "sort of" 
+
+requires that all libs be linked with the same codegen option. GLUT is built
+
+in XXX mode, so if you're linking with GLUT, you can get rid of the warning
+
+by linking with the XXX version of FTGL. The various versions are particularly
+
+useful if you're doing std C stuff, like printf etc. 
+
+
+
+
+
+
+
+FAQ
+
+
+
+Q: "But... do I HAVE to use all these DIFFERENT build modes, like multi-
+
+   threaded, debug single threaded, etc?"
+
+   
+
+A: No. Sometimes library makers only generate one style anyway. It depends
+
+   on your needs. Unless you're linking with standard C stuff (e.g. printf)
+
+   then it probably won't make a great deal of difference. If you get 
+
+   warnings about "default lib libcmt.lib conflicts" etc, then you can make
+
+   use of the different libraries.
+
+
+
diff --git a/extern/bFTGL/win32_vcpp/ftgl.dsw b/extern/bFTGL/win32_vcpp/ftgl.dsw
new file mode 100644
index 00000000000..17b8fbe6f12
--- /dev/null
+++ b/extern/bFTGL/win32_vcpp/ftgl.dsw
@@ -0,0 +1,92 @@
+Microsoft Developer Studio Workspace File, Format Version 6.00
+# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
+
+###############################################################################
+
+Project: "ftgl_demo"=".\ftgl_demo\ftgl_demo.dsp" - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+    Begin Project Dependency
+    Project_Dep_Name ftgl_dll
+    End Project Dependency
+    Begin Project Dependency
+    Project_Dep_Name ftgl_static_lib
+    End Project Dependency
+}}}
+
+###############################################################################
+
+Project: "ftgl_demo_2"=".\ftgl_demo\ftgl_demo_2.dsp" - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+    Begin Project Dependency
+    Project_Dep_Name ftgl_dll
+    End Project Dependency
+    Begin Project Dependency
+    Project_Dep_Name ftgl_static_lib
+    End Project Dependency
+}}}
+
+###############################################################################
+
+Project: "ftgl_dll"=".\ftgl_dll\ftgl_dll.dsp" - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Project: "ftgl_static_lib"=".\ftgl_static_lib\ftgl_static_lib.dsp" - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Project: "unit_tests"=".\unit_tests\unit_tests.dsp" - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+    Begin Project Dependency
+    Project_Dep_Name ftgl_static_lib
+    End Project Dependency
+}}}
+
+###############################################################################
+
+Global:
+
+Package=<5>
+{{{
+}}}
+
+Package=<3>
+{{{
+}}}
+
+###############################################################################
+
diff --git a/extern/bFTGL/win32_vcpp/ftgl_dll/ftgl_dll.dsp b/extern/bFTGL/win32_vcpp/ftgl_dll/ftgl_dll.dsp
new file mode 100644
index 00000000000..7e297df9111
--- /dev/null
+++ b/extern/bFTGL/win32_vcpp/ftgl_dll/ftgl_dll.dsp
@@ -0,0 +1,357 @@
+# Microsoft Developer Studio Project File - Name="ftgl_dll" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102
+
+CFG=ftgl_dll - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "ftgl_dll.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "ftgl_dll.mak" CFG="ftgl_dll - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "ftgl_dll - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE "ftgl_dll - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE "ftgl_dll - Win32 Release MT" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE "ftgl_dll - Win32 Debug MT" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+MTL=midl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "ftgl_dll - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release_ST"
+# PROP BASE Intermediate_Dir "Release_ST"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "../Build"
+# PROP Intermediate_Dir "Release_ST"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir "../Build"
+# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "FTGL_DLL_EXPORTS" /YX /FD /c
+# ADD CPP /nologo /MT /W3 /GX /O2 /I "D:\cots\freetype-2.0.5\include" /I "..\..\include" /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "FTGL_LIBRARY" /YX /FD /c
+# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib opengl32.lib glu32.lib freetype204.lib /nologo /dll /machine:I386 /out:"../Build/ftgl_dynamic_MT.dll" /libpath:"D:\cots\freetype-2.0.5\objs"
+
+!ELSEIF  "$(CFG)" == "ftgl_dll - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug_ST"
+# PROP BASE Intermediate_Dir "Debug_ST"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "../Build"
+# PROP Intermediate_Dir "Debug_ST"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir "../Build"
+# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "FTGL_DLL_EXPORTS" /YX /FD /GZ /c
+# ADD CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /I "D:\cots\freetype-2.0.5\include" /I "..\..\include" /D "_DEBUG" /D "WIN32" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "FTGL_LIBRARY" /YX /FD /GZ /c
+# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib opengl32.lib glu32.lib freetype204_D.lib /nologo /dll /pdb:"Debug_ST/ftgl_dynamic_ST_d.pdb" /debug /machine:I386 /out:"../Build/ftgl_dynamic_MT_d.dll" /pdbtype:sept /libpath:"D:\cots\freetype-2.0.5\objs"
+# SUBTRACT LINK32 /pdb:none
+
+!ELSEIF  "$(CFG)" == "ftgl_dll - Win32 Release MT"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release_MT"
+# PROP BASE Intermediate_Dir "Release_MT"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "../Build"
+# PROP Intermediate_Dir "Release_MT"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir "../Build"
+# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "FTGL_DLL_EXPORTS" /YX /FD /c
+# ADD CPP /nologo /MD /W3 /GX /O2 /I "D:\cots\freetype-2.0.5\include" /I "..\..\include" /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "FTGL_LIBRARY" /YX /FD /c
+# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib opengl32.lib glu32.lib freetype204MT.lib /nologo /dll /machine:I386 /out:"../Build/ftgl_dynamic_MTD.dll" /libpath:"D:\cots\freetype-2.0.5\objs"
+
+!ELSEIF  "$(CFG)" == "ftgl_dll - Win32 Debug MT"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug_MT"
+# PROP BASE Intermediate_Dir "Debug_MT"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "../Build"
+# PROP Intermediate_Dir "Debug_MT"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir "../Build"
+# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "FTGL_DLL_EXPORTS" /YX /FD /GZ /c
+# ADD CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /I "D:\cots\freetype-2.0.5\include" /I "..\..\include" /D "_DEBUG" /D "WIN32" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "FTGL_LIBRARY" /YX /FD /GZ /c
+# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib opengl32.lib glu32.lib freetype204MT_D.lib /nologo /dll /pdb:"Debug_ST/ftgl_dynamic_MT_d.pdb" /debug /machine:I386 /out:"../Build/ftgl_dynamic_MTD_d.dll" /pdbtype:sept /libpath:"D:\cots\freetype-2.0.5\objs"
+# SUBTRACT LINK32 /pdb:none
+
+!ENDIF 
+
+# Begin Target
+
+# Name "ftgl_dll - Win32 Release"
+# Name "ftgl_dll - Win32 Debug"
+# Name "ftgl_dll - Win32 Release MT"
+# Name "ftgl_dll - Win32 Debug MT"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
+# Begin Source File
+
+SOURCE=..\..\src\FTBitmapGlyph.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\FTCharmap.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\FTContour.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\FTExtrdGlyph.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\FTFace.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\FTFont.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\FTGLBitmapFont.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\FTGLExtrdFont.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\FTGLOutlineFont.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\FTGLPixmapFont.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\FTGLPolygonFont.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\FTGLTextureFont.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\FTGlyph.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\FTGlyphContainer.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\FTLibrary.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\FTOutlineGlyph.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\FTPixmapGlyph.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\FTPoint.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\FTPolyGlyph.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\FTSize.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\FTTextureGlyph.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\FTVectoriser.cpp
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl"
+# Begin Source File
+
+SOURCE=..\..\include\FTBBox.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\include\FTBitmapGlyph.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\include\FTCharmap.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\include\FTCharToGlyphIndexMap.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\include\FTContour.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\include\FTExtrdGlyph.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\include\FTFace.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\include\FTFont.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\include\FTGL.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\include\FTGLBitmapFont.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\include\FTGLExtrdFont.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\include\FTGLOutlineFont.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\include\FTGLPixmapFont.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\include\FTGLPolygonFont.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\include\FTGLTextureFont.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\include\FTGlyph.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\include\FTGlyphContainer.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\include\FTLibrary.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\include\FTList.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\include\FTOutlineGlyph.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\include\FTPixmapGlyph.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\include\FTPoint.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\include\FTPolyGlyph.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\include\FTSize.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\include\FTTextureGlyph.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\include\FTVector.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\include\FTVectoriser.h
+# End Source File
+# End Group
+# Begin Group "Resource Files"
+
+# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
+# End Group
+# End Target
+# End Project
diff --git a/extern/bFTGL/win32_vcpp/ftgl_static_lib/ftgl_static_lib.dsp b/extern/bFTGL/win32_vcpp/ftgl_static_lib/ftgl_static_lib.dsp
new file mode 100644
index 00000000000..06ca55c1901
--- /dev/null
+++ b/extern/bFTGL/win32_vcpp/ftgl_static_lib/ftgl_static_lib.dsp
@@ -0,0 +1,338 @@
+# Microsoft Developer Studio Project File - Name="ftgl_static_lib" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Static Library" 0x0104
+
+CFG=ftgl_static_lib - Win32 Debug MT
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "ftgl_static_lib.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "ftgl_static_lib.mak" CFG="ftgl_static_lib - Win32 Debug MT"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "ftgl_static_lib - Win32 Release" (based on "Win32 (x86) Static Library")
+!MESSAGE "ftgl_static_lib - Win32 Debug" (based on "Win32 (x86) Static Library")
+!MESSAGE "ftgl_static_lib - Win32 Debug MT" (based on "Win32 (x86) Static Library")
+!MESSAGE "ftgl_static_lib - Win32 Release MT" (based on "Win32 (x86) Static Library")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "ftgl_static_lib - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release_ST"
+# PROP BASE Intermediate_Dir "Release_ST"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release_ST"
+# PROP Intermediate_Dir "Release_ST"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /FD /c
+# ADD CPP /nologo /MT /W3 /GX /O2 /I "D:\cots\freetype-2.0.5\include" /I "..\..\include" /D "NDEBUG" /D "WIN32" /D "_MBCS" /D "_LIB" /D "FTGL_LIBRARY_STATIC" /YX /FD /c
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo /out:"..\Build\ftgl_static_MT.lib"
+
+!ELSEIF  "$(CFG)" == "ftgl_static_lib - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug_ST"
+# PROP BASE Intermediate_Dir "Debug_ST"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug_ST"
+# PROP Intermediate_Dir "Debug_ST"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c
+# ADD CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /I "D:\cots\freetype-2.0.5\include" /I "..\..\include" /D "_DEBUG" /D "WIN32" /D "_MBCS" /D "_LIB" /D "FTGL_LIBRARY_STATIC" /YX /FD /GZ /c
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo /out:"..\Build\ftgl_static_MT_d.lib"
+
+!ELSEIF  "$(CFG)" == "ftgl_static_lib - Win32 Debug MT"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug_MT"
+# PROP BASE Intermediate_Dir "Debug_MT"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug_MT"
+# PROP Intermediate_Dir "Debug_MT"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /I "D:\cots\freetype-2.0.5\include" /D "_DEBUG" /D "WIN32" /D "_MBCS" /D "_LIB" /D "FTGL_LIBRARY_STATIC" /YX /FD /GZ /c
+# ADD CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /I "D:\cots\freetype-2.0.5\include" /I "..\..\include" /D "_DEBUG" /D "WIN32" /D "_MBCS" /D "_LIB" /D "FTGL_LIBRARY_STATIC" /YX /FD /GZ /c
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo /out:"..\Build\ftgl_static_MTD_d.lib"
+
+!ELSEIF  "$(CFG)" == "ftgl_static_lib - Win32 Release MT"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release_MT"
+# PROP BASE Intermediate_Dir "Release_MT"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release_MT"
+# PROP Intermediate_Dir "Release_MT"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "NDEBUG" /D "WIN32" /D "_MBCS" /D "_LIB" /D "FTGL_LIBRARY_STATIC" /YX /FD /c
+# ADD CPP /nologo /MD /W3 /GX /O2 /I "D:\cots\freetype-2.0.5\include" /I "..\..\include" /D "NDEBUG" /D "WIN32" /D "_MBCS" /D "_LIB" /D "FTGL_LIBRARY_STATIC" /YX /FD /c
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo /out:"..\Build\ftgl_static_MTD.lib"
+
+!ENDIF 
+
+# Begin Target
+
+# Name "ftgl_static_lib - Win32 Release"
+# Name "ftgl_static_lib - Win32 Debug"
+# Name "ftgl_static_lib - Win32 Debug MT"
+# Name "ftgl_static_lib - Win32 Release MT"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
+# Begin Source File
+
+SOURCE=..\..\src\FTBitmapGlyph.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\FTCharmap.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\FTContour.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\FTExtrdGlyph.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\FTFace.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\FTFont.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\FTGLBitmapFont.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\FTGLExtrdFont.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\FTGLOutlineFont.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\FTGLPixmapFont.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\FTGLPolygonFont.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\FTGLTextureFont.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\FTGlyph.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\FTGlyphContainer.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\FTLibrary.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\FTOutlineGlyph.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\FTPixmapGlyph.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\FTPoint.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\FTPolyGlyph.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\FTSize.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\FTTextureGlyph.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\src\FTVectoriser.cpp
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl"
+# Begin Source File
+
+SOURCE=..\..\include\FTBBox.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\include\FTBitmapGlyph.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\include\FTCharmap.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\include\FTCharToGlyphIndexMap.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\include\FTContour.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\include\FTExtrdGlyph.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\include\FTFace.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\include\FTFont.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\include\FTGL.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\include\FTGLBitmapFont.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\include\FTGLExtrdFont.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\include\FTGLOutlineFont.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\include\FTGLPixmapFont.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\include\FTGLPolygonFont.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\include\FTGLTextureFont.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\include\FTGlyph.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\include\FTGlyphContainer.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\include\FTLibrary.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\include\FTList.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\include\FTOutlineGlyph.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\include\FTPixmapGlyph.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\include\FTPoint.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\include\FTPolyGlyph.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\include\FTSize.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\include\FTTextureGlyph.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\include\FTVector.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\include\FTVectoriser.h
+# End Source File
+# End Group
+# End Target
+# End Project
diff --git a/extern/bFTGL/win32_vcpp/unit_tests/unit_tests.dsp b/extern/bFTGL/win32_vcpp/unit_tests/unit_tests.dsp
new file mode 100644
index 00000000000..f68dfe9b2d8
--- /dev/null
+++ b/extern/bFTGL/win32_vcpp/unit_tests/unit_tests.dsp
@@ -0,0 +1,168 @@
+# Microsoft Developer Studio Project File - Name="unit_tests" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Console Application" 0x0103
+
+CFG=unit_tests - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "unit_tests.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "unit_tests.mak" CFG="unit_tests - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "unit_tests - Win32 Release" (based on "Win32 (x86) Console Application")
+!MESSAGE "unit_tests - Win32 Debug" (based on "Win32 (x86) Console Application")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "unit_tests - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /Yu"stdafx.h" /FD /c
+# ADD CPP /nologo /MD /W3 /GX /O2 /I "$(MIC_COTS_CPPUNIT_DIR)/include" /I "../../include" /I "../../extras" /I "D:\cots\freetype-2.0.5\include" /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /D "FTGL_LIBRARY_STATIC" /FD /c
+# SUBTRACT CPP /YX /Yc /Yu
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+# ADD LINK32 freetype204MT.lib ftgl_static_MT.lib cppunit.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib opengl32.lib glu32.lib /nologo /subsystem:console /machine:I386 /libpath:"..\Build" /libpath:"D:\cots\freetype-2.0.5\objs" /libpath:"D:\cots\cppunit-1.9.8\lib"
+
+!ELSEIF  "$(CFG)" == "unit_tests - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /Yu"stdafx.h" /FD /GZ /c
+# ADD CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /I "$(MIC_COTS_CPPUNIT_DIR)/include" /I "../../include" /I "../../extras" /I "D:\cots\freetype-2.0.5\include" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /D "FTGL_LIBRARY_STATIC" /FD /GZ /c
+# SUBTRACT CPP /YX /Yc /Yu
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 freetype204MT_D.lib ftgl_static_MT_d.lib cppunitd.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib opengl32.lib glu32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept /libpath:"..\Build" /libpath:"D:\cots\freetype-2.0.5\objs" /libpath:"D:\cots\cppunit-1.9.8\lib"
+
+!ENDIF 
+
+# Begin Target
+
+# Name "unit_tests - Win32 Release"
+# Name "unit_tests - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
+# Begin Source File
+
+SOURCE="..\..\test\FTBBox-Test.cpp"
+# End Source File
+# Begin Source File
+
+SOURCE="..\..\test\FTCharmap-Test.cpp"
+# End Source File
+# Begin Source File
+
+SOURCE="..\..\test\FTContour-Test.cpp"
+# End Source File
+# Begin Source File
+
+SOURCE="..\..\test\FTFace-Test.cpp"
+# End Source File
+# Begin Source File
+
+SOURCE="..\..\test\FTFont-Test.cpp"
+# End Source File
+# Begin Source File
+
+SOURCE="..\..\test\FTGlyphContainer-Test.cpp"
+# End Source File
+# Begin Source File
+
+SOURCE="..\..\test\FTLibrary-Test.cpp"
+# End Source File
+# Begin Source File
+
+SOURCE="..\..\test\FTList-Test.cpp"
+# End Source File
+# Begin Source File
+
+SOURCE="..\..\test\FTMesh-Test.cpp"
+# End Source File
+# Begin Source File
+
+SOURCE="..\..\test\FTPoint-Test.cpp"
+# End Source File
+# Begin Source File
+
+SOURCE="..\..\test\FTSize-Test.cpp"
+# End Source File
+# Begin Source File
+
+SOURCE="..\..\test\FTTesselation-Test.cpp"
+# End Source File
+# Begin Source File
+
+SOURCE="..\..\test\FTVector-Test.cpp"
+# End Source File
+# Begin Source File
+
+SOURCE="..\..\test\FTVectoriser-Test.cpp"
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\test\HPGCalc_afm.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\test\HPGCalc_pfb.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\test\TestMain.cpp
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl"
+# Begin Source File
+
+SOURCE=..\..\test\Fontdefs.h
+# End Source File
+# End Group
+# End Target
+# End Project