freetype stuff for testing

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

7 files changed, 6572 insertions, 0 deletions

diff --git a/src/lib/freetype/demo/Kopie von UFreeType.pas b/src/lib/freetype/demo/Kopie von UFreeType.pas
new file mode 100644
index 00000000..c1243aae
--- /dev/null
+++ b/src/lib/freetype/demo/Kopie von 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/Kopie von lesson43.dpr b/src/lib/freetype/demo/Kopie von lesson43.dpr
new file mode 100644
index 00000000..b49423fb
--- /dev/null
+++ b/src/lib/freetype/demo/Kopie von 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/UFont.pas b/src/lib/freetype/demo/UFont.pas
new file mode 100644
index 00000000..c15ff4ca
--- /dev/null
+++ b/src/lib/freetype/demo/UFont.pas
@@ -0,0 +1,2641 @@
+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/lesson43.bdsproj
new file mode 100644
index 00000000..30f88ab3
--- /dev/null
+++ b/src/lib/freetype/demo/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">{41656F26-D552-4948-B9DB-E184B77C3993}</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">0</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">vclx;vcl;rtl;vclactnband</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/lesson43.dpr b/src/lib/freetype/demo/lesson43.dpr
new file mode 100644
index 00000000..8a470a2e
--- /dev/null
+++ b/src/lib/freetype/demo/lesson43.dpr
@@ -0,0 +1,366 @@
+ďťż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.

diff --git a/src/lib/freetype/demo/lesson43.lpi b/src/lib/freetype/demo/lesson43.lpi
new file mode 100644
index 00000000..b6791f18
--- /dev/null
+++ b/src/lib/freetype/demo/lesson43.lpi
@@ -0,0 +1,272 @@
+<?xml version="1.0"?>

+<CONFIG>

+  <ProjectOptions>

+    <PathDelim Value="\"/>

+    <Version Value="6"/>

+    <General>

+      <MainUnit Value="0"/>

+      <IconPath Value=".\"/>

+      <TargetFileExt Value=""/>

+      <ActiveEditorIndexAtStart Value="1"/>

+    </General>

+    <VersionInfo>

+      <ProjectVersion Value=""/>

+      <Language Value=""/>

+      <CharSet Value=""/>

+    </VersionInfo>

+    <PublishOptions>

+      <Version Value="2"/>

+      <DestinationDirectory Value="$(TestDir)\publishedproject\"/>

+      <IgnoreBinaries Value="False"/>

+      <IncludeFileFilter Value="*.(pas|pp|inc|lfm|lpr|lrs|lpi|lpk|sh|xml)"/>

+      <ExcludeFileFilter Value="*.(bak|ppu|ppw|o|so);*~;backup"/>

+    </PublishOptions>

+    <RunParams>

+      <local>

+        <FormatVersion Value="1"/>

+        <LaunchingApplication PathPlusParams="\usr\X11R6\bin\xterm -T 'Lazarus Run Output' -e $(LazarusDir)\tools\runwait.sh $(TargetCmdLine)"/>

+      </local>

+    </RunParams>

+    <Units Count="16">

+      <Unit0>

+        <Filename Value="lesson43.dpr"/>

+        <IsPartOfProject Value="True"/>

+        <UnitName Value="lesson43"/>

+        <CursorPos X="1" Y="138"/>

+        <TopLine Value="118"/>

+        <EditorIndex Value="0"/>

+        <UsageCount Value="72"/>

+        <Loaded Value="True"/>

+      </Unit0>

+      <Unit1>

+        <Filename Value="JEDI-SDL\OpenGL\Pas\opengl12.pas"/>

+        <UnitName Value="opengl12"/>

+        <CursorPos X="20" Y="9922"/>

+        <TopLine Value="9889"/>

+        <UsageCount Value="5"/>

+      </Unit1>

+      <Unit2>

+        <Filename Value="JEDI-SDL\SDL\Pas\sdl.pas"/>

+        <UnitName Value="sdl"/>

+        <CursorPos X="29" Y="3569"/>

+        <TopLine Value="3547"/>

+        <UsageCount Value="5"/>

+      </Unit2>

+      <Unit3>

+        <Filename Value="FreeType.pas"/>

+        <UnitName Value="FreeType"/>

+        <CursorPos X="6" Y="1"/>

+        <TopLine Value="1"/>

+        <UsageCount Value="5"/>

+      </Unit3>

+      <Unit4>

+        <Filename Value="UFreeType.pas"/>

+        <UnitName Value="UFreeType"/>

+        <CursorPos X="47" Y="111"/>

+        <TopLine Value="76"/>

+        <UsageCount Value="35"/>

+      </Unit4>

+      <Unit5>

+        <Filename Value="freetype"/>

+        <CursorPos X="1" Y="1"/>

+        <TopLine Value="1"/>

+        <UsageCount Value="8"/>

+        <SyntaxHighlighter Value="None"/>

+      </Unit5>

+      <Unit6>

+        <Filename Value="freetype\freetype.pas"/>

+        <UnitName Value="freetype"/>

+        <CursorPos X="31" Y="807"/>

+        <TopLine Value="14"/>

+        <UsageCount Value="15"/>

+      </Unit6>

+      <Unit7>

+        <Filename Value="..\..\daten\Projekte\UltraStarDX\trunk\Game\Code\lib\ffmpeg\avcodec.pas"/>

+        <UnitName Value="avcodec"/>

+        <CursorPos X="1" Y="38"/>

+        <TopLine Value="1"/>

+        <UsageCount Value="6"/>

+      </Unit7>

+      <Unit8>

+        <Filename Value="..\..\JEDI-SDL\OpenGL\Pas\gl.pas"/>

+        <UnitName Value="gl"/>

+        <CursorPos X="2" Y="89"/>

+        <TopLine Value="69"/>

+        <UsageCount Value="9"/>

+      </Unit8>

+      <Unit9>

+        <Filename Value="..\..\ctypes\ctypes.pas"/>

+        <UnitName Value="ctypes"/>

+        <CursorPos X="8" Y="25"/>

+        <TopLine Value="51"/>

+        <UsageCount Value="9"/>

+      </Unit9>

+      <Unit10>

+        <Filename Value="..\..\JEDI-SDL\OpenGL\Pas\glu.pas"/>

+        <UnitName Value="glu"/>

+        <CursorPos X="14" Y="155"/>

+        <TopLine Value="135"/>

+        <UsageCount Value="9"/>

+      </Unit10>

+      <Unit11>

+        <Filename Value="..\..\JEDI-SDL\SDL\Pas\sdl.pas"/>

+        <UnitName Value="sdl"/>

+        <CursorPos X="12" Y="1418"/>

+        <TopLine Value="1398"/>

+        <UsageCount Value="9"/>

+      </Unit11>

+      <Unit12>

+        <Filename Value="..\freetype.pas"/>

+        <UnitName Value="freetype"/>

+        <CursorPos X="3" Y="1985"/>

+        <TopLine Value="1965"/>

+        <UsageCount Value="10"/>

+      </Unit12>

+      <Unit13>

+        <Filename Value="C:\Programme\lazarus\fpc\2.2.0\source\rtl\objpas\classes\classesh.inc"/>

+        <CursorPos X="13" Y="26"/>

+        <TopLine Value="6"/>

+        <UsageCount Value="13"/>

+      </Unit13>

+      <Unit14>

+        <Filename Value="C:\Programme\lazarus\fpc\2.2.0\source\rtl\objpas\types.pp"/>

+        <UnitName Value="types"/>

+        <CursorPos X="7" Y="105"/>

+        <TopLine Value="73"/>

+        <UsageCount Value="12"/>

+      </Unit14>

+      <Unit15>

+        <Filename Value="UFont.pas"/>

+        <UnitName Value="UFont"/>

+        <CursorPos X="1" Y="1751"/>

+        <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>

+  </ProjectOptions>

+  <CompilerOptions>

+    <Version Value="5"/>

+    <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">

+      <Item1>

+        <Source Value="lesson43.dpr"/>

+        <Line Value="138"/>

+      </Item1>

+      <Item2>

+        <Source Value="UFont.pas"/>

+        <Line Value="1751"/>

+      </Item2>

+    </BreakPoints>

+    <Exceptions Count="2">

+      <Item1>

+        <Name Value="ECodetoolError"/>

+      </Item1>

+      <Item2>

+        <Name Value="EFOpenError"/>

+      </Item2>

+    </Exceptions>

+  </Debugging>

+</CONFIG>

diff --git a/src/lib/freetype/freetype.pas b/src/lib/freetype/freetype.pas
new file mode 100644
index 00000000..65cce749
--- /dev/null
+++ b/src/lib/freetype/freetype.pas
@@ -0,0 +1,2503 @@
+//----------------------------------------------------------------------------
+// FreeType2 pascal header
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4 (Public License)
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Anti-Grain Geometry - Version 2.4 Release Milano 3 (AggPas 2.4 RM3)
+// Pascal Port By: Milan Marusinec alias Milano
+//                 milan@marusinec.sk
+//                 http://www.aggpas.org
+// Copyright (c) 2005-2007
+//
+// Permission to copy, use, modify, sell and distribute this software
+// is granted provided this copyright notice appears in all copies.
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Adapted by the UltraStar Deluxe Team
+//----------------------------------------------------------------------------
+
+unit freetype;
+
+interface
+
+{$IFDEF FPC}
+  {$MODE DELPHI }
+  {$PACKENUM 4}    (* use 4-byte enums *)
+  {$PACKRECORDS C} (* C/C++-compatible record packing *)
+{$ELSE}
+  {$MINENUMSIZE 4} (* use 4-byte enums *)
+{$ENDIF}
+
+uses
+  ctypes;
+
+const
+{$IF Defined(MSWINDOWS)}
+  ft_lib = 'libfreetype-6.dll';

+{$ELSEIF Defined(DARWIN)}

+  ft_lib = 'libfreetype.dylib';

+  {$LINKLIB libftgl}

+{$ELSEIF Defined(UNIX)}

+  ft_lib = 'freetype.so';

+{$IFEND}

