FT_EXPORT( FT_Long )
  FT_MulDiv( FT_Long  a,
             FT_Long  b,
             FT_Long  c );

A very simple function used to perform the computation ‘(a*b)/c’ with maximum accuracy (it uses a 64-bit intermediate integer whenever necessary).

This function isn't necessarily as fast as some processor specific operations, but is at least completely portable.

The result of ‘(a*b)/c’. This function never traps when trying to divide by zero; it simply returns ‘MaxInt’ or ‘MinInt’ depending on the signs of ‘a’ and ‘b’.

  FT_EXPORT( FT_Long )
  FT_MulFix( FT_Long  a,
             FT_Long  b );

A very simple function used to perform the computation ‘(a*b)/0x10000’ with maximum accuracy. Most of the time this is used to multiply a given value by a 16.16 fixed-point factor.

The result of ‘(a*b)/0x10000’.

This function has been optimized for the case where the absolute value of ‘a’ is less than 2048, and ‘b’ is a 16.16 scaling factor. As this happens mainly when scaling from notional units to fractional pixels in FreeType, it resulted in noticeable speed improvements between versions 2.x and 1.x.

As a conclusion, always try to place a 16.16 factor as the second argument of this function; this can make a great difference.

  FT_EXPORT( FT_Long )
  FT_DivFix( FT_Long  a,
             FT_Long  b );

A very simple function used to perform the computation ‘(a*0x10000)/b’ with maximum accuracy. Most of the time, this is used to divide a given value by a 16.16 fixed-point factor.

The result of ‘(a*0x10000)/b’.

The optimization for FT_DivFix() is simple: If (a << 16) fits in 32 bits, then the division is computed directly. Otherwise, we use a specialized version of FT_MulDiv.

  FT_EXPORT( FT_Fixed )
  FT_RoundFix( FT_Fixed  a );

A very simple function used to round a 16.16 fixed number.

The result of ‘(a + 0x8000) & -0x10000’.

  FT_EXPORT( FT_Fixed )
  FT_CeilFix( FT_Fixed  a );

A very simple function used to compute the ceiling function of a 16.16 fixed number.

The result of ‘(a + 0x10000 - 1) & -0x10000’.

  FT_EXPORT( FT_Fixed )
  FT_FloorFix( FT_Fixed  a );

A very simple function used to compute the floor function of a 16.16 fixed number.

The result of ‘a & -0x10000’.

  FT_EXPORT( void )
  FT_Vector_Transform( FT_Vector*        vec,
                       const FT_Matrix*  matrix );

Transform a single vector through a 2x2 matrix.

The result is undefined if either ‘vector’ or ‘matrix’ is invalid.

  FT_EXPORT( void )
  FT_Matrix_Multiply( const FT_Matrix*  a,
                      FT_Matrix*        b );

Perform the matrix operation ‘b = a*b’.

The result is undefined if either ‘a’ or ‘b’ is zero.

  FT_EXPORT( FT_Error )
  FT_Matrix_Invert( FT_Matrix*  matrix );

Invert a 2x2 matrix. Return an error if it can't be inverted.

FreeType error code. 0 means success.

  typedef FT_Fixed  FT_Angle;

This type is used to model angle values in FreeType. Note that the angle is a 16.16 fixed-point value expressed in degrees.

#define FT_ANGLE_PI  ( 180L << 16 )

The angle pi expressed in FT_Angle units.

#define FT_ANGLE_2PI  ( FT_ANGLE_PI * 2 )

The angle 2*pi expressed in FT_Angle units.

#define FT_ANGLE_PI2  ( FT_ANGLE_PI / 2 )

The angle pi/2 expressed in FT_Angle units.

#define FT_ANGLE_PI4  ( FT_ANGLE_PI / 4 )

The angle pi/4 expressed in FT_Angle units.

  FT_EXPORT( FT_Fixed )
  FT_Sin( FT_Angle  angle );

Return the sinus of a given angle in fixed-point format.

The sinus value.

If you need both the sinus and cosinus for a given angle, use the function FT_Vector_Unit.

  FT_EXPORT( FT_Fixed )
  FT_Cos( FT_Angle  angle );

Return the cosinus of a given angle in fixed-point format.

The cosinus value.

If you need both the sinus and cosinus for a given angle, use the function FT_Vector_Unit.

  FT_EXPORT( FT_Fixed )
  FT_Tan( FT_Angle  angle );

Return the tangent of a given angle in fixed-point format.

The tangent value.

  FT_EXPORT( FT_Angle )
  FT_Atan2( FT_Fixed  x,
            FT_Fixed  y );

Return the arc-tangent corresponding to a given vector (x,y) in the 2d plane.

The arc-tangent value (i.e. angle).

  FT_EXPORT( FT_Angle )
  FT_Angle_Diff( FT_Angle  angle1,
                 FT_Angle  angle2 );

Return the difference between two angles. The result is always constrained to the ]-PI..PI] interval.

Constrained value of ‘value2-value1’.

  FT_EXPORT( void )
  FT_Vector_Unit( FT_Vector*  vec,
                  FT_Angle    angle );

Return the unit vector corresponding to a given angle. After the call, the value of ‘vec.x’ will be ‘sin(angle)’, and the value of ‘vec.y’ will be ‘cos(angle)’.

This function is useful to retrieve both the sinus and cosinus of a given angle quickly.

  FT_EXPORT( void )
  FT_Vector_Rotate( FT_Vector*  vec,
                    FT_Angle    angle );

Rotate a vector by a given angle.

  FT_EXPORT( FT_Fixed )
  FT_Vector_Length( FT_Vector*  vec );

Return the length of a given vector.

The vector length, expressed in the same units that the original vector coordinates.

  FT_EXPORT( void )
  FT_Vector_Polarize( FT_Vector*  vec,
                      FT_Fixed   *length,
                      FT_Angle   *angle );

Compute both the length and angle of a given vector.

  FT_EXPORT( void )
  FT_Vector_From_Polar( FT_Vector*  vec,
                        FT_Fixed    length,
                        FT_Angle    angle );

Compute vector coordinates from a length and angle.