typedef struct FT_GlyphRec_*  FT_Glyph;

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.

Glyph objects are not owned by the library. You must thus release them manually (through FT_Done_Glyph before calling FT_Done_FreeType

  typedef struct  FT_GlyphRec_
  {
    FT_Library             library;
    const FT_Glyph_Class*  clazz;
    FT_Glyph_Format        format;
    FT_Vector              advance;

  } FT_GlyphRec;

The root glyph structure contains a given glyph image plus its advance width in 16.16 fixed float format.

  typedef struct FT_BitmapGlyphRec_*  FT_BitmapGlyph;

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

  typedef struct  FT_BitmapGlyphRec_
  {
    FT_GlyphRec  root;
    FT_Int       left;
    FT_Int       top;
    FT_Bitmap    bitmap;

  } FT_BitmapGlyphRec;

A structure used for bitmap glyph images. This really is a `sub-class' of `FT_GlyphRec'.

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.

  typedef struct FT_OutlineGlyphRec_*  FT_OutlineGlyph;

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

  typedef struct  FT_OutlineGlyphRec_
  {
    FT_GlyphRec  root;
    FT_Outline   outline;

  } FT_OutlineGlyphRec;

A structure used for outline (vectorial) glyph images. This really is a `sub-class' of `FT_GlyphRec'.

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_EXPORT( FT_Error )
  FT_Get_Glyph( FT_GlyphSlot  slot,
                FT_Glyph     *aglyph );

A function used to extract a glyph image from a slot.

FreeType error code. 0 means success.

  FT_EXPORT( FT_Error )
  FT_Glyph_Copy( FT_Glyph   source,
                 FT_Glyph  *target );

A function used to copy a glyph image.

FreeType error code. 0 means success.

  FT_EXPORT( FT_Error )
  FT_Glyph_Transform( FT_Glyph    glyph,
                      FT_Matrix*  matrix,
                      FT_Vector*  delta );

Transforms a glyph image if its format is scalable.

FreeType error code (the glyph format is not scalable if it is not zero).

The 2x2 transformation matrix is also applied to the glyph's advance vector.

  enum
  {
    ft_glyph_bbox_unscaled  = 0, /* return unscaled font units           */
    ft_glyph_bbox_subpixels = 0, /* return unfitted 26.6 coordinates     */
    ft_glyph_bbox_gridfit   = 1, /* return grid-fitted 26.6 coordinates  */
    ft_glyph_bbox_truncate  = 2, /* return coordinates in integer pixels */
    ft_glyph_bbox_pixels    = 3  /* return grid-fitted pixel coordinates */
  };


  FT_EXPORT( void )
  FT_Glyph_Get_CBox( FT_Glyph  glyph,
                     FT_UInt   bbox_mode,
                     FT_BBox  *acbox );

Returns a glyph's `control box'. The control box encloses all the outline's points, including Bezier 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 Bezier 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.

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.

If `bbox_mode' is set to `ft_glyph_bbox_subpixels' the bbox coordinates are returned in 26.6 pixels (i.e. 1/64th of pixels).

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'.

The default value for `bbox_mode' is `ft_glyph_bbox_pixels'.

  FT_EXPORT( FT_Error )
  FT_Glyph_To_Bitmap( FT_Glyph*       the_glyph,
                      FT_Render_Mode  render_mode,
                      FT_Vector*      origin,
                      FT_Bool         destroy );

Converts a given glyph object to a bitmap glyph object.

FreeType error code. 0 means success.

The glyph image is translated with the `origin' vector before rendering. In case of error, it it translated back to its original position and the glyph is left untouched.

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 will always fail if the glyph's format isn't scalable.

  FT_EXPORT( void )
  FT_Done_Glyph( FT_Glyph  glyph );


  /* other helpful functions */

Destroys a given glyph.