+
+type
+  FT_Byte    = cuchar;
+  FT_Short   = csshort;
+  FT_UShort  = cushort;
+  FT_Int     = csint;
+  FT_UInt    = cuint;
+  FT_Int16   = cint16;
+  FT_UInt16  = cuint16;
+  FT_Int32   = cint32;
+  FT_UInt32  = cuint32;
+  FT_Long    = cslong;
+  FT_ULong   = culong;
+
+  FT_Fixed   = cslong;
+  FT_Pos     = cslong;
+  FT_Error   = cint;
+  FT_F26Dot6 = cslong;
+  FT_String  = cchar;
+  FT_Bool    = cuchar;
+
+  PFT_Byte   = ^FT_Byte;
+  PFT_Short  = ^FT_Short;
+  PFT_String = ^FT_String;
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Enum>                                                                *)
+  (*    FT_FACE_FLAG_XXX                                                   *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    A list of bit flags used in the `face_flags' field of the          *)
+  (*    @FT_FaceRec structure.  They inform client applications of         *)
+  (*    properties of the corresponding face.                              *)
+  (*                                                                       *)
+  (* <Values>                                                              *)
+  (*    FT_FACE_FLAG_SCALABLE ::                                           *)
+  (*      Indicates that the face provides vectorial outlines.  This       *)
+  (*      doesn't prevent embedded bitmaps, i.e., a face can have both     *)
+  (*      this bit and @FT_FACE_FLAG_FIXED_SIZES set.                      *)
+  (*                                                                       *)
+  (*    FT_FACE_FLAG_FIXED_SIZES ::                                        *)
+  (*      Indicates that the face contains `fixed sizes', i.e., bitmap     *)
+  (*      strikes for some given pixel sizes.  See the `num_fixed_sizes'   *)
+  (*      and `available_sizes' fields of @FT_FaceRec.                     *)
+  (*                                                                       *)
+  (*    FT_FACE_FLAG_FIXED_WIDTH ::                                        *)
+  (*      Indicates that the face contains fixed-width characters (like    *)
+  (*      Courier, Lucido, MonoType, etc.).                                *)
+  (*                                                                       *)
+  (*    FT_FACE_FLAG_SFNT ::                                               *)
+  (*      Indicates that the face uses the `sfnt' storage scheme.  For     *)
+  (*      now, this means TrueType and OpenType.                           *)
+  (*                                                                       *)
+  (*    FT_FACE_FLAG_HORIZONTAL ::                                         *)
+  (*      Indicates that the face contains horizontal glyph metrics.  This *)
+  (*      should be set for all common formats.                            *)
+  (*                                                                       *)
+  (*    FT_FACE_FLAG_VERTICAL ::                                           *)
+  (*      Indicates that the face contains vertical glyph metrics.  This   *)
+  (*      is only available in some formats, not all of them.              *)
+  (*                                                                       *)
+  (*    FT_FACE_FLAG_KERNING ::                                            *)
+  (*      Indicates that the face contains kerning information.  If set,   *)
+  (*      the kerning distance can be retrieved through the function       *)
+  (*      @FT_Get_Kerning.  Note that if unset, this function will always  *)
+  (*      return the vector (0,0).                                         *)
+  (*                                                                       *)
+  (*    FT_FACE_FLAG_FAST_GLYPHS ::                                        *)
+  (*      THIS FLAG IS DEPRECATED.  DO NOT USE OR TEST IT.                 *)
+  (*                                                                       *)
+  (*    FT_FACE_FLAG_MULTIPLE_MASTERS ::                                   *)
+  (*      Indicates that the font contains multiple masters and is capable *)
+  (*      of interpolating between them.  See the multiple-masters         *)
+  (*      specific API for details.                                        *)
+  (*                                                                       *)
+  (*    FT_FACE_FLAG_GLYPH_NAMES ::                                        *)
+  (*      Indicates that the font contains glyph names that can be         *)
+  (*      retrieved through @FT_Get_Glyph_Name.  Note that some TrueType   *)
+  (*      fonts contain broken glyph name tables.  Use the function        *)
+  (*      @FT_Has_PS_Glyph_Names when needed.                              *)
+  (*                                                                       *)
+  (*    FT_FACE_FLAG_EXTERNAL_STREAM ::                                    *)
+  (*      Used internally by FreeType to indicate that a face's stream was *)
+  (*      provided by the client application and should not be destroyed   *)
+  (*      when @FT_Done_Face is called.  Don't read or test this flag.     *)
+  (*                                                                       *)
+const
+  FT_FACE_FLAG_SCALABLE = 1 shl 0;
+  FT_FACE_FLAG_KERNING  = 1 shl 6;
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Enum>                                                                *)
+  (*    FT_Encoding                                                        *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    An enumeration used to specify encodings supported by charmaps.    *)
+  (*    Used in the @FT_Select_Charmap API function.                       *)
+  (*                                                                       *)
+  (* <Note>                                                                *)
+  (*    Because of 32-bit charcodes defined in Unicode (i.e., surrogates), *)
+  (*    all character codes must be expressed as FT_Longs.                 *)
+  (*                                                                       *)
+  (*    The values of this type correspond to specific character           *)
+  (*    repertories (i.e. charsets), and not to text encoding methods      *)
+  (*    (like UTF-8, UTF-16, GB2312_EUC, etc.).                            *)
+  (*                                                                       *)
+  (*    Other encodings might be defined in the future.                    *)
+  (*                                                                       *)
+  (* <Values>                                                              *)
+  (*   FT_ENCODING_NONE ::                                                 *)
+  (*     The encoding value 0 is reserved.                                 *)
+  (*                                                                       *)
+  (*   FT_ENCODING_UNICODE ::                                              *)
+  (*     Corresponds to the Unicode character set.  This value covers      *)
+  (*     all versions of the Unicode repertoire, including ASCII and       *)
+  (*     Latin-1.  Most fonts include a Unicode charmap, but not all       *)
+  (*     of them.                                                          *)
+  (*                                                                       *)
+  (*   FT_ENCODING_MS_SYMBOL ::                                            *)
+  (*     Corresponds to the Microsoft Symbol encoding, used to encode      *)
+  (*     mathematical symbols in the 32..255 character code range.  For    *)
+  (*     more information, see `http://www.ceviz.net/symbol.htm'.          *)
+  (*                                                                       *)
+  (*   FT_ENCODING_SJIS ::                                                 *)
+  (*     Corresponds to Japanese SJIS encoding.  More info at              *)
+  (*     at `http://langsupport.japanreference.com/encoding.shtml'.        *)
+  (*     See note on multi-byte encodings below.                           *)
+  (*                                                                       *)
+  (*   FT_ENCODING_GB2312 ::                                               *)
+  (*     Corresponds to an encoding system for Simplified Chinese as used  *)
+  (*     used in mainland China.                                           *)
+  (*                                                                       *)
+  (*   FT_ENCODING_BIG5 ::                                                 *)
+  (*     Corresponds to an encoding system for Traditional Chinese as used *)
+  (*     in Taiwan and Hong Kong.                                          *)
+  (*                                                                       *)
+  (*   FT_ENCODING_WANSUNG ::                                              *)
+  (*     Corresponds to the Korean encoding system known as Wansung.       *)
+  (*     For more information see                                          *)
+  (*     `http://www.microsoft.com/typography/unicode/949.txt'.            *)
+  (*                                                                       *)
+  (*   FT_ENCODING_JOHAB ::                                                *)
+  (*     The Korean standard character set (KS C-5601-1992), which         *)
+  (*     corresponds to MS Windows code page 1361.  This character set     *)
+  (*     includes all possible Hangeul character combinations.             *)
+  (*                                                                       *)
+  (*   FT_ENCODING_ADOBE_LATIN_1 ::                                        *)
+  (*     Corresponds to a Latin-1 encoding as defined in a Type 1          *)
+  (*     Postscript font.  It is limited to 256 character codes.           *)
+  (*                                                                       *)
+  (*   FT_ENCODING_ADOBE_STANDARD ::                                       *)
+  (*     Corresponds to the Adobe Standard encoding, as found in Type 1,   *)
+  (*     CFF, and OpenType/CFF fonts.  It is limited to 256 character      *)
+  (*     codes.                                                            *)
+  (*                                                                       *)
+  (*   FT_ENCODING_ADOBE_EXPERT ::                                         *)
+  (*     Corresponds to the Adobe Expert encoding, as found in Type 1,     *)
+  (*     CFF, and OpenType/CFF fonts.  It is limited to 256 character      *)
+  (*     codes.                                                            *)
+  (*                                                                       *)
+  (*   FT_ENCODING_ADOBE_CUSTOM ::                                         *)
+  (*     Corresponds to a custom encoding, as found in Type 1, CFF, and    *)
+  (*     OpenType/CFF fonts.  It is limited to 256 character codes.        *)
+  (*                                                                       *)
+  (*   FT_ENCODING_APPLE_ROMAN ::                                          *)
+  (*     Corresponds to the 8-bit Apple roman encoding.  Many TrueType and *)
+  (*     OpenType fonts contain a charmap for this encoding, since older   *)
+  (*     versions of Mac OS are able to use it.                            *)
+  (*                                                                       *)
+  (*   FT_ENCODING_OLD_LATIN_2 ::                                          *)
+  (*     This value is deprecated and was never used nor reported by       *)
+  (*     FreeType.  Don't use or test for it.                              *)
+  (*                                                                       *)
+  (*   FT_ENCODING_MS_SJIS ::                                              *)
+  (*     Same as FT_ENCODING_SJIS.  Deprecated.                            *)
+  (*                                                                       *)
+  (*   FT_ENCODING_MS_GB2312 ::                                            *)
+  (*     Same as FT_ENCODING_GB2312.  Deprecated.                          *)
+  (*                                                                       *)
+  (*   FT_ENCODING_MS_BIG5 ::                                              *)
+  (*     Same as FT_ENCODING_BIG5.  Deprecated.                            *)
+  (*                                                                       *)
+  (*   FT_ENCODING_MS_WANSUNG ::                                           *)
+  (*     Same as FT_ENCODING_WANSUNG.  Deprecated.                         *)
+  (*                                                                       *)
+  (*   FT_ENCODING_MS_JOHAB ::                                             *)
+  (*     Same as FT_ENCODING_JOHAB.  Deprecated.                           *)
+  (*                                                                       *)
+  (* <Note>                                                                *)
+  (*   By default, FreeType automatically synthetizes a Unicode charmap    *)
+  (*   for Postscript fonts, using their glyph names dictionaries.         *)
+  (*   However, it will also report the encodings defined explicitly in    *)
+  (*   the font file, for the cases when they are needed, with the Adobe   *)
+  (*   values as well.                                                     *)
+  (*                                                                       *)
+  (*   FT_ENCODING_NONE is set by the BDF and PCF drivers if the charmap   *)
+  (*   is neither Unicode nor ISO-8859-1 (otherwise it is set to           *)
+  (*   FT_ENCODING_UNICODE).  Use `FT_Get_BDF_Charset_ID' to find out      *)
+  (*   which encoding is really present.  If, for example, the             *)
+  (*   `cs_registry' field is `KOI8' and the `cs_encoding' field is `R',   *)
+  (*   the font is encoded in KOI8-R.                                      *)
+  (*                                                                       *)
+  (*   FT_ENCODING_NONE is always set (with a single exception) by the     *)
+  (*   winfonts driver.  Use `FT_Get_WinFNT_Header' and examine the        *)
+  (*   `charset' field of the `FT_WinFNT_HeaderRec' structure to find out  *)
+  (*   which encoding is really present.  For example, FT_WinFNT_ID_CP1251 *)
+  (*   (204) means Windows code page 1251 (for Russian).                   *)
+  (*                                                                       *)
+  (*   FT_ENCODING_NONE is set if `platform_id' is `TT_PLATFORM_MACINTOSH' *)
+  (*   and `encoding_id' is not `TT_MAC_ID_ROMAN' (otherwise it is set to  *)
+  (*   FT_ENCODING_APPLE_ROMAN).                                           *)
+  (*                                                                       *)
+  (*   If `platform_id' is `TT_PLATFORM_MACINTOSH', use the function       *)
+  (*   `FT_Get_CMap_Language_ID' to query the Mac language ID which may be *)
+  (*   needed to be able to distinguish Apple encoding variants.  See      *)
+  (*                                                                       *)
+  (*     http://www.unicode.org/Public/MAPPINGS/VENDORS/APPLE/README.TXT   *)
+  (*                                                                       *)
+  (*   to get an idea how to do that.  Basically, if the language ID is 0, *)
+  (*   dont use it, otherwise subtract 1 from the language ID.  Then       *)
+  (*   examine `encoding_id'.  If, for example, `encoding_id' is           *)
+  (*   `TT_MAC_ID_ROMAN' and the language ID (minus 1) is                  *)
+  (*   `TT_MAC_LANGID_GREEK', it is the Greek encoding, not Roman.         *)
+  (*   `TT_MAC_ID_ARABIC' with `TT_MAC_LANGID_FARSI' means the Farsi       *)
+  (*   variant the Arabic encoding.                                        *)
+  (*                                                                       *)
+type
+  PFT_Encoding = ^FT_Encoding;
+  FT_Encoding = array[0..3] of char;
+const
+  FT_ENCODING_NONE:      FT_Encoding = (#0 ,#0 ,#0 ,#0 );
+  FT_ENCODING_MS_SYMBOL: FT_Encoding = ('s', 'y', 'm', 'b' );
+  FT_ENCODING_UNICODE:   FT_Encoding = ('u', 'n', 'i', 'c' );
+
+  FT_ENCODING_SJIS:      FT_Encoding = ('s', 'j', 'i', 's');
+  FT_ENCODING_GB2312:    FT_Encoding = ('g', 'b', ' ', ' ');
+  FT_ENCODING_BIG5:      FT_Encoding = ('b', 'i', 'g', '5');
+  FT_ENCODING_WANSUNG:   FT_Encoding = ('w', 'a', 'n', 's');
+  FT_ENCODING_JOHAB:     FT_Encoding = ('j', 'o', 'h', 'a');
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Enum>                                                                *)
+  (*    FT_Glyph_Format                                                    *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    An enumeration type used to describe the format of a given glyph   *)
+  (*    image.  Note that this version of FreeType only supports two image *)
+  (*    formats, even though future font drivers will be able to register  *)
+  (*    their own format.                                                  *)
+  (*                                                                       *)
+  (* <Values>                                                              *)
+  (*    FT_GLYPH_FORMAT_NONE ::                                            *)
+  (*      The value 0 is reserved and does describe a glyph format.        *)
+  (*                                                                       *)
+  (*    FT_GLYPH_FORMAT_COMPOSITE ::                                       *)
+  (*      The glyph image is a composite of several other images.  This    *)
+  (*      format is _only_ used with @FT_LOAD_NO_RECURSE, and is used to   *)
+  (*      report compound glyphs (like accented characters).               *)
+  (*                                                                       *)
+  (*    FT_GLYPH_FORMAT_BITMAP ::                                          *)
+  (*      The glyph image is a bitmap, and can be described as an          *)
+  (*      @FT_Bitmap.  You generally need to access the `bitmap' field of  *)
+  (*      the @FT_GlyphSlotRec structure to read it.                       *)
+  (*                                                                       *)
+  (*    FT_GLYPH_FORMAT_OUTLINE ::                                         *)
+  (*      The glyph image is a vertorial outline made of line segments     *)
+  (*      and Bezier arcs; it can be described as an @FT_Outline; you      *)
+  (*      generally want to access the `outline' field of the              *)
+  (*      @FT_GlyphSlotRec structure to read it.                           *)
+  (*                                                                       *)
+  (*    FT_GLYPH_FORMAT_PLOTTER ::                                         *)
+  (*      The glyph image is a vectorial path with no inside/outside       *)
+  (*      contours.  Some Type 1 fonts, like those in the Hershey family,  *)
+  (*      contain glyphs in this format.  These are described as           *)
+  (*      @FT_Outline, but FreeType isn't currently capable of rendering   *)
+  (*      them correctly.                                                  *)
+  (*                                                                       *)
+type
+  FT_Glyph_Format = array[0..3] of char;
+const
+  FT_GLYPH_FORMAT_NONE:      FT_Glyph_Format = (#0, #0, #0, #0 );
+
+  FT_GLYPH_FORMAT_COMPOSITE: FT_Glyph_Format = ('c', 'o', 'm', 'p' );
+  FT_GLYPH_FORMAT_BITMAP:    FT_Glyph_Format = ('b', 'i', 't', 's' );
+  FT_GLYPH_FORMAT_OUTLINE:   FT_Glyph_Format = ('o', 'u', 't', 'l' );
+  FT_GLYPH_FORMAT_PLOTTER:   FT_Glyph_Format = ('p', 'l', 'o', 't' );
+
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Constant>                                                            *)
+  (*    FT_STYLE_FLAG_XXX                                                  *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    A list of bit-flags used to indicate the style of a given face.    *)
+  (*    These are used in the `style_flags' field of @FT_FaceRec.          *)
+  (*                                                                       *)
+  (* <Values>                                                              *)
+  (*    FT_STYLE_FLAG_ITALIC ::                                            *)
+  (*      Indicates that a given face is italicized.                       *)
+  (*                                                                       *)
+  (*    FT_STYLE_FLAG_BOLD ::                                              *)
+  (*      Indicates that a given face is bold.                             *)
+  (*                                                                       *)
+const
+  FT_STYLE_FLAG_ITALIC = 1 shl 0;
+  FT_STYLE_FLAG_BOLD   = 1 shl 1;
+  
+
+ (***************************************************************************
+  *
+  * @enum:
+  *   FT_LOAD_XXX
+  *
+  * @description:
+  *   A list of bit-field constants, used with @FT_Load_Glyph to indicate
+  *   what kind of operations to perform during glyph loading.
+  *
+  * @values:
+  *   FT_LOAD_DEFAULT ::
+  *     Corresponding to 0, this value is used a default glyph load.  In this
+  *     case, the following will happen:
+  *
+  *     1. FreeType looks for a bitmap for the glyph corresponding to the
+  *        face's current size.  If one is found, the function returns.  The
+  *        bitmap data can be accessed from the glyph slot (see note below).
+  *
+  *     2. If no embedded bitmap is searched or found, FreeType looks for a
+  *        scalable outline.  If one is found, it is loaded from the font
+  *        file, scaled to device pixels, then "hinted" to the pixel grid in
+  *        order to optimize it.  The outline data can be accessed from the
+  *        glyph slot (see note below).
+  *
+  *     Note that by default, the glyph loader doesn't render outlines into
+  *     bitmaps.  The following flags are used to modify this default
+  *     behaviour to more specific and useful cases.
+  *
+  *   FT_LOAD_NO_SCALE ::
+  *     Don't scale the vector outline being loaded to 26.6 fractional
+  *     pixels, but kept in font units.  Note that this also disables
+  *     hinting and the loading of embedded bitmaps.  You should only use it
+  *     when you want to retrieve the original glyph outlines in font units.
+  *
+  *   FT_LOAD_NO_HINTING ::
+  *     Don't hint glyph outlines after their scaling to device pixels.
+  *     This generally generates "blurrier" glyphs in anti-aliased modes.
+  *
+  *     This flag is ignored if @FT_LOAD_NO_SCALE is set.
+  *
+  *   FT_LOAD_RENDER ::
+  *     Render the glyph outline immediately into a bitmap before the glyph
+  *     loader returns.  By default, the glyph is rendered for the
+  *     @FT_RENDER_MODE_NORMAL mode, which corresponds to 8-bit anti-aliased
+  *     bitmaps using 256 opacity levels.  You can use either
+  *     @FT_LOAD_TARGET_MONO or @FT_LOAD_MONOCHROME to render 1-bit
+  *     monochrome bitmaps.
+  *
+  *     This flag is ignored if @FT_LOAD_NO_SCALE is set.
+  *
+  *   FT_LOAD_NO_BITMAP ::
+  *     Don't look for bitmaps when loading the glyph.  Only scalable
+  *     outlines will be loaded when available, and scaled, hinted, or
+  *     rendered depending on other bit flags.
+  *
+  *     This does not prevent you from rendering outlines to bitmaps
+  *     with @FT_LOAD_RENDER, however.
+  *
+  *   FT_LOAD_VERTICAL_LAYOUT ::
+  *     Prepare the glyph image for vertical text layout.  This basically
+  *     means that `face.glyph.advance' will correspond to the vertical
+  *     advance height (instead of the default horizontal advance width),
+  *     and that the glyph image will be translated to match the vertical
+  *     bearings positions.
+  *
+  *   FT_LOAD_FORCE_AUTOHINT ::
+  *     Force the use of the FreeType auto-hinter when a glyph outline is
+  *     loaded.  You shouldn't need this in a typical application, since it
+  *     is mostly used to experiment with its algorithm.
+  *
+  *   FT_LOAD_CROP_BITMAP ::
+  *     Indicates that the glyph loader should try to crop the bitmap (i.e.,
+  *     remove all space around its black bits) when loading it.  This is
+  *     only useful when loading embedded bitmaps in certain fonts, since
+  *     bitmaps rendered with @FT_LOAD_RENDER are always cropped by default.
+  *
+  *   FT_LOAD_PEDANTIC ::
+  *     Indicates that the glyph loader should perform pedantic
+  *     verifications during glyph loading, rejecting invalid fonts.  This
+  *     is mostly used to detect broken glyphs in fonts.  By default,
+  *     FreeType tries to handle broken fonts also.
+  *
+  *   FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH ::
+  *     Indicates that the glyph loader should ignore the global advance
+  *     width defined in the font.  As far as we know, this is only used by
+  *     the X-TrueType font server, in order to deal correctly with the
+  *     incorrect metrics contained in DynaLab's TrueType CJK fonts.
+  *
+  *   FT_LOAD_NO_RECURSE ::
+  *     This flag is only used internally.  It merely indicates that the
+  *     glyph loader should not load composite glyphs recursively.  Instead,
+  *     it should set the `num_subglyph' and `subglyphs' values of the glyph
+  *     slot accordingly, and set "glyph->format" to
+  *     @FT_GLYPH_FORMAT_COMPOSITE.
+  *
+  *     The description of sub-glyphs is not available to client
+  *     applications for now.
+  *
+  *   FT_LOAD_IGNORE_TRANSFORM ::
+  *     Indicates that the glyph loader should not try to transform the
+  *     loaded glyph image.  This doesn't prevent scaling, hinting, or
+  *     rendering.
+  *
+  *   FT_LOAD_MONOCHROME ::
+  *     This flag is used with @FT_LOAD_RENDER to indicate that you want
+  *     to render a 1-bit monochrome glyph bitmap from a vectorial outline.
+  *
+  *     Note that this has no effect on the hinting algorithm used by the
+  *     glyph loader.  You should better use @FT_LOAD_TARGET_MONO if you
+  *     want to render monochrome-optimized glyph images instead.
+  *
+  *   FT_LOAD_LINEAR_DESIGN ::
+  *     Return the linearly scaled metrics expressed in original font units
+  *     instead of the default 16.16 pixel values.
+  *
+  *   FT_LOAD_NO_AUTOHINT ::
+  *     Indicates that the auto-hinter should never be used to hint glyph
+  *     outlines.  This doesn't prevent native format-specific hinters from
+  *     being used.  This can be important for certain fonts where unhinted
+  *     output is better than auto-hinted one.
+  *
+  *   FT_LOAD_TARGET_NORMAL ::
+  *     Use hinting for @FT_RENDER_MODE_NORMAL.
+  *
+  *   FT_LOAD_TARGET_LIGHT ::
+  *     Use hinting for @FT_RENDER_MODE_LIGHT.
+  *
+  *   FT_LOAD_TARGET_MONO ::
+  *     Use hinting for @FT_RENDER_MODE_MONO.
+  *
+  *   FT_LOAD_TARGET_LCD ::
+  *     Use hinting for @FT_RENDER_MODE_LCD.
+  *
+  *   FT_LOAD_TARGET_LCD_V ::
+  *     Use hinting for @FT_RENDER_MODE_LCD_V.
+  *)
+const
+  FT_LOAD_DEFAULT          = $0000;
+  FT_LOAD_NO_SCALE         = $0001;
+  FT_LOAD_NO_HINTING       = $0002;
+  FT_LOAD_RENDER           = $0004;
+  FT_LOAD_NO_BITMAP        = $0008;
+  FT_LOAD_VERTICAL_LAYOUT  = $0010;
+  FT_LOAD_FORCE_AUTOHINT   = $0020;
+  FT_LOAD_CROP_BITMAP      = $0040;
+  FT_LOAD_PEDANTIC         = $0080;
+  FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH = $0200;
+  FT_LOAD_NO_RECURSE       = $0400;
+  FT_LOAD_IGNORE_TRANSFORM = $0800;
+  FT_LOAD_MONOCHROME       = $1000;
+  FT_LOAD_LINEAR_DESIGN    = $2000;
+
+  (* temporary hack! *)
+  FT_LOAD_SBITS_ONLY       = $4000;
+  FT_LOAD_NO_AUTOHINT      = $8000;
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Enum>                                                                *)
+  (*    FT_Render_Mode                                                     *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    An enumeration type that lists the render modes supported by       *)
+  (*    FreeType 2.  Each mode corresponds to a specific type of scanline  *)
+  (*    conversion performed on the outline, as well as specific           *)
+  (*    hinting optimizations.                                             *)
+  (*                                                                       *)
+  (*    For bitmap fonts the `bitmap->pixel_mode' field in the             *)
+  (*    @FT_GlyphSlotRec structure gives the format of the returned        *)
+  (*    bitmap.                                                            *)
+  (*                                                                       *)
+  (* <Values>                                                              *)
+  (*    FT_RENDER_MODE_NORMAL ::                                           *)
+  (*      This is the default render mode; it corresponds to 8-bit         *)
+  (*      anti-aliased bitmaps, using 256 levels of opacity.               *)
+  (*                                                                       *)
+  (*    FT_RENDER_MODE_LIGHT ::                                            *)
+  (*      This is similar to @FT_RENDER_MODE_NORMAL -- you have to use     *)
+  (*      @FT_LOAD_TARGET_LIGHT in calls to @FT_Load_Glyph to get any      *)
+  (*      effect since the rendering process no longer influences the      *)
+  (*      positioning of glyph outlines.                                   *)
+  (*                                                                       *)
+  (*      The resulting glyph shapes are more similar to the original,     *)
+  (*      while being a bit more fuzzy (`better shapes' instead of `better *)
+  (*      contrast', so to say.                                            *)
+  (*                                                                       *)
+  (*    FT_RENDER_MODE_MONO ::                                             *)
+  (*      This mode corresponds to 1-bit bitmaps.                          *)
+  (*                                                                       *)
+  (*    FT_RENDER_MODE_LCD ::                                              *)
+  (*      This mode corresponds to horizontal RGB/BGR sub-pixel displays,  *)
+  (*      like LCD-screens.  It produces 8-bit bitmaps that are 3 times    *)
+  (*      the width of the original glyph outline in pixels, and which use *)
+  (*      the @FT_PIXEL_MODE_LCD mode.                                     *)
+  (*                                                                       *)
+  (*    FT_RENDER_MODE_LCD_V ::                                            *)
+  (*      This mode corresponds to vertical RGB/BGR sub-pixel displays     *)
+  (*      (like PDA screens, rotated LCD displays, etc.).  It produces     *)
+  (*      8-bit bitmaps that are 3 times the height of the original        *)
+  (*      glyph outline in pixels and use the @FT_PIXEL_MODE_LCD_V mode.   *)
+  (*                                                                       *)
+  (* <Note>                                                                *)
+  (*   The LCD-optimized glyph bitmaps produced by FT_Render_Glyph are     *)
+  (*   _not filtered_ to reduce color-fringes.  It is up to the caller to  *)
+  (*   perform this pass.                                                  *)
+  (*                                                                       *)
+type
+  FT_Render_Mode = FT_Int;
+
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Struct>                                                              *)
+  (*    FT_Glyph_Metrics                                                   *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    A structure used to model the metrics of a single glyph.  The      *)
+  (*    values are expressed in 26.6 fractional pixel format; if the flag  *)
+  (*    FT_LOAD_NO_SCALE is used, values are returned in font units        *)
+  (*    instead.                                                           *)
+  (*                                                                       *)
+  (* <Fields>                                                              *)
+  (*    width ::                                                           *)
+  (*      The glyph's width.                                               *)
+  (*                                                                       *)
+  (*    height ::                                                          *)
+  (*      The glyph's height.                                              *)
+  (*                                                                       *)
+  (*    horiBearingX ::                                                    *)
+  (*      Left side bearing for horizontal layout.                         *)
+  (*                                                                       *)
+  (*    horiBearingY ::                                                    *)
+  (*      Top side bearing for horizontal layout.                          *)
+  (*                                                                       *)
+  (*    horiAdvance ::                                                     *)
+  (*      Advance width for horizontal layout.                             *)
+  (*                                                                       *)
+  (*    vertBearingX ::                                                    *)
+  (*      Left side bearing for vertical layout.                           *)
+  (*                                                                       *)
+  (*    vertBearingY ::                                                    *)
+  (*      Top side bearing for vertical layout.                            *)
+  (*                                                                       *)
+  (*    vertAdvance ::                                                     *)
+  (*      Advance height for vertical layout.                              *)
+  (*                                                                       *)
+  FT_Glyph_Metrics = record
+    width  ,
+    height       : FT_Pos;
+
+    horiBearingX ,
+    horiBearingY ,
+    horiAdvance  : FT_Pos;
+
+    vertBearingX ,
+    vertBearingY ,
+    vertAdvance  : FT_Pos;
+  end;
+
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Struct>                                                              *)
+  (*    FT_Bitmap_Size                                                     *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    This structure models the size of a bitmap strike (i.e., a bitmap  *)
+  (*    instance of the font for a given resolution) in a fixed-size font  *)
+  (*    face.  It is used for the `available_sizes' field of the           *)
+  (*    @FT_FaceRec structure.                                             *)
+  (*                                                                       *)
+  (* <Fields>                                                              *)
+  (*    height :: The (vertical) baseline-to-baseline distance in pixels.  *)
+  (*              It makes most sense to define the height of a bitmap     *)
+  (*              font in this way.                                        *)
+  (*                                                                       *)
+  (*    width  :: The average width of the font (in pixels).  Since the    *)
+  (*              algorithms to compute this value are different for the   *)
+  (*              various bitmap formats, it can only give an additional   *)
+  (*              hint if the `height' value isn't sufficient to select    *)
+  (*              the proper font.  For monospaced fonts the average width *)
+  (*              is the same as the maximum width.                        *)
+  (*                                                                       *)
+  (*    size   :: The point size in 26.6 fractional format this font shall *)
+  (*              represent (for a given vertical resolution).             *)
+  (*                                                                       *)
+  (*    x_ppem :: The horizontal ppem value (in 26.6 fractional format).   *)
+  (*                                                                       *)
+  (*    y_ppem :: The vertical ppem value (in 26.6 fractional format).     *)
+  (*              Usually, this is the `nominal' pixel height of the font. *)
+  (*                                                                       *)
+  (* <Note>                                                                *)
+  (*    The values in this structure are taken from the bitmap font.  If   *)
+  (*    the font doesn't provide a parameter it is set to zero to indicate *)
+  (*    that the information is not available.                             *)
+  (*                                                                       *)
+  (*    The following formula converts from dpi to ppem:                   *)
+  (*                                                                       *)
+  (*      ppem = size * dpi / 72                                           *)
+  (*                                                                       *)
+  (*    where `size' is in points.                                         *)
+  (*                                                                       *)
+  (*    Windows FNT:                                                       *)
+  (*      The `size' parameter is not reliable: There exist fonts (e.g.,   *)
+  (*      app850.fon) which have a wrong size for some subfonts; x_ppem    *)
+  (*      and y_ppem are thus set equal to pixel width and height given in *)
+  (*      in the Windows FNT header.                                       *)
+  (*                                                                       *)
+  (*    TrueType embedded bitmaps:                                         *)
+  (*      `size', `width', and `height' values are not contained in the    *)
+  (*      bitmap strike itself.  They are computed from the global font    *)
+  (*      parameters.                                                      *)
+  (*                                                                       *)
+  PFT_Bitmap_Size = ^FT_Bitmap_Size;
+  FT_Bitmap_Size = record
+    height,
+    width  : FT_Short;
+    
+    size:    FT_Pos;
+
+    x_ppem:  FT_Pos;
+    y_ppem:  FT_Pos;
+  end;
+
+  PAFT_Bitmap_Size = ^AFT_Bitmap_Size;
+  AFT_Bitmap_Size = array[0..High(Word)] of FT_Bitmap_Size;
+
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Struct>                                                              *)
+  (*    FT_Vector                                                          *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    A simple structure used to store a 2D vector; coordinates are of   *)
+  (*    the FT_Pos type.                                                   *)
+  (*                                                                       *)
+  (* <Fields>                                                              *)
+  (*    x :: The horizontal coordinate.                                    *)
+  (*    y :: The vertical coordinate.                                      *)
+  (*                                                                       *)
+  PFT_Vector = ^FT_Vector;
+  FT_Vector = record
+    x ,
+    y : FT_Pos;
+  end;
+
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Struct>                                                              *)
+  (*    FT_Outline                                                         *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    This structure is used to describe an outline to the scan-line     *)
+  (*    converter.                                                         *)
+  (*                                                                       *)
+  (* <Fields>                                                              *)
+  (*    n_contours :: The number of contours in the outline.               *)
+  (*                                                                       *)
+  (*    n_points   :: The number of points in the outline.                 *)
+  (*                                                                       *)
+  (*    points     :: A pointer to an array of `n_points' FT_Vector        *)
+  (*                  elements, giving the outline's point coordinates.    *)
+  (*                                                                       *)
+  (*    tags       :: A pointer to an array of `n_points' chars, giving    *)
+  (*                  each outline point's type.  If bit 0 is unset, the   *)
+  (*                  point is `off' the curve, i.e. a Bezier control      *)
+  (*                  point, while it is `on' when set.                    *)
+  (*                                                                       *)
+  (*                  Bit 1 is meaningful for `off' points only.  If set,  *)
+  (*                  it indicates a third-order Bezier arc control point; *)
+  (*                  and a second-order control point if unset.           *)
+  (*                                                                       *)
+  (*    contours   :: An array of `n_contours' shorts, giving the end      *)
+  (*                  point of each contour within the outline.  For       *)
+  (*                  example, the first contour is defined by the points  *)
+  (*                  `0' to `contours[0]', the second one is defined by   *)
+  (*                  the points `contours[0]+1' to `contours[1]', etc.    *)
+  (*                                                                       *)
+  (*    flags      :: A set of bit flags used to characterize the outline  *)
+  (*                  and give hints to the scan-converter and hinter on   *)
+  (*                  how to convert/grid-fit it.  See FT_Outline_Flags.   *)
+  (*                                                                       *)
+  PFT_Outline = ^FT_Outline;
+  FT_Outline = record
+    n_contours : FT_Short;
+    n_points   : FT_Short;
+
+    points : PFT_Vector;
+    tags   : PChar;
+    contours : PFT_Short;
+
+    flags    : FT_Int;
+  end;
+
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Struct>                                                              *)
+  (*    FT_Bitmap                                                          *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    A structure used to describe a bitmap or pixmap to the raster.     *)
+  (*    Note that we now manage pixmaps of various depths through the      *)
+  (*    `pixel_mode' field.                                                *)
+  (*                                                                       *)
+  (* <Fields>                                                              *)
+  (*    rows         :: The number of bitmap rows.                         *)
+  (*                                                                       *)
+  (*    width        :: The number of pixels in bitmap row.                *)
+  (*                                                                       *)
+  (*    pitch        :: The pitch's absolute value is the number of bytes  *)
+  (*                    taken by one bitmap row, including padding.        *)
+  (*                    However, the pitch is positive when the bitmap has *)
+  (*                    a `down' flow, and negative when it has an `up'    *)
+  (*                    flow.  In all cases, the pitch is an offset to add *)
+  (*                    to a bitmap pointer in order to go down one row.   *)
+  (*                                                                       *)
+  (*    buffer       :: A typeless pointer to the bitmap buffer.  This     *)
+  (*                    value should be aligned on 32-bit boundaries in    *)
+  (*                    most cases.                                        *)
+  (*                                                                       *)
+  (*    num_grays    :: This field is only used with                       *)
+  (*                    `FT_PIXEL_MODE_GRAY'; it gives the number of gray  *)
+  (*                    levels used in the bitmap.                         *)
+  (*                                                                       *)
+  (*    pixel_mode   :: The pixel mode, i.e., how pixel bits are stored.   *)
+  (*                    See @FT_Pixel_Mode for possible values.            *)
+  (*                                                                       *)
+  (*    palette_mode :: This field is only used with paletted pixel modes; *)
+  (*                    it indicates how the palette is stored.            *)
+  (*                                                                       *)
+  (*    palette      :: A typeless pointer to the bitmap palette; only     *)
+  (*                    used for paletted pixel modes.                     *)
+  (*                                                                       *)
+  (* <Note>                                                                *)
+  (*   For now, the only pixel mode supported by FreeType are mono and     *)
+  (*   grays.  However, drivers might be added in the future to support    *)
+  (*   more `colorful' options.                                            *)
+  (*                                                                       *)
+  (*   When using pixel modes pal2, pal4 and pal8 with a void `palette'    *)
+  (*   field, a gray pixmap with respectively 4, 16, and 256 levels of     *)
+  (*   gray is assumed.  This, in order to be compatible with some         *)
+  (*   embedded bitmap formats defined in the TrueType specification.      *)
+  (*                                                                       *)
+  (*   Note that no font was found presenting such embedded bitmaps, so    *)
+  (*   this is currently completely unhandled by the library.              *)
+  (*                                                                       *)
+  PFT_Bitmap = ^FT_Bitmap;
+  FT_Bitmap = record
+    rows   ,
+    width  : FT_Int;
+    pitch  : FT_Int;
+    buffer : PChar;
+    num_grays    : FT_Short;
+    pixel_mode   ,
+    palette_mode : char;
+    palette : pointer;
+  end;
+
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Type>                                                                *)
+  (*    FT_Face                                                            *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    A handle to a given typographic face object.  A face object models *)
+  (*    a given typeface, in a given style.                                *)
+  (*                                                                       *)
+  (* <Note>                                                                *)
+  (*    Each face object also owns a single @FT_GlyphSlot object, as well  *)
+  (*    as one or more @FT_Size objects.                                   *)
+  (*                                                                       *)
+  (*    Use @FT_New_Face or @FT_Open_Face to create a new face object from *)
+  (*    a given filepathname or a custom input stream.                     *)
+  (*                                                                       *)
+  (*    Use @FT_Done_Face to destroy it (along with its slot and sizes).   *)
+  (*                                                                       *)
+  (* <Also>                                                                *)
+  (*    The @FT_FaceRec details the publicly accessible fields of a given  *)
+  (*    face object.                                                       *)
+  (*                                                                       *)
+  FT_Face = ^FT_FaceRec;
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Type>                                                                *)
+  (*    FT_CharMap                                                         *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    A handle to a given character map.  A charmap is used to translate *)
+  (*    character codes in a given encoding into glyph indexes for its     *)
+  (*    parent's face.  Some font formats may provide several charmaps per *)
+  (*    font.                                                              *)
+  (*                                                                       *)
+  (*    Each face object owns zero or more charmaps, but only one of them  *)
+  (*    can be "active" and used by @FT_Get_Char_Index or @FT_Load_Char.   *)
+  (*                                                                       *)
+  (*    The list of available charmaps in a face is available through the  *)
+  (*    "face->num_charmaps" and "face->charmaps" fields of @FT_FaceRec.   *)
+  (*                                                                       *)
+  (*    The currently active charmap is available as "face->charmap".      *)
+  (*    You should call @FT_Set_Charmap to change it.                      *)
+  (*                                                                       *)
+  (* <Note>                                                                *)
+  (*    When a new face is created (either through @FT_New_Face or         *)
+  (*    @FT_Open_Face), the library looks for a Unicode charmap within     *)
+  (*    the list and automatically activates it.                           *)
+  (*                                                                       *)
+  (* <Also>                                                                *)
+  (*    The @FT_CharMapRec details the publicly accessible fields of a     *)
+  (*    given character map.                                               *)
+  (*                                                                       *)
+  PFT_CharMap = ^FT_CharMap;
+  FT_CharMap = ^FT_CharMapRec;
+
+  PAFT_CharMap = ^FT_CharMap;
+  AFT_CharMap = array[0..High(Word)] of FT_CharMap;
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Type>                                                                *)
+  (*    FT_Library                                                         *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    A handle to a FreeType library instance.  Each `library' is        *)
+  (*    completely independent from the others; it is the `root' of a set  *)
+  (*    of objects like fonts, faces, sizes, etc.                          *)
+  (*                                                                       *)
+  (*    It also embeds a memory manager (see @FT_Memory), as well as a     *)
+  (*    scan-line converter object (see @FT_Raster).                       *)
+  (*                                                                       *)
+  (* <Note>                                                                *)
+  (*    Library objects are normally created by @FT_Init_FreeType, and     *)
+  (*    destroyed with @FT_Done_FreeType.                                  *)
+  (*                                                                       *)
+  FT_Library = ^FT_LibraryRec;
+  FT_LibraryRec = record // internal
+  end;
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Section>                                                             *)
+  (*    glyph_management                                                   *)
+  (*                                                                       *)
+  (* <Title>                                                               *)
+  (*    Glyph Management                                                   *)
+  (*                                                                       *)
+  (* <Abstract>                                                            *)
+  (*    Generic interface to manage individual glyph data.                 *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    This section contains definitions used to manage glyph data        *)
+  (*    through generic FT_Glyph objects.  Each of them can contain a      *)
+  (*    bitmap, a vector outline, or even images in other formats.         *)
+  (*                                                                       *)
+  (*************************************************************************)
+
+  (* forward declaration to a private type *)
+  PFT_Glyph_Class = ^FT_Glyph_Class;
+  FT_Glyph_Class = record // internal
+  end;
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Type>                                                                *)
+  (*    FT_Glyph                                                           *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    Handle to an object used to model generic glyph images.  It is a   *)
+  (*    pointer to the @FT_GlyphRec structure and can contain a glyph      *)
+  (*    bitmap or pointer.                                                 *)
+  (*                                                                       *)
+  (* <Note>                                                                *)
+  (*    Glyph objects are not owned by the library.  You must thus release *)
+  (*    them manually (through @FT_Done_Glyph) _before_ calling            *)
+  (*    @FT_Done_FreeType.                                                 *)
+  (*                                                                       *)
+  FT_Glyph = ^FT_GlyphRec;
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Struct>                                                              *)
+  (*    FT_GlyphRec                                                        *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    The root glyph structure contains a given glyph image plus its     *)
+  (*    advance width in 16.16 fixed float format.                         *)
+  (*                                                                       *)
+  (* <Fields>                                                              *)
+  (*    library :: A handle to the FreeType library object.                *)
+  (*                                                                       *)
+  (*    clazz   :: A pointer to the glyph's class.  Private.               *)
+  (*                                                                       *)
+  (*    format  :: The format of the glyph's image.                        *)
+  (*                                                                       *)
+  (*    advance :: A 16.16 vector that gives the glyph's advance width.    *)
+  (*                                                                       *)
+  FT_GlyphRec = record
+    library_: FT_Library;
+    clazz:    PFT_Glyph_Class;
+    format:   FT_Glyph_Format;
+    advance:  FT_Vector;
+  end;
+
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Type>                                                                *)
+  (*    FT_BitmapGlyph                                                     *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    A handle to an object used to model a bitmap glyph image.  This is *)
+  (*    a sub-class of @FT_Glyph, and a pointer to @FT_BitmapGlyphRec.     *)
+  (*                                                                       *)
+  FT_BitmapGlyph = ^FT_BitmapGlyphRec;
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Struct>                                                              *)
+  (*    FT_BitmapGlyphRec                                                  *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    A structure used for bitmap glyph images.  This really is a        *)
+  (*    `sub-class' of `FT_GlyphRec'.                                      *)
+  (*                                                                       *)
+  (* <Fields>                                                              *)
+  (*    root   :: The root FT_Glyph fields.                                *)
+  (*                                                                       *)
+  (*    left   :: The left-side bearing, i.e., the horizontal distance     *)
+  (*              from the current pen position to the left border of the  *)
+  (*              glyph bitmap.                                            *)
+  (*                                                                       *)
+  (*    top    :: The top-side bearing, i.e., the vertical distance from   *)
+  (*              the current pen position to the top border of the glyph  *)
+  (*              bitmap.  This distance is positive for upwards-y!        *)
+  (*                                                                       *)
+  (*    bitmap :: A descriptor for the bitmap.                             *)
+  (*                                                                       *)
+  (* <Note>                                                                *)
+  (*    You can typecast FT_Glyph to FT_BitmapGlyph if you have            *)
+  (*    glyph->format == FT_GLYPH_FORMAT_BITMAP.  This lets you access     *)
+  (*    the bitmap's contents easily.                                      *)
+  (*                                                                       *)
+  (*    The corresponding pixel buffer is always owned by the BitmapGlyph  *)
+  (*    and is thus created and destroyed with it.                         *)
+  (*                                                                       *)
+  FT_BitmapGlyphRec = record
+    root:   FT_GlyphRec;
+    left:   FT_Int;
+    top:    FT_Int;
+    bitmap: FT_Bitmap;
+  end;
+
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Type>                                                                *)
+  (*    FT_OutlineGlyph                                                    *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    A handle to an object used to model an outline glyph image.  This  *)
+  (*    is a sub-class of @FT_Glyph, and a pointer to @FT_OutlineGlyphRec. *)
+  (*                                                                       *)
+  FT_OutlineGlyph = ^FT_OutlineGlyphRec;
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Struct>                                                              *)
+  (*    FT_OutlineGlyphRec                                                 *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    A structure used for outline (vectorial) glyph images.  This       *)
+  (*    really is a `sub-class' of `FT_GlyphRec'.                          *)
+  (*                                                                       *)
+  (* <Fields>                                                              *)
+  (*    root    :: The root FT_Glyph fields.                               *)
+  (*                                                                       *)
+  (*    outline :: A descriptor for the outline.                           *)
+  (*                                                                       *)
+  (* <Note>                                                                *)
+  (*    You can typecast FT_Glyph to FT_OutlineGlyph if you have           *)
+  (*    glyph->format == FT_GLYPH_FORMAT_OUTLINE.  This lets you access    *)
+  (*    the outline's content easily.                                      *)
+  (*                                                                       *)
+  (*    As the outline is extracted from a glyph slot, its coordinates are *)
+  (*    expressed normally in 26.6 pixels, unless the flag                 *)
+  (*    FT_LOAD_NO_SCALE was used in FT_Load_Glyph() or FT_Load_Char().    *)
+  (*                                                                       *)
+  (*    The outline's tables are always owned by the object and are        *)
+  (*    destroyed with it.                                                 *)
+  (*                                                                       *)
+  FT_OutlineGlyphRec = record
+    root:    FT_GlyphRec;
+    outline: FT_Outline;
+  end;
+
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Struct>                                                              *)
+  (*    FT_SubGlyph                                                        *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    The subglyph structure is an internal object used to describe      *)
+  (*    subglyphs (for example, in the case of composites).                *)
+  (*                                                                       *)
+  (* <Note>                                                                *)
+  (*    The subglyph implementation is not part of the high-level API,     *)
+  (*    hence the forward structure declaration.                           *)
+  (*                                                                       *)
+  FT_SubGlyph = ^FT_SubGlyphRec;
+  FT_SubGlyphRec = record // internal
+  end;
+
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <FuncType>                                                            *)
+  (*    FT_Generic_Finalizer                                               *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    Describes a function used to destroy the `client' data of any      *)
+  (*    FreeType object.  See the description of the FT_Generic type for   *)
+  (*    details of usage.                                                  *)
+  (*                                                                       *)
+  (* <Input>                                                               *)
+  (*    The address of the FreeType object which is under finalization.    *)
+  (*    Its client data is accessed through its `generic' field.           *)
+  (*                                                                       *)
+  FT_Generic_Finalizer = procedure(AnObject : pointer ); cdecl;
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Struct>                                                              *)
+  (*    FT_Generic                                                         *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    Client applications often need to associate their own data to a    *)
+  (*    variety of FreeType core objects.  For example, a text layout API  *)
+  (*    might want to associate a glyph cache to a given size object.      *)
+  (*                                                                       *)
+  (*    Most FreeType object contains a `generic' field, of type           *)
+  (*    FT_Generic, which usage is left to client applications and font    *)
+  (*    servers.                                                           *)
+  (*                                                                       *)
+  (*    It can be used to store a pointer to client-specific data, as well *)
+  (*    as the address of a `finalizer' function, which will be called by  *)
+  (*    FreeType when the object is destroyed (for example, the previous   *)
+  (*    client example would put the address of the glyph cache destructor *)
+  (*    in the `finalizer' field).                                         *)
+  (*                                                                       *)
+  (* <Fields>                                                              *)
+  (*    data      :: A typeless pointer to any client-specified data. This *)
+  (*                 field is completely ignored by the FreeType library.  *)
+  (*                                                                       *)
+  (*    finalizer :: A pointer to a `generic finalizer' function, which    *)
+  (*                 will be called when the object is destroyed.  If this *)
+  (*                 field is set to NULL, no code will be called.         *)
+  (*                                                                       *)
+  FT_Generic = record
+    data      : pointer;
+    finalizer : FT_Generic_Finalizer;
+  end;
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Struct>                                                              *)
+  (*    FT_BBox                                                            *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    A structure used to hold an outline's bounding box, i.e., the      *)
+  (*    coordinates of its extrema in the horizontal and vertical          *)
+  (*    directions.                                                        *)
+  (*                                                                       *)
+  (* <Fields>                                                              *)
+  (*    xMin :: The horizontal minimum (left-most).                        *)
+  (*                                                                       *)
+  (*    yMin :: The vertical minimum (bottom-most).                        *)
+  (*                                                                       *)
+  (*    xMax :: The horizontal maximum (right-most).                       *)
+  (*                                                                       *)
+  (*    yMax :: The vertical maximum (top-most).                           *)
+  (*                                                                       *)
+  PFT_BBox = ^FT_BBox;
+  FT_BBox = record
+    xMin, yMin : FT_Pos;
+    xMax, yMax : FT_Pos;
+  end;
+
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Type>                                                                *)
+  (*    FT_GlyphSlot                                                       *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    A handle to a given `glyph slot'.  A slot is a container where it  *)
+  (*    is possible to load any one of the glyphs contained in its parent  *)
+  (*    face.                                                              *)
+  (*                                                                       *)
+  (*    In other words, each time you call @FT_Load_Glyph or               *)
+  (*    @FT_Load_Char, the slot's content is erased by the new glyph data, *)
+  (*    i.e. the glyph's metrics, its image (bitmap or outline), and       *)
+  (*    other control information.                                         *)
+  (*                                                                       *)
+  (* <Also>                                                                *)
+  (*    @FT_GlyphSlotRec details the publicly accessible glyph fields.     *)
+  (*                                                                       *)
+  FT_GlyphSlot = ^FT_GlyphSlotRec;
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Struct>                                                              *)
+  (*    FT_GlyphSlotRec                                                    *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    FreeType root glyph slot class structure.  A glyph slot is a       *)
+  (*    container where individual glyphs can be loaded, be they           *)
+  (*    vectorial or bitmap/graymaps.                                      *)
+  (*                                                                       *)
+  (* <Fields>                                                              *)
+  (*    library           :: A handle to the FreeType library instance     *)
+  (*                         this slot belongs to.                         *)
+  (*                                                                       *)
+  (*    face              :: A handle to the parent face object.           *)
+  (*                                                                       *)
+  (*    next              :: In some cases (like some font tools), several *)
+  (*                         glyph slots per face object can be a good     *)
+  (*                         thing.  As this is rare, the glyph slots are  *)
+  (*                         listed through a direct, single-linked list   *)
+  (*                         using its `next' field.                       *)
+  (*                                                                       *)
+  (*    generic           :: A typeless pointer which is unused by the     *)
+  (*                         FreeType library or any of its drivers.  It   *)
+  (*                         can be used by client applications to link    *)
+  (*                         their own data to each glyph slot object.     *)
+  (*                                                                       *)
+  (*    metrics           :: The metrics of the last loaded glyph in the   *)
+  (*                         slot.  The returned values depend on the last *)
+  (*                         load flags (see the @FT_Load_Glyph API        *)
+  (*                         function) and can be expressed either in 26.6 *)
+  (*                         fractional pixels or font units.              *)
+  (*                                                                       *)
+  (*                         Note that even when the glyph image is        *)
+  (*                         transformed, the metrics are not.             *)
+  (*                                                                       *)
+  (*    linearHoriAdvance :: For scalable formats only, this field holds   *)
+  (*                         the linearly scaled horizontal advance width  *)
+  (*                         for the glyph (i.e. the scaled and unhinted   *)
+  (*                         value of the hori advance).  This can be      *)
+  (*                         important to perform correct WYSIWYG layout.  *)
+  (*                                                                       *)
+  (*                         Note that this value is expressed by default  *)
+  (*                         in 16.16 pixels. However, when the glyph is   *)
+  (*                         loaded with the FT_LOAD_LINEAR_DESIGN flag,   *)
+  (*                         this field contains simply the value of the   *)
+  (*                         advance in original font units.               *)
+  (*                                                                       *)
+  (*    linearVertAdvance :: For scalable formats only, this field holds   *)
+  (*                         the linearly scaled vertical advance height   *)
+  (*                         for the glyph.  See linearHoriAdvance for     *)
+  (*                         comments.                                     *)
+  (*                                                                       *)
+  (*    advance           :: This is the transformed advance width for the *)
+  (*                         glyph.                                        *)
+  (*                                                                       *)
+  (*    format            :: This field indicates the format of the image  *)
+  (*                         contained in the glyph slot.  Typically       *)
+  (*                         FT_GLYPH_FORMAT_BITMAP,                       *)
+  (*                         FT_GLYPH_FORMAT_OUTLINE, and                  *)
+  (*                         FT_GLYPH_FORMAT_COMPOSITE, but others are     *)
+  (*                         possible.                                     *)
+  (*                                                                       *)
+  (*    bitmap            :: This field is used as a bitmap descriptor     *)
+  (*                         when the slot format is                       *)
+  (*                         FT_GLYPH_FORMAT_BITMAP.  Note that the        *)
+  (*                         address and content of the bitmap buffer can  *)
+  (*                         change between calls of @FT_Load_Glyph and a  *)
+  (*                         few other functions.                          *)
+  (*                                                                       *)
+  (*    bitmap_left       :: This is the bitmap's left bearing expressed   *)
+  (*                         in integer pixels.  Of course, this is only   *)
+  (*                         valid if the format is                        *)
+  (*                         FT_GLYPH_FORMAT_BITMAP.                       *)
+  (*                                                                       *)
+  (*    bitmap_top        :: This is the bitmap's top bearing expressed in *)
+  (*                         integer pixels.  Remember that this is the    *)
+  (*                         distance from the baseline to the top-most    *)
+  (*                         glyph scanline, upwards y-coordinates being   *)
+  (*                         *positive*.                                   *)
+  (*                                                                       *)
+  (*    outline           :: The outline descriptor for the current glyph  *)
+  (*                         image if its format is                        *)
+  (*                         FT_GLYPH_FORMAT_OUTLINE.                      *)
+  (*                                                                       *)
+  (*    num_subglyphs     :: The number of subglyphs in a composite glyph. *)
+  (*                         This field is only valid for the composite    *)
+  (*                         glyph format that should normally only be     *)
+  (*                         loaded with the @FT_LOAD_NO_RECURSE flag.     *)
+  (*                         For now this is internal to FreeType.         *)
+  (*                                                                       *)
+  (*    subglyphs         :: An array of subglyph descriptors for          *)
+  (*                         composite glyphs.  There are `num_subglyphs'  *)
+  (*                         elements in there.  Currently internal to     *)
+  (*                         FreeType.                                     *)
+  (*                                                                       *)
+  (*    control_data      :: Certain font drivers can also return the      *)
+  (*                         control data for a given glyph image (e.g.    *)
+  (*                         TrueType bytecode, Type 1 charstrings, etc.). *)
+  (*                         This field is a pointer to such data.         *)
+  (*                                                                       *)
+  (*    control_len       :: This is the length in bytes of the control    *)
+  (*                         data.                                         *)
+  (*                                                                       *)
+  (*    other             :: Really wicked formats can use this pointer to *)
+  (*                         present their own glyph image to client apps. *)
+  (*                         Note that the app will need to know about the *)
+  (*                         image format.                                 *)
+  (*                                                                       *)
+  (*    lsb_delta         :: The difference between hinted and unhinted    *)
+  (*                         left side bearing while autohinting is        *)
+  (*                         active.  Zero otherwise.                      *)
+  (*                                                                       *)
+  (*    rsb_delta         :: The difference between hinted and unhinted    *)
+  (*                         right side bearing while autohinting is       *)
+  (*                         active.  Zero otherwise.                      *)
+  (*                                                                       *)
+  (* <Note>                                                                *)
+  (*    If @FT_Load_Glyph is called with default flags (see                *)
+  (*    @FT_LOAD_DEFAULT) the glyph image is loaded in the glyph slot in   *)
+  (*    its native format (e.g. a vectorial outline for TrueType and       *)
+  (*    Type 1 formats).                                                   *)
+  (*                                                                       *)
+  (*    This image can later be converted into a bitmap by calling         *)
+  (*    @FT_Render_Glyph.  This function finds the current renderer for    *)
+  (*    the native image's format then invokes it.                         *)
+  (*                                                                       *)
+  (*    The renderer is in charge of transforming the native image through *)
+  (*    the slot's face transformation fields, then convert it into a      *)
+  (*    bitmap that is returned in `slot->bitmap'.                         *)
+  (*                                                                       *)
+  (*    Note that `slot->bitmap_left' and `slot->bitmap_top' are also used *)
+  (*    to specify the position of the bitmap relative to the current pen  *)
+  (*    position (e.g. coordinates [0,0] on the baseline).  Of course,     *)
+  (*    `slot->format' is also changed to `FT_GLYPH_FORMAT_BITMAP' .       *)
+  (*                                                                       *)
+  (* <Note>                                                                *)
+  (*    Here a small pseudo code fragment which shows how to use           *)
+  (*    `lsb_delta' and `rsb_delta':                                       *)
+  (*                                                                       *)
+  (*    {                                                                  *)
+  (*      FT_Pos  origin_x       = 0;                                      *)
+  (*      FT_Pos  prev_rsb_delta = 0;                                      *)
+  (*                                                                       *)
+  (*                                                                       *)
+  (*      for all glyphs do                                                *)
+  (*        <compute kern between current and previous glyph and add it to *)
+  (*         `origin_x'>                                                   *)
+  (*                                                                       *)
+  (*        <load glyph with `FT_Load_Glyph'>                              *)
+  (*                                                                       *)
+  (*        if ( prev_rsb_delta - face->glyph->lsb_delta >= 32 )           *)
+  (*          origin_x -= 64;                                              *)
+  (*        else if ( prev_rsb_delta - face->glyph->lsb_delta < -32 )      *)
+  (*          origin_x += 64;                                              *)
+  (*                                                                       *)
+  (*        prev_rsb_delta = face->glyph->rsb_delta;                       *)
+  (*                                                                       *)
+  (*        <save glyph image, or render glyph, or ...>                    *)
+  (*                                                                       *)
+  (*        origin_x += face->glyph->advance.x;                            *)
+  (*      endfor                                                           *)
+  (*    }                                                                  *)
+  (*                                                                       *)
+  FT_GlyphSlotRec = record
+    alibrary : FT_Library;
+
+    face  : FT_Face;
+    next  : FT_GlyphSlot;
+    flags : FT_UInt;
+
+    generic : FT_Generic;
+    metrics : FT_Glyph_Metrics;
+
+    linearHoriAdvance ,
+    linearVertAdvance : FT_Fixed;
+
+    advance : FT_Vector;
+    format  : FT_Glyph_Format;
+    bitmap  : FT_Bitmap;
+
+    bitmap_left ,
+    bitmap_top  : FT_Int;
+
+    outline : FT_Outline;
+
+    num_subglyphs : FT_UInt;
+    subglyphs     : FT_SubGlyph;
+    
+    control_data  : pointer;
+    control_len   : longint;
+
+    lsb_delta: FT_Pos;
+    rsb_delta: FT_Pos;
+
+    other : pointer;
+    
+    //internal: FT_Slot_Internal;
+  end;
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Struct>                                                              *)
+  (*    FT_Size_Metrics                                                    *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    The size metrics structure returned scaled important distances for *)
+  (*    a given size object.                                               *)
+  (*                                                                       *)
+  (* <Fields>                                                              *)
+  (*    x_ppem       :: The character width, expressed in integer pixels.  *)
+  (*                    This is the width of the EM square expressed in    *)
+  (*                    pixels, hence the term `ppem' (pixels per EM).     *)
+  (*                                                                       *)
+  (*    y_ppem       :: The character height, expressed in integer pixels. *)
+  (*                    This is the height of the EM square expressed in   *)
+  (*                    pixels, hence the term `ppem' (pixels per EM).     *)
+  (*                                                                       *)
+  (*    x_scale      :: A simple 16.16 fixed point format coefficient used *)
+  (*                    to scale horizontal distances expressed in font    *)
+  (*                    units to fractional (26.6) pixel coordinates.      *)
+  (*                                                                       *)
+  (*    y_scale      :: A simple 16.16 fixed point format coefficient used *)
+  (*                    to scale vertical distances expressed in font      *)
+  (*                    units to fractional (26.6) pixel coordinates.      *)
+  (*                                                                       *)
+  (*    ascender     :: The ascender, expressed in 26.6 fixed point        *)
+  (*                    pixels.  Positive for ascenders above the          *)
+  (*                    baseline.                                          *)
+  (*                                                                       *)
+  (*    descender    :: The descender, expressed in 26.6 fixed point       *)
+  (*                    pixels.  Negative for descenders below the         *)
+  (*                    baseline.                                          *)
+  (*                                                                       *)
+  (*    height       :: The text height, expressed in 26.6 fixed point     *)
+  (*                    pixels.  Always positive.                          *)
+  (*                                                                       *)
+  (*    max_advance  :: Maximum horizontal advance, expressed in 26.6      *)
+  (*                    fixed point pixels.  Always positive.              *)
+  (*                                                                       *)
+  (* <Note>                                                                *)
+  (*    For scalable fonts, the values of `ascender', `descender', and     *)
+  (*    `height' are scaled versions of `face->ascender',                  *)
+  (*    `face->descender', and `face->height', respectively.               *)
+  (*                                                                       *)
+  (*    Unfortunately, due to glyph hinting, these values might not be     *)
+  (*    exact for certain fonts.  They thus must be treated as unreliable  *)
+  (*    with an error margin of at least one pixel!                        *)
+  (*                                                                       *)
+  (*    Indeed, the only way to get the exact pixel ascender and descender *)
+  (*    is to render _all_ glyphs.  As this would be a definite            *)
+  (*    performance hit, it is up to client applications to perform such   *)
+  (*    computations.                                                      *)
+  (*                                                                       *)
+  FT_Size_Metrics = record
+    x_ppem  ,
+    y_ppem  : FT_UShort;
+    x_scale ,
+    y_scale : FT_Fixed;
+
+    ascender    ,
+    descender   : FT_Pos;
+    height      : FT_Pos;
+    max_advance : FT_Pos;
+  end;
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Type>                                                                *)
+  (*    FT_Size                                                            *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    A handle to a given size object.  Such an object models the data   *)
+  (*    that depends on the current _resolution_ and _character size_ in a *)
+  (*    given @FT_Face.                                                    *)
+  (*                                                                       *)
+  (* <Note>                                                                *)
+  (*    Each face object owns one or more sizes.  There is however a       *)
+  (*    single _active_ size for the face at any time that will be used by *)
+  (*    functions like @FT_Load_Glyph, @FT_Get_Kerning, etc.               *)
+  (*                                                                       *)
+  (*    You can use the @FT_Activate_Size API to change the current        *)
+  (*    active size of any given face.                                     *)
+  (*                                                                       *)
+  (* <Also>                                                                *)
+  (*    The @FT_SizeRec structure details the publicly accessible fields   *)
+  (*    of a given face object.                                            *)
+  (*                                                                       *)
+  FT_Size = ^FT_SizeRec;
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Struct>                                                              *)
+  (*    FT_SizeRec                                                         *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    FreeType root size class structure.  A size object models the      *)
+  (*    resolution and pointsize dependent data of a given face.           *)
+  (*                                                                       *)
+  (* <Fields>                                                              *)
+  (*    face    :: Handle to the parent face object.                       *)
+  (*                                                                       *)
+  (*    generic :: A typeless pointer, which is unused by the FreeType     *)
+  (*               library or any of its drivers.  It can be used by       *)
+  (*               client applications to link their own data to each size *)
+  (*               object.                                                 *)
+  (*                                                                       *)
+  (*    metrics :: Metrics for this size object.  This field is read-only. *)
+  (*                                                                       *)
+  FT_SizeRec = record
+    face    : FT_Face;
+    generic : FT_Generic;
+    metrics : FT_Size_Metrics;
+    //internal : FT_Size_Internal;
+  end;
+
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Struct>                                                              *)
+  (*    FT_FaceRec                                                         *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    FreeType root face class structure.  A face object models the      *)
+  (*    resolution and point-size independent data found in a font file.   *)
+  (*                                                                       *)
+  (* <Fields>                                                              *)
+  (*    num_faces           :: In the case where the face is located in a  *)
+  (*                           collection (i.e., a file which embeds       *)
+  (*                           several faces), this is the total number of *)
+  (*                           faces found in the resource.  1 by default. *)
+  (*                           Accessing non-existent face indices causes  *)
+  (*                           an error.                                   *)
+  (*                                                                       *)
+  (*    face_index          :: The index of the face in its font file.     *)
+  (*                           Usually, this is 0 for all normal font      *)
+  (*                           formats.  It can be > 0 in the case of      *)
+  (*                           collections (which embed several fonts in a *)
+  (*                           single resource/file).                      *)
+  (*                                                                       *)
+  (*    face_flags          :: A set of bit flags that give important      *)
+  (*                           information about the face; see the         *)
+  (*                           @FT_FACE_FLAG_XXX constants for details.    *)
+  (*                                                                       *)
+  (*    style_flags         :: A set of bit flags indicating the style of  *)
+  (*                           the face (i.e., italic, bold, underline,    *)
+  (*                           etc).  See the @FT_STYLE_FLAG_XXX           *)
+  (*                           constants.                                  *)
+  (*                                                                       *)
+  (*    num_glyphs          :: The total number of glyphs in the face.     *)
+  (*                                                                       *)
+  (*    family_name         :: The face's family name.  This is an ASCII   *)
+  (*                           string, usually in English, which describes *)
+  (*                           the typeface's family (like `Times New      *)
+  (*                           Roman', `Bodoni', `Garamond', etc).  This   *)
+  (*                           is a least common denominator used to list  *)
+  (*                           fonts.  Some formats (TrueType & OpenType)  *)
+  (*                           provide localized and Unicode versions of   *)
+  (*                           this string.  Applications should use the   *)
+  (*                           format specific interface to access them.   *)
+  (*                                                                       *)
+  (*    style_name          :: The face's style name.  This is an ASCII    *)
+  (*                           string, usually in English, which describes *)
+  (*                           the typeface's style (like `Italic',        *)
+  (*                           `Bold', `Condensed', etc).  Not all font    *)
+  (*                           formats provide a style name, so this field *)
+  (*                           is optional, and can be set to NULL.  As    *)
+  (*                           for `family_name', some formats provide     *)
+  (*                           localized/Unicode versions of this string.  *)
+  (*                           Applications should use the format specific *)
+  (*                           interface to access them.                   *)
+  (*                                                                       *)
+  (*    num_fixed_sizes     :: The number of fixed sizes available in this *)
+  (*                           face.  This should be set to 0 for scalable *)
+  (*                           fonts, unless its face includes a set of    *)
+  (*                           glyphs (called a `strike') for the          *)
+  (*                           specified sizes.                            *)
+  (*                                                                       *)
+  (*    available_sizes     :: An array of sizes specifying the available  *)
+  (*                           bitmap/graymap sizes that are contained in  *)
+  (*                           in the font face.  Should be set to NULL if *)
+  (*                           the field `num_fixed_sizes' is set to 0.    *)
+  (*                                                                       *)
+  (*    num_charmaps        :: The total number of character maps in the   *)
+  (*                           face.                                       *)
+  (*                                                                       *)
+  (*    charmaps            :: A table of pointers to the face's charmaps. *)
+  (*                           Used to scan the list of available charmaps *)
+  (*                           -- this table might change after a call to  *)
+  (*                           @FT_Attach_File or @FT_Attach_Stream (e.g.  *)
+  (*                           if used to hook an additional encoding or   *)
+  (*                           CMap to the face object).                   *)
+  (*                                                                       *)
+  (*    generic             :: A field reserved for client uses.  See the  *)
+  (*                           @FT_Generic type description.               *)
+  (*                                                                       *)
+  (*    bbox                :: The font bounding box.  Coordinates are     *)
+  (*                           expressed in font units (see units_per_EM). *)
+  (*                           The box is large enough to contain any      *)
+  (*                           glyph from the font.  Thus, bbox.yMax can   *)
+  (*                           be seen as the `maximal ascender',          *)
+  (*                           bbox.yMin as the `minimal descender', and   *)
+  (*                           the maximal glyph width is given by         *)
+  (*                           `bbox.xMax-bbox.xMin' (not to be confused   *)
+  (*                           with the maximal _advance_width_).  Only    *)
+  (*                           relevant for scalable formats.              *)
+  (*                                                                       *)
+  (*    units_per_EM        :: The number of font units per EM square for  *)
+  (*                           this face.  This is typically 2048 for      *)
+  (*                           TrueType fonts, 1000 for Type1 fonts, and   *)
+  (*                           should be set to the (unrealistic) value 1  *)
+  (*                           for fixed-sizes fonts.  Only relevant for   *)
+  (*                           scalable formats.                           *)
+  (*                                                                       *)
+  (*    ascender            :: The face's ascender is the vertical         *)
+  (*                           distance from the baseline to the topmost   *)
+  (*                           point of any glyph in the face.  This       *)
+  (*                           field's value is positive, expressed in     *)
+  (*                           font units.  Some font designs use a value  *)
+  (*                           different from `bbox.yMax'.  Only relevant  *)
+  (*                           for scalable formats.                       *)
+  (*                                                                       *)
+  (*    descender           :: The face's descender is the vertical        *)
+  (*                           distance from the baseline to the           *)
+  (*                           bottommost point of any glyph in the face.  *)
+  (*                           This field's value is *negative* for values *)
+  (*                           below the baseline.  It is expressed in     *)
+  (*                           font units.  Some font designs use a value  *)
+  (*                           different from `bbox.yMin'.  Only relevant  *)
+  (*                           for scalable formats.                       *)
+  (*                                                                       *)
+  (*    height              :: The face's height is the vertical distance  *)
+  (*                           from one baseline to the next when writing  *)
+  (*                           several lines of text.  Its value is always *)
+  (*                           positive, expressed in font units.  The     *)
+  (*                           value can be computed as                    *)
+  (*                           `ascender+descender+line_gap' where the     *)
+  (*                           value of `line_gap' is also called          *)
+  (*                           `external leading'.  Only relevant for      *)
+  (*                           scalable formats.                           *)
+  (*                                                                       *)
+  (*    max_advance_width   :: The maximal advance width, in font units,   *)
+  (*                           for all glyphs in this face.  This can be   *)
+  (*                           used to make word wrapping computations     *)
+  (*                           faster.  Only relevant for scalable         *)
+  (*                           formats.                                    *)
+  (*                                                                       *)
+  (*    max_advance_height  :: The maximal advance height, in font units,  *)
+  (*                           for all glyphs in this face.  This is only  *)
+  (*                           relevant for vertical layouts, and should   *)
+  (*                           be set to the `height' for fonts that do    *)
+  (*                           not provide vertical metrics.  Only         *)
+  (*                           relevant for scalable formats.              *)
+  (*                                                                       *)
+  (*    underline_position  :: The position, in font units, of the         *)
+  (*                           underline line for this face.  It's the     *)
+  (*                           center of the underlining stem.  Only       *)
+  (*                           relevant for scalable formats.              *)
+  (*                                                                       *)
+  (*    underline_thickness :: The thickness, in font units, of the        *)
+  (*                           underline for this face.  Only relevant for *)
+  (*                           scalable formats.                           *)
+  (*                                                                       *)
+  (*    glyph               :: The face's associated glyph slot(s).  This  *)
+  (*                           object is created automatically with a new  *)
+  (*                           face object.  However, certain kinds of     *)
+  (*                           applications (mainly tools like converters) *)
+  (*                           can need more than one slot to ease their   *)
+  (*                           task.                                       *)
+  (*                                                                       *)
+  (*    size                :: The current active size for this face.      *)
+  (*                                                                       *)
+  (*    charmap             :: The current active charmap for this face.   *)
+  (*                                                                       *)
+  FT_FaceRec = record
+    num_faces       : FT_Long;
+    face_index      : FT_Long;
+
+    face_flags      : FT_Long;
+    style_flags     : FT_Long;
+
+    num_glyphs      : FT_Long;
+
+    family_name     : PFT_String;
+    style_name      : PFT_String;
+
+    num_fixed_sizes : FT_Int;
+    available_sizes : PAFT_Bitmap_Size; // is array
+
+    num_charmaps    : FT_Int;
+    charmaps        : PAFT_CharMap;    // is array
+
+    generic         : FT_Generic;
+
+    (*# the following are only relevant to scalable outlines *)
+    bbox            : FT_BBox;
+
+    units_per_EM    : FT_UShort;
+    ascender        : FT_Short;
+    descender       : FT_Short;
+    height          : FT_Short;
+
+    max_advance_width   : FT_Short;
+    max_advance_height  : FT_Short;
+    
+    underline_position  : FT_Short;
+    underline_thickness : FT_Short;
+
+    glyph           : FT_GlyphSlot;
+    size            : FT_Size;
+    charmap         : FT_CharMap;
+  end;
+
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Struct>                                                              *)
+  (*    FT_CharMapRec                                                      *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    The base charmap structure.                                        *)
+  (*                                                                       *)
+  (* <Fields>                                                              *)
+  (*    face        :: A handle to the parent face object.                 *)
+  (*                                                                       *)
+  (*    encoding    :: An @FT_Encoding tag identifying the charmap.  Use   *)
+  (*                   this with @FT_Select_Charmap.                       *)
+  (*                                                                       *)
+  (*    platform_id :: An ID number describing the platform for the        *)
+  (*                   following encoding ID.  This comes directly from    *)
+  (*                   the TrueType specification and should be emulated   *)
+  (*                   for other formats.                                  *)
+  (*                                                                       *)
+  (*    encoding_id :: A platform specific encoding number.  This also     *)
+  (*                   comes from the TrueType specification and should be *)
+  (*                   emulated similarly.                                 *)
+  (*                                                                       *)
+  FT_CharMapRec = record
+    face        : FT_Face;
+    encoding    : FT_Encoding;
+    platform_id : FT_UShort;
+    encoding_id : FT_UShort;
+  end;
+
+{ GLOBAL PROCEDURES }
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* @macro:                                                               *)
+  (*    FT_CURVE_TAG  ( flag )                                             *)
+  (*                                                                       *)
+  function  FT_CURVE_TAG  (flag : char ) : char;
+
+const
+  FT_CURVE_TAG_ON    = 1;
+  FT_CURVE_TAG_CONIC = 0;
+  FT_CURVE_TAG_CUBIC = 2;
+
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* @macro:                                                               *)
+  (*    FT_IS_SCALABLE( face )                                             *)
+  (*                                                                       *)
+  (* @description:                                                         *)
+  (*    A macro that returns true whenever a face object contains a        *)
+  (*    scalable font face (true for TrueType, Type 1, CID, and            *)
+  (*    OpenType/CFF font formats.                                         *)
+  (*                                                                       *)
+  function  FT_IS_SCALABLE(face : FT_Face ) : cbool;
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* @macro:                                                               *)
+  (*    FT_HAS_KERNING( face )                                             *)
+  (*                                                                       *)
+  (* @description:                                                         *)
+  (*    A macro that returns true whenever a face object contains kerning  *)
+  (*    data that can be accessed with @FT_Get_Kerning.                    *)
+  (*                                                                       *)
+  function  FT_HAS_KERNING(face : FT_Face ) : cbool;
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Function>                                                            *)
+  (*    FT_Init_FreeType                                                   *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    Initializes a new FreeType library object.  The set of modules     *)
+  (*    that are registered by this function is determined at build time.  *)
+  (*                                                                       *)
+  (* <Output>                                                              *)
+  (*    alibrary :: A handle to a new library object.                      *)
+  (*                                                                       *)
+  (* <Return>                                                              *)
+  (*    FreeType error code.  0 means success.                             *)
+  (*                                                                       *)
+  function  FT_Init_FreeType(out alibrary : FT_Library ) : FT_Error;
+    cdecl; external ft_lib name 'FT_Init_FreeType';
+
+ (*************************************************************************)
+  (*                                                                       *)
+  (* <Function>                                                            *)
+  (*    FT_Done_FreeType                                                   *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    Destroys a given FreeType library object and all of its childs,    *)
+  (*    including resources, drivers, faces, sizes, etc.                   *)
+  (*                                                                       *)
+  (* <Input>                                                               *)
+  (*    library :: A handle to the target library object.                  *)
+  (*                                                                       *)
+  (* <Return>                                                              *)
+  (*    FreeType error code.  0 means success.                             *)
+  (*                                                                       *)
+  function  FT_Done_FreeType(alibrary : FT_Library ) : FT_Error;
+    cdecl; external ft_lib name 'FT_Done_FreeType';
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Function>                                                            *)
+  (*    FT_Attach_File                                                     *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    `Attaches' a given font file to an existing face.  This is usually *)
+  (*    to read additional information for a single face object.  For      *)
+  (*    example, it is used to read the AFM files that come with Type 1    *)
+  (*    fonts in order to add kerning data and other metrics.              *)
+  (*                                                                       *)
+  (* <InOut>                                                               *)
+  (*    face         :: The target face object.                            *)
+  (*                                                                       *)
+  (* <Input>                                                               *)
+  (*    filepathname :: An 8-bit pathname naming the `metrics' file.       *)
+  (*                                                                       *)
+  (* <Return>                                                              *)
+  (*    FreeType error code.  0 means success.                             *)
+  (*                                                                       *)
+  (* <Note>                                                                *)
+  (*    If your font file is in memory, or if you want to provide your     *)
+  (*    own input stream object, use @FT_Attach_Stream.                    *)
+  (*                                                                       *)
+  (*    The meaning of the `attach' action (i.e., what really happens when *)
+  (*    the new file is read) is not fixed by FreeType itself.  It really  *)
+  (*    depends on the font format (and thus the font driver).             *)
+  (*                                                                       *)
+  (*    Client applications are expected to know what they are doing       *)
+  (*    when invoking this function.  Most drivers simply do not implement *)
+  (*    file attachments.                                                  *)
+  (*                                                                       *)
+  function  FT_Attach_File(face : FT_Face; filepathname : PChar ) : FT_Error;
+    cdecl; external ft_lib name 'FT_Attach_File';
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Function>                                                            *)
+  (*    FT_New_Memory_Face                                                 *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    Creates a new face object from a given resource and typeface index *)
+  (*    using a font file already loaded into memory.                      *)
+  (*                                                                       *)
+  (* <InOut>                                                               *)
+  (*    library    :: A handle to the library resource.                    *)
+  (*                                                                       *)
+  (* <Input>                                                               *)
+  (*    file_base  :: A pointer to the beginning of the font data.         *)
+  (*                                                                       *)
+  (*    file_size  :: The size of the memory chunk used by the font data.  *)
+  (*                                                                       *)
+  (*    face_index :: The index of the face within the resource.  The      *)
+  (*                  first face has index 0.                              *)
+  (*                                                                       *)
+  (* <Output>                                                              *)
+  (*    aface      :: A handle to a new face object.                       *)
+  (*                                                                       *)
+  (* <Return>                                                              *)
+  (*    FreeType error code.  0 means success.                             *)
+  (*                                                                       *)
+  (* <Note>                                                                *)
+  (*    The font data bytes are used _directly_ by the @FT_Face object.    *)
+  (*    This means that they are not copied, and that the client is        *)
+  (*    responsible for releasing/destroying them _after_ the              *)
+  (*    corresponding call to @FT_Done_Face .                              *)
+  (*                                                                       *)
+  (*    Unlike FreeType 1.x, this function automatically creates a glyph   *)
+  (*    slot for the face object which can be accessed directly through    *)
+  (*    `face->glyph'.                                                     *)
+  (*                                                                       *)
+  (*    @FT_New_Memory_Face can be used to determine and/or check the font *)
+  (*    format of a given font resource.  If the `face_index' field is     *)
+  (*    negative, the function will _not_ return any face handle in        *)
+  (*    `aface'; the return value is 0 if the font format is recognized,   *)
+  (*    or non-zero otherwise.                                             *)
+  (*                                                                       *)
+  function  FT_New_Memory_Face(
+            library_ : FT_Library;
+            file_base : PFT_Byte;
+            file_size ,
+            face_index : FT_Long;
+            out aface :  FT_Face ) : FT_Error;
+    cdecl; external ft_lib name 'FT_New_Memory_Face';
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Function>                                                            *)
+  (*    FT_New_Face                                                        *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    Creates a new face object from a given resource and typeface index *)
+  (*    using a pathname to the font file.                                 *)
+  (*                                                                       *)
+  (* <InOut>                                                               *)
+  (*    library    :: A handle to the library resource.                    *)
+  (*                                                                       *)
+  (* <Input>                                                               *)
+  (*    pathname   :: A path to the font file.                             *)
+  (*                                                                       *)
+  (*    face_index :: The index of the face within the resource.  The      *)
+  (*                  first face has index 0.                              *)
+  (*                                                                       *)
+  (* <Output>                                                              *)
+  (*    aface      :: A handle to a new face object.                       *)
+  (*                                                                       *)
+  (* <Return>                                                              *)
+  (*    FreeType error code.  0 means success.                             *)
+  (*                                                                       *)
+  (* <Note>                                                                *)
+  (*    Unlike FreeType 1.x, this function automatically creates a glyph   *)
+  (*    slot for the face object which can be accessed directly through    *)
+  (*    `face->glyph'.                                                     *)
+  (*                                                                       *)
+  (*    @FT_New_Face can be used to determine and/or check the font format *)
+  (*    of a given font resource.  If the `face_index' field is negative,  *)
+  (*    the function will _not_ return any face handle in `aface';  the    *)
+  (*    return value is 0 if the font format is recognized, or non-zero    *)
+  (*    otherwise.                                                         *)
+  (*                                                                       *)
+  (*    Each new face object created with this function also owns a        *)
+  (*    default @FT_Size object, accessible as `face->size'.               *)
+  (*                                                                       *)
+  function  FT_New_Face(
+            library_ : FT_Library;
+            filepathname : PChar;
+            face_index : FT_Long;
+            out aface : FT_Face ) : FT_Error;
+    cdecl; external ft_lib name 'FT_New_Face';
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Function>                                                            *)
+  (*    FT_Done_Face                                                       *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    Discards a given face object, as well as all of its child slots    *)
+  (*    and sizes.                                                         *)
+  (*                                                                       *)
+  (* <Input>                                                               *)
+  (*    face :: A handle to a target face object.                          *)
+  (*                                                                       *)
+  (* <Return>                                                              *)
+  (*    FreeType error code.  0 means success.                             *)
+  (*                                                                       *)
+  function  FT_Done_Face(face : FT_Face ) : FT_Error;
+    cdecl; external ft_lib name 'FT_Done_Face';
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Function>                                                            *)
+  (*    FT_Select_Charmap                                                  *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    Selects a given charmap by its encoding tag (as listed in          *)
+  (*    `freetype.h').                                                     *)
+  (*                                                                       *)
+  (* <InOut>                                                               *)
+  (*    face     :: A handle to the source face object.                    *)
+  (*                                                                       *)
+  (* <Input>                                                               *)
+  (*    encoding :: A handle to the selected charmap.                      *)
+  (*                                                                       *)
+  (* <Return>                                                              *)
+  (*    FreeType error code.  0 means success.                             *)
+  (*                                                                       *)
+  (* <Note>                                                                *)
+  (*    This function will return an error if no charmap in the face       *)
+  (*    corresponds to the encoding queried here.                          *)
+  (*                                                                       *)
+  function  FT_Select_Charmap(face : FT_Face; encoding : FT_Encoding ) : FT_Error;
+    cdecl; external ft_lib name 'FT_Select_Charmap';
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Function>                                                            *)
+  (*    FT_Get_Char_Index                                                  *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    Returns the glyph index of a given character code.  This function  *)
+  (*    uses a charmap object to do the translation.                       *)
+  (*                                                                       *)
+  (* <Input>                                                               *)
+  (*    face     :: A handle to the source face object.                    *)
+  (*                                                                       *)
+  (*    charcode :: The character code.                                    *)
+  (*                                                                       *)
+  (* <Return>                                                              *)
+  (*    The glyph index.  0 means `undefined character code'.              *)
+  (*                                                                       *)
+  (* <Note>                                                                *)
+  (*    FreeType computes its own glyph indices which are not necessarily  *)
+  (*    the same as used in the font in case the font is based on glyph    *)
+  (*    indices.  Reason for this behaviour is to assure that index 0 is   *)
+  (*    never used, representing the missing glyph.                        *)
+  (*                                                                       *)
+  function  FT_Get_Char_Index(face : FT_Face; charcode : FT_ULong ) : FT_UInt;
+    cdecl; external ft_lib name 'FT_Get_Char_Index';
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Function>                                                            *)
+  (*    FT_Load_Glyph                                                      *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    A function used to load a single glyph within a given glyph slot,  *)
+  (*    for a given size.                                                  *)
+  (*                                                                       *)
+  (* <InOut>                                                               *)
+  (*    face        :: A handle to the target face object where the glyph  *)
+  (*                   will be loaded.                                     *)
+  (*                                                                       *)
+  (* <Input>                                                               *)
+  (*    glyph_index :: The index of the glyph in the font file.  For       *)
+  (*                   CID-keyed fonts (either in PS or in CFF format)     *)
+  (*                   this argument specifies the CID value.              *)
+  (*                                                                       *)
+  (*    load_flags  :: A flag indicating what to load for this glyph.  The *)
+  (*                   @FT_LOAD_XXX constants can be used to control the   *)
+  (*                   glyph loading process (e.g., whether the outline    *)
+  (*                   should be scaled, whether to load bitmaps or not,   *)
+  (*                   whether to hint the outline, etc).                  *)
+  (*                                                                       *)
+  (* <Return>                                                              *)
+  (*    FreeType error code.  0 means success.                             *)
+  (*                                                                       *)
+  (* <Note>                                                                *)
+  (*    If the glyph image is not a bitmap, and if the bit flag            *)
+  (*    FT_LOAD_IGNORE_TRANSFORM is unset, the glyph image will be         *)
+  (*    transformed with the information passed to a previous call to      *)
+  (*    @FT_Set_Transform.                                                 *)
+  (*                                                                       *)
+  (*    Note that this also transforms the `face.glyph.advance' field, but *)
+  (*    *not* the values in `face.glyph.metrics'.                          *)
+  (*                                                                       *)
+  function  FT_Load_Glyph(
+            face : FT_Face;
+            glyph_index : FT_UInt ;
+            load_flags : FT_Int32 ) : FT_Error;
+    cdecl; external ft_lib name 'FT_Load_Glyph';
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Enum>                                                                *)
+  (*    FT_Render_Mode                                                     *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    An enumeration type that lists the render modes supported by       *)
+  (*    FreeType 2.  Each mode corresponds to a specific type of scanline  *)
+  (*    conversion performed on the outline, as well as specific           *)
+  (*    hinting optimizations.                                             *)
+  (*                                                                       *)
+  (*    For bitmap fonts the `bitmap->pixel_mode' field in the             *)
+  (*    @FT_GlyphSlotRec structure gives the format of the returned        *)
+  (*    bitmap.                                                            *)
+  (*                                                                       *)
+  (* <Values>                                                              *)
+  (*    FT_RENDER_MODE_NORMAL ::                                           *)
+  (*      This is the default render mode; it corresponds to 8-bit         *)
+  (*      anti-aliased bitmaps, using 256 levels of opacity.               *)
+  (*                                                                       *)
+  (*    FT_RENDER_MODE_LIGHT ::                                            *)
+  (*      This is similar to @FT_RENDER_MODE_NORMAL -- you have to use     *)
+  (*      @FT_LOAD_TARGET_LIGHT in calls to @FT_Load_Glyph to get any      *)
+  (*      effect since the rendering process no longer influences the      *)
+  (*      positioning of glyph outlines.                                   *)
+  (*                                                                       *)
+  (*      The resulting glyph shapes are more similar to the original,     *)
+  (*      while being a bit more fuzzy (`better shapes' instead of `better *)
+  (*      contrast', so to say.                                            *)
+  (*                                                                       *)
+  (*    FT_RENDER_MODE_MONO ::                                             *)
+  (*      This mode corresponds to 1-bit bitmaps.                          *)
+  (*                                                                       *)
+  (*    FT_RENDER_MODE_LCD ::                                              *)
+  (*      This mode corresponds to horizontal RGB/BGR sub-pixel displays,  *)
+  (*      like LCD-screens.  It produces 8-bit bitmaps that are 3 times    *)
+  (*      the width of the original glyph outline in pixels, and which use *)
+  (*      the @FT_PIXEL_MODE_LCD mode.                                     *)
+  (*                                                                       *)
+  (*    FT_RENDER_MODE_LCD_V ::                                            *)
+  (*      This mode corresponds to vertical RGB/BGR sub-pixel displays     *)
+  (*      (like PDA screens, rotated LCD displays, etc.).  It produces     *)
+  (*      8-bit bitmaps that are 3 times the height of the original        *)
+  (*      glyph outline in pixels and use the @FT_PIXEL_MODE_LCD_V mode.   *)
+  (*                                                                       *)
+  (* <Note>                                                                *)
+  (*   The LCD-optimized glyph bitmaps produced by FT_Render_Glyph are     *)
+  (*   _not filtered_ to reduce color-fringes.  It is up to the caller to  *)
+  (*   perform this pass.                                                  *)
+  (*                                                                       *)
+const
+  FT_RENDER_MODE_NORMAL = 0;
+  FT_RENDER_MODE_LIGHT  = FT_RENDER_MODE_NORMAL + 1;
+  FT_RENDER_MODE_MONO   = FT_RENDER_MODE_LIGHT  + 1;
+  FT_RENDER_MODE_LCD    = FT_RENDER_MODE_MONO   + 1;
+  FT_RENDER_MODE_LCD_V  = FT_RENDER_MODE_LCD    + 1;
+  FT_RENDER_MODE_MAX    = FT_RENDER_MODE_LCD_V  + 1;
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Function>                                                            *)
+  (*    FT_Render_Glyph                                                    *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    Converts a given glyph image to a bitmap.  It does so by           *)
+  (*    inspecting the glyph image format, find the relevant renderer, and *)
+  (*    invoke it.                                                         *)
+  (*                                                                       *)
+  (* <InOut>                                                               *)
+  (*    slot        :: A handle to the glyph slot containing the image to  *)
+  (*                   convert.                                            *)
+  (*                                                                       *)
+  (* <Input>                                                               *)
+  (*    render_mode :: This is the render mode used to render the glyph    *)
+  (*                   image into a bitmap.  See FT_Render_Mode for a list *)
+  (*                   of possible values.                                 *)
+  (*                                                                       *)
+  (* <Return>                                                              *)
+  (*    FreeType error code.  0 means success.                             *)
+  (*                                                                       *)
+  function  FT_Render_Glyph(slot : FT_GlyphSlot; render_mode : FT_Render_Mode ) : FT_Error;
+    cdecl; external ft_lib name 'FT_Render_Glyph';
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Enum>                                                                *)
+  (*    FT_Kerning_Mode                                                    *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    An enumeration used to specify which kerning values to return in   *)
+  (*    @FT_Get_Kerning.                                                   *)
+  (*                                                                       *)
+  (* <Values>                                                              *)
+  (*    FT_KERNING_DEFAULT  :: Return scaled and grid-fitted kerning       *)
+  (*                           distances (value is 0).                     *)
+  (*                                                                       *)
+  (*    FT_KERNING_UNFITTED :: Return scaled but un-grid-fitted kerning    *)
+  (*                           distances.                                  *)
+  (*                                                                       *)
+  (*    FT_KERNING_UNSCALED :: Return the kerning vector in original font  *)
+  (*                           units.                                      *)
+  (*                                                                       *)
+const
+  FT_KERNING_DEFAULT  = 0;
+  FT_KERNING_UNFITTED = 1;
+  FT_KERNING_UNSCALED = 2;
+
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Function>                                                            *)
+  (*    FT_Get_Kerning                                                     *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    Returns the kerning vector between two glyphs of a same face.      *)
+  (*                                                                       *)
+  (* <Input>                                                               *)
+  (*    face        :: A handle to a source face object.                   *)
+  (*                                                                       *)
+  (*    left_glyph  :: The index of the left glyph in the kern pair.       *)
+  (*                                                                       *)
+  (*    right_glyph :: The index of the right glyph in the kern pair.      *)
+  (*                                                                       *)
+  (*    kern_mode   :: See @FT_Kerning_Mode for more information.          *)
+  (*                   Determines the scale/dimension of the returned      *)
+  (*                   kerning vector.                                     *)
+  (*                                                                       *)
+  (* <Output>                                                              *)
+  (*    akerning    :: The kerning vector.  This is in font units for      *)
+  (*                   scalable formats, and in pixels for fixed-sizes     *)
+  (*                   formats.                                            *)
+  (*                                                                       *)
+  (* <Return>                                                              *)
+  (*    FreeType error code.  0 means success.                             *)
+  (*                                                                       *)
+  (* <Note>                                                                *)
+  (*    Only horizontal layouts (left-to-right & right-to-left) are        *)
+  (*    supported by this method.  Other layouts, or more sophisticated    *)
+  (*    kernings, are out of the scope of this API function -- they can be *)
+  (*    implemented through format-specific interfaces.                    *)
+  (*                                                                       *)
+  function  FT_Get_Kerning(
+            face : FT_Face;
+            left_glyph ,
+            right_glyph ,
+            kern_mode : FT_UInt;
+            out akerning : FT_Vector ) : FT_Error;
+    cdecl; external ft_lib name 'FT_Get_Kerning';
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Function>                                                            *)
+  (*    FT_Set_Char_Size                                                   *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    Sets the character dimensions of a given face object.  The         *)
+  (*    `char_width' and `char_height' values are used for the width and   *)
+  (*    height, respectively, expressed in 26.6 fractional points.         *)
+  (*                                                                       *)
+  (*    If the horizontal or vertical resolution values are zero, a        *)
+  (*    default value of 72dpi is used.  Similarly, if one of the          *)
+  (*    character dimensions is zero, its value is set equal to the other. *)
+  (*                                                                       *)
+  (* <InOut>                                                               *)
+  (*    face            :: A handle to a target face object.               *)
+  (*                                                                       *)
+  (* <Input>                                                               *)
+  (*    char_width      :: The character width, in 26.6 fractional points. *)
+  (*                                                                       *)
+  (*    char_height     :: The character height, in 26.6 fractional        *)
+  (*                       points.                                         *)
+  (*                                                                       *)
+  (*    horz_resolution :: The horizontal resolution.                      *)
+  (*                                                                       *)
+  (*    vert_resolution :: The vertical resolution.                        *)
+  (*                                                                       *)
+  (* <Return>                                                              *)
+  (*    FreeType error code.  0 means success.                             *)
+  (*                                                                       *)
+  (* <Note>                                                                *)
+  (*    When dealing with fixed-size faces (i.e., non-scalable formats),   *)
+  (*    @FT_Set_Pixel_Sizes provides a more convenient interface.          *)
+  (*                                                                       *)
+  function  FT_Set_Char_Size(
+            face : FT_Face;
+            char_width ,
+            char_height : FT_F26dot6;
+            horz_res ,
+            vert_res : FT_UInt) : FT_Error;
+    cdecl; external ft_lib name 'FT_Set_Char_Size';
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Function>                                                            *)
+  (*    FT_Set_Pixel_Sizes                                                 *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    Sets the character dimensions of a given face object.  The width   *)
+  (*    and height are expressed in integer pixels.                        *)
+  (*                                                                       *)
+  (*    If one of the character dimensions is zero, its value is set equal *)
+  (*    to the other.                                                      *)
+  (*                                                                       *)
+  (* <InOut>                                                               *)
+  (*    face         :: A handle to the target face object.                *)
+  (*                                                                       *)
+  (* <Input>                                                               *)
+  (*    pixel_width  :: The character width, in integer pixels.            *)
+  (*                                                                       *)
+  (*    pixel_height :: The character height, in integer pixels.           *)
+  (*                                                                       *)
+  (* <Return>                                                              *)
+  (*    FreeType error code.  0 means success.                             *)
+  (*                                                                       *)
+  (* <Note>                                                                *)
+  (*    The values of `pixel_width' and `pixel_height' correspond to the   *)
+  (*    pixel values of the _typographic_ character size, which are NOT    *)
+  (*    necessarily the same as the dimensions of the glyph `bitmap        *)
+  (*    cells'.                                                            *)
+  (*                                                                       *)
+  (*    The `character size' is really the size of an abstract square      *)
+  (*    called the `EM', used to design the font.  However, depending      *)
+  (*    on the font design, glyphs will be smaller or greater than the     *)
+  (*    EM.                                                                *)
+  (*                                                                       *)
+  (*    This means that setting the pixel size to, say, 8x8 doesn't        *)
+  (*    guarantee in any way that you will get glyph bitmaps that all fit  *)
+  (*    within an 8x8 cell (sometimes even far from it).                   *)
+  (*                                                                       *)
+  (*    For bitmap fonts, `pixel_height' usually is a reliable value for   *)
+  (*    the height of the bitmap cell.  Drivers for bitmap font formats    *)
+  (*    which contain a single bitmap strike only (BDF, PCF, FNT) ignore   *)
+  (*    `pixel_width'.                                                     *)
+  (*                                                                       *)
+  function  FT_Set_Pixel_Sizes(
+            face : FT_Face;
+            pixel_width ,
+            pixel_height : FT_UInt ) : FT_Error;
+    cdecl; external ft_lib name 'FT_Set_Pixel_Sizes';
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Function>                                                            *)
+  (*    FT_Get_Glyph                                                       *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    A function used to extract a glyph image from a slot.              *)
+  (*                                                                       *)
+  (* <Input>                                                               *)
+  (*    slot   :: A handle to the source glyph slot.                       *)
+  (*                                                                       *)
+  (* <Output>                                                              *)
+  (*    aglyph :: A handle to the glyph object.                            *)
+  (*                                                                       *)
+  (* <Return>                                                              *)
+  (*    FreeType error code.  0 means success.                             *)
+  (*                                                                       *)
+  function FT_Get_Glyph(
+             slot:   FT_GlyphSlot;
+             out aglyph: FT_Glyph ): FT_Error;
+    cdecl; external ft_lib name 'FT_Get_Glyph';
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Enum>                                                                *)
+  (*    FT_Glyph_BBox_Mode                                                 *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    The mode how the values of @FT_Glyph_Get_CBox are returned.        *)
+  (*                                                                       *)
+  (* <Values>                                                              *)
+  (*    FT_GLYPH_BBOX_UNSCALED ::                                          *)
+  (*      Return unscaled font units.                                      *)
+  (*                                                                       *)
+  (*    FT_GLYPH_BBOX_SUBPIXELS ::                                         *)
+  (*      Return unfitted 26.6 coordinates.                                *)
+  (*                                                                       *)
+  (*    FT_GLYPH_BBOX_GRIDFIT ::                                           *)
+  (*      Return grid-fitted 26.6 coordinates.                             *)
+  (*                                                                       *)
+  (*    FT_GLYPH_BBOX_TRUNCATE ::                                          *)
+  (*      Return coordinates in integer pixels.                            *)
+  (*                                                                       *)
+  (*    FT_GLYPH_BBOX_PIXELS ::                                            *)
+  (*      Return grid-fitted pixel coordinates.                            *)
+  (*                                                                       *)
+type
+  FT_Glyph_BBox_Mode = FT_UInt;
+const
+  FT_GLYPH_BBOX_UNSCALED  = 0;
+  FT_GLYPH_BBOX_SUBPIXELS = 0;
+  FT_GLYPH_BBOX_GRIDFIT   = 1;
+  FT_GLYPH_BBOX_TRUNCATE  = 2;
+  FT_GLYPH_BBOX_PIXELS    = 3;
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Function>                                                            *)
+  (*    FT_Glyph_Get_CBox                                                  *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    Return a glyph's `control box'.  The control box encloses all the  *)
+  (*    outline's points, including Bézier control points.  Though it      *)
+  (*    coincides with the exact bounding box for most glyphs, it can be   *)
+  (*    slightly larger in some situations (like when rotating an outline  *)
+  (*    which contains Bézier outside arcs).                               *)
+  (*                                                                       *)
+  (*    Computing the control box is very fast, while getting the bounding *)
+  (*    box can take much more time as it needs to walk over all segments  *)
+  (*    and arcs in the outline.  To get the latter, you can use the       *)
+  (*    `ftbbox' component which is dedicated to this single task.         *)
+  (*                                                                       *)
+  (* <Input>                                                               *)
+  (*    glyph :: A handle to the source glyph object.                      *)
+  (*                                                                       *)
+  (*    mode  :: The mode which indicates how to interpret the returned    *)
+  (*             bounding box values.                                      *)
+  (*                                                                       *)
+  (* <Output>                                                              *)
+  (*    acbox :: The glyph coordinate bounding box.  Coordinates are       *)
+  (*             expressed in 1/64th of pixels if it is grid-fitted.       *)
+  (*                                                                       *)
+  (* <Note>                                                                *)
+  (*    Coordinates are relative to the glyph origin, using the Y-upwards  *)
+  (*    convention.                                                        *)
+  (*                                                                       *)
+  (*    If the glyph has been loaded with @FT_LOAD_NO_SCALE, `bbox_mode'   *)
+  (*    must be set to @FT_GLYPH_BBOX_UNSCALED to get unscaled font        *)
+  (*    units in 26.6 pixel format.  The value @FT_GLYPH_BBOX_SUBPIXELS    *)
+  (*    is another name for this constant.                                 *)
+  (*                                                                       *)
+  (*    Note that the maximum coordinates are exclusive, which means that  *)
+  (*    one can compute the width and height of the glyph image (be it in  *)
+  (*    integer or 26.6 pixels) as:                                        *)
+  (*                                                                       *)
+  (*    {                                                                  *)
+  (*      width  = bbox.xMax - bbox.xMin;                                  *)
+  (*      height = bbox.yMax - bbox.yMin;                                  *)
+  (*    }                                                                  *)
+  (*                                                                       *)
+  (*    Note also that for 26.6 coordinates, if `bbox_mode' is set to      *)
+  (*    @FT_GLYPH_BBOX_GRIDFIT, the coordinates will also be grid-fitted,  *)
+  (*    which corresponds to:                                              *)
+  (*                                                                       *)
+  (*    {                                                                  *)
+  (*      bbox.xMin = FLOOR(bbox.xMin);                                    *)
+  (*      bbox.yMin = FLOOR(bbox.yMin);                                    *)
+  (*      bbox.xMax = CEILING(bbox.xMax);                                  *)
+  (*      bbox.yMax = CEILING(bbox.yMax);                                  *)
+  (*    }                                                                  *)
+  (*                                                                       *)
+  (*    To get the bbox in pixel coordinates, set `bbox_mode' to           *)
+  (*    @FT_GLYPH_BBOX_TRUNCATE.                                           *)
+  (*                                                                       *)
+  (*    To get the bbox in grid-fitted pixel coordinates, set `bbox_mode'  *)
+  (*    to @FT_GLYPH_BBOX_PIXELS.                                          *)
+  (*                                                                       *)
+  procedure FT_Glyph_Get_CBox( glyph: FT_Glyph;
+                     bbox_mode: FT_UInt;
+                     out acbox: FT_BBox );
+    cdecl; external ft_lib name 'FT_Glyph_Get_CBox';
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Function>                                                            *)
+  (*    FT_Glyph_To_Bitmap                                                 *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    Converts a given glyph object to a bitmap glyph object.            *)
+  (*                                                                       *)
+  (* <InOut>                                                               *)
+  (*    the_glyph   :: A pointer to a handle to the target glyph.          *)
+  (*                                                                       *)
+  (* <Input>                                                               *)
+  (*    render_mode :: An enumeration that describe how the data is        *)
+  (*                   rendered.                                           *)
+  (*                                                                       *)
+  (*    origin      :: A pointer to a vector used to translate the glyph   *)
+  (*                   image before rendering.  Can be 0 (if no            *)
+  (*                   translation).  The origin is expressed in           *)
+  (*                   26.6 pixels.                                        *)
+  (*                                                                       *)
+  (*    destroy     :: A boolean that indicates that the original glyph    *)
+  (*                   image should be destroyed by this function.  It is  *)
+  (*                   never destroyed in case of error.                   *)
+  (*                                                                       *)
+  (* <Return>                                                              *)
+  (*    FreeType error code.  0 means success.                             *)
+  (*                                                                       *)
+  (* <Note>                                                                *)
+  (*    The glyph image is translated with the `origin' vector before      *)
+  (*    rendering.                                                         *)
+  (*                                                                       *)
+  (*    The first parameter is a pointer to a FT_Glyph handle, that will   *)
+  (*    be replaced by this function.  Typically, you would use (omitting  *)
+  (*    error handling):                                                   *)
+  (*                                                                       *)
+  (*                                                                       *)
+  (*      {                                                                *)
+  (*        FT_Glyph        glyph;                                         *)
+  (*        FT_BitmapGlyph  glyph_bitmap;                                  *)
+  (*                                                                       *)
+  (*                                                                       *)
+  (*        // load glyph                                                  *)
+  (*        error = FT_Load_Char( face, glyph_index, FT_LOAD_DEFAUT );     *)
+  (*                                                                       *)
+  (*        // extract glyph image                                         *)
+  (*        error = FT_Get_Glyph( face->glyph, &glyph );                   *)
+  (*                                                                       *)
+  (*        // convert to a bitmap (default render mode + destroy old)     *)
+  (*        if ( glyph->format != FT_GLYPH_FORMAT_BITMAP )                 *)
+  (*        {                                                              *)
+  (*          error = FT_Glyph_To_Bitmap( &glyph, FT_RENDER_MODE_DEFAULT,  *)
+  (*                                      0, 1 );                          *)
+  (*          if ( error ) // glyph unchanged                              *)
+  (*            ...                                                        *)
+  (*        }                                                              *)
+  (*                                                                       *)
+  (*        // access bitmap content by typecasting                        *)
+  (*        glyph_bitmap = (FT_BitmapGlyph)glyph;                          *)
+  (*                                                                       *)
+  (*        // do funny stuff with it, like blitting/drawing               *)
+  (*        ...                                                            *)
+  (*                                                                       *)
+  (*        // discard glyph image (bitmap or not)                         *)
+  (*        FT_Done_Glyph( glyph );                                        *)
+  (*      }                                                                *)
+  (*                                                                       *)
+  (*                                                                       *)
+  (*    This function does nothing if the glyph format isn't scalable.     *)
+  (*                                                                       *)
+  function FT_Glyph_To_Bitmap(var the_glyph: FT_Glyph;
+                      render_mode: FT_Render_Mode;
+                      origin:      PFT_Vector;
+                      destroy:     FT_Bool ): FT_Error;
+    cdecl; external ft_lib name 'FT_Glyph_To_Bitmap';
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Function>                                                            *)
+  (*    FT_Done_Glyph                                                      *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    Destroys a given glyph.                                            *)
+  (*                                                                       *)
+  (* <Input>                                                               *)
+  (*    glyph :: A handle to the target glyph object.                      *)
+  (*                                                                       *)
+  procedure FT_Done_Glyph( glyph: FT_Glyph );
+    cdecl; external ft_lib name 'FT_Done_Glyph';
+
+implementation
+
+
+{ FT_CURVE_TAG }
+function FT_CURVE_TAG(flag : char ) : char;
+begin
+  result := char(byte(flag) and 3);
+end;
+
+{ FT_IS_SCALABLE }
+function FT_IS_SCALABLE(face : FT_Face ) : cbool;
+begin
+  result := cbool(face.face_flags and FT_FACE_FLAG_SCALABLE );
+end;
+
+{ FT_HAS_KERNING }
+function FT_HAS_KERNING(face : FT_Face ) : cbool;
+begin
+  result := cbool(face.face_flags and FT_FACE_FLAG_KERNING );
+end;
+
+end.
+