Package org.lwjgl.stb

Class STBTruetype


  • public class STBTruetype
extends java.lang.Object
    Native bindings to stb_truetype.h from the stb library.

    This library processes TrueType files:

    • parse files
    • extract glyph metrics
    • extract glyph shapes
    • render glyphs to one-channel bitmaps with antialiasing (box filter)

    ADDITIONAL DOCUMENTATION

    Some important concepts to understand to use this library:

    Codepoint

    Characters are defined by unicode codepoints, e.g. 65 is uppercase A, 231 is lowercase c with a cedilla, 0x7e30 is the hiragana for "ma".

    Glyph

    A visual character shape (every codepoint is rendered as some glyph)

    Glyph index

    A font-specific integer ID representing a glyph

    Baseline

    Glyph shapes are defined relative to a baseline, which is the bottom of uppercase characters. Characters extend both above and below the baseline.

    Current Point

    As you draw text to the screen, you keep track of a "current point" which is the origin of each character. The current point's vertical position is the baseline. Even "baked fonts" use this model.

    Vertical Font Metrics

    The vertical qualities of the font, used to vertically position and space the characters. See docs for GetFontVMetrics.

    Font Size in Pixels or Points

    The preferred interface for specifying font sizes in stb_truetype is to specify how tall the font's vertical extent should be in pixels. If that sounds good enough, skip the next paragraph.

    Most font APIs instead use "points", which are a common typographic measurement for describing font size, defined as 72 points per inch. stb_truetype provides a point API for compatibility. However, true "per inch" conventions don't make much sense on computer displays since different monitors have different number of pixels per inch. For example, Windows traditionally uses a convention that there are 96 pixels per inch, thus making 'inch' measurements have nothing to do with inches, and thus effectively defining a point to be 1.333 pixels. Additionally, the TrueType font data provides an explicit scale factor to scale a given font's glyphs to points, but the author has observed that this scale factor is often wrong for non-commercial fonts, thus making fonts scaled in points according to the TrueType spec incoherently sized in practice.

    ADVANCED USAGE

    Quality:

    • Use the functions with Subpixel at the end to allow your characters to have subpixel positioning. Since the font is anti-aliased, not hinted, this is very important for quality. (This is not possible with baked fonts.)
    • Kerning is now supported, and if you're supporting subpixel rendering then kerning is worth using to give your text a polished look.

    Performance:

    • Convert Unicode codepoints to glyph indexes and operate on the glyphs; if you don't do this, stb_truetype is forced to do the conversion on every call.
    • There are a lot of memory allocations. We should modify it to take a temp buffer and allocate from the temp buffer (without freeing), should help performance a lot.

    NOTES

    The system uses the raw data found in the .ttf file without changing it and without building auxiliary data structures. This is a bit inefficient on little-endian systems (the data is big-endian), but assuming you're caching the bitmaps or glyph shapes this shouldn't be a big deal.

    It appears to be very hard to programmatically determine what font a given file is in a general way. I provide an API for this, but I don't recommend it.

    SAMPLE PROGRAMS

    Incomplete text-in-3d-api example, which draws quads properly aligned to be lossless:

    unsigned char ttf_buffer[1<<20];
unsigned char temp_bitmap[512*512];

stbtt_bakedchar cdata[96]; // ASCII 32..126 is 95 glyphs
GLuint ftex;

void my_stbtt_initfont(void)
{
   fread(ttf_buffer, 1, 1<<20, fopen("c:/windows/fonts/times.ttf", "rb"));
   stbtt_BakeFontBitmap(ttf_buffer,0, 32.0, temp_bitmap,512,512, 32,96, cdata); // no guarantee this fits!
   // can free ttf_buffer at this point
   glGenTextures(1, &ftex);
   glBindTexture(GL_TEXTURE_2D, ftex);
   glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, 512,512, 0, GL_ALPHA, GL_UNSIGNED_BYTE, temp_bitmap);
   // can free temp_bitmap at this point
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
}

void my_stbtt_print(float x, float y, char *text)
{
   // assume orthographic projection with units = screen pixels, origin at top left
   glEnable(GL_TEXTURE_2D);
   glBindTexture(GL_TEXTURE_2D, ftex);
   glBegin(GL_QUADS);
   while (*text) {
      if (*text >= 32 && *text < 128) {
         stbtt_aligned_quad q;
         stbtt_GetBakedQuad(cdata, 512,512, *text-32, &x,&y,&q,1);//1=opengl & d3d10+,0=d3d9
         glTexCoord2f(q.s0,q.t1); glVertex2f(q.x0,q.y0);
         glTexCoord2f(q.s1,q.t1); glVertex2f(q.x1,q.y0);
         glTexCoord2f(q.s1,q.t0); glVertex2f(q.x1,q.y1);
         glTexCoord2f(q.s0,q.t0); glVertex2f(q.x0,q.y1);
      }
      ++text;
   }
   glEnd();
}

    Complete program (this compiles): get a single bitmap, print as ASCII art:

    char ttf_buffer[1<<25];

int main(int argc, char **argv)
{
   stbtt_fontinfo font;
   unsigned char *bitmap;
   int w,h,i,j,c = (argc > 1 ? atoi(argv[1]) : 'a'), s = (argc > 2 ? atoi(argv[2]) : 20);

   fread(ttf_buffer, 1, 1<<25, fopen(argc > 3 ? argv[3] : "c:/windows/fonts/arialbd.ttf", "rb"));

   stbtt_InitFont(&font, ttf_buffer, stbtt_GetFontOffsetForIndex(ttf_buffer,0));
   bitmap = stbtt_GetCodepointBitmap(&font, 0,stbtt_ScaleForPixelHeight(&font, s), c, &w, &h, 0,0);

   for (j=0; j < h; ++j) {
      for (i=0; i < w; ++i)
         putchar(" .:ioVM@"[bitmap[j*w+i]>>5]);
      putchar('\n');
   }
   return 0;
}

    Complete program: print "Hello World!" banner, with bugs:

    char buffer[24<<20];
