./ttfcompile font size gap search-radius output-size [-chars=chars-set] [-charsfile=chars-file] [-o=output-name]

character-count : uint32  // number of characters in the font atlas
line-height     : float   // height between baselines for font rendering.
line-ascender   : float   // (not-guaranteed) height from the base line to
                             highest point in the font.
line-descender  : float   // (not-guaranteed) height from the base line to
                             lowest point in the font.
{ character-code : uint32   // Unicode code point associated with atlas index.
  horiz-advance  : float    // How much to advance pen-position after
                               rendering this character.
  offset-left    : float    // horizontal offset to pen-position when
                               rendering this character.
  offset-top     : float    // vertical offset to pen-position when
                               rendering this character.
  char-width     : float    // width of character
  char-height    : float    // height of character
  atlas-u        : float    // normalised tex-coordinate in atlas
                               for this character.
  atlas-v        : float    // normalised tex-coordinate in atlas
                               for this character.
  atlas-w        : float    // normalised width in atlas for character.
  atlas-h        : float    // normalised height in atlas for character.
}  <-- repeated character-count times.
{ horiz-kerning  : float    // horizontal offset to be applied before rendering
                               a character based on previously rendered char.
  repeats        : uint32   // number of times this kerning value is repeated in
                               the matrix.
}  <-- repeated as many times as is necessary to enumerate
      character-count * character-count entries.

[[ 0, 0, 0, 1 ]
 [-1, 1, 1, 0 ]
 [ 0, 0, 0, 0 ]
 [ 1, 1, 1, 1 ]]

0:ft, 3:u32, 1:ft, 1:u32, -1:ft, 1:u32, 1:ft, 2:u32, 0:ft, 5:u32, 1:ft, 4:u32

./ttfcompile -transform input.png search-radius output-size [-o=output-name]

class Font {
    // Load font files, create opengl texture (must have a context!)
    // Can pass null for .dat path if wanting to simply load
    // the distance map to a texture for use.
    function new(path_to_dat:Null<String>, path_to_png:String);

    // ID for the opengl texture generated.
    var texture : GLuint;

    // Information from .dat file parsed.
    var info : FontInfo;

    // Destroy GL state, can't use font following this call.
    function destroy();
}

class FontInfo {
    // Map from character's unicode point value, to index in the atlas/FontInfo structure.
    var idmap : Map<Int,Int>;

    // Global font metrics
    var height : Float;
    var ascender : Float;
    var descender : Float;

    // Kerning matrix, [prev][curr] : Float for horizontal offset before rendering 'curr' after 'prev'
    var kerning : Array<Array<Float>>;

    // Metrics for each character in the font
    var metrics : Array<Metric>;
}

class Metric {
    // Horizontal offset after rendering character.
    var advance : Float;

    // Horizontal and vertical offsets for rendering character.
    var left : Float;
    var top : Float;

    // Character size
    var width : Float;
    var height : Float;

    // Character texture rectangle in atlas png
    var u : Float;
    var v : Float;
    var w : Float;
    var h : Float;
}

class FontRenderer {

    function new();

    // Set transformation matrix for rendering font to the screen.
    function setTransform(mat:Mat4) : FontRenderer;

    // Set font colour for rendering
    function setColour(colour:Vec4) : FontRenderer;

    // Begin rendering fonts (Selects gl program, enables vertex attrib arrays)
    function begin() : FontRenderer;

    // End rendering of fonts (disables vertex attrib arrays)
    function end() : FontRenderer;

    // Render a string, must be called being begin() and end()
    function render(string:StringBuffer) : FontRenderer;

    // Render arbitrary vertex data (with distance field texture)
    function renderRaw(texture:GLuint, vertexBuffer:GLuint) : FontRenderer;

    // Destroy GL state, can't use renderer following this call.
    function destroy();
}

class StringBuffer {

    // Create string buffer with initial space for 'size' characters
    // and with vertex buffer set for either static, or dynamic drawing.
    // (Strings that frequently change should be dynamic).
    function new(font:Font, ?size:Int=1, ?staticDraw:Bool=false);

    // Font in use for string, can be changed at any 'reasonable' time.
    // i.e. changing font, after setting text, but before rencering has no effect
    // on that rendered text.
    var font:Font;

    // Set StringBuffer to render the given string, using given alignment.
    // Multiline strings (delimited by \n) permitted.
    //
    // Returns Vec4 for text bounds (x,y,width,height)
    function set(string:String, ?align:FontAlign=AlignLeft) : Vec4;

    // Destroy GL state, can't use string buffer following this call.
    function destroy();
}

enum FontAlign {
    AlignLeft;   // Text drawn starting with first baseline at y=0, rendering each line to the right of origin.
    AlignRight;  // Text drawn starting with first baseline at y=0, rendering each line to the left of origin.
    AlignCentre; // Text drawn starting with first baseline at y=0, rendering each line centered on x=0.

    // Justified varients of the above. Each line has spacing artificially scaled up so that every line covers
    // the same horizontal space.
    AlignLeftJustified;
    AlignRightJustified;
    AlignCentreJustified;
}