diff options
author | Kent Mein <mein@cs.umn.edu> | 2005-01-21 08:15:33 +0300 |
---|---|---|
committer | Kent Mein <mein@cs.umn.edu> | 2005-01-21 08:15:33 +0300 |
commit | 26f63bfa197e82a6d3a3f298c603f1878891b8f8 (patch) | |
tree | 370880862bd533224e42e7b374f39a43279e79f8 /extern/bFTGL | |
parent | b561ca88cfc2445b82c3dc59bdbb8d9e46ee7e31 (diff) |
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
Diffstat (limited to 'extern/bFTGL')
63 files changed, 7126 insertions, 0 deletions
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 |