git-svn-id: svn://svn.code.sf.net/p/ultrastardx/svn/trunk@1479 b956fd51-792f-4845-bead-9b4dfca2ff2c

10 files changed, 3833 insertions, 5751 deletions

diff --git a/src/base/UFont.pas b/src/base/UFont.pas
index 947a1c6f..30be4c3b 100644
--- a/src/base/UFont.pas
+++ b/src/base/UFont.pas
@@ -1,2646 +1,2698 @@
-unit UFont;

-

-{$IFDEF FPC}

-  {$mode delphi}{$H+}

-{$ENDIF}

-

-{$DEFINE HasInline}

-

-interface

-

-// Flip direction of y-axis.

-// Default is a cartesian coordinate system with y-axis in upper direction

-// but with USDX the y-axis is in lower direction.

-{$DEFINE FLIP_YAXIS}

-{$DEFINE BITMAP_FONT}

-

-uses

-  FreeType,

-  gl,

-  glext,

-  glu,

-  sdl,

-  {$IFDEF BITMAP_FONT}

-  UTexture,

-  {$ENDIF}

-  Math,

-  Classes,

-  SysUtils;

-

-type

-

-  PGLubyteArray = ^TGLubyteArray;

-  TGLubyteArray = array[0 .. (MaxInt div SizeOf(GLubyte))-1] of GLubyte;

-  TGLubyteDynArray = array of GLubyte;

-

-  TWideStringArray = array of WideString;

-

-  TGLColor = packed record

-    case byte of

-      0: ( vals: array[0..3] of GLfloat; );

-      1: ( r, g, b, a: GLfloat; );

-  end;

-

-  TBoundsDbl = record

-    Left, Right: double;

-    Bottom, Top: double;

-  end;

-

-  TPositionDbl = record

-    X, Y: double;

-  end;

-

-  TTextureSize = record

-    Width, Height: integer;

-  end;

-

-  TBitmapCoords = record

-    Left, Top: double;

-    Width, Height: integer;

-  end;

-

-  {**

-   * Abstract base class representing a glyph.

-   *}

-  TGlyph = class

-    protected

-      function GetAdvance(): TPositionDbl; virtual; abstract;

-      function GetBounds(): TBoundsDbl; virtual; abstract;

-    public

-      procedure Render(UseDisplayLists: boolean); virtual; abstract;

-      procedure RenderReflection(); virtual; abstract;

-

-      {** Distance to next glyph (in pixels) *}

-      property Advance: TPositionDbl read GetAdvance;

-      {** Glyph bounding box (in pixels) *}

-      property Bounds: TBoundsDbl read GetBounds;

-  end;

-

-  {**

-   * Font styles used by TFont.Style

-   *}

-  TFontStyle = set of (Italic, Underline, Reflect);

-

-  {**

-   * Base font class.

-   *}

-  TFont = class

-    private

-      {** Non-virtual reset-method used in Create() and Reset() }

-      procedure ResetIntern();

-

-    protected

-      fStyle: TFontStyle;

-      fUseKerning: boolean;       

-      fLineSpacing: single;       // must be inited by subclass

-      fReflectionSpacing: single; // must be inited by subclass to -2*Descender

-      fGlyphSpacing: single;

-      fReflectionPass: boolean;

-

-      {**

-       * Splits lines in Text seperated by newline (char-code #13).

-       * @param Text   UTF-8 encoded string

-       * @param Lines  splitted WideString lines

-       *}

-      procedure SplitLines(const Text: UTF8String; var Lines: TWideStringArray);

-

-      {**

-       * Print an array of WideStrings. Each array-item is a line of text.

-       * Lines of text are seperated by the line-spacing.

-       * This is the base function for all text drawing.

-       *}

-      procedure Print(const Text: TWideStringArray); overload; virtual;

-

-      {**

+{* UltraStar Deluxe - Karaoke Game
+ *
+ * UltraStar Deluxe is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * 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.
+ *
+ * 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; see the file COPYING. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ *
+ * $URL$
+ * $Id$
+ *}
+
+unit UFont;
+
+{$IFDEF FPC}
+  {$MODE Delphi}
+{$ENDIF}
+
+{$I switches.inc}
+
+interface
+
+{$IFNDEF FREETYPE_DEMO}
+  // Flip direction of y-axis.
+  // Default is a cartesian coordinate system with y-axis in upper direction
+  // but with USDX the y-axis is in lower direction.
+  {$DEFINE FLIP_YAXIS}
+  {$DEFINE BITMAP_FONT}
+{$ENDIF}
+
+uses
+  FreeType,
+  gl,
+  glext,
+  glu,
+  sdl,
+  {$IFDEF BITMAP_FONT}
+  UTexture,
+  {$ENDIF}
+  Math,
+  Classes,
+  SysUtils;
+
+type
+
+  PGLubyteArray = ^TGLubyteArray;
+  TGLubyteArray = array[0 .. (MaxInt div SizeOf(GLubyte))-1] of GLubyte;
+  TGLubyteDynArray = array of GLubyte;
+
+  TWideStringArray = array of WideString;
+
+  TGLColor = packed record
+    case byte of
+      0: ( vals: array[0..3] of GLfloat; );
+      1: ( r, g, b, a: GLfloat; );
+  end;
+
+  TBoundsDbl = record
+    Left, Right: double;
+    Bottom, Top: double;
+  end;
+
+  TPositionDbl = record
+    X, Y: double;
+  end;
+
+  TTextureSize = record
+    Width, Height: integer;
+  end;
+
+  TBitmapCoords = record
+    Left, Top: double;
+    Width, Height: integer;
+  end;
+
+  {**
+   * Abstract base class representing a glyph.
+   *}
+  TGlyph = class
+    protected
+      function GetAdvance(): TPositionDbl; virtual; abstract;
+      function GetBounds(): TBoundsDbl; virtual; abstract;
+    public
+      procedure Render(UseDisplayLists: boolean); virtual; abstract;
+      procedure RenderReflection(); virtual; abstract;
+
+      {** Distance to next glyph (in pixels) *}
+      property Advance: TPositionDbl read GetAdvance;
+      {** Glyph bounding box (in pixels) *}
+      property Bounds: TBoundsDbl read GetBounds;
+  end;
+
+  {**
+   * Font styles used by TFont.Style
+   *}
+  TFontStyle = set of (Italic, Underline, Reflect);
+
+  {**
+   * Base font class.
+   *}
+  TFont = class
+    private
+      {** Non-virtual reset-method used in Create() and Reset() }
+      procedure ResetIntern();
+
+    protected
+      fStyle: TFontStyle;
+      fUseKerning: boolean;       
+      fLineSpacing: single;       // must be inited by subclass
+      fReflectionSpacing: single; // must be inited by subclass to -2*Descender
+      fGlyphSpacing: single;
+      fReflectionPass: boolean;
+
+      {**
+       * Splits lines in Text seperated by newline (char-code #13).
+       * @param Text   UTF-8 encoded string
+       * @param Lines  splitted WideString lines
+       *}
+      procedure SplitLines(const Text: UTF8String; var Lines: TWideStringArray);
+
+      {**
+       * Print an array of WideStrings. Each array-item is a line of text.
+       * Lines of text are seperated by the line-spacing.
+       * This is the base function for all text drawing.
+       *}
+      procedure Print(const Text: TWideStringArray); overload; virtual;
+
+      {**
        * Draws an underline.
        *}
-      procedure DrawUnderline(const Text: WideString); virtual;

-

-      {**

-       * Renders (one) line of text.

-       *}

-      procedure Render(const Text: WideString); virtual; abstract;

-

-      {**

-       * Returns the bounds of text-lines contained in Text.

-       * @param(Advance  if true the right bound is set to the advance instead

-       *   of the minimal right bound.)

-       *}

-      function BBox(const Text: TWideStringArray; Advance: boolean): TBoundsDbl; overload; virtual; abstract;

-

-      {**

-       * Resets all user settings to default values.

-       * Override methods should always call the inherited version.

-       *}

-      procedure Reset(); virtual;

-

-      function GetHeight(): single; virtual; abstract;

-      function GetAscender(): single; virtual; abstract;

-      function GetDescender(): single; virtual; abstract;

-      procedure SetLineSpacing(Spacing: single); virtual;

-      function GetLineSpacing(): single; virtual;

-      procedure SetGlyphSpacing(Spacing: single); virtual;

-      function GetGlyphSpacing(): single; virtual;

-      procedure SetReflectionSpacing(Spacing: single); virtual;

-      function GetReflectionSpacing(): single; virtual;

-      procedure SetStyle(Style: TFontStyle); virtual;

-      function GetStyle(): TFontStyle; virtual;

-      function GetUnderlinePosition(): single; virtual; abstract;

-      function GetUnderlineThickness(): single; virtual; abstract;

-      procedure SetUseKerning(Enable: boolean); virtual;

-      function GetUseKerning(): boolean; virtual;

-      procedure SetReflectionPass(Enable: boolean); virtual;

-

-      {** Returns true if the current render-pass is used to draw the reflection }

-      property ReflectionPass: boolean read fReflectionPass write SetReflectionPass;

-

-    public

-      constructor Create();

-      destructor Destroy(); override;

-

-      {**

-       * Prints a text.

-       *}

-      procedure Print(const Text: WideString); overload;

-      {** UTF-8 version of @link(Print) }

-      procedure Print(const Text: string); overload;

-

-      {**

-       * Calculates the bounding box (width and height) around Text.

-       * Works with Italic and Underline styles but reflections created

-       * with the Reflect style are not considered.

-       * Note that the width might differ due to kerning with appended text,

-       * e.g. Width('VA') <= Width('V') + Width('A').

-       * @param Advance  if set to true, Result.Right is set to the advance of

-       * the given text rather than the min. right border. The advance width is

-       * bigger than the text's width as it additionally contains the advance

-       * and glyph-spacing of the last character.

-       *}

-      function BBox(const Text: WideString; Advance: boolean = false): TBoundsDbl; overload;

-      {** UTF-8 version of @link(BBox) }

-      function BBox(const Text: UTF8String; Advance: boolean = false): TBoundsDbl; overload;

-

-      {** Font height }

-      property Height: single read GetHeight;

-      {** Vertical distance from baseline to top of glyph }

-      property Ascender: single read GetAscender;

-      {** Vertical distance from baseline to bottom of glyph }

-      property Descender: single read GetDescender;

-      {** Vertical distance between two baselines }

-      property LineSpacing: single read GetLineSpacing write SetLineSpacing;

-      {** Space between end and start of next glyph added to the advance width }

-      property GlyphSpacing: single read GetGlyphSpacing write SetGlyphSpacing;

-      {** Distance between normal baseline and baseline of the reflection }

-      property ReflectionSpacing: single read GetReflectionSpacing write SetReflectionSpacing;

-      {** Font style (italic/underline/...) }

-      property Style: TFontStyle read GetStyle write SetStyle;

-      {** If set to true (default) kerning will be used if available }

-      property UseKerning: boolean read GetUseKerning write SetUseKerning;

-  end;

-

-const

-  //** Max. number of mipmap levels that a TScalableFont can contain

-  cMaxMipmapLevel = 5;

-

-type

-  {**

-   * Wrapper around TFont to allow font size changes.

-   * The font is scaled to the requested size by a modelview matrix

-   * transformation (glScale) and not by rescaling the internal bitmap

-   * representation. This way changing the size is really fast but the result

-   * may lack quality on large or small scale factors.

-   *}

-  TScalableFont = class(TFont)

-    private

-      procedure ResetIntern();

-

-    protected

-      fScale: single;        //**< current height to base-font height ratio 

-      fAspect: single;       //**< width to height aspect

-      fBaseFont: TFont;      //**< shortcut for fMipmapFonts[0]

-      fUseMipmaps: boolean;  //**< true if mipmap fonts are generated

-      /// Mipmap fonts (size[level+1] = size[level]/2)

-      fMipmapFonts: array[0..cMaxMipmapLevel] of TFont;

-

-      procedure Render(const Text: WideString); override;

-      procedure Print(const Text: TWideStringArray); override;

-      function BBox(const Text: TWideStringArray; Advance: boolean): TBoundsDbl; override;

-

-      {**

-       * Callback called for creation of each mipmap font.

-       * Must be defined by the subclass.

-       * Mipmaps created by this method are managed and freed by TScalableFont.

-       *}

-      function CreateMipmap(Level: integer; Scale: single): TFont; virtual; abstract;

-

-      {**

-       * Returns the mipmap level considering the current scale and projection

-       * matrix.

-       *}

-      function GetMipmapLevel(): integer;

-

-      {**

-       * Returns the scale applied to the given mipmap font.

-       * fScale * fBaseFont.Height / fMipmapFont[Level].Height

-       *}

-      function GetMipmapScale(Level: integer): single;

-

-      {**

-       * Chooses the mipmap that looks nicest with current scale and projection

-       * matrix.

-       *}

-      function ChooseMipmapFont(): TFont;

-

-      procedure SetHeight(Height: single); virtual;

-      function GetHeight(): single; override;

-      procedure SetAspect(Aspect: single); virtual;

-      function GetAspect(): single; virtual;

-      function GetAscender(): single; override;

-      function GetDescender(): single; override;

-      procedure SetLineSpacing(Spacing: single); override;

-      function GetLineSpacing(): single; override;

-      procedure SetGlyphSpacing(Spacing: single); override;

-      function GetGlyphSpacing(): single; override;

-      procedure SetReflectionSpacing(Spacing: single); override;

-      function GetReflectionSpacing(): single; override;

-      procedure SetStyle(Style: TFontStyle); override;

-      function GetStyle(): TFontStyle; override;

-      function GetUnderlinePosition(): single; override;

-      function GetUnderlineThickness(): single; override;

-      procedure SetUseKerning(Enable: boolean); override;

-

-    public

-      {**

-       * Creates a wrapper to make the base-font Font scalable.

-       * If UseMipmaps is set to true smaller fonts are created so that a

-       * resized (Height property changed) font looks nicer.

-       * The font passed is managed and freed by TScalableFont.

-       *}

-      constructor Create(Font: TFont; UseMipmaps: boolean); overload;

-

-      {**

-       * Frees memory. The fonts passed on Create() and mipmap creation

-       * are freed too. 

-       *}

-      destructor Destroy(); override;

-

-      {** @seealso TFont.Reset }

-      procedure Reset(); override;

-

-      {** Font height }

-      property Height: single read GetHeight write SetHeight;

-      {** Factor for font stretching (NewWidth = Width*Aspect), 1.0 by default }

-      property Aspect: single read GetAspect write SetAspect;

-  end;

-

-  {**

-   * Table for storage of max. 256 glyphs.

-   * Used for the second cache level. Indexed by the LSB of the WideChar

-   * char-code.

-   *}

-  PGlyphTable = ^TGlyphTable;

-  TGlyphTable = array[0..255] of TGlyph;

-

-  {**

-   * Cache for glyphs of a single font.

-   * The cached glyphs are stored inside a hash-list.

-   * Hashing is performed in two steps:

-   * 1. the least significant byte (LSB) of the WideChar character code

-   * is removed (shr 8) and the result (we call it BaseCode here) looked up in

-   * the hash-list.

-   * 2. Each entry of the hash-list contains a table with max. 256 entries.

-   * The LSB of the char-code of a glyph is the table-offset of that glyph.

-   *}

-  TGlyphCache = class

-    private

-      fHash: TList;

-

-      {**

-       * Finds a glyph-table storing cached glyphs with base-code BaseCode

-       * (= upper char-code bytes) in the hash-list and returns the table and

-       * its index.

-       * @param(InsertPos  the position of the tyble in the list if it was found,

-       *                   otherwise the position the table should be inserted)

-       *}

-      function FindGlyphTable(BaseCode: cardinal; out InsertPos: integer): PGlyphTable;

-

-    public

-      constructor Create();

-      destructor Destroy(); override;

-

-      {**

-       * Add glyph Glyph with char-code ch to the cache.

-       * @returns @true on success, @false otherwise

-       *}

-      function AddGlyph(ch: WideChar; const Glyph: TGlyph): boolean;

-

-      {**

-       * Removes the glyph with char-code ch from the cache.

-       *}

-      procedure DeleteGlyph(ch: WideChar);

-

-      {**

-       * Removes the glyph with char-code ch from the cache.

-       *}

-      function GetGlyph(ch: WideChar): TGlyph;

-

-      {**

-       * Checks if a glyph with char-code ch is cached.

-       *}

-      function HasGlyph(ch: WideChar): boolean;

-

-      {**

-       * Remove and free all cached glyphs. If KeepBaseSet is set to

-       * true, cached characters in the range 0..255 will not be flushed.

-       *}

-      procedure FlushCache(KeepBaseSet: boolean);

-  end;

-

-  {**

-   * Entry of a glyph-cache's (TGlyphCache) hash.

-   * Stores a BaseCode (upper-bytes of a glyph's char-code) and a table

-   * with all glyphs cached at the moment with that BaseCode.

-   *}

-  TGlyphCacheHashEntry = class

-    private

-      fBaseCode: cardinal;

-    public

-      GlyphTable: TGlyphTable;

-

-      constructor Create(BaseCode: cardinal);

-

-      {** Base-code (upper-bytes) of the glyphs stored in this entry's table }

-      property BaseCode: cardinal read fBaseCode;

-  end;

-

-  TCachedFont = class(TFont)

-    protected

-      fCache: TGlyphCache;

-

-      {**

-       * Retrieves a cached glyph with char-code ch from cache.

-       * If the glyph is not already cached, it is loaded with LoadGlyph().

-       *}

-      function GetGlyph(ch: WideChar): TGlyph;

-

-      {**

-       * Callback to create (load) a glyph with char-code ch.

-       * Implemented by subclasses.

-       *}

-      function LoadGlyph(ch: WideChar): TGlyph; virtual; abstract;

-

-    public

-      constructor Create();

-      destructor Destroy(); override;

-

-      {**

-       * Remove and free all cached glyphs. If KeepBaseSet is set to

-       * true, the base glyphs are not be flushed.

-       * @seealso TGlyphCache.FlushCache

-       *}

-      procedure FlushCache(KeepBaseSet: boolean);

-  end;

-

-  TFTFont = class;

-

-  {**

-   * Freetype glyph.

-   * Each glyph stores a texture with the glyph's image.

-   *}

-  TFTGlyph = class(TGlyph)

-    private

-      fCharIndex: FT_UInt;      //**< Freetype specific char-index (<> char-code)

-      fDisplayList: GLuint;     //**< Display-list ID

-      fTexture: GLuint;         //**< Texture ID

-      fBitmapCoords: TBitmapCoords; //**< Left/Top offset and Width/Height of the bitmap (in pixels)

-      fTexOffset: TPositionDbl; //**< Right and bottom texture offset for removal of power-of-2 padding

-      fTexSize: TTextureSize;   //**< Texture size in pixels

-

-      fFont: TFTFont;           //**< Font associated with this glyph

-      fAdvance: TPositionDbl;   //**< Advance width of this glyph

-      fBounds: TBoundsDbl;      //**< Glyph bounds

-      fOutset: single;          //**< Extrusion outset

-

-      {**

-       * Extrudes the outline of a glyph's bitmap stored in TexBuffer with size

-       * fTexSize by Outset pixels.

-       * This is useful to create bold or outlined fonts.

-       * TexBuffer must be 2*Ceil(Outset) pixels higher and wider than the

-       * original glyph bitmap, otherwise the glyph borders cannot be extruded

-       * correctly.

-       * The bitmap must be 2* pixels wider and higher than the

-       * original glyph's bitmap with the latter centered in it.

-       *}

-      procedure Extrude(var TexBuffer: TGLubyteDynArray; Outset: single);

-

-      {**

-       * Creates an OpenGL texture (and display list) for the glyph.

-       * The glyph's and bitmap's metrics are set correspondingly.

-       * @param  LoadFlags  flags passed to FT_Load_Glyph()

-       * @raises Exception  if the glyph could not be initialized

-       *}

-      procedure CreateTexture(LoadFlags: FT_Int32);

-

-    protected

-      function GetAdvance(): TPositionDbl; override;

-      function GetBounds(): TBoundsDbl; override;

-

-    public

-      {**

-       * Creates a glyph with char-code ch from font Font.

-       * @param LoadFlags  flags passed to FT_Load_Glyph()

-       *}

-      constructor Create(Font: TFTFont; ch: WideChar; Outset: single;

-                         LoadFlags: FT_Int32);

-      destructor Destroy(); override;

-

-      {** Renders the glyph (normal render pass) }

-      procedure Render(UseDisplayLists: boolean); override;

-      {** Renders the glyph's reflection }

-      procedure RenderReflection(); override;

-

-      {** Freetype specific char-index (<> char-code) }

-      property CharIndex: FT_UInt read fCharIndex;

-  end;

-

-  {**

-   * Freetype font class.

-   *}

-  TFTFont = class(TCachedFont)

-    private

-      procedure ResetIntern();

-

-    protected

-      fFilename: string;            //**< filename of the font-file

-      fSize: integer;               //**< Font base size (in pixels)

-      fOutset: single;              //**< size of outset extrusion (in pixels)

-      fFace: FT_Face;               //**< Holds the height of the font

-      fLoadFlags: FT_Int32;         //**< FT glpyh load-flags

-      fFontUnitScale: TPositionDbl; //**< FT font-units to pixel ratio

-      fUseDisplayLists: boolean;    //**< true: use display-lists, false: direct drawing

-

-      {** @seealso TCachedFont.LoadGlyph }

-      function LoadGlyph(ch: WideChar): TGlyph; override;

-

-      procedure Render(const Text: WideString); override;

-      function BBox(const Text: TWideStringArray; Advance: boolean): TBoundsDbl; override;

-

-      function GetHeight(): single; override;

-      function GetAscender(): single; override;

-      function GetDescender(): single; override;

-      function GetUnderlinePosition(): single; override;

-      function GetUnderlineThickness(): single; override;

-

-      property Face: FT_Face read fFace;

-

-    public

-      {**

-       * Creates a font of size Size (in pixels) from the file Filename.

-       * If Outset (in pixels) is set to a value > 0 the glyphs will be extruded

-       * at their borders. Use it for e.g. a bold effect.

-       * @param  LoadFlags  flags passed to FT_Load_Glyph()

-       * @raises Exception  if the font-file could not be loaded

-       *}

-      constructor Create(const Filename: string;

-                         Size: integer; Outset: single = 0.0;

-                         LoadFlags: FT_Int32 = FT_LOAD_DEFAULT);

-

-      {**

-       * Frees all resources associated with the font.

-       *}

-      destructor Destroy(); override;

-

-      {** @seealso TFont.Reset }

-      procedure Reset(); override;

-      

-      {** Size of the base font }

-      property Size: integer read fSize;

-      {** Outset size }

-      property Outset: single read fOutset;

-  end;

-

-  TFTScalableFont = class(TScalableFont)

-    protected

-      function GetOutset(): single; virtual;

-      function CreateMipmap(Level: integer; Scale: single): TFont; override;

-

-    public

-      {**

-       * Creates a scalable font of size Size (in pixels) from the file Filename.

-       * OutsetAmount is the ratio of the glyph extrusion.

-       * The extrusion in pixels is Size*OutsetAmount

-       * (0.0 -> no extrusion, 0.1 -> 10%).

-       *}

-      constructor Create(const Filename: string;

-                         Size: integer; OutsetAmount: single = 0.0;

-                         UseMipmaps: boolean = true);

-

-      {** @seealso TGlyphCache.FlushCache }

-      procedure FlushCache(KeepBaseSet: boolean);

-

-      {** Outset size (in pixels) of the scaled font }

-      property Outset: single read GetOutset;

-  end;

-

-  

-  {**

-   * Represents a freetype font with an additional outline around its glyphs.

-   * The outline size is passed on creation and cannot be changed later.

-   *}

-  TFTOutlineFont = class(TFont)

-    private

-      fFilename: string;

-      fSize: integer;

-      fOutset: single;

-      fInnerFont, fOutlineFont: TFTFont;

-      fOutlineColor: TGLColor;

-

-      procedure ResetIntern();

-      

-  protected

-      procedure DrawUnderline(const Text: WideString); override;

-      procedure Render(const Text: WideString); override;

-      function BBox(const Text: TWideStringArray; Advance: boolean): TBoundsDbl; override;

-

-      function GetHeight(): single; override;

-      function GetAscender(): single; override;

-      function GetDescender(): single; override;

-      procedure SetLineSpacing(Spacing: single); override;

-      procedure SetGlyphSpacing(Spacing: single); override;

-      procedure SetReflectionSpacing(Spacing: single); override;

-      procedure SetStyle(Style: TFontStyle); override;

-      function GetStyle(): TFontStyle; override;

-      function GetUnderlinePosition(): single; override;

-      function GetUnderlineThickness(): single; override;

-      procedure SetUseKerning(Enable: boolean); override;

-      procedure SetReflectionPass(Enable: boolean); override;

-

-    public

-      constructor Create(const Filename: string;

-                         Size: integer; Outset: single;

-                         LoadFlags: FT_Int32 = FT_LOAD_DEFAULT);

-      destructor Destroy; override;

-

-      {** Sets the color of the outline }

-      procedure SetOutlineColor(r, g, b: GLfloat; a: GLfloat = 1.0);

-

-      {** @seealso TGlyphCache.FlushCache }

-      procedure FlushCache(KeepBaseSet: boolean);

-

-      {** @seealso TFont.Reset }

-      procedure Reset(); override;

-

-      {** Size of the base font }

-      property Size: integer read fSize;

-      {** Outset size }

-      property Outset: single read fOutset;

-  end;

-

-  {**

-   * Wrapper around TOutlineFont to allow font resizing.

-   * @seealso TScalableFont

-   *}

-  TFTScalableOutlineFont = class(TScalableFont)

-    protected

-      function GetOutset(): single; virtual;

-      function CreateMipmap(Level: integer; Scale: single): TFont; override;

-

-    public

-      constructor Create(const Filename: string;

-                         Size: integer; OutsetAmount: single;

-                         UseMipmaps: boolean = true);

-

-      {** Sets the color of the outline }

-      procedure SetOutlineColor(r, g, b: GLfloat; a: GLfloat = 1.0);

-

-      {** @seealso TGlyphCache.FlushCache }

-      procedure FlushCache(KeepBaseSet: boolean);

-

-      {** Outset size }

-      property Outset: single read GetOutset;

-  end;

-

-{$IFDEF BITMAP_FONT}

-

-  {**

-   * A bitmapped font loads it's glyphs from a bitmap and stores them in a

-   * texture. Unicode characters are not supported (but could be by supporting

-   * multiple textures each storing a subset of unicode glyphs).

-   * For backward compatibility only.

-   *}

-  TBitmapFont = class(TFont)

-    private

-      fTex:       TTexture;

-      fTexSize:   integer;

-      fBaseline:  integer;

-      fAscender:  integer;

-      fDescender: integer;

-      fWidths:    array[0..255] of byte; //**< half widths

-      fOutline:   integer;

-      fTempColor: TGLColor; //**< colours for the reflection

-

-      procedure ResetIntern();

-

-      procedure RenderChar(ch: WideChar; var AdvanceX: real);

-

-      {**

-       * Load font widths from an info file.

-       * @param  InfoFile  the name of the info (.dat) file

-       * @raises Exception if the file is corrupted

-       *}

-      procedure LoadFontInfo(const InfoFile: string);

-

-    protected

-      procedure Render(const Text: WideString); override;

-      function BBox(const Text: TWideStringArray; Advance: boolean): TBoundsDbl; override;

-

-      function GetHeight(): single; override;

-      function GetAscender(): single; override;

-      function GetDescender(): single; override;

-      function GetUnderlinePosition(): single; override;

-      function GetUnderlineThickness(): single; override;

-

-    public

-      {**

-       * Creates a bitmapped font from image Filename and font width info

-       * loaded from the corresponding file with ending .dat.

-       * @param(Baseline  y-coord of the baseline given in cartesian coords

-       *        (y-axis up) and from the lower edge of the glyphs bounding box)

-       * @param(Ascender  pixels from baseline to top of highest glyph)

-       *}

-      constructor Create(const Filename: string; Outline: integer;

-                         Baseline, Ascender, Descender: integer);

-      destructor Destroy(); override;

-

-      {**

-       * Corrects font widths provided by the info file.

-       * NewWidth := Width * WidthMult + WidthAdd

-       *}

-      procedure CorrectWidths(WidthMult: real; WidthAdd: integer);

-

-      {** @seealso TFont.Reset }

-      procedure Reset(); override;

-  end;

-

-{$ENDIF BITMAP_FONT}

-

-  TFreeType = class

-    public

-      {**

-       * Returns a pointer to the freetype library singleton.

-       * If non exists, freetype will be initialized.

-       * @raises Exception if initialization failed

-       *}

-      class function GetLibrary(): FT_Library;

-      class procedure FreeLibrary();

-  end;

-

-

-implementation

-

-uses Types;

-

-const

-  //** shear factor used for the italic effect (bigger value -> more bending)

-  cShearFactor = 0.25;

-  cShearMatrix: array[0..15] of GLfloat = (

-      1,            0, 0, 0,

-      cShearFactor, 1, 0, 0,

-      0,            0, 1, 0,

-      0,            0, 0, 1

-  );

-  cShearMatrixInv: array[0..15] of GLfloat = (

-      1,             0, 0, 0,

-      -cShearFactor, 1, 0, 0,

-      0,             0, 1, 0,

-      0,             0, 0, 1

-  );

-

-var

-  LibraryInst: FT_Library;

-

-function NewGLColor(r, g, b, a: GLfloat): TGLColor;

-begin

-  Result.r := r;

-  Result.g := g;

-  Result.b := b;

-  Result.a := a;

-end;

-

-{**

- * Returns the first power of 2 >= Value.

- *}

-function NextPowerOf2(Value: integer): integer; {$IFDEF HasInline}inline;{$ENDIF}

-begin

-  Result := 1;

-  while (Result < Value) do

-    Result := Result shl 1;

-end;

-

-

-{*

- * TFont

- *}

-

-constructor TFont.Create();

-begin

-  inherited;

-  ResetIntern();

-end;

-

-destructor TFont.Destroy();

-begin

-  inherited;

-end;

-

-procedure TFont.ResetIntern();

-begin

-  fStyle := [];

-  fUseKerning := true;

-  fGlyphSpacing := 0.0;

-  fReflectionPass := false;

-

-  // must be set by subclasses

-  fLineSpacing := 0.0;

-  fReflectionSpacing := 0.0;

-end;

-

-procedure TFont.Reset();

-begin

-  ResetIntern();

-end;

-

-procedure TFont.SplitLines(const Text: UTF8String; var Lines: TWideStringArray);

-var

-  LineList: TStringList;

-  LineIndex: integer;

-begin

-  // split lines on newline (there is no WideString version of ExtractStrings)

-  LineList := TStringList.Create();

-  ExtractStrings([#13], [], PChar(Text), LineList);

-

-  // create an array of WideStrins from the UTF-8 string-list

-  SetLength(Lines, LineList.Count);

-  for LineIndex := 0 to LineList.Count-1 do

-    Lines[LineIndex] := UTF8Decode(LineList[LineIndex]);

-  LineList.Free();

-end;

-

-function TFont.BBox(const Text: UTF8String; Advance: boolean): TBoundsDbl;

-var

-  LineArray: TWideStringArray;

-begin

-  SplitLines(Text, LineArray);

-  Result := BBox(LineArray, Advance);

-  SetLength(LineArray, 0);

-end;

-

-function TFont.BBox(const Text: WideString; Advance: boolean): TBoundsDbl;

-begin

-  Result := BBox(UTF8Encode(Text), Advance);

-end;

-

-procedure TFont.Print(const Text: TWideStringArray);

-var

-  LineIndex: integer;

-begin

-  // recursively call this function to draw reflected text

-  if ((Reflect in Style) and not ReflectionPass) then

-  begin

-    ReflectionPass := true;

-    Print(Text);

-    ReflectionPass := false;

-  end;

-

-  // store current color, enable-flags, matrix-mode

-  glPushAttrib(GL_CURRENT_BIT or GL_ENABLE_BIT or GL_TRANSFORM_BIT);

-

-  // set OpenGL state

-  glMatrixMode(GL_MODELVIEW);

-  glDisable(GL_DEPTH_TEST);

-  glEnable(GL_BLEND);

-  glEnable(GL_TEXTURE_2D);

-  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

-

-  {

-  // TODO: just draw texels with alpha > 0 to avoid setting z-buffer for them?

-  glAlphaFunc(GL_GREATER, 0);

-  glEnable(GL_ALPHA_TEST);

-

-  //TODO: Do we need depth-testing?

-  if (ReflectionPass) then

-  begin

-    glDepthMask(0);

-    glEnable(GL_DEPTH_TEST);

-  end;

-  }

-

-  {$IFDEF FLIP_YAXIS}

-  glPushMatrix();

-  glScalef(1, -1, 1);

-  {$ENDIF}

-

-  // display text

-  for LineIndex := 0 to High(Text) do

-  begin

-    glPushMatrix();

-

-    // move to baseline

-    glTranslatef(0, -LineSpacing*LineIndex, 0);

-

-    if ((Underline in Style) and not ReflectionPass) then

-    begin

-      glDisable(GL_TEXTURE_2D);

-      DrawUnderline(Text[LineIndex]);

-      glEnable(GL_TEXTURE_2D);

-    end;

-

-    // draw reflection

-    if (ReflectionPass) then

-    begin

-      // set reflection spacing

-      glTranslatef(0, -ReflectionSpacing, 0);

-      // flip y-axis

-      glScalef(1, -1, 1);

-    end;

-

-    // shear for italic effect

-    if (Italic in Style) then

-      glMultMatrixf(@cShearMatrix);

-

+      procedure DrawUnderline(const Text: WideString); virtual;
+
+      {**
+       * Renders (one) line of text.
+       *}
+      procedure Render(const Text: WideString); virtual; abstract;
+
+      {**
+       * Returns the bounds of text-lines contained in Text.
+       * @param(Advance  if true the right bound is set to the advance instead
+       *   of the minimal right bound.)
+       *}
+      function BBox(const Text: TWideStringArray; Advance: boolean): TBoundsDbl; overload; virtual; abstract;
+
+      {**
+       * Resets all user settings to default values.
+       * Override methods should always call the inherited version.
+       *}
+      procedure Reset(); virtual;
+
+      function GetHeight(): single; virtual; abstract;
+      function GetAscender(): single; virtual; abstract;
+      function GetDescender(): single; virtual; abstract;
+      procedure SetLineSpacing(Spacing: single); virtual;
+      function GetLineSpacing(): single; virtual;
+      procedure SetGlyphSpacing(Spacing: single); virtual;
+      function GetGlyphSpacing(): single; virtual;
+      procedure SetReflectionSpacing(Spacing: single); virtual;
+      function GetReflectionSpacing(): single; virtual;
+      procedure SetStyle(Style: TFontStyle); virtual;
+      function GetStyle(): TFontStyle; virtual;
+      function GetUnderlinePosition(): single; virtual; abstract;
+      function GetUnderlineThickness(): single; virtual; abstract;
+      procedure SetUseKerning(Enable: boolean); virtual;
+      function GetUseKerning(): boolean; virtual;
+      procedure SetReflectionPass(Enable: boolean); virtual;
+
+      {** Returns true if the current render-pass is used to draw the reflection }
+      property ReflectionPass: boolean read fReflectionPass write SetReflectionPass;
+
+    public
+      constructor Create();
+      destructor Destroy(); override;
+
+      {**
+       * Prints a text.
+       *}
+      procedure Print(const Text: WideString); overload;
+      {** UTF-8 version of @link(Print) }
+      procedure Print(const Text: string); overload;
+
+      {**
+       * Calculates the bounding box (width and height) around Text.
+       * Works with Italic and Underline styles but reflections created
+       * with the Reflect style are not considered.
+       * Note that the width might differ due to kerning with appended text,
+       * e.g. Width('VA') <= Width('V') + Width('A').
+       * @param Advance  if set to true, Result.Right is set to the advance of
+       * the given text rather than the min. right border. The advance width is
+       * bigger than the text's width as it additionally contains the advance
+       * and glyph-spacing of the last character.
+       *}
+      function BBox(const Text: WideString; Advance: boolean = true): TBoundsDbl; overload;
+      {** UTF-8 version of @link(BBox) }
+      function BBox(const Text: UTF8String; Advance: boolean = true): TBoundsDbl; overload;
+
+      {** Font height }
+      property Height: single read GetHeight;
+      {** Vertical distance from baseline to top of glyph }
+      property Ascender: single read GetAscender;
+      {** Vertical distance from baseline to bottom of glyph }
+      property Descender: single read GetDescender;
+      {** Vertical distance between two baselines }
+      property LineSpacing: single read GetLineSpacing write SetLineSpacing;
+      {** Space between end and start of next glyph added to the advance width }
+      property GlyphSpacing: single read GetGlyphSpacing write SetGlyphSpacing;
+      {** Distance between normal baseline and baseline of the reflection }
+      property ReflectionSpacing: single read GetReflectionSpacing write SetReflectionSpacing;
+      {** Font style (italic/underline/...) }
+      property Style: TFontStyle read GetStyle write SetStyle;
+      {** If set to true (default) kerning will be used if available }
+      property UseKerning: boolean read GetUseKerning write SetUseKerning;
+  end;
+
+const
+  //** Max. number of mipmap levels that a TScalableFont can contain
+  cMaxMipmapLevel = 5;
+
+type
+  {**
+   * Wrapper around TFont to allow font size changes.
+   * The font is scaled to the requested size by a modelview matrix
+   * transformation (glScale) and not by rescaling the internal bitmap
+   * representation. This way changing the size is really fast but the result
+   * may lack quality on large or small scale factors.
+   *}
+  TScalableFont = class(TFont)
+    private
+      procedure ResetIntern();
+
+    protected
+      fScale: single;        //**< current height to base-font height ratio 
+      fAspect: single;       //**< width to height aspect
+      fBaseFont: TFont;      //**< shortcut for fMipmapFonts[0]
+      fUseMipmaps: boolean;  //**< true if mipmap fonts are generated
+      /// Mipmap fonts (size[level+1] = size[level]/2)
+      fMipmapFonts: array[0..cMaxMipmapLevel] of TFont;
+
+      procedure Render(const Text: WideString); override;
+      procedure Print(const Text: TWideStringArray); override;
+      function BBox(const Text: TWideStringArray; Advance: boolean): TBoundsDbl; override;
+
+      {**
+       * Callback called for creation of each mipmap font.
+       * Must be defined by the subclass.
+       * Mipmaps created by this method are managed and freed by TScalableFont.
+       *}
+      function CreateMipmap(Level: integer; Scale: single): TFont; virtual; abstract;
+
+      {**
+       * Returns the mipmap level considering the current scale and projection
+       * matrix.
+       *}
+      function GetMipmapLevel(): integer;
+
+      {**
+       * Returns the scale applied to the given mipmap font.
+       * fScale * fBaseFont.Height / fMipmapFont[Level].Height
+       *}
+      function GetMipmapScale(Level: integer): single;
+
+      {**
+       * Chooses the mipmap that looks nicest with current scale and projection
+       * matrix.
+       *}
+      function ChooseMipmapFont(): TFont;
+
+      procedure SetHeight(Height: single); virtual;
+      function GetHeight(): single; override;
+      procedure SetAspect(Aspect: single); virtual;
+      function GetAspect(): single; virtual;
+      function GetAscender(): single; override;
+      function GetDescender(): single; override;
+      procedure SetLineSpacing(Spacing: single); override;
+      function GetLineSpacing(): single; override;
+      procedure SetGlyphSpacing(Spacing: single); override;
+      function GetGlyphSpacing(): single; override;
+      procedure SetReflectionSpacing(Spacing: single); override;
+      function GetReflectionSpacing(): single; override;
+      procedure SetStyle(Style: TFontStyle); override;
+      function GetStyle(): TFontStyle; override;
+      function GetUnderlinePosition(): single; override;
+      function GetUnderlineThickness(): single; override;
+      procedure SetUseKerning(Enable: boolean); override;
+
+    public
+      {**
+       * Creates a wrapper to make the base-font Font scalable.
+       * If UseMipmaps is set to true smaller fonts are created so that a
+       * resized (Height property changed) font looks nicer.
+       * The font passed is managed and freed by TScalableFont.
+       *}
+      constructor Create(Font: TFont; UseMipmaps: boolean); overload;
+
+      {**
+       * Frees memory. The fonts passed on Create() and mipmap creation
+       * are freed too. 
+       *}
+      destructor Destroy(); override;
+
+      {** @seealso TFont.Reset }
+      procedure Reset(); override;
+
+      {** Font height }
+      property Height: single read GetHeight write SetHeight;
+      {** Factor for font stretching (NewWidth = Width*Aspect), 1.0 by default }
+      property Aspect: single read GetAspect write SetAspect;
+  end;
+
+  {**
+   * Table for storage of max. 256 glyphs.
+   * Used for the second cache level. Indexed by the LSB of the WideChar
+   * char-code.
+   *}
+  PGlyphTable = ^TGlyphTable;
+  TGlyphTable = array[0..255] of TGlyph;
+
+  {**
+   * Cache for glyphs of a single font.
+   * The cached glyphs are stored inside a hash-list.
+   * Hashing is performed in two steps:
+   * 1. the least significant byte (LSB) of the WideChar character code
+   * is removed (shr 8) and the result (we call it BaseCode here) looked up in
+   * the hash-list.
+   * 2. Each entry of the hash-list contains a table with max. 256 entries.
+   * The LSB of the char-code of a glyph is the table-offset of that glyph.
+   *}
+  TGlyphCache = class
+    private
+      fHash: TList;
+
+      {**
+       * Finds a glyph-table storing cached glyphs with base-code BaseCode
+       * (= upper char-code bytes) in the hash-list and returns the table and
+       * its index.
+       * @param(InsertPos  the position of the tyble in the list if it was found,
+       *                   otherwise the position the table should be inserted)
+       *}
+      function FindGlyphTable(BaseCode: cardinal; out InsertPos: integer): PGlyphTable;
+
+    public
+      constructor Create();
+      destructor Destroy(); override;
+
+      {**
+       * Add glyph Glyph with char-code ch to the cache.
+       * @returns @true on success, @false otherwise
+       *}
+      function AddGlyph(ch: WideChar; const Glyph: TGlyph): boolean;
+
+      {**
+       * Removes the glyph with char-code ch from the cache.
+       *}
+      procedure DeleteGlyph(ch: WideChar);
+
+      {**
+       * Removes the glyph with char-code ch from the cache.
+       *}
+      function GetGlyph(ch: WideChar): TGlyph;
+
+      {**
+       * Checks if a glyph with char-code ch is cached.
+       *}
+      function HasGlyph(ch: WideChar): boolean;
+
+      {**
+       * Remove and free all cached glyphs. If KeepBaseSet is set to
+       * true, cached characters in the range 0..255 will not be flushed.
+       *}
+      procedure FlushCache(KeepBaseSet: boolean);
+  end;
+
+  {**
+   * Entry of a glyph-cache's (TGlyphCache) hash.
+   * Stores a BaseCode (upper-bytes of a glyph's char-code) and a table
+   * with all glyphs cached at the moment with that BaseCode.
+   *}
+  TGlyphCacheHashEntry = class
+    private
+      fBaseCode: cardinal;
+    public
+      GlyphTable: TGlyphTable;
+
+      constructor Create(BaseCode: cardinal);
+
+      {** Base-code (upper-bytes) of the glyphs stored in this entry's table }
+      property BaseCode: cardinal read fBaseCode;
+  end;
+
+  TCachedFont = class(TFont)
+    protected
+      fCache: TGlyphCache;
+
+      {**
+       * Retrieves a cached glyph with char-code ch from cache.
+       * If the glyph is not already cached, it is loaded with LoadGlyph().
+       *}
+      function GetGlyph(ch: WideChar): TGlyph;
+
+      {**
+       * Callback to create (load) a glyph with char-code ch.
+       * Implemented by subclasses.
+       *}
+      function LoadGlyph(ch: WideChar): TGlyph; virtual; abstract;
+
+    public
+      constructor Create();
+      destructor Destroy(); override;
+
+      {**
+       * Remove and free all cached glyphs. If KeepBaseSet is set to
+       * true, the base glyphs are not be flushed.
+       * @seealso TGlyphCache.FlushCache
+       *}
+      procedure FlushCache(KeepBaseSet: boolean);
+  end;
+
+  TFTFont = class;
+
+  {**
+   * Freetype glyph.
+   * Each glyph stores a texture with the glyph's image.
+   *}
+  TFTGlyph = class(TGlyph)
+    private
+      fCharIndex: FT_UInt;      //**< Freetype specific char-index (<> char-code)
+      fDisplayList: GLuint;     //**< Display-list ID
+      fTexture: GLuint;         //**< Texture ID
+      fBitmapCoords: TBitmapCoords; //**< Left/Top offset and Width/Height of the bitmap (in pixels)
+      fTexOffset: TPositionDbl; //**< Right and bottom texture offset for removal of power-of-2 padding
+      fTexSize: TTextureSize;   //**< Texture size in pixels
+
+      fFont: TFTFont;           //**< Font associated with this glyph
+      fAdvance: TPositionDbl;   //**< Advance width of this glyph
+      fBounds: TBoundsDbl;      //**< Glyph bounds
+      fOutset: single;          //**< Extrusion outset
+
+      {**
+       * Extrudes the outline of a glyph's bitmap stored in TexBuffer with size
+       * fTexSize by Outset pixels.
+       * This is useful to create bold or outlined fonts.
+       * TexBuffer must be 2*Ceil(Outset) pixels higher and wider than the
+       * original glyph bitmap, otherwise the glyph borders cannot be extruded
+       * correctly.
+       * The bitmap must be 2* pixels wider and higher than the
+       * original glyph's bitmap with the latter centered in it.
+       *}
+      procedure Extrude(var TexBuffer: TGLubyteDynArray; Outset: single);
+
+      {**
+       * Creates an OpenGL texture (and display list) for the glyph.
+       * The glyph's and bitmap's metrics are set correspondingly.
+       * @param  LoadFlags  flags passed to FT_Load_Glyph()
+       * @raises Exception  if the glyph could not be initialized
+       *}
+      procedure CreateTexture(LoadFlags: FT_Int32);
+
+    protected
+      function GetAdvance(): TPositionDbl; override;
+      function GetBounds(): TBoundsDbl; override;
+
+    public
+      {**
+       * Creates a glyph with char-code ch from font Font.
+       * @param LoadFlags  flags passed to FT_Load_Glyph()
+       *}
+      constructor Create(Font: TFTFont; ch: WideChar; Outset: single;
+                         LoadFlags: FT_Int32);
+      destructor Destroy(); override;
+
+      {** Renders the glyph (normal render pass) }
+      procedure Render(UseDisplayLists: boolean); override;
+      {** Renders the glyph's reflection }
+      procedure RenderReflection(); override;
+
+      {** Freetype specific char-index (<> char-code) }
+      property CharIndex: FT_UInt read fCharIndex;
+  end;
+
+  {**
+   * Freetype font class.
+   *}
+  TFTFont = class(TCachedFont)
+    private
+      procedure ResetIntern();
+
+    protected
+      fFilename: string;            //**< filename of the font-file
+      fSize: integer;               //**< Font base size (in pixels)
+      fOutset: single;              //**< size of outset extrusion (in pixels)
+      fFace: FT_Face;               //**< Holds the height of the font
+      fLoadFlags: FT_Int32;         //**< FT glpyh load-flags
+      fFontUnitScale: TPositionDbl; //**< FT font-units to pixel ratio
+      fUseDisplayLists: boolean;    //**< true: use display-lists, false: direct drawing
+
+      {** @seealso TCachedFont.LoadGlyph }
+      function LoadGlyph(ch: WideChar): TGlyph; override;
+
+      procedure Render(const Text: WideString); override;
+      function BBox(const Text: TWideStringArray; Advance: boolean): TBoundsDbl; override;
+
+      function GetHeight(): single; override;
+      function GetAscender(): single; override;
+      function GetDescender(): single; override;
+      function GetUnderlinePosition(): single; override;
+      function GetUnderlineThickness(): single; override;
+
+      property Face: FT_Face read fFace;
+
+    public
+      {**
+       * Creates a font of size Size (in pixels) from the file Filename.
+       * If Outset (in pixels) is set to a value > 0 the glyphs will be extruded
+       * at their borders. Use it for e.g. a bold effect.
+       * @param  LoadFlags  flags passed to FT_Load_Glyph()
+       * @raises Exception  if the font-file could not be loaded
+       *}
+      constructor Create(const Filename: string;
+                         Size: integer; Outset: single = 0.0;
+                         LoadFlags: FT_Int32 = FT_LOAD_DEFAULT);
+
+      {**
+       * Frees all resources associated with the font.
+       *}
+      destructor Destroy(); override;
+
+      {** @seealso TFont.Reset }
+      procedure Reset(); override;
+      
+      {** Size of the base font }
+      property Size: integer read fSize;
+      {** Outset size }
+      property Outset: single read fOutset;
+  end;
+
+  TFTScalableFont = class(TScalableFont)
+    protected
+      function GetOutset(): single; virtual;
+      function CreateMipmap(Level: integer; Scale: single): TFont; override;
+
+    public
+      {**
+       * Creates a scalable font of size Size (in pixels) from the file Filename.
+       * OutsetAmount is the ratio of the glyph extrusion.
+       * The extrusion in pixels is Size*OutsetAmount
+       * (0.0 -> no extrusion, 0.1 -> 10%).
+       *}
+      constructor Create(const Filename: string;
+                         Size: integer; OutsetAmount: single = 0.0;
+                         UseMipmaps: boolean = true);
+
+      {** @seealso TGlyphCache.FlushCache }
+      procedure FlushCache(KeepBaseSet: boolean);
+
+      {** Outset size (in pixels) of the scaled font }
+      property Outset: single read GetOutset;
+  end;
+
+  
+  {**
+   * Represents a freetype font with an additional outline around its glyphs.
+   * The outline size is passed on creation and cannot be changed later.
+   *}
+  TFTOutlineFont = class(TFont)
+    private
+      fFilename: string;
+      fSize: integer;
+      fOutset: single;
+      fInnerFont, fOutlineFont: TFTFont;
+      fOutlineColor: TGLColor;
+
+      procedure ResetIntern();
+      
+  protected
+      procedure DrawUnderline(const Text: WideString); override;
+      procedure Render(const Text: WideString); override;
+      function BBox(const Text: TWideStringArray; Advance: boolean): TBoundsDbl; override;
+
+      function GetHeight(): single; override;
+      function GetAscender(): single; override;
+      function GetDescender(): single; override;
+      procedure SetLineSpacing(Spacing: single); override;
+      procedure SetGlyphSpacing(Spacing: single); override;
+      procedure SetReflectionSpacing(Spacing: single); override;
+      procedure SetStyle(Style: TFontStyle); override;
+      function GetStyle(): TFontStyle; override;
+      function GetUnderlinePosition(): single; override;
+      function GetUnderlineThickness(): single; override;
+      procedure SetUseKerning(Enable: boolean); override;
+      procedure SetReflectionPass(Enable: boolean); override;
+
+    public
+      constructor Create(const Filename: string;
+                         Size: integer; Outset: single;
+                         LoadFlags: FT_Int32 = FT_LOAD_DEFAULT);
+      destructor Destroy; override;
+
+      {**
+       * Sets the color of the outline.
+       * If the alpha component is < 0, OpenGL's current alpha value will be
+       * used.
+       *}
+      procedure SetOutlineColor(r, g, b: GLfloat; a: GLfloat = -1.0);
+
+      {** @seealso TGlyphCache.FlushCache }
+      procedure FlushCache(KeepBaseSet: boolean);
+
+      {** @seealso TFont.Reset }
+      procedure Reset(); override;
+
+      {** Size of the base font }
+      property Size: integer read fSize;
+      {** Outset size }
+      property Outset: single read fOutset;
+  end;
+
+  {**
+   * Wrapper around TOutlineFont to allow font resizing.
+   * @seealso TScalableFont
+   *}
+  TFTScalableOutlineFont = class(TScalableFont)
+    protected
+      function GetOutset(): single; virtual;
+      function CreateMipmap(Level: integer; Scale: single): TFont; override;
+
+    public
+      constructor Create(const Filename: string;
+                         Size: integer; OutsetAmount: single;
+                         UseMipmaps: boolean = true);
+
+      {** @seealso TFTOutlineFont.SetOutlineColor }
+      procedure SetOutlineColor(r, g, b: GLfloat; a: GLfloat = -1.0);
+
+      {** @seealso TGlyphCache.FlushCache }
+      procedure FlushCache(KeepBaseSet: boolean);
+
+      {** Outset size }
+      property Outset: single read GetOutset;
+  end;
+
+{$IFDEF BITMAP_FONT}
+
+  {**
+   * A bitmapped font loads it's glyphs from a bitmap and stores them in a
+   * texture. Unicode characters are not supported (but could be by supporting
+   * multiple textures each storing a subset of unicode glyphs).
+   * For backward compatibility only.
+   *}
+  TBitmapFont = class(TFont)
+    private
+      fTex:       TTexture;
+      fTexSize:   integer;
+      fBaseline:  integer;
+      fAscender:  integer;
+      fDescender: integer;
+      fWidths:    array[0..255] of byte; //**< half widths
+      fOutline:   integer;
+      fTempColor: TGLColor; //**< colours for the reflection
+
+      procedure ResetIntern();
+
+      procedure RenderChar(ch: WideChar; var AdvanceX: real);
+
+      {**
+       * Load font widths from an info file.
+       * @param  InfoFile  the name of the info (.dat) file
+       * @raises Exception if the file is corrupted
+       *}
+      procedure LoadFontInfo(const InfoFile: string);
+
+    protected
+      procedure Render(const Text: WideString); override;
+      function BBox(const Text: TWideStringArray; Advance: boolean): TBoundsDbl; override;
+
+      function GetHeight(): single; override;
+      function GetAscender(): single; override;
+      function GetDescender(): single; override;
+      function GetUnderlinePosition(): single; override;
+      function GetUnderlineThickness(): single; override;
+
+    public
+      {**
+       * Creates a bitmapped font from image Filename and font width info
+       * loaded from the corresponding file with ending .dat.
+       * @param(Baseline  y-coord of the baseline given in cartesian coords
+       *        (y-axis up) and from the lower edge of the glyphs bounding box)
+       * @param(Ascender  pixels from baseline to top of highest glyph)
+       *}
+      constructor Create(const Filename: string; Outline: integer;
+                         Baseline, Ascender, Descender: integer);
+      destructor Destroy(); override;
+
+      {**
+       * Corrects font widths provided by the info file.
+       * NewWidth := Width * WidthMult + WidthAdd
+       *}
+      procedure CorrectWidths(WidthMult: real; WidthAdd: integer);
+
+      {** @seealso TFont.Reset }
+      procedure Reset(); override;
+  end;
+
+{$ENDIF BITMAP_FONT}
+
+  TFreeType = class
+    public
+      {**
+       * Returns a pointer to the freetype library singleton.
+       * If non exists, freetype will be initialized.
+       * @raises Exception if initialization failed
+       *}
+      class function GetLibrary(): FT_Library;
+      class procedure FreeLibrary();
+  end;
+
+
+implementation
+
+uses Types;
+
+const
+  //** shear factor used for the italic effect (bigger value -> more bending)
+  cShearFactor = 0.25;
+  cShearMatrix: array[0..15] of GLfloat = (
+      1,            0, 0, 0,
+      cShearFactor, 1, 0, 0,
+      0,            0, 1, 0,
+      0,            0, 0, 1
+  );
+  cShearMatrixInv: array[0..15] of GLfloat = (
+      1,             0, 0, 0,
+      -cShearFactor, 1, 0, 0,
+      0,             0, 1, 0,
+      0,             0, 0, 1
+  );
+
+var
+  LibraryInst: FT_Library;
+
+function NewGLColor(r, g, b, a: GLfloat): TGLColor;
+begin
+  Result.r := r;
+  Result.g := g;
+  Result.b := b;
+  Result.a := a;
+end;
+
+{**
+ * Returns the first power of 2 >= Value.
+ *}
+function NextPowerOf2(Value: integer): integer; {$IFDEF HasInline}inline;{$ENDIF}
+begin
+  Result := 1;
+  while (Result < Value) do
+    Result := Result shl 1;
+end;
+
+
+{*
+ * TFont
+ *}
+
+constructor TFont.Create();
+begin
+  inherited;
+  ResetIntern();
+end;
+
+destructor TFont.Destroy();
+begin
+  inherited;
+end;
+
+procedure TFont.ResetIntern();
+begin
+  fStyle := [];
+  fUseKerning := true;
+  fGlyphSpacing := 0.0;
+  fReflectionPass := false;
+
+  // must be set by subclasses
+  fLineSpacing := 0.0;
+  fReflectionSpacing := 0.0;
+end;
+
+procedure TFont.Reset();
+begin
+  ResetIntern();
+end;
+
+procedure TFont.SplitLines(const Text: UTF8String; var Lines: TWideStringArray);
+var
+  LineList: TStringList;
+  LineIndex: integer;
+begin
+  // split lines on newline (there is no WideString version of ExtractStrings)
+  LineList := TStringList.Create();
+  ExtractStrings([#13], [], PChar(Text), LineList);
+
+  // create an array of WideStrins from the UTF-8 string-list
+  SetLength(Lines, LineList.Count);
+  for LineIndex := 0 to LineList.Count-1 do
+    Lines[LineIndex] := UTF8Decode(LineList[LineIndex]);
+  LineList.Free();
+end;
+
+function TFont.BBox(const Text: UTF8String; Advance: boolean): TBoundsDbl;
+var
+  LineArray: TWideStringArray;
+begin
+  SplitLines(Text, LineArray);
+  Result := BBox(LineArray, Advance);
+  SetLength(LineArray, 0);
+end;
+
+function TFont.BBox(const Text: WideString; Advance: boolean): TBoundsDbl;
+begin
+  Result := BBox(UTF8Encode(Text), Advance);
+end;
+
+procedure TFont.Print(const Text: TWideStringArray);
+var
+  LineIndex: integer;
+begin
+  // recursively call this function to draw reflected text
+  if ((Reflect in Style) and not ReflectionPass) then
+  begin
+    ReflectionPass := true;
+    Print(Text);
+    ReflectionPass := false;
+  end;
+
+  // store current color, enable-flags, matrix-mode
+  glPushAttrib(GL_CURRENT_BIT or GL_ENABLE_BIT or GL_TRANSFORM_BIT);
+
+  // set OpenGL state
+  glMatrixMode(GL_MODELVIEW);
+  glDisable(GL_DEPTH_TEST);
+  glEnable(GL_BLEND);
+  glEnable(GL_TEXTURE_2D);
+  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+  {
+  // TODO: just draw texels with alpha > 0 to avoid setting z-buffer for them?
+  glAlphaFunc(GL_GREATER, 0);
+  glEnable(GL_ALPHA_TEST);
+
+  //TODO: Do we need depth-testing?
+  if (ReflectionPass) then
+  begin
+    glDepthMask(0);
+    glEnable(GL_DEPTH_TEST);
+  end;
+  }
+
+  {$IFDEF FLIP_YAXIS}
+  glPushMatrix();
+  glScalef(1, -1, 1);
+  {$ENDIF}
+
+  // display text
+  for LineIndex := 0 to High(Text) do
+  begin
+    glPushMatrix();
+
+    // move to baseline
+    glTranslatef(0, -LineSpacing*LineIndex, 0);
+
+    if ((Underline in Style) and not ReflectionPass) then
+    begin
+      glDisable(GL_TEXTURE_2D);
+      DrawUnderline(Text[LineIndex]);
+      glEnable(GL_TEXTURE_2D);
+    end;
+
+    // draw reflection
+    if (ReflectionPass) then
+    begin
+      // set reflection spacing
+      glTranslatef(0, -ReflectionSpacing, 0);
+      // flip y-axis
+      glScalef(1, -1, 1);
+    end;
+
+    // shear for italic effect
+    if (Italic in Style) then
+      glMultMatrixf(@cShearMatrix);
+
     // render text line
-    Render(Text[LineIndex]);

-

-    glPopMatrix();

-  end;

-

-  // restore settings

-  {$IFDEF FLIP_YAXIS}

-  glPopMatrix();

-  {$ENDIF}

-  glPopAttrib();

-end;

-

-procedure TFont.Print(const Text: string);

-var

-  LineArray: TWideStringArray;

-begin

-  SplitLines(Text, LineArray);

-  Print(LineArray);

-  SetLength(LineArray, 0);

-end;

-

-procedure TFont.Print(const Text: WideString);

-begin

-  Print(UTF8Encode(Text));

-end;

-

-procedure TFont.DrawUnderline(const Text: WideString);

+    Render(Text[LineIndex]);
+
+    glPopMatrix();
+  end;
+
+  // restore settings
+  {$IFDEF FLIP_YAXIS}
+  glPopMatrix();
+  {$ENDIF}
+  glPopAttrib();
+end;
+
+procedure TFont.Print(const Text: string);
+var
+  LineArray: TWideStringArray;
+begin
+  SplitLines(Text, LineArray);
+  Print(LineArray);
+  SetLength(LineArray, 0);
+end;
+
+procedure TFont.Print(const Text: WideString);
+begin
+  Print(UTF8Encode(Text));
+end;
+
+procedure TFont.DrawUnderline(const Text: WideString);
 var
   UnderlineY1, UnderlineY2: single;
   Bounds: TBoundsDbl;
 begin
-  UnderlineY1 := GetUnderlinePosition();

-  UnderlineY2 := UnderlineY1 + GetUnderlineThickness();

-  Bounds := BBox(Text);

-  glRectf(Bounds.Left, UnderlineY1, Bounds.Right, UnderlineY2);

-end;

-

-procedure TFont.SetStyle(Style: TFontStyle);

-begin

-  fStyle := Style;

-end;

-

-function TFont.GetStyle(): TFontStyle;

-begin

-  Result := fStyle;

-end;

-

-procedure TFont.SetLineSpacing(Spacing: single);

-begin

-  fLineSpacing := Spacing;

-end;

-

-function TFont.GetLineSpacing(): single;

-begin

-  Result := fLineSpacing;

-end;

-

-procedure TFont.SetGlyphSpacing(Spacing: single);

-begin

-  fGlyphSpacing := Spacing;

-end;

-

-function TFont.GetGlyphSpacing(): single;

-begin

-  Result := fGlyphSpacing;

-end;

-

-procedure TFont.SetReflectionSpacing(Spacing: single);

-begin

-  fReflectionSpacing := Spacing;

-end;

-

-function TFont.GetReflectionSpacing(): single;

-begin

-  Result := fReflectionSpacing;

-end;

-

-procedure TFont.SetUseKerning(Enable: boolean);

-begin

-  fUseKerning := Enable;

-end;

-

-function TFont.GetUseKerning(): boolean;

-begin

-  Result := fUseKerning;

-end;

-

-procedure TFont.SetReflectionPass(Enable: boolean);

-begin

-  fReflectionPass := Enable;

-end;

-

-

-{*

- * TScalableFont

- *}

-

-constructor TScalableFont.Create(Font: TFont; UseMipmaps: boolean);

-var

-  MipmapLevel: integer;

-begin

-  inherited Create();

-  

-  fBaseFont := Font;

-  fMipmapFonts[0] := Font;

-  fUseMipmaps := UseMipmaps;

-  ResetIntern();

-

-  // create mipmap fonts if requested

-  if (UseMipmaps) then

-  begin

-    for MipmapLevel := 1 to cMaxMipmapLevel do

-    begin

-      fMipmapFonts[MipmapLevel] := CreateMipmap(MipmapLevel, 1/(1 shl MipmapLevel));

-      // stop if no smaller mipmap font is returned

-      if (fMipmapFonts[MipmapLevel] = nil) then

-        Break;

-    end;

-  end;

-end;

-

-destructor TScalableFont.Destroy();

-var

-  Level: integer;

-begin

-  for Level := 0 to High(fMipmapFonts) do

-    fMipmapFonts[Level].Free;

-  inherited;

-end;

-

-procedure TScalableFont.ResetIntern();

-begin

-  fScale := 1.0;

-  fAspect := 1.0;

-end;

-

-procedure TScalableFont.Reset();

-var

-  Level: integer;

-begin

-  inherited;

-  ResetIntern();

-  for Level := 0 to High(fMipmapFonts) do

-    if (fMipmapFonts[Level] <> nil) then

-      fMipmapFonts[Level].Reset();

-end;

-

-{**

- * Returns the mipmap level to use with regard to the current projection

- * and modelview matrix, font scale and aspect.

- *

- * Note:

- * - for Freetype fonts, hinting and grid-fitting must be disabled, otherwise

- *   the glyph widths/heights ratios and advance widths of the mipmap fonts

- *   do not match as they are adjusted sligthly (e.g. an 'a' at size 12px has

- *   width 12px, but at size 6px width 8px).

- * - returned mipmap-level is used for all glyphs of the current text to print.

- *   This is faster, much easier to handle, since we just need to create

- *   multiple sized fonts and select the one we need for the mipmap-level and

- *   it avoids that neighbored glyphs use different mipmap-level which might

- *   look odd because one glyph might look blurry and the other sharp.

- *

- * Motivation:

- *   We do not use OpenGL for mipmapping as the results are very bad. At least

- *   with automatic mipmap generation (gluBuildMipmaps) the fonts look rather

- *   blurry.

- *   Defining our own mipmaps by creating multiple textures with

- *   for different mimap levels is a pain, as the font size passed to freetype

- *   is not the size of the bitmaps created and it does not guarantee that a

- *   glyph bitmap of a font with font-size s/2 is half the size of the font with

- *   font-size s. If the bitmap size is just a single pixel bigger than the half

- *   we might need a texture of the next power-of-2 and the texture would not be

- *   half of the size of the next bigger mipmap. In addition we use a fixed one

- *   pixel sized border to smooth the texture (see cTexSmoothBorder) and maybe

- *   an outset that is added to the font, so creating a glyph mipmap that is

- *   exactly half the size of the next bigger one is a very difficult task.

- *

- * Solution:

- *   Use mipmap textures that are not exactly half the size of the next mipmap

- *   level. OpenGL does not support this (at least not without extensions).

- *   The trickiest task is to determine the mipmap to use by calculating the

- *   amount of minification that is performed in this function.

- *}

-function TScalableFont.GetMipmapLevel(): integer;

-var

-  ModelMatrix, ProjMatrix: T16dArray;

-  WinCoords: array[0..2, 0..2] of GLdouble;

-  ViewPortArray: TViewPortArray;

-  Dist, Dist2: double;

-  WidthScale, HeightScale: double;

-const

-  // width/height of square used for determining the scale

-  cTestSize = 10.0;

-  // an offset to the mipmap-level to adjust the change-over of two consecutive

-  // mipmap levels. If for example the bias is 0.1 and unbiased level is 1.9

-  // the result level will be 2. A bias of 0.5 is equal to rounding.

-  // With bias=0.1 we prefer larger mipmaps over smaller ones.

-  cBias = 0.2;

-begin

-  // 1. retrieve current transformation matrices for gluProject

-  glGetDoublev(GL_MODELVIEW_MATRIX, @ModelMatrix);

-  glGetDoublev(GL_PROJECTION_MATRIX, @ProjMatrix);

-  glGetIntegerv(GL_VIEWPORT, @ViewPortArray);

-

-  // 2. project three of the corner points of a square with size cTestSize

-  // to window coordinates (the square is just a dummy for a glyph)

-

-  // project point (x1, y1) to window corrdinates

-  gluProject(0, 0, 0,

-             ModelMatrix, ProjMatrix, ViewPortArray,

-             @WinCoords[0][0], @WinCoords[0][1], @WinCoords[0][2]);

-  // project point (x2, y1) to window corrdinates

-  gluProject(cTestSize, 0, 0,

-             ModelMatrix, ProjMatrix, ViewPortArray,

-             @WinCoords[1][0], @WinCoords[1][1], @WinCoords[1][2]);

-  // project point (x1, y2) to window corrdinates

-  gluProject(0, cTestSize, 0,

-             ModelMatrix, ProjMatrix, ViewPortArray,

-             @WinCoords[2][0], @WinCoords[2][1], @WinCoords[2][2]);

-

-  // 3. Lets see how much the width and height of the square changed.

-  // Calculate the width and height as displayed on the screen in window

-  // coordinates and calculate the ratio to the original coordinates in

-  // modelview space so the ratio gives us the scale (minification here).

-

-  // projected width ||(x1, y1) - (x2, y1)||

-  Dist  := (WinCoords[0][0] - WinCoords[1][0]);

-  Dist2 := (WinCoords[0][1] - WinCoords[1][1]);

-  WidthScale := cTestSize / Sqrt(Dist*Dist + Dist2*Dist2);

-

-  // projected height ||(x1, y1) - (x1, y2)||

-  Dist  := (WinCoords[0][0] - WinCoords[2][0]);

-  Dist2 := (WinCoords[0][1] - WinCoords[2][1]);

-  HeightScale := cTestSize / Sqrt(Dist*Dist + Dist2*Dist2);

-

-  //writeln(Format('Scale %f, %f', [WidthScale, HeightScale]));

-

-  // 4. Now that we have got the scale, take the bigger minification scale

-  // and get it to a logarithmic scale as each mipmap is 1/2 the size of its

-  // predecessor (Mipmap_size[i] = Mipmap_size[i-1]/2).

-  // The result is our mipmap-level = the index of the mipmap to use.

-

-  // Level > 0: Minification; < 0: Magnification

-  Result := Trunc(Log2(Max(WidthScale, HeightScale)) + cBias);

-

-  // clamp to valid range

-  if (Result < 0) then

-    Result := 0;

-  if (Result > High(fMipmapFonts)) then

-    Result := High(fMipmapFonts);

-end;

-

-function TScalableFont.GetMipmapScale(Level: integer): single;

-begin

-  if (fMipmapFonts[Level] = nil) then

-  begin

-    Result := -1;

-    Exit;

-  end;

-

-  Result := fScale * fMipmapFonts[0].Height / fMipmapFonts[Level].Height;

-end;

-

-{**

- * Returns the correct mipmap font for the current scale and projection

- * matrix. The modelview scale is adjusted to the mipmap level, so

- * Result.Print() will display the font in the correct size.

- *}

-function TScalableFont.ChooseMipmapFont(): TFont;

-var

-  DesiredLevel: integer;

-  Level: integer;

-  MipmapScale: single;

-begin

-  Result := nil;

-  DesiredLevel := GetMipmapLevel();

-

-  // get the smallest mipmap available for the desired level

-  // as not all levels must be assigned to a font.

-  for Level := DesiredLevel downto 0 do

-  begin

-    if (fMipmapFonts[Level] <> nil) then

-    begin

-      Result := fMipmapFonts[Level];

-      Break;

-    end;

-  end;

-

-  // since the mipmap font (if level > 0) is smaller than the base-font

-  // we have to scale to get its size right.

-  MipmapScale := fMipmapFonts[0].Height/Result.Height;

-  glScalef(MipmapScale, MipmapScale, 0);

-end;

-

-procedure TScalableFont.Print(const Text: TWideStringArray);

-begin

-  glPushMatrix();

-

-  // set scale and stretching

-  glScalef(fScale * fAspect, fScale, 0);

-

-  // print text

-  if (fUseMipmaps) then

-    ChooseMipmapFont().Print(Text)

-  else

-    fBaseFont.Print(Text);

-

-  glPopMatrix();

-end;

-

-procedure TScalableFont.Render(const Text: WideString);

-begin

-  Assert(false, 'Unused TScalableFont.Render() was called');

-end;

-

-function TScalableFont.BBox(const Text: TWideStringArray; Advance: boolean): TBoundsDbl;

-begin

-  Result := fBaseFont.BBox(Text, Advance);

-  Result.Left   := Result.Left * fScale * fAspect;

-  Result.Right  := Result.Right * fScale * fAspect;

-  Result.Top    := Result.Top * fScale;

-  Result.Bottom := Result.Bottom * fScale;

-end;

-

-procedure TScalableFont.SetHeight(Height: single);

-begin

-  fScale := Height / fBaseFont.GetHeight();

-end;

-

-function TScalableFont.GetHeight(): single;

-begin

-  Result := fBaseFont.GetHeight() * fScale;

-end;

-

-procedure TScalableFont.SetAspect(Aspect: single);

-begin

-  fAspect := Aspect;

-end;

-

-function TScalableFont.GetAspect(): single;

-begin

-  Result := fAspect;

-end;

-

-function TScalableFont.GetAscender(): single;

-begin

-  Result := fBaseFont.GetAscender() * fScale;

-end;

-

-function TScalableFont.GetDescender(): single;

-begin

-  Result := fBaseFont.GetDescender() * fScale;

-end;

-

-procedure TScalableFont.SetLineSpacing(Spacing: single);

-var

-  Level: integer;

-begin

-  for Level := 0 to High(fMipmapFonts) do

-    if (fMipmapFonts[Level] <> nil) then

-      fMipmapFonts[Level].SetLineSpacing(Spacing / GetMipmapScale(Level));

-end;

-

-function TScalableFont.GetLineSpacing(): single;

-begin

-  Result := fBaseFont.GetLineSpacing() * fScale;

-end;

-

-procedure TScalableFont.SetGlyphSpacing(Spacing: single);

-var

-  Level: integer;

-begin

-  for Level := 0 to High(fMipmapFonts) do

-    if (fMipmapFonts[Level] <> nil) then

-      fMipmapFonts[Level].SetGlyphSpacing(Spacing / GetMipmapScale(Level));

-end;

-

-function TScalableFont.GetGlyphSpacing(): single;

-begin

-  Result := fBaseFont.GetGlyphSpacing() * fScale;

-end;

-

-procedure TScalableFont.SetReflectionSpacing(Spacing: single);

-var

-  Level: integer;

-begin

-  for Level := 0 to High(fMipmapFonts) do

-    if (fMipmapFonts[Level] <> nil) then

-      fMipmapFonts[Level].SetReflectionSpacing(Spacing / GetMipmapScale(Level));

-end;

-

-function TScalableFont.GetReflectionSpacing(): single;

-begin

-  Result := fBaseFont.GetLineSpacing() * fScale;

-end;

-

-procedure TScalableFont.SetStyle(Style: TFontStyle);

-var

-  Level: integer;

-begin

-  for Level := 0 to High(fMipmapFonts) do

-    if (fMipmapFonts[Level] <> nil) then

-      fMipmapFonts[Level].SetStyle(Style);

-end;

-

-function TScalableFont.GetStyle(): TFontStyle;

-begin

-  Result := fBaseFont.GetStyle();

-end;

-

-function TScalableFont.GetUnderlinePosition(): single;

-begin

-  Result := fBaseFont.GetUnderlinePosition();

-end;

-

-function TScalableFont.GetUnderlineThickness(): single;

-begin

-  Result := fBaseFont.GetUnderlinePosition();

-end;

-

-procedure TScalableFont.SetUseKerning(Enable: boolean);

-var

-  Level: integer;

-begin

-  for Level := 0 to High(fMipmapFonts) do

-    if (fMipmapFonts[Level] <> nil) then

-      fMipmapFonts[Level].SetUseKerning(Enable);

-end;

-

-

-{*

- * TCachedFont

- *}

-

-constructor TCachedFont.Create();

-begin

-  inherited;

-  fCache := TGlyphCache.Create();

-end;

-

-destructor TCachedFont.Destroy();

-begin

-  fCache.Free;

-  inherited;

-end;

-

-function TCachedFont.GetGlyph(ch: WideChar): TGlyph;

-begin

-  Result := fCache.GetGlyph(ch);

-  if (Result = nil) then

-  begin

-    Result := LoadGlyph(ch);

-    if (not fCache.AddGlyph(ch, Result)) then

-      Result.Free;

-  end;

-end;

-

-procedure TCachedFont.FlushCache(KeepBaseSet: boolean);

-begin

-  fCache.FlushCache(KeepBaseSet);

-end;

-

-

-{*

- * TFTFont

- *}

-

-constructor TFTFont.Create(

-    const Filename: string;

-    Size: integer; Outset: single;

-    LoadFlags: FT_Int32);

-var

-  i: WideChar;

-begin

-  inherited Create();

-

-  fFilename := Filename;

-  fSize := Size;

-  fOutset := Outset;

-  fLoadFlags := LoadFlags;

-  fUseDisplayLists := true;

-

-  // load font information

-  if (FT_New_Face(TFreeType.GetLibrary(), PChar(Filename), 0, fFace) <> 0) then

-    raise Exception.Create('FT_New_Face: Could not load font '''  + Filename + '''');

-

-  // support scalable fonts only

-  if (not FT_IS_SCALABLE(fFace)) then

-    raise Exception.Create('Font is not scalable');

-

-  if (FT_Set_Pixel_Sizes(fFace, 0, Size) <> 0) then

-    raise Exception.Create('FT_Set_Pixel_Sizes failes');

-

-  // get scale factor for font-unit to pixel-size transformation

-  fFontUnitScale.X := fFace.size.metrics.x_ppem / fFace.units_per_EM;

-  fFontUnitScale.Y := fFace.size.metrics.y_ppem / fFace.units_per_EM;

-

-  ResetIntern();

-

-  // pre-cache some commonly used glyphs (' ' - '~')

-  for i := #32 to #126 do

-    fCache.AddGlyph(i, TFTGlyph.Create(Self, i, Outset, LoadFlags));

-end;

-

-destructor TFTFont.Destroy();

-begin

-  // free face

-  FT_Done_Face(fFace);

-  inherited;

-end;

-

-procedure TFTFont.ResetIntern();

-begin

-  // Note: outset and non outset fonts use same spacing

-  fLineSpacing := fFace.height * fFontUnitScale.Y;

-  fReflectionSpacing := -2*fFace.descender * fFontUnitScale.Y;

-end;

-

-procedure TFTFont.Reset();

-begin

-  inherited;

-  ResetIntern();

-end;

-

-function TFTFont.LoadGlyph(ch: WideChar): TGlyph;

-begin

-  Result := TFTGlyph.Create(Self, ch, Outset, fLoadFlags);

-end;

-

-function TFTFont.BBox(const Text: TWideStringArray; Advance: boolean): TBoundsDbl;

-var

-  Glyph, PrevGlyph: TFTGlyph;

-  TextLine: WideString;

-  LineYOffset: single;

-  LineIndex, CharIndex: integer;

-  LineBounds: TBoundsDbl;

-  KernDelta: FT_Vector;

-  UnderlinePos: double;

-begin

-  // Reset global bounds

-  Result.Left   := Infinity;

-  Result.Right  := 0;

-  Result.Bottom := Infinity;

-  Result.Top    := 0;

-

-  // reset last glyph

-  PrevGlyph := nil;

-

-  // display text

-  for LineIndex := 0 to High(Text) do

-  begin

-    // get next text line

-    TextLine := Text[LineIndex];

-    LineYOffset := -LineSpacing * LineIndex;

-

-    // reset line bounds

-    LineBounds.Left   := Infinity;

-    LineBounds.Right  := 0;

-    LineBounds.Bottom := Infinity;

-    LineBounds.Top    := 0;

-

-    // for each glyph image, compute its bounding box

-    for CharIndex := 1 to Length(TextLine) do

-    begin

-      Glyph := TFTGlyph(GetGlyph(TextLine[CharIndex]));

-      if (Glyph <> nil) then

-      begin

-        // get kerning

-        if (fUseKerning and FT_HAS_KERNING(fFace) and (PrevGlyph <> nil)) then

-        begin

-          FT_Get_Kerning(fFace, PrevGlyph.CharIndex, Glyph.CharIndex,

-                         FT_KERNING_UNSCALED, KernDelta);

-          LineBounds.Right := LineBounds.Right + KernDelta.x * fFontUnitScale.X;

-        end;

-

-        // update left bound (must be done before right bound is updated)

-        if (LineBounds.Right + Glyph.Bounds.Left < LineBounds.Left) then

-          LineBounds.Left := LineBounds.Right + Glyph.Bounds.Left;

-

-        // update right bound

-        if (CharIndex < Length(TextLine)) or  // not the last character

-           (TextLine[CharIndex] = ' ') or     // on space char (Bounds.Right = 0)

-           Advance then                       // or in advance mode

-        begin

-          // add advance and glyph spacing

-          LineBounds.Right := LineBounds.Right + Glyph.Advance.x + GlyphSpacing

-        end

-        else

-        begin

-          // add glyph's right bound

-          LineBounds.Right := LineBounds.Right + Glyph.Bounds.Right;

-        end;

-

-        // update bottom and top bounds

-        if (Glyph.Bounds.Bottom < LineBounds.Bottom) then

-          LineBounds.Bottom := Glyph.Bounds.Bottom;

-        if (Glyph.Bounds.Top > LineBounds.Top) then

-          LineBounds.Top := Glyph.Bounds.Top;

-      end;

-

-      PrevGlyph := Glyph;

-    end;

-

-    // handle italic font style

-    if (Italic in Style) then

-    begin

-      LineBounds.Left := LineBounds.Left + LineBounds.Bottom * cShearFactor;

-      LineBounds.Right := LineBounds.Right + LineBounds.Top * cShearFactor;

-    end;

-

-    // handle underlined font style

-    if (Underline in Style) then

-    begin

-      UnderlinePos := GetUnderlinePosition();

-      if (UnderlinePos < LineBounds.Bottom) then

-        LineBounds.Bottom := UnderlinePos;

-    end;

-

-    // add line offset

-    LineBounds.Bottom := LineBounds.Bottom + LineYOffset;

-    LineBounds.Top := LineBounds.Top + LineYOffset;

-

-    // adjust global bounds

-    if (Result.Left > LineBounds.Left) then

-      Result.Left := LineBounds.Left;

-    if (Result.Right < LineBounds.Right) then

-      Result.Right := LineBounds.Right;

-    if (Result.Bottom > LineBounds.Bottom) then

-      Result.Bottom := LineBounds.Bottom;

-    if (Result.Top < LineBounds.Top) then

-      Result.Top := LineBounds.Top;

-  end;

-

-  // if left or bottom bound was not set, set them to 0

-  if (Result.Left = Infinity) then

-    Result.Left := 0.0;

-  if (Result.Bottom = Infinity) then

-    Result.Bottom := 0.0;

-end;

-

-procedure TFTFont.Render(const Text: WideString);

+  UnderlineY1 := GetUnderlinePosition();
+  UnderlineY2 := UnderlineY1 + GetUnderlineThickness();
+  Bounds := BBox(Text, false);
+  glRectf(Bounds.Left, UnderlineY1, Bounds.Right, UnderlineY2);
+end;
+
+procedure TFont.SetStyle(Style: TFontStyle);
+begin
+  fStyle := Style;
+end;
+
+function TFont.GetStyle(): TFontStyle;
+begin
+  Result := fStyle;
+end;
+
+procedure TFont.SetLineSpacing(Spacing: single);
+begin
+  fLineSpacing := Spacing;
+end;
+
+function TFont.GetLineSpacing(): single;
+begin
+  Result := fLineSpacing;
+end;
+
+procedure TFont.SetGlyphSpacing(Spacing: single);
+begin
+  fGlyphSpacing := Spacing;
+end;
+
+function TFont.GetGlyphSpacing(): single;
+begin
+  Result := fGlyphSpacing;
+end;
+
+procedure TFont.SetReflectionSpacing(Spacing: single);
+begin
+  fReflectionSpacing := Spacing;
+end;
+
+function TFont.GetReflectionSpacing(): single;
+begin
+  Result := fReflectionSpacing;
+end;
+
+procedure TFont.SetUseKerning(Enable: boolean);
+begin
+  fUseKerning := Enable;
+end;
+
+function TFont.GetUseKerning(): boolean;
+begin
+  Result := fUseKerning;
+end;
+
+procedure TFont.SetReflectionPass(Enable: boolean);
+begin
+  fReflectionPass := Enable;
+end;
+
+
+{*
+ * TScalableFont
+ *}
+
+constructor TScalableFont.Create(Font: TFont; UseMipmaps: boolean);
+var
+  MipmapLevel: integer;
+begin
+  inherited Create();
+  
+  fBaseFont := Font;
+  fMipmapFonts[0] := Font;
+  fUseMipmaps := UseMipmaps;
+  ResetIntern();
+
+  // create mipmap fonts if requested
+  if (UseMipmaps) then
+  begin
+    for MipmapLevel := 1 to cMaxMipmapLevel do
+    begin
+      fMipmapFonts[MipmapLevel] := CreateMipmap(MipmapLevel, 1/(1 shl MipmapLevel));
+      // stop if no smaller mipmap font is returned
+      if (fMipmapFonts[MipmapLevel] = nil) then
+        Break;
+    end;
+  end;
+end;
+
+destructor TScalableFont.Destroy();
+var
+  Level: integer;
+begin
+  for Level := 0 to High(fMipmapFonts) do
+    fMipmapFonts[Level].Free;
+  inherited;
+end;
+
+procedure TScalableFont.ResetIntern();
+begin
+  fScale := 1.0;
+  fAspect := 1.0;
+end;
+
+procedure TScalableFont.Reset();
+var
+  Level: integer;
+begin
+  inherited;
+  ResetIntern();
+  for Level := 0 to High(fMipmapFonts) do
+    if (fMipmapFonts[Level] <> nil) then
+      fMipmapFonts[Level].Reset();
+end;
+
+{**
+ * Returns the mipmap level to use with regard to the current projection
+ * and modelview matrix, font scale and aspect.
+ *
+ * Note:
+ * - for Freetype fonts, hinting and grid-fitting must be disabled, otherwise
+ *   the glyph widths/heights ratios and advance widths of the mipmap fonts
+ *   do not match as they are adjusted sligthly (e.g. an 'a' at size 12px has
+ *   width 12px, but at size 6px width 8px).
+ * - returned mipmap-level is used for all glyphs of the current text to print.
+ *   This is faster, much easier to handle, since we just need to create
+ *   multiple sized fonts and select the one we need for the mipmap-level and
+ *   it avoids that neighbored glyphs use different mipmap-level which might
+ *   look odd because one glyph might look blurry and the other sharp.
+ *
+ * Motivation:
+ *   We do not use OpenGL for mipmapping as the results are very bad. At least
+ *   with automatic mipmap generation (gluBuildMipmaps) the fonts look rather
+ *   blurry.
+ *   Defining our own mipmaps by creating multiple textures with
+ *   for different mimap levels is a pain, as the font size passed to freetype
+ *   is not the size of the bitmaps created and it does not guarantee that a
+ *   glyph bitmap of a font with font-size s/2 is half the size of the font with
+ *   font-size s. If the bitmap size is just a single pixel bigger than the half
+ *   we might need a texture of the next power-of-2 and the texture would not be
+ *   half of the size of the next bigger mipmap. In addition we use a fixed one
+ *   pixel sized border to smooth the texture (see cTexSmoothBorder) and maybe
+ *   an outset that is added to the font, so creating a glyph mipmap that is
+ *   exactly half the size of the next bigger one is a very difficult task.
+ *
+ * Solution:
+ *   Use mipmap textures that are not exactly half the size of the next mipmap
+ *   level. OpenGL does not support this (at least not without extensions).
+ *   The trickiest task is to determine the mipmap to use by calculating the
+ *   amount of minification that is performed in this function.
+ *}
+function TScalableFont.GetMipmapLevel(): integer;
+var
+  ModelMatrix, ProjMatrix: T16dArray;
+  WinCoords: array[0..2, 0..2] of GLdouble;
+  ViewPortArray: TViewPortArray;
+  Dist, Dist2: double;
+  WidthScale, HeightScale: double;
+const
+  // width/height of square used for determining the scale
+  cTestSize = 10.0;
+  // an offset to the mipmap-level to adjust the change-over of two consecutive
+  // mipmap levels. If for example the bias is 0.1 and unbiased level is 1.9
+  // the result level will be 2. A bias of 0.5 is equal to rounding.
+  // With bias=0.1 we prefer larger mipmaps over smaller ones.
+  cBias = 0.2;
+begin
+  // 1. retrieve current transformation matrices for gluProject
+  glGetDoublev(GL_MODELVIEW_MATRIX, @ModelMatrix);
+  glGetDoublev(GL_PROJECTION_MATRIX, @ProjMatrix);
+  glGetIntegerv(GL_VIEWPORT, @ViewPortArray);
+
+  // 2. project three of the corner points of a square with size cTestSize
+  // to window coordinates (the square is just a dummy for a glyph)
+
+  // project point (x1, y1) to window corrdinates
+  gluProject(0, 0, 0,
+             ModelMatrix, ProjMatrix, ViewPortArray,
+             @WinCoords[0][0], @WinCoords[0][1], @WinCoords[0][2]);
+  // project point (x2, y1) to window corrdinates
+  gluProject(cTestSize, 0, 0,
+             ModelMatrix, ProjMatrix, ViewPortArray,
+             @WinCoords[1][0], @WinCoords[1][1], @WinCoords[1][2]);
+  // project point (x1, y2) to window corrdinates
+  gluProject(0, cTestSize, 0,
+             ModelMatrix, ProjMatrix, ViewPortArray,
+             @WinCoords[2][0], @WinCoords[2][1], @WinCoords[2][2]);
+
+  // 3. Lets see how much the width and height of the square changed.
+  // Calculate the width and height as displayed on the screen in window
+  // coordinates and calculate the ratio to the original coordinates in
+  // modelview space so the ratio gives us the scale (minification here).
+
+  // projected width ||(x1, y1) - (x2, y1)||
+  Dist  := (WinCoords[0][0] - WinCoords[1][0]);
+  Dist2 := (WinCoords[0][1] - WinCoords[1][1]);
+  WidthScale := cTestSize / Sqrt(Dist*Dist + Dist2*Dist2);
+
+  // projected height ||(x1, y1) - (x1, y2)||
+  Dist  := (WinCoords[0][0] - WinCoords[2][0]);
+  Dist2 := (WinCoords[0][1] - WinCoords[2][1]);
+  HeightScale := cTestSize / Sqrt(Dist*Dist + Dist2*Dist2);
+
+  //writeln(Format('Scale %f, %f', [WidthScale, HeightScale]));
+
+  // 4. Now that we have got the scale, take the bigger minification scale
+  // and get it to a logarithmic scale as each mipmap is 1/2 the size of its
+  // predecessor (Mipmap_size[i] = Mipmap_size[i-1]/2).
+  // The result is our mipmap-level = the index of the mipmap to use.
+
+  // Level > 0: Minification; < 0: Magnification
+  Result := Trunc(Log2(Max(WidthScale, HeightScale)) + cBias);
+
+  // clamp to valid range
+  if (Result < 0) then
+    Result := 0;
+  if (Result > High(fMipmapFonts)) then
+    Result := High(fMipmapFonts);
+end;
+
+function TScalableFont.GetMipmapScale(Level: integer): single;
+begin
+  if (fMipmapFonts[Level] = nil) then
+  begin
+    Result := -1;
+    Exit;
+  end;
+
+  Result := fScale * fMipmapFonts[0].Height / fMipmapFonts[Level].Height;
+end;
+
+{**
+ * Returns the correct mipmap font for the current scale and projection
+ * matrix. The modelview scale is adjusted to the mipmap level, so
+ * Result.Print() will display the font in the correct size.
+ *}
+function TScalableFont.ChooseMipmapFont(): TFont;
+var
+  DesiredLevel: integer;
+  Level: integer;
+  MipmapScale: single;
+begin
+  Result := nil;
+  DesiredLevel := GetMipmapLevel();
+
+  // get the smallest mipmap available for the desired level
+  // as not all levels must be assigned to a font.
+  for Level := DesiredLevel downto 0 do
+  begin
+    if (fMipmapFonts[Level] <> nil) then
+    begin
+      Result := fMipmapFonts[Level];
+      Break;
+    end;
+  end;
+
+  // since the mipmap font (if level > 0) is smaller than the base-font
+  // we have to scale to get its size right.
+  MipmapScale := fMipmapFonts[0].Height/Result.Height;
+  glScalef(MipmapScale, MipmapScale, 0);
+end;
+
+procedure TScalableFont.Print(const Text: TWideStringArray);
+begin
+  glPushMatrix();
+
+  // set scale and stretching
+  glScalef(fScale * fAspect, fScale, 0);
+
+  // print text
+  if (fUseMipmaps) then
+    ChooseMipmapFont().Print(Text)
+  else
+    fBaseFont.Print(Text);
+
+  glPopMatrix();
+end;
+
+procedure TScalableFont.Render(const Text: WideString);
+begin
+  Assert(false, 'Unused TScalableFont.Render() was called');
+end;
+
+function TScalableFont.BBox(const Text: TWideStringArray; Advance: boolean): TBoundsDbl;
+begin
+  Result := fBaseFont.BBox(Text, Advance);
+  Result.Left   := Result.Left * fScale * fAspect;
+  Result.Right  := Result.Right * fScale * fAspect;
+  Result.Top    := Result.Top * fScale;
+  Result.Bottom := Result.Bottom * fScale;
+end;
+
+procedure TScalableFont.SetHeight(Height: single);
+begin
+  fScale := Height / fBaseFont.GetHeight();
+end;
+
+function TScalableFont.GetHeight(): single;
+begin
+  Result := fBaseFont.GetHeight() * fScale;
+end;
+
+procedure TScalableFont.SetAspect(Aspect: single);
+begin
+  fAspect := Aspect;
+end;
+
+function TScalableFont.GetAspect(): single;
+begin
+  Result := fAspect;
+end;
+
+function TScalableFont.GetAscender(): single;
+begin
+  Result := fBaseFont.GetAscender() * fScale;
+end;
+
+function TScalableFont.GetDescender(): single;
+begin
+  Result := fBaseFont.GetDescender() * fScale;
+end;
+
+procedure TScalableFont.SetLineSpacing(Spacing: single);
+var
+  Level: integer;
+begin
+  for Level := 0 to High(fMipmapFonts) do
+    if (fMipmapFonts[Level] <> nil) then
+      fMipmapFonts[Level].SetLineSpacing(Spacing / GetMipmapScale(Level));
+end;
+
+function TScalableFont.GetLineSpacing(): single;
+begin
+  Result := fBaseFont.GetLineSpacing() * fScale;
+end;
+
+procedure TScalableFont.SetGlyphSpacing(Spacing: single);
+var
+  Level: integer;
+begin
+  for Level := 0 to High(fMipmapFonts) do
+    if (fMipmapFonts[Level] <> nil) then
+      fMipmapFonts[Level].SetGlyphSpacing(Spacing / GetMipmapScale(Level));
+end;
+
+function TScalableFont.GetGlyphSpacing(): single;
+begin
+  Result := fBaseFont.GetGlyphSpacing() * fScale;
+end;
+
+procedure TScalableFont.SetReflectionSpacing(Spacing: single);
+var
+  Level: integer;
+begin
+  for Level := 0 to High(fMipmapFonts) do
+    if (fMipmapFonts[Level] <> nil) then
+      fMipmapFonts[Level].SetReflectionSpacing(Spacing / GetMipmapScale(Level));
+end;
+
+function TScalableFont.GetReflectionSpacing(): single;
+begin
+  Result := fBaseFont.GetLineSpacing() * fScale;
+end;
+
+procedure TScalableFont.SetStyle(Style: TFontStyle);
+var
+  Level: integer;
+begin
+  for Level := 0 to High(fMipmapFonts) do
+    if (fMipmapFonts[Level] <> nil) then
+      fMipmapFonts[Level].SetStyle(Style);
+end;
+
+function TScalableFont.GetStyle(): TFontStyle;
+begin
+  Result := fBaseFont.GetStyle();
+end;
+
+function TScalableFont.GetUnderlinePosition(): single;
+begin
+  Result := fBaseFont.GetUnderlinePosition();
+end;
+
+function TScalableFont.GetUnderlineThickness(): single;
+begin
+  Result := fBaseFont.GetUnderlinePosition();
+end;
+
+procedure TScalableFont.SetUseKerning(Enable: boolean);
+var
+  Level: integer;
+begin
+  for Level := 0 to High(fMipmapFonts) do
+    if (fMipmapFonts[Level] <> nil) then
+      fMipmapFonts[Level].SetUseKerning(Enable);
+end;
+
+
+{*
+ * TCachedFont
+ *}
+
+constructor TCachedFont.Create();
+begin
+  inherited;
+  fCache := TGlyphCache.Create();
+end;
+
+destructor TCachedFont.Destroy();
+begin
+  fCache.Free;
+  inherited;
+end;
+
+function TCachedFont.GetGlyph(ch: WideChar): TGlyph;
+begin
+  Result := fCache.GetGlyph(ch);
+  if (Result = nil) then
+  begin
+    Result := LoadGlyph(ch);
+    if (not fCache.AddGlyph(ch, Result)) then
+      Result.Free;
+  end;
+end;
+
+procedure TCachedFont.FlushCache(KeepBaseSet: boolean);
+begin
+  fCache.FlushCache(KeepBaseSet);
+end;
+
+
+{*
+ * TFTFont
+ *}
+
+constructor TFTFont.Create(
+    const Filename: string;
+    Size: integer; Outset: single;
+    LoadFlags: FT_Int32);
+var
+  i: WideChar;
+begin
+  inherited Create();
+
+  fFilename := Filename;
+  fSize := Size;
+  fOutset := Outset;
+  fLoadFlags := LoadFlags;
+  fUseDisplayLists := true;
+
+  // load font information
+  if (FT_New_Face(TFreeType.GetLibrary(), PChar(Filename), 0, fFace) <> 0) then
+    raise Exception.Create('FT_New_Face: Could not load font '''  + Filename + '''');
+
+  // support scalable fonts only
+  if (not FT_IS_SCALABLE(fFace)) then
+    raise Exception.Create('Font is not scalable');
+
+  if (FT_Set_Pixel_Sizes(fFace, 0, Size) <> 0) then
+    raise Exception.Create('FT_Set_Pixel_Sizes failes');
+
+  // get scale factor for font-unit to pixel-size transformation
+  fFontUnitScale.X := fFace.size.metrics.x_ppem / fFace.units_per_EM;
+  fFontUnitScale.Y := fFace.size.metrics.y_ppem / fFace.units_per_EM;
+
+  ResetIntern();
+
+  // pre-cache some commonly used glyphs (' ' - '~')
+  for i := #32 to #126 do
+    fCache.AddGlyph(i, TFTGlyph.Create(Self, i, Outset, LoadFlags));
+end;
+
+destructor TFTFont.Destroy();
+begin
+  // free face
+  FT_Done_Face(fFace);
+  inherited;
+end;
+
+procedure TFTFont.ResetIntern();
+begin
+  // Note: outset and non outset fonts use same spacing
+  fLineSpacing := fFace.height * fFontUnitScale.Y;
+  fReflectionSpacing := -2*fFace.descender * fFontUnitScale.Y;
+end;
+
+procedure TFTFont.Reset();
+begin
+  inherited;
+  ResetIntern();
+end;
+
+function TFTFont.LoadGlyph(ch: WideChar): TGlyph;
+begin
+  Result := TFTGlyph.Create(Self, ch, Outset, fLoadFlags);
+end;
+
+function TFTFont.BBox(const Text: TWideStringArray; Advance: boolean): TBoundsDbl;
+var
+  Glyph, PrevGlyph: TFTGlyph;
+  TextLine: WideString;
+  LineYOffset: single;
+  LineIndex, CharIndex: integer;
+  LineBounds: TBoundsDbl;
+  KernDelta: FT_Vector;
+  UnderlinePos: double;
+begin
+  // Reset global bounds
+  Result.Left   := Infinity;
+  Result.Right  := 0;
+  Result.Bottom := Infinity;
+  Result.Top    := 0;
+
+  // reset last glyph
+  PrevGlyph := nil;
+
+  // display text
+  for LineIndex := 0 to High(Text) do
+  begin
+    // get next text line
+    TextLine := Text[LineIndex];
+    LineYOffset := -LineSpacing * LineIndex;
+
+    // reset line bounds
+    LineBounds.Left   := Infinity;
+    LineBounds.Right  := 0;
+    LineBounds.Bottom := Infinity;
+    LineBounds.Top    := 0;
+
+    // for each glyph image, compute its bounding box
+    for CharIndex := 1 to Length(TextLine) do
+    begin
+      Glyph := TFTGlyph(GetGlyph(TextLine[CharIndex]));
+      if (Glyph <> nil) then
+      begin
+        // get kerning
+        if (fUseKerning and FT_HAS_KERNING(fFace) and (PrevGlyph <> nil)) then
+        begin
+          FT_Get_Kerning(fFace, PrevGlyph.CharIndex, Glyph.CharIndex,
+                         FT_KERNING_UNSCALED, KernDelta);
+          LineBounds.Right := LineBounds.Right + KernDelta.x * fFontUnitScale.X;
+        end;
+
+        // update left bound (must be done before right bound is updated)
+        if (LineBounds.Right + Glyph.Bounds.Left < LineBounds.Left) then
+          LineBounds.Left := LineBounds.Right + Glyph.Bounds.Left;
+
+        // update right bound
+        if (CharIndex < Length(TextLine)) or  // not the last character
+           (TextLine[CharIndex] = ' ') or     // on space char (Bounds.Right = 0)
+           Advance then                       // or in advance mode
+        begin
+          // add advance and glyph spacing
+          LineBounds.Right := LineBounds.Right + Glyph.Advance.x + GlyphSpacing
+        end
+        else
+        begin
+          // add glyph's right bound
+          LineBounds.Right := LineBounds.Right + Glyph.Bounds.Right;
+        end;
+
+        // update bottom and top bounds
+        if (Glyph.Bounds.Bottom < LineBounds.Bottom) then
+          LineBounds.Bottom := Glyph.Bounds.Bottom;
+        if (Glyph.Bounds.Top > LineBounds.Top) then
+          LineBounds.Top := Glyph.Bounds.Top;
+      end;
+
+      PrevGlyph := Glyph;
+    end;
+
+    // handle italic font style
+    if (Italic in Style) then
+    begin
+      LineBounds.Left := LineBounds.Left + LineBounds.Bottom * cShearFactor;
+      LineBounds.Right := LineBounds.Right + LineBounds.Top * cShearFactor;
+    end;
+
+    // handle underlined font style
+    if (Underline in Style) then
+    begin
+      UnderlinePos := GetUnderlinePosition();
+      if (UnderlinePos < LineBounds.Bottom) then
+        LineBounds.Bottom := UnderlinePos;
+    end;
+
+    // add line offset
+    LineBounds.Bottom := LineBounds.Bottom + LineYOffset;
+    LineBounds.Top := LineBounds.Top + LineYOffset;
+
+    // adjust global bounds
+    if (Result.Left > LineBounds.Left) then
+      Result.Left := LineBounds.Left;
+    if (Result.Right < LineBounds.Right) then
+      Result.Right := LineBounds.Right;
+    if (Result.Bottom > LineBounds.Bottom) then
+      Result.Bottom := LineBounds.Bottom;
+    if (Result.Top < LineBounds.Top) then
+      Result.Top := LineBounds.Top;
+  end;
+
+  // if left or bottom bound was not set, set them to 0
+  if (Result.Left = Infinity) then
+    Result.Left := 0.0;
+  if (Result.Bottom = Infinity) then
+    Result.Bottom := 0.0;
+end;
+
+procedure TFTFont.Render(const Text: WideString);
 var
   CharIndex: integer;
-  Glyph, PrevGlyph: TFTGlyph;

-  KernDelta: FT_Vector;

-begin

-  // reset last glyph

-  PrevGlyph := nil;

-

-  // draw current line

-  for CharIndex := 1 to Length(Text) do

-  begin

-    Glyph := TFTGlyph(GetGlyph(Text[CharIndex]));

-    if (Assigned(Glyph)) then

-    begin

-      // get kerning

-      if (fUseKerning and FT_HAS_KERNING(fFace) and (PrevGlyph <> nil)) then

-      begin

-        FT_Get_Kerning(fFace, PrevGlyph.CharIndex, Glyph.CharIndex,

-                       FT_KERNING_UNSCALED, KernDelta);

-        glTranslatef(KernDelta.x * fFontUnitScale.X, 0, 0);

-      end;

-

-      if (ReflectionPass) then

-        Glyph.RenderReflection()

-      else

-        Glyph.Render(fUseDisplayLists);

-

-      glTranslatef(Glyph.Advance.x + fGlyphSpacing, 0, 0);

-    end;

-

-    PrevGlyph := Glyph;

-  end;

-end;

-
-function TFTFont.GetHeight(): single;

-begin

-  Result := Ascender - Descender;

-end;

-

-function TFTFont.GetAscender(): single;

-begin

-  Result := fFace.ascender * fFontUnitScale.Y + Outset*2;

-end;

-

-function TFTFont.GetDescender(): single;

-begin

-  // Note: outset is not part of the descender as the baseline is lifted

-  Result := fFace.descender * fFontUnitScale.Y;

-end;

-

-function TFTFont.GetUnderlinePosition(): single;

-begin

-  Result := fFace.underline_position * fFontUnitScale.Y - Outset;

-end;

-

-function TFTFont.GetUnderlineThickness(): single;

-begin

-  Result := fFace.underline_thickness * fFontUnitScale.Y + Outset*2;

-end;

-

-

-{*

- * TFTScalableFont

- *}

-

-constructor TFTScalableFont.Create(const Filename: string;

-                   Size: integer; OutsetAmount: single;

-                   UseMipmaps: boolean);

-var

-  LoadFlags: FT_Int32;

-begin

-  LoadFlags := FT_LOAD_DEFAULT;

-  // Disable hinting and grid-fitting to preserve font outlines at each font

-  // size, otherwise the font widths/heights do not match resulting in ugly

-  // text size changes during zooming.

-  // A drawback is a reduced quality with smaller font sizes but it is not that

-  // bad with gray-scaled rendering (at least it looks better than OpenGL's

-  // linear downscaling on minification).

-  if (UseMipmaps) then

-    LoadFlags := LoadFlags or FT_LOAD_NO_HINTING;

-  inherited Create(

-      TFTFont.Create(Filename, Size, Size * OutsetAmount, LoadFlags),

-      UseMipmaps);

-end;

-

-function TFTScalableFont.CreateMipmap(Level: integer; Scale: single): TFont;

-var

-  ScaledSize: integer;

-  BaseFont: TFTFont;

-begin

-  Result := nil;

-  BaseFont := TFTFont(fBaseFont);

-  ScaledSize := Round(BaseFont.Size * Scale);

-  // do not create mipmap fonts < 8 pixels

-  if (ScaledSize < 8) then

-    Exit;

-  Result := TFTFont.Create(BaseFont.fFilename,

-      ScaledSize, BaseFont.fOutset * Scale,

-      FT_LOAD_DEFAULT or FT_LOAD_NO_HINTING);

-end;

-

-function TFTScalableFont.GetOutset(): single;

-begin

-  Result := TFTFont(fBaseFont).Outset * fScale;

-end;

-

-procedure TFTScalableFont.FlushCache(KeepBaseSet: boolean);

-var

-  Level: integer;

-begin

-  for Level := 0 to High(fMipmapFonts) do

-    if (fMipmapFonts[Level] <> nil) then

-      TFTFont(fMipmapFonts[Level]).FlushCache(KeepBaseSet);

-end;

-

-

-{*

- * TOutlineFont

- *}

-

-constructor TFTOutlineFont.Create(

-    const Filename: string;

-    Size: integer; Outset: single;

-    LoadFlags: FT_Int32);

-begin

-  inherited Create();

-

-  fFilename := Filename;

-  fSize := Size;

-  fOutset := Outset;

-

-  fInnerFont := TFTFont.Create(Filename, Size, 0.0, LoadFlags);

-  fOutlineFont := TFTFont.Create(Filename, Size, Outset, LoadFlags);

-

-  ResetIntern();

-end;

-

-destructor TFTOutlineFont.Destroy;

-begin

-  fOutlineFont.Free;

-  fInnerFont.Free;

-  inherited;

-end;

-

-procedure TFTOutlineFont.ResetIntern();

-begin

-  // TODO: maybe swap fInnerFont/fOutlineFont.GlyphSpacing to use the spacing

-  // of the outline font?

-  //fInnerFont.GlyphSpacing := fOutset*2;

-  fOutlineFont.GlyphSpacing := -fOutset*2;

-

-  fLineSpacing := fOutlineFont.LineSpacing;

-  fReflectionSpacing := fOutlineFont.ReflectionSpacing;

-  fOutlineColor := NewGLColor(0, 0, 0, 1);

-end;

-

-procedure TFTOutlineFont.Reset();

-begin

-  inherited;

-  fInnerFont.Reset();

-  fOutlineFont.Reset();

-  ResetIntern();

-end;

-

-procedure TFTOutlineFont.DrawUnderline(const Text: WideString);

-begin

-  glPushAttrib(GL_CURRENT_BIT);

-  glColor4fv(@fOutlineColor.vals);

-  fOutlineFont.DrawUnderline(Text);

-  glPopAttrib();

-

-  glPushMatrix();

-  glTranslatef(fOutset, 0, 0);

-  fInnerFont.DrawUnderline(Text);

-  glPopMatrix();

-end;

-

-procedure TFTOutlineFont.Render(const Text: WideString);

-begin

-  { setup and render outline font }

-

-  // save old color

-  glPushAttrib(GL_CURRENT_BIT);

-  glColor4fv(@fOutlineColor.vals);

-  glPushMatrix();

-  fOutlineFont.Render(Text);

-  glPopMatrix();

-  glPopAttrib();

-

-  { setup and render inner font }

-

-  glPushMatrix();

-  glTranslatef(fOutset, fOutset, 0);

-  fInnerFont.Render(Text);

-  glPopMatrix();

-end;

-

-procedure TFTOutlineFont.SetOutlineColor(r, g, b: GLfloat; a: GLfloat);

-begin

-  fOutlineColor := NewGLColor(r, g, b, a);

-end;

-

-procedure TFTOutlineFont.FlushCache(KeepBaseSet: boolean);

-begin

-  fOutlineFont.FlushCache(KeepBaseSet);

-  fInnerFont.FlushCache(KeepBaseSet);

-end;

-

-function TFTOutlineFont.BBox(const Text: TWideStringArray; Advance: boolean): TBoundsDbl;

-begin

-  Result := fOutlineFont.BBox(Text, Advance);

-end;

-

-function TFTOutlineFont.GetHeight(): single;

-begin

-  Result := fOutlineFont.Height;

-end;

-

-function TFTOutlineFont.GetAscender(): single;

-begin

-  Result := fOutlineFont.Ascender;

-end;

-

-function TFTOutlineFont.GetDescender(): single;

-begin

-  Result := fOutlineFont.Descender;

-end;

-

-procedure TFTOutlineFont.SetLineSpacing(Spacing: single);

-begin

-  inherited SetLineSpacing(Spacing);

-  fInnerFont.LineSpacing := Spacing;

-  fOutlineFont.LineSpacing := Spacing;

-end;

-

-procedure TFTOutlineFont.SetGlyphSpacing(Spacing: single);

-begin

-  inherited SetGlyphSpacing(Spacing);

-  fInnerFont.GlyphSpacing := Spacing;

-  fOutlineFont.GlyphSpacing := Spacing - Outset*2;

-end;

-

-procedure TFTOutlineFont.SetReflectionSpacing(Spacing: single);

-begin

-  inherited SetReflectionSpacing(Spacing);

-  fInnerFont.ReflectionSpacing := Spacing;

-  fOutlineFont.ReflectionSpacing := Spacing;

-end;

-

-procedure TFTOutlineFont.SetStyle(Style: TFontStyle);

-begin

-  inherited SetStyle(Style);

-  fInnerFont.Style := Style;

-  fOutlineFont.Style := Style;

-end;

-

-function TFTOutlineFont.GetStyle(): TFontStyle;

-begin

-  Result := inherited GetStyle();

-end;

-

-function TFTOutlineFont.GetUnderlinePosition(): single;

-begin

-  Result := fOutlineFont.GetUnderlinePosition();

-end;

-

-function TFTOutlineFont.GetUnderlineThickness(): single;

-begin

-  Result := fOutlineFont.GetUnderlinePosition();

-end;

-

-procedure TFTOutlineFont.SetUseKerning(Enable: boolean);

-begin

-  inherited SetUseKerning(Enable);

-  fInnerFont.fUseKerning := Enable;

-  fOutlineFont.fUseKerning := Enable;

-end;

-

-procedure TFTOutlineFont.SetReflectionPass(Enable: boolean);

-begin

-  inherited SetReflectionPass(Enable);

-  fInnerFont.fReflectionPass := Enable;

-  fOutlineFont.fReflectionPass := Enable;

-end;

-

-{**

- * TScalableOutlineFont

- *}

-

-constructor TFTScalableOutlineFont.Create(

-    const Filename: string;

-    Size: integer; OutsetAmount: single;

-    UseMipmaps: boolean);

-var

-  LoadFlags: FT_Int32;

-begin

-  LoadFlags := FT_LOAD_DEFAULT;

-  // Disable hinting and grid-fitting (see TFTScalableFont.Create)

-  if (UseMipmaps) then

-    LoadFlags := LoadFlags or FT_LOAD_NO_HINTING;

-  inherited Create(

-      TFTOutlineFont.Create(Filename, Size, Size*OutsetAmount, LoadFlags),

-      UseMipmaps);

-end;

-

-function TFTScalableOutlineFont.CreateMipmap(Level: integer; Scale: single): TFont;

-var

-  ScaledSize: integer;

-  BaseFont: TFTOutlineFont;

-begin

-  Result := nil;

-  BaseFont := TFTOutlineFont(fBaseFont);

-  ScaledSize := Round(BaseFont.Size*Scale);

-  // do not create mipmap fonts < 8 pixels

-  if (ScaledSize < 8) then

-    Exit;

-  Result := TFTOutlineFont.Create(BaseFont.fFilename,

-      ScaledSize, BaseFont.fOutset*Scale,

-      FT_LOAD_DEFAULT or FT_LOAD_NO_HINTING);

-end;

-

-function TFTScalableOutlineFont.GetOutset(): single;

-begin

-  Result := TFTOutlineFont(fBaseFont).Outset * fScale;

-end;

-

-procedure TFTScalableOutlineFont.SetOutlineColor(r, g, b: GLfloat; a: GLfloat);

-var

-  Level: integer;

-begin

-  for Level := 0 to High(fMipmapFonts) do

-    if (fMipmapFonts[Level] <> nil) then

-      TFTOutlineFont(fMipmapFonts[Level]).SetOutlineColor(r, g, b, a);

-end;

-

-procedure TFTScalableOutlineFont.FlushCache(KeepBaseSet: boolean);

-var

-  Level: integer;

-begin

-  for Level := 0 to High(fMipmapFonts) do

-    if (fMipmapFonts[Level] <> nil) then

-      TFTOutlineFont(fMipmapFonts[Level]).FlushCache(KeepBaseSet);

-end;

-

-

-{*

- * TFTGlyph

- *}

-

-const

-  {**

-   * Size of the transparent border surrounding the glyph image in the texture.

-   * The border is necessary because OpenGL does not smooth texels at the

-   * border of a texture with the GL_CLAMP or GL_CLAMP_TO_EDGE styles.

-   * Without the border, magnified glyph textures look very ugly at their edges.

-   * It looks edgy, as if some pixels are missing especially on the left edge

-   * (just set cTexSmoothBorder to 0 to see what is meant by this).

-   * With the border even the glyphs edges are blended to the border (transparent)

-   * color and everything looks nice.

-   *

-   * Note:

-   * OpenGL already supports texture border by setting the border parameter

-   * of glTexImage*D() to 1 and using a texture size of 2^m+2b and setting the

-   * border pixels to the border color. In some forums it is discouraged to use

-   * the border parameter as only a few of the more modern graphics cards support

-   * this feature. On an ATI Radeon 9700 card, the slowed down to 0.5 fps and

-   * the glyph's background got black.  So instead of using this feature we

-   * handle it on our own. The only drawback is that textures might get bigger

-   * because the border might require a higher power of 2 size instead of just

-   * two additional pixels.

-   *}

-  cTexSmoothBorder = 1;

-

-procedure TFTGlyph.Extrude(var TexBuffer: TGLubyteDynArray; Outset: single);

-

-  procedure SetToMax(var Val1: GLubyte; Val2: GLubyte); {$IFDEF HasInline}inline;{$ENDIF}

-  begin

-    if (Val1 < Val2) then

-      Val1 := Val2;

-  end;

-

-var

-  I, X, Y: integer;

-  SrcBuffer,TmpBuffer: TGLubyteDynArray;

-  TexLine, TexLinePrev, TexLineNext: PGLubyteArray;

-  SrcLine: PGLubyteArray;

-  AlphaScale: single;

-  Value, ValueNeigh, ValueDiag: GLubyte;

-const

-  // square-root of 2 used for diagonal neighbor pixels

-  cSqrt2 = 1.4142;

-  // number of ignored pixels on each edge of the bitmap. Consists of:

-  // - border used for font smoothing and

-  // - outer (extruded) bitmap pixel (because it is just written but never read)

-  cBorder = cTexSmoothBorder + 1;

-begin

-  // allocate memory for temporary buffer

-  SetLength(SrcBuffer, Length(TexBuffer));

-  FillChar(SrcBuffer[0], Length(TexBuffer), 0);

-

-  // extrude pixel by pixel

-  for I := 1 to Ceil(Outset) do

-  begin

-    // swap arrays

-    TmpBuffer := TexBuffer;

-    TexBuffer := SrcBuffer;

-    SrcBuffer := TmpBuffer;

-

-    // as long as we add an entire pixel of outset, use a solid color.

-    // If the fractional part is reached blend, e.g. outline=3.2 -> 3 solid

-    // pixels and one blended with alpha=0.2.

-    // For the fractional part I = Ceil(Outset) is always true.

-    if (I <= Outset) then

-      AlphaScale := 1

-    else

-      AlphaScale := Outset - Trunc(Outset);

-

-    // copy data to the expanded bitmap.

-    for Y := cBorder to fTexSize.Height - 2*cBorder do

-    begin

-      TexLine     := @TexBuffer[Y*fTexSize.Width];

-      TexLinePrev := @TexBuffer[(Y-1)*fTexSize.Width];

-      TexLineNext := @TexBuffer[(Y+1)*fTexSize.Width];

-      SrcLine     := @SrcBuffer[Y*fTexSize.Width];

-

-      // expand current line's pixels

-      for X := cBorder to fTexSize.Width - 2*cBorder do

-      begin

-        Value := SrcLine[X];

-        ValueNeigh := Round(Value * AlphaScale);

-        ValueDiag := Round(ValueNeigh / cSqrt2);

-

-        SetToMax(TexLine[X],   Value);

-        SetToMax(TexLine[X-1], ValueNeigh);

-        SetToMax(TexLine[X+1], ValueNeigh);

-

-        SetToMax(TexLinePrev[X],   ValueNeigh);

-        SetToMax(TexLinePrev[X-1], ValueDiag);

-        SetToMax(TexLinePrev[X+1], ValueDiag);

-

-        SetToMax(TexLineNext[X],   ValueNeigh);

-        SetToMax(TexLineNext[X-1], ValueDiag);

-        SetToMax(TexLineNext[X+1], ValueDiag);

-      end;

-    end;

-  end;

-

-  TmpBuffer := nil;

-  SetLength(SrcBuffer, 0);

-end;

-

-procedure TFTGlyph.CreateTexture(LoadFlags: FT_Int32);

-var

-  X, Y:          integer;

-  Glyph:         FT_Glyph;

-  BitmapGlyph:   FT_BitmapGlyph;

-  Bitmap:        PFT_Bitmap;

-  BitmapLine:    PChar;

-  BitmapBuffer:  PChar;

-  TexBuffer:     TGLubyteDynArray;

-  TexLine:       PGLubyteArray;

-  CBox:          FT_BBox;

-begin

-  // load the Glyph for our character

-  if (FT_Load_Glyph(fFont.Face, fCharIndex, LoadFlags) <> 0) then

-    raise Exception.Create('FT_Load_Glyph failed');

-

-  // move the face's glyph into a Glyph object

-  if (FT_Get_Glyph(fFont.Face^.glyph, Glyph) <> 0) then

-    raise Exception.Create('FT_Get_Glyph failed');

-

-  // store scaled advance width/height in glyph-object

-  fAdvance.X := fFont.Face^.glyph^.advance.x / 64 + fOutset*2;

-  fAdvance.Y := fFont.Face^.glyph^.advance.y / 64 + fOutset*2;

-

-  // get the contour's bounding box (in 1/64th pixels, not font-units)

-  FT_Glyph_Get_CBox(Glyph, FT_GLYPH_BBOX_UNSCALED, CBox);

-  // convert 1/64th values to double values

-  fBounds.Left   := CBox.xMin / 64;

-  fBounds.Right  := CBox.xMax / 64 + fOutset*2;

-  fBounds.Bottom := CBox.yMin / 64;

-  fBounds.Top    := CBox.yMax / 64 + fOutset*2;

-

-  // convert the glyph to a bitmap (and destroy original glyph image)

-  FT_Glyph_To_Bitmap(Glyph, ft_render_mode_normal, nil, 1);

-  BitmapGlyph := FT_BitmapGlyph(Glyph);

-

-  // get bitmap offsets

-  fBitmapCoords.Left := BitmapGlyph^.left - cTexSmoothBorder;

-  // Note: add 1*fOutset for lifting the baseline so outset fonts to not intersect

-  // with the baseline; Ceil(fOutset) for the outset pixels added to the bitmap.

-  fBitmapCoords.Top  := BitmapGlyph^.top + fOutset+Ceil(fOutset) + cTexSmoothBorder;

-

-  // make accessing the bitmap easier

-  Bitmap := @BitmapGlyph^.bitmap;

-  // get bitmap dimensions

-  fBitmapCoords.Width  := Bitmap.width + (Ceil(fOutset) + cTexSmoothBorder)*2;

-  fBitmapCoords.Height := Bitmap.rows + (Ceil(fOutset) + cTexSmoothBorder)*2;

-

-  // get power-of-2 bitmap widths

-  fTexSize.Width  :=

-      NextPowerOf2(Bitmap.width + (Ceil(fOutset) + cTexSmoothBorder)*2);

-  fTexSize.Height :=

-      NextPowerOf2(Bitmap.rows + (Ceil(fOutset) + cTexSmoothBorder)*2);

-

-  // texture-widths ignoring empty (power-of-2) padding space

-  fTexOffset.X := fBitmapCoords.Width / fTexSize.Width;

-  fTexOffset.Y := fBitmapCoords.Height / fTexSize.Height;

-

-  // allocate memory for texture data

-  SetLength(TexBuffer, fTexSize.Width * fTexSize.Height);

-  FillChar(TexBuffer[0], Length(TexBuffer), 0);

-

-  // Freetype stores the bitmap with either upper (pitch is > 0) or lower

-  // (pitch < 0) glyphs line first. Set the buffer to the upper line.

-  // See http://freetype.sourceforge.net/freetype2/docs/glyphs/glyphs-7.html

-  if (Bitmap.pitch > 0) then

-    BitmapBuffer := @Bitmap.buffer[0]

-  else

-    BitmapBuffer := @Bitmap.buffer[(Bitmap.rows-1) * Abs(Bitmap.pitch)];

-

-  // copy data to texture bitmap (upper line first).

-  for Y := 0 to Bitmap.rows-1 do

-  begin

-    // set pointer to first pixel in line that holds bitmap data.

-    // Each line starts with a cTexSmoothBorder pixel and multiple outset pixels

-    // that are added by Extrude() later.

-    TexLine := @TexBuffer[(Y + cTexSmoothBorder + Ceil(fOutset)) * fTexSize.Width +

-                          cTexSmoothBorder + Ceil(fOutset)];

-    // get next lower line offset, use pitch instead of width as it tells

-    // us the storage direction of the lines. In addition a line might be padded.

-    BitmapLine := @BitmapBuffer[Y * Bitmap.pitch];

-    for X := 0 to Bitmap.width-1 do

-      TexLine[X] := GLubyte(BitmapLine[X]);

-  end;

-

-  if (fOutset > 0) then

-    Extrude(TexBuffer, fOutset);

-

-  // allocate resources for textures and display lists

-  glGenTextures(1, @fTexture);

-

-  // setup texture parameters

-  glBindTexture(GL_TEXTURE_2D, fTexture);

-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);

-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

-

-  glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

-  // create alpha-map (GL_ALPHA component only).

-  // TexCoord (0,0) corresponds to the top left pixel of the glyph,

-  // (1,1) to the bottom right pixel. So the glyph is flipped as OpenGL uses

-  // a cartesian (y-axis up) coordinate system for textures.   

-  // See the cTexSmoothBorder comment for info on texture borders.

-  glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, fTexSize.Width, fTexSize.Height,

-      0, GL_ALPHA, GL_UNSIGNED_BYTE, @TexBuffer[0]);

-

-  // free expanded data

-  SetLength(TexBuffer, 0);

-

-  // create the display list

-  fDisplayList := glGenLists(1);

-

-  // render to display-list

-  glNewList(fDisplayList, GL_COMPILE);

-    Render(false);

-  glEndList();

-

-  // free glyph data (bitmap, etc.)

-  FT_Done_Glyph(Glyph);

-end;

-

-constructor TFTGlyph.Create(Font: TFTFont; ch: WideChar; Outset: single;

-    LoadFlags: FT_Int32);

-begin

-  inherited Create();

-

-  fFont := Font;

-  fOutset := Outset;

-

-  // get the Freetype char-index (use default UNICODE charmap)

-  fCharIndex := FT_Get_Char_Index(Font.fFace, FT_ULONG(ch));

-

-  CreateTexture(LoadFlags);

-end;

-

-destructor TFTGlyph.Destroy;

-begin

-  if (fDisplayList <> 0) then

-    glDeleteLists(fDisplayList, 1);

-  if (fTexture <> 0) then

-    glDeleteTextures(1, @fTexture);

-  inherited;

-end;

-

-procedure TFTGlyph.Render(UseDisplayLists: boolean);

-begin

-  // use display-lists if enabled and exit

-  if (UseDisplayLists) then

-  begin

-    glCallList(fDisplayList);

-    Exit;

-  end;

-

-  glBindTexture(GL_TEXTURE_2D, fTexture);

-  glPushMatrix();

-

-  // move to top left glyph position

-  glTranslatef(fBitmapCoords.Left, fBitmapCoords.Top, 0);

-

-  // draw glyph texture

-  glBegin(GL_QUADS);

-    // top right

-    glTexCoord2f(fTexOffset.X, 0);

-    glVertex2f(fBitmapCoords.Width, 0);

-

-    // top left

-    glTexCoord2f(0, 0);

-    glVertex2f(0, 0);

-

-    // bottom left

-    glTexCoord2f(0, fTexOffset.Y);

-    glVertex2f(0, -fBitmapCoords.Height);

-

-    // bottom right

-    glTexCoord2f(fTexOffset.X, fTexOffset.Y);

-    glVertex2f(fBitmapCoords.Width, -fBitmapCoords.Height);

-  glEnd();

-

-  glPopMatrix();

-end;

-

-procedure TFTGlyph.RenderReflection();

-var

-  Color: TGLColor;

-  TexUpperPos: single;

-  TexLowerPos: single;

-  UpperPos: single;

-const

-  CutOff = 0.6;

-begin

-  glPushMatrix();

-  glBindTexture(GL_TEXTURE_2D, fTexture);

-  glGetFloatv(GL_CURRENT_COLOR, @Color.vals);

-

-  // add extra space to the left of the glyph

-  glTranslatef(fBitmapCoords.Left, 0, 0);

-

-  // The upper position of the glyph, if CutOff is 1.0, it is fFont.Ascender.

-  // If CutOff is set to 0.5 only half of the glyph height is displayed.

-  UpperPos := fFont.Descender + fFont.Height * CutOff;

-

-  // the glyph texture's height is just the height of the glyph but not the font

-  // height. Setting a color for the upper and lower bounds of the glyph results

-  // in different color gradients. So we have to set the color values for the

-  // descender and ascender (as we have a cutoff, for the upper-pos here) as

-  // these positions are font but not glyph specific.

-

-  // To get the texture positions we have to enhance the texture at the top and

-  // bottom by the amount from the top to ascender (rather upper-pos here) and

-  // from the bottom (Height-Top) to descender. Then we have to convert those

-  // heights to texture coordinates by dividing by the bitmap Height and

-  // removing the power-of-2 padding space by multiplying with fTexOffset.Y

-  // (as fBitmapCoords.Height corresponds to fTexOffset.Y and not 1.0).

-  TexUpperPos  := -(UpperPos - fBitmapCoords.Top) / fBitmapCoords.Height * fTexOffset.Y;

-  TexLowerPos := (-(fFont.Descender + fBitmapCoords.Height - fBitmapCoords.Top) /

-                    fBitmapCoords.Height + 1) * fTexOffset.Y;

-

-  // draw glyph texture

-  glBegin(GL_QUADS);

-    // top right

-    glColor4f(Color.r, Color.g, Color.b, 0);

-    glTexCoord2f(fTexOffset.X, TexUpperPos);

-    glVertex2f(fBitmapCoords.Width, UpperPos);

-

-    // top left

-    glTexCoord2f(0, TexUpperPos);

-    glVertex2f(0, UpperPos);

-

-    // bottom left

-    glColor4f(Color.r, Color.g, Color.b, Color.a-0.3);

-    glTexCoord2f(0, TexLowerPos);

-    glVertex2f(0, fFont.Descender);

-

-    // bottom right

-    glTexCoord2f(fTexOffset.X, TexLowerPos);

-    glVertex2f(fBitmapCoords.Width, fFont.Descender);

-  glEnd();

-

-  glPopMatrix();

-

-  // restore old color

-  // Note: glPopAttrib(GL_CURRENT_BIT)/glPopAttrib() is much slower then

-  // glGetFloatv(GL_CURRENT_COLOR, ...)/glColor4fv(...)

-  glColor4fv(@Color.vals);

-end;

-

-function TFTGlyph.GetAdvance(): TPositionDbl;

-begin

-  Result := fAdvance;

-end;

-

-function TFTGlyph.GetBounds(): TBoundsDbl;

-begin

-  Result := fBounds;

-end;

-

-

-{*

- * TGlyphCache

- *}

-

-constructor TGlyphCache.Create();

-begin

-  inherited;

-  fHash := TList.Create();

-end;

-

-destructor TGlyphCache.Destroy();

-begin

-  // free cached glyphs

-  FlushCache(false);

-

-  // destroy TList

-  fHash.Free;

-  

-  inherited;

-end;

-

-function TGlyphCache.FindGlyphTable(BaseCode: cardinal; out InsertPos: integer): PGlyphTable;

-var

-  I: integer;

-  Entry: TGlyphCacheHashEntry;

-begin

-  Result := nil;

-

-  for I := 0 to fHash.Count-1 do

-  begin

-    Entry := TGlyphCacheHashEntry(fHash[I]);

-

-    if (Entry.BaseCode > BaseCode) then

-    begin

-      InsertPos := I;

-      Exit;

-    end;

-

-    if (Entry.BaseCode = BaseCode) then

-    begin

-      InsertPos := I;

-      Result := @Entry.GlyphTable;

-      Exit;

-    end;

-  end;

-

-  InsertPos := fHash.Count;

-end;

-

-function TGlyphCache.AddGlyph(ch: WideChar; const Glyph: TGlyph): boolean;

-var

-  BaseCode:  cardinal;

-  GlyphCode: integer;

-  InsertPos: integer;

-  GlyphTable: PGlyphTable;

-  Entry: TGlyphCacheHashEntry;

-begin

-  Result := false;

-

-  BaseCode := cardinal(ch) shr 8;

-  GlyphTable := FindGlyphTable(BaseCode, InsertPos);

-  if (GlyphTable = nil) then

-  begin

-    Entry := TGlyphCacheHashEntry.Create(BaseCode);

-    GlyphTable := @Entry.GlyphTable;

-    fHash.Insert(InsertPos, Entry);

-  end;

-

-  // get glyph table offset

-  GlyphCode := cardinal(ch) and $FF;

-  // insert glyph into table if not present

-  if (GlyphTable[GlyphCode] = nil) then

-  begin

-    GlyphTable[GlyphCode] := Glyph;

-    Result := true;

-  end;

-end;

-

-procedure TGlyphCache.DeleteGlyph(ch: WideChar);

-var

-  Table: PGlyphTable;

-  TableIndex, GlyphIndex: integer;

-  TableEmpty: boolean;

-begin

-  // find table

-  Table := FindGlyphTable(cardinal(ch) shr 8, TableIndex);

-  if (Table = nil) then

-    Exit;

-

-  // find glyph    

-  GlyphIndex := cardinal(ch) and $FF;

-  if (Table[GlyphIndex] <> nil) then

-  begin

-    // destroy glyph

-    FreeAndNil(Table[GlyphIndex]);

-

-    // check if table is empty

-    TableEmpty := true;

-    for GlyphIndex := 0 to High(Table^) do

-    begin

-      if (Table[GlyphIndex] <> nil) then

-      begin

-        TableEmpty := false;

-        Break;

-      end;

-    end;

-

-    // free empty table

-    if (TableEmpty) then

-    begin

-      fHash.Delete(TableIndex);

-    end;

-  end;

-end;

-

-function TGlyphCache.GetGlyph(ch: WideChar): TGlyph;

-var

-  InsertPos: integer;

-  Table: PGlyphTable;

-begin

-  Table := FindGlyphTable(cardinal(ch) shr 8, InsertPos);

-  if (Table = nil) then

-    Result := nil

-  else

-    Result := Table[cardinal(ch) and $FF];

-end;

-

-function TGlyphCache.HasGlyph(ch: WideChar): boolean;

-begin

-  Result := (GetGlyph(ch) <> nil);

-end;

-

-procedure TGlyphCache.FlushCache(KeepBaseSet: boolean);

-var

-  EntryIndex, TableIndex: integer;

-  Entry: TGlyphCacheHashEntry;

-begin

-  // destroy cached glyphs

-  for EntryIndex := 0 to fHash.Count-1 do

-  begin

-    Entry := TGlyphCacheHashEntry(fHash[EntryIndex]);

-

-    // the base set (0-255) has BaseCode 0 as the upper bytes are 0.

-    if KeepBaseSet and (Entry.fBaseCode = 0) then

-      Continue;

-

-    for TableIndex := 0 to High(Entry.GlyphTable) do

-    begin

-      if (Entry.GlyphTable[TableIndex] <> nil) then

-        FreeAndNil(Entry.GlyphTable[TableIndex]);

-    end;

-    FreeAndNil(Entry);

-  end;

-end;

-

-

-{*

- * TGlyphCacheEntry

- *}

-

-constructor TGlyphCacheHashEntry.Create(BaseCode: cardinal);

-begin

-  inherited Create();

-  fBaseCode := BaseCode;

-end;

-

-

-{*

- * TFreeType

- *}

-

-class function TFreeType.GetLibrary(): FT_Library;

-begin

-  if (LibraryInst = nil) then

-  begin

-    // initialize freetype

-    if (FT_Init_FreeType(LibraryInst) <> 0) then

-      raise Exception.Create('FT_Init_FreeType failed');

-  end;

-  Result := LibraryInst;

-end;

-

-class procedure TFreeType.FreeLibrary();

-begin

-  if (LibraryInst <> nil) then

-    FT_Done_FreeType(LibraryInst);

-  LibraryInst := nil;

-end;

-

-

-{$IFDEF BITMAP_FONT}

-{*

- * TBitmapFont

- *}

-

-constructor TBitmapFont.Create(const Filename: string; Outline: integer;

-    Baseline, Ascender, Descender: integer);

-begin

-  inherited Create();

-

-  fTex := Texture.LoadTexture(true, Filename, TEXTURE_TYPE_TRANSPARENT, 0);

-  fTexSize := 1024;

-  fOutline := Outline;

-  fBaseline  := Baseline;

-  fAscender  := Ascender;

-  fDescender := Descender;

-

-  LoadFontInfo(ChangeFileExt(Filename, '.dat'));

-

-  ResetIntern();

-end;

-

-destructor TBitmapFont.Destroy();

-begin

-  glDeleteTextures(1, @fTex.TexNum);

-  inherited;

-end;

-

-procedure TBitmapFont.ResetIntern();

-begin

-  fLineSpacing := Height;

-end;

-

-procedure TBitmapFont.Reset();

-begin

-  inherited;

-  ResetIntern();

-end;

-

-procedure TBitmapFont.CorrectWidths(WidthMult: real; WidthAdd: integer);

-var

-  Count: integer;

-begin

-  for Count := 0 to 255 do

-    fWidths[Count] := Round(fWidths[Count] * WidthMult) + WidthAdd;

-end;

-

-procedure TBitmapFont.LoadFontInfo(const InfoFile: string);

-var

-  Stream:  TFileStream;

-begin

-  FillChar(fWidths[0], Length(fWidths), 0);

-

-  Stream := nil;

-  try

-    Stream := TFileStream.Create(InfoFile, fmOpenRead);

-    Stream.Read(fWidths, 256);

-  except

-    raise Exception.Create('Could not read font info file ''' +  InfoFile + '''');

-  end;

-  Stream.Free;

-end;

-

-function TBitmapFont.BBox(const Text: TWideStringArray; Advance: boolean): TBoundsDbl;

-var

-  LineIndex, CharIndex: integer;

-  CharCode: cardinal;

-  Line: WideString;

-  LineWidth: double;

-begin

-  Result.Left := 0;

-  Result.Right := 0;

-  Result.Top := Height;

-  Result.Bottom := 0;

-

-  for LineIndex := 0 to High(Text) do

-  begin

-    Line := Text[LineIndex];

-    LineWidth := 0;

-    for CharIndex := 1 to Length(Line) do

-    begin

-      CharCode := Ord(Line[CharIndex]);

-      if (CharCode < Length(fWidths)) then

-        LineWidth := LineWidth + fWidths[CharCode];

-    end;

-    if (LineWidth > Result.Right) then

-      Result.Right := LineWidth;

-  end;

-end;

-

-procedure TBitmapFont.RenderChar(ch: WideChar; var AdvanceX: real);

-var

-  TexX, TexY:        real;

-  TexR, TexB:        real;

-  GlyphWidth:        real;

-  PL, PT:            real;

-  PR, PB:            real;

-  CharCode:          cardinal;

-begin

-  CharCode := Ord(ch);

-  if (CharCode > High(fWidths)) then

-    CharCode := 0;

-

-  GlyphWidth := fWidths[CharCode];

-

-  // set texture positions

-  TexX := (CharCode mod 16) * 1/16 + 1/32 - (GlyphWidth/2 - fOutline)/fTexSize;

-  TexY := (CharCode div 16) * 1/16 + {2 texels} 2/fTexSize;

-  TexR := (CharCode mod 16) * 1/16 + 1/32 + (GlyphWidth/2 + fOutline)/fTexSize;

-  TexB := (1 + CharCode div 16) * 1/16 - {2 texels} 2/fTexSize;

-

-  // set vector positions

-  PL := AdvanceX - fOutline;

-  PR := PL + GlyphWidth + fOutline*2;

-  PB := -fBaseline;

-  PT := PB + fTexSize div 16;

-

-  (*

-  if (Font.Blend) then

-  begin

-    glEnable(GL_BLEND);

-    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

-  end;

-  *)

-

-  glEnable(GL_TEXTURE_2D);

-  glBindTexture(GL_TEXTURE_2D, fTex.TexNum);

-  

-  if (not ReflectionPass) then

-  begin

-    glBegin(GL_QUADS);

-      glTexCoord2f(TexX, TexY); glVertex2f(PL, PT);

-      glTexCoord2f(TexX, TexB); glVertex2f(PL, PB);

-      glTexCoord2f(TexR, TexB); glVertex2f(PR, PB);

-      glTexCoord2f(TexR, TexY); glVertex2f(PR, PT);

-    glEnd;

-  end

-  else

-  begin

-    glDepthRange(0, 10);

-    glDepthFunc(GL_LEQUAL);

-    glEnable(GL_DEPTH_TEST);

-

-    glBegin(GL_QUADS);

-      glTexCoord2f(TexX, TexY); glVertex2f(PL, PT);

-      glTexCoord2f(TexX, TexB); glVertex2f(PL, PB);

-      glTexCoord2f(TexR, TexB); glVertex2f(PR, PB);

-      glTexCoord2f(TexR, TexY); glVertex2f(PR, PT);

-    glEnd;

-

-    glBegin(GL_QUADS);

-      glTexCoord2f(TexX, TexY); glVertex2f(PL, PT);

-      glTexCoord2f(TexX, TexB); glVertex2f(PL, PB);

-      glTexCoord2f(TexR, TexB); glVertex2f(PR, PB);

-      glTexCoord2f(TexR, TexY); glVertex2f(PR, PT);

-

-(*

-      glColor4f(fTempColor.r, fTempColor.g, fTempColor.b, 0.7);

-      glTexCoord2f(TexX, TexB); glVertex3f(PL, PB, 0);

-      glTexCoord2f(TexR, TexB); glVertex3f(PR, PB, 0);

-

-      glColor4f(fTempColor.r, fTempColor.g, fTempColor.b, 0);

-      glTexCoord2f(TexR, (TexY + TexB)/2); glVertex3f(PR, (PT + PB)/2, 0);

-      glTexCoord2f(TexX, (TexY + TexB)/2); glVertex3f(PL, (PT + PB)/2, 0);

-*)

-    glEnd;

-

-    //write the colour back

-    glColor4fv(@fTempColor);

-

-    glDisable(GL_DEPTH_TEST);

-  end; // reflection

-

-  glDisable(GL_TEXTURE_2D);

-  (*

-  if (Font.Blend) then

-    glDisable(GL_BLEND);

-  *)

-

-  AdvanceX := AdvanceX + GlyphWidth;

-end;

-

-procedure TBitmapFont.Render(const Text: WideString);

-var

-  CharIndex: integer;

-  AdvanceX: real;

-begin

-  // if there is no text do nothing

-  if (Text = '') then

-    Exit;

-

-  //Save the current color and alpha (for reflection)

-  glGetFloatv(GL_CURRENT_COLOR, @fTempColor);

-

-  AdvanceX := 0;

-  for CharIndex := 1 to Length(Text) do

-  begin

-    RenderChar(Text[CharIndex], AdvanceX);

-  end;

-end;

-

-function TBitmapFont.GetHeight(): single;

-begin

-  Result := fAscender - fDescender;

-end;

-

-function TBitmapFont.GetAscender(): single;

-begin

-  Result := fAscender;

-end;

-

-function TBitmapFont.GetDescender(): single;

-begin

-  Result := fDescender;

-end;

-

-function TBitmapFont.GetUnderlinePosition(): single;

-begin

-  Result := -2.0;

-end;

-

-function TBitmapFont.GetUnderlineThickness(): single;

-begin

-  Result := 1.0;

-end;

-

-{$ENDIF BITMAP_FONT}

-

-

-initialization

-

-finalization

-  TFreeType.FreeLibrary();

-

-end.

+  Glyph, PrevGlyph: TFTGlyph;
+  KernDelta: FT_Vector;
+begin
+  // reset last glyph
+  PrevGlyph := nil;
+
+  // draw current line
+  for CharIndex := 1 to Length(Text) do
+  begin
+    Glyph := TFTGlyph(GetGlyph(Text[CharIndex]));
+    if (Assigned(Glyph)) then
+    begin
+      // get kerning
+      if (fUseKerning and FT_HAS_KERNING(fFace) and (PrevGlyph <> nil)) then
+      begin
+        FT_Get_Kerning(fFace, PrevGlyph.CharIndex, Glyph.CharIndex,
+                       FT_KERNING_UNSCALED, KernDelta);
+        glTranslatef(KernDelta.x * fFontUnitScale.X, 0, 0);
+      end;
+
+      if (ReflectionPass) then
+        Glyph.RenderReflection()
+      else
+        Glyph.Render(fUseDisplayLists);
+
+      glTranslatef(Glyph.Advance.x + fGlyphSpacing, 0, 0);
+    end;
+
+    PrevGlyph := Glyph;
+  end;
+end;
+
+function TFTFont.GetHeight(): single;
+begin
+  Result := Ascender - Descender;
+end;
+
+function TFTFont.GetAscender(): single;
+begin
+  Result := fFace.ascender * fFontUnitScale.Y + Outset*2;
+end;
+
+function TFTFont.GetDescender(): single;
+begin
+  // Note: outset is not part of the descender as the baseline is lifted
+  Result := fFace.descender * fFontUnitScale.Y;
+end;
+
+function TFTFont.GetUnderlinePosition(): single;
+begin
+  Result := fFace.underline_position * fFontUnitScale.Y - Outset;
+end;
+
+function TFTFont.GetUnderlineThickness(): single;
+begin
+  Result := fFace.underline_thickness * fFontUnitScale.Y + Outset*2;
+end;
+
+
+{*
+ * TFTScalableFont
+ *}
+
+constructor TFTScalableFont.Create(const Filename: string;
+                   Size: integer; OutsetAmount: single;
+                   UseMipmaps: boolean);
+var
+  LoadFlags: FT_Int32;
+begin
+  LoadFlags := FT_LOAD_DEFAULT;
+  // Disable hinting and grid-fitting to preserve font outlines at each font
+  // size, otherwise the font widths/heights do not match resulting in ugly
+  // text size changes during zooming.
+  // A drawback is a reduced quality with smaller font sizes but it is not that
+  // bad with gray-scaled rendering (at least it looks better than OpenGL's
+  // linear downscaling on minification).
+  if (UseMipmaps) then
+    LoadFlags := LoadFlags or FT_LOAD_NO_HINTING;
+  inherited Create(
+      TFTFont.Create(Filename, Size, Size * OutsetAmount, LoadFlags),
+      UseMipmaps);
+end;
+
+function TFTScalableFont.CreateMipmap(Level: integer; Scale: single): TFont;
+var
+  ScaledSize: integer;
+  BaseFont: TFTFont;
+begin
+  Result := nil;
+  BaseFont := TFTFont(fBaseFont);
+  ScaledSize := Round(BaseFont.Size * Scale);
+  // do not create mipmap fonts < 8 pixels
+  if (ScaledSize < 8) then
+    Exit;
+  Result := TFTFont.Create(BaseFont.fFilename,
+      ScaledSize, BaseFont.fOutset * Scale,
+      FT_LOAD_DEFAULT or FT_LOAD_NO_HINTING);
+end;
+
+function TFTScalableFont.GetOutset(): single;
+begin
+  Result := TFTFont(fBaseFont).Outset * fScale;
+end;
+
+procedure TFTScalableFont.FlushCache(KeepBaseSet: boolean);
+var
+  Level: integer;
+begin
+  for Level := 0 to High(fMipmapFonts) do
+    if (fMipmapFonts[Level] <> nil) then
+      TFTFont(fMipmapFonts[Level]).FlushCache(KeepBaseSet);
+end;
+
+
+{*
+ * TOutlineFont
+ *}
+
+constructor TFTOutlineFont.Create(
+    const Filename: string;
+    Size: integer; Outset: single;
+    LoadFlags: FT_Int32);
+begin
+  inherited Create();
+
+  fFilename := Filename;
+  fSize := Size;
+  fOutset := Outset;
+
+  fInnerFont := TFTFont.Create(Filename, Size, 0.0, LoadFlags);
+  fOutlineFont := TFTFont.Create(Filename, Size, Outset, LoadFlags);
+
+  ResetIntern();
+end;
+
+destructor TFTOutlineFont.Destroy;
+begin
+  fOutlineFont.Free;
+  fInnerFont.Free;
+  inherited;
+end;
+
+procedure TFTOutlineFont.ResetIntern();
+begin
+  // TODO: maybe swap fInnerFont/fOutlineFont.GlyphSpacing to use the spacing
+  // of the outline font?
+  //fInnerFont.GlyphSpacing := fOutset*2;
+  fOutlineFont.GlyphSpacing := -fOutset*2;
+
+  fLineSpacing := fOutlineFont.LineSpacing;
+  fReflectionSpacing := fOutlineFont.ReflectionSpacing;
+  fOutlineColor := NewGLColor(0, 0, 0, -1);
+end;
+
+procedure TFTOutlineFont.Reset();
+begin
+  inherited;
+  fInnerFont.Reset();
+  fOutlineFont.Reset();
+  ResetIntern();
+end;
+
+procedure TFTOutlineFont.DrawUnderline(const Text: WideString);
+var
+  CurrentColor: TGLColor;
+  OutlineColor: TGLColor;
+begin
+  // save current color
+  glGetFloatv(GL_CURRENT_COLOR, @CurrentColor.vals);
+
+  // if the outline's alpha component is < 0 use the current alpha
+  OutlineColor := fOutlineColor;
+  if (OutlineColor.a < 0) then
+    OutlineColor.a := CurrentColor.a;
+
+  // draw underline outline (in outline color)
+  glColor4fv(@OutlineColor.vals);
+  fOutlineFont.DrawUnderline(Text);
+  glColor4fv(@CurrentColor.vals);
+
+  // draw underline inner part (in current color)
+  glPushMatrix();
+  glTranslatef(fOutset, 0, 0);
+  fInnerFont.DrawUnderline(Text);
+  glPopMatrix();
+end;
+
+procedure TFTOutlineFont.Render(const Text: WideString);
+var
+  CurrentColor: TGLColor;
+  OutlineColor: TGLColor;
+begin
+  // save current color
+  glGetFloatv(GL_CURRENT_COLOR, @CurrentColor.vals);
+
+  // if the outline's alpha component is < 0 use the current alpha
+  OutlineColor := fOutlineColor;
+  if (OutlineColor.a < 0) then
+    OutlineColor.a := CurrentColor.a;
+
+  { setup and render outline font }
+
+  glColor4fv(@OutlineColor.vals);
+  glPushMatrix();
+  fOutlineFont.Render(Text);
+  glPopMatrix();
+  glColor4fv(@CurrentColor.vals);
+
+  { setup and render inner font }
+
+  glPushMatrix();
+  glTranslatef(fOutset, fOutset, 0);
+  fInnerFont.Render(Text);
+  glPopMatrix();
+end;
+
+procedure TFTOutlineFont.SetOutlineColor(r, g, b: GLfloat; a: GLfloat);
+begin
+  fOutlineColor := NewGLColor(r, g, b, a);
+end;
+
+procedure TFTOutlineFont.FlushCache(KeepBaseSet: boolean);
+begin
+  fOutlineFont.FlushCache(KeepBaseSet);
+  fInnerFont.FlushCache(KeepBaseSet);
+end;
+
+function TFTOutlineFont.BBox(const Text: TWideStringArray; Advance: boolean): TBoundsDbl;
+begin
+  Result := fOutlineFont.BBox(Text, Advance);
+end;
+
+function TFTOutlineFont.GetHeight(): single;
+begin
+  Result := fOutlineFont.Height;
+end;
+
+function TFTOutlineFont.GetAscender(): single;
+begin
+  Result := fOutlineFont.Ascender;
+end;
+
+function TFTOutlineFont.GetDescender(): single;
+begin
+  Result := fOutlineFont.Descender;
+end;
+
+procedure TFTOutlineFont.SetLineSpacing(Spacing: single);
+begin
+  inherited SetLineSpacing(Spacing);
+  fInnerFont.LineSpacing := Spacing;
+  fOutlineFont.LineSpacing := Spacing;
+end;
+
+procedure TFTOutlineFont.SetGlyphSpacing(Spacing: single);
+begin
+  inherited SetGlyphSpacing(Spacing);
+  fInnerFont.GlyphSpacing := Spacing;
+  fOutlineFont.GlyphSpacing := Spacing - Outset*2;
+end;
+
+procedure TFTOutlineFont.SetReflectionSpacing(Spacing: single);
+begin
+  inherited SetReflectionSpacing(Spacing);
+  fInnerFont.ReflectionSpacing := Spacing;
+  fOutlineFont.ReflectionSpacing := Spacing;
+end;
+
+procedure TFTOutlineFont.SetStyle(Style: TFontStyle);
+begin
+  inherited SetStyle(Style);
+  fInnerFont.Style := Style;
+  fOutlineFont.Style := Style;
+end;
+
+function TFTOutlineFont.GetStyle(): TFontStyle;
+begin
+  Result := inherited GetStyle();
+end;
+
+function TFTOutlineFont.GetUnderlinePosition(): single;
+begin
+  Result := fOutlineFont.GetUnderlinePosition();
+end;
+
+function TFTOutlineFont.GetUnderlineThickness(): single;
+begin
+  Result := fOutlineFont.GetUnderlinePosition();
+end;
+
+procedure TFTOutlineFont.SetUseKerning(Enable: boolean);
+begin
+  inherited SetUseKerning(Enable);
+  fInnerFont.fUseKerning := Enable;
+  fOutlineFont.fUseKerning := Enable;
+end;
+
+procedure TFTOutlineFont.SetReflectionPass(Enable: boolean);
+begin
+  inherited SetReflectionPass(Enable);
+  fInnerFont.fReflectionPass := Enable;
+  fOutlineFont.fReflectionPass := Enable;
+end;
+
+{**
+ * TScalableOutlineFont
+ *}
+
+constructor TFTScalableOutlineFont.Create(
+    const Filename: string;
+    Size: integer; OutsetAmount: single;
+    UseMipmaps: boolean);
+var
+  LoadFlags: FT_Int32;
+begin
+  LoadFlags := FT_LOAD_DEFAULT;
+  // Disable hinting and grid-fitting (see TFTScalableFont.Create)
+  if (UseMipmaps) then
+    LoadFlags := LoadFlags or FT_LOAD_NO_HINTING;
+  inherited Create(
+      TFTOutlineFont.Create(Filename, Size, Size*OutsetAmount, LoadFlags),
+      UseMipmaps);
+end;
+
+function TFTScalableOutlineFont.CreateMipmap(Level: integer; Scale: single): TFont;
+var
+  ScaledSize: integer;
+  BaseFont: TFTOutlineFont;
+begin
+  Result := nil;
+  BaseFont := TFTOutlineFont(fBaseFont);
+  ScaledSize := Round(BaseFont.Size*Scale);
+  // do not create mipmap fonts < 8 pixels
+  if (ScaledSize < 8) then
+    Exit;
+  Result := TFTOutlineFont.Create(BaseFont.fFilename,
+      ScaledSize, BaseFont.fOutset*Scale,
+      FT_LOAD_DEFAULT or FT_LOAD_NO_HINTING);
+end;
+
+function TFTScalableOutlineFont.GetOutset(): single;
+begin
+  Result := TFTOutlineFont(fBaseFont).Outset * fScale;
+end;
+
+procedure TFTScalableOutlineFont.SetOutlineColor(r, g, b: GLfloat; a: GLfloat);
+var
+  Level: integer;
+begin
+  for Level := 0 to High(fMipmapFonts) do
+    if (fMipmapFonts[Level] <> nil) then
+      TFTOutlineFont(fMipmapFonts[Level]).SetOutlineColor(r, g, b, a);
+end;
+
+procedure TFTScalableOutlineFont.FlushCache(KeepBaseSet: boolean);
+var
+  Level: integer;
+begin
+  for Level := 0 to High(fMipmapFonts) do
+    if (fMipmapFonts[Level] <> nil) then
+      TFTOutlineFont(fMipmapFonts[Level]).FlushCache(KeepBaseSet);
+end;
+
+
+{*
+ * TFTGlyph
+ *}
+
+const
+  {**
+   * Size of the transparent border surrounding the glyph image in the texture.
+   * The border is necessary because OpenGL does not smooth texels at the
+   * border of a texture with the GL_CLAMP or GL_CLAMP_TO_EDGE styles.
+   * Without the border, magnified glyph textures look very ugly at their edges.
+   * It looks edgy, as if some pixels are missing especially on the left edge
+   * (just set cTexSmoothBorder to 0 to see what is meant by this).
+   * With the border even the glyphs edges are blended to the border (transparent)
+   * color and everything looks nice.
+   *
+   * Note:
+   * OpenGL already supports texture border by setting the border parameter
+   * of glTexImage*D() to 1 and using a texture size of 2^m+2b and setting the
+   * border pixels to the border color. In some forums it is discouraged to use
+   * the border parameter as only a few of the more modern graphics cards support
+   * this feature. On an ATI Radeon 9700 card, the slowed down to 0.5 fps and
+   * the glyph's background got black.  So instead of using this feature we
+   * handle it on our own. The only drawback is that textures might get bigger
+   * because the border might require a higher power of 2 size instead of just
+   * two additional pixels.
+   *}
+  cTexSmoothBorder = 1;
+
+procedure TFTGlyph.Extrude(var TexBuffer: TGLubyteDynArray; Outset: single);
+
+  procedure SetToMax(var Val1: GLubyte; Val2: GLubyte); {$IFDEF HasInline}inline;{$ENDIF}
+  begin
+    if (Val1 < Val2) then
+      Val1 := Val2;
+  end;
+
+var
+  I, X, Y: integer;
+  SrcBuffer,TmpBuffer: TGLubyteDynArray;
+  TexLine, TexLinePrev, TexLineNext: PGLubyteArray;
+  SrcLine: PGLubyteArray;
+  AlphaScale: single;
+  Value, ValueNeigh, ValueDiag: GLubyte;
+const
+  // square-root of 2 used for diagonal neighbor pixels
+  cSqrt2 = 1.4142;
+  // number of ignored pixels on each edge of the bitmap. Consists of:
+  // - border used for font smoothing and
+  // - outer (extruded) bitmap pixel (because it is just written but never read)
+  cBorder = cTexSmoothBorder + 1;
+begin
+  // allocate memory for temporary buffer
+  SetLength(SrcBuffer, Length(TexBuffer));
+  FillChar(SrcBuffer[0], Length(TexBuffer), 0);
+
+  // extrude pixel by pixel
+  for I := 1 to Ceil(Outset) do
+  begin
+    // swap arrays
+    TmpBuffer := TexBuffer;
+    TexBuffer := SrcBuffer;
+    SrcBuffer := TmpBuffer;
+
+    // as long as we add an entire pixel of outset, use a solid color.
+    // If the fractional part is reached blend, e.g. outline=3.2 -> 3 solid
+    // pixels and one blended with alpha=0.2.
+    // For the fractional part I = Ceil(Outset) is always true.
+    if (I <= Outset) then
+      AlphaScale := 1
+    else
+      AlphaScale := Outset - Trunc(Outset);
+
+    // copy data to the expanded bitmap.
+    for Y := cBorder to fTexSize.Height - 2*cBorder do
+    begin
+      TexLine     := @TexBuffer[Y*fTexSize.Width];
+      TexLinePrev := @TexBuffer[(Y-1)*fTexSize.Width];
+      TexLineNext := @TexBuffer[(Y+1)*fTexSize.Width];
+      SrcLine     := @SrcBuffer[Y*fTexSize.Width];
+
+      // expand current line's pixels
+      for X := cBorder to fTexSize.Width - 2*cBorder do
+      begin
+        Value := SrcLine[X];
+        ValueNeigh := Round(Value * AlphaScale);
+        ValueDiag := Round(ValueNeigh / cSqrt2);
+
+        SetToMax(TexLine[X],   Value);
+        SetToMax(TexLine[X-1], ValueNeigh);
+        SetToMax(TexLine[X+1], ValueNeigh);
+
+        SetToMax(TexLinePrev[X],   ValueNeigh);
+        SetToMax(TexLinePrev[X-1], ValueDiag);
+        SetToMax(TexLinePrev[X+1], ValueDiag);
+
+        SetToMax(TexLineNext[X],   ValueNeigh);
+        SetToMax(TexLineNext[X-1], ValueDiag);
+        SetToMax(TexLineNext[X+1], ValueDiag);
+      end;
+    end;
+  end;
+
+  TmpBuffer := nil;
+  SetLength(SrcBuffer, 0);
+end;
+
+procedure TFTGlyph.CreateTexture(LoadFlags: FT_Int32);
+var
+  X, Y:          integer;
+  Glyph:         FT_Glyph;
+  BitmapGlyph:   FT_BitmapGlyph;
+  Bitmap:        PFT_Bitmap;
+  BitmapLine:    PChar;
+  BitmapBuffer:  PChar;
+  TexBuffer:     TGLubyteDynArray;
+  TexLine:       PGLubyteArray;
+  CBox:          FT_BBox;
+begin
+  // load the Glyph for our character
+  if (FT_Load_Glyph(fFont.Face, fCharIndex, LoadFlags) <> 0) then
+    raise Exception.Create('FT_Load_Glyph failed');
+
+  // move the face's glyph into a Glyph object
+  if (FT_Get_Glyph(fFont.Face^.glyph, Glyph) <> 0) then
+    raise Exception.Create('FT_Get_Glyph failed');
+
+  // store scaled advance width/height in glyph-object
+  fAdvance.X := fFont.Face^.glyph^.advance.x / 64 + fOutset*2;
+  fAdvance.Y := fFont.Face^.glyph^.advance.y / 64 + fOutset*2;
+
+  // get the contour's bounding box (in 1/64th pixels, not font-units)
+  FT_Glyph_Get_CBox(Glyph, FT_GLYPH_BBOX_UNSCALED, CBox);
+  // convert 1/64th values to double values
+  fBounds.Left   := CBox.xMin / 64;
+  fBounds.Right  := CBox.xMax / 64 + fOutset*2;
+  fBounds.Bottom := CBox.yMin / 64;
+  fBounds.Top    := CBox.yMax / 64 + fOutset*2;
+
+  // convert the glyph to a bitmap (and destroy original glyph image)
+  FT_Glyph_To_Bitmap(Glyph, ft_render_mode_normal, nil, 1);
+  BitmapGlyph := FT_BitmapGlyph(Glyph);
+
+  // get bitmap offsets
+  fBitmapCoords.Left := BitmapGlyph^.left - cTexSmoothBorder;
+  // Note: add 1*fOutset for lifting the baseline so outset fonts to not intersect
+  // with the baseline; Ceil(fOutset) for the outset pixels added to the bitmap.
+  fBitmapCoords.Top  := BitmapGlyph^.top + fOutset+Ceil(fOutset) + cTexSmoothBorder;
+
+  // make accessing the bitmap easier
+  Bitmap := @BitmapGlyph^.bitmap;
+  // get bitmap dimensions
+  fBitmapCoords.Width  := Bitmap.width + (Ceil(fOutset) + cTexSmoothBorder)*2;
+  fBitmapCoords.Height := Bitmap.rows + (Ceil(fOutset) + cTexSmoothBorder)*2;
+
+  // get power-of-2 bitmap widths
+  fTexSize.Width  :=
+      NextPowerOf2(Bitmap.width + (Ceil(fOutset) + cTexSmoothBorder)*2);
+  fTexSize.Height :=
+      NextPowerOf2(Bitmap.rows + (Ceil(fOutset) + cTexSmoothBorder)*2);
+
+  // texture-widths ignoring empty (power-of-2) padding space
+  fTexOffset.X := fBitmapCoords.Width / fTexSize.Width;
+  fTexOffset.Y := fBitmapCoords.Height / fTexSize.Height;
+
+  // allocate memory for texture data
+  SetLength(TexBuffer, fTexSize.Width * fTexSize.Height);
+  FillChar(TexBuffer[0], Length(TexBuffer), 0);
+
+  // Freetype stores the bitmap with either upper (pitch is > 0) or lower
+  // (pitch < 0) glyphs line first. Set the buffer to the upper line.
+  // See http://freetype.sourceforge.net/freetype2/docs/glyphs/glyphs-7.html
+  if (Bitmap.pitch > 0) then
+    BitmapBuffer := @Bitmap.buffer[0]
+  else
+    BitmapBuffer := @Bitmap.buffer[(Bitmap.rows-1) * Abs(Bitmap.pitch)];
+
+  // copy data to texture bitmap (upper line first).
+  for Y := 0 to Bitmap.rows-1 do
+  begin
+    // set pointer to first pixel in line that holds bitmap data.
+    // Each line starts with a cTexSmoothBorder pixel and multiple outset pixels
+    // that are added by Extrude() later.
+    TexLine := @TexBuffer[(Y + cTexSmoothBorder + Ceil(fOutset)) * fTexSize.Width +
+                          cTexSmoothBorder + Ceil(fOutset)];
+    // get next lower line offset, use pitch instead of width as it tells
+    // us the storage direction of the lines. In addition a line might be padded.
+    BitmapLine := @BitmapBuffer[Y * Bitmap.pitch];
+    for X := 0 to Bitmap.width-1 do
+      TexLine[X] := GLubyte(BitmapLine[X]);
+  end;
+
+  if (fOutset > 0) then
+    Extrude(TexBuffer, fOutset);
+
+  // allocate resources for textures and display lists
+  glGenTextures(1, @fTexture);
+
+  // setup texture parameters
+  glBindTexture(GL_TEXTURE_2D, fTexture);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+
+  glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+  // create alpha-map (GL_ALPHA component only).
+  // TexCoord (0,0) corresponds to the top left pixel of the glyph,
+  // (1,1) to the bottom right pixel. So the glyph is flipped as OpenGL uses
+  // a cartesian (y-axis up) coordinate system for textures.   
+  // See the cTexSmoothBorder comment for info on texture borders.
+  glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, fTexSize.Width, fTexSize.Height,
+      0, GL_ALPHA, GL_UNSIGNED_BYTE, @TexBuffer[0]);
+
+  // free expanded data
+  SetLength(TexBuffer, 0);
+
+  // create the display list
+  fDisplayList := glGenLists(1);
+
+  // render to display-list
+  glNewList(fDisplayList, GL_COMPILE);
+    Render(false);
+  glEndList();
+
+  // free glyph data (bitmap, etc.)
+  FT_Done_Glyph(Glyph);
+end;
+
+constructor TFTGlyph.Create(Font: TFTFont; ch: WideChar; Outset: single;
+    LoadFlags: FT_Int32);
+begin
+  inherited Create();
+
+  fFont := Font;
+  fOutset := Outset;
+
+  // get the Freetype char-index (use default UNICODE charmap)
+  fCharIndex := FT_Get_Char_Index(Font.fFace, FT_ULONG(ch));
+
+  CreateTexture(LoadFlags);
+end;
+
+destructor TFTGlyph.Destroy;
+begin
+  if (fDisplayList <> 0) then
+    glDeleteLists(fDisplayList, 1);
+  if (fTexture <> 0) then
+    glDeleteTextures(1, @fTexture);
+  inherited;
+end;
+
+procedure TFTGlyph.Render(UseDisplayLists: boolean);
+begin
+  // use display-lists if enabled and exit
+  if (UseDisplayLists) then
+  begin
+    glCallList(fDisplayList);
+    Exit;
+  end;
+
+  glBindTexture(GL_TEXTURE_2D, fTexture);
+  glPushMatrix();
+
+  // move to top left glyph position
+  glTranslatef(fBitmapCoords.Left, fBitmapCoords.Top, 0);
+
+  // draw glyph texture
+  glBegin(GL_QUADS);
+    // top right
+    glTexCoord2f(fTexOffset.X, 0);
+    glVertex2f(fBitmapCoords.Width, 0);
+
+    // top left
+    glTexCoord2f(0, 0);
+    glVertex2f(0, 0);
+
+    // bottom left
+    glTexCoord2f(0, fTexOffset.Y);
+    glVertex2f(0, -fBitmapCoords.Height);
+
+    // bottom right
+    glTexCoord2f(fTexOffset.X, fTexOffset.Y);
+    glVertex2f(fBitmapCoords.Width, -fBitmapCoords.Height);
+  glEnd();
+
+  glPopMatrix();
+end;
+
+procedure TFTGlyph.RenderReflection();
+var
+  Color: TGLColor;
+  TexUpperPos: single;
+  TexLowerPos: single;
+  UpperPos: single;
+const
+  CutOff = 0.6;
+begin
+  glPushMatrix();
+  glBindTexture(GL_TEXTURE_2D, fTexture);
+  glGetFloatv(GL_CURRENT_COLOR, @Color.vals);
+
+  // add extra space to the left of the glyph
+  glTranslatef(fBitmapCoords.Left, 0, 0);
+
+  // The upper position of the glyph, if CutOff is 1.0, it is fFont.Ascender.
+  // If CutOff is set to 0.5 only half of the glyph height is displayed.
+  UpperPos := fFont.Descender + fFont.Height * CutOff;
+
+  // the glyph texture's height is just the height of the glyph but not the font
+  // height. Setting a color for the upper and lower bounds of the glyph results
+  // in different color gradients. So we have to set the color values for the
+  // descender and ascender (as we have a cutoff, for the upper-pos here) as
+  // these positions are font but not glyph specific.
+
+  // To get the texture positions we have to enhance the texture at the top and
+  // bottom by the amount from the top to ascender (rather upper-pos here) and
+  // from the bottom (Height-Top) to descender. Then we have to convert those
+  // heights to texture coordinates by dividing by the bitmap Height and
+  // removing the power-of-2 padding space by multiplying with fTexOffset.Y
+  // (as fBitmapCoords.Height corresponds to fTexOffset.Y and not 1.0).
+  TexUpperPos  := -(UpperPos - fBitmapCoords.Top) / fBitmapCoords.Height * fTexOffset.Y;
+  TexLowerPos := (-(fFont.Descender + fBitmapCoords.Height - fBitmapCoords.Top) /
+                    fBitmapCoords.Height + 1) * fTexOffset.Y;
+
+  // draw glyph texture
+  glBegin(GL_QUADS);
+    // top right
+    glColor4f(Color.r, Color.g, Color.b, 0);
+    glTexCoord2f(fTexOffset.X, TexUpperPos);
+    glVertex2f(fBitmapCoords.Width, UpperPos);
+
+    // top left
+    glTexCoord2f(0, TexUpperPos);
+    glVertex2f(0, UpperPos);
+
+    // bottom left
+    glColor4f(Color.r, Color.g, Color.b, Color.a-0.3);
+    glTexCoord2f(0, TexLowerPos);
+    glVertex2f(0, fFont.Descender);
+
+    // bottom right
+    glTexCoord2f(fTexOffset.X, TexLowerPos);
+    glVertex2f(fBitmapCoords.Width, fFont.Descender);
+  glEnd();
+
+  glPopMatrix();
+
+  // restore old color
+  // Note: glPopAttrib(GL_CURRENT_BIT)/glPopAttrib() is much slower then
+  // glGetFloatv(GL_CURRENT_COLOR, ...)/glColor4fv(...)
+  glColor4fv(@Color.vals);
+end;
+
+function TFTGlyph.GetAdvance(): TPositionDbl;
+begin
+  Result := fAdvance;
+end;
+
+function TFTGlyph.GetBounds(): TBoundsDbl;
+begin
+  Result := fBounds;
+end;
+
+
+{*
+ * TGlyphCache
+ *}
+
+constructor TGlyphCache.Create();
+begin
+  inherited;
+  fHash := TList.Create();
+end;
+
+destructor TGlyphCache.Destroy();
+begin
+  // free cached glyphs
+  FlushCache(false);
+
+  // destroy TList
+  fHash.Free;
+  
+  inherited;
+end;
+
+function TGlyphCache.FindGlyphTable(BaseCode: cardinal; out InsertPos: integer): PGlyphTable;
+var
+  I: integer;
+  Entry: TGlyphCacheHashEntry;
+begin
+  Result := nil;
+
+  for I := 0 to fHash.Count-1 do
+  begin
+    Entry := TGlyphCacheHashEntry(fHash[I]);
+
+    if (Entry.BaseCode > BaseCode) then
+    begin
+      InsertPos := I;
+      Exit;
+    end;
+
+    if (Entry.BaseCode = BaseCode) then
+    begin
+      InsertPos := I;
+      Result := @Entry.GlyphTable;
+      Exit;
+    end;
+  end;
+
+  InsertPos := fHash.Count;
+end;
+
+function TGlyphCache.AddGlyph(ch: WideChar; const Glyph: TGlyph): boolean;
+var
+  BaseCode:  cardinal;
+  GlyphCode: integer;
+  InsertPos: integer;
+  GlyphTable: PGlyphTable;
+  Entry: TGlyphCacheHashEntry;
+begin
+  Result := false;
+
+  BaseCode := cardinal(ch) shr 8;
+  GlyphTable := FindGlyphTable(BaseCode, InsertPos);
+  if (GlyphTable = nil) then
+  begin
+    Entry := TGlyphCacheHashEntry.Create(BaseCode);
+    GlyphTable := @Entry.GlyphTable;
+    fHash.Insert(InsertPos, Entry);
+  end;
+
+  // get glyph table offset
+  GlyphCode := cardinal(ch) and $FF;
+  // insert glyph into table if not present
+  if (GlyphTable[GlyphCode] = nil) then
+  begin
+    GlyphTable[GlyphCode] := Glyph;
+    Result := true;
+  end;
+end;
+
+procedure TGlyphCache.DeleteGlyph(ch: WideChar);
+var
+  Table: PGlyphTable;
+  TableIndex, GlyphIndex: integer;
+  TableEmpty: boolean;
+begin
+  // find table
+  Table := FindGlyphTable(cardinal(ch) shr 8, TableIndex);
+  if (Table = nil) then
+    Exit;
+
+  // find glyph    
+  GlyphIndex := cardinal(ch) and $FF;
+  if (Table[GlyphIndex] <> nil) then
+  begin
+    // destroy glyph
+    FreeAndNil(Table[GlyphIndex]);
+
+    // check if table is empty
+    TableEmpty := true;
+    for GlyphIndex := 0 to High(Table^) do
+    begin
+      if (Table[GlyphIndex] <> nil) then
+      begin
+        TableEmpty := false;
+        Break;
+      end;
+    end;
+
+    // free empty table
+    if (TableEmpty) then
+    begin
+      fHash.Delete(TableIndex);
+    end;
+  end;
+end;
+
+function TGlyphCache.GetGlyph(ch: WideChar): TGlyph;
+var
+  InsertPos: integer;
+  Table: PGlyphTable;
+begin
+  Table := FindGlyphTable(cardinal(ch) shr 8, InsertPos);
+  if (Table = nil) then
+    Result := nil
+  else
+    Result := Table[cardinal(ch) and $FF];
+end;
+
+function TGlyphCache.HasGlyph(ch: WideChar): boolean;
+begin
+  Result := (GetGlyph(ch) <> nil);
+end;
+
+procedure TGlyphCache.FlushCache(KeepBaseSet: boolean);
+var
+  EntryIndex, TableIndex: integer;
+  Entry: TGlyphCacheHashEntry;
+begin
+  // destroy cached glyphs
+  for EntryIndex := 0 to fHash.Count-1 do
+  begin
+    Entry := TGlyphCacheHashEntry(fHash[EntryIndex]);
+
+    // the base set (0-255) has BaseCode 0 as the upper bytes are 0.
+    if KeepBaseSet and (Entry.fBaseCode = 0) then
+      Continue;
+
+    for TableIndex := 0 to High(Entry.GlyphTable) do
+    begin
+      if (Entry.GlyphTable[TableIndex] <> nil) then
+        FreeAndNil(Entry.GlyphTable[TableIndex]);
+    end;
+    FreeAndNil(Entry);
+  end;
+end;
+
+
+{*
+ * TGlyphCacheEntry
+ *}
+
+constructor TGlyphCacheHashEntry.Create(BaseCode: cardinal);
+begin
+  inherited Create();
+  fBaseCode := BaseCode;
+end;
+
+
+{*
+ * TFreeType
+ *}
+
+class function TFreeType.GetLibrary(): FT_Library;
+begin
+  if (LibraryInst = nil) then
+  begin
+    // initialize freetype
+    if (FT_Init_FreeType(LibraryInst) <> 0) then
+      raise Exception.Create('FT_Init_FreeType failed');
+  end;
+  Result := LibraryInst;
+end;
+
+class procedure TFreeType.FreeLibrary();
+begin
+  if (LibraryInst <> nil) then
+    FT_Done_FreeType(LibraryInst);
+  LibraryInst := nil;
+end;
+
+
+{$IFDEF BITMAP_FONT}
+{*
+ * TBitmapFont
+ *}
+
+constructor TBitmapFont.Create(const Filename: string; Outline: integer;
+    Baseline, Ascender, Descender: integer);
+begin
+  inherited Create();
+
+  fTex := Texture.LoadTexture(true, Filename, TEXTURE_TYPE_TRANSPARENT, 0);
+  fTexSize := 1024;
+  fOutline := Outline;
+  fBaseline  := Baseline;
+  fAscender  := Ascender;
+  fDescender := Descender;
+
+  LoadFontInfo(ChangeFileExt(Filename, '.dat'));
+
+  ResetIntern();
+end;
+
+destructor TBitmapFont.Destroy();
+begin
+  glDeleteTextures(1, @fTex.TexNum);
+  inherited;
+end;
+
+procedure TBitmapFont.ResetIntern();
+begin
+  fLineSpacing := Height;
+end;
+
+procedure TBitmapFont.Reset();
+begin
+  inherited;
+  ResetIntern();
+end;
+
+procedure TBitmapFont.CorrectWidths(WidthMult: real; WidthAdd: integer);
+var
+  Count: integer;
+begin
+  for Count := 0 to 255 do
+    fWidths[Count] := Round(fWidths[Count] * WidthMult) + WidthAdd;
+end;
+
+procedure TBitmapFont.LoadFontInfo(const InfoFile: string);
+var
+  Stream:  TFileStream;
+begin
+  FillChar(fWidths[0], Length(fWidths), 0);
+
+  Stream := nil;
+  try
+    Stream := TFileStream.Create(InfoFile, fmOpenRead);
+    Stream.Read(fWidths, 256);
+  except
+    raise Exception.Create('Could not read font info file ''' +  InfoFile + '''');
+  end;
+  Stream.Free;
+end;
+
+function TBitmapFont.BBox(const Text: TWideStringArray; Advance: boolean): TBoundsDbl;
+var
+  LineIndex, CharIndex: integer;
+  CharCode: cardinal;
+  Line: WideString;
+  LineWidth: double;
+begin
+  Result.Left := 0;
+  Result.Right := 0;
+  Result.Top := Height;
+  Result.Bottom := 0;
+
+  for LineIndex := 0 to High(Text) do
+  begin
+    Line := Text[LineIndex];
+    LineWidth := 0;
+    for CharIndex := 1 to Length(Line) do
+    begin
+      CharCode := Ord(Line[CharIndex]);
+      if (CharCode < Length(fWidths)) then
+        LineWidth := LineWidth + fWidths[CharCode];
+    end;
+    if (LineWidth > Result.Right) then
+      Result.Right := LineWidth;
+  end;
+end;
+
+procedure TBitmapFont.RenderChar(ch: WideChar; var AdvanceX: real);
+var
+  TexX, TexY:        real;
+  TexR, TexB:        real;
+  GlyphWidth:        real;
+  PL, PT:            real;
+  PR, PB:            real;
+  CharCode:          cardinal;
+begin
+  CharCode := Ord(ch);
+  if (CharCode > High(fWidths)) then
+    CharCode := 0;
+
+  GlyphWidth := fWidths[CharCode];
+
+  // set texture positions
+  TexX := (CharCode mod 16) * 1/16 + 1/32 - (GlyphWidth/2 - fOutline)/fTexSize;
+  TexY := (CharCode div 16) * 1/16 + {2 texels} 2/fTexSize;
+  TexR := (CharCode mod 16) * 1/16 + 1/32 + (GlyphWidth/2 + fOutline)/fTexSize;
+  TexB := (1 + CharCode div 16) * 1/16 - {2 texels} 2/fTexSize;
+
+  // set vector positions
+  PL := AdvanceX - fOutline;
+  PR := PL + GlyphWidth + fOutline*2;
+  PB := -fBaseline;
+  PT := PB + fTexSize div 16;
+
+  (*
+  if (Font.Blend) then
+  begin
+    glEnable(GL_BLEND);
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+  end;
+  *)
+
+  glEnable(GL_TEXTURE_2D);
+  glBindTexture(GL_TEXTURE_2D, fTex.TexNum);
+  
+  if (not ReflectionPass) then
+  begin
+    glBegin(GL_QUADS);
+      glTexCoord2f(TexX, TexY); glVertex2f(PL, PT);
+      glTexCoord2f(TexX, TexB); glVertex2f(PL, PB);
+      glTexCoord2f(TexR, TexB); glVertex2f(PR, PB);
+      glTexCoord2f(TexR, TexY); glVertex2f(PR, PT);
+    glEnd;
+  end
+  else
+  begin
+    glDepthRange(0, 10);
+    glDepthFunc(GL_LEQUAL);
+    glEnable(GL_DEPTH_TEST);
+
+    glBegin(GL_QUADS);
+      glTexCoord2f(TexX, TexY); glVertex2f(PL, PT);
+      glTexCoord2f(TexX, TexB); glVertex2f(PL, PB);
+      glTexCoord2f(TexR, TexB); glVertex2f(PR, PB);
+      glTexCoord2f(TexR, TexY); glVertex2f(PR, PT);
+    glEnd;
+
+    glBegin(GL_QUADS);
+      glTexCoord2f(TexX, TexY); glVertex2f(PL, PT);
+      glTexCoord2f(TexX, TexB); glVertex2f(PL, PB);
+      glTexCoord2f(TexR, TexB); glVertex2f(PR, PB);
+      glTexCoord2f(TexR, TexY); glVertex2f(PR, PT);
+
+(*
+      glColor4f(fTempColor.r, fTempColor.g, fTempColor.b, 0.7);
+      glTexCoord2f(TexX, TexB); glVertex3f(PL, PB, 0);
+      glTexCoord2f(TexR, TexB); glVertex3f(PR, PB, 0);
+
+      glColor4f(fTempColor.r, fTempColor.g, fTempColor.b, 0);
+      glTexCoord2f(TexR, (TexY + TexB)/2); glVertex3f(PR, (PT + PB)/2, 0);
+      glTexCoord2f(TexX, (TexY + TexB)/2); glVertex3f(PL, (PT + PB)/2, 0);
+*)
+    glEnd;
+
+    //write the colour back
+    glColor4fv(@fTempColor);
+
+    glDisable(GL_DEPTH_TEST);
+  end; // reflection
+
+  glDisable(GL_TEXTURE_2D);
+  (*
+  if (Font.Blend) then
+    glDisable(GL_BLEND);
+  *)
+
+  AdvanceX := AdvanceX + GlyphWidth;
+end;
+
+procedure TBitmapFont.Render(const Text: WideString);
+var
+  CharIndex: integer;
+  AdvanceX: real;
+begin
+  // if there is no text do nothing
+  if (Text = '') then
+    Exit;
+
+  //Save the current color and alpha (for reflection)
+  glGetFloatv(GL_CURRENT_COLOR, @fTempColor);
+
+  AdvanceX := 0;
+  for CharIndex := 1 to Length(Text) do
+  begin
+    RenderChar(Text[CharIndex], AdvanceX);
+  end;
+end;
+
+function TBitmapFont.GetHeight(): single;
+begin
+  Result := fAscender - fDescender;
+end;
+
+function TBitmapFont.GetAscender(): single;
+begin
+  Result := fAscender;
+end;
+
+function TBitmapFont.GetDescender(): single;
+begin
+  Result := fDescender;
+end;
+
+function TBitmapFont.GetUnderlinePosition(): single;
+begin
+  Result := -2.0;
+end;
+
+function TBitmapFont.GetUnderlineThickness(): single;
+begin
+  Result := 1.0;
+end;
+
+{$ENDIF BITMAP_FONT}
+
+
+initialization
+
+finalization
+  TFreeType.FreeLibrary();
+
+end.
diff --git a/src/lib/freetype/demo/UFont.pas b/src/lib/freetype/demo/UFont.pas
deleted file mode 100644
index c15ff4ca..00000000
--- a/src/lib/freetype/demo/UFont.pas
+++ /dev/null
@@ -1,2641 +0,0 @@
-unit UFont;

-

-{$IFDEF FPC}

-  {$mode delphi}{$H+}

-{$ENDIF}

-

-{$DEFINE HasInline}

-

-interface

-

-// Flip direction of y-axis.

-// Default is a cartesian coordinate system with y-axis in upper direction

-// but with USDX the y-axis is in lower direction.

-{.$DEFINE FLIP_YAXIS}

-{.$DEFINE BITMAP_FONT}  

-

-uses

-  FreeType,

-  gl,

-  glext,

-  glu,

-  sdl,

-  {$IFDEF BITMAP_FONT}

-  UTexture,

-  {$ENDIF}

-  Math,

-  Classes,

-  SysUtils;

-

-type

-

-  PGLubyteArray = ^TGLubyteArray;

-  TGLubyteArray = array[0 .. (MaxInt div SizeOf(GLubyte))-1] of GLubyte;

-  TGLubyteDynArray = array of GLubyte;

-

-  TWideStringArray = array of WideString;

-

-  TGLColor = packed record

-    case byte of

-      0: ( vals: array[0..3] of GLfloat; );

-      1: ( r, g, b, a: GLfloat; );

-  end;

-

-  TBoundsDbl = record

-    Left, Right: double;

-    Bottom, Top: double;

-  end;

-

-  TPositionDbl = record

-    X, Y: double;

-  end;

-

-  TTextureSize = record

-    Width, Height: integer;

-  end;

-

-  TBitmapCoords = record

-    Left, Top: double;

-    Width, Height: integer;

-  end;

-

-  {**

-   * Abstract base class representing a glyph.

-   *}

-  TGlyph = class

-    protected

-      function GetAdvance(): TPositionDbl; virtual; abstract;

-      function GetBounds(): TBoundsDbl; virtual; abstract;

-    public

-      procedure Render(UseDisplayLists: boolean); virtual; abstract;

-      procedure RenderReflection(); virtual; abstract;

-

-      {** Distance to next glyph (in pixels) *}

-      property Advance: TPositionDbl read GetAdvance;

-      {** Glyph bounding box (in pixels) *}

-      property Bounds: TBoundsDbl read GetBounds;

-  end;

-

-  {**

-   * Font styles used by TFont.Style

-   *}

-  TFontStyle = set of (Italic, Underline, Reflect);

-

-  {**

-   * Base font class.

-   *}

-  TFont = class

-    private

-      {** Non-virtual reset-method used in Create() and Reset() *}

-      procedure ResetIntern();

-

-    protected

-      fStyle: TFontStyle;

-      fUseKerning: boolean;

-      fLineSpacing: single;       // must be inited by subclass

-      fReflectionSpacing: single; // must be inited by subclass to -2*Descender

-      fGlyphSpacing: single;

-      fReflectionPass: boolean;

-

-      {**

-       * Splits lines in Text seperated by newline (char-code #13).

-       * @param Text: UTF-8 encoded string

-       * @param Lines: splitted WideString lines

-       *}

-      procedure SplitLines(const Text: UTF8String; var Lines: TWideStringArray);

-

-      {**

-       * Print an array of WideStrings. Each array-item is a line of text.

-       * Lines of text are seperated by the line-spacing.

-       * This is the base function for all text drawing.

-       *}

-      procedure Print(const Text: TWideStringArray); overload; virtual;

-

-      {**

-       * Draws an underline.

-       *}

-      procedure DrawUnderline(const Text: WideString); virtual;

-

-      {**

-       * Renders (one) line of text.

-       *}

-      procedure Render(const Text: WideString); virtual; abstract;

-

-      {**

-       * Returns the bounds of text-lines contained in Text.

-       * @param Advance: if true the right bound is set to the advance instead

-       *   of the minimal right bound.

-       *}

-      function BBox(const Text: TWideStringArray; Advance: boolean): TBoundsDbl; overload; virtual; abstract;

-

-      {**

-       * Resets all user settings to default values.

-       * Override methods should always call the inherited version.

-       *}

-      procedure Reset(); virtual;

-

-      function GetHeight(): single; virtual; abstract;

-      function GetAscender(): single; virtual; abstract;

-      function GetDescender(): single; virtual; abstract;

-      procedure SetLineSpacing(Spacing: single); virtual;

-      function GetLineSpacing(): single; virtual;

-      procedure SetGlyphSpacing(Spacing: single); virtual;

-      function GetGlyphSpacing(): single; virtual;

-      procedure SetReflectionSpacing(Spacing: single); virtual;

-      function GetReflectionSpacing(): single; virtual;

-      procedure SetStyle(Style: TFontStyle); virtual;

-      function GetStyle(): TFontStyle; virtual;

-      function GetUnderlinePosition(): single; virtual; abstract;

-      function GetUnderlineThickness(): single; virtual; abstract;

-      procedure SetUseKerning(Enable: boolean); virtual;

-      function GetUseKerning(): boolean; virtual;

-      procedure SetReflectionPass(Enable: boolean); virtual;

-

-      {** Returns true if the current render-pass is used to draw the reflection *}

-      property ReflectionPass: boolean read fReflectionPass write SetReflectionPass;

-

-    public

-      constructor Create();

-      destructor Destroy(); override;

-

-      {**

-       * Prints a text.

-       *}

-      procedure Print(const Text: WideString); overload;

-      {** UTF-8 version of @link Print(const Text: WideString) *}

-      procedure Print(const Text: string); overload;

-

-      {**

-       * Calculates the bounding box (width and height) around Text.

-       * Works with Italic and Underline styles but reflections created

-       * with the Reflect style are not considered.

-       * Note that the width might differ due to kerning with appended text,

-       * e.g. Width('VA') <= Width('V') + Width('A').

-       * @param Advance: if set to true, Result.Right is set to the advance of

-       * the given text rather than the min. right border. The advance width is

-       * bigger than the text's width as it additionally contains the advance

-       * and glyph-spacing of the last character.

-       *}

-      function BBox(const Text: WideString; Advance: boolean = false): TBoundsDbl; overload;

-      {** UTF-8 version of @link BBox(const Text: WideString) *}

-      function BBox(const Text: UTF8String; Advance: boolean = false): TBoundsDbl; overload;

-

-      {** Font height *}

-      property Height: single read GetHeight;

-      {** Vertical distance from baseline to top of glyph *}

-      property Ascender: single read GetAscender;

-      {** Vertical distance from baseline to bottom of glyph *}

-      property Descender: single read GetDescender;

-      {** Vertical distance between two baselines *}

-      property LineSpacing: single read GetLineSpacing write SetLineSpacing;

-      {** Space between end and start of next glyph added to the advance width *}

-      property GlyphSpacing: single read GetGlyphSpacing write SetGlyphSpacing;

-      {** Distance between normal baseline and baseline of the reflection *}

-      property ReflectionSpacing: single read GetReflectionSpacing write SetReflectionSpacing;

-      {** Font style (italic/underline/...) *}

-      property Style: TFontStyle read GetStyle write SetStyle;

-      {** If set to true (default) kerning will be used if available *}

-      property UseKerning: boolean read GetUseKerning write SetUseKerning;

-  end;

-

-const

-  // max. number of mipmap levels that a TScalableFont can contain

-  cMaxMipmapLevel = 5;

-

-type

-  {**

-   * Wrapper around TFont to allow font size changes.

-   * The font is scaled to the requested size by a modelview matrix

-   * transformation (glScale) and not by rescaling the internal bitmap

-   * representation. This way changing the size is really fast but the result

-   * may lack quality on large or small scale factors.

-   *}

-  TScalableFont = class(TFont)

-    private

-      procedure ResetIntern();

-

-    protected

-      fScale: single;        ///< current height to base-font height ratio 

-      fAspect: single;       ///< width to height aspect

-      fBaseFont: TFont;      ///< shortcut for fMipmapFonts[0]

-      fUseMipmaps: boolean;  ///< true if mipmap fonts are generated

-      /// Mipmap fonts (size[level+1] = size[level]/2)

-      fMipmapFonts: array[0..cMaxMipmapLevel] of TFont;

-

-      procedure Render(const Text: WideString); override;

-      procedure Print(const Text: TWideStringArray); override;

-      function BBox(const Text: TWideStringArray; Advance: boolean): TBoundsDbl; override;

-

-      {**

-       * Callback called for creation of each mipmap font.

-       * Must be defined by the subclass.

-       * Mipmaps created by this method are managed and freed by TScalableFont.

-       *}

-      function CreateMipmap(Level: integer; Scale: single): TFont; virtual; abstract;

-

-      {**

-       * Returns the mipmap level considering the current scale and projection

-       * matrix.

-       *}

-      function GetMipmapLevel(): integer;

-

-      {**

-       * Returns the scale applied to the given mipmap font.

-       * fScale * fBaseFont.Height / fMipmapFont[Level].Height

-       *}

-      function GetMipmapScale(Level: integer): single;

-

-      {**

-       * Chooses the mipmap that looks nicest with current scale and projection

-       * matrix.

-       *}

-      function ChooseMipmapFont(): TFont;

-

-      procedure SetHeight(Height: single); virtual;

-      function GetHeight(): single; override;

-      procedure SetAspect(Aspect: single); virtual;

-      function GetAspect(): single; virtual;

-      function GetAscender(): single; override;

-      function GetDescender(): single; override;

-      procedure SetLineSpacing(Spacing: single); override;

-      function GetLineSpacing(): single; override;

-      procedure SetGlyphSpacing(Spacing: single); override;

-      function GetGlyphSpacing(): single; override;

-      procedure SetReflectionSpacing(Spacing: single); override;

-      function GetReflectionSpacing(): single; override;

-      procedure SetStyle(Style: TFontStyle); override;

-      function GetStyle(): TFontStyle; override;

-      function GetUnderlinePosition(): single; override;

-      function GetUnderlineThickness(): single; override;

-      procedure SetUseKerning(Enable: boolean); override;

-

-    public

-      {**

-       * Creates a wrapper to make the base-font Font scalable.

-       * If UseMipmaps is set to true smaller fonts are created so that a

-       * resized (Height property changed) font looks nicer.

-       * The font passed is managed and freed by TScalableFont.

-       *}

-      constructor Create(Font: TFont; UseMipmaps: boolean); overload;

-

-      {**

-       * Frees memory. The fonts passed on Create() and mipmap creation

-       * are freed too. 

-       *}

-      destructor Destroy(); override;

-

-      {** @see TFont.Reset *}

-      procedure Reset(); override;

-

-      {** Font height *}

-      property Height: single read GetHeight write SetHeight;

-      {** Factor for font stretching (NewWidth = Width*Aspect), 1.0 by default *}

-      property Aspect: single read GetAspect write SetAspect;

-  end;

-

-  {**

-   * Table for storage of max. 256 glyphs.

-   * Used for the second cache level. Indexed by the LSB of the WideChar

-   * char-code.

-   *}

-  PGlyphTable = ^TGlyphTable;

-  TGlyphTable = array[0..255] of TGlyph;

-

-  {**

-   * Cache for glyphs of a single font.

-   * The cached glyphs are stored inside a hash-list.

-   * Hashing is performed in two steps:

-   * 1. the least significant byte (LSB) of the WideChar character code

-   * is removed (shr 8) and the result (we call it BaseCode here) looked up in

-   * the hash-list.

-   * 2. Each entry of the hash-list contains a table with max. 256 entries.

-   * The LSB of the char-code of a glyph is the table-offset of that glyph.

-   *}

-  TGlyphCache = class

-    private

-      fHash: TList;

-

-      {**

-       * Finds a glyph-table storing cached glyphs with base-code BaseCode

-       * (= upper char-code bytes) in the hash-list and returns the table and

-       * its index.

-       * @param InsertPos: the position of the tyble in the list if it was found,

-       *                   otherwise the position the table should be inserted

-       *}

-      function FindGlyphTable(BaseCode: cardinal; out InsertPos: integer): PGlyphTable;

-

-    public

-      constructor Create();

-      destructor Destroy(); override;

-

-      {**

-       * Add glyph Glyph with char-code ch to the cache.

-       * @returns @true on success, @false otherwise

-       *}

-      function AddGlyph(ch: WideChar; const Glyph: TGlyph): boolean;

-

-      {**

-       * Removes the glyph with char-code ch from the cache.

-       *}

-      procedure DeleteGlyph(ch: WideChar);

-

-      {**

-       * Removes the glyph with char-code ch from the cache.

-       *}

-      function GetGlyph(ch: WideChar): TGlyph;

-

-      {**

-       * Checks if a glyph with char-code ch is cached.

-       *}

-      function HasGlyph(ch: WideChar): boolean;

-

-      {**

-       * Remove and free all cached glyphs. If KeepBaseSet is set to

-       * true, cached characters in the range 0..255 will not be flushed.

-       *}

-      procedure FlushCache(KeepBaseSet: boolean);

-  end;

-

-  {**

-   * Entry of a glyph-cache's (TGlyphCache) hash.

-   * Stores a BaseCode (upper-bytes of a glyph's char-code) and a table

-   * with all glyphs cached at the moment with that BaseCode.

-   *}

-  TGlyphCacheHashEntry = class

-    private

-      fBaseCode: cardinal;

-    public

-      GlyphTable: TGlyphTable;

-

-      constructor Create(BaseCode: cardinal);

-

-      {** Base-code (upper-bytes) of the glyphs stored in this entry's table *}

-      property BaseCode: cardinal read fBaseCode;

-  end;

-

-  TCachedFont = class(TFont)

-    protected

-      fCache: TGlyphCache;

-

-      {**

-       * Retrieves a cached glyph with char-code ch from cache.

-       * If the glyph is not already cached, it is loaded with LoadGlyph().

-       *}

-      function GetGlyph(ch: WideChar): TGlyph;

-

-      {**

-       * Callback to create (load) a glyph with char-code ch.

-       * Implemented by subclasses.

-       *}

-      function LoadGlyph(ch: WideChar): TGlyph; virtual; abstract;

-

-    public

-      constructor Create();

-      destructor Destroy(); override;

-

-      {**

-       * Remove and free all cached glyphs. If KeepBaseSet is set to

-       * true, the base glyphs are not be flushed.

-       * @see TGlyphCache.FlushCache

-       *}

-      procedure FlushCache(KeepBaseSet: boolean);

-  end;

-

-  TFTFont = class;

-

-  {**

-   * Freetype glyph.

-   * Each glyph stores a texture with the glyph's image.

-   *}

-  TFTGlyph = class(TGlyph)

-    private

-      fCharIndex: FT_UInt;      ///< Freetype specific char-index (<> char-code)

-      fDisplayList: GLuint;     ///< Display-list ID

-      fTexture: GLuint;         ///< Texture ID

-      fBitmapCoords: TBitmapCoords; ///< Left/Top offset and Width/Height of the bitmap (in pixels)

-      fTexOffset: TPositionDbl; ///< Right and bottom texture offset for removal of power-of-2 padding

-      fTexSize: TTextureSize;   ///< Texture size in pixels

-

-      fFont: TFTFont;           ///< Font associated with this glyph

-      fAdvance: TPositionDbl;   ///< Advance width of this glyph

-      fBounds: TBoundsDbl;      ///< Glyph bounds

-      fOutset: single;          ///< Extrusion outset

-

-      {**

-       * Extrudes the outline of a glyph's bitmap stored in TexBuffer with size

-       * fTexSize by Outset pixels.

-       * This is useful to create bold or outlined fonts.

-       * TexBuffer must be 2*Ceil(Outset) pixels higher and wider than the

-       * original glyph bitmap, otherwise the glyph borders cannot be extruded

-       * correctly.

-       * The bitmap must be 2* pixels wider and higher than the

-       * original glyph's bitmap with the latter centered in it.

-       *}

-      procedure Extrude(var TexBuffer: TGLubyteDynArray; Outset: single);

-

-      {**

-       * Creates an OpenGL texture (and display list) for the glyph.

-       * The glyph's and bitmap's metrics are set correspondingly.

-       * @param LoadFlags: flags passed to FT_Load_Glyph()

-       * @raises Exception if the glyph could not be initialized

-       *}

-      procedure CreateTexture(LoadFlags: FT_Int32);

-

-    protected

-      function GetAdvance(): TPositionDbl; override;

-      function GetBounds(): TBoundsDbl; override;

-

-    public

-      {**

-       * Creates a glyph with char-code ch from font Font.

-       * @param LoadFlags: flags passed to FT_Load_Glyph()

-       *}

-      constructor Create(Font: TFTFont; ch: WideChar; Outset: single;

-                         LoadFlags: FT_Int32);

-      destructor Destroy(); override;

-

-      {** Renders the glyph (normal render pass) *}

-      procedure Render(UseDisplayLists: boolean); override;

-      {** Renders the glyph's reflection *}

-      procedure RenderReflection(); override;

-

-      {** Freetype specific char-index (<> char-code) *}

-      property CharIndex: FT_UInt read fCharIndex;

-  end;

-

-  {**

-   * Freetype font class.

-   *}

-  TFTFont = class(TCachedFont)

-    private

-      procedure ResetIntern();

-

-    protected

-      fFilename: string;            ///< filename of the font-file

-      fSize: integer;               ///< Font base size (in pixels)

-      fOutset: single;              ///< size of outset extrusion (in pixels)

-      fFace: FT_Face;               ///< Holds the height of the font

-      fLoadFlags: FT_Int32;         ///< FT glpyh load-flags

-      fFontUnitScale: TPositionDbl; ///< FT font-units to pixel ratio

-      fUseDisplayLists: boolean;    ///< true: use display-lists, false: direct drawing

-

-      {** @see TCachedFont.LoadGlyph *}

-      function LoadGlyph(ch: WideChar): TGlyph; override;

-

-      procedure Render(const Text: WideString); override;

-      function BBox(const Text: TWideStringArray; Advance: boolean): TBoundsDbl; override;

-

-      function GetHeight(): single; override;

-      function GetAscender(): single; override;

-      function GetDescender(): single; override;

-      function GetUnderlinePosition(): single; override;

-      function GetUnderlineThickness(): single; override;

-

-      property Face: FT_Face read fFace;

-

-    public

-      {**

-       * Creates a font of size Size (in pixels) from the file Filename.

-       * If Outset (in pixels) is set to a value > 0 the glyphs will be extruded

-       * at their borders. Use it for e.g. a bold effect.

-       * @param LoadFlags: flags passed to FT_Load_Glyph()

-       * @raises Exception if the font-file could not be loaded

-       *}

-      constructor Create(const Filename: string;

-                         Size: integer; Outset: single = 0.0;

-                         LoadFlags: FT_Int32 = FT_LOAD_DEFAULT);

-

-      {**

-       * Frees all resources associated with the font.

-       *}

-      destructor Destroy(); override;

-

-      {** @see TFont.Reset *}

-      procedure Reset(); override;

-      

-      {** Size of the base font *}

-      property Size: integer read fSize;

-      {** Outset size *}

-      property Outset: single read fOutset;

-  end;

-

-  TFTScalableFont = class(TScalableFont)

-    protected

-      function GetOutset(): single; virtual;

-      function CreateMipmap(Level: integer; Scale: single): TFont; override;

-

-    public

-      {**

-       * Creates a scalable font of size Size (in pixels) from the file Filename.

-       * OutsetAmount is the ratio of the glyph extrusion.

-       * The extrusion in pixels is Size*OutsetAmount

-       * (0.0 -> no extrusion, 0.1 -> 10%).

-       *}

-      constructor Create(const Filename: string;

-                         Size: integer; OutsetAmount: single = 0.0;

-                         UseMipmaps: boolean = true);

-

-      {** @see TGlyphCache.FlushCache *}

-      procedure FlushCache(KeepBaseSet: boolean);

-

-      {** Outset size (in pixels) of the scaled font *}

-      property Outset: single read GetOutset;

-  end;

-

-  

-  {**

-   * Represents a freetype font with an additional outline around its glyphs.

-   * The outline size is passed on creation and cannot be changed later.

-   *}

-  TFTOutlineFont = class(TFont)

-    private

-      fFilename: string;

-      fSize: integer;

-      fOutset: single;

-      fInnerFont, fOutlineFont: TFTFont;

-      fOutlineColor: TGLColor;

-

-      procedure ResetIntern();

-      

-  protected

-      procedure DrawUnderline(const Text: WideString); override;

-      procedure Render(const Text: WideString); override;

-      function BBox(const Text: TWideStringArray; Advance: boolean): TBoundsDbl; override;

-

-      function GetHeight(): single; override;

-      function GetAscender(): single; override;

-      function GetDescender(): single; override;

-      procedure SetLineSpacing(Spacing: single); override;

-      procedure SetGlyphSpacing(Spacing: single); override;

-      procedure SetReflectionSpacing(Spacing: single); override;

-      procedure SetStyle(Style: TFontStyle); override;

-      function GetStyle(): TFontStyle; override;

-      function GetUnderlinePosition(): single; override;

-      function GetUnderlineThickness(): single; override;

-      procedure SetUseKerning(Enable: boolean); override;

-      procedure SetReflectionPass(Enable: boolean); override;

-

-    public

-      constructor Create(const Filename: string;

-                         Size: integer; Outset: single;

-                         LoadFlags: FT_Int32 = FT_LOAD_DEFAULT);

-      destructor Destroy; override;

-

-      {** Sets the color of the outline *}

-      procedure SetOutlineColor(r, g, b: GLfloat; a: GLfloat = 1.0);

-

-      {** @see TGlyphCache.FlushCache *}

-      procedure FlushCache(KeepBaseSet: boolean);

-

-      {** @see TFont.Reset *}

-      procedure Reset(); override;

-      

-      {** Size of the base font *}

-      property Size: integer read fSize;

-      {** Outset size *}

-      property Outset: single read fOutset;

-  end;

-

-  {**

-   * Wrapper around TOutlineFont to allow font resizing.

-   * @see TScalableFont

-   *}

-  TFTScalableOutlineFont = class(TScalableFont)

-    protected

-      function GetOutset(): single; virtual;

-      function CreateMipmap(Level: integer; Scale: single): TFont; override;

-

-    public

-      constructor Create(const Filename: string;

-                         Size: integer; OutsetAmount: single;

-                         UseMipmaps: boolean = true);

-

-      {** Sets the color of the outline *}

-      procedure SetOutlineColor(r, g, b: GLfloat; a: GLfloat = 1.0);

-

-      {** @see TGlyphCache.FlushCache *}

-      procedure FlushCache(KeepBaseSet: boolean);

-      

-      {** Outset size *}

-      property Outset: single read GetOutset;

-  end;

-

-{$IFDEF BITMAP_FONT}

-

-  {**

-   * A bitmapped font loads it's glyphs from a bitmap and stores them in a

-   * texture. Unicode characters are not supported (but could be by supporting

-   * multiple textures each storing a subset of unicode glyphs).

-   * For backward compatibility only.

-   *}

-  TBitmapFont = class(TFont)

-    private

-      fTex:       TTexture;

-      fTexSize:   integer;

-      fBaseline:  integer;

-      fAscender:  integer;

-      fDescender: integer;

-      fWidths:    array[0..255] of byte; // half widths

-      fOutline:   integer;

-      fTempColor: TGLColor; ///< colours for the reflection

-

-      procedure ResetIntern();

-

-      procedure RenderChar(ch: WideChar; var AdvanceX: real);

-

-      {**

-       * Load font widths from an info file.

-       * @param InfoFile: the name of the info (.dat) file

-       * @raises Exception if the file is corrupted

-       *}

-      procedure LoadFontInfo(const InfoFile: string);

-

-    protected

-      procedure Render(const Text: WideString); override;

-      function BBox(const Text: TWideStringArray; Advance: boolean): TBoundsDbl; override;

-

-      function GetHeight(): single; override;

-      function GetAscender(): single; override;

-      function GetDescender(): single; override;

-      function GetUnderlinePosition(): single; override;

-      function GetUnderlineThickness(): single; override;

-

-    public

-      {**

-       * Creates a bitmapped font from image Filename and font width info

-       * loaded from the corresponding file with ending .dat.

-       * @param Baseline: y-coord of the baseline given in cartesian coords

-       *        (y-axis up) and from the lower edge of the glyphs bounding box

-       * @param Ascender: pixels from baseline to top of highest glyph

-       *}

-      constructor Create(const Filename: string; Outline: integer;

-                         Baseline, Ascender, Descender: integer);

-      destructor Destroy(); override;

-

-      {**

-       * Corrects font widths provided by the info file.

-       * NewWidth := Width * WidthMult + WidthAdd

-       *}

-      procedure CorrectWidths(WidthMult: real; WidthAdd: integer);

-

-      {** @see TFont.Reset *}

-      procedure Reset(); override;

-  end;

-

-{$ENDIF BITMAP_FONT}

-

-  TFreeType = class

-    public

-      {**

-       * Returns a pointer to the freetype library singleton.

-       * If non exists, freetype will be initialized.

-       * @raises Exception if initialization failed

-       *}

-      class function GetLibrary(): FT_Library;

-      class procedure FreeLibrary();

-  end;

-

-

-implementation

-

-uses Types;

-

-const

-  // shear factor used for the italic effect (bigger value -> more bending)

-  cShearFactor = 0.25;

-  cShearMatrix: array[0..15] of GLfloat = (

-      1,            0, 0, 0,

-      cShearFactor, 1, 0, 0,

-      0,            0, 1, 0,

-      0,            0, 0, 1

-  );

-  cShearMatrixInv: array[0..15] of GLfloat = (

-      1,             0, 0, 0,

-      -cShearFactor, 1, 0, 0,

-      0,             0, 1, 0,

-      0,             0, 0, 1

-  );

-

-var

-  LibraryInst: FT_Library;

-

-function NewGLColor(r, g, b, a: GLfloat): TGLColor;

-begin

-  Result.r := r;

-  Result.g := g;

-  Result.b := b;

-  Result.a := a;

-end;

-

-{**

- * Returns the first power of 2 >= Value.

- *}

-function NextPowerOf2(Value: integer): integer; {$IFDEF HasInline}inline;{$ENDIF}

-begin

-  Result := 1;

-  while (Result < Value) do

-    Result := Result shl 1;

-end;

-

-

-{*

- * TFont

- *}

-

-constructor TFont.Create();

-begin

-  inherited;

-  ResetIntern();

-end;

-

-destructor TFont.Destroy();

-begin

-  inherited;

-end;

-

-procedure TFont.ResetIntern();

-begin

-  fStyle := [];

-  fUseKerning := true;

-  fGlyphSpacing := 0.0;

-  fReflectionPass := false;

-

-  // must be set by subclasses

-  fLineSpacing := 0.0;

-  fReflectionSpacing := 0.0;

-end;

-

-procedure TFont.Reset();

-begin

-  ResetIntern();

-end;

-

-procedure TFont.SplitLines(const Text: UTF8String; var Lines: TWideStringArray);

-var

-  LineList: TStringList;

-  LineIndex: integer;

-begin

-  // split lines on newline (there is no WideString version of ExtractStrings)

-  LineList := TStringList.Create();

-  ExtractStrings([#13], [], PChar(Text), LineList);

-

-  // create an array of WideStrins from the UTF-8 string-list

-  SetLength(Lines, LineList.Count);

-  for LineIndex := 0 to LineList.Count-1 do

-    Lines[LineIndex] := UTF8Decode(LineList[LineIndex]);

-  LineList.Free();

-end;

-

-function TFont.BBox(const Text: UTF8String; Advance: boolean): TBoundsDbl;

-var

-  LineArray: TWideStringArray;

-begin

-  SplitLines(Text, LineArray);

-  Result := BBox(LineArray, Advance);

-  SetLength(LineArray, 0);

-end;

-

-function TFont.BBox(const Text: WideString; Advance: boolean): TBoundsDbl;

-begin

-  Result := BBox(UTF8Encode(Text), Advance);

-end;

-

-procedure TFont.Print(const Text: TWideStringArray);

-var

-  LineIndex: integer;

-begin

-  // recursively call this function to draw reflected text

-  if ((Reflect in Style) and not ReflectionPass) then

-  begin

-    ReflectionPass := true;

-    Print(Text);

-    ReflectionPass := false;

-  end;

-

-  // store current color, enable-flags, matrix-mode

-  glPushAttrib(GL_CURRENT_BIT or GL_ENABLE_BIT or GL_TRANSFORM_BIT);

-

-  // set OpenGL state

-  glMatrixMode(GL_MODELVIEW);

-  glDisable(GL_DEPTH_TEST);

-  glEnable(GL_BLEND);

-  glEnable(GL_TEXTURE_2D);

-  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

-

-  {

-  // TODO: just draw texels with alpha > 0 to avoid setting z-buffer for them?

-  glAlphaFunc(GL_GREATER, 0);

-  glEnable(GL_ALPHA_TEST);

-

-  //TODO: Do we need depth-testing?

-  if (ReflectionPass) then

-  begin

-    glDepthMask(0);

-    glEnable(GL_DEPTH_TEST);

-  end;

-  }

-

-  {$IFDEF FLIP_YAXIS}

-  glPushMatrix();

-  glScalef(1, -1, 1);

-  {$ENDIF}

-

-  // display text

-  for LineIndex := 0 to High(Text) do

-  begin

-    glPushMatrix();

-

-    // move to baseline

-    glTranslatef(0, -LineSpacing*LineIndex, 0);

-

-    if ((Underline in Style) and not ReflectionPass) then

-    begin

-      glDisable(GL_TEXTURE_2D);

-      DrawUnderline(Text[LineIndex]);

-      glEnable(GL_TEXTURE_2D);

-    end;

-

-    // draw reflection

-    if (ReflectionPass) then

-    begin

-      // set reflection spacing

-      glTranslatef(0, -ReflectionSpacing, 0);

-      // flip y-axis

-      glScalef(1, -1, 1);

-    end;

-

-    // shear for italic effect

-    if (Italic in Style) then

-      glMultMatrixf(@cShearMatrix);

-

-    // render text line

-    Render(Text[LineIndex]);

-

-    glPopMatrix();

-  end;

-

-  // restore settings

-  {$IFDEF FLIP_YAXIS}

-  glPopMatrix();

-  {$ENDIF}

-  glPopAttrib();

-end;

-

-procedure TFont.Print(const Text: string);

-var

-  LineArray: TWideStringArray;

-begin

-  SplitLines(Text, LineArray);

-  Print(LineArray);

-  SetLength(LineArray, 0);

-end;

-

-procedure TFont.Print(const Text: WideString);

-begin

-  Print(UTF8Encode(Text));

-end;

-

-procedure TFont.DrawUnderline(const Text: WideString);

-var

-  UnderlineY1, UnderlineY2: single;

-  Bounds: TBoundsDbl;

-begin

-  UnderlineY1 := GetUnderlinePosition();

-  UnderlineY2 := UnderlineY1 + GetUnderlineThickness();

-  Bounds := BBox(Text);

-  glRectf(Bounds.Left, UnderlineY1, Bounds.Right, UnderlineY2);

-end;

-

-procedure TFont.SetStyle(Style: TFontStyle);

-begin

-  fStyle := Style;

-end;

-

-function TFont.GetStyle(): TFontStyle;

-begin

-  Result := fStyle;

-end;

-

-procedure TFont.SetLineSpacing(Spacing: single);

-begin

-  fLineSpacing := Spacing;

-end;

-

-function TFont.GetLineSpacing(): single;

-begin

-  Result := fLineSpacing;

-end;

-

-procedure TFont.SetGlyphSpacing(Spacing: single);

-begin

-  fGlyphSpacing := Spacing;

-end;

-

-function TFont.GetGlyphSpacing(): single;

-begin

-  Result := fGlyphSpacing;

-end;

-

-procedure TFont.SetReflectionSpacing(Spacing: single);

-begin

-  fReflectionSpacing := Spacing;

-end;

-

-function TFont.GetReflectionSpacing(): single;

-begin

-  Result := fReflectionSpacing;

-end;

-

-procedure TFont.SetUseKerning(Enable: boolean);

-begin

-  fUseKerning := Enable;

-end;

-

-function TFont.GetUseKerning(): boolean;

-begin

-  Result := fUseKerning;

-end;

-

-procedure TFont.SetReflectionPass(Enable: boolean);

-begin

-  fReflectionPass := Enable;

-end;

-

-

-{*

- * TScalableFont

- *}

-

-constructor TScalableFont.Create(Font: TFont; UseMipmaps: boolean);

-var

-  MipmapLevel: integer;

-begin

-  inherited Create();

-  

-  fBaseFont := Font;

-  fMipmapFonts[0] := Font;

-  fUseMipmaps := UseMipmaps;

-  ResetIntern();

-

-  // create mipmap fonts if requested

-  if (UseMipmaps) then

-  begin

-    for MipmapLevel := 1 to cMaxMipmapLevel do

-    begin

-      fMipmapFonts[MipmapLevel] := CreateMipmap(MipmapLevel, 1/(1 shl MipmapLevel));

-      // stop if no smaller mipmap font is returned

-      if (fMipmapFonts[MipmapLevel] = nil) then

-        Break;

-    end;

-  end;

-end;

-

-destructor TScalableFont.Destroy();

-var

-  Level: integer;

-begin

-  for Level := 0 to High(fMipmapFonts) do

-    fMipmapFonts[Level].Free;

-  inherited;

-end;

-

-procedure TScalableFont.ResetIntern();

-begin

-  fScale := 1.0;

-  fAspect := 1.0;

-end;

-

-procedure TScalableFont.Reset();

-var

-  Level: integer;

-begin

-  inherited;

-  ResetIntern();

-  for Level := 0 to High(fMipmapFonts) do

-    if (fMipmapFonts[Level] <> nil) then

-      fMipmapFonts[Level].Reset();

-end;

-

-{**

- * Returns the mipmap level to use with regard to the current projection

- * and modelview matrix, font scale and aspect.

- *

- * Note:

- * - for Freetype fonts, hinting and grid-fitting must be disabled, otherwise

- *   the glyph widths/heights ratios and advance widths of the mipmap fonts

- *   do not match as they are adjusted sligthly (e.g. an 'a' at size 12px has

- *   width 12px, but at size 6px width 8px).

- * - returned mipmap-level is used for all glyphs of the current text to print.

- *   This is faster, much easier to handle, since we just need to create

- *   multiple sized fonts and select the one we need for the mipmap-level and

- *   it avoids that neighbored glyphs use different mipmap-level which might

- *   look odd because one glyph might look blurry and the other sharp.

- *

- * Motivation:

- *   We do not use OpenGL for mipmapping as the results are very bad. At least

- *   with automatic mipmap generation (gluBuildMipmaps) the fonts look rather

- *   blurry.

- *   Defining our own mipmaps by creating multiple textures with

- *   for different mimap levels is a pain, as the font size passed to freetype

- *   is not the size of the bitmaps created and it does not guarantee that a

- *   glyph bitmap of a font with font-size s/2 is half the size of the font with

- *   font-size s. If the bitmap size is just a single pixel bigger than the half

- *   we might need a texture of the next power-of-2 and the texture would not be

- *   half of the size of the next bigger mipmap. In addition we use a fixed one

- *   pixel sized border to smooth the texture (see cTexSmoothBorder) and maybe

- *   an outset that is added to the font, so creating a glyph mipmap that is

- *   exactly half the size of the next bigger one is a very difficult task.

- *

- * Solution:

- *   Use mipmap textures that are not exactly half the size of the next mipmap

- *   level. OpenGL does not support this (at least not without extensions).

- *   The trickiest task is to determine the mipmap to use by calculating the

- *   amount of minification that is performed in this function.

- *}

-function TScalableFont.GetMipmapLevel(): integer;

-var

-  ModelMatrix, ProjMatrix: T16dArray;

-  WinCoords: array[0..2, 0..2] of GLdouble;

-  ViewPortArray: TViewPortArray;

-  Dist, Dist2: double;

-  WidthScale, HeightScale: double;

-const

-  // width/height of square used for determining the scale

-  cTestSize = 10.0;

-  // an offset to the mipmap-level to adjust the change-over of two consecutive

-  // mipmap levels. If for example the bias is 0.1 and unbiased level is 1.9

-  // the result level will be 2. A bias of 0.5 is equal to rounding.

-  // With bias=0.1 we prefer larger mipmaps over smaller ones.

-  cBias = 0.2;

-begin

-  // 1. retrieve current transformation matrices for gluProject

-  glGetDoublev(GL_MODELVIEW_MATRIX, @ModelMatrix);

-  glGetDoublev(GL_PROJECTION_MATRIX, @ProjMatrix);

-  glGetIntegerv(GL_VIEWPORT, @ViewPortArray);

-

-  // 2. project three of the corner points of a square with size cTestSize

-  // to window coordinates (the square is just a dummy for a glyph)

-

-  // project point (x1, y1) to window corrdinates

-  gluProject(0, 0, 0,

-             ModelMatrix, ProjMatrix, ViewPortArray,

-             @WinCoords[0][0], @WinCoords[0][1], @WinCoords[0][2]);

-  // project point (x2, y1) to window corrdinates

-  gluProject(cTestSize, 0, 0,

-             ModelMatrix, ProjMatrix, ViewPortArray,

-             @WinCoords[1][0], @WinCoords[1][1], @WinCoords[1][2]);

-  // project point (x1, y2) to window corrdinates

-  gluProject(0, cTestSize, 0,

-             ModelMatrix, ProjMatrix, ViewPortArray,

-             @WinCoords[2][0], @WinCoords[2][1], @WinCoords[2][2]);

-

-  // 3. Lets see how much the width and height of the square changed.

-  // Calculate the width and height as displayed on the screen in window

-  // coordinates and calculate the ratio to the original coordinates in

-  // modelview space so the ratio gives us the scale (minification here).

-

-  // projected width ||(x1, y1) - (x2, y1)||

-  Dist  := (WinCoords[0][0] - WinCoords[1][0]);

-  Dist2 := (WinCoords[0][1] - WinCoords[1][1]);

-  WidthScale := cTestSize / Sqrt(Dist*Dist + Dist2*Dist2);

-

-  // projected height ||(x1, y1) - (x1, y2)||

-  Dist  := (WinCoords[0][0] - WinCoords[2][0]);

-  Dist2 := (WinCoords[0][1] - WinCoords[2][1]);

-  HeightScale := cTestSize / Sqrt(Dist*Dist + Dist2*Dist2);

-

-  //writeln(Format('Scale %f, %f', [WidthScale, HeightScale]));

-

-  // 4. Now that we have got the scale, take the bigger minification scale

-  // and get it to a logarithmic scale as each mipmap is 1/2 the size of its

-  // predecessor (Mipmap_size[i] = Mipmap_size[i-1]/2).

-  // The result is our mipmap-level = the index of the mipmap to use.

-

-  // Level > 0: Minification; < 0: Magnification

-  Result := Trunc(Log2(Max(WidthScale, HeightScale)) + cBias);

-

-  // clamp to valid range

-  if (Result < 0) then

-    Result := 0;

-  if (Result > High(fMipmapFonts)) then

-    Result := High(fMipmapFonts);

-end;

-

-function TScalableFont.GetMipmapScale(Level: integer): single;

-begin

-  if (fMipmapFonts[Level] = nil) then

-  begin

-    Result := -1;

-    Exit;

-  end;

-

-  Result := fScale * fMipmapFonts[0].Height / fMipmapFonts[Level].Height;

-end;

-

-{**

- * Returns the correct mipmap font for the current scale and projection

- * matrix. The modelview scale is adjusted to the mipmap level, so

- * Result.Print() will display the font in the correct size.

- *}

-function TScalableFont.ChooseMipmapFont(): TFont;

-var

-  DesiredLevel: integer;

-  Level: integer;

-  MipmapScale: single;

-begin

-  Result := nil;

-  DesiredLevel := GetMipmapLevel();

-

-  // get the smallest mipmap available for the desired level

-  // as not all levels must be assigned to a font.

-  for Level := DesiredLevel downto 0 do

-  begin

-    if (fMipmapFonts[Level] <> nil) then

-    begin

-      Result := fMipmapFonts[Level];

-      Break;

-    end;

-  end;

-

-  // since the mipmap font (if level > 0) is smaller than the base-font

-  // we have to scale to get its size right.

-  MipmapScale := fMipmapFonts[0].Height/Result.Height;

-  glScalef(MipmapScale, MipmapScale, 0);

-end;

-

-procedure TScalableFont.Print(const Text: TWideStringArray);

-begin

-  glPushMatrix();

-  glScalef(fScale * fAspect, fScale, 0);

-  if (fUseMipmaps) then

-    ChooseMipmapFont().Print(Text)

-  else

-    fBaseFont.Print(Text);

-  glPopMatrix();

-end;

-

-procedure TScalableFont.Render(const Text: WideString);

-begin

-  Assert(false, 'Unused TScalableFont.Render() was called');

-end;

-

-function TScalableFont.BBox(const Text: TWideStringArray; Advance: boolean): TBoundsDbl;

-begin

-  Result := fBaseFont.BBox(Text, Advance);

-  Result.Left   := Result.Left * fScale;

-  Result.Right  := Result.Right * fScale;

-  Result.Top    := Result.Top * fScale;

-  Result.Bottom := Result.Bottom * fScale;

-end;

-

-procedure TScalableFont.SetHeight(Height: single);

-begin

-  fScale := Height / fBaseFont.GetHeight();

-end;

-

-function TScalableFont.GetHeight(): single;

-begin

-  Result := fBaseFont.GetHeight() * fScale;

-end;

-

-procedure TScalableFont.SetAspect(Aspect: single);

-begin

-  fAspect := Aspect;

-end;

-

-function TScalableFont.GetAspect(): single;

-begin

-  Result := fAspect;

-end;

-

-function TScalableFont.GetAscender(): single;

-begin

-  Result := fBaseFont.GetAscender() * fScale;

-end;

-

-function TScalableFont.GetDescender(): single;

-begin

-  Result := fBaseFont.GetDescender() * fScale;

-end;

-

-procedure TScalableFont.SetLineSpacing(Spacing: single);

-var

-  Level: integer;

-begin

-  for Level := 0 to High(fMipmapFonts) do

-    if (fMipmapFonts[Level] <> nil) then

-      fMipmapFonts[Level].SetLineSpacing(Spacing / GetMipmapScale(Level));

-end;

-

-function TScalableFont.GetLineSpacing(): single;

-begin

-  Result := fBaseFont.GetLineSpacing() * fScale;

-end;

-

-procedure TScalableFont.SetGlyphSpacing(Spacing: single);

-var

-  Level: integer;

-begin

-  for Level := 0 to High(fMipmapFonts) do

-    if (fMipmapFonts[Level] <> nil) then

-      fMipmapFonts[Level].SetGlyphSpacing(Spacing / GetMipmapScale(Level));

-end;

-

-function TScalableFont.GetGlyphSpacing(): single;

-begin

-  Result := fBaseFont.GetGlyphSpacing() * fScale;

-end;

-

-procedure TScalableFont.SetReflectionSpacing(Spacing: single);

-var

-  Level: integer;

-begin

-  for Level := 0 to High(fMipmapFonts) do

-    if (fMipmapFonts[Level] <> nil) then

-      fMipmapFonts[Level].SetReflectionSpacing(Spacing / GetMipmapScale(Level));

-end;

-

-function TScalableFont.GetReflectionSpacing(): single;

-begin

-  Result := fBaseFont.GetLineSpacing() * fScale;

-end;

-

-procedure TScalableFont.SetStyle(Style: TFontStyle);

-var

-  Level: integer;

-begin

-  for Level := 0 to High(fMipmapFonts) do

-    if (fMipmapFonts[Level] <> nil) then

-      fMipmapFonts[Level].SetStyle(Style);

-end;

-

-function TScalableFont.GetStyle(): TFontStyle;

-begin

-  Result := fBaseFont.GetStyle();

-end;

-

-function TScalableFont.GetUnderlinePosition(): single;

-begin

-  Result := fBaseFont.GetUnderlinePosition();

-end;

-

-function TScalableFont.GetUnderlineThickness(): single;

-begin

-  Result := fBaseFont.GetUnderlinePosition();

-end;

-

-procedure TScalableFont.SetUseKerning(Enable: boolean);

-var

-  Level: integer;

-begin

-  for Level := 0 to High(fMipmapFonts) do

-    if (fMipmapFonts[Level] <> nil) then

-      fMipmapFonts[Level].SetUseKerning(Enable);

-end;

-

-

-{*

- * TCachedFont

- *}

-

-constructor TCachedFont.Create();

-begin

-  inherited;

-  fCache := TGlyphCache.Create();

-end;

-

-destructor TCachedFont.Destroy();

-begin

-  fCache.Free;

-  inherited;

-end;

-

-function TCachedFont.GetGlyph(ch: WideChar): TGlyph;

-begin

-  Result := fCache.GetGlyph(ch);

-  if (Result = nil) then

-  begin

-    Result := LoadGlyph(ch);

-    if (not fCache.AddGlyph(ch, Result)) then

-      Result.Free;

-  end;

-end;

-

-procedure TCachedFont.FlushCache(KeepBaseSet: boolean);

-begin

-  fCache.FlushCache(KeepBaseSet);

-end;

-

-

-{*

- * TFTFont

- *}

-

-constructor TFTFont.Create(

-    const Filename: string;

-    Size: integer; Outset: single;

-    LoadFlags: FT_Int32);

-var

-  i: WideChar;

-begin

-  inherited Create();

-

-  fFilename := Filename;

-  fSize := Size;

-  fOutset := Outset;

-  fLoadFlags := LoadFlags;

-  fUseDisplayLists := true;

-

-  // load font information

-  if (FT_New_Face(TFreeType.GetLibrary(), PChar(Filename), 0, fFace) <> 0) then

-    raise Exception.Create('FT_New_Face: Could not load font '''  + Filename + '''');

-

-  // support scalable fonts only

-  if (not FT_IS_SCALABLE(fFace)) then

-    raise Exception.Create('Font is not scalable');

-

-  if (FT_Set_Pixel_Sizes(fFace, 0, Size) <> 0) then

-    raise Exception.Create('FT_Set_Pixel_Sizes failes');

-

-  // get scale factor for font-unit to pixel-size transformation

-  fFontUnitScale.X := fFace.size.metrics.x_ppem / fFace.units_per_EM;

-  fFontUnitScale.Y := fFace.size.metrics.y_ppem / fFace.units_per_EM;

-

-  ResetIntern();

-

-  // pre-cache some commonly used glyphs (' ' - '~')

-  for i := #32 to #126 do

-    fCache.AddGlyph(i, TFTGlyph.Create(Self, i, Outset, LoadFlags));

-end;

-

-destructor TFTFont.Destroy();

-begin

-  // free face

-  FT_Done_Face(fFace);

-  inherited;

-end;

-

-procedure TFTFont.ResetIntern();

-begin

-  // Note: outset and non outset fonts use same spacing

-  fLineSpacing := fFace.height * fFontUnitScale.Y;

-  fReflectionSpacing := -2*fFace.descender * fFontUnitScale.Y;

-end;

-

-procedure TFTFont.Reset();

-begin

-  inherited;

-  ResetIntern();

-end;

-

-function TFTFont.LoadGlyph(ch: WideChar): TGlyph;

-begin

-  Result := TFTGlyph.Create(Self, ch, Outset, fLoadFlags);

-end;

-

-function TFTFont.BBox(const Text: TWideStringArray; Advance: boolean): TBoundsDbl;

-var

-  Glyph, PrevGlyph: TFTGlyph;

-  TextLine: WideString;

-  LineYOffset: single;

-  LineIndex, CharIndex: integer;

-  LineBounds: TBoundsDbl;

-  KernDelta: FT_Vector;

-  UnderlinePos: double;

-begin

-  // Reset global bounds

-  Result.Left   := Infinity;

-  Result.Right  := 0;

-  Result.Bottom := Infinity;

-  Result.Top    := 0;

-

-  // reset last glyph

-  PrevGlyph := nil;

-

-  // display text

-  for LineIndex := 0 to High(Text) do

-  begin

-    // get next text line

-    TextLine := Text[LineIndex];

-    LineYOffset := -LineSpacing * LineIndex;

-

-    // reset line bounds

-    LineBounds.Left   := Infinity;

-    LineBounds.Right  := 0;

-    LineBounds.Bottom := Infinity;

-    LineBounds.Top    := 0;

-

-    // for each glyph image, compute its bounding box

-    for CharIndex := 1 to Length(TextLine) do

-    begin

-      Glyph := TFTGlyph(GetGlyph(TextLine[CharIndex]));

-      if (Glyph <> nil) then

-      begin

-        // get kerning

-        if (fUseKerning and FT_HAS_KERNING(fFace) and (PrevGlyph <> nil)) then

-        begin

-          FT_Get_Kerning(fFace, PrevGlyph.CharIndex, Glyph.CharIndex,

-                         FT_KERNING_UNSCALED, KernDelta);

-          LineBounds.Right := LineBounds.Right + KernDelta.x * fFontUnitScale.X;

-        end;

-

-        // update left bound (must be done before right bound is updated)

-        if (LineBounds.Right + Glyph.Bounds.Left < LineBounds.Left) then

-          LineBounds.Left := LineBounds.Right + Glyph.Bounds.Left;

-

-        // update right bound

-        if (CharIndex < Length(TextLine)) or  // not the last character

-           (TextLine[CharIndex] = ' ') or     // on space char (Bounds.Right = 0)

-           Advance then                       // or in advance mode

-        begin

-          // add advance and glyph spacing

-          LineBounds.Right := LineBounds.Right + Glyph.Advance.x + GlyphSpacing

-        end

-        else

-        begin

-          // add glyph's right bound

-          LineBounds.Right := LineBounds.Right + Glyph.Bounds.Right;

-        end;

-

-        // update bottom and top bounds

-        if (Glyph.Bounds.Bottom < LineBounds.Bottom) then

-          LineBounds.Bottom := Glyph.Bounds.Bottom;

-        if (Glyph.Bounds.Top > LineBounds.Top) then

-          LineBounds.Top := Glyph.Bounds.Top;

-      end;

-

-      PrevGlyph := Glyph;

-    end;

-

-    // handle italic font style

-    if (Italic in Style) then

-    begin

-      LineBounds.Left := LineBounds.Left + LineBounds.Bottom * cShearFactor;

-      LineBounds.Right := LineBounds.Right + LineBounds.Top * cShearFactor;

-    end;

-

-    // handle underlined font style

-    if (Underline in Style) then

-    begin

-      UnderlinePos := GetUnderlinePosition();

-      if (UnderlinePos < LineBounds.Bottom) then

-        LineBounds.Bottom := UnderlinePos;

-    end;

-

-    // add line offset

-    LineBounds.Bottom := LineBounds.Bottom + LineYOffset;

-    LineBounds.Top := LineBounds.Top + LineYOffset;

-

-    // adjust global bounds

-    if (Result.Left > LineBounds.Left) then

-      Result.Left := LineBounds.Left;

-    if (Result.Right < LineBounds.Right) then

-      Result.Right := LineBounds.Right;

-    if (Result.Bottom > LineBounds.Bottom) then

-      Result.Bottom := LineBounds.Bottom;

-    if (Result.Top < LineBounds.Top) then

-      Result.Top := LineBounds.Top;

-  end;

-

-  // if left or bottom bound was not set, set them to 0

-  if (Result.Left = Infinity) then

-    Result.Left := 0.0;

-  if (Result.Bottom = Infinity) then

-    Result.Bottom := 0.0;

-end;

-

-procedure TFTFont.Render(const Text: WideString);

-var

-  CharIndex: integer;

-  Glyph, PrevGlyph: TFTGlyph;

-  KernDelta: FT_Vector;

-begin

-  // reset last glyph

-  PrevGlyph := nil;

-

-  // draw current line

-  for CharIndex := 1 to Length(Text) do

-  begin

-    Glyph := TFTGlyph(GetGlyph(Text[CharIndex]));

-    if (Assigned(Glyph)) then

-    begin

-      // get kerning

-      if (fUseKerning and FT_HAS_KERNING(fFace) and (PrevGlyph <> nil)) then

-      begin

-        FT_Get_Kerning(fFace, PrevGlyph.CharIndex, Glyph.CharIndex,

-                       FT_KERNING_UNSCALED, KernDelta);

-        glTranslatef(KernDelta.x * fFontUnitScale.X, 0, 0);

-      end;

-

-      if (ReflectionPass) then

-        Glyph.RenderReflection()

-      else

-        Glyph.Render(fUseDisplayLists);

-

-      glTranslatef(Glyph.Advance.x + fGlyphSpacing, 0, 0);

-    end;

-

-    PrevGlyph := Glyph;

-  end;

-end;

-

-function TFTFont.GetHeight(): single;

-begin

-  Result := Ascender - Descender;

-end;

-

-function TFTFont.GetAscender(): single;

-begin

-  Result := fFace.ascender * fFontUnitScale.Y + Outset*2;

-end;

-

-function TFTFont.GetDescender(): single;

-begin

-  // Note: outset is not part of the descender as the baseline is lifted

-  Result := fFace.descender * fFontUnitScale.Y;

-end;

-

-function TFTFont.GetUnderlinePosition(): single;

-begin

-  Result := fFace.underline_position * fFontUnitScale.Y - Outset;

-end;

-

-function TFTFont.GetUnderlineThickness(): single;

-begin

-  Result := fFace.underline_thickness * fFontUnitScale.Y + Outset*2;

-end;

-

-

-{*

- * TFTScalableFont

- *}

-

-constructor TFTScalableFont.Create(const Filename: string;

-                   Size: integer; OutsetAmount: single;

-                   UseMipmaps: boolean);

-var

-  LoadFlags: FT_Int32;

-begin

-  LoadFlags := FT_LOAD_DEFAULT;

-  // Disable hinting and grid-fitting to preserve font outlines at each font

-  // size, otherwise the font widths/heights do not match resulting in ugly

-  // text size changes during zooming.

-  // A drawback is a reduced quality with smaller font sizes but it is not that

-  // bad with gray-scaled rendering (at least it looks better than OpenGL's

-  // linear downscaling on minification).

-  if (UseMipmaps) then

-    LoadFlags := LoadFlags or FT_LOAD_NO_HINTING;

-  inherited Create(

-      TFTFont.Create(Filename, Size, Size * OutsetAmount, LoadFlags),

-      UseMipmaps);

-end;

-

-function TFTScalableFont.CreateMipmap(Level: integer; Scale: single): TFont;

-var

-  ScaledSize: integer;

-  BaseFont: TFTFont;

-begin

-  Result := nil;

-  BaseFont := TFTFont(fBaseFont);

-  ScaledSize := Round(BaseFont.Size * Scale);

-  // do not create mipmap fonts < 8 pixels

-  if (ScaledSize < 8) then

-    Exit;

-  Result := TFTFont.Create(BaseFont.fFilename,

-      ScaledSize, BaseFont.fOutset * Scale,

-      FT_LOAD_DEFAULT or FT_LOAD_NO_HINTING);

-end;

-

-function TFTScalableFont.GetOutset(): single;

-begin

-  Result := TFTFont(fBaseFont).Outset * fScale;

-end;

-

-procedure TFTScalableFont.FlushCache(KeepBaseSet: boolean);

-var

-  Level: integer;

-begin

-  for Level := 0 to High(fMipmapFonts) do

-    if (fMipmapFonts[Level] <> nil) then

-      TFTFont(fMipmapFonts[Level]).FlushCache(KeepBaseSet);

-end;

-

-

-{*

- * TOutlineFont

- *}

-

-constructor TFTOutlineFont.Create(

-    const Filename: string;

-    Size: integer; Outset: single;

-    LoadFlags: FT_Int32);

-begin

-  inherited Create();

-

-  fFilename := Filename;

-  fSize := Size;

-  fOutset := Outset;

-

-  fInnerFont := TFTFont.Create(Filename, Size, 0.0, LoadFlags);

-  fOutlineFont := TFTFont.Create(Filename, Size, Outset, LoadFlags);

-

-  ResetIntern();

-end;

-

-destructor TFTOutlineFont.Destroy;

-begin

-  fOutlineFont.Free;

-  fInnerFont.Free;

-  inherited;

-end;

-

-procedure TFTOutlineFont.ResetIntern();

-begin

-  // TODO: maybe swap fInnerFont/fOutlineFont.GlyphSpacing to use the spacing

-  // of the outline font?

-  //fInnerFont.GlyphSpacing := fOutset*2;

-  fOutlineFont.GlyphSpacing := -fOutset*2;

-

-  fLineSpacing := fOutlineFont.LineSpacing;

-  fReflectionSpacing := fOutlineFont.ReflectionSpacing;

-  fOutlineColor := NewGLColor(0, 0, 0, 1);

-end;

-

-procedure TFTOutlineFont.Reset();

-begin

-  inherited;

-  fInnerFont.Reset();

-  fOutlineFont.Reset();

-  ResetIntern();

-end;

-

-procedure TFTOutlineFont.DrawUnderline(const Text: WideString);

-begin

-  glPushAttrib(GL_CURRENT_BIT);

-  glColor4fv(@fOutlineColor.vals);

-  fOutlineFont.DrawUnderline(Text);

-  glPopAttrib();

-

-  glPushMatrix();

-  glTranslatef(fOutset, 0, 0);

-  fInnerFont.DrawUnderline(Text);

-  glPopMatrix();

-end;

-

-procedure TFTOutlineFont.Render(const Text: WideString);

-begin

-  { setup and render outline font }

-

-  // save old color

-  glPushAttrib(GL_CURRENT_BIT);

-  glColor4fv(@fOutlineColor.vals);

-  glPushMatrix();

-  fOutlineFont.Render(Text);

-  glPopMatrix();

-  glPopAttrib();

-

-  { setup and render inner font }

-

-  glPushMatrix();

-  glTranslatef(fOutset, fOutset, 0);

-  fInnerFont.Render(Text);

-  glPopMatrix();

-end;

-

-procedure TFTOutlineFont.SetOutlineColor(r, g, b: GLfloat; a: GLfloat);

-begin

-  fOutlineColor := NewGLColor(r, g, b, a);

-end;

-

-procedure TFTOutlineFont.FlushCache(KeepBaseSet: boolean);

-begin

-  fOutlineFont.FlushCache(KeepBaseSet);

-  fInnerFont.FlushCache(KeepBaseSet);

-end;

-

-function TFTOutlineFont.BBox(const Text: TWideStringArray; Advance: boolean): TBoundsDbl;

-begin

-  Result := fOutlineFont.BBox(Text, Advance);

-end;

-

-function TFTOutlineFont.GetHeight(): single;

-begin

-  Result := fOutlineFont.Height;

-end;

-

-function TFTOutlineFont.GetAscender(): single;

-begin

-  Result := fOutlineFont.Ascender;

-end;

-

-function TFTOutlineFont.GetDescender(): single;

-begin

-  Result := fOutlineFont.Descender;

-end;

-

-procedure TFTOutlineFont.SetLineSpacing(Spacing: single);

-begin

-  inherited SetLineSpacing(Spacing);

-  fInnerFont.LineSpacing := Spacing;

-  fOutlineFont.LineSpacing := Spacing;

-end;

-

-procedure TFTOutlineFont.SetGlyphSpacing(Spacing: single);

-begin

-  inherited SetGlyphSpacing(Spacing);

-  fInnerFont.GlyphSpacing := Spacing;

-  fOutlineFont.GlyphSpacing := Spacing - Outset*2;

-end;

-

-procedure TFTOutlineFont.SetReflectionSpacing(Spacing: single);

-begin

-  inherited SetReflectionSpacing(Spacing);

-  fInnerFont.ReflectionSpacing := Spacing;

-  fOutlineFont.ReflectionSpacing := Spacing;

-end;

-

-procedure TFTOutlineFont.SetStyle(Style: TFontStyle);

-begin

-  inherited SetStyle(Style);

-  fInnerFont.Style := Style;

-  fOutlineFont.Style := Style;

-end;

-

-function TFTOutlineFont.GetStyle(): TFontStyle;

-begin

-  Result := inherited GetStyle();

-end;

-

-function TFTOutlineFont.GetUnderlinePosition(): single;

-begin

-  Result := fOutlineFont.GetUnderlinePosition();

-end;

-

-function TFTOutlineFont.GetUnderlineThickness(): single;

-begin

-  Result := fOutlineFont.GetUnderlinePosition();

-end;

-

-procedure TFTOutlineFont.SetUseKerning(Enable: boolean);

-begin

-  inherited SetUseKerning(Enable);

-  fInnerFont.fUseKerning := Enable;

-  fOutlineFont.fUseKerning := Enable;

-end;

-

-procedure TFTOutlineFont.SetReflectionPass(Enable: boolean);

-begin

-  inherited SetReflectionPass(Enable);

-  fInnerFont.fReflectionPass := Enable;

-  fOutlineFont.fReflectionPass := Enable;

-end;

-

-{**

- * TScalableOutlineFont

- *}

-

-constructor TFTScalableOutlineFont.Create(

-    const Filename: string;

-    Size: integer; OutsetAmount: single;

-    UseMipmaps: boolean);

-var

-  LoadFlags: FT_Int32;

-begin

-  LoadFlags := FT_LOAD_DEFAULT;

-  // Disable hinting and grid-fitting (see TFTScalableFont.Create)

-  if (UseMipmaps) then

-    LoadFlags := LoadFlags or FT_LOAD_NO_HINTING;

-  inherited Create(

-      TFTOutlineFont.Create(Filename, Size, Size*OutsetAmount, LoadFlags),

-      UseMipmaps);

-end;

-

-function TFTScalableOutlineFont.CreateMipmap(Level: integer; Scale: single): TFont;

-var

-  ScaledSize: integer;

-  BaseFont: TFTOutlineFont;

-begin

-  Result := nil;

-  BaseFont := TFTOutlineFont(fBaseFont);

-  ScaledSize := Round(BaseFont.Size*Scale);

-  // do not create mipmap fonts < 8 pixels

-  if (ScaledSize < 8) then

-    Exit;

-  Result := TFTOutlineFont.Create(BaseFont.fFilename,

-      ScaledSize, BaseFont.fOutset*Scale,

-      FT_LOAD_DEFAULT or FT_LOAD_NO_HINTING);

-end;

-

-function TFTScalableOutlineFont.GetOutset(): single;

-begin

-  Result := TFTOutlineFont(fBaseFont).Outset * fScale;

-end;

-

-procedure TFTScalableOutlineFont.SetOutlineColor(r, g, b: GLfloat; a: GLfloat);

-var

-  Level: integer;

-begin

-  for Level := 0 to High(fMipmapFonts) do

-    if (fMipmapFonts[Level] <> nil) then

-      TFTOutlineFont(fMipmapFonts[Level]).SetOutlineColor(r, g, b, a);

-end;

-

-procedure TFTScalableOutlineFont.FlushCache(KeepBaseSet: boolean);

-var

-  Level: integer;

-begin

-  for Level := 0 to High(fMipmapFonts) do

-    if (fMipmapFonts[Level] <> nil) then

-      TFTOutlineFont(fMipmapFonts[Level]).FlushCache(KeepBaseSet);

-end;

-

-

-{*

- * TFTGlyph

- *}

-

-const

-  {**

-   * Size of the transparent border surrounding the glyph image in the texture.

-   * The border is necessary because OpenGL does not smooth texels at the

-   * border of a texture with the GL_CLAMP or GL_CLAMP_TO_EDGE styles.

-   * Without the border, magnified glyph textures look very ugly at their edges.

-   * It looks edgy, as if some pixels are missing especially on the left edge

-   * (just set cTexSmoothBorder to 0 to see what is meant by this).

-   * With the border even the glyphs edges are blended to the border (transparent)

-   * color and everything looks nice.

-   *

-   * Note:

-   * OpenGL already supports texture border by setting the border parameter

-   * of glTexImage*D() to 1 and using a texture size of 2^m+2b and setting the

-   * border pixels to the border color. In some forums it is discouraged to use

-   * the border parameter as only a few of the more modern graphics cards support

-   * this feature. On an ATI Radeon 9700 card, the slowed down to 0.5 fps and

-   * the glyph's background got black.  So instead of using this feature we

-   * handle it on our own. The only drawback is that textures might get bigger

-   * because the border might require a higher power of 2 size instead of just

-   * two additional pixels.

-   *}

-  cTexSmoothBorder = 1;

-

-procedure TFTGlyph.Extrude(var TexBuffer: TGLubyteDynArray; Outset: single);

-

-  procedure SetToMax(var Val1: GLubyte; Val2: GLubyte); {$IFDEF HasInline}inline;{$ENDIF}

-  begin

-    if (Val1 < Val2) then

-      Val1 := Val2;

-  end;

-

-var

-  I, X, Y: integer;

-  SrcBuffer,TmpBuffer: TGLubyteDynArray;

-  TexLine, TexLinePrev, TexLineNext: PGLubyteArray;

-  SrcLine: PGLubyteArray;

-  AlphaScale: single;

-  Value, ValueNeigh, ValueDiag: GLubyte;

-const

-  // square-root of 2 used for diagonal neighbor pixels

-  cSqrt2 = 1.4142;

-  // number of ignored pixels on each edge of the bitmap. Consists of:

-  // - border used for font smoothing and

-  // - outer (extruded) bitmap pixel (because it is just written but never read)

-  cBorder = cTexSmoothBorder + 1;

-begin

-  // allocate memory for temporary buffer

-  SetLength(SrcBuffer, Length(TexBuffer));

-  FillChar(SrcBuffer[0], Length(TexBuffer), 0);

-

-  // extrude pixel by pixel

-  for I := 1 to Ceil(Outset) do

-  begin

-    // swap arrays

-    TmpBuffer := TexBuffer;

-    TexBuffer := SrcBuffer;

-    SrcBuffer := TmpBuffer;

-

-    // as long as we add an entire pixel of outset, use a solid color.

-    // If the fractional part is reached blend, e.g. outline=3.2 -> 3 solid

-    // pixels and one blended with alpha=0.2.

-    // For the fractional part I = Ceil(Outset) is always true.

-    if (I <= Outset) then

-      AlphaScale := 1

-    else

-      AlphaScale := Outset - Trunc(Outset);

-

-    // copy data to the expanded bitmap.

-    for Y := cBorder to fTexSize.Height - 2*cBorder do

-    begin

-      TexLine     := @TexBuffer[Y*fTexSize.Width];

-      TexLinePrev := @TexBuffer[(Y-1)*fTexSize.Width];

-      TexLineNext := @TexBuffer[(Y+1)*fTexSize.Width];

-      SrcLine     := @SrcBuffer[Y*fTexSize.Width];

-

-      // expand current line's pixels

-      for X := cBorder to fTexSize.Width - 2*cBorder do

-      begin

-        Value := SrcLine[X];

-        ValueNeigh := Round(Value * AlphaScale);

-        ValueDiag := Round(ValueNeigh / cSqrt2);

-

-        SetToMax(TexLine[X],   Value);

-        SetToMax(TexLine[X-1], ValueNeigh);

-        SetToMax(TexLine[X+1], ValueNeigh);

-

-        SetToMax(TexLinePrev[X],   ValueNeigh);

-        SetToMax(TexLinePrev[X-1], ValueDiag);

-        SetToMax(TexLinePrev[X+1], ValueDiag);

-

-        SetToMax(TexLineNext[X],   ValueNeigh);

-        SetToMax(TexLineNext[X-1], ValueDiag);

-        SetToMax(TexLineNext[X+1], ValueDiag);

-      end;

-    end;

-  end;

-

-  TmpBuffer := nil;

-  SetLength(SrcBuffer, 0);

-end;

-

-procedure TFTGlyph.CreateTexture(LoadFlags: FT_Int32);

-var

-  X, Y:          integer;

-  Glyph:         FT_Glyph;

-  BitmapGlyph:   FT_BitmapGlyph;

-  Bitmap:        PFT_Bitmap;

-  BitmapLine:    PChar;

-  BitmapBuffer:  PChar;

-  TexBuffer:     TGLubyteDynArray;

-  TexLine:       PGLubyteArray;

-  CBox:          FT_BBox;

-begin

-  // load the Glyph for our character

-  if (FT_Load_Glyph(fFont.Face, fCharIndex, LoadFlags) <> 0) then

-    raise Exception.Create('FT_Load_Glyph failed');

-

-  // move the face's glyph into a Glyph object

-  if (FT_Get_Glyph(fFont.Face^.glyph, Glyph) <> 0) then

-    raise Exception.Create('FT_Get_Glyph failed');

-

-  // store scaled advance width/height in glyph-object

-  fAdvance.X := fFont.Face^.glyph^.advance.x / 64 + fOutset*2;

-  fAdvance.Y := fFont.Face^.glyph^.advance.y / 64 + fOutset*2;

-

-  // get the contour's bounding box (in 1/64th pixels, not font-units)

-  FT_Glyph_Get_CBox(Glyph, FT_GLYPH_BBOX_UNSCALED, CBox);

-  // convert 1/64th values to double values

-  fBounds.Left   := CBox.xMin / 64;

-  fBounds.Right  := CBox.xMax / 64 + fOutset*2;

-  fBounds.Bottom := CBox.yMin / 64;

-  fBounds.Top    := CBox.yMax / 64 + fOutset*2;

-

-  // convert the glyph to a bitmap (and destroy original glyph image)

-  FT_Glyph_To_Bitmap(Glyph, ft_render_mode_normal, nil, 1);

-  BitmapGlyph := FT_BitmapGlyph(Glyph);

-

-  // get bitmap offsets

-  fBitmapCoords.Left := BitmapGlyph^.left - cTexSmoothBorder;

-  // Note: add 1*fOutset for lifting the baseline so outset fonts to not intersect

-  // with the baseline; Ceil(fOutset) for the outset pixels added to the bitmap.

-  fBitmapCoords.Top  := BitmapGlyph^.top + fOutset+Ceil(fOutset) + cTexSmoothBorder;

-

-  // make accessing the bitmap easier

-  Bitmap := @BitmapGlyph^.bitmap;

-  // get bitmap dimensions

-  fBitmapCoords.Width  := Bitmap.width + (Ceil(fOutset) + cTexSmoothBorder)*2;

-  fBitmapCoords.Height := Bitmap.rows + (Ceil(fOutset) + cTexSmoothBorder)*2;

-

-  // get power-of-2 bitmap widths

-  fTexSize.Width  :=

-      NextPowerOf2(Bitmap.width + (Ceil(fOutset) + cTexSmoothBorder)*2);

-  fTexSize.Height :=

-      NextPowerOf2(Bitmap.rows + (Ceil(fOutset) + cTexSmoothBorder)*2);

-

-  // texture-widths ignoring empty (power-of-2) padding space

-  fTexOffset.X := fBitmapCoords.Width / fTexSize.Width;

-  fTexOffset.Y := fBitmapCoords.Height / fTexSize.Height;

-

-  // allocate memory for texture data

-  SetLength(TexBuffer, fTexSize.Width * fTexSize.Height);

-  FillChar(TexBuffer[0], Length(TexBuffer), 0);

-

-  // Freetype stores the bitmap with either upper (pitch is > 0) or lower

-  // (pitch < 0) glyphs line first. Set the buffer to the upper line.

-  // See http://freetype.sourceforge.net/freetype2/docs/glyphs/glyphs-7.html

-  if (Bitmap.pitch > 0) then

-    BitmapBuffer := @Bitmap.buffer[0]

-  else

-    BitmapBuffer := @Bitmap.buffer[(Bitmap.rows-1) * Abs(Bitmap.pitch)];

-

-  // copy data to texture bitmap (upper line first).

-  for Y := 0 to Bitmap.rows-1 do

-  begin

-    // set pointer to first pixel in line that holds bitmap data.

-    // Each line starts with a cTexSmoothBorder pixel and multiple outset pixels

-    // that are added by Extrude() later.

-    TexLine := @TexBuffer[(Y + cTexSmoothBorder + Ceil(fOutset)) * fTexSize.Width +

-                          cTexSmoothBorder + Ceil(fOutset)];

-    // get next lower line offset, use pitch instead of width as it tells

-    // us the storage direction of the lines. In addition a line might be padded.

-    BitmapLine := @BitmapBuffer[Y * Bitmap.pitch];

-    for X := 0 to Bitmap.width-1 do

-      TexLine[X] := GLubyte(BitmapLine[X]);

-  end;

-

-  if (fOutset > 0) then

-    Extrude(TexBuffer, fOutset);

-

-  // allocate resources for textures and display lists

-  glGenTextures(1, @fTexture);

-

-  // setup texture paramaters

-  glBindTexture(GL_TEXTURE_2D, fTexture);

-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);

-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

-

-  glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

-  // create alpha-map (GL_ALPHA component only).

-  // TexCoord (0,0) corresponds to the top left pixel of the glyph,

-  // (1,1) to the bottom right pixel. So the glyph is flipped as OpenGL uses

-  // a cartesian (y-axis up) coordinate system for textures.   

-  // See the cTexSmoothBorder comment for info on texture borders.

-  glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, fTexSize.Width, fTexSize.Height,

-      0, GL_ALPHA, GL_UNSIGNED_BYTE, @TexBuffer[0]);

-

-  // free expanded data

-  SetLength(TexBuffer, 0);

-

-  // create the display list

-  fDisplayList := glGenLists(1);

-

-  // render to display-list

-  glNewList(fDisplayList, GL_COMPILE);

-    Render(false);

-  glEndList();

-

-  // free glyph data (bitmap, etc.)

-  FT_Done_Glyph(Glyph);

-end;

-

-constructor TFTGlyph.Create(Font: TFTFont; ch: WideChar; Outset: single;

-    LoadFlags: FT_Int32);

-begin

-  inherited Create();

-

-  fFont := Font;

-  fOutset := Outset;

-

-  // get the Freetype char-index (use default UNICODE charmap)

-  fCharIndex := FT_Get_Char_Index(Font.fFace, FT_ULONG(ch));

-

-  CreateTexture(LoadFlags);

-end;

-

-destructor TFTGlyph.Destroy;

-begin

-  if (fDisplayList <> 0) then

-    glDeleteLists(fDisplayList, 1);

-  if (fTexture <> 0) then

-    glDeleteTextures(1, @fTexture);

-  inherited;

-end;

-

-procedure TFTGlyph.Render(UseDisplayLists: boolean);

-begin

-  // use display-lists if enabled and exit

-  if (UseDisplayLists) then

-  begin

-    glCallList(fDisplayList);

-    Exit;

-  end;

-

-  glBindTexture(GL_TEXTURE_2D, fTexture);

-  glPushMatrix();

-

-  // move to top left glyph position

-  glTranslatef(fBitmapCoords.Left, fBitmapCoords.Top, 0);

-

-  // draw glyph texture

-  glBegin(GL_QUADS);

-    // top right

-    glTexCoord2f(fTexOffset.X, 0);

-    glVertex2f(fBitmapCoords.Width, 0);

-

-    // top left

-    glTexCoord2f(0, 0);

-    glVertex2f(0, 0);

-

-    // bottom left

-    glTexCoord2f(0, fTexOffset.Y);

-    glVertex2f(0, -fBitmapCoords.Height);

-

-    // bottom right

-    glTexCoord2f(fTexOffset.X, fTexOffset.Y);

-    glVertex2f(fBitmapCoords.Width, -fBitmapCoords.Height);

-  glEnd();

-

-  glPopMatrix();

-end;

-

-procedure TFTGlyph.RenderReflection();

-var

-  Color: TGLColor;

-  TexUpperPos: single;

-  TexLowerPos: single;

-  UpperPos: single;

-const

-  CutOff = 0.6;

-begin

-  glPushMatrix();

-  glBindTexture(GL_TEXTURE_2D, fTexture);

-  glGetFloatv(GL_CURRENT_COLOR, @Color.vals);

-

-  // add extra space to the left of the glyph

-  glTranslatef(fBitmapCoords.Left, 0, 0);

-

-  // The upper position of the glyph, if CutOff is 1.0, it is fFont.Ascender.

-  // If CutOff is set to 0.5 only half of the glyph height is displayed.

-  UpperPos := fFont.Descender + fFont.Height * CutOff;

-

-  // the glyph texture's height is just the height of the glyph but not the font

-  // height. Setting a color for the upper and lower bounds of the glyph results

-  // in different color gradients. So we have to set the color values for the

-  // descender and ascender (as we have a cutoff, for the upper-pos here) as

-  // these positions are font but not glyph specific.

-

-  // To get the texture positions we have to enhance the texture at the top and

-  // bottom by the amount from the top to ascender (rather upper-pos here) and

-  // from the bottom (Height-Top) to descender. Then we have to convert those

-  // heights to texture coordinates by dividing by the bitmap Height and

-  // removing the power-of-2 padding space by multiplying with fTexOffset.Y

-  // (as fBitmapCoords.Height corresponds to fTexOffset.Y and not 1.0).

-  TexUpperPos  := -(UpperPos - fBitmapCoords.Top) / fBitmapCoords.Height * fTexOffset.Y;

-  TexLowerPos := (-(fFont.Descender + fBitmapCoords.Height - fBitmapCoords.Top) /

-                    fBitmapCoords.Height + 1) * fTexOffset.Y;

-

-  // draw glyph texture

-  glBegin(GL_QUADS);

-    // top right

-    glColor4f(Color.r, Color.g, Color.b, 0);

-    glTexCoord2f(fTexOffset.X, TexUpperPos);

-    glVertex2f(fBitmapCoords.Width, UpperPos);

-

-    // top left

-    glTexCoord2f(0, TexUpperPos);

-    glVertex2f(0, UpperPos);

-

-    // bottom left

-    glColor4f(Color.r, Color.g, Color.b, Color.a-0.3);

-    glTexCoord2f(0, TexLowerPos);

-    glVertex2f(0, fFont.Descender);

-

-    // bottom right

-    glTexCoord2f(fTexOffset.X, TexLowerPos);

-    glVertex2f(fBitmapCoords.Width, fFont.Descender);

-  glEnd();

-

-  glPopMatrix();

-

-  // restore old color

-  // Note: glPopAttrib(GL_CURRENT_BIT)/glPopAttrib() is much slower then

-  // glGetFloatv(GL_CURRENT_COLOR, ...)/glColor4fv(...)

-  glColor4fv(@Color.vals);

-end;

-

-function TFTGlyph.GetAdvance(): TPositionDbl;

-begin

-  Result := fAdvance;

-end;

-

-function TFTGlyph.GetBounds(): TBoundsDbl;

-begin

-  Result := fBounds;

-end;

-

-

-{*

- * TGlyphCache

- *}

-

-constructor TGlyphCache.Create();

-begin

-  inherited;

-  fHash := TList.Create();

-end;

-

-destructor TGlyphCache.Destroy();

-begin

-  // free cached glyphs

-  FlushCache(false);

-

-  // destroy TList

-  fHash.Free;

-  

-  inherited;

-end;

-

-function TGlyphCache.FindGlyphTable(BaseCode: cardinal; out InsertPos: integer): PGlyphTable;

-var

-  I: integer;

-  Entry: TGlyphCacheHashEntry;

-begin

-  Result := nil;

-

-  for I := 0 to fHash.Count-1 do

-  begin

-    Entry := TGlyphCacheHashEntry(fHash[I]);

-

-    if (Entry.BaseCode > BaseCode) then

-    begin

-      InsertPos := I;

-      Exit;

-    end;

-

-    if (Entry.BaseCode = BaseCode) then

-    begin

-      InsertPos := I;

-      Result := @Entry.GlyphTable;

-      Exit;

-    end;

-  end;

-

-  InsertPos := fHash.Count;

-end;

-

-function TGlyphCache.AddGlyph(ch: WideChar; const Glyph: TGlyph): boolean;

-var

-  BaseCode:  cardinal;

-  GlyphCode: integer;

-  InsertPos: integer;

-  GlyphTable: PGlyphTable;

-  Entry: TGlyphCacheHashEntry;

-begin

-  Result := false;

-

-  BaseCode := cardinal(ch) shr 8;

-  GlyphTable := FindGlyphTable(BaseCode, InsertPos);

-  if (GlyphTable = nil) then

-  begin

-    Entry := TGlyphCacheHashEntry.Create(BaseCode);

-    GlyphTable := @Entry.GlyphTable;

-    fHash.Insert(InsertPos, Entry);

-  end;

-

-  // get glyph table offset

-  GlyphCode := cardinal(ch) and $FF;

-  // insert glyph into table if not present

-  if (GlyphTable[GlyphCode] = nil) then

-  begin

-    GlyphTable[GlyphCode] := Glyph;

-    Result := true;

-  end;

-end;

-

-procedure TGlyphCache.DeleteGlyph(ch: WideChar);

-var

-  Table: PGlyphTable;

-  TableIndex, GlyphIndex: integer;

-  TableEmpty: boolean;

-begin

-  // find table

-  Table := FindGlyphTable(cardinal(ch) shr 8, TableIndex);

-  if (Table = nil) then

-    Exit;

-

-  // find glyph    

-  GlyphIndex := cardinal(ch) and $FF;

-  if (Table[GlyphIndex] <> nil) then

-  begin

-    // destroy glyph

-    FreeAndNil(Table[GlyphIndex]);

-

-    // check if table is empty

-    TableEmpty := true;

-    for GlyphIndex := 0 to High(Table^) do

-    begin

-      if (Table[GlyphIndex] <> nil) then

-      begin

-        TableEmpty := false;

-        Break;

-      end;

-    end;

-

-    // free empty table

-    if (TableEmpty) then

-    begin

-      fHash.Delete(TableIndex);

-    end;

-  end;

-end;

-

-function TGlyphCache.GetGlyph(ch: WideChar): TGlyph;

-var

-  InsertPos: integer;

-  Table: PGlyphTable;

-begin

-  Table := FindGlyphTable(cardinal(ch) shr 8, InsertPos);

-  if (Table = nil) then

-    Result := nil

-  else

-    Result := Table[cardinal(ch) and $FF];

-end;

-

-function TGlyphCache.HasGlyph(ch: WideChar): boolean;

-begin

-  Result := (GetGlyph(ch) <> nil);

-end;

-

-procedure TGlyphCache.FlushCache(KeepBaseSet: boolean);

-var

-  EntryIndex, TableIndex: integer;

-  Entry: TGlyphCacheHashEntry;

-begin

-  // destroy cached glyphs

-  for EntryIndex := 0 to fHash.Count-1 do

-  begin

-    Entry := TGlyphCacheHashEntry(fHash[EntryIndex]);

-

-    // the base set (0-255) has BaseCode 0 as the upper bytes are 0.

-    if KeepBaseSet and (Entry.fBaseCode = 0) then

-      Continue;

-

-    for TableIndex := 0 to High(Entry.GlyphTable) do

-    begin

-      if (Entry.GlyphTable[TableIndex] <> nil) then

-        FreeAndNil(Entry.GlyphTable[TableIndex]);

-    end;

-    FreeAndNil(Entry);

-  end;

-end;

-

-

-{*

- * TGlyphCacheEntry

- *}

-

-constructor TGlyphCacheHashEntry.Create(BaseCode: cardinal);

-begin

-  inherited Create();

-  fBaseCode := BaseCode;

-end;

-

-

-{*

- * TFreeType

- *}

-

-class function TFreeType.GetLibrary(): FT_Library;

-begin

-  if (LibraryInst = nil) then

-  begin

-    // initialize freetype

-    if (FT_Init_FreeType(LibraryInst) <> 0) then

-      raise Exception.Create('FT_Init_FreeType failed');

-  end;

-  Result := LibraryInst;

-end;

-

-class procedure TFreeType.FreeLibrary();

-begin

-  if (LibraryInst <> nil) then

-    FT_Done_FreeType(LibraryInst);

-  LibraryInst := nil;

-end;

-

-

-{$IFDEF BITMAP_FONT}

-{*

- * TBitmapFont

- *}

-

-constructor TBitmapFont.Create(const Filename: string; Outline: integer;

-    Baseline, Ascender, Descender: integer);

-begin

-  inherited Create();

-

-  fTex := Texture.LoadTexture(true, Filename, TEXTURE_TYPE_TRANSPARENT, 0);

-  fTexSize := 1024;

-  fOutline := Outline;

-  fBaseline  := Baseline;

-  fAscender  := Ascender;

-  fDescender := Descender;

-

-  LoadFontInfo(ChangeFileExt(Filename, '.dat'));

-

-  ResetIntern();

-end;

-

-destructor TBitmapFont.Destroy();

-begin

-  glDeleteTextures(1, @fTex.TexNum);

-  inherited;

-end;

-

-procedure TBitmapFont.ResetIntern();

-begin

-  fLineSpacing := Height;

-end;

-

-procedure TBitmapFont.Reset();

-begin

-  inherited;

-  ResetIntern();

-end;

-

-procedure TBitmapFont.CorrectWidths(WidthMult: real; WidthAdd: integer);

-var

-  Count: integer;

-begin

-  for Count := 0 to 255 do

-    fWidths[Count] := Round(fWidths[Count] * WidthMult) + WidthAdd;

-end;

-

-procedure TBitmapFont.LoadFontInfo(const InfoFile: string);

-var

-  Stream:  TFileStream;

-begin

-  FillChar(fWidths[0], Length(fWidths), 0);

-

-  Stream := nil;

-  try

-    Stream := TFileStream.Create(InfoFile, fmOpenRead);

-    Stream.Read(fWidths, 256);

-  except

-    raise Exception.Create('Could not read font info file ''' +  InfoFile + '''');

-  end;

-  Stream.Free;

-end;

-

-function TBitmapFont.BBox(const Text: TWideStringArray; Advance: boolean): TBoundsDbl;

-var

-  LineIndex, CharIndex: integer;

-  CharCode: cardinal;

-  Line: WideString;

-  LineWidth: double;

-begin

-  Result.Left := 0;

-  Result.Right := 0;

-  Result.Top := Height;

-  Result.Bottom := 0;

-

-  for LineIndex := 0 to High(Text) do

-  begin

-    Line := Text[LineIndex];

-    LineWidth := 0;

-    for CharIndex := 1 to Length(Line) do

-    begin

-      CharCode := Ord(Line[CharIndex]);

-      if (CharCode < Length(fWidths)) then

-        LineWidth := LineWidth + fWidths[CharCode];

-    end;

-    if (LineWidth > Result.Right) then

-      Result.Right := LineWidth;

-  end;

-end;

-

-procedure TBitmapFont.RenderChar(ch: WideChar; var AdvanceX: real);

-var

-  TexX, TexY:        real;

-  TexR, TexB:        real;

-  GlyphWidth:        real;

-  PL, PT:            real;

-  PR, PB:            real;

-  CharCode:          cardinal;

-begin

-  CharCode := Ord(ch);

-  if (CharCode > High(fWidths)) then

-    CharCode := 0;

-

-  GlyphWidth := fWidths[CharCode];

-

-  // set texture positions

-  TexX := (CharCode mod 16) * 1/16 + 1/32 - (GlyphWidth/2 - fOutline)/fTexSize;

-  TexY := (CharCode div 16) * 1/16 + {2 texels} 2/fTexSize;

-  TexR := (CharCode mod 16) * 1/16 + 1/32 + (GlyphWidth/2 + fOutline)/fTexSize;

-  TexB := (1 + CharCode div 16) * 1/16 - {2 texels} 2/fTexSize;

-

-  // set vector positions

-  PL := AdvanceX - fOutline;

-  PR := PL + GlyphWidth + fOutline*2;

-  PB := -fBaseline;

-  PT := PB + fTexSize div 16;

-

-  (*

-  if (Font.Blend) then

-  begin

-    glEnable(GL_BLEND);

-    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

-  end;

-  *)

-

-  glEnable(GL_TEXTURE_2D);

-  glBindTexture(GL_TEXTURE_2D, fTex.TexNum);

-  

-  if (not ReflectionPass) then

-  begin

-    glBegin(GL_QUADS);

-      glTexCoord2f(TexX, TexY); glVertex2f(PL, PT);

-      glTexCoord2f(TexX, TexB); glVertex2f(PL, PB);

-      glTexCoord2f(TexR, TexB); glVertex2f(PR, PB);

-      glTexCoord2f(TexR, TexY); glVertex2f(PR, PT);

-    glEnd;

-  end

-  else

-  begin

-    glDepthRange(0, 10);

-    glDepthFunc(GL_LEQUAL);

-    glEnable(GL_DEPTH_TEST);

-

-    glBegin(GL_QUADS);

-      glTexCoord2f(TexX, TexY); glVertex2f(PL, PT);

-      glTexCoord2f(TexX, TexB); glVertex2f(PL, PB);

-      glTexCoord2f(TexR, TexB); glVertex2f(PR, PB);

-      glTexCoord2f(TexR, TexY); glVertex2f(PR, PT);

-    glEnd;

-

-    glBegin(GL_QUADS);

-      glTexCoord2f(TexX, TexY); glVertex2f(PL, PT);

-      glTexCoord2f(TexX, TexB); glVertex2f(PL, PB);

-      glTexCoord2f(TexR, TexB); glVertex2f(PR, PB);

-      glTexCoord2f(TexR, TexY); glVertex2f(PR, PT);

-

-(*

-      glColor4f(fTempColor.r, fTempColor.g, fTempColor.b, 0.7);

-      glTexCoord2f(TexX, TexB); glVertex3f(PL, PB, 0);

-      glTexCoord2f(TexR, TexB); glVertex3f(PR, PB, 0);

-

-      glColor4f(fTempColor.r, fTempColor.g, fTempColor.b, 0);

-      glTexCoord2f(TexR, (TexY + TexB)/2); glVertex3f(PR, (PT + PB)/2, 0);

-      glTexCoord2f(TexX, (TexY + TexB)/2); glVertex3f(PL, (PT + PB)/2, 0);

-*)

-    glEnd;

-

-    //write the colour back

-    glColor4fv(@fTempColor);

-

-    glDisable(GL_DEPTH_TEST);

-  end; // reflection

-

-  glDisable(GL_TEXTURE_2D);

-  (*

-  if (Font.Blend) then

-    glDisable(GL_BLEND);

-  *)

-

-  AdvanceX := AdvanceX + GlyphWidth;

-end;

-

-procedure TBitmapFont.Render(const Text: WideString);

-var

-  CharIndex: integer;

-  AdvanceX: real;

-begin

-  // if there is no text do nothing

-  if (Text = '') then

-    Exit;

-

-  //Save the current color and alpha (for reflection)

-  glGetFloatv(GL_CURRENT_COLOR, @fTempColor);

-

-  AdvanceX := 0;

-  for CharIndex := 1 to Length(Text) do

-  begin

-    RenderChar(Text[CharIndex], AdvanceX);

-  end;

-end;

-

-function TBitmapFont.GetHeight(): single;

-begin

-  Result := fAscender - fDescender;

-end;

-

-function TBitmapFont.GetAscender(): single;

-begin

-  Result := fAscender;

-end;

-

-function TBitmapFont.GetDescender(): single;

-begin

-  Result := fDescender;

-end;

-

-function TBitmapFont.GetUnderlinePosition(): single;

-begin

-  Result := -2.0;

-end;

-

-function TBitmapFont.GetUnderlineThickness(): single;

-begin

-  Result := 1.0;

-end;

-

-{$ENDIF BITMAP_FONT}

-

-

-initialization

-

-finalization

-  TFreeType.FreeLibrary();

-

-end.

diff --git a/src/lib/freetype/demo/lesson43.bdsproj b/src/lib/freetype/demo/engine-test.bdsproj
index 30f88ab3..9547f18f 100644
--- a/src/lib/freetype/demo/lesson43.bdsproj
+++ b/src/lib/freetype/demo/engine-test.bdsproj
@@ -10,7 +10,7 @@
 	</PersonalityInfo>

 	<Delphi.Personality>

 		<Source>

-			<Source Name="MainSource">lesson43.dpr</Source>

+			<Source Name="MainSource">engine-test.dpr</Source>

 		</Source>

 		<FileVersion>

 			<FileVersion Name="Version">7.0</FileVersion>

diff --git a/src/lib/freetype/demo/lesson43.dpr b/src/lib/freetype/demo/engine-test.dpr
index 8a470a2e..80177735 100644
--- a/src/lib/freetype/demo/lesson43.dpr
+++ b/src/lib/freetype/demo/engine-test.dpr
@@ -1,366 +1,336 @@
-program lesson43;

-(*

- * This code was created by Jeff Molofee '99

- * (ported to Linux/SDL by Ti Leggett '01)

- *

- * If you've found this code useful, please let me know.

- *

- * Visit Jeff at http://nehe.gamedev.net/

- *

- * or for port-specific comments, questions, bugreports etc.

- * email to leggett@eecs.tulane.edu

- *)

-

-{$IFDEF FPC}

-  {$mode delphi}{$H+}

-{$ENDIF}

-

-{$APPTYPE Console}

-

-{.$DEFINE FONT2}

-

-uses

-  moduleloader in '../../JEDI-SDL/SDL/Pas/moduleloader.pas',

-  SDL          in '../../JEDI-SDL/SDL/Pas/sdl.pas',

-  gl           in '../../JEDI-SDL/OpenGL/Pas/gl.pas',

-  glext        in '../../JEDI-SDL/OpenGL/Pas/glext.pas',

-  glu          in '../../JEDI-SDL/OpenGL/Pas/glu.pas',

-  ctypes       in '../../ctypes/ctypes.pas',

-  FreeType     in '../freetype.pas',

-  {$IFNDEF FONT2}

-  UFont        in 'UFont.pas',

-  {$ELSE}

-  UFont2       in 'UFont2.pas',

-  {$ENDIF}

-  math,

-  sysutils;

-

-const

-  // screen width, height, and bit depth

-  SCREEN_WIDTH  = 640;

-  SCREEN_HEIGHT = 480;

-  SCREEN_BPP    =  16;

-

-  //FONT_FILE = 'Test.ttf';

-  //FONT_FILE = 'C:/Windows/Fonts/Arial.ttf';

-  //FONT_FILE = 'C:/Windows/Fonts/SimSun.ttf';

-  //FONT_FILE = 'C:/Windows/Fonts/SimSun.ttf';

-  FONT_FILE = 'eurostarregularextended.ttf';

-

-var

-  OurFont: TScalableFont;

-  // This is our SDL surface

-  surface: PSDL_Surface;

-  cnt1, cnt2: GLfloat;

-

-(* function to release/destroy our resources and restoring the old desktop *)

-procedure Quit(returnCode: integer);

-begin

-  OurFont.Free;

-

-  // clean up the window

-  SDL_Quit( );

-

-  // and exit appropriately

-  Halt( returnCode );

-end;

-

-(* function to reset our viewport after a window resize *)

-function resizeWindow(width: integer; height: integer): boolean;

-begin

-  // Protect against a divide by zero

-  if ( height = 0 ) then

-    height := 1;

-

-  // Setup our viewport.

-  glViewport( 0, 0, GLsizei(width), GLsizei(height) );

-

-  // change to the projection matrix and set our viewing volume.

-  glMatrixMode( GL_PROJECTION );

-  glLoadIdentity( );

-

-  // Set our perspective

-  //gluOrtho2D(0, width, 0, height);

-  gluOrtho2D(0, 800, 0, 600);

-

-  // Make sure we're chaning the model view and not the projection

-  glMatrixMode( GL_MODELVIEW );

-

-  // Reset The View

-  glLoadIdentity( );

-

-  Result := true;

-end;

-

-(* function to handle key press events *)

-procedure handleKeyPress(keysym: PSDL_keysym);

-begin

-  case ( keysym^.sym ) of

-    SDLK_ESCAPE:

-    begin

-      // ESC key was pressed

-      Quit( 0 );

-    end;

-    SDLK_F1:

-    begin

-      // F1 key was pressed

-      // this toggles fullscreen mode

-      SDL_WM_ToggleFullScreen( surface );

-    end;

-  end;

-end;

-

-(* general OpenGL initialization function *)

-function initGL(): boolean;

-begin

-  // Enable smooth shading

-  glShadeModel( GL_SMOOTH );

-

-  // Set the background black

-  //glClearColor( 1, 1, 1.0, 1.0 );

-  //glClearColor( 0.3, 0.7, 1.0, 1.0 );

-  glClearColor( 0.0, 0.0, 0.0, 1.0 );

-

-  // Depth buffer setup

-  glClearDepth( 1.0 );

-

-  // Enables Depth Testing

-  glEnable( GL_DEPTH_TEST );

-

-  // The Type Of Depth Test To Do

-  glDepthFunc( GL_LEQUAL );

-

-  // Really Nice Perspective Calculations

-  glHint( GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST );

-

-  //OurFont := TFTScalableFont.Create(FONT_FILE, 64);

-  //OurFont := TFTFont.Create(FONT_FILE, 128);

-  OurFont := TFTScalableOutlineFont.Create(FONT_FILE, 64, 0.05);

-  //OurFont.UseKerning := false;

-  TFTScalableOutlineFont(OurFont).SetOutlineColor(1, 0, 0);

-  //OurFont := TOutlineFont.Create(FONT_FILE, 32, 2);

-  //OurFont.LineSpacing := OurFont.LineSpacing * 0.5;

-

-  Result := true;

-end;

-

-var

-  NextTime: cardinal;

-  Counter: integer;

-

-type

-  TVector4d = array[0..3] of GLdouble;

-

-function NewVector4d(a, b, c, d: GLdouble): TVector4d;

-begin

-  Result[0] := a;

-  Result[1] := b;

-  Result[2] := c;

-  Result[3] := d;

-end;

-

-(* Here goes our drawing code *)

-function drawGLScene(): boolean;

-var

-  msg: WideString;

-  bounds: TBoundsDbl;

-  ClipPlaneEq: TVector4d;

-begin

-  glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT);  // Clear Screen And Depth Buffer

-

-  //msg := 'Here'#13'there'#13'be'#13#13'newlines'#13'.';

-  //msg := 'Here'#13'newlines';

-  msg := 'Hallo Du';//Active FreeType Text - ' + FloatToStr(cnt1);

-  //msg := 'Hören'#13'其自诞生至今'#13'спецификация';

-

-  // Red text

-  glLoadIdentity();

-  glTranslatef(cnt2, 240, 0);

-  if (cnt2 > 800) then

-    cnt2 := 0;

-  glTranslatef(30, 40, 0);

-  //glTranslatef(320, 240, 0);

-  //glRotatef(cnt1, 0, 0, 1);

-  //glScalef(1, 0.8 + 0.3*cos(cnt1/5), 1);

-

-  OurFont.Style := [Italic, Underline, Reflect];

-  //OurFont.GlyphSpacing := 10;

-  //OurFont.SetOutlineColor(0.5, 0.5, 0.5);

-  //OurFont.ReflectionSpacing := -4;

-  //OurFont.UseKerning := false;

-  OurFont.Height := 32;//cnt2;

-  //OurFont.Reset;

-  //OurFont.Aspect := 2;

-

-  {

-  glColor3f(1, 1, 0);

-  bounds := OurFont.BBox(msg);

-  glRectf(bounds.Left, bounds.Top, bounds.Right, bounds.Bottom);

-  }

-

-  {

-  glEnable(GL_CLIP_PLANE0);

-  ClipPlaneEq := NewVector4d(-1, 0, 0, bounds.Right/5);

-  glClipPlane(GL_CLIP_PLANE0, @ClipPlaneEq);

-  }

-  //glColor3f(1, 0, 0);

-  glColor3f(1, 1, 1);

-  //OurFont.ReflectionSpacing := 0;

-  OurFont.Print(msg);

-

-  glTranslatef(0, 50, 0);

-  glColor3f(1, 1, 0);

-  bounds := OurFont.BBox('Hallo ');

-  glRectf(bounds.Left, bounds.Top, bounds.Right, bounds.Bottom);

-  OurFont.Print('Hallo ');

-

-  {

-  ClipPlaneEq := NewVector4d(1, 0, 0, -bounds.Right/5);

-  glClipPlane(GL_CLIP_PLANE0, @ClipPlaneEq);

-  glColor3f(0, 0, 1);

-  OurFont.Print(msg);

-  glDisable(GL_CLIP_PLANE0);

-  //glColor3f(0, 1, 0);

-  //OurFont.Style := OurFont.Style - [Italic];

-  //OurFont.Print(msg);

-  }

-

-  cnt1 := cnt1 + 0.051;  // Increase The First Counter

-  cnt2 := cnt2 + 0.005;  // Increase The First Counter

-

-  SDL_GL_SwapBuffers( );

-

-  Inc(Counter);

-

-  if (NextTime < SDL_GetTicks()) then

-  begin

-    NextTime := SDL_GetTicks() + 2000;

-    writeln('FPS: ' + floattostr(Counter / 2.0));

-    Counter := 0;

-  end;

-

-  Result := true;

-end;

-

-var

-  // Flags to pass to SDL_SetVideoMode

-  videoFlags: integer;

-  // main loop variable

-  done: boolean = false;

-  // used to collect events

-  event: TSDL_Event;

-  // this holds some info about our display

-  videoInfo: PSDL_VideoInfo;

-  // whether or not the window is active

-  isActive: boolean = true;

-

-begin

-  // initialize SDL

-  if ( SDL_Init( SDL_INIT_VIDEO or SDL_INIT_TIMER ) < 0 ) then

-  begin

-    writeln( ErrOutput, 'Video initialization failed: ' + SDL_GetError() );

-    Quit( 1 );

-  end;

-

-  // Fetch the video info

-  videoInfo := SDL_GetVideoInfo( );

-

-  if ( videoInfo = nil ) then

-  begin

-    writeln( ErrOutput, 'Video query failed: ' + SDL_GetError() );

-    Quit( 1 );

-  end;

-

-  SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 ); // Enable double buffering

-

-  // the flags to pass to SDL_SetVideoMode

-  videoFlags := SDL_OPENGL;                        // Enable OpenGL in SDL

-  videoFlags := videoFlags or SDL_HWPALETTE;       // Store the palette in hardware

-  videoFlags := videoFlags or SDL_RESIZABLE;       // Enable window resizing

-

-  // This checks to see if surfaces can be stored in memory

-  if ( videoInfo^.hw_available <> 0 ) then

-    videoFlags := videoFlags or SDL_HWSURFACE

-  else

-    videoFlags := videoFlags or SDL_SWSURFACE;

-

-  // This checks if hardware blits can be done

-  if ( videoInfo^.blit_hw <> 0 ) then

-    videoFlags := videoFlags or SDL_HWACCEL;

-

-  // Sets up OpenGL double buffering

-  SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 );

-

-  // get a SDL surface

-  surface := SDL_SetVideoMode( SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_BPP,

-                               videoFlags );

-

-  // Verify there is a surface

-  if ( surface = nil ) then

-  begin

-    writeln( ErrOutput, 'Video mode set failed: ' + SDL_GetError() );

-    Quit( 1 );

-  end;

-

-  // initialize OpenGL

-  initGL();

-

-  // resize the initial window

-  resizeWindow( SCREEN_WIDTH, SCREEN_HEIGHT );

-

-  // wait for events

-  while ( not done ) do

-  begin

-    { handle the events in the queue }

-

-    while ( SDL_PollEvent( @event ) <> 0 ) do

-    begin

-      case( event.type_ ) of

-        SDL_ACTIVEEVENT:

-        begin

-          // Something's happend with our focus

-          // If we are iconified, we shouldn't draw the screen

-          if ( (event.active.state and SDL_APPACTIVE) <> 0 ) then

-          begin

-            if (  event.active.gain = 0 ) then

-              isActive := false

-            else

-              isActive := true;

-          end;

-        end;

-        SDL_VIDEORESIZE:

-        begin

-          // handle resize event

-          {$IFDEF UNIX}

-          surface := SDL_SetVideoMode( event.resize.w,

-              event.resize.h,

-              16, videoFlags );

-          if ( surface = nil ) then

-          begin

-            writeln( ErrOutput, 'Could not get a surface after resize: ' + SDL_GetError( ) );

-            Quit( 1 );

-          end;

-          {$ENDIF}

-          resizeWindow( event.resize.w, event.resize.h );

-        end;

-        SDL_KEYDOWN:

-        begin

-          // handle key presses

-          handleKeyPress( @event.key.keysym );

-        end;

-        SDL_QUITEV:

-        begin

-          // handle quit requests

-          done := true;

-        end;

-      end;

-    end;

-

-    // draw the scene

-    if ( isActive ) then

-      drawGLScene( );

-  end;

-

-  // clean ourselves up and exit

-  Quit( 0 );

-end.

+program engine_test;
+(*
+ * This code was created by Jeff Molofee '99
+ * (ported to Linux/SDL by Ti Leggett '01)
+ *
+ * If you've found this code useful, please let me know.
+ *
+ * Visit Jeff at http://nehe.gamedev.net/
+ *
+ * or for port-specific comments, questions, bugreports etc.
+ * email to leggett@eecs.tulane.edu
+ *)
+
+{$IFDEF FPC}
+  {$mode delphi}{$H+}
+{$ENDIF}
+
+{$APPTYPE Console}
+
+uses
+  moduleloader in '../../JEDI-SDL/SDL/Pas/moduleloader.pas',
+  SDL          in '../../JEDI-SDL/SDL/Pas/sdl.pas',
+  gl           in '../../JEDI-SDL/OpenGL/Pas/gl.pas',
+  glext        in '../../JEDI-SDL/OpenGL/Pas/glext.pas',
+  glu          in '../../JEDI-SDL/OpenGL/Pas/glu.pas',
+  {$IFNDEF FPC}
+  ctypes       in '../../ctypes/ctypes.pas',
+  {$ENDIF}
+  FreeType     in '../freetype.pas',
+  UFont        in '../../../base/UFont.pas',
+  math,
+  sysutils;
+
+const
+  // screen width, height, and bit depth
+  SCREEN_WIDTH  = 640;
+  SCREEN_HEIGHT = 480;
+  SCREEN_BPP    =  16;
+
+  //FONT_FILE = 'Test.ttf';
+  //FONT_FILE = 'C:/Windows/Fonts/Arial.ttf';
+  //FONT_FILE = 'C:/Windows/Fonts/SimSun.ttf';
+  //FONT_FILE = 'eurostarregularextended.ttf';
+  FONT_FILE = 'FreeSans.ttf';
+  
+var
+  OurFont: TScalableFont;
+  // This is our SDL surface
+  surface: PSDL_Surface;
+  cnt1, cnt2: GLfloat;
+
+(* function to release/destroy our resources and restoring the old desktop *)
+procedure Quit(returnCode: integer);
+begin
+  OurFont.Free;
+
+  // clean up the window
+  SDL_Quit( );
+
+  // and exit appropriately
+  Halt( returnCode );
+end;
+
+(* function to reset our viewport after a window resize *)
+function resizeWindow(width: integer; height: integer): boolean;
+begin
+  // Protect against a divide by zero
+  if ( height = 0 ) then
+    height := 1;
+
+  // Setup our viewport.
+  glViewport( 0, 0, GLsizei(width), GLsizei(height) );
+
+  // change to the projection matrix and set our viewing volume.
+  glMatrixMode( GL_PROJECTION );
+  glLoadIdentity( );
+
+  // Set our perspective
+  //gluOrtho2D(0, width, 0, height);
+  gluOrtho2D(0, 800, 0, 600);
+
+  // Make sure we're chaning the model view and not the projection
+  glMatrixMode( GL_MODELVIEW );
+
+  // Reset The View
+  glLoadIdentity( );
+
+  Result := true;
+end;
+
+(* function to handle key press events *)
+procedure handleKeyPress(keysym: PSDL_keysym);
+begin
+  case ( keysym^.sym ) of
+    SDLK_ESCAPE:
+    begin
+      // ESC key was pressed
+      Quit( 0 );
+    end;
+    SDLK_F1:
+    begin
+      // F1 key was pressed
+      // this toggles fullscreen mode
+      SDL_WM_ToggleFullScreen( surface );
+    end;
+  end;
+end;
+
+(* general OpenGL initialization function *)
+function initGL(): boolean;
+begin
+  // Enable smooth shading
+  glShadeModel( GL_SMOOTH );
+
+  // Set the background black
+  //glClearColor( 1, 1, 1.0, 1.0 );
+  //glClearColor( 0.3, 0.7, 1.0, 1.0 );
+  glClearColor( 0.0, 0.0, 0.0, 1.0 );
+
+  // Depth buffer setup
+  glClearDepth( 1.0 );
+
+  // Enables Depth Testing
+  glEnable( GL_DEPTH_TEST );
+
+  // The Type Of Depth Test To Do
+  glDepthFunc( GL_LEQUAL );
+
+  // Really Nice Perspective Calculations
+  glHint( GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST );
+
+  //OurFont := TFTScalableFont.Create(FONT_FILE, 64);
+  //OurFont := TFTFont.Create(FONT_FILE, 128);
+  OurFont := TFTScalableOutlineFont.Create(FONT_FILE, 64, 0.05);
+  //OurFont.UseKerning := false;
+  TFTScalableOutlineFont(OurFont).SetOutlineColor(1, 0, 0);
+  //OurFont := TOutlineFont.Create(FONT_FILE, 32, 2);
+  //OurFont.LineSpacing := OurFont.LineSpacing * 0.5;
+
+  Result := true;
+end;
+
+var
+  NextTime: cardinal;
+  Counter: integer;
+
+type
+  TVector4d = array[0..3] of GLdouble;
+
+function NewVector4d(a, b, c, d: GLdouble): TVector4d;
+begin
+  Result[0] := a;
+  Result[1] := b;
+  Result[2] := c;
+  Result[3] := d;
+end;
+
+(* Here goes our drawing code *)
+function drawGLScene(): boolean;
+var
+  msg: WideString;
+  bounds: TBoundsDbl;
+begin
+  glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT);  // Clear Screen And Depth Buffer
+
+  //msg := 'Here'#13'there'#13'be'#13#13'newlines'#13'.';
+  //msg := 'Here'#13'newlines';
+  msg := 'Active FreeType Text - ' + FloatToStr(cnt1);
+  //msg := 'Hören'#13'其自诞生至今'#13'спецификация';
+
+  // Red text
+  glLoadIdentity();
+  glTranslatef(cnt2, 240, 0);
+  if (cnt2 > 800) then
+    cnt2 := 0;
+  glTranslatef(30, 40, 0);
+  //glTranslatef(320, 240, 0);
+  //glRotatef(cnt1, 0, 0, 1);
+  //glScalef(1, 0.8 + 0.3*cos(cnt1/5), 1);
+
+  OurFont.Style := [Italic, {Underline,} Reflect];
+  //OurFont.GlyphSpacing := 10;
+  //OurFont.SetOutlineColor(0.5, 0.5, 0.5);
+  //OurFont.ReflectionSpacing := -4;
+  //OurFont.UseKerning := false;
+  OurFont.Height := 64;//cnt2;
+  //OurFont.Reset;
+  //OurFont.Aspect := 2;
+
+  glColor3f(1, 1, 0);
+  bounds := OurFont.BBox(msg);
+  //glRectf(bounds.Left, OurFont.Ascender, bounds.Right, OurFont.Ascender-OurFont.Height);
+
+  glColor3f(1, 1, 1);
+  //OurFont.ReflectionSpacing := 0;
+  OurFont.Print(msg);
+
+  cnt1 := cnt1 + 0.051;  // Increase The First Counter
+  cnt2 := cnt2 + 0.005;  // Increase The First Counter
+
+  SDL_GL_SwapBuffers( );
+
+  Inc(Counter);
+
+  if (NextTime < SDL_GetTicks()) then
+  begin
+    NextTime := SDL_GetTicks() + 2000;
+    writeln('FPS: ' + floattostr(Counter / 2.0));
+    Counter := 0;
+  end;
+
+  Result := true;
+end;
+
+var
+  // Flags to pass to SDL_SetVideoMode
+  videoFlags: integer;
+  // main loop variable
+  done: boolean = false;
+  // used to collect events
+  event: TSDL_Event;
+  // this holds some info about our display
+  videoInfo: PSDL_VideoInfo;
+  // whether or not the window is active
+  isActive: boolean = true;
+
+begin
+  // initialize SDL
+  if ( SDL_Init( SDL_INIT_VIDEO or SDL_INIT_TIMER ) < 0 ) then
+  begin
+    writeln( ErrOutput, 'Video initialization failed: ' + SDL_GetError() );
+    Quit( 1 );
+  end;
+
+  // Fetch the video info
+  videoInfo := SDL_GetVideoInfo( );
+
+  if ( videoInfo = nil ) then
+  begin
+    writeln( ErrOutput, 'Video query failed: ' + SDL_GetError() );
+    Quit( 1 );
+  end;
+
+  SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 ); // Enable double buffering
+
+  // the flags to pass to SDL_SetVideoMode
+  videoFlags := SDL_OPENGL;                        // Enable OpenGL in SDL
+  videoFlags := videoFlags or SDL_HWPALETTE;       // Store the palette in hardware
+  videoFlags := videoFlags or SDL_RESIZABLE;       // Enable window resizing
+
+  // This checks to see if surfaces can be stored in memory
+  if ( videoInfo^.hw_available <> 0 ) then
+    videoFlags := videoFlags or SDL_HWSURFACE
+  else
+    videoFlags := videoFlags or SDL_SWSURFACE;
+
+  // This checks if hardware blits can be done
+  if ( videoInfo^.blit_hw <> 0 ) then
+    videoFlags := videoFlags or SDL_HWACCEL;
+
+  // Sets up OpenGL double buffering
+  SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 );
+
+  // get a SDL surface
+  surface := SDL_SetVideoMode( SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_BPP,
+                               videoFlags );
+
+  // Verify there is a surface
+  if ( surface = nil ) then
+  begin
+    writeln( ErrOutput, 'Video mode set failed: ' + SDL_GetError() );
+    Quit( 1 );
+  end;
+
+  // initialize OpenGL
+  initGL();
+
+  // resize the initial window
+  resizeWindow( SCREEN_WIDTH, SCREEN_HEIGHT );
+
+  // wait for events
+  while ( not done ) do
+  begin
+    { handle the events in the queue }
+
+    while ( SDL_PollEvent( @event ) <> 0 ) do
+    begin
+      case( event.type_ ) of
+        SDL_ACTIVEEVENT:
+        begin
+          // Something's happend with our focus
+          // If we are iconified, we shouldn't draw the screen
+          if ( (event.active.state and SDL_APPACTIVE) <> 0 ) then
+          begin
+            if (  event.active.gain = 0 ) then
+              isActive := false
+            else
+              isActive := true;
+          end;
+        end;
+        SDL_VIDEORESIZE:
+        begin
+          // handle resize event
+          {$IFDEF UNIX}
+          surface := SDL_SetVideoMode( event.resize.w,
+              event.resize.h,
+              16, videoFlags );
+          if ( surface = nil ) then
+          begin
+            writeln( ErrOutput, 'Could not get a surface after resize: ' + SDL_GetError( ) );
+            Quit( 1 );
+          end;
+          {$ENDIF}
+          resizeWindow( event.resize.w, event.resize.h );
+        end;
+        SDL_KEYDOWN:
+        begin
+          // handle key presses
+          handleKeyPress( @event.key.keysym );
+        end;
+        SDL_QUITEV:
+        begin
+          // handle quit requests
+          done := true;
+        end;
+      end;
+    end;
+
+    // draw the scene
+    if ( isActive ) then
+      drawGLScene( );
+  end;
+
+  // clean ourselves up and exit
+  Quit( 0 );
+end.
diff --git a/src/lib/freetype/demo/lesson43.lpi b/src/lib/freetype/demo/engine-test.lpi
index b6791f18..6cbfe1eb 100644
--- a/src/lib/freetype/demo/lesson43.lpi
+++ b/src/lib/freetype/demo/engine-test.lpi
@@ -7,7 +7,7 @@
       <MainUnit Value="0"/>

       <IconPath Value=".\"/>

       <TargetFileExt Value=""/>

-      <ActiveEditorIndexAtStart Value="1"/>

+      <ActiveEditorIndexAtStart Value="0"/>

     </General>

     <VersionInfo>

       <ProjectVersion Value=""/>

@@ -29,10 +29,9 @@
     </RunParams>

     <Units Count="16">

       <Unit0>

-        <Filename Value="lesson43.dpr"/>

+        <Filename Value="engine-test.dpr"/>

         <IsPartOfProject Value="True"/>

-        <UnitName Value="lesson43"/>

-        <CursorPos X="1" Y="138"/>

+        <CursorPos X="25" Y="135"/>

         <TopLine Value="118"/>

         <EditorIndex Value="0"/>

         <UsageCount Value="72"/>

@@ -138,127 +137,29 @@
       <Unit15>

         <Filename Value="UFont.pas"/>

         <UnitName Value="UFont"/>

-        <CursorPos X="1" Y="1751"/>

+        <CursorPos X="15" Y="1752"/>

         <TopLine Value="1734"/>

-        <EditorIndex Value="1"/>

         <UsageCount Value="10"/>

-        <Loaded Value="True"/>

       </Unit15>

     </Units>

-    <JumpHistory Count="22" HistoryIndex="21">

-      <Position1>

-        <Filename Value="lesson43.dpr"/>

-        <Caret Line="1" Column="1" TopLine="1"/>

-      </Position1>

-      <Position2>

-        <Filename Value="lesson43.dpr"/>

-        <Caret Line="138" Column="1" TopLine="118"/>

-      </Position2>

-      <Position3>

-        <Filename Value="UFont.pas"/>

-        <Caret Line="1746" Column="1" TopLine="1726"/>

-      </Position3>

-      <Position4>

-        <Filename Value="UFont.pas"/>

-        <Caret Line="1747" Column="1" TopLine="1727"/>

-      </Position4>

-      <Position5>

-        <Filename Value="UFont.pas"/>

-        <Caret Line="1749" Column="1" TopLine="1729"/>

-      </Position5>

-      <Position6>

-        <Filename Value="UFont.pas"/>

-        <Caret Line="1750" Column="1" TopLine="1730"/>

-      </Position6>

-      <Position7>

-        <Filename Value="UFont.pas"/>

-        <Caret Line="1751" Column="1" TopLine="1731"/>

-      </Position7>

-      <Position8>

-        <Filename Value="UFont.pas"/>

-        <Caret Line="1752" Column="1" TopLine="1732"/>

-      </Position8>

-      <Position9>

-        <Filename Value="UFont.pas"/>

-        <Caret Line="1575" Column="1" TopLine="1555"/>

-      </Position9>

-      <Position10>

-        <Filename Value="UFont.pas"/>

-        <Caret Line="1576" Column="1" TopLine="1556"/>

-      </Position10>

-      <Position11>

-        <Filename Value="UFont.pas"/>

-        <Caret Line="1578" Column="1" TopLine="1558"/>

-      </Position11>

-      <Position12>

-        <Filename Value="UFont.pas"/>

-        <Caret Line="1579" Column="1" TopLine="1559"/>

-      </Position12>

-      <Position13>

-        <Filename Value="UFont.pas"/>

-        <Caret Line="1580" Column="1" TopLine="1560"/>

-      </Position13>

-      <Position14>

-        <Filename Value="UFont.pas"/>

-        <Caret Line="1582" Column="1" TopLine="1562"/>

-      </Position14>

-      <Position15>

-        <Filename Value="UFont.pas"/>

-        <Caret Line="1583" Column="1" TopLine="1563"/>

-      </Position15>

-      <Position16>

-        <Filename Value="UFont.pas"/>

-        <Caret Line="1585" Column="1" TopLine="1565"/>

-      </Position16>

-      <Position17>

-        <Filename Value="UFont.pas"/>

-        <Caret Line="1600" Column="1" TopLine="1580"/>

-      </Position17>

-      <Position18>

-        <Filename Value="UFont.pas"/>

-        <Caret Line="1602" Column="1" TopLine="1582"/>

-      </Position18>

-      <Position19>

-        <Filename Value="UFont.pas"/>

-        <Caret Line="1603" Column="1" TopLine="1583"/>

-      </Position19>

-      <Position20>

-        <Filename Value="UFont.pas"/>

-        <Caret Line="1604" Column="1" TopLine="1584"/>

-      </Position20>

-      <Position21>

-        <Filename Value="UFont.pas"/>

-        <Caret Line="1605" Column="1" TopLine="1585"/>

-      </Position21>

-      <Position22>

-        <Filename Value="UFont.pas"/>

-        <Caret Line="1586" Column="1" TopLine="1566"/>

-      </Position22>

-    </JumpHistory>

+    <JumpHistory Count="0" HistoryIndex="-1"/>

   </ProjectOptions>

   <CompilerOptions>

-    <Version Value="5"/>

+    <Version Value="8"/>

     <PathDelim Value="\"/>

     <SearchPaths>

       <IncludeFiles Value="..\..\JEDI-SDL\SDL\Pas\"/>

     </SearchPaths>

-    <CodeGeneration>

-      <Generate Value="Faster"/>

-    </CodeGeneration>

     <Other>

       <CompilerPath Value="$(CompPath)"/>

     </Other>

   </CompilerOptions>

   <Debugging>

-    <BreakPoints Count="2">

+    <BreakPoints Count="1">

       <Item1>

         <Source Value="lesson43.dpr"/>

         <Line Value="138"/>

       </Item1>

-      <Item2>

-        <Source Value="UFont.pas"/>

-        <Line Value="1751"/>

-      </Item2>

     </BreakPoints>

     <Exceptions Count="2">

       <Item1>

diff --git a/src/lib/freetype/demo/nehe/UFreeType.pas b/src/lib/freetype/demo/nehe/UFreeType.pas
new file mode 100644
index 00000000..c1243aae
--- /dev/null
+++ b/src/lib/freetype/demo/nehe/UFreeType.pas
@@ -0,0 +1,326 @@
+unit UFreeType;
+
+{$IFDEF FPC}
+  {$mode delphi}{$H+}
+{$ENDIF}
+
+interface
+
+uses
+  FreeType,
+  gl,
+  glu,
+  classes,
+  sysutils;
+
+type
+  // This holds all of the information related to any
+  // freetype font that we want to create.
+  TFontData = class
+    h: single;                  ///< Holds the height of the font.
+    textures: array of GLuint;  ///< Holds the texture id's
+    list_base: GLuint;          ///< Holds the first display list id
+
+    // The init function will create a font of
+    // of the height h from the file fname.
+    constructor Create(const fname: string; h: cardinal);
+
+    // Free all the resources assosiated with the font.
+    destructor Destroy(); override;
+  end;
+
+  TFreeType = class
+    public
+      // The flagship function of the library - this thing will print
+      // out text at window coordinates x,y, using the font ft_font.
+      // The current modelview matrix will also be applied to the text.
+      class procedure print(ft_font: TFontData; x, y: single; const str: string);
+  end;
+
+
+implementation
+
+
+// This function gets the first power of 2 >= the
+// int that we pass it.
+function next_p2 ( a: integer ): integer; inline;
+begin
+  Result := 1;
+  while (Result < a) do
+    Result := Result shl 1;
+end;
+
+type
+  PAGLuint = ^AGLuint;
+  AGLuint = array[0..High(Word)] of GLuint;
+
+// Create a display list coresponding to the given character.
+procedure make_dlist ( face: FT_Face; ch: byte; list_base: GLuint; tex_base: PAGLuint );
+var
+  i, j: integer;
+  width, height: integer;
+  glyph: FT_Glyph;
+  bitmap_glyph: FT_BitmapGlyph;
+  bitmap: PFT_Bitmap;
+  expanded_data: array of GLubyte;
+  x, y: single;
+begin
+  // The first thing we do is get FreeType to render our character
+  // into a bitmap.  This actually requires a couple of FreeType commands:
+
+  // Load the Glyph for our character.
+  if (FT_Load_Glyph( face, FT_Get_Char_Index( face, ch ), FT_LOAD_DEFAULT ) <> 0) then
+    raise Exception.create('FT_Load_Glyph failed');
+
+  // Move the face's glyph into a Glyph object.
+  if (FT_Get_Glyph( face^.glyph, glyph ) <> 0) then
+    raise Exception.create('FT_Get_Glyph failed');
+
+  // Convert the glyph to a bitmap.
+  FT_Glyph_To_Bitmap( glyph, ft_render_mode_normal, nil, 1 );
+  bitmap_glyph := FT_BitmapGlyph(glyph);
+
+  // This reference will make accessing the bitmap easier
+  bitmap := @bitmap_glyph^.bitmap;
+
+  // Use our helper function to get the widths of
+  // the bitmap data that we will need in order to create
+  // our texture.
+  width := next_p2( bitmap.width );
+  height := next_p2( bitmap.rows );
+
+  // Allocate memory for the texture data.
+  SetLength(expanded_data, 2 * width * height);
+
+  // Here we fill in the data for the expanded bitmap.
+  // Notice that we are using two channel bitmap (one for
+  // luminocity and one for alpha), but we assign
+  // both luminocity and alpha to the value that we
+  // find in the FreeType bitmap.
+  // We use the ?: operator so that value which we use
+  // will be 0 if we are in the padding zone, and whatever
+  // is the the Freetype bitmap otherwise.
+  for j := 0 to height-1 do
+  begin
+    for i := 0 to width-1 do
+    begin
+      if ((i >= bitmap.width) or (j >= bitmap.rows)) then
+        expanded_data[2*(i+j*width)] := 0
+      else
+        expanded_data[2*(i+j*width)] := byte(bitmap.buffer[i + bitmap.width*j]);
+      expanded_data[2*(i+j*width)+1] := expanded_data[2*(i+j*width)];
+    end;
+  end;
+
+
+  // Now we just setup some texture paramaters.
+  glBindTexture( GL_TEXTURE_2D, tex_base[integer(ch)]);
+  glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
+  glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
+
+  // Here we actually create the texture itself, notice
+  // that we are using GL_LUMINANCE_ALPHA to indicate that
+  // we are using 2 channel data.
+  glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, width, height,
+      0, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, @expanded_data[0] );
+
+  //With the texture created, we don't need to expanded data anymore
+  SetLength(expanded_data, 0);
+
+  //So now we can create the display list
+  glNewList(list_base+ch, GL_COMPILE);
+
+  glBindTexture(GL_TEXTURE_2D, tex_base[ch]);
+
+  glPushMatrix();
+
+  //first we need to move over a little so that
+  //the character has the right amount of space
+  //between it and the one before it.
+  glTranslatef(bitmap_glyph^.left, 0, 0);
+
+  //Now we move down a little in the case that the
+  //bitmap extends past the bottom of the line
+  //(this is only true for characters like 'g' or 'y'.
+  glTranslatef(0, bitmap_glyph^.top - bitmap.rows, 0);
+
+  //Now we need to account for the fact that many of
+  //our textures are filled with empty padding space.
+  //We figure what portion of the texture is used by 
+  //the actual character and store that information in
+  //the x and y variables, then when we draw the
+  //quad, we will only reference the parts of the texture
+  //that we contain the character itself.
+  x := bitmap.width / width;
+  y := bitmap.rows  / height;
+
+  //Here we draw the texturemaped quads.
+  //The bitmap that we got from FreeType was not
+  //oriented quite like we would like it to be,
+  //so we need to link the texture to the quad
+  //so that the result will be properly aligned.
+  glBegin(GL_QUADS);
+    glTexCoord2d(0, 0); glVertex2f(0, bitmap.rows);
+    glTexCoord2d(0, y); glVertex2f(0, 0);
+    glTexCoord2d(x, y); glVertex2f(bitmap.width, 0);
+    glTexCoord2d(x, 0); glVertex2f(bitmap.width, bitmap.rows);
+  glEnd();
+
+  glPopMatrix();
+  glTranslatef(face^.glyph^.advance.x shr 6, 0, 0);
+
+  //increment the raster position as if we were a bitmap font.
+  //(only needed if you want to calculate text length)
+  //glBitmap(0,0,0,0,face->glyph->advance.x >> 6,0,NULL);
+
+  //Finnish the display list
+  glEndList();
+end;
+
+
+constructor TFontData.Create(const fname: string; h: cardinal);
+var
+  library_: FT_Library;
+  //The object in which Freetype holds information on a given
+  //font is called a "face".
+  face: FT_Face;
+  i: byte;
+begin
+  //Allocate some memory to store the texture ids.
+  SetLength(textures, 128);
+
+  Self.h := h;
+
+  //Create and initilize a freetype font library.
+  if (FT_Init_FreeType( library_ ) <> 0) then
+    raise Exception.create('FT_Init_FreeType failed');
+
+  //This is where we load in the font information from the file.
+  //Of all the places where the code might die, this is the most likely,
+  //as FT_New_Face will die if the font file does not exist or is somehow broken.
+  if (FT_New_Face( library_, PChar(fname), 0, face ) <> 0) then
+    raise Exception.create('FT_New_Face failed (there is probably a problem with your font file)');
+
+  //For some twisted reason, Freetype measures font size
+  //in terms of 1/64ths of pixels.  Thus, to make a font
+  //h pixels high, we need to request a size of h*64.
+  //(h shl 6 is just a prettier way of writting h*64)
+  FT_Set_Char_Size( face, h shl 6, h shl 6, 96, 96);
+
+  //Here we ask opengl to allocate resources for
+  //all the textures and displays lists which we
+  //are about to create.  
+  list_base := glGenLists(128);
+  glGenTextures( 128, @textures[0] );
+
+  //This is where we actually create each of the fonts display lists.
+  for i := 0 to 127 do
+    make_dlist(face, i, list_base, @textures[0]);
+
+  //We don't need the face information now that the display
+  //lists have been created, so we free the assosiated resources.
+  FT_Done_Face(face);
+
+  //Ditto for the library.
+  FT_Done_FreeType(library_);
+end;
+
+destructor TFontData.Destroy();
+begin
+  glDeleteLists(list_base, 128);
+  glDeleteTextures(128, @textures[0]);
+  SetLength(textures, 0);
+end;
+
+/// A fairly straight forward function that pushes
+/// a projection matrix that will make object world
+/// coordinates identical to window coordinates.
+procedure pushScreenCoordinateMatrix(); inline;
+var
+  viewport: array [0..3] of GLint;
+begin
+  glPushAttrib(GL_TRANSFORM_BIT);
+  glGetIntegerv(GL_VIEWPORT, @viewport);
+  glMatrixMode(GL_PROJECTION);
+  glPushMatrix();
+  glLoadIdentity();
+  gluOrtho2D(viewport[0], viewport[2], viewport[1], viewport[3]);
+  glPopAttrib();
+end;
+
+/// Pops the projection matrix without changing the current
+/// MatrixMode.
+procedure pop_projection_matrix(); inline;
+begin
+  glPushAttrib(GL_TRANSFORM_BIT);
+  glMatrixMode(GL_PROJECTION);
+  glPopMatrix();
+  glPopAttrib();
+end;
+
+///Much like Nehe's glPrint function, but modified to work
+///with freetype fonts.
+class procedure TFreeType.print(ft_font: TFontData; x, y: single; const str: string);
+var
+  font: GLuint;
+  h: single;
+  i: cardinal;
+  lines: TStringList;
+  modelview_matrix: array[0..15] of single;
+begin
+  // We want a coordinate system where things coresponding to window pixels.
+  pushScreenCoordinateMatrix();
+
+  font := ft_font.list_base;
+  h := ft_font.h / 0.63;      //We make the height about 1.5* that of
+
+  lines := TStringList.Create();
+  ExtractStrings([#13], [], PChar(str), lines);
+
+  glPushAttrib(GL_LIST_BIT or GL_CURRENT_BIT  or GL_ENABLE_BIT or GL_TRANSFORM_BIT);
+  glMatrixMode(GL_MODELVIEW);
+  glDisable(GL_LIGHTING);
+  glEnable(GL_TEXTURE_2D);
+  glDisable(GL_DEPTH_TEST);
+  glEnable(GL_BLEND);
+  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+  glListBase(font);
+
+  glGetFloatv(GL_MODELVIEW_MATRIX, @modelview_matrix);
+
+  //This is where the text display actually happens.
+  //For each line of text we reset the modelview matrix
+  //so that the line's text will start in the correct position.
+  //Notice that we need to reset the matrix, rather than just translating
+  //down by h. This is because when each character is
+  //draw it modifies the current matrix so that the next character
+  //will be drawn immediatly after it.
+  for i := 0 to lines.Count-1 do
+  begin
+    glPushMatrix();
+    glLoadIdentity();
+    glTranslatef(x, y - h*i, 0);
+    glMultMatrixf(@modelview_matrix);
+
+    //  The commented out raster position stuff can be useful if you need to
+    //  know the length of the text that you are creating.
+    //  If you decide to use it make sure to also uncomment the glBitmap command
+    //  in make_dlist().
+    //glRasterPos2f(0,0);
+    glCallLists(Length(lines[i]), GL_UNSIGNED_BYTE, PChar(lines[i]));
+    //float rpos[4];
+    //glGetFloatv(GL_CURRENT_RASTER_POSITION ,rpos);
+    //float len=x-rpos[0];
+
+    glPopMatrix();
+  end;
+
+  glPopAttrib();
+
+  pop_projection_matrix();
+ 
+  lines.Free();
+end;
+
+end.
diff --git a/src/lib/freetype/demo/nehe/lesson43.bdsproj b/src/lib/freetype/demo/nehe/lesson43.bdsproj
new file mode 100644
index 00000000..9d3851c4
--- /dev/null
+++ b/src/lib/freetype/demo/nehe/lesson43.bdsproj
@@ -0,0 +1,175 @@
+<?xml version="1.0" encoding="utf-8"?>

+<BorlandProject>

+  <PersonalityInfo>

+    <Option>

+      <Option Name="Personality">Delphi.Personality</Option>

+      <Option Name="ProjectType">VCLApplication</Option>

+      <Option Name="Version">1.0</Option>

+      <Option Name="GUID">{3306FA70-362B-4647-A969-BCEA731F436C}</Option>

+    </Option>

+  </PersonalityInfo>

+  <Delphi.Personality>

+    <Source>

+      <Source Name="MainSource">lesson43.dpr</Source>

+    </Source>

+    <FileVersion>

+      <FileVersion Name="Version">7.0</FileVersion>

+    </FileVersion>

+    <Compiler>

+      <Compiler Name="A">8</Compiler>

+      <Compiler Name="B">0</Compiler>

+      <Compiler Name="C">1</Compiler>

+      <Compiler Name="D">1</Compiler>

+      <Compiler Name="E">0</Compiler>

+      <Compiler Name="F">0</Compiler>

+      <Compiler Name="G">1</Compiler>

+      <Compiler Name="H">1</Compiler>

+      <Compiler Name="I">1</Compiler>

+      <Compiler Name="J">0</Compiler>

+      <Compiler Name="K">0</Compiler>

+      <Compiler Name="L">1</Compiler>

+      <Compiler Name="M">0</Compiler>

+      <Compiler Name="N">1</Compiler>

+      <Compiler Name="O">1</Compiler>

+      <Compiler Name="P">1</Compiler>

+      <Compiler Name="Q">0</Compiler>

+      <Compiler Name="R">0</Compiler>

+      <Compiler Name="S">0</Compiler>

+      <Compiler Name="T">0</Compiler>

+      <Compiler Name="U">0</Compiler>

+      <Compiler Name="V">1</Compiler>

+      <Compiler Name="W">0</Compiler>

+      <Compiler Name="X">1</Compiler>

+      <Compiler Name="Y">1</Compiler>

+      <Compiler Name="Z">1</Compiler>

+      <Compiler Name="ShowHints">True</Compiler>

+      <Compiler Name="ShowWarnings">True</Compiler>

+      <Compiler Name="UnitAliases">WinTypes=Windows;WinProcs=Windows;DbiTypes=BDE;DbiProcs=BDE;DbiErrs=BDE;</Compiler>

+      <Compiler Name="NamespacePrefix"></Compiler>

+      <Compiler Name="GenerateDocumentation">False</Compiler>

+      <Compiler Name="DefaultNamespace"></Compiler>

+      <Compiler Name="SymbolDeprecated">True</Compiler>

+      <Compiler Name="SymbolLibrary">True</Compiler>

+      <Compiler Name="SymbolPlatform">True</Compiler>

+      <Compiler Name="SymbolExperimental">True</Compiler>

+      <Compiler Name="UnitLibrary">True</Compiler>

+      <Compiler Name="UnitPlatform">True</Compiler>

+      <Compiler Name="UnitDeprecated">True</Compiler>

+      <Compiler Name="UnitExperimental">True</Compiler>

+      <Compiler Name="HResultCompat">True</Compiler>

+      <Compiler Name="HidingMember">True</Compiler>

+      <Compiler Name="HiddenVirtual">True</Compiler>

+      <Compiler Name="Garbage">True</Compiler>

+      <Compiler Name="BoundsError">True</Compiler>

+      <Compiler Name="ZeroNilCompat">True</Compiler>

+      <Compiler Name="StringConstTruncated">True</Compiler>

+      <Compiler Name="ForLoopVarVarPar">True</Compiler>

+      <Compiler Name="TypedConstVarPar">True</Compiler>

+      <Compiler Name="AsgToTypedConst">True</Compiler>

+      <Compiler Name="CaseLabelRange">True</Compiler>

+      <Compiler Name="ForVariable">True</Compiler>

+      <Compiler Name="ConstructingAbstract">True</Compiler>

+      <Compiler Name="ComparisonFalse">True</Compiler>

+      <Compiler Name="ComparisonTrue">True</Compiler>

+      <Compiler Name="ComparingSignedUnsigned">True</Compiler>

+      <Compiler Name="CombiningSignedUnsigned">True</Compiler>

+      <Compiler Name="UnsupportedConstruct">True</Compiler>

+      <Compiler Name="FileOpen">True</Compiler>

+      <Compiler Name="FileOpenUnitSrc">True</Compiler>

+      <Compiler Name="BadGlobalSymbol">True</Compiler>

+      <Compiler Name="DuplicateConstructorDestructor">True</Compiler>

+      <Compiler Name="InvalidDirective">True</Compiler>

+      <Compiler Name="PackageNoLink">True</Compiler>

+      <Compiler Name="PackageThreadVar">True</Compiler>

+      <Compiler Name="ImplicitImport">True</Compiler>

+      <Compiler Name="HPPEMITIgnored">True</Compiler>

+      <Compiler Name="NoRetVal">True</Compiler>

+      <Compiler Name="UseBeforeDef">True</Compiler>

+      <Compiler Name="ForLoopVarUndef">True</Compiler>

+      <Compiler Name="UnitNameMismatch">True</Compiler>

+      <Compiler Name="NoCFGFileFound">True</Compiler>

+      <Compiler Name="ImplicitVariants">True</Compiler>

+      <Compiler Name="UnicodeToLocale">True</Compiler>

+      <Compiler Name="LocaleToUnicode">True</Compiler>

+      <Compiler Name="ImagebaseMultiple">True</Compiler>

+      <Compiler Name="SuspiciousTypecast">True</Compiler>

+      <Compiler Name="PrivatePropAccessor">True</Compiler>

+      <Compiler Name="UnsafeType">False</Compiler>

+      <Compiler Name="UnsafeCode">False</Compiler>

+      <Compiler Name="UnsafeCast">False</Compiler>

+      <Compiler Name="OptionTruncated">True</Compiler>

+      <Compiler Name="WideCharReduced">True</Compiler>

+      <Compiler Name="DuplicatesIgnored">True</Compiler>

+      <Compiler Name="UnitInitSeq">True</Compiler>

+      <Compiler Name="LocalPInvoke">True</Compiler>

+      <Compiler Name="MessageDirective">True</Compiler>

+      <Compiler Name="CodePage"></Compiler>

+    </Compiler>

+    <Linker>

+      <Linker Name="MapFile">0</Linker>

+      <Linker Name="OutputObjs">0</Linker>

+      <Linker Name="GenerateHpps">False</Linker>

+      <Linker Name="ConsoleApp">1</Linker>

+      <Linker Name="DebugInfo">False</Linker>

+      <Linker Name="RemoteSymbols">False</Linker>

+      <Linker Name="GenerateDRC">False</Linker>

+      <Linker Name="MinStackSize">16384</Linker>

+      <Linker Name="MaxStackSize">1048576</Linker>

+      <Linker Name="ImageBase">4194304</Linker>

+      <Linker Name="ExeDescription"></Linker>

+    </Linker>

+    <Directories>

+      <Directories Name="OutputDir"></Directories>

+      <Directories Name="UnitOutputDir"></Directories>

+      <Directories Name="PackageDLLOutputDir"></Directories>

+      <Directories Name="PackageDCPOutputDir"></Directories>

+      <Directories Name="SearchPath">../../../JEDI-SDL/SDL/Pas</Directories>

+      <Directories Name="Packages"></Directories>

+      <Directories Name="Conditionals"></Directories>

+      <Directories Name="DebugSourceDirs"></Directories>

+      <Directories Name="UsePackages">False</Directories>

+    </Directories>

+    <Parameters>

+      <Parameters Name="RunParams"></Parameters>

+      <Parameters Name="HostApplication"></Parameters>

+      <Parameters Name="Launcher"></Parameters>

+      <Parameters Name="UseLauncher">False</Parameters>

+      <Parameters Name="DebugCWD"></Parameters>

+      <Parameters Name="Debug Symbols Search Path"></Parameters>

+      <Parameters Name="LoadAllSymbols">True</Parameters>

+      <Parameters Name="LoadUnspecifiedSymbols">False</Parameters>

+    </Parameters>

+    <Language>

+      <Language Name="ActiveLang"></Language>

+      <Language Name="ProjectLang">$00000000</Language>

+      <Language Name="RootDir"></Language>

+    </Language>

+    <VersionInfo>

+      <VersionInfo Name="IncludeVerInfo">False</VersionInfo>

+      <VersionInfo Name="AutoIncBuild">False</VersionInfo>

+      <VersionInfo Name="MajorVer">1</VersionInfo>

+      <VersionInfo Name="MinorVer">0</VersionInfo>

+      <VersionInfo Name="Release">0</VersionInfo>

+      <VersionInfo Name="Build">0</VersionInfo>

+      <VersionInfo Name="Debug">False</VersionInfo>

+      <VersionInfo Name="PreRelease">False</VersionInfo>

+      <VersionInfo Name="Special">False</VersionInfo>

+      <VersionInfo Name="Private">False</VersionInfo>

+      <VersionInfo Name="DLL">False</VersionInfo>

+      <VersionInfo Name="Locale">1031</VersionInfo>

+      <VersionInfo Name="CodePage">1252</VersionInfo>

+    </VersionInfo>

+    <VersionInfoKeys>

+      <VersionInfoKeys Name="CompanyName"></VersionInfoKeys>

+      <VersionInfoKeys Name="FileDescription"></VersionInfoKeys>

+      <VersionInfoKeys Name="FileVersion">1.0.0.0</VersionInfoKeys>

+      <VersionInfoKeys Name="InternalName"></VersionInfoKeys>

+      <VersionInfoKeys Name="LegalCopyright"></VersionInfoKeys>

+      <VersionInfoKeys Name="LegalTrademarks"></VersionInfoKeys>

+      <VersionInfoKeys Name="OriginalFilename"></VersionInfoKeys>

+      <VersionInfoKeys Name="ProductName"></VersionInfoKeys>

+      <VersionInfoKeys Name="ProductVersion">1.0.0.0</VersionInfoKeys>

+      <VersionInfoKeys Name="Comments"></VersionInfoKeys>

+    </VersionInfoKeys>

+  </Delphi.Personality>

+</BorlandProject>

diff --git a/src/lib/freetype/demo/nehe/lesson43.dpr b/src/lib/freetype/demo/nehe/lesson43.dpr
new file mode 100644
index 00000000..fe296fb5
--- /dev/null
+++ b/src/lib/freetype/demo/nehe/lesson43.dpr
@@ -0,0 +1,289 @@
+program lesson43;
+(*
+ * This code was created by Jeff Molofee '99
+ * (ported to Linux/SDL by Ti Leggett '01)
+ *
+ * If you've found this code useful, please let me know.
+ *
+ * Visit Jeff at http://nehe.gamedev.net/
+ *
+ * or for port-specific comments, questions, bugreports etc.
+ * email to leggett@eecs.tulane.edu
+ *)
+
+{$IFDEF FPC}
+  {$mode delphi}{$H+}
+{$ENDIF}
+
+{$APPTYPE Console}
+
+uses
+  moduleloader in '../../../JEDI-SDL/SDL/Pas/moduleloader.pas',
+  SDL          in '../../../JEDI-SDL/SDL/Pas/sdl.pas',
+  gl           in '../../../JEDI-SDL/OpenGL/Pas/gl.pas',
+  glu          in '../../../JEDI-SDL/OpenGL/Pas/glu.pas',
+  ctypes       in '../../../ctypes/ctypes.pas',
+  FreeType     in '../../freetype.pas',
+  UFreeType    in 'UFreeType.pas',
+  math,
+  sysutils;
+
+const
+  // screen width, height, and bit depth
+  SCREEN_WIDTH  = 640;
+  SCREEN_HEIGHT = 480;
+  SCREEN_BPP    =  16;
+
+var
+  our_font: TFontData;
+  // This is our SDL surface
+  surface: PSDL_Surface;
+  cnt1, cnt2: GLfloat;
+
+(* function to release/destroy our resources and restoring the old desktop *)
+procedure Quit(returnCode: integer);
+begin
+  // clean up the window
+  SDL_Quit( );
+
+  // and exit appropriately
+  Halt( returnCode );
+end;
+
+(* function to reset our viewport after a window resize *)
+function resizeWindow(width: integer; height: integer): boolean;
+var
+  // Height / width ration
+  ratio: GLfloat;
+begin
+  // Protect against a divide by zero
+  if ( height = 0 ) then
+    height := 1;
+
+  ratio := width / height;
+
+  // Setup our viewport.
+  glViewport( 0, 0, GLsizei(width), GLsizei(height) );
+
+  // change to the projection matrix and set our viewing volume.
+  glMatrixMode( GL_PROJECTION );
+  glLoadIdentity( );
+
+  // Set our perspective
+  gluPerspective( 45.0, ratio, 0.1, 100.0 );
+
+  // Make sure we're chaning the model view and not the projection
+  glMatrixMode( GL_MODELVIEW );
+
+  // Reset The View
+  glLoadIdentity( );
+
+  Result := true;
+end;
+
+(* function to handle key press events *)
+procedure handleKeyPress(keysym: PSDL_keysym);
+begin
+  case ( keysym^.sym ) of
+    SDLK_ESCAPE:
+    begin
+      // ESC key was pressed
+      Quit( 0 );
+    end;
+    SDLK_F1:
+    begin
+      // F1 key was pressed
+      // this toggles fullscreen mode
+      SDL_WM_ToggleFullScreen( surface );
+    end;
+  end;
+end;
+
+(* general OpenGL initialization function *)
+function initGL(): boolean;
+begin
+  // Enable smooth shading
+  glShadeModel( GL_SMOOTH );
+
+  // Set the background black
+  glClearColor( 0.0, 0.0, 0.0, 0.0 );
+
+  // Depth buffer setup
+  glClearDepth( 1.0 );
+
+  // Enables Depth Testing
+  glEnable( GL_DEPTH_TEST );
+
+  // The Type Of Depth Test To Do
+  glDepthFunc( GL_LEQUAL );
+
+  // Really Nice Perspective Calculations
+  glHint( GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST );
+
+  our_font := TFontData.Create('Test.ttf', 16);
+
+  Result := true;
+end;
+
+(* Here goes our drawing code *)
+function drawGLScene(): boolean;
+begin
+  glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT);  // Clear Screen And Depth Buffer
+  glLoadIdentity();              // Reset The Current Modelview Matrix
+  glTranslatef(0.0, 0.0, -1.0);  // Move One Unit Into The Screen
+
+  // Blue Text
+  glColor3ub(0, 0, $ff);
+
+  // Position The WGL Text On The Screen
+  glRasterPos2f(-0.40, 0.35);
+
+  // Here We Print Some Text Using Our FreeType Font
+  // The only really important command is the actual print() call,
+  // but for the sake of making the results a bit more interesting
+  // I have put in some code to rotate and scale the text.
+
+  // Red text
+  glColor3ub($ff, 0, 0);
+
+  glPushMatrix();
+  glLoadIdentity();
+  glRotatef(cnt1, 0, 0,1);
+  glScalef(1, 0.8 + 0.3*cos(cnt1/5) ,1);
+  glTranslatef(-180, 0, 0);
+  TFreeType.print(our_font, 320, 240, 'Active FreeType Text - ' + FloatToStr(cnt1));
+  glPopMatrix();
+
+  //Uncomment this to test out print's ability to handle newlines.
+  //TFreeType.print(our_font, 320, 200, 'Here'#13'there'#13'be'#13#13'newlines'#13'.');
+
+  cnt1 := cnt1 + 0.051;  // Increase The First Counter
+  cnt2 := cnt2 + 0.005;  // Increase The First Counter
+
+  SDL_GL_SwapBuffers( );
+
+  Result := true;
+end;
+
+var
+  // Flags to pass to SDL_SetVideoMode
+  videoFlags: integer;
+  // main loop variable
+  done: boolean = false;
+  // used to collect events
+  event: TSDL_Event;
+  // this holds some info about our display
+  videoInfo: PSDL_VideoInfo;
+  // whether or not the window is active
+  isActive: boolean = true;
+
+begin
+  // initialize SDL
+  if ( SDL_Init( SDL_INIT_VIDEO ) < 0 ) then
+  begin
+    writeln( ErrOutput, 'Video initialization failed: ' + SDL_GetError() );
+    Quit( 1 );
+  end;
+
+  // Fetch the video info
+  videoInfo := SDL_GetVideoInfo( );
+
+  if ( videoInfo = nil ) then
+  begin
+    writeln( ErrOutput, 'Video query failed: ' + SDL_GetError() );
+    Quit( 1 );
+  end;
+
+  SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 ); // Enable double buffering
+
+  // the flags to pass to SDL_SetVideoMode
+  videoFlags := SDL_OPENGL;                        // Enable OpenGL in SDL
+  videoFlags := videoFlags or SDL_HWPALETTE;       // Store the palette in hardware
+  videoFlags := videoFlags or SDL_RESIZABLE;       // Enable window resizing
+
+  // This checks to see if surfaces can be stored in memory
+  if ( videoInfo^.hw_available <> 0 ) then
+    videoFlags := videoFlags or SDL_HWSURFACE
+  else
+    videoFlags := videoFlags or SDL_SWSURFACE;
+
+  // This checks if hardware blits can be done
+  if ( videoInfo^.blit_hw <> 0 ) then
+    videoFlags := videoFlags or SDL_HWACCEL;
+
+  // Sets up OpenGL double buffering
+  SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 );
+
+  // get a SDL surface
+  surface := SDL_SetVideoMode( SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_BPP,
+                               videoFlags );
+
+  // Verify there is a surface
+  if ( surface = nil ) then
+  begin
+    writeln( ErrOutput, 'Video mode set failed: ' + SDL_GetError() );
+    Quit( 1 );
+  end;
+
+  // initialize OpenGL
+  initGL();
+
+  // resize the initial window
+  resizeWindow( SCREEN_WIDTH, SCREEN_HEIGHT );
+
+  // wait for events
+  while ( not done ) do
+  begin
+    { handle the events in the queue }
+
+    while ( SDL_PollEvent( @event ) <> 0 ) do
+    begin
+      case( event.type_ ) of
+        SDL_ACTIVEEVENT:
+        begin
+          // Something's happend with our focus
+          // If we are iconified, we shouldn't draw the screen
+          if ( (event.active.state and SDL_APPACTIVE) <> 0 ) then
+          begin
+            if (  event.active.gain = 0 ) then
+              isActive := false
+            else
+              isActive := true;
+          end;
+        end;
+        SDL_VIDEORESIZE:
+        begin
+          // handle resize event
+          {$IFDEF UNIX}
+          surface := SDL_SetVideoMode( event.resize.w,
+              event.resize.h,
+              16, videoFlags );
+          if ( surface = nil ) then
+          begin
+            writeln( ErrOutput, 'Could not get a surface after resize: ' + SDL_GetError( ) );
+            Quit( 1 );
+          end;
+          {$ENDIF}
+          resizeWindow( event.resize.w, event.resize.h );
+        end;
+        SDL_KEYDOWN:
+        begin
+          // handle key presses
+          handleKeyPress( @event.key.keysym );
+        end;
+        SDL_QUITEV:
+        begin
+          // handle quit requests
+          done := true;
+        end;
+      end;
+    end;
+
+    // draw the scene
+    if ( isActive ) then
+      drawGLScene( );
+  end;
+
+  // clean ourselves up and exit
+  Quit( 0 );
+end.
diff --git a/src/lib/freetype/demo/nehe/readme.txt b/src/lib/freetype/demo/nehe/readme.txt
new file mode 100644
index 00000000..1186ef0e
--- /dev/null
+++ b/src/lib/freetype/demo/nehe/readme.txt
@@ -0,0 +1,9 @@
+Pascal conversion of the NeHe tutorial lesson 43  (Tutorial on using FreeType Fonts in OpenGL)
+http://nehe.gamedev.net/data/lessons/lesson.asp?lesson=43
+
+Put the following DLLs into this directory:
+- libfreetype-6.dll
+- SDL.dll
+- zlib1.dll
+
+and copy a TrueType font to this directory and rename it into "Test.ttf".
diff --git a/src/lib/freetype/demo/switches.inc b/src/lib/freetype/demo/switches.inc
new file mode 100644
index 00000000..0a940004
--- /dev/null
+++ b/src/lib/freetype/demo/switches.inc
@@ -0,0 +1 @@
+{$DEFINE FREETYPE_DEMO}