unsigned char screen[20][79];

int main(int arg, char **argv)
{
   stbtt_fontinfo font;
   int i,j,ascent,baseline,ch=0;
   float scale, xpos=2; // leave a little padding in case the character extends left
   char *text = "Heljo World!";

   fread(buffer, 1, 1000000, fopen("c:/windows/fonts/arialbd.ttf", "rb"));
   stbtt_InitFont(&font, buffer, 0);

   scale = stbtt_ScaleForPixelHeight(&font, 15);
   stbtt_GetFontVMetrics(&font, &ascent,0,0);
   baseline = (int) (ascent*scale);

   while (text[ch]) {
      int advance,lsb,x0,y0,x1,y1;
      float x_shift = xpos - (float) floor(xpos);
      stbtt_GetCodepointHMetrics(&font, text[ch], &advance, &lsb);
      stbtt_GetCodepointBitmapBoxSubpixel(&font, text[ch], scale,scale,x_shift,0, &x0,&y0,&x1,&y1);
      stbtt_MakeCodepointBitmapSubpixel(&font, &screen[baseline + y0][(int) xpos + x0], x1-x0,y1-y0, 79, scale,scale,x_shift,0, text[ch]);
      // note that this stomps the old data, so where character boxes overlap (e.g. 'lj') it's wrong
      // because this API is really for baking character bitmaps into textures. if you want to render
      // a sequence of characters, you really need to render each bitmap to a temp buffer, then
      // "alpha blend" that into the working buffer
      xpos += (advance * scale);
      if (text[ch+1])
         xpos += scale*stbtt_GetCodepointKernAdvance(&font, text[ch],text[ch+1]);
      ++ch;
   }

   for (j=0; j < 20; ++j) {
      for (i=0; i < 78; ++i)
         putchar(" .:ioVM@"[screen[j][i]>>5]);
      putchar('\n');
   }

   return 0;
}

    Finding the right font...

    You should really just solve this offline, keep your own tables of what font is what, and don't try to get it out of the .ttf file. That's because getting it out of the .ttf file is really hard, because the names in the file can appear in many possible encodings, in many possible languages, and e.g. if you need a case-insensitive comparison, the details of that depend on the encoding & language in a complex way (actually underspecified in truetype, but also gigantic).

    But you can use the provided functions in two possible ways:

    • FindMatchingFont will use *case-sensitive* comparisons on unicode-encoded names to try to find the font you want; you can run this before calling InitFont
    • GetFontNameString lets you get any of the various strings from the file yourself and do your own comparisons on them. You have to have called InitFont first.

    • Method Detail

      • stbtt_BakeFontBitmap

        public static int stbtt_BakeFontBitmap(java.nio.ByteBuffer data,
                                       float pixel_height,
                                       java.nio.ByteBuffer pixels,
                                       int pw,
                                       int ph,
                                       int first_char,
                                       STBTTBakedChar.Buffer chardata)
        Bakes a font to a bitmap for use as texture.

        This uses a very simply packing, use with GetBakedQuad.

        Parameters:
        data - the font data
        pixel_height - the font height, in pixels
        pixels - a buffer in which to write the font bitmap
        pw - the bitmap width, in pixels
        ph - the bitmap height, in pixels
        first_char - the first character to bake
        chardata - an array of STBTTBakedChar structs, it's num_chars long
        Returns:
        if positive, the first unused row of the bitmap. If negative, returns the negative of the number of characters that fit. If 0, no characters fit and no rows were used.

      • stbtt_GetBakedQuad

        public static void stbtt_GetBakedQuad(STBTTBakedChar.Buffer chardata,
                                      int pw,
                                      int ph,
                                      int char_index,
                                      java.nio.FloatBuffer xpos,
                                      java.nio.FloatBuffer ypos,
                                      STBTTAlignedQuad q,
                                      boolean opengl_fillrule)
        Computes quad to draw for a given char and advances the current position.

        The coordinate system used assumes y increases downwards. Characters will extend both above and below the current position; see discussion of "BASELINE" above.

        Parameters:
        chardata - an array of STBTTBakedChar structs
        pw - the bitmap width, in pixels
        ph - the bitmap height, in pixels
        char_index - the character index in the chardata array
        xpos - the current x position, in screen pixel space
        ypos - the current y position, in screen pixel space
        q - an STBTTAlignedQuad struct in which to return the quad to draw
        opengl_fillrule - 1 if opengl fill rule; 0 if DX9 or earlier

      • stbtt_PackBegin

        public static boolean stbtt_PackBegin(STBTTPackContext spc,
                                      java.nio.ByteBuffer pixels,
                                      int width,
                                      int height,
                                      int stride_in_bytes,
                                      int padding,
                                      long alloc_context)
        Initializes a packing context stored in the passed-in stbtt_pack_context. Future calls using this context will pack characters into the bitmap passed in here: a 1-channel bitmap that is width x height.
        Parameters:
        spc - an STBTTPackContext struct
        pixels - a buffer in which to store the bitmap data
        width - the bitmap width, in pixels
        height - the bitmap height, in pixels
        stride_in_bytes - the distance from one row to the next (or 0 to mean they are packed tightly together)
        padding - the amount of padding to leave between each character (normally you want '1' for bitmaps you'll use as textures with bilinear filtering)
        alloc_context - a pointer to an allocation context
        Returns:
        1 on success, 0 on failure

      • stbtt_PackBegin

        public static boolean stbtt_PackBegin(STBTTPackContext spc,
                                      java.nio.ByteBuffer pixels,
                                      int width,
                                      int height,
                                      int stride_in_bytes,
                                      int padding)
        Initializes a packing context stored in the passed-in stbtt_pack_context. Future calls using this context will pack characters into the bitmap passed in here: a 1-channel bitmap that is width x height.
        Parameters:
        spc - an STBTTPackContext struct
        pixels - a buffer in which to store the bitmap data
        width - the bitmap width, in pixels
        height - the bitmap height, in pixels
        stride_in_bytes - the distance from one row to the next (or 0 to mean they are packed tightly together)
        padding - the amount of padding to leave between each character (normally you want '1' for bitmaps you'll use as textures with bilinear filtering)
        Returns:
        1 on success, 0 on failure

      • stbtt_PackEnd

        public static void stbtt_PackEnd(STBTTPackContext spc)
        Cleans up the packing context and frees all memory.
        Parameters:
        spc - an STBTTPackContext struct

      • STBTT_POINT_SIZE

        public static int STBTT_POINT_SIZE(int font_size)
        Converts the full height of a character from ascender to descender, as computed by ScaleForPixelHeight, to a point size as computed by ScaleForMappingEmToPixels.
        Parameters:
        font_size - the full height of a character
        Returns:
        the point size of the character

      • stbtt_PackFontRange

        public static boolean stbtt_PackFontRange(STBTTPackContext spc,
                                          java.nio.ByteBuffer fontdata,
                                          int font_index,
                                          float font_size,
                                          int first_unicode_char_in_range,
                                          STBTTPackedchar.Buffer chardata_for_range)
        Creates character bitmaps from the font_index'th font found in fontdata (use font_index=0 if you don't know what that is). It creates num_chars_in_range bitmaps for characters with unicode values starting at first_unicode_char_in_range and increasing. Data for how to render them is stored in chardata_for_range; pass these to GetPackedQuad to get back renderable quads.
        Parameters:
        spc - an STBTTPackContext struct
        fontdata - the font data
        font_index - the font index (use 0 if you don't know what that is
        font_size - the full height of the character from ascender to descender, as computed by ScaleForPixelHeight. To use a point size as computed by ScaleForMappingEmToPixels, wrap the font size in STBTruetype.STBTT_POINT_SIZE(int) and pass the result, i.e.: 
        ...,                  20 , ... // font max minus min y is 20 pixels tall
..., STBTT_POINT_SIZE(20), ... // 'M' is 20 pixels tall
        first_unicode_char_in_range - the first unicode code point in the range
        chardata_for_range - an array of STBTTPackedchar structs
        Returns:
        1 on success, 0 on failure

      • stbtt_PackFontRanges

        public static boolean stbtt_PackFontRanges(STBTTPackContext spc,
                                           java.nio.ByteBuffer fontdata,
                                           int font_index,
                                           STBTTPackRange.Buffer ranges)
        Creates character bitmaps from multiple ranges of characters stored in ranges. This will usually create a better-packed bitmap than multiple calls to PackFontRange. Note that you can call this multiple times within a single PackBegin/PackEnd.
        Parameters:
        spc - an STBTTPackContext struct
        fontdata - the font data
        font_index - the font index (use 0 if you don't know what that is
        ranges - an array of STBTTPackRange structs
        Returns:
        1 on success, 0 on failure

      • stbtt_PackSetOversampling

        public static void stbtt_PackSetOversampling(STBTTPackContext spc,
                                             int h_oversample,
                                             int v_oversample)
        Oversampling a font increases the quality by allowing higher-quality subpixel positioning, and is especially valuable at smaller text sizes.

        This function sets the amount of oversampling for all following calls to PackFontRange or PackFontRangesGatherRects for a given pack context. The default (no oversampling) is achieved by h_oversample=1, v_oversample=1. The total number of pixels required is h_oversample*v_oversample larger than the default; for example, 2x2 oversampling requires 4x the storage of 1x1. For best results, render oversampled textures with bilinear filtering. Look at the readme in stb/tests/oversample for information about oversampled fonts.

        To use with PackFontRangesGather etc., you must set it before calls to PackFontRangesGatherRects.

        Parameters:
        spc - an STBTTPackContext struct
        h_oversample - the horizontal oversampling amount
        v_oversample - the vertical oversampling amount

      • stbtt_GetPackedQuad

        public static void stbtt_GetPackedQuad(STBTTPackedchar.Buffer chardata,
                                       int pw,
                                       int ph,
                                       int char_index,
                                       java.nio.FloatBuffer xpos,
                                       java.nio.FloatBuffer ypos,
                                       STBTTAlignedQuad q,
                                       boolean align_to_integer)
        Computes quad to draw for a given char and advances the current position.

        The coordinate system used assumes y increases downwards. Characters will extend both above and below the current position; see discussion of "BASELINE" above.

        Parameters:
        chardata - an array of STBTTPackedchar structs
        pw - the bitmap width, in pixels
        ph - the bitmap height, in pixels
        char_index - the character index in the chardata array
        xpos - the current x position, in screen pixel space
        ypos - the current y position, in screen pixel space
        q - an STBTTAlignedQuad struct in which to return the quad to draw
        align_to_integer - 1 to align the quad to integer coordinates

      • stbtt_GetFontOffsetForIndex

        public static int stbtt_GetFontOffsetForIndex(java.nio.ByteBuffer data,
                                              int index)
        Each .ttf/.ttc file may have more than one font. Each font has a sequential index number starting from 0. Call this function to get the font offset for a given index; it returns -1 if the index is out of range. A regular .ttf file will only define one font and it always be at offset 0, so it will return '0' for index 0, and -1 for all other indices. You can just skip this step if you know it's that kind of font.
        Parameters:
        data - the font data
        index - the font index

      • stbtt_InitFont

        public static boolean stbtt_InitFont(STBTTFontinfo info,
                                     java.nio.ByteBuffer data,
                                     int offset)
        Given an offset into the file that defines a font, this function builds the necessary cached info for the rest of the system. You must allocate the STBTTFontinfo yourself, and stbtt_InitFont will fill it out. You don't need to do anything special to free it, because the contents are pure value data with no additional data structures.
        Parameters:
        info - an STBTTFontinfo struct
        data - the font data
        offset - the font data offset
        Returns:
        1 on success, 0 on failure

      • stbtt_InitFont

        public static boolean stbtt_InitFont(STBTTFontinfo info,
                                     java.nio.ByteBuffer data)
        Given an offset into the file that defines a font, this function builds the necessary cached info for the rest of the system. You must allocate the STBTTFontinfo yourself, and stbtt_InitFont will fill it out. You don't need to do anything special to free it, because the contents are pure value data with no additional data structures.
        Parameters:
        info - an STBTTFontinfo struct
        data - the font data
        Returns:
        1 on success, 0 on failure

      • stbtt_FindGlyphIndex

        public static int stbtt_FindGlyphIndex(STBTTFontinfo info,
                                       int unicode_codepoint)
        If you're going to perform multiple operations on the same character and you want a speed-up, call this function with the character you're going to process, then use glyph-based functions instead of the codepoint-based functions.
        Parameters:
        info - an STBTTFontinfo struct
        unicode_codepoint - the unicode code point
        Returns:
        the glyph index

      • stbtt_ScaleForPixelHeight

        public static float stbtt_ScaleForPixelHeight(STBTTFontinfo info,
                                              float pixels)
        Computes a scale factor to produce a font whose "height" is pixels tall. Height is measured as the distance from the highest ascender to the lowest descender; in other words, it's equivalent to calling GetFontVMetrics and computing: 
        scale = pixels / (ascent - descent)

        so if you prefer to measure height by the ascent only, use a similar calculation.

        Parameters:
        info - an STBTTFontinfo struct
        pixels - the font height, in pixels
        Returns:
        the scale factor

      • stbtt_ScaleForMappingEmToPixels

        public static float stbtt_ScaleForMappingEmToPixels(STBTTFontinfo info,
                                                    float pixels)
        Computes a scale factor to produce a font whose EM size is mapped to pixels tall. This is probably what traditional APIs compute, but I'm not positive.
        Parameters:
        info - an STBTTFontinfo struct
        pixels - the font height, in pixels
        Returns:
        the scale factor

      • stbtt_GetFontVMetrics

        public static void stbtt_GetFontVMetrics(STBTTFontinfo info,
                                         java.nio.IntBuffer ascent,
                                         java.nio.IntBuffer descent,
                                         java.nio.IntBuffer lineGap)
        Returns vertical metrics for the specified font. You should advance the vertical position by *ascent - *descent + *lineGap

        The returned values are expressed in unscaled coordinates, so you must multiply by the scale factor for a given size.

        Parameters:
        info - an STBTTFontinfo struct
        ascent - returns the coordinate above the baseline the font extends
        descent - returns the coordinate below the baseline the font extends (i.e. it is typically negative)
        lineGap - returns the spacing between one row's descent and the next row's ascent

      • stbtt_GetFontBoundingBox

        public static void stbtt_GetFontBoundingBox(STBTTFontinfo info,
                                            java.nio.IntBuffer x0,
                                            java.nio.IntBuffer y0,
                                            java.nio.IntBuffer x1,
                                            java.nio.IntBuffer y1)
        Returns the bounding box around all possible characters.
        Parameters:
        info - an STBTTFontinfo struct
        x0 - the left coordinate
        y0 - the bottom coordinate
        x1 - the right coordinate
        y1 - the top coordinate

      • stbtt_GetCodepointHMetrics

        public static void stbtt_GetCodepointHMetrics(STBTTFontinfo info,
                                              int codepoint,
                                              java.nio.IntBuffer advanceWidth,
                                              java.nio.IntBuffer leftSideBearing)
        Returns horizontal metrics for the specified codepoint.

        The returned values are expressed in unscaled coordinates.

        Parameters:
        info - an STBTTFontinfo struct
        codepoint - the unicode codepoint
        advanceWidth - the offset from the current horizontal position to the next horizontal position
        leftSideBearing - the offset from the current horizontal position to the left edge of the character

      • stbtt_GetCodepointKernAdvance

        public static int stbtt_GetCodepointKernAdvance(STBTTFontinfo info,
                                                int ch1,
                                                int ch2)
        Returns the additional amount to add to the advance value between ch1 and ch2.
        Parameters:
        info - an STBTTFontinfo struct
        ch1 - the first unicode codepoint
        ch2 - the second unicode codepoint

      • stbtt_GetCodepointBox

        public static boolean stbtt_GetCodepointBox(STBTTFontinfo info,
                                            int codepoint,
                                            java.nio.IntBuffer x0,
                                            java.nio.IntBuffer y0,
                                            java.nio.IntBuffer x1,
                                            java.nio.IntBuffer y1)
        Gets the bounding box of the visible part of the glyph, in unscaled coordinates.
        Parameters:
        info - an STBTTFontinfo struct
        codepoint - the unicode codepoint
        x0 - returns the left coordinate
        y0 - returns the bottom coordinate
        x1 - returns the right coordinate
        y1 - returns the top coordinate

      • stbtt_GetGlyphHMetrics

        public static void stbtt_GetGlyphHMetrics(STBTTFontinfo info,
                                          int glyph_index,
                                          java.nio.IntBuffer advanceWidth,
                                          java.nio.IntBuffer leftSideBearing)
        Glyph version of GetCodepointHMetrics, for greater efficiency.
        Parameters:
        info - an STBTTFontinfo struct
        glyph_index - the glyph index
        advanceWidth - the offset from the current horizontal position to the next horizontal position
        leftSideBearing - the offset from the current horizontal position to the left edge of the character

      • stbtt_GetGlyphKernAdvance

        public static int stbtt_GetGlyphKernAdvance(STBTTFontinfo info,
                                            int glyph1,
                                            int glyph2)
        Glyph version of GetCodepointKernAdvance, for greater efficiency.
        Parameters:
        info - an STBTTFontinfo struct
        glyph1 - the first glyph index
        glyph2 - the second glyph index

      • stbtt_GetGlyphBox

        public static boolean stbtt_GetGlyphBox(STBTTFontinfo info,
                                        int glyph_index,
                                        java.nio.IntBuffer x0,
                                        java.nio.IntBuffer y0,
                                        java.nio.IntBuffer x1,
                                        java.nio.IntBuffer y1)
        Glyph version of GetCodepointBox, for greater efficiency.
        Parameters:
        info - an STBTTFontinfo struct
        glyph_index - the glyph index
        x0 - returns the left coordinate
        y0 - returns the bottom coordinate
        x1 - returns the right coordinate
        y1 - returns the top coordinate

      • stbtt_IsGlyphEmpty

        public static boolean stbtt_IsGlyphEmpty(STBTTFontinfo info,
                                         int glyph_index)
        Returns non-zero if nothing is drawn for this glyph.
        Parameters:
        info - an STBTTFontinfo struct
        glyph_index - the glyph index

      • stbtt_GetCodepointShape

        public static int stbtt_GetCodepointShape(STBTTFontinfo info,
                                          int unicode_codepoint,
                                          org.lwjgl.PointerBuffer vertices)
        Returns number of vertices and fills *vertices with the pointer to them

        The shape is a series of countours. Each one starts with a vmove, then consists of a series of mixed vline and vcurve segments. A vline draws a line from previous endpoint to its x,y; a vcurve draws a quadratic bezier from previous endpoint to its x,y, using cx,cy as the bezier control point.

        The STBTTVertex values are expressed in "unscaled" coordinates.

        Parameters:
        info - an STBTTFontinfo struct
        unicode_codepoint - the unicode codepoint
        vertices - returns a pointer to an array of STBTTVertex structs

      • stbtt_GetCodepointShape

        public static STBTTVertex.Buffer stbtt_GetCodepointShape(STBTTFontinfo info,
                                                         int unicode_codepoint)
        Returns number of vertices and fills *vertices with the pointer to them

        The shape is a series of countours. Each one starts with a vmove, then consists of a series of mixed vline and vcurve segments. A vline draws a line from previous endpoint to its x,y; a vcurve draws a quadratic bezier from previous endpoint to its x,y, using cx,cy as the bezier control point.

        The STBTTVertex values are expressed in "unscaled" coordinates.

        Parameters:
        info - an STBTTFontinfo struct
        unicode_codepoint - the unicode codepoint

      • stbtt_GetGlyphShape

        public static int stbtt_GetGlyphShape(STBTTFontinfo info,
                                      int glyph_index,
                                      org.lwjgl.PointerBuffer vertices)
        Glyph version of GetCodepointShape, for greater efficiency.
        Parameters:
        info - an STBTTFontinfo struct
        glyph_index - the unicode codepoint
        vertices - returns a pointer to an array of STBTTVertex structs

      • stbtt_GetCodepointBitmap

        public static java.nio.ByteBuffer stbtt_GetCodepointBitmap(STBTTFontinfo info,
                                                           float scale_x,
                                                           float scale_y,
                                                           int codepoint,
                                                           java.nio.IntBuffer width,
                                                           java.nio.IntBuffer height,
                                                           java.nio.IntBuffer xoff,
                                                           java.nio.IntBuffer yoff)
        Allocates a large-enough single-channel 8bpp bitmap and renders the specified character/glyph at the specified scale into it, with antialiasing.
        Parameters:
        info - an STBTTFontinfo struct
        scale_x - the horizontal scale
        scale_y - the vertical scale
        codepoint - the unicode codepoint to render
        width - returns the bitmap width
        height - returns the bitmap height
        xoff - returns the horizontal offset in pixel space from the glyph origin to the left of the bitmap
        yoff - returns the vertical offset in pixel space from the glyph origin to the top of the bitmap

      • stbtt_GetCodepointBitmapSubpixel

        public static java.nio.ByteBuffer stbtt_GetCodepointBitmapSubpixel(STBTTFontinfo info,
                                                                   float scale_x,
                                                                   float scale_y,
                                                                   float shift_x,
                                                                   float shift_y,
                                                                   int codepoint,
                                                                   java.nio.IntBuffer width,
                                                                   java.nio.IntBuffer height,
                                                                   java.nio.IntBuffer xoff,
                                                                   java.nio.IntBuffer yoff)
        Same as GetCodepointBitmap, but you can specify a subpixel shift for the character.
        Parameters:
        info - an STBTTFontinfo struct
        scale_x - the horizontal scale
        scale_y - the vertical scale
        shift_x - the horizontal subpixel shift
        shift_y - the vertical subpixel shift
        codepoint - the unicode codepoint to render
        width - returns the bitmap width
        height - returns the bitmap height
        xoff - returns the horizontal offset in pixel space from the glyph origin to the left of the bitmap
        yoff - returns the vertical offset in pixel space from the glyph origin to the top of the bitmap

      • stbtt_MakeCodepointBitmap

        public static void stbtt_MakeCodepointBitmap(STBTTFontinfo info,
                                             java.nio.ByteBuffer output,
                                             int out_w,
                                             int out_h,
                                             int out_stride,
                                             float scale_x,
                                             float scale_y,
                                             int codepoint)
        Same as GetCodepointBitmap, but you pass in storage for the bitmap in the form of output, with row spacing of out_stride bytes. The bitmap is clipped to out_w/out_h bytes. Call GetCodepointBitmapBox to get the width and height and positioning info for it first.
        Parameters:
        info - an STBTTFontinfo struct
        output - the bitmap storage
        out_w - the bitmap width
        out_h - the bitmap height
        out_stride - the row stride, in bytes
        scale_x - the horizontal scale
        scale_y - the vertical scale
        codepoint - the unicode codepoint to render

      • stbtt_MakeCodepointBitmapSubpixel

        public static void stbtt_MakeCodepointBitmapSubpixel(STBTTFontinfo info,
                                                     java.nio.ByteBuffer output,
                                                     int out_w,
                                                     int out_h,
                                                     int out_stride,
                                                     float scale_x,
                                                     float scale_y,
                                                     float shift_x,
                                                     float shift_y,
                                                     int codepoint)
        Same as MakeCodepointBitmap, but you can specify a subpixel shift for the character.
        Parameters:
        info - an STBTTFontinfo struct
        output - the bitmap storage
        out_w - the bitmap width
        out_h - the bitmap height
        out_stride - the row stride, in bytes
        scale_x - the horizontal scale
        scale_y - the vertical scale
        shift_x - the horizontal subpixel shift
        shift_y - the vertical subpixel shift
        codepoint - the unicode codepoint to render

      • stbtt_GetCodepointBitmapBox

        public static void stbtt_GetCodepointBitmapBox(STBTTFontinfo font,
                                               int codepoint,
                                               float scale_x,
                                               float scale_y,
                                               java.nio.IntBuffer ix0,
                                               java.nio.IntBuffer iy0,
                                               java.nio.IntBuffer ix1,
                                               java.nio.IntBuffer iy1)
        Get the bbox of the bitmap centered around the glyph origin; so the bitmap width is ix1-ix0, height is iy1-iy0, and location to place the bitmap top left is (leftSideBearing*scale,iy0).

        Note that the bitmap uses y-increases-down, but the shape uses y-increases-up, so CodepointBitmapBox and CodepointBox are inverted.

        Parameters:
        font - an STBTTFontinfo struct
        codepoint - the unicode codepoint
        scale_x - the horizontal scale
        scale_y - the vertical scale
        ix0 - returns the left coordinate
        iy0 - returns the bottom coordinate
        ix1 - returns the right coordinate
        iy1 - returns the top coordinate

      • stbtt_GetCodepointBitmapBoxSubpixel

        public static void stbtt_GetCodepointBitmapBoxSubpixel(STBTTFontinfo font,
                                                       int codepoint,
                                                       float scale_x,
                                                       float scale_y,
                                                       float shift_x,
                                                       float shift_y,
                                                       java.nio.IntBuffer ix0,
                                                       java.nio.IntBuffer iy0,
                                                       java.nio.IntBuffer ix1,
                                                       java.nio.IntBuffer iy1)
        Same as GetCodepointBitmapBox, but you can specify a subpixel shift for the character.
        Parameters:
        font - an STBTTFontinfo struct
        codepoint - the unicode codepoint
        scale_x - the horizontal scale
        scale_y - the vertical scale
        shift_x - the horizontal subpixel shift
        shift_y - the vertical subpixel shift
        ix0 - returns the left coordinate
        iy0 - returns the bottom coordinate
        ix1 - returns the right coordinate
        iy1 - returns the top coordinate

      • stbtt_GetGlyphBitmap

        public static java.nio.ByteBuffer stbtt_GetGlyphBitmap(STBTTFontinfo info,
                                                       float scale_x,
                                                       float scale_y,
                                                       int glyph,
                                                       java.nio.IntBuffer width,
                                                       java.nio.IntBuffer height,
                                                       java.nio.IntBuffer xoff,
                                                       java.nio.IntBuffer yoff)
        Allocates a large-enough single-channel 8bpp bitmap and renders the specified character/glyph at the specified scale into it, with antialiasing.
        Parameters:
        info - an STBTTFontinfo struct
        scale_x - the horizontal scale
        scale_y - the vertical scale
        glyph - the glyph index to render
        width - returns the bitmap width
        height - returns the bitmap height
        xoff - returns the horizontal offset in pixel space from the glyph origin to the left of the bitmap
        yoff - returns the vertical offset in pixel space from the glyph origin to the top of the bitmap

      • stbtt_GetGlyphBitmapSubpixel

        public static java.nio.ByteBuffer stbtt_GetGlyphBitmapSubpixel(STBTTFontinfo info,
                                                               float scale_x,
                                                               float scale_y,
                                                               float shift_x,
                                                               float shift_y,
                                                               int glyph,
                                                               java.nio.IntBuffer width,
                                                               java.nio.IntBuffer height,
                                                               java.nio.IntBuffer xoff,
                                                               java.nio.IntBuffer yoff)
        Same as GetGlyphBitmap, but you can specify a subpixel shift for the character.
        Parameters:
        info - an STBTTFontinfo struct
        scale_x - the horizontal scale
        scale_y - the vertical scale
        shift_x - the horizontal subpixel shift
        shift_y - the vertical subpixel shift
        glyph - the glyph index to render
        width - returns the bitmap width
        height - returns the bitmap height
        xoff - returns the horizontal offset in pixel space from the glyph origin to the left of the bitmap
        yoff - returns the vertical offset in pixel space from the glyph origin to the top of the bitmap

      • stbtt_MakeGlyphBitmap

        public static void stbtt_MakeGlyphBitmap(STBTTFontinfo info,
                                         java.nio.ByteBuffer output,
                                         int out_w,
                                         int out_h,
                                         int out_stride,
                                         float scale_x,
                                         float scale_y,
                                         int glyph)
        Same as GetGlyphBitmap, but you pass in storage for the bitmap in the form of output, with row spacing of out_stride bytes. The bitmap is clipped to out_w/out_h bytes. Call GetGlyphBitmapBox to get the width and height and positioning info for it first.
        Parameters:
        info - an STBTTFontinfo struct
        output - the bitmap storage
        out_w - the bitmap width
        out_h - the bitmap height
        out_stride - the row stride, in bytes
        scale_x - the horizontal scale
        scale_y - the vertical scale
        glyph - the glyph index to render

      • stbtt_MakeGlyphBitmapSubpixel

        public static void stbtt_MakeGlyphBitmapSubpixel(STBTTFontinfo info,
                                                 java.nio.ByteBuffer output,
                                                 int out_w,
                                                 int out_h,
                                                 int out_stride,
                                                 float scale_x,
                                                 float scale_y,
                                                 float shift_x,
                                                 float shift_y,
                                                 int glyph)
        Same as MakeGlyphBitmap, but you can specify a subpixel shift for the character.
        Parameters:
        info - an STBTTFontinfo struct
        output - the bitmap storage
        out_w - the bitmap width
        out_h - the bitmap height
        out_stride - the row stride, in bytes
        scale_x - the horizontal scale
        scale_y - the vertical scale
        shift_x - the horizontal subpixel shift
        shift_y - the vertical subpixel shift
        glyph - the glyph index to render

      • stbtt_GetGlyphBitmapBox

        public static void stbtt_GetGlyphBitmapBox(STBTTFontinfo font,
                                           int glyph,
                                           float scale_x,
                                           float scale_y,
                                           java.nio.IntBuffer ix0,
                                           java.nio.IntBuffer iy0,
                                           java.nio.IntBuffer ix1,
                                           java.nio.IntBuffer iy1)
        Get the bbox of the bitmap centered around the glyph origin; so the bitmap width is ix1-ix0, height is iy1-iy0, and location to place the bitmap top left is (leftSideBearing*scale,iy0).

        Note that the bitmap uses y-increases-down, but the shape uses y-increases-up, so GlyphBitmapBox and GlyphBox are inverted.

        Parameters:
        font - an STBTTFontinfo struct
        glyph - the glyph index
        scale_x - the horizontal scale
        scale_y - the vertical scale
        ix0 - returns the left coordinate
        iy0 - returns the bottom coordinate
        ix1 - returns the right coordinate
        iy1 - returns the top coordinate

      • stbtt_GetGlyphBitmapBoxSubpixel

        public static void stbtt_GetGlyphBitmapBoxSubpixel(STBTTFontinfo font,
                                                   int glyph,
                                                   float scale_x,
                                                   float scale_y,
                                                   float shift_x,
                                                   float shift_y,
                                                   java.nio.IntBuffer ix0,
                                                   java.nio.IntBuffer iy0,
                                                   java.nio.IntBuffer ix1,
                                                   java.nio.IntBuffer iy1)
        Same as GetGlyphBitmapBox, but you can specify a subpixel shift for the character.
        Parameters:
        font - an STBTTFontinfo struct
        glyph - the glyph index
        scale_x - the horizontal scale
        scale_y - the vertical scale
        shift_x - the horizontal subpixel shift
        shift_y - the vertical subpixel shift
        ix0 - returns the left coordinate
        iy0 - returns the bottom coordinate
        ix1 - returns the right coordinate
        iy1 - returns the top coordinate

      • stbtt_FindMatchingFont

        public static int stbtt_FindMatchingFont(java.nio.ByteBuffer fontdata,
                                         java.nio.ByteBuffer name,
                                         int flags)

public static int stbtt_FindMatchingFont(java.nio.ByteBuffer fontdata,
                                         java.lang.CharSequence name,
                                         int flags)
        Returns the offset (not index) of the font that matches, or -1 if none.

        If you use STBTT_MACSTYLE_DONTCARE, use a font name like "Arial Bold". If you use any other flag, use a font name like "Arial"; this checks the macStyle header field; I don't know if fonts set this consistently.

        Parameters:
        fontdata - the font data
        name - the font name
        flags - the style flags. One of:
        MACSTYLE_DONTCAREMACSTYLE_BOLDMACSTYLE_ITALICMACSTYLE_UNDERSCOREMACSTYLE_NONE

      • stbtt_CompareUTF8toUTF16_bigendian

        public static boolean stbtt_CompareUTF8toUTF16_bigendian(java.nio.ByteBuffer s1,
                                                         java.nio.ByteBuffer s2)
        Returns 1/0 whether the first string interpreted as utf8 is identical to the second string interpreted as big-endian utf16... useful for strings returned from GetFontNameString.
        Parameters:
        s1 - the first string
        s2 - the second string

      • stbtt_GetFontVMetrics

        public static void stbtt_GetFontVMetrics(STBTTFontinfo info,
                                         int[] ascent,
                                         int[] descent,
                                         int[] lineGap)
        Array version of: GetFontVMetrics

      • stbtt_GetFontBoundingBox

        public static void stbtt_GetFontBoundingBox(STBTTFontinfo info,
                                            int[] x0,
                                            int[] y0,
                                            int[] x1,
                                            int[] y1)
        Array version of: GetFontBoundingBox

      • stbtt_GetCodepointHMetrics

        public static void stbtt_GetCodepointHMetrics(STBTTFontinfo info,
                                              int codepoint,
                                              int[] advanceWidth,
                                              int[] leftSideBearing)
        Array version of: GetCodepointHMetrics

      • stbtt_GetCodepointBox

        public static boolean stbtt_GetCodepointBox(STBTTFontinfo info,
                                            int codepoint,
                                            int[] x0,
                                            int[] y0,
                                            int[] x1,
                                            int[] y1)
        Array version of: GetCodepointBox

      • stbtt_GetGlyphHMetrics

        public static void stbtt_GetGlyphHMetrics(STBTTFontinfo info,
                                          int glyph_index,
                                          int[] advanceWidth,
                                          int[] leftSideBearing)
        Array version of: GetGlyphHMetrics

      • stbtt_GetGlyphBox

        public static boolean stbtt_GetGlyphBox(STBTTFontinfo info,
                                        int glyph_index,
                                        int[] x0,
                                        int[] y0,
                                        int[] x1,
                                        int[] y1)
        Array version of: GetGlyphBox

      • stbtt_GetCodepointBitmap

        public static java.nio.ByteBuffer stbtt_GetCodepointBitmap(STBTTFontinfo info,
                                                           float scale_x,
                                                           float scale_y,
                                                           int codepoint,
                                                           int[] width,
                                                           int[] height,
                                                           int[] xoff,
                                                           int[] yoff)
        Array version of: GetCodepointBitmap

      • stbtt_GetCodepointBitmapSubpixel

        public static java.nio.ByteBuffer stbtt_GetCodepointBitmapSubpixel(STBTTFontinfo info,
                                                                   float scale_x,
                                                                   float scale_y,
                                                                   float shift_x,
                                                                   float shift_y,
                                                                   int codepoint,
                                                                   int[] width,
                                                                   int[] height,
                                                                   int[] xoff,
                                                                   int[] yoff)
        Array version of: GetCodepointBitmapSubpixel

      • stbtt_GetCodepointBitmapBox

        public static void stbtt_GetCodepointBitmapBox(STBTTFontinfo font,
                                               int codepoint,
                                               float scale_x,
                                               float scale_y,
                                               int[] ix0,
                                               int[] iy0,
                                               int[] ix1,
                                               int[] iy1)
        Array version of: GetCodepointBitmapBox

      • stbtt_GetCodepointBitmapBoxSubpixel

        public static void stbtt_GetCodepointBitmapBoxSubpixel(STBTTFontinfo font,
                                                       int codepoint,
                                                       float scale_x,
                                                       float scale_y,
                                                       float shift_x,
                                                       float shift_y,
                                                       int[] ix0,
                                                       int[] iy0,
                                                       int[] ix1,
                                                       int[] iy1)
        Array version of: GetCodepointBitmapBoxSubpixel

      • stbtt_GetGlyphBitmap

        public static java.nio.ByteBuffer stbtt_GetGlyphBitmap(STBTTFontinfo info,
                                                       float scale_x,
                                                       float scale_y,
                                                       int glyph,
                                                       int[] width,
                                                       int[] height,
                                                       int[] xoff,
                                                       int[] yoff)
        Array version of: GetGlyphBitmap

      • stbtt_GetGlyphBitmapSubpixel

        public static java.nio.ByteBuffer stbtt_GetGlyphBitmapSubpixel(STBTTFontinfo info,
                                                               float scale_x,
                                                               float scale_y,
                                                               float shift_x,
                                                               float shift_y,
                                                               int glyph,
                                                               int[] width,
                                                               int[] height,
                                                               int[] xoff,
                                                               int[] yoff)
        Array version of: GetGlyphBitmapSubpixel

      • stbtt_GetGlyphBitmapBox

        public static void stbtt_GetGlyphBitmapBox(STBTTFontinfo font,
                                           int glyph,
                                           float scale_x,
                                           float scale_y,
                                           int[] ix0,
                                           int[] iy0,
                                           int[] ix1,
                                           int[] iy1)
        Array version of: GetGlyphBitmapBox

      • stbtt_GetGlyphBitmapBoxSubpixel

        public static void stbtt_GetGlyphBitmapBoxSubpixel(STBTTFontinfo font,
                                                   int glyph,
                                                   float scale_x,
                                                   float scale_y,
                                                   float shift_x,
                                                   float shift_y,
                                                   int[] ix0,
                                                   int[] iy0,
                                                   int[] ix1,
                                                   int[] iy1)
        Array version of: GetGlyphBitmapBoxSubpixel