aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--src/base/UFont.pas5326
-rw-r--r--src/lib/freetype/demo/UFont.pas2641
-rw-r--r--src/lib/freetype/demo/engine-test.bdsproj (renamed from src/lib/freetype/demo/lesson43.bdsproj)2
-rw-r--r--src/lib/freetype/demo/engine-test.dpr (renamed from src/lib/freetype/demo/lesson43.dpr)702
-rw-r--r--src/lib/freetype/demo/engine-test.lpi (renamed from src/lib/freetype/demo/lesson43.lpi)113
-rw-r--r--src/lib/freetype/demo/nehe/UFreeType.pas326
-rw-r--r--src/lib/freetype/demo/nehe/lesson43.bdsproj175
-rw-r--r--src/lib/freetype/demo/nehe/lesson43.dpr289
-rw-r--r--src/lib/freetype/demo/nehe/readme.txt9
-rw-r--r--src/lib/freetype/demo/switches.inc1
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}
generated by cgit v1.2.3 (git 2.25.1) at 2024-12-28 13:12:32 +0000