From cd7c7c555ce20be3fda3014eb9419a8a523c73fa Mon Sep 17 00:00:00 2001 From: Ron Aaron Date: Fri, 7 Feb 2020 09:32:45 +0200 Subject: [PATCH] modded build.py etc to convert comments in external files --- nuklear.h | 8 +- src/build.py | 35 +- src/paq.bat | 2 +- src/paq.sh | 2 +- src/stb_rect_pack.h | 362 +++---- src/stb_truetype.h | 2208 +++++++++++++++++++++---------------------- 6 files changed, 1319 insertions(+), 1298 deletions(-) diff --git a/nuklear.h b/nuklear.h index 3c610bd..d9fe6b5 100644 --- a/nuklear.h +++ b/nuklear.h @@ -11294,7 +11294,7 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. /* stbtt_GetBakedQuad() -- compute quad to draw for a given char */ /* */ /* Improved 3D API (more shippable): */ -/* -- optional, but you really want it */ +/* #include "stb_rect_pack.h" -- optional, but you really want it */ /* stbtt_PackBegin() */ /* stbtt_PackSetOversampling() -- for improved quality on small fonts */ /* stbtt_PackFontRanges() -- pack and renders */ @@ -11465,7 +11465,7 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. /* */ #if 0 #define STB_TRUETYPE_IMPLEMENTATION /* force following include to generate implementation */ - +#include "stb_truetype.h" unsigned char ttf_buffer[1<<20]; unsigned char temp_bitmap[512*512]; @@ -11514,7 +11514,7 @@ void my_stbtt_print(float x, float y, char *text) #if 0 #include #define STB_TRUETYPE_IMPLEMENTATION /* force following include to generate implementation */ - +#include "stb_truetype.h" char ttf_buffer[1<<25]; @@ -15027,7 +15027,7 @@ typedef int stbrp_coord; /* // */ /* // */ /* if you get a compile warning due to these symbols being defined more than // */ -/* once, move before // */ +/* once, move #include "stb_rect_pack.h" before #include "stb_truetype.h" // */ /* // */ /* ////////////////////////////////////////////////////////////////////////////////// */ diff --git a/src/build.py b/src/build.py index aec4e22..e0d6565 100644 --- a/src/build.py +++ b/src/build.py @@ -2,12 +2,15 @@ import fnmatch import os.path import sys +import re def print_help(): print( -"""usage: python single_header_packer.py --macro [--intro ] --pub --priv [--outro ] +"""usage: python single_header_packer.py --macro [--intro ] --extern --pub --priv1 --priv2 [--outro ] where can be a comma-separated list of files. e.g. --priv *.c,inc/*.h + + The 'extern' files are placed between 'priv1' and 'priv2'. The resulting code is packed as follows: @@ -70,6 +73,9 @@ def omit_includes(str, files): str = str.replace("#include <" + fname + ">", ""); return str +def fix_comments(str): + return re.sub(r"//(.*)(\n|$)", "/* \\1 */\\2", str) + # Main start # ========== @@ -79,8 +85,9 @@ if len(sys.argv) < 2: intro_files = [] pub_files = [] -priv_files = [] -outro_files = [] +priv_files1 = [] +outro_files2 = [] +extern_files = [] cur_arg = 1 macro = "" @@ -99,9 +106,15 @@ while cur_arg < len(sys.argv): elif sys.argv[cur_arg] == "--pub": cur_arg += 1 pub_files = parse_files(sys.argv[cur_arg]) - elif sys.argv[cur_arg] == "--priv": + elif sys.argv[cur_arg] == "--priv1": cur_arg += 1 - priv_files = parse_files(sys.argv[cur_arg]) + priv_files1 = parse_files(sys.argv[cur_arg]) + elif sys.argv[cur_arg] == "--priv2": + cur_arg += 1 + priv_files2 = parse_files(sys.argv[cur_arg]) + elif sys.argv[cur_arg] == "--extern": + cur_arg += 1 + extern_files = parse_files(sys.argv[cur_arg]) elif sys.argv[cur_arg] == "--outro": cur_arg += 1 outro_files = parse_files(sys.argv[cur_arg]) @@ -134,9 +147,17 @@ for f in pub_files: print(os.linesep + "#ifdef " + macro + "_IMPLEMENTATION"); print(""); -for f in priv_files: + +for f in priv_files1: print(omit_includes(open(f, 'r').read(), - pub_files + priv_files)) + pub_files + priv_files1 + priv_files2 + extern_files)) +for f in extern_files: + print(fix_comments(open(f, 'r').read())) + +for f in priv_files2: + print(omit_includes(open(f, 'r').read(), + pub_files + priv_files1 + priv_files2 + extern_files)) + print("#endif /* " + macro + "_IMPLEMENTATION */"); print(os.linesep + "/*") diff --git a/src/paq.bat b/src/paq.bat index de8e62e..a8973d8 100644 --- a/src/paq.bat +++ b/src/paq.bat @@ -1 +1 @@ -build.py --macro NK --intro HEADER --pub nuklear.h --priv nuklear_internal.h,nuklear_math.c,nuklear_util.c,nuklear_color.c,nuklear_utf8.c,nuklear_buffer.c,nuklear_string.c,nuklear_draw.c,nuklear_vertex.c,stb_rect_pack.h,stb_truetype.h,nuklear_font.c,nuklear_input.c,nuklear_style.c,nuklear_context.c,nuklear_pool.c,nuklear_page_element.c,nuklear_table.c,nuklear_panel.c,nuklear_window.c,nuklear_popup.c,nuklear_contextual.c,nuklear_menu.c,nuklear_layout.c,nuklear_tree.c,nuklear_group.c,nuklear_list_view.c,nuklear_widget.c,nuklear_text.c,nuklear_image.c,nuklear_button.c,nuklear_toggle.c,nuklear_selectable.c,nuklear_slider.c,nuklear_progress.c,nuklear_scrollbar.c,nuklear_text_editor.c,nuklear_edit.c,nuklear_property.c,nuklear_chart.c,nuklear_color_picker.c,nuklear_combo.c,nuklear_tooltip.c --outro LICENSE,CHANGELOG,CREDITS > ..\nuklear.h +build.py --macro NK --intro HEADER --pub nuklear.h --priv1 nuklear_internal.h,nuklear_math.c,nuklear_util.c,nuklear_color.c,nuklear_utf8.c,nuklear_buffer.c,nuklear_string.c,nuklear_draw.c,nuklear_vertex.c --extern stb_rect_pack.h,stb_truetype.h --priv2 nuklear_font.c,nuklear_input.c,nuklear_style.c,nuklear_context.c,nuklear_pool.c,nuklear_page_element.c,nuklear_table.c,nuklear_panel.c,nuklear_window.c,nuklear_popup.c,nuklear_contextual.c,nuklear_menu.c,nuklear_layout.c,nuklear_tree.c,nuklear_group.c,nuklear_list_view.c,nuklear_widget.c,nuklear_text.c,nuklear_image.c,nuklear_button.c,nuklear_toggle.c,nuklear_selectable.c,nuklear_slider.c,nuklear_progress.c,nuklear_scrollbar.c,nuklear_text_editor.c,nuklear_edit.c,nuklear_property.c,nuklear_chart.c,nuklear_color_picker.c,nuklear_combo.c,nuklear_tooltip.c --outro LICENSE,CHANGELOG,CREDITS > ..\nuklear.h diff --git a/src/paq.sh b/src/paq.sh index a105045..1eb05a4 100755 --- a/src/paq.sh +++ b/src/paq.sh @@ -1,3 +1,3 @@ #!/bin/sh -python build.py --macro NK --intro HEADER --pub nuklear.h --priv nuklear_internal.h,nuklear_math.c,nuklear_util.c,nuklear_color.c,nuklear_utf8.c,nuklear_buffer.c,nuklear_string.c,nuklear_draw.c,nuklear_vertex.c,stb_rect_pack.h,stb_truetype.h,nuklear_font.c,nuklear_input.c,nuklear_style.c,nuklear_context.c,nuklear_pool.c,nuklear_page_element.c,nuklear_table.c,nuklear_panel.c,nuklear_window.c,nuklear_popup.c,nuklear_contextual.c,nuklear_menu.c,nuklear_layout.c,nuklear_tree.c,nuklear_group.c,nuklear_list_view.c,nuklear_widget.c,nuklear_text.c,nuklear_image.c,nuklear_button.c,nuklear_toggle.c,nuklear_selectable.c,nuklear_slider.c,nuklear_progress.c,nuklear_scrollbar.c,nuklear_text_editor.c,nuklear_edit.c,nuklear_property.c,nuklear_chart.c,nuklear_color_picker.c,nuklear_combo.c,nuklear_tooltip.c --outro LICENSE,CHANGELOG,CREDITS +python build.py --macro NK --intro HEADER --pub nuklear.h --priv1 nuklear_internal.h,nuklear_math.c,nuklear_util.c,nuklear_color.c,nuklear_utf8.c,nuklear_buffer.c,nuklear_string.c,nuklear_draw.c,nuklear_vertex.c --extern stb_rect_pack.h,stb_truetype.h --priv2 nuklear_font.c,nuklear_input.c,nuklear_style.c,nuklear_context.c,nuklear_pool.c,nuklear_page_element.c,nuklear_table.c,nuklear_panel.c,nuklear_window.c,nuklear_popup.c,nuklear_contextual.c,nuklear_menu.c,nuklear_layout.c,nuklear_tree.c,nuklear_group.c,nuklear_list_view.c,nuklear_widget.c,nuklear_text.c,nuklear_image.c,nuklear_button.c,nuklear_toggle.c,nuklear_selectable.c,nuklear_slider.c,nuklear_progress.c,nuklear_scrollbar.c,nuklear_text_editor.c,nuklear_edit.c,nuklear_property.c,nuklear_chart.c,nuklear_color_picker.c,nuklear_combo.c,nuklear_tooltip.c --outro LICENSE,CHANGELOG,CREDITS diff --git a/src/stb_rect_pack.h b/src/stb_rect_pack.h index 40f42ad..5c848de 100644 --- a/src/stb_rect_pack.h +++ b/src/stb_rect_pack.h @@ -1,60 +1,60 @@ -/* stb_rect_pack.h - v1.00 - public domain - rectangle packing */ -/* Sean Barrett 2014 */ -/* */ -/* Useful for e.g. packing rectangular textures into an atlas. */ -/* Does not do rotation. */ -/* */ -/* Not necessarily the awesomest packing method, but better than */ -/* the totally naive one in stb_truetype (which is primarily what */ -/* this is meant to replace). */ -/* */ -/* Has only had a few tests run, may have issues. */ -/* */ -/* More docs to come. */ -/* */ -/* No memory allocations; uses qsort() and assert() from stdlib. */ -/* Can override those by defining STBRP_SORT and STBRP_ASSERT. */ -/* */ -/* This library currently uses the Skyline Bottom-Left algorithm. */ -/* */ -/* Please note: better rectangle packers are welcome! Please */ -/* implement them to the same API, but with a different init */ -/* function. */ -/* */ -/* Credits */ -/* */ -/* Library */ -/* Sean Barrett */ -/* Minor features */ -/* Martins Mozeiko */ -/* github:IntellectualKitty */ -/* */ -/* Bugfixes / warning fixes */ -/* Jeremy Jaussaud */ -/* Fabian Giesen */ -/* */ -/* Version history: */ -/* */ -/* 1.00 (2019-02-25) avoid small space waste; gracefully fail too-wide rectangles */ -/* 0.99 (2019-02-07) warning fixes */ -/* 0.11 (2017-03-03) return packing success/fail result */ -/* 0.10 (2016-10-25) remove cast-away-const to avoid warnings */ -/* 0.09 (2016-08-27) fix compiler warnings */ -/* 0.08 (2015-09-13) really fix bug with empty rects (w=0 or h=0) */ -/* 0.07 (2015-09-13) fix bug with empty rects (w=0 or h=0) */ -/* 0.06 (2015-04-15) added STBRP_SORT to allow replacing qsort */ -/* 0.05: added STBRP_ASSERT to allow replacing assert */ -/* 0.04: fixed minor bug in STBRP_LARGE_RECTS support */ -/* 0.01: initial release */ -/* */ -/* LICENSE */ -/* */ -/* See end of file for license information. */ +// stb_rect_pack.h - v1.00 - public domain - rectangle packing +// Sean Barrett 2014 +// +// Useful for e.g. packing rectangular textures into an atlas. +// Does not do rotation. +// +// Not necessarily the awesomest packing method, but better than +// the totally naive one in stb_truetype (which is primarily what +// this is meant to replace). +// +// Has only had a few tests run, may have issues. +// +// More docs to come. +// +// No memory allocations; uses qsort() and assert() from stdlib. +// Can override those by defining STBRP_SORT and STBRP_ASSERT. +// +// This library currently uses the Skyline Bottom-Left algorithm. +// +// Please note: better rectangle packers are welcome! Please +// implement them to the same API, but with a different init +// function. +// +// Credits +// +// Library +// Sean Barrett +// Minor features +// Martins Mozeiko +// github:IntellectualKitty +// +// Bugfixes / warning fixes +// Jeremy Jaussaud +// Fabian Giesen +// +// Version history: +// +// 1.00 (2019-02-25) avoid small space waste; gracefully fail too-wide rectangles +// 0.99 (2019-02-07) warning fixes +// 0.11 (2017-03-03) return packing success/fail result +// 0.10 (2016-10-25) remove cast-away-const to avoid warnings +// 0.09 (2016-08-27) fix compiler warnings +// 0.08 (2015-09-13) really fix bug with empty rects (w=0 or h=0) +// 0.07 (2015-09-13) fix bug with empty rects (w=0 or h=0) +// 0.06 (2015-04-15) added STBRP_SORT to allow replacing qsort +// 0.05: added STBRP_ASSERT to allow replacing assert +// 0.04: fixed minor bug in STBRP_LARGE_RECTS support +// 0.01: initial release +// +// LICENSE +// +// See end of file for license information. -/* //////////////////////////////////////////////////////////////////////////// */ -/* */ -/* INCLUDE SECTION */ -/* */ +////////////////////////////////////////////////////////////////////////////// +// +// INCLUDE SECTION +// #ifndef STB_INCLUDE_STB_RECT_PACK_H #define STB_INCLUDE_STB_RECT_PACK_H @@ -82,76 +82,76 @@ typedef unsigned short stbrp_coord; #endif STBRP_DEF int stbrp_pack_rects (stbrp_context *context, stbrp_rect *rects, int num_rects); -/* Assign packed locations to rectangles. The rectangles are of type */ -/* 'stbrp_rect' defined below, stored in the array 'rects', and there */ -/* are 'num_rects' many of them. */ -/* */ -/* Rectangles which are successfully packed have the 'was_packed' flag */ -/* set to a non-zero value and 'x' and 'y' store the minimum location */ -/* on each axis (i.e. bottom-left in cartesian coordinates, top-left */ -/* if you imagine y increasing downwards). Rectangles which do not fit */ -/* have the 'was_packed' flag set to 0. */ -/* */ -/* You should not try to access the 'rects' array from another thread */ -/* while this function is running, as the function temporarily reorders */ -/* the array while it executes. */ -/* */ -/* To pack into another rectangle, you need to call stbrp_init_target */ -/* again. To continue packing into the same rectangle, you can call */ -/* this function again. Calling this multiple times with multiple rect */ -/* arrays will probably produce worse packing results than calling it */ -/* a single time with the full rectangle array, but the option is */ -/* available. */ -/* */ -/* The function returns 1 if all of the rectangles were successfully */ -/* packed and 0 otherwise. */ +// Assign packed locations to rectangles. The rectangles are of type +// 'stbrp_rect' defined below, stored in the array 'rects', and there +// are 'num_rects' many of them. +// +// Rectangles which are successfully packed have the 'was_packed' flag +// set to a non-zero value and 'x' and 'y' store the minimum location +// on each axis (i.e. bottom-left in cartesian coordinates, top-left +// if you imagine y increasing downwards). Rectangles which do not fit +// have the 'was_packed' flag set to 0. +// +// You should not try to access the 'rects' array from another thread +// while this function is running, as the function temporarily reorders +// the array while it executes. +// +// To pack into another rectangle, you need to call stbrp_init_target +// again. To continue packing into the same rectangle, you can call +// this function again. Calling this multiple times with multiple rect +// arrays will probably produce worse packing results than calling it +// a single time with the full rectangle array, but the option is +// available. +// +// The function returns 1 if all of the rectangles were successfully +// packed and 0 otherwise. struct stbrp_rect { - /* reserved for your use: */ + // reserved for your use: int id; - /* input: */ + // input: stbrp_coord w, h; - /* output: */ + // output: stbrp_coord x, y; - int was_packed; /* non-zero if valid packing */ + int was_packed; // non-zero if valid packing -}; /* 16 bytes, nominally */ +}; // 16 bytes, nominally STBRP_DEF void stbrp_init_target (stbrp_context *context, int width, int height, stbrp_node *nodes, int num_nodes); -/* Initialize a rectangle packer to: */ -/* pack a rectangle that is 'width' by 'height' in dimensions */ -/* using temporary storage provided by the array 'nodes', which is 'num_nodes' long */ -/* */ -/* You must call this function every time you start packing into a new target. */ -/* */ -/* There is no "shutdown" function. The 'nodes' memory must stay valid for */ -/* the following stbrp_pack_rects() call (or calls), but can be freed after */ -/* the call (or calls) finish. */ -/* */ -/* Note: to guarantee best results, either: */ -/* 1. make sure 'num_nodes' >= 'width' */ -/* or 2. call stbrp_allow_out_of_mem() defined below with 'allow_out_of_mem = 1' */ -/* */ -/* If you don't do either of the above things, widths will be quantized to multiples */ -/* of small integers to guarantee the algorithm doesn't run out of temporary storage. */ -/* */ -/* If you do #2, then the non-quantized algorithm will be used, but the algorithm */ -/* may run out of temporary storage and be unable to pack some rectangles. */ +// Initialize a rectangle packer to: +// pack a rectangle that is 'width' by 'height' in dimensions +// using temporary storage provided by the array 'nodes', which is 'num_nodes' long +// +// You must call this function every time you start packing into a new target. +// +// There is no "shutdown" function. The 'nodes' memory must stay valid for +// the following stbrp_pack_rects() call (or calls), but can be freed after +// the call (or calls) finish. +// +// Note: to guarantee best results, either: +// 1. make sure 'num_nodes' >= 'width' +// or 2. call stbrp_allow_out_of_mem() defined below with 'allow_out_of_mem = 1' +// +// If you don't do either of the above things, widths will be quantized to multiples +// of small integers to guarantee the algorithm doesn't run out of temporary storage. +// +// If you do #2, then the non-quantized algorithm will be used, but the algorithm +// may run out of temporary storage and be unable to pack some rectangles. STBRP_DEF void stbrp_setup_allow_out_of_mem (stbrp_context *context, int allow_out_of_mem); -/* Optionally call this function after init but before doing any packing to */ -/* change the handling of the out-of-temp-memory scenario, described above. */ -/* If you call init again, this will be reset to the default (false). */ +// Optionally call this function after init but before doing any packing to +// change the handling of the out-of-temp-memory scenario, described above. +// If you call init again, this will be reset to the default (false). STBRP_DEF void stbrp_setup_heuristic (stbrp_context *context, int heuristic); -/* Optionally select which packing heuristic the library should use. Different */ -/* heuristics will produce better/worse results for different data sets. */ -/* If you call init again, this will be reset to the default. */ +// Optionally select which packing heuristic the library should use. Different +// heuristics will produce better/worse results for different data sets. +// If you call init again, this will be reset to the default. enum { @@ -161,10 +161,10 @@ enum }; -/* //////////////////////////////////////////////////////////////////////////// */ -/* */ -/* the details of the following structures don't matter to you, but they must */ -/* be visible so you can handle the memory allocations for them */ +////////////////////////////////////////////////////////////////////////////// +// +// the details of the following structures don't matter to you, but they must +// be visible so you can handle the memory allocations for them struct stbrp_node { @@ -182,7 +182,7 @@ struct stbrp_context int num_nodes; stbrp_node *active_head; stbrp_node *free_head; - stbrp_node extra[2]; /* we allocate two extra nodes so optimal user-node-count is 'width' not 'width+2' */ + stbrp_node extra[2]; // we allocate two extra nodes so optimal user-node-count is 'width' not 'width+2' }; #ifdef __cplusplus @@ -191,10 +191,10 @@ struct stbrp_context #endif -/* //////////////////////////////////////////////////////////////////////////// */ -/* */ -/* IMPLEMENTATION SECTION */ -/* */ +////////////////////////////////////////////////////////////////////////////// +// +// IMPLEMENTATION SECTION +// #ifdef STB_RECT_PACK_IMPLEMENTATION #ifndef STBRP_SORT @@ -233,18 +233,18 @@ STBRP_DEF void stbrp_setup_heuristic(stbrp_context *context, int heuristic) STBRP_DEF void stbrp_setup_allow_out_of_mem(stbrp_context *context, int allow_out_of_mem) { if (allow_out_of_mem) - /* if it's ok to run out of memory, then don't bother aligning them; */ - /* this gives better packing, but may fail due to OOM (even though */ - /* the rectangles easily fit). @TODO a smarter approach would be to only */ - /* quantize once we've hit OOM, then we could get rid of this parameter. */ + // if it's ok to run out of memory, then don't bother aligning them; + // this gives better packing, but may fail due to OOM (even though + // the rectangles easily fit). @TODO a smarter approach would be to only + // quantize once we've hit OOM, then we could get rid of this parameter. context->align = 1; else { - /* if it's not ok to run out of memory, then quantize the widths */ - /* so that num_nodes is always enough nodes. */ - /* */ - /* I.e. num_nodes * align >= width */ - /* align >= width / num_nodes */ - /* align = ceil(width/num_nodes) */ + // if it's not ok to run out of memory, then quantize the widths + // so that num_nodes is always enough nodes. + // + // I.e. num_nodes * align >= width + // align >= width / num_nodes + // align = ceil(width/num_nodes) context->align = (context->width + context->num_nodes-1) / context->num_nodes; } @@ -269,7 +269,7 @@ STBRP_DEF void stbrp_init_target(stbrp_context *context, int width, int height, context->num_nodes = num_nodes; stbrp_setup_allow_out_of_mem(context, 0); - /* node 0 is the full width, node 1 is the sentinel (lets us not store width explicitly) */ + // node 0 is the full width, node 1 is the sentinel (lets us not store width explicitly) context->extra[0].x = 0; context->extra[0].y = 0; context->extra[0].next = &context->extra[1]; @@ -282,7 +282,7 @@ STBRP_DEF void stbrp_init_target(stbrp_context *context, int width, int height, context->extra[1].next = NULL; } -/* find minimum y position if it starts at x1 */ +// find minimum y position if it starts at x1 static int stbrp__skyline_find_min_y(stbrp_context *c, stbrp_node *first, int x0, int width, int *pwaste) { stbrp_node *node = first; @@ -294,11 +294,11 @@ static int stbrp__skyline_find_min_y(stbrp_context *c, stbrp_node *first, int x0 STBRP_ASSERT(first->x <= x0); #if 0 - /* skip in case we're past the node */ + // skip in case we're past the node while (node->next->x <= x0) ++node; #else - STBRP_ASSERT(node->next->x > x0); /* we ended up handling this in the caller for efficiency */ + STBRP_ASSERT(node->next->x > x0); // we ended up handling this in the caller for efficiency #endif STBRP_ASSERT(node->x <= x0); @@ -308,18 +308,18 @@ static int stbrp__skyline_find_min_y(stbrp_context *c, stbrp_node *first, int x0 visited_width = 0; while (node->x < x1) { if (node->y > min_y) { - /* raise min_y higher. */ - /* we've accounted for all waste up to min_y, */ - /* but we'll now add more waste for everything we've visted */ + // raise min_y higher. + // we've accounted for all waste up to min_y, + // but we'll now add more waste for everything we've visted waste_area += visited_width * (node->y - min_y); min_y = node->y; - /* the first time through, visited_width might be reduced */ + // the first time through, visited_width might be reduced if (node->x < x0) visited_width += node->next->x - x0; else visited_width += node->next->x - node->x; } else { - /* add waste area */ + // add waste area int under_width = node->next->x - node->x; if (under_width + visited_width > width) under_width = width - visited_width; @@ -345,12 +345,12 @@ static stbrp__findresult stbrp__skyline_find_best_pos(stbrp_context *c, int widt stbrp__findresult fr; stbrp_node **prev, *node, *tail, **best = NULL; - /* align to multiple of c->align */ + // align to multiple of c->align width = (width + c->align - 1); width -= width % c->align; STBRP_ASSERT(width % c->align == 0); - /* if it can't possibly fit, bail immediately */ + // if it can't possibly fit, bail immediately if (width > c->width || height > c->height) { fr.prev_link = NULL; fr.x = fr.y = 0; @@ -362,16 +362,16 @@ static stbrp__findresult stbrp__skyline_find_best_pos(stbrp_context *c, int widt while (node->x + width <= c->width) { int y,waste; y = stbrp__skyline_find_min_y(c, node, node->x, width, &waste); - if (c->heuristic == STBRP_HEURISTIC_Skyline_BL_sortHeight) { /* actually just want to test BL */ - /* bottom left */ + if (c->heuristic == STBRP_HEURISTIC_Skyline_BL_sortHeight) { // actually just want to test BL + // bottom left if (y < best_y) { best_y = y; best = prev; } } else { - /* best-fit */ + // best-fit if (y + height <= c->height) { - /* can only use it if it first vertically */ + // can only use it if it first vertically if (y < best_y || (y == best_y && waste < best_waste)) { best_y = y; best_waste = waste; @@ -385,35 +385,35 @@ static stbrp__findresult stbrp__skyline_find_best_pos(stbrp_context *c, int widt best_x = (best == NULL) ? 0 : (*best)->x; - /* if doing best-fit (BF), we also have to try aligning right edge to each node position */ - /* */ - /* e.g, if fitting */ - /* */ - /* ____________________ */ - /* |____________________| */ - /* */ - /* into */ - /* */ - /* | | */ - /* | ____________| */ - /* |____________| */ - /* */ - /* then right-aligned reduces waste, but bottom-left BL is always chooses left-aligned */ - /* */ - /* This makes BF take about 2x the time */ + // if doing best-fit (BF), we also have to try aligning right edge to each node position + // + // e.g, if fitting + // + // ____________________ + // |____________________| + // + // into + // + // | | + // | ____________| + // |____________| + // + // then right-aligned reduces waste, but bottom-left BL is always chooses left-aligned + // + // This makes BF take about 2x the time if (c->heuristic == STBRP_HEURISTIC_Skyline_BF_sortHeight) { tail = c->active_head; node = c->active_head; prev = &c->active_head; - /* find first node that's admissible */ + // find first node that's admissible while (tail->x < width) tail = tail->next; while (tail) { int xpos = tail->x - width; int y,waste; STBRP_ASSERT(xpos >= 0); - /* find the left position that matches this */ + // find the left position that matches this while (node->next->x <= xpos) { prev = &node->next; node = node->next; @@ -443,33 +443,33 @@ static stbrp__findresult stbrp__skyline_find_best_pos(stbrp_context *c, int widt static stbrp__findresult stbrp__skyline_pack_rectangle(stbrp_context *context, int width, int height) { - /* find best position according to heuristic */ + // find best position according to heuristic stbrp__findresult res = stbrp__skyline_find_best_pos(context, width, height); stbrp_node *node, *cur; - /* bail if: */ - /* 1. it failed */ - /* 2. the best node doesn't fit (we don't always check this) */ - /* 3. we're out of memory */ + // bail if: + // 1. it failed + // 2. the best node doesn't fit (we don't always check this) + // 3. we're out of memory if (res.prev_link == NULL || res.y + height > context->height || context->free_head == NULL) { res.prev_link = NULL; return res; } - /* on success, create new node */ + // on success, create new node node = context->free_head; node->x = (stbrp_coord) res.x; node->y = (stbrp_coord) (res.y + height); context->free_head = node->next; - /* insert the new node into the right starting point, and */ - /* let 'cur' point to the remaining nodes needing to be */ - /* stiched back in */ + // insert the new node into the right starting point, and + // let 'cur' point to the remaining nodes needing to be + // stiched back in cur = *res.prev_link; if (cur->x < res.x) { - /* preserve the existing one, so start testing with the next one */ + // preserve the existing one, so start testing with the next one stbrp_node *next = cur->next; cur->next = node; cur = next; @@ -477,17 +477,17 @@ static stbrp__findresult stbrp__skyline_pack_rectangle(stbrp_context *context, i *res.prev_link = node; } - /* from here, traverse cur and free the nodes, until we get to one */ - /* that shouldn't be freed */ + // from here, traverse cur and free the nodes, until we get to one + // that shouldn't be freed while (cur->next && cur->next->x <= res.x + width) { stbrp_node *next = cur->next; - /* move the current node to the free list */ + // move the current node to the free list cur->next = context->free_head; context->free_head = cur; cur = next; } - /* stitch the list back in */ + // stitch the list back in node->next = cur; if (cur->x < res.x + width) @@ -548,17 +548,17 @@ STBRP_DEF int stbrp_pack_rects(stbrp_context *context, stbrp_rect *rects, int nu { int i, all_rects_packed = 1; - /* we use the 'was_packed' field internally to allow sorting/unsorting */ + // we use the 'was_packed' field internally to allow sorting/unsorting for (i=0; i < num_rects; ++i) { rects[i].was_packed = i; } - /* sort according to heuristic */ + // sort according to heuristic STBRP_SORT(rects, num_rects, sizeof(rects[0]), rect_height_compare); for (i=0; i < num_rects; ++i) { if (rects[i].w == 0 || rects[i].h == 0) { - rects[i].x = rects[i].y = 0; /* empty rect needs no space */ + rects[i].x = rects[i].y = 0; // empty rect needs no space } else { stbrp__findresult fr = stbrp__skyline_pack_rectangle(context, rects[i].w, rects[i].h); if (fr.prev_link) { @@ -570,17 +570,17 @@ STBRP_DEF int stbrp_pack_rects(stbrp_context *context, stbrp_rect *rects, int nu } } - /* unsort */ + // unsort STBRP_SORT(rects, num_rects, sizeof(rects[0]), rect_original_order); - /* set was_packed flags and all_rects_packed status */ + // set was_packed flags and all_rects_packed status for (i=0; i < num_rects; ++i) { rects[i].was_packed = !(rects[i].x == STBRP__MAXVAL && rects[i].y == STBRP__MAXVAL); if (!rects[i].was_packed) all_rects_packed = 0; } - /* return the all_rects_packed status */ + // return the all_rects_packed status return all_rects_packed; } #endif diff --git a/src/stb_truetype.h b/src/stb_truetype.h index e1a7292..935a6de 100644 --- a/src/stb_truetype.h +++ b/src/stb_truetype.h @@ -1,309 +1,309 @@ -/* stb_truetype.h - v1.24 - public domain */ -/* authored from 2009-2020 by Sean Barrett / RAD Game Tools */ -/* */ -/* ======================================================================= */ -/* */ -/* NO SECURITY GUARANTEE -- DO NOT USE THIS ON UNTRUSTED FONT FILES */ -/* */ -/* This library does no range checking of the offsets found in the file, */ -/* meaning an attacker can use it to read arbitrary memory. */ -/* */ -/* ======================================================================= */ -/* */ -/* This library processes TrueType files: */ -/* parse files */ -/* extract glyph metrics */ -/* extract glyph shapes */ -/* render glyphs to one-channel bitmaps with antialiasing (box filter) */ -/* render glyphs to one-channel SDF bitmaps (signed-distance field/function) */ -/* */ -/* Todo: */ -/* non-MS cmaps */ -/* crashproof on bad data */ -/* hinting? (no longer patented) */ -/* cleartype-style AA? */ -/* optimize: use simple memory allocator for intermediates */ -/* optimize: build edge-list directly from curves */ -/* optimize: rasterize directly from curves? */ -/* */ -/* ADDITIONAL CONTRIBUTORS */ -/* */ -/* Mikko Mononen: compound shape support, more cmap formats */ -/* Tor Andersson: kerning, subpixel rendering */ -/* Dougall Johnson: OpenType / Type 2 font handling */ -/* Daniel Ribeiro Maciel: basic GPOS-based kerning */ -/* */ -/* Misc other: */ -/* Ryan Gordon */ -/* Simon Glass */ -/* github:IntellectualKitty */ -/* Imanol Celaya */ -/* Daniel Ribeiro Maciel */ -/* */ -/* Bug/warning reports/fixes: */ -/* "Zer" on mollyrocket Fabian "ryg" Giesen github:NiLuJe */ -/* Cass Everitt Martins Mozeiko github:aloucks */ -/* stoiko (Haemimont Games) Cap Petschulat github:oyvindjam */ -/* Brian Hook Omar Cornut github:vassvik */ -/* Walter van Niftrik Ryan Griege */ -/* David Gow Peter LaValle */ -/* David Given Sergey Popov */ -/* Ivan-Assen Ivanov Giumo X. Clanjor */ -/* Anthony Pesch Higor Euripedes */ -/* Johan Duparc Thomas Fields */ -/* Hou Qiming Derek Vinyard */ -/* Rob Loach Cort Stratton */ -/* Kenney Phillis Jr. Brian Costabile */ -/* Ken Voskuil (kaesve) */ -/* */ -/* VERSION HISTORY */ -/* */ -/* 1.24 (2020-02-05) fix warning */ -/* 1.23 (2020-02-02) query SVG data for glyphs; query whole kerning table (but only kern not GPOS) */ -/* 1.22 (2019-08-11) minimize missing-glyph duplication; fix kerning if both 'GPOS' and 'kern' are defined */ -/* 1.21 (2019-02-25) fix warning */ -/* 1.20 (2019-02-07) PackFontRange skips missing codepoints; GetScaleFontVMetrics() */ -/* 1.19 (2018-02-11) GPOS kerning, STBTT_fmod */ -/* 1.18 (2018-01-29) add missing function */ -/* 1.17 (2017-07-23) make more arguments const; doc fix */ -/* 1.16 (2017-07-12) SDF support */ -/* 1.15 (2017-03-03) make more arguments const */ -/* 1.14 (2017-01-16) num-fonts-in-TTC function */ -/* 1.13 (2017-01-02) support OpenType fonts, certain Apple fonts */ -/* 1.12 (2016-10-25) suppress warnings about casting away const with -Wcast-qual */ -/* 1.11 (2016-04-02) fix unused-variable warning */ -/* 1.10 (2016-04-02) user-defined fabs(); rare memory leak; remove duplicate typedef */ -/* 1.09 (2016-01-16) warning fix; avoid crash on outofmem; use allocation userdata properly */ -/* 1.08 (2015-09-13) document stbtt_Rasterize(); fixes for vertical & horizontal edges */ -/* 1.07 (2015-08-01) allow PackFontRanges to accept arrays of sparse codepoints; */ -/* variant PackFontRanges to pack and render in separate phases; */ -/* fix stbtt_GetFontOFfsetForIndex (never worked for non-0 input?); */ -/* fixed an assert() bug in the new rasterizer */ -/* replace assert() with STBTT_assert() in new rasterizer */ -/* */ -/* Full history can be found at the end of this file. */ -/* */ -/* LICENSE */ -/* */ -/* See end of file for license information. */ -/* */ -/* USAGE */ -/* */ -/* Include this file in whatever places need to refer to it. In ONE C/C++ */ -/* file, write: */ -/* #define STB_TRUETYPE_IMPLEMENTATION */ -/* before the #include of this file. This expands out the actual */ -/* implementation into that C/C++ file. */ -/* */ -/* To make the implementation private to the file that generates the implementation, */ -/* #define STBTT_STATIC */ -/* */ -/* Simple 3D API (don't ship this, but it's fine for tools and quick start) */ -/* stbtt_BakeFontBitmap() -- bake a font to a bitmap for use as texture */ -/* stbtt_GetBakedQuad() -- compute quad to draw for a given char */ -/* */ -/* Improved 3D API (more shippable): */ -/* #include "stb_rect_pack.h" -- optional, but you really want it */ -/* stbtt_PackBegin() */ -/* stbtt_PackSetOversampling() -- for improved quality on small fonts */ -/* stbtt_PackFontRanges() -- pack and renders */ -/* stbtt_PackEnd() */ -/* stbtt_GetPackedQuad() */ -/* */ -/* "Load" a font file from a memory buffer (you have to keep the buffer loaded) */ -/* stbtt_InitFont() */ -/* stbtt_GetFontOffsetForIndex() -- indexing for TTC font collections */ -/* stbtt_GetNumberOfFonts() -- number of fonts for TTC font collections */ -/* */ -/* Render a unicode codepoint to a bitmap */ -/* stbtt_GetCodepointBitmap() -- allocates and returns a bitmap */ -/* stbtt_MakeCodepointBitmap() -- renders into bitmap you provide */ -/* stbtt_GetCodepointBitmapBox() -- how big the bitmap must be */ -/* */ -/* Character advance/positioning */ -/* stbtt_GetCodepointHMetrics() */ -/* stbtt_GetFontVMetrics() */ -/* stbtt_GetFontVMetricsOS2() */ -/* stbtt_GetCodepointKernAdvance() */ -/* */ -/* Starting with version 1.06, the rasterizer was replaced with a new, */ -/* faster and generally-more-precise rasterizer. The new rasterizer more */ -/* accurately measures pixel coverage for anti-aliasing, except in the case */ -/* where multiple shapes overlap, in which case it overestimates the AA pixel */ -/* coverage. Thus, anti-aliasing of intersecting shapes may look wrong. If */ -/* this turns out to be a problem, you can re-enable the old rasterizer with */ -/* #define STBTT_RASTERIZER_VERSION 1 */ -/* which will incur about a 15% speed hit. */ -/* */ -/* ADDITIONAL DOCUMENTATION */ -/* */ -/* Immediately after this block comment are a series of sample programs. */ -/* */ -/* After the sample programs is the "header file" section. This section */ -/* includes documentation for each API function. */ -/* */ -/* 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 stbtt_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. */ -/* */ -/* DETAILED USAGE: */ -/* */ -/* Scale: */ -/* Select how high you want the font to be, in points or pixels. */ -/* Call ScaleForPixelHeight or ScaleForMappingEmToPixels to compute */ -/* a scale factor SF that will be used by all other functions. */ -/* */ -/* Baseline: */ -/* You need to select a y-coordinate that is the baseline of where */ -/* your text will appear. Call GetFontBoundingBox to get the baseline-relative */ -/* bounding box for all characters. SF*-y0 will be the distance in pixels */ -/* that the worst-case character could extend above the baseline, so if */ -/* you want the top edge of characters to appear at the top of the */ -/* screen where y=0, then you would set the baseline to SF*-y0. */ -/* */ -/* Current point: */ -/* Set the current point where the first character will appear. The */ -/* first character could extend left of the current point; this is font */ -/* dependent. You can either choose a current point that is the leftmost */ -/* point and hope, or add some padding, or check the bounding box or */ -/* left-side-bearing of the first character to be displayed and set */ -/* the current point based on that. */ -/* */ -/* Displaying a character: */ -/* Compute the bounding box of the character. It will contain signed values */ -/* relative to . I.e. if it returns x0,y0,x1,y1, */ -/* then the character should be displayed in the rectangle from */ -/* to . I.e. if it returns x0,y0,x1,y1, +// then the character should be displayed in the rectangle from +// to = 32 && *text < 128) { stbtt_aligned_quad q; - stbtt_GetBakedQuad(cdata, 512,512, *text-32, &x,&y,&q,1);/* 1=opengl & d3d10+,0=d3d9 */ + 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); @@ -314,15 +314,15 @@ void my_stbtt_print(float x, float y, char *text) glEnd(); } #endif -/* */ -/* */ -/* //////////////////////////////////////////////////////////////////////////// */ -/* */ -/* Complete program (this compiles): get a single bitmap, print as ASCII art */ -/* */ +// +// +////////////////////////////////////////////////////////////////////////////// +// +// Complete program (this compiles): get a single bitmap, print as ASCII art +// #if 0 #include -#define STB_TRUETYPE_IMPLEMENTATION /* force following include to generate implementation */ +#define STB_TRUETYPE_IMPLEMENTATION // force following include to generate implementation #include "stb_truetype.h" char ttf_buffer[1<<25]; @@ -346,24 +346,24 @@ int main(int argc, char **argv) return 0; } #endif -/* */ -/* Output: */ -/* */ -/* .ii. */ -/* @@@@@@. */ -/* V@Mio@@o */ -/* :i. V@V */ -/* :oM@@M */ -/* :@@@MM@M */ -/* @@o o@M */ -/* :@@. M@M */ -/* @@@o@@@@ */ -/* :M@@V:@@. */ -/* */ -/* //////////////////////////////////////////////////////////////////////////// */ -/* */ -/* Complete program: print "Hello World!" banner, with bugs */ -/* */ +// +// Output: +// +// .ii. +// @@@@@@. +// V@Mio@@o +// :i. V@V +// :oM@@M +// :@@@MM@M +// @@o o@M +// :@@. M@M +// @@@o@@@@ +// :M@@V:@@. +// +////////////////////////////////////////////////////////////////////////////// +// +// Complete program: print "Hello World!" banner, with bugs +// #if 0 char buffer[24<<20]; unsigned char screen[20][79]; @@ -372,8 +372,8 @@ 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!"; /* intentionally misspelled to show 'lj' brokenness */ + float scale, xpos=2; // leave a little padding in case the character extends left + char *text = "Heljo World!"; // intentionally misspelled to show 'lj' brokenness fread(buffer, 1, 1000000, fopen("c:/windows/fonts/arialbd.ttf", "rb")); stbtt_InitFont(&font, buffer, 0); @@ -388,10 +388,10 @@ int main(int arg, char **argv) 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 */ + // 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]); @@ -409,17 +409,17 @@ int main(int arg, char **argv) #endif -/* //////////////////////////////////////////////////////////////////////////// */ -/* //////////////////////////////////////////////////////////////////////////// */ -/* // */ -/* // INTEGRATION WITH YOUR CODEBASE */ -/* // */ -/* // The following sections allow you to supply alternate definitions */ -/* // of C library functions used by stb_truetype, e.g. if you don't */ -/* // link with the C runtime library. */ +////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////// +//// +//// INTEGRATION WITH YOUR CODEBASE +//// +//// The following sections allow you to supply alternate definitions +//// of C library functions used by stb_truetype, e.g. if you don't +//// link with the C runtime library. #ifdef STB_TRUETYPE_IMPLEMENTATION - /* #define your own (u)stbtt_int8/16/32 before including to override this */ + // #define your own (u)stbtt_int8/16/32 before including to override this #ifndef stbtt_uint8 typedef unsigned char stbtt_uint8; typedef signed char stbtt_int8; @@ -432,7 +432,7 @@ int main(int arg, char **argv) typedef char stbtt__check_size32[sizeof(stbtt_int32)==4 ? 1 : -1]; typedef char stbtt__check_size16[sizeof(stbtt_int16)==2 ? 1 : -1]; - /* e.g. #define your own STBTT_ifloor/STBTT_iceil() to avoid math.h */ + // e.g. #define your own STBTT_ifloor/STBTT_iceil() to avoid math.h #ifndef STBTT_ifloor #include #define STBTT_ifloor(x) ((int) floor(x)) @@ -461,7 +461,7 @@ int main(int arg, char **argv) #define STBTT_fabs(x) fabs(x) #endif - /* #define your own functions "STBTT_malloc" / "STBTT_free" to avoid malloc.h */ + // #define your own functions "STBTT_malloc" / "STBTT_free" to avoid malloc.h #ifndef STBTT_malloc #include #define STBTT_malloc(x,u) ((void)(u),malloc(x)) @@ -485,12 +485,12 @@ int main(int arg, char **argv) #endif #endif -/* ///////////////////////////////////////////////////////////////////////////// */ -/* ///////////////////////////////////////////////////////////////////////////// */ -/* // */ -/* // INTERFACE */ -/* // */ -/* // */ +/////////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////////// +//// +//// INTERFACE +//// +//// #ifndef __STB_INCLUDE_STB_TRUETYPE_H__ #define __STB_INCLUDE_STB_TRUETYPE_H__ @@ -505,7 +505,7 @@ int main(int arg, char **argv) extern "C" { #endif -/* private structure */ +// private structure typedef struct { unsigned char *data; @@ -513,64 +513,64 @@ typedef struct int size; } stbtt__buf; -/* //////////////////////////////////////////////////////////////////////////// */ -/* */ -/* TEXTURE BAKING API */ -/* */ -/* If you use this API, you only have to call two functions ever. */ -/* */ +////////////////////////////////////////////////////////////////////////////// +// +// TEXTURE BAKING API +// +// If you use this API, you only have to call two functions ever. +// typedef struct { - unsigned short x0,y0,x1,y1; /* coordinates of bbox in bitmap */ + unsigned short x0,y0,x1,y1; // coordinates of bbox in bitmap float xoff,yoff,xadvance; } stbtt_bakedchar; -STBTT_DEF int stbtt_BakeFontBitmap(const unsigned char *data, int offset, /* font location (use offset=0 for plain .ttf) */ - float pixel_height, /* height of font in pixels */ - unsigned char *pixels, int pw, int ph, /* bitmap to be filled in */ - int first_char, int num_chars, /* characters to bake */ - stbtt_bakedchar *chardata); /* you allocate this, it's num_chars long */ -/* if return is positive, the first unused row of the bitmap */ -/* if return is negative, returns the negative of the number of characters that fit */ -/* if return is 0, no characters fit and no rows were used */ -/* This uses a very crappy packing. */ +STBTT_DEF int stbtt_BakeFontBitmap(const unsigned char *data, int offset, // font location (use offset=0 for plain .ttf) + float pixel_height, // height of font in pixels + unsigned char *pixels, int pw, int ph, // bitmap to be filled in + int first_char, int num_chars, // characters to bake + stbtt_bakedchar *chardata); // you allocate this, it's num_chars long +// if return is positive, the first unused row of the bitmap +// if return is negative, returns the negative of the number of characters that fit +// if return is 0, no characters fit and no rows were used +// This uses a very crappy packing. typedef struct { - float x0,y0,s0,t0; /* top-left */ - float x1,y1,s1,t1; /* bottom-right */ + float x0,y0,s0,t0; // top-left + float x1,y1,s1,t1; // bottom-right } stbtt_aligned_quad; -STBTT_DEF void stbtt_GetBakedQuad(const stbtt_bakedchar *chardata, int pw, int ph, /* same data as above */ - int char_index, /* character to display */ - float *xpos, float *ypos, /* pointers to current position in screen pixel space */ - stbtt_aligned_quad *q, /* output: quad to draw */ - int opengl_fillrule); /* true if opengl fill rule; false if DX9 or earlier */ -/* Call GetBakedQuad with char_index = 'character - first_char', and it */ -/* creates the quad you need to draw 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. */ -/* */ -/* It's inefficient; you might want to c&p it and optimize it. */ +STBTT_DEF void stbtt_GetBakedQuad(const stbtt_bakedchar *chardata, int pw, int ph, // same data as above + int char_index, // character to display + float *xpos, float *ypos, // pointers to current position in screen pixel space + stbtt_aligned_quad *q, // output: quad to draw + int opengl_fillrule); // true if opengl fill rule; false if DX9 or earlier +// Call GetBakedQuad with char_index = 'character - first_char', and it +// creates the quad you need to draw 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. +// +// It's inefficient; you might want to c&p it and optimize it. STBTT_DEF void stbtt_GetScaledFontVMetrics(const unsigned char *fontdata, int index, float size, float *ascent, float *descent, float *lineGap); -/* Query the font vertical metrics without having to create a font first. */ +// Query the font vertical metrics without having to create a font first. -/* //////////////////////////////////////////////////////////////////////////// */ -/* */ -/* NEW TEXTURE BAKING API */ -/* */ -/* This provides options for packing multiple fonts into one atlas, not */ -/* perfectly but better than nothing. */ +////////////////////////////////////////////////////////////////////////////// +// +// NEW TEXTURE BAKING API +// +// This provides options for packing multiple fonts into one atlas, not +// perfectly but better than nothing. typedef struct { - unsigned short x0,y0,x1,y1; /* coordinates of bbox in bitmap */ + unsigned short x0,y0,x1,y1; // coordinates of bbox in bitmap float xoff,yoff,xadvance; float xoff2,yoff2; } stbtt_packedchar; @@ -582,95 +582,95 @@ typedef struct stbrp_rect stbrp_rect; #endif STBTT_DEF int stbtt_PackBegin(stbtt_pack_context *spc, unsigned char *pixels, int width, int height, int stride_in_bytes, int padding, void *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 * height. stride_in_bytes is */ -/* the distance from one row to the next (or 0 to mean they are packed tightly */ -/* together). "padding" is the amount of padding to leave between each */ -/* character (normally you want '1' for bitmaps you'll use as textures with */ -/* bilinear filtering). */ -/* */ -/* Returns 0 on failure, 1 on success. */ +// 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 * height. stride_in_bytes is +// the distance from one row to the next (or 0 to mean they are packed tightly +// together). "padding" is the amount of padding to leave between each +// character (normally you want '1' for bitmaps you'll use as textures with +// bilinear filtering). +// +// Returns 0 on failure, 1 on success. STBTT_DEF void stbtt_PackEnd (stbtt_pack_context *spc); -/* Cleans up the packing context and frees all memory. */ +// Cleans up the packing context and frees all memory. #define STBTT_POINT_SIZE(x) (-(x)) STBTT_DEF int stbtt_PackFontRange(stbtt_pack_context *spc, const unsigned char *fontdata, int font_index, float font_size, int first_unicode_char_in_range, int num_chars_in_range, stbtt_packedchar *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 stbtt_GetPackedQuad to get back renderable quads. */ -/* */ -/* font_size is the full height of the character from ascender to descender, */ -/* as computed by stbtt_ScaleForPixelHeight. To use a point size as computed */ -/* by stbtt_ScaleForMappingEmToPixels, wrap the point size in STBTT_POINT_SIZE() */ -/* and pass that result as 'font_size': */ -/* ..., 20 , ... // font max minus min y is 20 pixels tall */ -/* ..., STBTT_POINT_SIZE(20), ... // 'M' is 20 pixels tall */ +// 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 stbtt_GetPackedQuad to get back renderable quads. +// +// font_size is the full height of the character from ascender to descender, +// as computed by stbtt_ScaleForPixelHeight. To use a point size as computed +// by stbtt_ScaleForMappingEmToPixels, wrap the point size in STBTT_POINT_SIZE() +// and pass that result as 'font_size': +// ..., 20 , ... // font max minus min y is 20 pixels tall +// ..., STBTT_POINT_SIZE(20), ... // 'M' is 20 pixels tall typedef struct { float font_size; - int first_unicode_codepoint_in_range; /* if non-zero, then the chars are continuous, and this is the first codepoint */ - int *array_of_unicode_codepoints; /* if non-zero, then this is an array of unicode codepoints */ + int first_unicode_codepoint_in_range; // if non-zero, then the chars are continuous, and this is the first codepoint + int *array_of_unicode_codepoints; // if non-zero, then this is an array of unicode codepoints int num_chars; - stbtt_packedchar *chardata_for_range; /* output */ - unsigned char h_oversample, v_oversample; /* don't set these, they're used internally */ + stbtt_packedchar *chardata_for_range; // output + unsigned char h_oversample, v_oversample; // don't set these, they're used internally } stbtt_pack_range; STBTT_DEF int stbtt_PackFontRanges(stbtt_pack_context *spc, const unsigned char *fontdata, int font_index, stbtt_pack_range *ranges, int num_ranges); -/* Creates character bitmaps from multiple ranges of characters stored in */ -/* ranges. This will usually create a better-packed bitmap than multiple */ -/* calls to stbtt_PackFontRange. Note that you can call this multiple */ -/* times within a single PackBegin/PackEnd. */ +// Creates character bitmaps from multiple ranges of characters stored in +// ranges. This will usually create a better-packed bitmap than multiple +// calls to stbtt_PackFontRange. Note that you can call this multiple +// times within a single PackBegin/PackEnd. STBTT_DEF void stbtt_PackSetOversampling(stbtt_pack_context *spc, unsigned int h_oversample, unsigned 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 */ -/* stbtt_PackFontRange(s) or stbtt_PackFontRangesGatherRects for a given */ -/* pack context. The default (no oversampling) is achieved by h_oversample=1 */ -/* and 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 */ -/* call to PackFontRangesGatherRects. */ +// 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 +// stbtt_PackFontRange(s) or stbtt_PackFontRangesGatherRects for a given +// pack context. The default (no oversampling) is achieved by h_oversample=1 +// and 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 +// call to PackFontRangesGatherRects. STBTT_DEF void stbtt_PackSetSkipMissingCodepoints(stbtt_pack_context *spc, int skip); -/* If skip != 0, this tells stb_truetype to skip any codepoints for which */ -/* there is no corresponding glyph. If skip=0, which is the default, then */ -/* codepoints without a glyph recived the font's "missing character" glyph, */ -/* typically an empty box by convention. */ +// If skip != 0, this tells stb_truetype to skip any codepoints for which +// there is no corresponding glyph. If skip=0, which is the default, then +// codepoints without a glyph recived the font's "missing character" glyph, +// typically an empty box by convention. -STBTT_DEF void stbtt_GetPackedQuad(const stbtt_packedchar *chardata, int pw, int ph, /* same data as above */ - int char_index, /* character to display */ - float *xpos, float *ypos, /* pointers to current position in screen pixel space */ - stbtt_aligned_quad *q, /* output: quad to draw */ +STBTT_DEF void stbtt_GetPackedQuad(const stbtt_packedchar *chardata, int pw, int ph, // same data as above + int char_index, // character to display + float *xpos, float *ypos, // pointers to current position in screen pixel space + stbtt_aligned_quad *q, // output: quad to draw int align_to_integer); STBTT_DEF int stbtt_PackFontRangesGatherRects(stbtt_pack_context *spc, const stbtt_fontinfo *info, stbtt_pack_range *ranges, int num_ranges, stbrp_rect *rects); STBTT_DEF void stbtt_PackFontRangesPackRects(stbtt_pack_context *spc, stbrp_rect *rects, int num_rects); STBTT_DEF int stbtt_PackFontRangesRenderIntoRects(stbtt_pack_context *spc, const stbtt_fontinfo *info, stbtt_pack_range *ranges, int num_ranges, stbrp_rect *rects); -/* Calling these functions in sequence is roughly equivalent to calling */ -/* stbtt_PackFontRanges(). If you more control over the packing of multiple */ -/* fonts, or if you want to pack custom data into a font texture, take a look */ -/* at the source to of stbtt_PackFontRanges() and create a custom version */ -/* using these functions, e.g. call GatherRects multiple times, */ -/* building up a single array of rects, then call PackRects once, */ -/* then call RenderIntoRects repeatedly. This may result in a */ -/* better packing than calling PackFontRanges multiple times */ -/* (or it may not). */ +// Calling these functions in sequence is roughly equivalent to calling +// stbtt_PackFontRanges(). If you more control over the packing of multiple +// fonts, or if you want to pack custom data into a font texture, take a look +// at the source to of stbtt_PackFontRanges() and create a custom version +// using these functions, e.g. call GatherRects multiple times, +// building up a single array of rects, then call PackRects once, +// then call RenderIntoRects repeatedly. This may result in a +// better packing than calling PackFontRanges multiple times +// (or it may not). -/* this is an opaque structure that you shouldn't mess with which holds */ -/* all the context needed from PackBegin to PackEnd. */ +// this is an opaque structure that you shouldn't mess with which holds +// all the context needed from PackBegin to PackEnd. struct stbtt_pack_context { void *user_allocator_context; void *pack_info; @@ -684,139 +684,139 @@ struct stbtt_pack_context { void *nodes; }; -/* //////////////////////////////////////////////////////////////////////////// */ -/* */ -/* FONT LOADING */ -/* */ -/* */ +////////////////////////////////////////////////////////////////////////////// +// +// FONT LOADING +// +// STBTT_DEF int stbtt_GetNumberOfFonts(const unsigned char *data); -/* This function will determine the number of fonts in a font file. TrueType */ -/* collection (.ttc) files may contain multiple fonts, while TrueType font */ -/* (.ttf) files only contain one font. The number of fonts can be used for */ -/* indexing with the previous function where the index is between zero and one */ -/* less than the total fonts. If an error occurs, -1 is returned. */ +// This function will determine the number of fonts in a font file. TrueType +// collection (.ttc) files may contain multiple fonts, while TrueType font +// (.ttf) files only contain one font. The number of fonts can be used for +// indexing with the previous function where the index is between zero and one +// less than the total fonts. If an error occurs, -1 is returned. STBTT_DEF int stbtt_GetFontOffsetForIndex(const unsigned char *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. */ +// 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. -/* The following structure is defined publicly so you can declare one on */ -/* the stack or as a global or etc, but you should treat it as opaque. */ +// The following structure is defined publicly so you can declare one on +// the stack or as a global or etc, but you should treat it as opaque. struct stbtt_fontinfo { void * userdata; - unsigned char * data; /* pointer to .ttf file */ - int fontstart; /* offset of start of font */ + unsigned char * data; // pointer to .ttf file + int fontstart; // offset of start of font - int numGlyphs; /* number of glyphs, needed for range checking */ + int numGlyphs; // number of glyphs, needed for range checking - int loca,head,glyf,hhea,hmtx,kern,gpos,svg; /* table locations as offset from start of .ttf */ - int index_map; /* a cmap mapping for our chosen character encoding */ - int indexToLocFormat; /* format needed to map from glyph index to glyph */ + int loca,head,glyf,hhea,hmtx,kern,gpos,svg; // table locations as offset from start of .ttf + int index_map; // a cmap mapping for our chosen character encoding + int indexToLocFormat; // format needed to map from glyph index to glyph - stbtt__buf cff; /* cff font data */ - stbtt__buf charstrings; /* the charstring index */ - stbtt__buf gsubrs; /* global charstring subroutines index */ - stbtt__buf subrs; /* private charstring subroutines index */ - stbtt__buf fontdicts; /* array of font dicts */ - stbtt__buf fdselect; /* map from glyph to fontdict */ + stbtt__buf cff; // cff font data + stbtt__buf charstrings; // the charstring index + stbtt__buf gsubrs; // global charstring subroutines index + stbtt__buf subrs; // private charstring subroutines index + stbtt__buf fontdicts; // array of font dicts + stbtt__buf fdselect; // map from glyph to fontdict }; STBTT_DEF int stbtt_InitFont(stbtt_fontinfo *info, const unsigned char *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 stbtt_fontinfo 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. Returns 0 on failure. */ +// 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 stbtt_fontinfo 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. Returns 0 on failure. -/* //////////////////////////////////////////////////////////////////////////// */ -/* */ -/* CHARACTER TO GLYPH-INDEX CONVERSIOn */ +////////////////////////////////////////////////////////////////////////////// +// +// CHARACTER TO GLYPH-INDEX CONVERSIOn STBTT_DEF int stbtt_FindGlyphIndex(const stbtt_fontinfo *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. */ -/* Returns 0 if the character codepoint is not defined in the font. */ +// 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. +// Returns 0 if the character codepoint is not defined in the font. -/* //////////////////////////////////////////////////////////////////////////// */ -/* */ -/* CHARACTER PROPERTIES */ -/* */ +////////////////////////////////////////////////////////////////////////////// +// +// CHARACTER PROPERTIES +// STBTT_DEF float stbtt_ScaleForPixelHeight(const stbtt_fontinfo *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 stbtt_GetFontVMetrics */ -/* and computing: */ -/* scale = pixels / (ascent - descent) */ -/* so if you prefer to measure height by the ascent only, use a similar calculation. */ +// 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 stbtt_GetFontVMetrics +// and computing: +// scale = pixels / (ascent - descent) +// so if you prefer to measure height by the ascent only, use a similar calculation. STBTT_DEF float stbtt_ScaleForMappingEmToPixels(const stbtt_fontinfo *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. */ +// 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. STBTT_DEF void stbtt_GetFontVMetrics(const stbtt_fontinfo *info, int *ascent, int *descent, int *lineGap); -/* ascent is the coordinate above the baseline the font extends; descent */ -/* is the coordinate below the baseline the font extends (i.e. it is typically negative) */ -/* lineGap is the spacing between one row's descent and the next row's ascent... */ -/* so you should advance the vertical position by "*ascent - *descent + *lineGap" */ -/* these are expressed in unscaled coordinates, so you must multiply by */ -/* the scale factor for a given size */ +// ascent is the coordinate above the baseline the font extends; descent +// is the coordinate below the baseline the font extends (i.e. it is typically negative) +// lineGap is the spacing between one row's descent and the next row's ascent... +// so you should advance the vertical position by "*ascent - *descent + *lineGap" +// these are expressed in unscaled coordinates, so you must multiply by +// the scale factor for a given size STBTT_DEF int stbtt_GetFontVMetricsOS2(const stbtt_fontinfo *info, int *typoAscent, int *typoDescent, int *typoLineGap); -/* analogous to GetFontVMetrics, but returns the "typographic" values from the OS/2 */ -/* table (specific to MS/Windows TTF files). */ -/* */ -/* Returns 1 on success (table present), 0 on failure. */ +// analogous to GetFontVMetrics, but returns the "typographic" values from the OS/2 +// table (specific to MS/Windows TTF files). +// +// Returns 1 on success (table present), 0 on failure. STBTT_DEF void stbtt_GetFontBoundingBox(const stbtt_fontinfo *info, int *x0, int *y0, int *x1, int *y1); -/* the bounding box around all possible characters */ +// the bounding box around all possible characters STBTT_DEF void stbtt_GetCodepointHMetrics(const stbtt_fontinfo *info, int codepoint, int *advanceWidth, int *leftSideBearing); -/* leftSideBearing is the offset from the current horizontal position to the left edge of the character */ -/* advanceWidth is the offset from the current horizontal position to the next horizontal position */ -/* these are expressed in unscaled coordinates */ +// leftSideBearing is the offset from the current horizontal position to the left edge of the character +// advanceWidth is the offset from the current horizontal position to the next horizontal position +// these are expressed in unscaled coordinates STBTT_DEF int stbtt_GetCodepointKernAdvance(const stbtt_fontinfo *info, int ch1, int ch2); -/* an additional amount to add to the 'advance' value between ch1 and ch2 */ +// an additional amount to add to the 'advance' value between ch1 and ch2 STBTT_DEF int stbtt_GetCodepointBox(const stbtt_fontinfo *info, int codepoint, int *x0, int *y0, int *x1, int *y1); -/* Gets the bounding box of the visible part of the glyph, in unscaled coordinates */ +// Gets the bounding box of the visible part of the glyph, in unscaled coordinates STBTT_DEF void stbtt_GetGlyphHMetrics(const stbtt_fontinfo *info, int glyph_index, int *advanceWidth, int *leftSideBearing); STBTT_DEF int stbtt_GetGlyphKernAdvance(const stbtt_fontinfo *info, int glyph1, int glyph2); STBTT_DEF int stbtt_GetGlyphBox(const stbtt_fontinfo *info, int glyph_index, int *x0, int *y0, int *x1, int *y1); -/* as above, but takes one or more glyph indices for greater efficiency */ +// as above, but takes one or more glyph indices for greater efficiency typedef struct stbtt_kerningentry { - int glyph1; /* use stbtt_FindGlyphIndex */ + int glyph1; // use stbtt_FindGlyphIndex int glyph2; int advance; } stbtt_kerningentry; STBTT_DEF int stbtt_GetKerningTableLength(const stbtt_fontinfo *info); STBTT_DEF int stbtt_GetKerningTable(const stbtt_fontinfo *info, stbtt_kerningentry* table, int table_length); -/* Retrieves a complete list of all of the kerning pairs provided by the font */ -/* stbtt_GetKerningTable never writes more than table_length entries and returns how many entries it did write. */ -/* The table will be sorted by (a.glyph1 == b.glyph1)?(a.glyph2 < b.glyph2):(a.glyph1 < b.glyph1) */ +// Retrieves a complete list of all of the kerning pairs provided by the font +// stbtt_GetKerningTable never writes more than table_length entries and returns how many entries it did write. +// The table will be sorted by (a.glyph1 == b.glyph1)?(a.glyph2 < b.glyph2):(a.glyph1 < b.glyph1) -/* //////////////////////////////////////////////////////////////////////////// */ -/* */ -/* GLYPH SHAPES (you probably don't need these, but they have to go before */ -/* the bitmaps for C declaration-order reasons) */ -/* */ +////////////////////////////////////////////////////////////////////////////// +// +// GLYPH SHAPES (you probably don't need these, but they have to go before +// the bitmaps for C declaration-order reasons) +// -#ifndef STBTT_vmove /* you can predefine these to use different values (but why?) */ +#ifndef STBTT_vmove // you can predefine these to use different values (but why?) enum { STBTT_vmove=1, STBTT_vline, @@ -825,9 +825,9 @@ STBTT_DEF int stbtt_GetKerningTable(const stbtt_fontinfo *info, stbtt_kerningen }; #endif -#ifndef stbtt_vertex /* you can predefine this to use different values */ - /* (we share this with other code at RAD) */ - #define stbtt_vertex_type short /* can't use stbtt_int16 because that's not visible in the header file */ +#ifndef stbtt_vertex // you can predefine this to use different values + // (we share this with other code at RAD) + #define stbtt_vertex_type short // can't use stbtt_int16 because that's not visible in the header file typedef struct { stbtt_vertex_type x,y,cx,cy,cx1,cy1; @@ -836,76 +836,76 @@ STBTT_DEF int stbtt_GetKerningTable(const stbtt_fontinfo *info, stbtt_kerningen #endif STBTT_DEF int stbtt_IsGlyphEmpty(const stbtt_fontinfo *info, int glyph_index); -/* returns non-zero if nothing is drawn for this glyph */ +// returns non-zero if nothing is drawn for this glyph STBTT_DEF int stbtt_GetCodepointShape(const stbtt_fontinfo *info, int unicode_codepoint, stbtt_vertex **vertices); STBTT_DEF int stbtt_GetGlyphShape(const stbtt_fontinfo *info, int glyph_index, stbtt_vertex **vertices); -/* returns # of vertices and fills *vertices with the pointer to them */ -/* these are expressed in "unscaled" coordinates */ -/* */ -/* The shape is a series of contours. Each one starts with */ -/* a STBTT_moveto, then consists of a series of mixed */ -/* STBTT_lineto and STBTT_curveto segments. A lineto */ -/* draws a line from previous endpoint to its x,y; a curveto */ -/* draws a quadratic bezier from previous endpoint to */ -/* its x,y, using cx,cy as the bezier control point. */ +// returns # of vertices and fills *vertices with the pointer to them +// these are expressed in "unscaled" coordinates +// +// The shape is a series of contours. Each one starts with +// a STBTT_moveto, then consists of a series of mixed +// STBTT_lineto and STBTT_curveto segments. A lineto +// draws a line from previous endpoint to its x,y; a curveto +// draws a quadratic bezier from previous endpoint to +// its x,y, using cx,cy as the bezier control point. STBTT_DEF void stbtt_FreeShape(const stbtt_fontinfo *info, stbtt_vertex *vertices); -/* frees the data allocated above */ +// frees the data allocated above STBTT_DEF int stbtt_GetCodepointSVG(const stbtt_fontinfo *info, int unicode_codepoint, const char **svg); STBTT_DEF int stbtt_GetGlyphSVG(const stbtt_fontinfo *info, int gl, const char **svg); -/* fills svg with the character's SVG data. */ -/* returns data size or 0 if SVG not found. */ +// fills svg with the character's SVG data. +// returns data size or 0 if SVG not found. -/* //////////////////////////////////////////////////////////////////////////// */ -/* */ -/* BITMAP RENDERING */ -/* */ +////////////////////////////////////////////////////////////////////////////// +// +// BITMAP RENDERING +// STBTT_DEF void stbtt_FreeBitmap(unsigned char *bitmap, void *userdata); -/* frees the bitmap allocated below */ +// frees the bitmap allocated below STBTT_DEF unsigned char *stbtt_GetCodepointBitmap(const stbtt_fontinfo *info, float scale_x, float scale_y, int codepoint, int *width, int *height, int *xoff, int *yoff); -/* allocates a large-enough single-channel 8bpp bitmap and renders the */ -/* specified character/glyph at the specified scale into it, with */ -/* antialiasing. 0 is no coverage (transparent), 255 is fully covered (opaque). */ -/* *width & *height are filled out with the width & height of the bitmap, */ -/* which is stored left-to-right, top-to-bottom. */ -/* */ -/* xoff/yoff are the offset it pixel space from the glyph origin to the top-left of the bitmap */ +// allocates a large-enough single-channel 8bpp bitmap and renders the +// specified character/glyph at the specified scale into it, with +// antialiasing. 0 is no coverage (transparent), 255 is fully covered (opaque). +// *width & *height are filled out with the width & height of the bitmap, +// which is stored left-to-right, top-to-bottom. +// +// xoff/yoff are the offset it pixel space from the glyph origin to the top-left of the bitmap STBTT_DEF unsigned char *stbtt_GetCodepointBitmapSubpixel(const stbtt_fontinfo *info, float scale_x, float scale_y, float shift_x, float shift_y, int codepoint, int *width, int *height, int *xoff, int *yoff); -/* the same as stbtt_GetCodepoitnBitmap, but you can specify a subpixel */ -/* shift for the character */ +// the same as stbtt_GetCodepoitnBitmap, but you can specify a subpixel +// shift for the character STBTT_DEF void stbtt_MakeCodepointBitmap(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, int codepoint); -/* the same as stbtt_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 stbtt_GetCodepointBitmapBox to get the */ -/* width and height and positioning info for it first. */ +// the same as stbtt_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 stbtt_GetCodepointBitmapBox to get the +// width and height and positioning info for it first. STBTT_DEF void stbtt_MakeCodepointBitmapSubpixel(const stbtt_fontinfo *info, unsigned char *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 stbtt_MakeCodepointBitmap, but you can specify a subpixel */ -/* shift for the character */ +// same as stbtt_MakeCodepointBitmap, but you can specify a subpixel +// shift for the character STBTT_DEF void stbtt_MakeCodepointBitmapSubpixelPrefilter(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int oversample_x, int oversample_y, float *sub_x, float *sub_y, int codepoint); -/* same as stbtt_MakeCodepointBitmapSubpixel, but prefiltering */ -/* is performed (see stbtt_PackSetOversampling) */ +// same as stbtt_MakeCodepointBitmapSubpixel, but prefiltering +// is performed (see stbtt_PackSetOversampling) STBTT_DEF void stbtt_GetCodepointBitmapBox(const stbtt_fontinfo *font, int codepoint, float scale_x, float scale_y, int *ix0, int *iy0, int *ix1, int *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.) */ +// 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.) STBTT_DEF void stbtt_GetCodepointBitmapBoxSubpixel(const stbtt_fontinfo *font, int codepoint, float scale_x, float scale_y, float shift_x, float shift_y, int *ix0, int *iy0, int *ix1, int *iy1); -/* same as stbtt_GetCodepointBitmapBox, but you can specify a subpixel */ -/* shift for the character */ +// same as stbtt_GetCodepointBitmapBox, but you can specify a subpixel +// shift for the character -/* the following functions are equivalent to the above functions, but operate */ -/* on glyph indices instead of Unicode codepoints (for efficiency) */ +// the following functions are equivalent to the above functions, but operate +// on glyph indices instead of Unicode codepoints (for efficiency) STBTT_DEF unsigned char *stbtt_GetGlyphBitmap(const stbtt_fontinfo *info, float scale_x, float scale_y, int glyph, int *width, int *height, int *xoff, int *yoff); STBTT_DEF unsigned char *stbtt_GetGlyphBitmapSubpixel(const stbtt_fontinfo *info, float scale_x, float scale_y, float shift_x, float shift_y, int glyph, int *width, int *height, int *xoff, int *yoff); STBTT_DEF void stbtt_MakeGlyphBitmap(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, int glyph); @@ -915,135 +915,135 @@ STBTT_DEF void stbtt_GetGlyphBitmapBox(const stbtt_fontinfo *font, int glyph, fl STBTT_DEF void stbtt_GetGlyphBitmapBoxSubpixel(const stbtt_fontinfo *font, int glyph, float scale_x, float scale_y,float shift_x, float shift_y, int *ix0, int *iy0, int *ix1, int *iy1); -/* @TODO: don't expose this structure */ +// @TODO: don't expose this structure typedef struct { int w,h,stride; unsigned char *pixels; } stbtt__bitmap; -/* rasterize a shape with quadratic beziers into a bitmap */ -STBTT_DEF void stbtt_Rasterize(stbtt__bitmap *result, /* 1-channel bitmap to draw into */ - float flatness_in_pixels, /* allowable error of curve in pixels */ - stbtt_vertex *vertices, /* array of vertices defining shape */ - int num_verts, /* number of vertices in above array */ - float scale_x, float scale_y, /* scale applied to input vertices */ - float shift_x, float shift_y, /* translation applied to input vertices */ - int x_off, int y_off, /* another translation applied to input */ - int invert, /* if non-zero, vertically flip shape */ - void *userdata); /* context for to STBTT_MALLOC */ +// rasterize a shape with quadratic beziers into a bitmap +STBTT_DEF void stbtt_Rasterize(stbtt__bitmap *result, // 1-channel bitmap to draw into + float flatness_in_pixels, // allowable error of curve in pixels + stbtt_vertex *vertices, // array of vertices defining shape + int num_verts, // number of vertices in above array + float scale_x, float scale_y, // scale applied to input vertices + float shift_x, float shift_y, // translation applied to input vertices + int x_off, int y_off, // another translation applied to input + int invert, // if non-zero, vertically flip shape + void *userdata); // context for to STBTT_MALLOC -/* //////////////////////////////////////////////////////////////////////////// */ -/* */ -/* Signed Distance Function (or Field) rendering */ +////////////////////////////////////////////////////////////////////////////// +// +// Signed Distance Function (or Field) rendering STBTT_DEF void stbtt_FreeSDF(unsigned char *bitmap, void *userdata); -/* frees the SDF bitmap allocated below */ +// frees the SDF bitmap allocated below STBTT_DEF unsigned char * stbtt_GetGlyphSDF(const stbtt_fontinfo *info, float scale, int glyph, int padding, unsigned char onedge_value, float pixel_dist_scale, int *width, int *height, int *xoff, int *yoff); STBTT_DEF unsigned char * stbtt_GetCodepointSDF(const stbtt_fontinfo *info, float scale, int codepoint, int padding, unsigned char onedge_value, float pixel_dist_scale, int *width, int *height, int *xoff, int *yoff); -/* These functions compute a discretized SDF field for a single character, suitable for storing */ -/* in a single-channel texture, sampling with bilinear filtering, and testing against */ -/* larger than some threshold to produce scalable fonts. */ -/* info -- the font */ -/* scale -- controls the size of the resulting SDF bitmap, same as it would be creating a regular bitmap */ -/* glyph/codepoint -- the character to generate the SDF for */ -/* padding -- extra "pixels" around the character which are filled with the distance to the character (not 0), */ -/* which allows effects like bit outlines */ -/* onedge_value -- value 0-255 to test the SDF against to reconstruct the character (i.e. the isocontour of the character) */ -/* pixel_dist_scale -- what value the SDF should increase by when moving one SDF "pixel" away from the edge (on the 0..255 scale) */ -/* if positive, > onedge_value is inside; if negative, < onedge_value is inside */ -/* width,height -- output height & width of the SDF bitmap (including padding) */ -/* xoff,yoff -- output origin of the character */ -/* return value -- a 2D array of bytes 0..255, width*height in size */ -/* */ -/* pixel_dist_scale & onedge_value are a scale & bias that allows you to make */ -/* optimal use of the limited 0..255 for your application, trading off precision */ -/* and special effects. SDF values outside the range 0..255 are clamped to 0..255. */ -/* */ -/* Example: */ -/* scale = stbtt_ScaleForPixelHeight(22) */ -/* padding = 5 */ -/* onedge_value = 180 */ -/* pixel_dist_scale = 180/5.0 = 36.0 */ -/* */ -/* This will create an SDF bitmap in which the character is about 22 pixels */ -/* high but the whole bitmap is about 22+5+5=32 pixels high. To produce a filled */ -/* shape, sample the SDF at each pixel and fill the pixel if the SDF value */ -/* is greater than or equal to 180/255. (You'll actually want to antialias, */ -/* which is beyond the scope of this example.) Additionally, you can compute */ -/* offset outlines (e.g. to stroke the character border inside & outside, */ -/* or only outside). For example, to fill outside the character up to 3 SDF */ -/* pixels, you would compare against (180-36.0*3)/255 = 72/255. The above */ -/* choice of variables maps a range from 5 pixels outside the shape to */ -/* 2 pixels inside the shape to 0..255; this is intended primarily for apply */ -/* outside effects only (the interior range is needed to allow proper */ -/* antialiasing of the font at *smaller* sizes) */ -/* */ -/* The function computes the SDF analytically at each SDF pixel, not by e.g. */ -/* building a higher-res bitmap and approximating it. In theory the quality */ -/* should be as high as possible for an SDF of this size & representation, but */ -/* unclear if this is true in practice (perhaps building a higher-res bitmap */ -/* and computing from that can allow drop-out prevention). */ -/* */ -/* The algorithm has not been optimized at all, so expect it to be slow */ -/* if computing lots of characters or very large sizes. */ +// These functions compute a discretized SDF field for a single character, suitable for storing +// in a single-channel texture, sampling with bilinear filtering, and testing against +// larger than some threshold to produce scalable fonts. +// info -- the font +// scale -- controls the size of the resulting SDF bitmap, same as it would be creating a regular bitmap +// glyph/codepoint -- the character to generate the SDF for +// padding -- extra "pixels" around the character which are filled with the distance to the character (not 0), +// which allows effects like bit outlines +// onedge_value -- value 0-255 to test the SDF against to reconstruct the character (i.e. the isocontour of the character) +// pixel_dist_scale -- what value the SDF should increase by when moving one SDF "pixel" away from the edge (on the 0..255 scale) +// if positive, > onedge_value is inside; if negative, < onedge_value is inside +// width,height -- output height & width of the SDF bitmap (including padding) +// xoff,yoff -- output origin of the character +// return value -- a 2D array of bytes 0..255, width*height in size +// +// pixel_dist_scale & onedge_value are a scale & bias that allows you to make +// optimal use of the limited 0..255 for your application, trading off precision +// and special effects. SDF values outside the range 0..255 are clamped to 0..255. +// +// Example: +// scale = stbtt_ScaleForPixelHeight(22) +// padding = 5 +// onedge_value = 180 +// pixel_dist_scale = 180/5.0 = 36.0 +// +// This will create an SDF bitmap in which the character is about 22 pixels +// high but the whole bitmap is about 22+5+5=32 pixels high. To produce a filled +// shape, sample the SDF at each pixel and fill the pixel if the SDF value +// is greater than or equal to 180/255. (You'll actually want to antialias, +// which is beyond the scope of this example.) Additionally, you can compute +// offset outlines (e.g. to stroke the character border inside & outside, +// or only outside). For example, to fill outside the character up to 3 SDF +// pixels, you would compare against (180-36.0*3)/255 = 72/255. The above +// choice of variables maps a range from 5 pixels outside the shape to +// 2 pixels inside the shape to 0..255; this is intended primarily for apply +// outside effects only (the interior range is needed to allow proper +// antialiasing of the font at *smaller* sizes) +// +// The function computes the SDF analytically at each SDF pixel, not by e.g. +// building a higher-res bitmap and approximating it. In theory the quality +// should be as high as possible for an SDF of this size & representation, but +// unclear if this is true in practice (perhaps building a higher-res bitmap +// and computing from that can allow drop-out prevention). +// +// The algorithm has not been optimized at all, so expect it to be slow +// if computing lots of characters or very large sizes. -/* //////////////////////////////////////////////////////////////////////////// */ -/* */ -/* 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: */ -/* stbtt_FindMatchingFont() will use *case-sensitive* comparisons on */ -/* unicode-encoded names to try to find the font you want; */ -/* you can run this before calling stbtt_InitFont() */ -/* */ -/* stbtt_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 stbtt_InitFont() first. */ +////////////////////////////////////////////////////////////////////////////// +// +// 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: +// stbtt_FindMatchingFont() will use *case-sensitive* comparisons on +// unicode-encoded names to try to find the font you want; +// you can run this before calling stbtt_InitFont() +// +// stbtt_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 stbtt_InitFont() first. STBTT_DEF int stbtt_FindMatchingFont(const unsigned char *fontdata, const char *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 */ +// 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 #define STBTT_MACSTYLE_DONTCARE 0 #define STBTT_MACSTYLE_BOLD 1 #define STBTT_MACSTYLE_ITALIC 2 #define STBTT_MACSTYLE_UNDERSCORE 4 -#define STBTT_MACSTYLE_NONE 8 /* <= not same as 0, this makes us check the bitfield is 0 */ +#define STBTT_MACSTYLE_NONE 8 // <= not same as 0, this makes us check the bitfield is 0 STBTT_DEF int stbtt_CompareUTF8toUTF16_bigendian(const char *s1, int len1, const char *s2, int len2); -/* returns 1/0 whether the first string interpreted as utf8 is identical to */ -/* the second string interpreted as big-endian utf16... useful for strings from next func */ +// returns 1/0 whether the first string interpreted as utf8 is identical to +// the second string interpreted as big-endian utf16... useful for strings from next func STBTT_DEF const char *stbtt_GetFontNameString(const stbtt_fontinfo *font, int *length, int platformID, int encodingID, int languageID, int nameID); -/* returns the string (which may be big-endian double byte, e.g. for unicode) */ -/* and puts the length in bytes in *length. */ -/* */ -/* some of the values for the IDs are below; for more see the truetype spec: */ -/* http://developer.apple.com/textfonts/TTRefMan/RM06/Chap6name.html */ -/* http://www.microsoft.com/typography/otspec/name.htm */ +// returns the string (which may be big-endian double byte, e.g. for unicode) +// and puts the length in bytes in *length. +// +// some of the values for the IDs are below; for more see the truetype spec: +// http://developer.apple.com/textfonts/TTRefMan/RM06/Chap6name.html +// http://www.microsoft.com/typography/otspec/name.htm -enum { /* platformID */ +enum { // platformID STBTT_PLATFORM_ID_UNICODE =0, STBTT_PLATFORM_ID_MAC =1, STBTT_PLATFORM_ID_ISO =2, STBTT_PLATFORM_ID_MICROSOFT =3 }; -enum { /* encodingID for STBTT_PLATFORM_ID_UNICODE */ +enum { // encodingID for STBTT_PLATFORM_ID_UNICODE STBTT_UNICODE_EID_UNICODE_1_0 =0, STBTT_UNICODE_EID_UNICODE_1_1 =1, STBTT_UNICODE_EID_ISO_10646 =2, @@ -1051,22 +1051,22 @@ enum { /* encodingID for STBTT_PLATFORM_ID_UNICODE */ STBTT_UNICODE_EID_UNICODE_2_0_FULL=4 }; -enum { /* encodingID for STBTT_PLATFORM_ID_MICROSOFT */ +enum { // encodingID for STBTT_PLATFORM_ID_MICROSOFT STBTT_MS_EID_SYMBOL =0, STBTT_MS_EID_UNICODE_BMP =1, STBTT_MS_EID_SHIFTJIS =2, STBTT_MS_EID_UNICODE_FULL =10 }; -enum { /* encodingID for STBTT_PLATFORM_ID_MAC; same as Script Manager codes */ +enum { // encodingID for STBTT_PLATFORM_ID_MAC; same as Script Manager codes STBTT_MAC_EID_ROMAN =0, STBTT_MAC_EID_ARABIC =4, STBTT_MAC_EID_JAPANESE =1, STBTT_MAC_EID_HEBREW =5, STBTT_MAC_EID_CHINESE_TRAD =2, STBTT_MAC_EID_GREEK =6, STBTT_MAC_EID_KOREAN =3, STBTT_MAC_EID_RUSSIAN =7 }; -enum { /* languageID for STBTT_PLATFORM_ID_MICROSOFT; same as LCID... */ - /* problematic because there are e.g. 16 english LCIDs and 16 arabic LCIDs */ +enum { // languageID for STBTT_PLATFORM_ID_MICROSOFT; same as LCID... + // problematic because there are e.g. 16 english LCIDs and 16 arabic LCIDs STBTT_MS_LANG_ENGLISH =0x0409, STBTT_MS_LANG_ITALIAN =0x0410, STBTT_MS_LANG_CHINESE =0x0804, STBTT_MS_LANG_JAPANESE =0x0411, STBTT_MS_LANG_DUTCH =0x0413, STBTT_MS_LANG_KOREAN =0x0412, @@ -1075,7 +1075,7 @@ enum { /* languageID for STBTT_PLATFORM_ID_MICROSOFT; same as LCID... */ STBTT_MS_LANG_HEBREW =0x040d, STBTT_MS_LANG_SWEDISH =0x041D }; -enum { /* languageID for STBTT_PLATFORM_ID_MAC */ +enum { // languageID for STBTT_PLATFORM_ID_MAC STBTT_MAC_LANG_ENGLISH =0 , STBTT_MAC_LANG_JAPANESE =11, STBTT_MAC_LANG_ARABIC =12, STBTT_MAC_LANG_KOREAN =23, STBTT_MAC_LANG_DUTCH =4 , STBTT_MAC_LANG_RUSSIAN =32, @@ -1089,14 +1089,14 @@ enum { /* languageID for STBTT_PLATFORM_ID_MAC */ } #endif -#endif /* __STB_INCLUDE_STB_TRUETYPE_H__ */ +#endif // __STB_INCLUDE_STB_TRUETYPE_H__ -/* ///////////////////////////////////////////////////////////////////////////// */ -/* ///////////////////////////////////////////////////////////////////////////// */ -/* // */ -/* // IMPLEMENTATION */ -/* // */ -/* // */ +/////////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////////// +//// +//// IMPLEMENTATION +//// +//// #ifdef STB_TRUETYPE_IMPLEMENTATION @@ -1120,10 +1120,10 @@ typedef int stbtt__test_oversample_pow2[(STBTT_MAX_OVERSAMPLE & (STBTT_MAX_OVERS #define STBTT__NOTUSED(v) (void)sizeof(v) #endif -/* //////////////////////////////////////////////////////////////////////// */ -/* */ -/* stbtt__buf helpers to parse data from file */ -/* */ +////////////////////////////////////////////////////////////////////////// +// +// stbtt__buf helpers to parse data from file +// static stbtt_uint8 stbtt__buf_get8(stbtt__buf *b) { @@ -1266,13 +1266,13 @@ static stbtt__buf stbtt__cff_index_get(stbtt__buf b, int i) return stbtt__buf_range(&b, 2+(count+1)*offsize+start, end - start); } -/* //////////////////////////////////////////////////////////////////////// */ -/* */ -/* accessors to parse data from file */ -/* */ +////////////////////////////////////////////////////////////////////////// +// +// accessors to parse data from file +// -/* on platforms that don't allow misaligned reads, if we want to allow */ -/* truetype fonts that aren't padded to alignment, define ALLOW_UNALIGNED_TRUETYPE */ +// on platforms that don't allow misaligned reads, if we want to allow +// truetype fonts that aren't padded to alignment, define ALLOW_UNALIGNED_TRUETYPE #define ttBYTE(p) (* (stbtt_uint8 *) (p)) #define ttCHAR(p) (* (stbtt_int8 *) (p)) @@ -1288,16 +1288,16 @@ static stbtt_int32 ttLONG(stbtt_uint8 *p) { return (p[0]<<24) + (p[1]<<16) + static int stbtt__isfont(stbtt_uint8 *font) { - /* check the version number */ - if (stbtt_tag4(font, '1',0,0,0)) return 1; /* TrueType 1 */ - if (stbtt_tag(font, "typ1")) return 1; /* TrueType with type 1 font -- we don't support this! */ - if (stbtt_tag(font, "OTTO")) return 1; /* OpenType with CFF */ - if (stbtt_tag4(font, 0,1,0,0)) return 1; /* OpenType 1.0 */ - if (stbtt_tag(font, "true")) return 1; /* Apple specification for TrueType fonts */ + // check the version number + if (stbtt_tag4(font, '1',0,0,0)) return 1; // TrueType 1 + if (stbtt_tag(font, "typ1")) return 1; // TrueType with type 1 font -- we don't support this! + if (stbtt_tag(font, "OTTO")) return 1; // OpenType with CFF + if (stbtt_tag4(font, 0,1,0,0)) return 1; // OpenType 1.0 + if (stbtt_tag(font, "true")) return 1; // Apple specification for TrueType fonts return 0; } -/* @OPTIMIZE: binary search */ +// @OPTIMIZE: binary search static stbtt_uint32 stbtt__find_table(stbtt_uint8 *data, stbtt_uint32 fontstart, const char *tag) { stbtt_int32 num_tables = ttUSHORT(data+fontstart+4); @@ -1313,13 +1313,13 @@ static stbtt_uint32 stbtt__find_table(stbtt_uint8 *data, stbtt_uint32 fontstart, static int stbtt_GetFontOffsetForIndex_internal(unsigned char *font_collection, int index) { - /* if it's just a font, there's only one valid index */ + // if it's just a font, there's only one valid index if (stbtt__isfont(font_collection)) return index == 0 ? 0 : -1; - /* check if it's a TTC */ + // check if it's a TTC if (stbtt_tag(font_collection, "ttcf")) { - /* version 1? */ + // version 1? if (ttULONG(font_collection+4) == 0x00010000 || ttULONG(font_collection+4) == 0x00020000) { stbtt_int32 n = ttLONG(font_collection+8); if (index >= n) @@ -1332,13 +1332,13 @@ static int stbtt_GetFontOffsetForIndex_internal(unsigned char *font_collection, static int stbtt_GetNumberOfFonts_internal(unsigned char *font_collection) { - /* if it's just a font, there's only one valid font */ + // if it's just a font, there's only one valid font if (stbtt__isfont(font_collection)) return 1; - /* check if it's a TTC */ + // check if it's a TTC if (stbtt_tag(font_collection, "ttcf")) { - /* version 1? */ + // version 1? if (ttULONG(font_collection+4) == 0x00010000 || ttULONG(font_collection+4) == 0x00020000) { return ttLONG(font_collection+8); } @@ -1359,7 +1359,7 @@ static stbtt__buf stbtt__get_subrs(stbtt__buf cff, stbtt__buf fontdict) return stbtt__cff_get_index(&cff); } -/* since most people won't use this, find this table the first time it's needed */ +// since most people won't use this, find this table the first time it's needed static int stbtt__get_svg(stbtt_fontinfo *info) { stbtt_uint32 t; @@ -1384,22 +1384,22 @@ static int stbtt_InitFont_internal(stbtt_fontinfo *info, unsigned char *data, in info->fontstart = fontstart; info->cff = stbtt__new_buf(NULL, 0); - cmap = stbtt__find_table(data, fontstart, "cmap"); /* required */ - info->loca = stbtt__find_table(data, fontstart, "loca"); /* required */ - info->head = stbtt__find_table(data, fontstart, "head"); /* required */ - info->glyf = stbtt__find_table(data, fontstart, "glyf"); /* required */ - info->hhea = stbtt__find_table(data, fontstart, "hhea"); /* required */ - info->hmtx = stbtt__find_table(data, fontstart, "hmtx"); /* required */ - info->kern = stbtt__find_table(data, fontstart, "kern"); /* not required */ - info->gpos = stbtt__find_table(data, fontstart, "GPOS"); /* not required */ + cmap = stbtt__find_table(data, fontstart, "cmap"); // required + info->loca = stbtt__find_table(data, fontstart, "loca"); // required + info->head = stbtt__find_table(data, fontstart, "head"); // required + info->glyf = stbtt__find_table(data, fontstart, "glyf"); // required + info->hhea = stbtt__find_table(data, fontstart, "hhea"); // required + info->hmtx = stbtt__find_table(data, fontstart, "hmtx"); // required + info->kern = stbtt__find_table(data, fontstart, "kern"); // not required + info->gpos = stbtt__find_table(data, fontstart, "GPOS"); // not required if (!cmap || !info->head || !info->hhea || !info->hmtx) return 0; if (info->glyf) { - /* required for truetype */ + // required for truetype if (!info->loca) return 0; } else { - /* initialization for CFF / Type2 fonts (OTF) */ + // initialization for CFF / Type2 fonts (OTF) stbtt__buf b, topdict, topdictidx; stbtt_uint32 cstype = 2, charstrings = 0, fdarrayoff = 0, fdselectoff = 0; stbtt_uint32 cff; @@ -1410,20 +1410,20 @@ static int stbtt_InitFont_internal(stbtt_fontinfo *info, unsigned char *data, in info->fontdicts = stbtt__new_buf(NULL, 0); info->fdselect = stbtt__new_buf(NULL, 0); - /* @TODO this should use size from table (not 512MB) */ + // @TODO this should use size from table (not 512MB) info->cff = stbtt__new_buf(data+cff, 512*1024*1024); b = info->cff; - /* read the header */ + // read the header stbtt__buf_skip(&b, 2); - stbtt__buf_seek(&b, stbtt__buf_get8(&b)); /* hdrsize */ + stbtt__buf_seek(&b, stbtt__buf_get8(&b)); // hdrsize - /* @TODO the name INDEX could list multiple fonts, */ - /* but we just use the first one. */ - stbtt__cff_get_index(&b); /* name INDEX */ + // @TODO the name INDEX could list multiple fonts, + // but we just use the first one. + stbtt__cff_get_index(&b); // name INDEX topdictidx = stbtt__cff_get_index(&b); topdict = stbtt__cff_index_get(topdictidx, 0); - stbtt__cff_get_index(&b); /* string INDEX */ + stbtt__cff_get_index(&b); // string INDEX info->gsubrs = stbtt__cff_get_index(&b); stbtt__dict_get_ints(&topdict, 17, 1, &charstrings); @@ -1432,12 +1432,12 @@ static int stbtt_InitFont_internal(stbtt_fontinfo *info, unsigned char *data, in stbtt__dict_get_ints(&topdict, 0x100 | 37, 1, &fdselectoff); info->subrs = stbtt__get_subrs(b, topdict); - /* we only support Type 2 charstrings */ + // we only support Type 2 charstrings if (cstype != 2) return 0; if (charstrings == 0) return 0; if (fdarrayoff) { - /* looks like a CID font */ + // looks like a CID font if (!fdselectoff) return 0; stbtt__buf_seek(&b, fdarrayoff); info->fontdicts = stbtt__cff_get_index(&b); @@ -1456,27 +1456,27 @@ static int stbtt_InitFont_internal(stbtt_fontinfo *info, unsigned char *data, in info->svg = -1; - /* find a cmap encoding table we understand *now* to avoid searching */ - /* later. (todo: could make this installable) */ - /* the same regardless of glyph. */ + // find a cmap encoding table we understand *now* to avoid searching + // later. (todo: could make this installable) + // the same regardless of glyph. numTables = ttUSHORT(data + cmap + 2); info->index_map = 0; for (i=0; i < numTables; ++i) { stbtt_uint32 encoding_record = cmap + 4 + 8 * i; - /* find an encoding we understand: */ + // find an encoding we understand: switch(ttUSHORT(data+encoding_record)) { case STBTT_PLATFORM_ID_MICROSOFT: switch (ttUSHORT(data+encoding_record+2)) { case STBTT_MS_EID_UNICODE_BMP: case STBTT_MS_EID_UNICODE_FULL: - /* MS/Unicode */ + // MS/Unicode info->index_map = cmap + ttULONG(data+encoding_record+4); break; } break; case STBTT_PLATFORM_ID_UNICODE: - /* Mac/iOS has these */ - /* all the encodingIDs are unicode, so we don't bother to check it */ + // Mac/iOS has these + // all the encodingIDs are unicode, so we don't bother to check it info->index_map = cmap + ttULONG(data+encoding_record+4); break; } @@ -1494,7 +1494,7 @@ STBTT_DEF int stbtt_FindGlyphIndex(const stbtt_fontinfo *info, int unicode_codep stbtt_uint32 index_map = info->index_map; stbtt_uint16 format = ttUSHORT(data + index_map + 0); - if (format == 0) { /* apple byte encoding */ + if (format == 0) { // apple byte encoding stbtt_int32 bytes = ttUSHORT(data + index_map + 2); if (unicode_codepoint < bytes-6) return ttBYTE(data + index_map + 6 + unicode_codepoint); @@ -1506,27 +1506,27 @@ STBTT_DEF int stbtt_FindGlyphIndex(const stbtt_fontinfo *info, int unicode_codep return ttUSHORT(data + index_map + 10 + (unicode_codepoint - first)*2); return 0; } else if (format == 2) { - STBTT_assert(0); /* @TODO: high-byte mapping for japanese/chinese/korean */ + STBTT_assert(0); // @TODO: high-byte mapping for japanese/chinese/korean return 0; - } else if (format == 4) { /* standard mapping for windows fonts: binary search collection of ranges */ + } else if (format == 4) { // standard mapping for windows fonts: binary search collection of ranges stbtt_uint16 segcount = ttUSHORT(data+index_map+6) >> 1; stbtt_uint16 searchRange = ttUSHORT(data+index_map+8) >> 1; stbtt_uint16 entrySelector = ttUSHORT(data+index_map+10); stbtt_uint16 rangeShift = ttUSHORT(data+index_map+12) >> 1; - /* do a binary search of the segments */ + // do a binary search of the segments stbtt_uint32 endCount = index_map + 14; stbtt_uint32 search = endCount; if (unicode_codepoint > 0xffff) return 0; - /* they lie from endCount .. endCount + segCount */ - /* but searchRange is the nearest power of two, so... */ + // they lie from endCount .. endCount + segCount + // but searchRange is the nearest power of two, so... if (unicode_codepoint >= ttUSHORT(data + search + rangeShift*2)) search += rangeShift*2; - /* now decrement to bias correctly to find smallest */ + // now decrement to bias correctly to find smallest search -= 2; while (entrySelector) { stbtt_uint16 end; @@ -1557,9 +1557,9 @@ STBTT_DEF int stbtt_FindGlyphIndex(const stbtt_fontinfo *info, int unicode_codep stbtt_uint32 ngroups = ttULONG(data+index_map+12); stbtt_int32 low,high; low = 0; high = (stbtt_int32)ngroups; - /* Binary search the right group. */ + // Binary search the right group. while (low < high) { - stbtt_int32 mid = low + ((high-low) >> 1); /* rounds down, so low <= mid < high */ + stbtt_int32 mid = low + ((high-low) >> 1); // rounds down, so low <= mid < high stbtt_uint32 start_char = ttULONG(data+index_map+16+mid*12); stbtt_uint32 end_char = ttULONG(data+index_map+16+mid*12+4); if ((stbtt_uint32) unicode_codepoint < start_char) @@ -1570,13 +1570,13 @@ STBTT_DEF int stbtt_FindGlyphIndex(const stbtt_fontinfo *info, int unicode_codep stbtt_uint32 start_glyph = ttULONG(data+index_map+16+mid*12+8); if (format == 12) return start_glyph + unicode_codepoint-start_char; - else /* format == 13 */ + else // format == 13 return start_glyph; } } - return 0; /* not found */ + return 0; // not found } - /* @TODO */ + // @TODO STBTT_assert(0); return 0; } @@ -1601,8 +1601,8 @@ static int stbtt__GetGlyfOffset(const stbtt_fontinfo *info, int glyph_index) STBTT_assert(!info->cff.size); - if (glyph_index >= info->numGlyphs) return -1; /* glyph index out of range */ - if (info->indexToLocFormat >= 2) return -1; /* unknown index->glyph map format */ + if (glyph_index >= info->numGlyphs) return -1; // glyph index out of range + if (info->indexToLocFormat >= 2) return -1; // unknown index->glyph map format if (info->indexToLocFormat == 0) { g1 = info->glyf + ttUSHORT(info->data + info->loca + glyph_index * 2) * 2; @@ -1612,7 +1612,7 @@ static int stbtt__GetGlyfOffset(const stbtt_fontinfo *info, int glyph_index) g2 = info->glyf + ttULONG (info->data + info->loca + glyph_index * 4 + 4); } - return g1==g2 ? -1 : g1; /* if length is 0, return -1 */ + return g1==g2 ? -1 : g1; // if length is 0, return -1 } static int stbtt__GetGlyphInfoT2(const stbtt_fontinfo *info, int glyph_index, int *x0, int *y0, int *x1, int *y1); @@ -1692,7 +1692,7 @@ static int stbtt__GetGlyphShapeTT(const stbtt_fontinfo *info, int glyph_index, s n = 1+ttUSHORT(endPtsOfContours + numberOfContours*2-2); - m = n + 2*numberOfContours; /* a loose bound on how many vertices we might need */ + m = n + 2*numberOfContours; // a loose bound on how many vertices we might need vertices = (stbtt_vertex *) STBTT_malloc(m * sizeof(vertices[0]), info->userdata); if (vertices == 0) return 0; @@ -1700,13 +1700,13 @@ static int stbtt__GetGlyphShapeTT(const stbtt_fontinfo *info, int glyph_index, s next_move = 0; flagcount=0; - /* in first pass, we load uninterpreted data into the allocated array */ - /* above, shifted to the end of the array so we won't overwrite it when */ - /* we create our final data starting from the front */ + // in first pass, we load uninterpreted data into the allocated array + // above, shifted to the end of the array so we won't overwrite it when + // we create our final data starting from the front - off = m - n; /* starting offset for uninterpreted data, regardless of how m ends up being calculated */ + off = m - n; // starting offset for uninterpreted data, regardless of how m ends up being calculated - /* first load flags */ + // first load flags for (i=0; i < n; ++i) { if (flagcount == 0) { @@ -1718,13 +1718,13 @@ static int stbtt__GetGlyphShapeTT(const stbtt_fontinfo *info, int glyph_index, s vertices[off+i].type = flags; } - /* now load x coordinates */ + // now load x coordinates x=0; for (i=0; i < n; ++i) { flags = vertices[off+i].type; if (flags & 2) { stbtt_int16 dx = *points++; - x += (flags & 16) ? dx : -dx; /* ??? */ + x += (flags & 16) ? dx : -dx; // ??? } else { if (!(flags & 16)) { x = x + (stbtt_int16) (points[0]*256 + points[1]); @@ -1734,13 +1734,13 @@ static int stbtt__GetGlyphShapeTT(const stbtt_fontinfo *info, int glyph_index, s vertices[off+i].x = (stbtt_int16) x; } - /* now load y coordinates */ + // now load y coordinates y=0; for (i=0; i < n; ++i) { flags = vertices[off+i].type; if (flags & 4) { stbtt_int16 dy = *points++; - y += (flags & 32) ? dy : -dy; /* ??? */ + y += (flags & 32) ? dy : -dy; // ??? } else { if (!(flags & 32)) { y = y + (stbtt_int16) (points[0]*256 + points[1]); @@ -1750,7 +1750,7 @@ static int stbtt__GetGlyphShapeTT(const stbtt_fontinfo *info, int glyph_index, s vertices[off+i].y = (stbtt_int16) y; } - /* now convert them to our format */ + // now convert them to our format num_vertices=0; sx = sy = cx = cy = scx = scy = 0; for (i=0; i < n; ++i) { @@ -1762,22 +1762,22 @@ static int stbtt__GetGlyphShapeTT(const stbtt_fontinfo *info, int glyph_index, s if (i != 0) num_vertices = stbtt__close_shape(vertices, num_vertices, was_off, start_off, sx,sy,scx,scy,cx,cy); - /* now start the new one */ + // now start the new one start_off = !(flags & 1); if (start_off) { - /* if we start off with an off-curve point, then when we need to find a point on the curve */ - /* where we can start, and we need to save some state for when we wraparound. */ + // if we start off with an off-curve point, then when we need to find a point on the curve + // where we can start, and we need to save some state for when we wraparound. scx = x; scy = y; if (!(vertices[off+i+1].type & 1)) { - /* next point is also a curve point, so interpolate an on-point curve */ + // next point is also a curve point, so interpolate an on-point curve sx = (x + (stbtt_int32) vertices[off+i+1].x) >> 1; sy = (y + (stbtt_int32) vertices[off+i+1].y) >> 1; } else { - /* otherwise just use the next point as our start point */ + // otherwise just use the next point as our start point sx = (stbtt_int32) vertices[off+i+1].x; sy = (stbtt_int32) vertices[off+i+1].y; - ++i; /* we're using point i+1 as the starting point, so skip it */ + ++i; // we're using point i+1 as the starting point, so skip it } } else { sx = x; @@ -1788,8 +1788,8 @@ static int stbtt__GetGlyphShapeTT(const stbtt_fontinfo *info, int glyph_index, s next_move = 1 + ttUSHORT(endPtsOfContours+j*2); ++j; } else { - if (!(flags & 1)) { /* if it's a curve */ - if (was_off) /* two off-curve control points in a row means interpolate an on-curve midpoint */ + if (!(flags & 1)) { // if it's a curve + if (was_off) // two off-curve control points in a row means interpolate an on-curve midpoint stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve, (cx+x)>>1, (cy+y)>>1, cx, cy); cx = x; cy = y; @@ -1805,7 +1805,7 @@ static int stbtt__GetGlyphShapeTT(const stbtt_fontinfo *info, int glyph_index, s } num_vertices = stbtt__close_shape(vertices, num_vertices, was_off, start_off, sx,sy,scx,scy,cx,cy); } else if (numberOfContours < 0) { - /* Compound shapes. */ + // Compound shapes. int more = 1; stbtt_uint8 *comp = data + g + 10; num_vertices = 0; @@ -1819,8 +1819,8 @@ static int stbtt__GetGlyphShapeTT(const stbtt_fontinfo *info, int glyph_index, s flags = ttSHORT(comp); comp+=2; gidx = ttSHORT(comp); comp+=2; - if (flags & 2) { /* XY values */ - if (flags & 1) { /* shorts */ + if (flags & 2) { // XY values + if (flags & 1) { // shorts mtx[4] = ttSHORT(comp); comp+=2; mtx[5] = ttSHORT(comp); comp+=2; } else { @@ -1829,31 +1829,31 @@ static int stbtt__GetGlyphShapeTT(const stbtt_fontinfo *info, int glyph_index, s } } else { - /* @TODO handle matching point */ + // @TODO handle matching point STBTT_assert(0); } - if (flags & (1<<3)) { /* WE_HAVE_A_SCALE */ + if (flags & (1<<3)) { // WE_HAVE_A_SCALE mtx[0] = mtx[3] = ttSHORT(comp)/16384.0f; comp+=2; mtx[1] = mtx[2] = 0; - } else if (flags & (1<<6)) { /* WE_HAVE_AN_X_AND_YSCALE */ + } else if (flags & (1<<6)) { // WE_HAVE_AN_X_AND_YSCALE mtx[0] = ttSHORT(comp)/16384.0f; comp+=2; mtx[1] = mtx[2] = 0; mtx[3] = ttSHORT(comp)/16384.0f; comp+=2; - } else if (flags & (1<<7)) { /* WE_HAVE_A_TWO_BY_TWO */ + } else if (flags & (1<<7)) { // WE_HAVE_A_TWO_BY_TWO mtx[0] = ttSHORT(comp)/16384.0f; comp+=2; mtx[1] = ttSHORT(comp)/16384.0f; comp+=2; mtx[2] = ttSHORT(comp)/16384.0f; comp+=2; mtx[3] = ttSHORT(comp)/16384.0f; comp+=2; } - /* Find transformation scales. */ + // Find transformation scales. m = (float) STBTT_sqrt(mtx[0]*mtx[0] + mtx[1]*mtx[1]); n = (float) STBTT_sqrt(mtx[2]*mtx[2] + mtx[3]*mtx[3]); - /* Get indexed glyph. */ + // Get indexed glyph. comp_num_verts = stbtt_GetGlyphShape(info, gidx, &comp_verts); if (comp_num_verts > 0) { - /* Transform vertices. */ + // Transform vertices. for (i = 0; i < comp_num_verts; ++i) { stbtt_vertex* v = &comp_verts[i]; stbtt_vertex_type x,y; @@ -1864,7 +1864,7 @@ static int stbtt__GetGlyphShapeTT(const stbtt_fontinfo *info, int glyph_index, s v->cx = (stbtt_vertex_type)(m * (mtx[0]*x + mtx[2]*y + mtx[4])); v->cy = (stbtt_vertex_type)(n * (mtx[1]*x + mtx[3]*y + mtx[5])); } - /* Append vertices. */ + // Append vertices. tmp = (stbtt_vertex*)STBTT_malloc((num_vertices+comp_num_verts)*sizeof(stbtt_vertex), info->userdata); if (!tmp) { if (vertices) STBTT_free(vertices, info->userdata); @@ -1878,11 +1878,11 @@ static int stbtt__GetGlyphShapeTT(const stbtt_fontinfo *info, int glyph_index, s STBTT_free(comp_verts, info->userdata); num_vertices += comp_num_verts; } - /* More components ? */ + // More components ? more = flags & (1<<5); } } else { - /* numberOfCounters == 0, do nothing */ + // numberOfCounters == 0, do nothing } *pvertices = vertices; @@ -1982,7 +1982,7 @@ static stbtt__buf stbtt__cid_get_glyph_subrs(const stbtt_fontinfo *info, int gly stbtt__buf_seek(&fdselect, 0); fmt = stbtt__buf_get8(&fdselect); if (fmt == 0) { - /* untested */ + // untested stbtt__buf_skip(&fdselect, glyph_index); fdselector = stbtt__buf_get8(&fdselect); } else if (fmt == 3) { @@ -2012,58 +2012,58 @@ static int stbtt__run_charstring(const stbtt_fontinfo *info, int glyph_index, st #define STBTT__CSERR(s) (0) - /* this currently ignores the initial width value, which isn't needed if we have hmtx */ + // this currently ignores the initial width value, which isn't needed if we have hmtx b = stbtt__cff_index_get(info->charstrings, glyph_index); while (b.cursor < b.size) { i = 0; clear_stack = 1; b0 = stbtt__buf_get8(&b); switch (b0) { - /* @TODO implement hinting */ - case 0x13: /* hintmask */ - case 0x14: /* cntrmask */ + // @TODO implement hinting + case 0x13: // hintmask + case 0x14: // cntrmask if (in_header) - maskbits += (sp / 2); /* implicit "vstem" */ + maskbits += (sp / 2); // implicit "vstem" in_header = 0; stbtt__buf_skip(&b, (maskbits + 7) / 8); break; - case 0x01: /* hstem */ - case 0x03: /* vstem */ - case 0x12: /* hstemhm */ - case 0x17: /* vstemhm */ + case 0x01: // hstem + case 0x03: // vstem + case 0x12: // hstemhm + case 0x17: // vstemhm maskbits += (sp / 2); break; - case 0x15: /* rmoveto */ + case 0x15: // rmoveto in_header = 0; if (sp < 2) return STBTT__CSERR("rmoveto stack"); stbtt__csctx_rmove_to(c, s[sp-2], s[sp-1]); break; - case 0x04: /* vmoveto */ + case 0x04: // vmoveto in_header = 0; if (sp < 1) return STBTT__CSERR("vmoveto stack"); stbtt__csctx_rmove_to(c, 0, s[sp-1]); break; - case 0x16: /* hmoveto */ + case 0x16: // hmoveto in_header = 0; if (sp < 1) return STBTT__CSERR("hmoveto stack"); stbtt__csctx_rmove_to(c, s[sp-1], 0); break; - case 0x05: /* rlineto */ + case 0x05: // rlineto if (sp < 2) return STBTT__CSERR("rlineto stack"); for (; i + 1 < sp; i += 2) stbtt__csctx_rline_to(c, s[i], s[i+1]); break; - /* hlineto/vlineto and vhcurveto/hvcurveto alternate horizontal and vertical */ - /* starting from a different place. */ + // hlineto/vlineto and vhcurveto/hvcurveto alternate horizontal and vertical + // starting from a different place. - case 0x07: /* vlineto */ + case 0x07: // vlineto if (sp < 1) return STBTT__CSERR("vlineto stack"); goto vlineto; - case 0x06: /* hlineto */ + case 0x06: // hlineto if (sp < 1) return STBTT__CSERR("hlineto stack"); for (;;) { if (i >= sp) break; @@ -2076,10 +2076,10 @@ static int stbtt__run_charstring(const stbtt_fontinfo *info, int glyph_index, st } break; - case 0x1F: /* hvcurveto */ + case 0x1F: // hvcurveto if (sp < 4) return STBTT__CSERR("hvcurveto stack"); goto hvcurveto; - case 0x1E: /* vhcurveto */ + case 0x1E: // vhcurveto if (sp < 4) return STBTT__CSERR("vhcurveto stack"); for (;;) { if (i + 3 >= sp) break; @@ -2092,13 +2092,13 @@ static int stbtt__run_charstring(const stbtt_fontinfo *info, int glyph_index, st } break; - case 0x08: /* rrcurveto */ + case 0x08: // rrcurveto if (sp < 6) return STBTT__CSERR("rcurveline stack"); for (; i + 5 < sp; i += 6) stbtt__csctx_rccurve_to(c, s[i], s[i+1], s[i+2], s[i+3], s[i+4], s[i+5]); break; - case 0x18: /* rcurveline */ + case 0x18: // rcurveline if (sp < 8) return STBTT__CSERR("rcurveline stack"); for (; i + 5 < sp - 2; i += 6) stbtt__csctx_rccurve_to(c, s[i], s[i+1], s[i+2], s[i+3], s[i+4], s[i+5]); @@ -2106,7 +2106,7 @@ static int stbtt__run_charstring(const stbtt_fontinfo *info, int glyph_index, st stbtt__csctx_rline_to(c, s[i], s[i+1]); break; - case 0x19: /* rlinecurve */ + case 0x19: // rlinecurve if (sp < 8) return STBTT__CSERR("rlinecurve stack"); for (; i + 1 < sp - 6; i += 2) stbtt__csctx_rline_to(c, s[i], s[i+1]); @@ -2114,8 +2114,8 @@ static int stbtt__run_charstring(const stbtt_fontinfo *info, int glyph_index, st stbtt__csctx_rccurve_to(c, s[i], s[i+1], s[i+2], s[i+3], s[i+4], s[i+5]); break; - case 0x1A: /* vvcurveto */ - case 0x1B: /* hhcurveto */ + case 0x1A: // vvcurveto + case 0x1B: // hhcurveto if (sp < 4) return STBTT__CSERR("(vv|hh)curveto stack"); f = 0.0; if (sp & 1) { f = s[i]; i++; } @@ -2128,14 +2128,14 @@ static int stbtt__run_charstring(const stbtt_fontinfo *info, int glyph_index, st } break; - case 0x0A: /* callsubr */ + case 0x0A: // callsubr if (!has_subrs) { if (info->fdselect.size) subrs = stbtt__cid_get_glyph_subrs(info, glyph_index); has_subrs = 1; } - /* fallthrough */ - case 0x1D: /* callgsubr */ + // fallthrough + case 0x1D: // callgsubr if (sp < 1) return STBTT__CSERR("call(g|)subr stack"); v = (int) s[--sp]; if (subr_stack_height >= 10) return STBTT__CSERR("recursion limit"); @@ -2146,24 +2146,24 @@ static int stbtt__run_charstring(const stbtt_fontinfo *info, int glyph_index, st clear_stack = 0; break; - case 0x0B: /* return */ + case 0x0B: // return if (subr_stack_height <= 0) return STBTT__CSERR("return outside subr"); b = subr_stack[--subr_stack_height]; clear_stack = 0; break; - case 0x0E: /* endchar */ + case 0x0E: // endchar stbtt__csctx_close_shape(c); return 1; - case 0x0C: { /* two-byte escape */ + case 0x0C: { // two-byte escape float dx1, dx2, dx3, dx4, dx5, dx6, dy1, dy2, dy3, dy4, dy5, dy6; float dx, dy; int b1 = stbtt__buf_get8(&b); switch (b1) { - /* @TODO These "flex" implementations ignore the flex-depth and resolution, */ - /* and always draw beziers. */ - case 0x22: /* hflex */ + // @TODO These "flex" implementations ignore the flex-depth and resolution, + // and always draw beziers. + case 0x22: // hflex if (sp < 7) return STBTT__CSERR("hflex stack"); dx1 = s[0]; dx2 = s[1]; @@ -2176,7 +2176,7 @@ static int stbtt__run_charstring(const stbtt_fontinfo *info, int glyph_index, st stbtt__csctx_rccurve_to(c, dx4, 0, dx5, -dy2, dx6, 0); break; - case 0x23: /* flex */ + case 0x23: // flex if (sp < 13) return STBTT__CSERR("flex stack"); dx1 = s[0]; dy1 = s[1]; @@ -2190,12 +2190,12 @@ static int stbtt__run_charstring(const stbtt_fontinfo *info, int glyph_index, st dy5 = s[9]; dx6 = s[10]; dy6 = s[11]; - /* fd is s[12] */ + //fd is s[12] stbtt__csctx_rccurve_to(c, dx1, dy1, dx2, dy2, dx3, dy3); stbtt__csctx_rccurve_to(c, dx4, dy4, dx5, dy5, dx6, dy6); break; - case 0x24: /* hflex1 */ + case 0x24: // hflex1 if (sp < 9) return STBTT__CSERR("hflex1 stack"); dx1 = s[0]; dy1 = s[1]; @@ -2210,7 +2210,7 @@ static int stbtt__run_charstring(const stbtt_fontinfo *info, int glyph_index, st stbtt__csctx_rccurve_to(c, dx4, 0, dx5, dy5, dx6, -(dy1+dy2+dy5)); break; - case 0x25: /* flex1 */ + case 0x25: // flex1 if (sp < 11) return STBTT__CSERR("flex1 stack"); dx1 = s[0]; dy1 = s[1]; @@ -2242,7 +2242,7 @@ static int stbtt__run_charstring(const stbtt_fontinfo *info, int glyph_index, st if (b0 != 255 && b0 != 28 && (b0 < 32 || b0 > 254)) return STBTT__CSERR("reserved operator"); - /* push immediate */ + // push immediate if (b0 == 255) { f = (float)(stbtt_int32)stbtt__buf_get32(&b) / 0x10000; } else { @@ -2263,7 +2263,7 @@ static int stbtt__run_charstring(const stbtt_fontinfo *info, int glyph_index, st static int stbtt__GetGlyphShapeT2(const stbtt_fontinfo *info, int glyph_index, stbtt_vertex **pvertices) { - /* runs the charstring twice, once to count and once to output (to avoid realloc) */ + // runs the charstring twice, once to count and once to output (to avoid realloc) stbtt__csctx count_ctx = STBTT__CSCTX_INIT(1); stbtt__csctx output_ctx = STBTT__CSCTX_INIT(0); if (stbtt__run_charstring(info, glyph_index, &count_ctx)) { @@ -2313,12 +2313,12 @@ STBTT_DEF int stbtt_GetKerningTableLength(const stbtt_fontinfo *info) { stbtt_uint8 *data = info->data + info->kern; - /* we only look at the first table. it must be 'horizontal' and format 0. */ + // we only look at the first table. it must be 'horizontal' and format 0. if (!info->kern) return 0; - if (ttUSHORT(data+2) < 1) /* number of tables, need at least 1 */ + if (ttUSHORT(data+2) < 1) // number of tables, need at least 1 return 0; - if (ttUSHORT(data+8) != 1) /* horizontal flag must be set in format */ + if (ttUSHORT(data+8) != 1) // horizontal flag must be set in format return 0; return ttUSHORT(data+10); @@ -2329,12 +2329,12 @@ STBTT_DEF int stbtt_GetKerningTable(const stbtt_fontinfo *info, stbtt_kerningent stbtt_uint8 *data = info->data + info->kern; int k, length; - /* we only look at the first table. it must be 'horizontal' and format 0. */ + // we only look at the first table. it must be 'horizontal' and format 0. if (!info->kern) return 0; - if (ttUSHORT(data+2) < 1) /* number of tables, need at least 1 */ + if (ttUSHORT(data+2) < 1) // number of tables, need at least 1 return 0; - if (ttUSHORT(data+8) != 1) /* horizontal flag must be set in format */ + if (ttUSHORT(data+8) != 1) // horizontal flag must be set in format return 0; length = ttUSHORT(data+10); @@ -2357,12 +2357,12 @@ static int stbtt__GetGlyphKernInfoAdvance(const stbtt_fontinfo *info, int glyph stbtt_uint32 needle, straw; int l, r, m; - /* we only look at the first table. it must be 'horizontal' and format 0. */ + // we only look at the first table. it must be 'horizontal' and format 0. if (!info->kern) return 0; - if (ttUSHORT(data+2) < 1) /* number of tables, need at least 1 */ + if (ttUSHORT(data+2) < 1) // number of tables, need at least 1 return 0; - if (ttUSHORT(data+8) != 1) /* horizontal flag must be set in format */ + if (ttUSHORT(data+8) != 1) // horizontal flag must be set in format return 0; l = 0; @@ -2370,7 +2370,7 @@ static int stbtt__GetGlyphKernInfoAdvance(const stbtt_fontinfo *info, int glyph needle = glyph1 << 16 | glyph2; while (l <= r) { m = (l + r) >> 1; - straw = ttULONG(data+18+(m*6)); /* note: unaligned read */ + straw = ttULONG(data+18+(m*6)); // note: unaligned read if (needle < straw) r = m - 1; else if (needle > straw) @@ -2388,7 +2388,7 @@ static stbtt_int32 stbtt__GetCoverageIndex(stbtt_uint8 *coverageTable, int glyp case 1: { stbtt_uint16 glyphCount = ttUSHORT(coverageTable + 2); - /* Binary search. */ + // Binary search. stbtt_int32 l=0, r=glyphCount-1, m; int straw, needle=glyph; while (l <= r) { @@ -2411,7 +2411,7 @@ static stbtt_int32 stbtt__GetCoverageIndex(stbtt_uint8 *coverageTable, int glyp stbtt_uint16 rangeCount = ttUSHORT(coverageTable + 2); stbtt_uint8 *rangeArray = coverageTable + 4; - /* Binary search. */ + // Binary search. stbtt_int32 l=0, r=rangeCount-1, m; int strawStart, strawEnd, needle=glyph; while (l <= r) { @@ -2432,7 +2432,7 @@ static stbtt_int32 stbtt__GetCoverageIndex(stbtt_uint8 *coverageTable, int glyp } break; default: { - /* There are no other cases. */ + // There are no other cases. STBTT_assert(0); } break; } @@ -2460,7 +2460,7 @@ static stbtt_int32 stbtt__GetGlyphClass(stbtt_uint8 *classDefTable, int glyph) stbtt_uint16 classRangeCount = ttUSHORT(classDefTable + 2); stbtt_uint8 *classRangeRecords = classDefTable + 4; - /* Binary search. */ + // Binary search. stbtt_int32 l=0, r=classRangeCount-1, m; int strawStart, strawEnd, needle=glyph; while (l <= r) { @@ -2481,7 +2481,7 @@ static stbtt_int32 stbtt__GetGlyphClass(stbtt_uint8 *classDefTable, int glyph) } break; default: { - /* There are no other cases. */ + // There are no other cases. STBTT_assert(0); } break; } @@ -2489,7 +2489,7 @@ static stbtt_int32 stbtt__GetGlyphClass(stbtt_uint8 *classDefTable, int glyph) return -1; } -/* Define to STBTT_assert(x) if you want to break on unimplemented formats. */ +// Define to STBTT_assert(x) if you want to break on unimplemented formats. #define STBTT_GPOS_TODO_assert(x) static stbtt_int32 stbtt__GetGlyphGPOSInfoAdvance(const stbtt_fontinfo *info, int glyph1, int glyph2) @@ -2504,8 +2504,8 @@ static stbtt_int32 stbtt__GetGlyphGPOSInfoAdvance(const stbtt_fontinfo *info, i data = info->data + info->gpos; - if (ttUSHORT(data+0) != 1) return 0; /* Major version 1 */ - if (ttUSHORT(data+2) != 0) return 0; /* Minor version 0 */ + if (ttUSHORT(data+0) != 1) return 0; // Major version 1 + if (ttUSHORT(data+2) != 0) return 0; // Minor version 0 lookupListOffset = ttUSHORT(data+8); lookupList = data + lookupListOffset; @@ -2519,7 +2519,7 @@ static stbtt_int32 stbtt__GetGlyphGPOSInfoAdvance(const stbtt_fontinfo *info, i stbtt_uint16 subTableCount = ttUSHORT(lookupTable + 4); stbtt_uint8 *subTableOffsets = lookupTable + 6; switch(lookupType) { - case 2: { /* Pair Adjustment Positioning Subtable */ + case 2: { // Pair Adjustment Positioning Subtable stbtt_int32 sti; for (sti=0; stikern && !info->gpos) /* if no kerning table, don't waste time looking up both codepoint->glyphs */ + if (!info->kern && !info->gpos) // if no kerning table, don't waste time looking up both codepoint->glyphs return 0; return stbtt_GetGlyphKernAdvance(info, stbtt_FindGlyphIndex(info,ch1), stbtt_FindGlyphIndex(info,ch2)); } @@ -2726,22 +2726,22 @@ STBTT_DEF int stbtt_GetCodepointSVG(const stbtt_fontinfo *info, int unicode_code return stbtt_GetGlyphSVG(info, stbtt_FindGlyphIndex(info, unicode_codepoint), svg); } -/* //////////////////////////////////////////////////////////////////////////// */ -/* */ -/* antialiasing software rasterizer */ -/* */ +////////////////////////////////////////////////////////////////////////////// +// +// antialiasing software rasterizer +// STBTT_DEF void stbtt_GetGlyphBitmapBoxSubpixel(const stbtt_fontinfo *font, int glyph, float scale_x, float scale_y,float shift_x, float shift_y, int *ix0, int *iy0, int *ix1, int *iy1) { - int x0=0,y0=0,x1,y1; /* =0 suppresses compiler warning */ + int x0=0,y0=0,x1,y1; // =0 suppresses compiler warning if (!stbtt_GetGlyphBox(font, glyph, &x0,&y0,&x1,&y1)) { - /* e.g. space character */ + // e.g. space character if (ix0) *ix0 = 0; if (iy0) *iy0 = 0; if (ix1) *ix1 = 0; if (iy1) *iy1 = 0; } else { - /* move to integral bboxes (treating pixels as little squares, what pixels get touched)? */ + // move to integral bboxes (treating pixels as little squares, what pixels get touched)? if (ix0) *ix0 = STBTT_ifloor( x0 * scale_x + shift_x); if (iy0) *iy0 = STBTT_ifloor(-y1 * scale_y + shift_y); if (ix1) *ix1 = STBTT_iceil ( x1 * scale_x + shift_x); @@ -2764,9 +2764,9 @@ STBTT_DEF void stbtt_GetCodepointBitmapBox(const stbtt_fontinfo *font, int codep stbtt_GetCodepointBitmapBoxSubpixel(font, codepoint, scale_x, scale_y,0.0f,0.0f, ix0,iy0,ix1,iy1); } -/* //////////////////////////////////////////////////////////////////////////// */ -/* */ -/* Rasterizer */ +////////////////////////////////////////////////////////////////////////////// +// +// Rasterizer typedef struct stbtt__hheap_chunk { @@ -2852,13 +2852,13 @@ static stbtt__active_edge *stbtt__new_active(stbtt__hheap *hh, stbtt__edge *e, i STBTT_assert(z != NULL); if (!z) return z; - /* round dx down to avoid overshooting */ + // round dx down to avoid overshooting if (dxdy < 0) z->dx = -STBTT_ifloor(STBTT_FIX * -dxdy); else z->dx = STBTT_ifloor(STBTT_FIX * dxdy); - z->x = STBTT_ifloor(STBTT_FIX * e->x0 + z->dx * (start_point - e->y0)); /* use z->dx so when we offset later it's by the same amount */ + z->x = STBTT_ifloor(STBTT_FIX * e->x0 + z->dx * (start_point - e->y0)); // use z->dx so when we offset later it's by the same amount z->x -= off_x * STBTT_FIX; z->ey = e->y1; @@ -2872,7 +2872,7 @@ static stbtt__active_edge *stbtt__new_active(stbtt__hheap *hh, stbtt__edge *e, i stbtt__active_edge *z = (stbtt__active_edge *) stbtt__hheap_alloc(hh, sizeof(*z), userdata); float dxdy = (e->x1 - e->x0) / (e->y1 - e->y0); STBTT_assert(z != NULL); - /* STBTT_assert(e->y0 <= start_point); */ + //STBTT_assert(e->y0 <= start_point); if (!z) return z; z->fdx = dxdy; z->fdy = dxdy != 0.0f ? (1.0f/dxdy) : 0.0f; @@ -2889,41 +2889,41 @@ static stbtt__active_edge *stbtt__new_active(stbtt__hheap *hh, stbtt__edge *e, i #endif #if STBTT_RASTERIZER_VERSION == 1 -/* note: this routine clips fills that extend off the edges... ideally this */ -/* wouldn't happen, but it could happen if the truetype glyph bounding boxes */ -/* are wrong, or if the user supplies a too-small bitmap */ +// note: this routine clips fills that extend off the edges... ideally this +// wouldn't happen, but it could happen if the truetype glyph bounding boxes +// are wrong, or if the user supplies a too-small bitmap static void stbtt__fill_active_edges(unsigned char *scanline, int len, stbtt__active_edge *e, int max_weight) { - /* non-zero winding fill */ + // non-zero winding fill int x0=0, w=0; while (e) { if (w == 0) { - /* if we're currently at zero, we need to record the edge start point */ + // if we're currently at zero, we need to record the edge start point x0 = e->x; w += e->direction; } else { int x1 = e->x; w += e->direction; - /* if we went to zero, we need to draw */ + // if we went to zero, we need to draw if (w == 0) { int i = x0 >> STBTT_FIXSHIFT; int j = x1 >> STBTT_FIXSHIFT; if (i < len && j >= 0) { if (i == j) { - /* x0,x1 are the same pixel, so compute combined coverage */ + // x0,x1 are the same pixel, so compute combined coverage scanline[i] = scanline[i] + (stbtt_uint8) ((x1 - x0) * max_weight >> STBTT_FIXSHIFT); } else { - if (i >= 0) /* add antialiasing for x0 */ + if (i >= 0) // add antialiasing for x0 scanline[i] = scanline[i] + (stbtt_uint8) (((STBTT_FIX - (x0 & STBTT_FIXMASK)) * max_weight) >> STBTT_FIXSHIFT); else - i = -1; /* clip */ + i = -1; // clip - if (j < len) /* add antialiasing for x1 */ + if (j < len) // add antialiasing for x1 scanline[j] = scanline[j] + (stbtt_uint8) (((x1 & STBTT_FIXMASK) * max_weight) >> STBTT_FIXSHIFT); else - j = len; /* clip */ + j = len; // clip - for (++i; i < j; ++i) /* fill pixels between x0 and x1 */ + for (++i; i < j; ++i) // fill pixels between x0 and x1 scanline[i] = scanline[i] + (stbtt_uint8) max_weight; } } @@ -2939,8 +2939,8 @@ static void stbtt__rasterize_sorted_edges(stbtt__bitmap *result, stbtt__edge *e, stbtt__hheap hh = { 0, 0, 0 }; stbtt__active_edge *active = NULL; int y,j=0; - int max_weight = (255 / vsubsample); /* weight per vertical scanline */ - int s; /* vertical subsample index */ + int max_weight = (255 / vsubsample); // weight per vertical scanline + int s; // vertical subsample index unsigned char scanline_data[512], *scanline; if (result->w > 512) @@ -2954,26 +2954,26 @@ static void stbtt__rasterize_sorted_edges(stbtt__bitmap *result, stbtt__edge *e, while (j < result->h) { STBTT_memset(scanline, 0, result->w); for (s=0; s < vsubsample; ++s) { - /* find center of pixel for this scanline */ + // find center of pixel for this scanline float scan_y = y + 0.5f; stbtt__active_edge **step = &active; - /* update all active edges; */ - /* remove all active edges that terminate before the center of this scanline */ + // update all active edges; + // remove all active edges that terminate before the center of this scanline while (*step) { stbtt__active_edge * z = *step; if (z->ey <= scan_y) { - *step = z->next; /* delete from list */ + *step = z->next; // delete from list STBTT_assert(z->direction); z->direction = 0; stbtt__hheap_free(&hh, z); } else { - z->x += z->dx; /* advance to position for current scanline */ - step = &((*step)->next); /* advance through list */ + z->x += z->dx; // advance to position for current scanline + step = &((*step)->next); // advance through list } } - /* resort the list if needed */ + // resort the list if needed for(;;) { int changed=0; step = &active; @@ -2992,24 +2992,24 @@ static void stbtt__rasterize_sorted_edges(stbtt__bitmap *result, stbtt__edge *e, if (!changed) break; } - /* insert all edges that start before the center of this scanline -- omit ones that also end on this scanline */ + // insert all edges that start before the center of this scanline -- omit ones that also end on this scanline while (e->y0 <= scan_y) { if (e->y1 > scan_y) { stbtt__active_edge *z = stbtt__new_active(&hh, e, off_x, scan_y, userdata); if (z != NULL) { - /* find insertion point */ + // find insertion point if (active == NULL) active = z; else if (z->x < active->x) { - /* insert at front */ + // insert at front z->next = active; active = z; } else { - /* find thing to insert AFTER */ + // find thing to insert AFTER stbtt__active_edge *p = active; while (p->next && p->next->x < z->x) p = p->next; - /* at this point, p->next->x is NOT < z->x */ + // at this point, p->next->x is NOT < z->x z->next = p->next; p->next = z; } @@ -3018,7 +3018,7 @@ static void stbtt__rasterize_sorted_edges(stbtt__bitmap *result, stbtt__edge *e, ++e; } - /* now process all active edges in XOR fashion */ + // now process all active edges in XOR fashion if (active) stbtt__fill_active_edges(scanline, result->w, active, max_weight); @@ -3036,8 +3036,8 @@ static void stbtt__rasterize_sorted_edges(stbtt__bitmap *result, stbtt__edge *e, #elif STBTT_RASTERIZER_VERSION == 2 -/* the edge passed in here does not cross the vertical line at x or the vertical line at x+1 */ -/* (i.e. it has already been clipped to those) */ +// the edge passed in here does not cross the vertical line at x or the vertical line at x+1 +// (i.e. it has already been clipped to those) static void stbtt__handle_clipped_edge(float *scanline, int x, stbtt__active_edge *e, float x0, float y0, float x1, float y1) { if (y0 == y1) return; @@ -3071,7 +3071,7 @@ static void stbtt__handle_clipped_edge(float *scanline, int x, stbtt__active_edg ; else { STBTT_assert(x0 >= x && x0 <= x+1 && x1 >= x && x1 <= x+1); - scanline[x] += e->direction * (y1-y0) * (1-((x0-x)+(x1-x))/2); /* coverage = 1 - average x position */ + scanline[x] += e->direction * (y1-y0) * (1-((x0-x)+(x1-x))/2); // coverage = 1 - average x position } } @@ -3080,9 +3080,9 @@ static void stbtt__fill_active_edges_new(float *scanline, float *scanline_fill, float y_bottom = y_top+1; while (e) { - /* brute force every pixel */ + // brute force every pixel - /* compute intersection points with top & bottom */ + // compute intersection points with top & bottom STBTT_assert(e->ey >= y_top); if (e->fdx == 0) { @@ -3104,9 +3104,9 @@ static void stbtt__fill_active_edges_new(float *scanline, float *scanline_fill, float dy = e->fdy; STBTT_assert(e->sy <= y_bottom && e->ey >= y_top); - /* compute endpoints of line segment clipped to this scanline (if the */ - /* line segment starts on this scanline. x0 is the intersection of the */ - /* line with y_top, but that may be off the line segment. */ + // compute endpoints of line segment clipped to this scanline (if the + // line segment starts on this scanline. x0 is the intersection of the + // line with y_top, but that may be off the line segment. if (e->sy > y_top) { x_top = x0 + dx * (e->sy - y_top); sy0 = e->sy; @@ -3123,22 +3123,22 @@ static void stbtt__fill_active_edges_new(float *scanline, float *scanline_fill, } if (x_top >= 0 && x_bottom >= 0 && x_top < len && x_bottom < len) { - /* from here on, we don't have to range check x values */ + // from here on, we don't have to range check x values if ((int) x_top == (int) x_bottom) { float height; - /* simple case, only spans one pixel */ + // simple case, only spans one pixel int x = (int) x_top; height = sy1 - sy0; STBTT_assert(x >= 0 && x < len); scanline[x] += e->direction * (1-((x_top - x) + (x_bottom-x))/2) * height; - scanline_fill[x] += e->direction * height; /* everything right of this pixel is filled */ + scanline_fill[x] += e->direction * height; // everything right of this pixel is filled } else { int x,x1,x2; float y_crossing, step, sign, area; - /* covers 2+ pixels */ + // covers 2+ pixels if (x_top > x_bottom) { - /* flip scanline vertically; signed area is the same */ + // flip scanline vertically; signed area is the same float t; sy0 = y_bottom - (sy0 - y_top); sy1 = y_bottom - (sy1 - y_top); @@ -3151,13 +3151,13 @@ static void stbtt__fill_active_edges_new(float *scanline, float *scanline_fill, x1 = (int) x_top; x2 = (int) x_bottom; - /* compute intersection with y axis at x1+1 */ + // compute intersection with y axis at x1+1 y_crossing = (x1+1 - x0) * dy + y_top; sign = e->direction; - /* area of the rectangle covered from y0..y_crossing */ + // area of the rectangle covered from y0..y_crossing area = sign * (y_crossing-sy0); - /* area of the triangle (x_top,y0), (x+1,y0), (x+1,y_crossing) */ + // area of the triangle (x_top,y0), (x+1,y0), (x+1,y_crossing) scanline[x1] += area * (1-((x_top - x1)+(x1+1-x1))/2); step = sign * dy; @@ -3174,59 +3174,59 @@ static void stbtt__fill_active_edges_new(float *scanline, float *scanline_fill, scanline_fill[x2] += sign * (sy1-sy0); } } else { - /* if edge goes outside of box we're drawing, we require */ - /* clipping logic. since this does not match the intended use */ - /* of this library, we use a different, very slow brute */ - /* force implementation */ + // if edge goes outside of box we're drawing, we require + // clipping logic. since this does not match the intended use + // of this library, we use a different, very slow brute + // force implementation int x; for (x=0; x < len; ++x) { - /* cases: */ - /* */ - /* there can be up to two intersections with the pixel. any intersection */ - /* with left or right edges can be handled by splitting into two (or three) */ - /* regions. intersections with top & bottom do not necessitate case-wise logic. */ - /* */ - /* the old way of doing this found the intersections with the left & right edges, */ - /* then used some simple logic to produce up to three segments in sorted order */ - /* from top-to-bottom. however, this had a problem: if an x edge was epsilon */ - /* across the x border, then the corresponding y position might not be distinct */ - /* from the other y segment, and it might ignored as an empty segment. to avoid */ - /* that, we need to explicitly produce segments based on x positions. */ + // cases: + // + // there can be up to two intersections with the pixel. any intersection + // with left or right edges can be handled by splitting into two (or three) + // regions. intersections with top & bottom do not necessitate case-wise logic. + // + // the old way of doing this found the intersections with the left & right edges, + // then used some simple logic to produce up to three segments in sorted order + // from top-to-bottom. however, this had a problem: if an x edge was epsilon + // across the x border, then the corresponding y position might not be distinct + // from the other y segment, and it might ignored as an empty segment. to avoid + // that, we need to explicitly produce segments based on x positions. - /* rename variables to clearly-defined pairs */ + // rename variables to clearly-defined pairs float y0 = y_top; float x1 = (float) (x); float x2 = (float) (x+1); float x3 = xb; float y3 = y_bottom; - /* x = e->x + e->dx * (y-y_top) */ - /* (y-y_top) = (x - e->x) / e->dx */ - /* y = (x - e->x) / e->dx + y_top */ + // x = e->x + e->dx * (y-y_top) + // (y-y_top) = (x - e->x) / e->dx + // y = (x - e->x) / e->dx + y_top float y1 = (x - x0) / dx + y_top; float y2 = (x+1 - x0) / dx + y_top; - if (x0 < x1 && x3 > x2) { /* three segments descending down-right */ + if (x0 < x1 && x3 > x2) { // three segments descending down-right stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x1,y1); stbtt__handle_clipped_edge(scanline,x,e, x1,y1, x2,y2); stbtt__handle_clipped_edge(scanline,x,e, x2,y2, x3,y3); - } else if (x3 < x1 && x0 > x2) { /* three segments descending down-left */ + } else if (x3 < x1 && x0 > x2) { // three segments descending down-left stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x2,y2); stbtt__handle_clipped_edge(scanline,x,e, x2,y2, x1,y1); stbtt__handle_clipped_edge(scanline,x,e, x1,y1, x3,y3); - } else if (x0 < x1 && x3 > x1) { /* two segments across x, down-right */ + } else if (x0 < x1 && x3 > x1) { // two segments across x, down-right stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x1,y1); stbtt__handle_clipped_edge(scanline,x,e, x1,y1, x3,y3); - } else if (x3 < x1 && x0 > x1) { /* two segments across x, down-left */ + } else if (x3 < x1 && x0 > x1) { // two segments across x, down-left stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x1,y1); stbtt__handle_clipped_edge(scanline,x,e, x1,y1, x3,y3); - } else if (x0 < x2 && x3 > x2) { /* two segments across x+1, down-right */ + } else if (x0 < x2 && x3 > x2) { // two segments across x+1, down-right stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x2,y2); stbtt__handle_clipped_edge(scanline,x,e, x2,y2, x3,y3); - } else if (x3 < x2 && x0 > x2) { /* two segments across x+1, down-left */ + } else if (x3 < x2 && x0 > x2) { // two segments across x+1, down-left stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x2,y2); stbtt__handle_clipped_edge(scanline,x,e, x2,y2, x3,y3); - } else { /* one segment */ + } else { // one segment stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x3,y3); } } @@ -3236,7 +3236,7 @@ static void stbtt__fill_active_edges_new(float *scanline, float *scanline_fill, } } -/* directly AA rasterize edges w/o supersampling */ +// directly AA rasterize edges w/o supersampling static void stbtt__rasterize_sorted_edges(stbtt__bitmap *result, stbtt__edge *e, int n, int vsubsample, int off_x, int off_y, void *userdata) { stbtt__hheap hh = { 0, 0, 0 }; @@ -3257,7 +3257,7 @@ static void stbtt__rasterize_sorted_edges(stbtt__bitmap *result, stbtt__edge *e, e[n].y0 = (float) (off_y + result->h) + 1; while (j < result->h) { - /* find center of pixel for this scanline */ + // find center of pixel for this scanline float scan_y_top = y + 0.0f; float scan_y_bottom = y + 1.0f; stbtt__active_edge **step = &active; @@ -3265,33 +3265,33 @@ static void stbtt__rasterize_sorted_edges(stbtt__bitmap *result, stbtt__edge *e, STBTT_memset(scanline , 0, result->w*sizeof(scanline[0])); STBTT_memset(scanline2, 0, (result->w+1)*sizeof(scanline[0])); - /* update all active edges; */ - /* remove all active edges that terminate before the top of this scanline */ + // update all active edges; + // remove all active edges that terminate before the top of this scanline while (*step) { stbtt__active_edge * z = *step; if (z->ey <= scan_y_top) { - *step = z->next; /* delete from list */ + *step = z->next; // delete from list STBTT_assert(z->direction); z->direction = 0; stbtt__hheap_free(&hh, z); } else { - step = &((*step)->next); /* advance through list */ + step = &((*step)->next); // advance through list } } - /* insert all edges that start before the bottom of this scanline */ + // insert all edges that start before the bottom of this scanline while (e->y0 <= scan_y_bottom) { if (e->y0 != e->y1) { stbtt__active_edge *z = stbtt__new_active(&hh, e, off_x, scan_y_top, userdata); if (z != NULL) { if (j == 0 && off_y != 0) { if (z->ey < scan_y_top) { - /* this can happen due to subpixel positioning and some kind of fp rounding error i think */ + // this can happen due to subpixel positioning and some kind of fp rounding error i think z->ey = scan_y_top; } } - STBTT_assert(z->ey >= scan_y_top); /* if we get really unlucky a tiny bit of an edge can be out of bounds */ - /* insert at front */ + STBTT_assert(z->ey >= scan_y_top); // if we get really unlucky a tiny bit of an edge can be out of bounds + // insert at front z->next = active; active = z; } @@ -3299,7 +3299,7 @@ static void stbtt__rasterize_sorted_edges(stbtt__bitmap *result, stbtt__edge *e, ++e; } - /* now process all active edges */ + // now process all active edges if (active) stbtt__fill_active_edges_new(scanline, scanline2+1, result->w, active, scan_y_top); @@ -3316,12 +3316,12 @@ static void stbtt__rasterize_sorted_edges(stbtt__bitmap *result, stbtt__edge *e, result->pixels[j*result->stride + i] = (unsigned char) m; } } - /* advance all the edges */ + // advance all the edges step = &active; while (*step) { stbtt__active_edge *z = *step; - z->fx += z->fdx; /* advance to position for current scanline */ - step = &((*step)->next); /* advance through list */ + z->fx += z->fdx; // advance to position for current scanline + step = &((*step)->next); // advance through list } ++y; @@ -3442,14 +3442,14 @@ static void stbtt__rasterize(stbtt__bitmap *result, stbtt__point *pts, int *wcou #else #error "Unrecognized value of STBTT_RASTERIZER_VERSION" #endif - /* vsubsample should divide 255 evenly; otherwise we won't reach full opacity */ + // vsubsample should divide 255 evenly; otherwise we won't reach full opacity - /* now we have to blow out the windings into explicit edge lists */ + // now we have to blow out the windings into explicit edge lists n = 0; for (i=0; i < windings; ++i) n += wcount[i]; - e = (stbtt__edge *) STBTT_malloc(sizeof(*e) * (n+1), userdata); /* add an extra one as a sentinel */ + e = (stbtt__edge *) STBTT_malloc(sizeof(*e) * (n+1), userdata); // add an extra one as a sentinel if (e == 0) return; n = 0; @@ -3460,10 +3460,10 @@ static void stbtt__rasterize(stbtt__bitmap *result, stbtt__point *pts, int *wcou j = wcount[i]-1; for (k=0; k < wcount[i]; j=k++) { int a=k,b=j; - /* skip the edge if horizontal */ + // skip the edge if horizontal if (p[j].y == p[k].y) continue; - /* add edge from j to k to the list */ + // add edge from j to k to the list e[n].invert = 0; if (invert ? p[j].y > p[k].y : p[j].y < p[k].y) { e[n].invert = 1; @@ -3477,11 +3477,11 @@ static void stbtt__rasterize(stbtt__bitmap *result, stbtt__point *pts, int *wcou } } - /* now sort the edges by their highest point (should snap to integer, and then by x) */ - /* STBTT_sort(e, n, sizeof(e[0]), stbtt__edge_compare); */ + // now sort the edges by their highest point (should snap to integer, and then by x) + //STBTT_sort(e, n, sizeof(e[0]), stbtt__edge_compare); stbtt__sort_edges(e, n); - /* now, traverse the scanlines and find the intersections on each scanline, use xor winding rule */ + // now, traverse the scanlines and find the intersections on each scanline, use xor winding rule stbtt__rasterize_sorted_edges(result, e, n, vsubsample, off_x, off_y, userdata); STBTT_free(e, userdata); @@ -3489,23 +3489,23 @@ static void stbtt__rasterize(stbtt__bitmap *result, stbtt__point *pts, int *wcou static void stbtt__add_point(stbtt__point *points, int n, float x, float y) { - if (!points) return; /* during first pass, it's unallocated */ + if (!points) return; // during first pass, it's unallocated points[n].x = x; points[n].y = y; } -/* tessellate until threshold p is happy... @TODO warped to compensate for non-linear stretching */ +// tessellate until threshold p is happy... @TODO warped to compensate for non-linear stretching static int stbtt__tesselate_curve(stbtt__point *points, int *num_points, float x0, float y0, float x1, float y1, float x2, float y2, float objspace_flatness_squared, int n) { - /* midpoint */ + // midpoint float mx = (x0 + 2*x1 + x2)/4; float my = (y0 + 2*y1 + y2)/4; - /* versus directly drawn line */ + // versus directly drawn line float dx = (x0+x2)/2 - mx; float dy = (y0+y2)/2 - my; - if (n > 16) /* 65536 segments on one curve better be enough! */ + if (n > 16) // 65536 segments on one curve better be enough! return 1; - if (dx*dx+dy*dy > objspace_flatness_squared) { /* half-pixel error allowed... need to be smaller if AA */ + if (dx*dx+dy*dy > objspace_flatness_squared) { // half-pixel error allowed... need to be smaller if AA stbtt__tesselate_curve(points, num_points, x0,y0, (x0+x1)/2.0f,(y0+y1)/2.0f, mx,my, objspace_flatness_squared,n+1); stbtt__tesselate_curve(points, num_points, mx,my, (x1+x2)/2.0f,(y1+y2)/2.0f, x2,y2, objspace_flatness_squared,n+1); } else { @@ -3517,7 +3517,7 @@ static int stbtt__tesselate_curve(stbtt__point *points, int *num_points, float x static void stbtt__tesselate_cubic(stbtt__point *points, int *num_points, float x0, float y0, float x1, float y1, float x2, float y2, float x3, float y3, float objspace_flatness_squared, int n) { - /* @TODO this "flatness" calculation is just made-up nonsense that seems to work well enough */ + // @TODO this "flatness" calculation is just made-up nonsense that seems to work well enough float dx0 = x1-x0; float dy0 = y1-y0; float dx1 = x2-x1; @@ -3530,7 +3530,7 @@ static void stbtt__tesselate_cubic(stbtt__point *points, int *num_points, float float shortlen = (float) STBTT_sqrt(dx*dx+dy*dy); float flatness_squared = longlen*longlen-shortlen*shortlen; - if (n > 16) /* 65536 segments on one curve better be enough! */ + if (n > 16) // 65536 segments on one curve better be enough! return; if (flatness_squared > objspace_flatness_squared) { @@ -3557,7 +3557,7 @@ static void stbtt__tesselate_cubic(stbtt__point *points, int *num_points, float } } -/* returns number of contours */ +// returns number of contours static stbtt__point *stbtt_FlattenCurves(stbtt_vertex *vertices, int num_verts, float objspace_flatness, int **contour_lengths, int *num_contours, void *userdata) { stbtt__point *points=0; @@ -3566,7 +3566,7 @@ static stbtt__point *stbtt_FlattenCurves(stbtt_vertex *vertices, int num_verts, float objspace_flatness_squared = objspace_flatness * objspace_flatness; int i,n=0,start=0, pass; - /* count how many "moves" there are to get the contour count */ + // count how many "moves" there are to get the contour count for (i=0; i < num_verts; ++i) if (vertices[i].type == STBTT_vmove) ++n; @@ -3581,7 +3581,7 @@ static stbtt__point *stbtt_FlattenCurves(stbtt_vertex *vertices, int num_verts, return 0; } - /* make two passes through the points so we don't need to realloc */ + // make two passes through the points so we don't need to realloc for (pass=0; pass < 2; ++pass) { float x=0,y=0; if (pass == 1) { @@ -3593,7 +3593,7 @@ static stbtt__point *stbtt_FlattenCurves(stbtt_vertex *vertices, int num_verts, for (i=0; i < num_verts; ++i) { switch (vertices[i].type) { case STBTT_vmove: - /* start the next contour */ + // start the next contour if (n >= 0) (*contour_lengths)[n] = num_points - start; ++n; @@ -3671,10 +3671,10 @@ STBTT_DEF unsigned char *stbtt_GetGlyphBitmapSubpixel(const stbtt_fontinfo *info stbtt_GetGlyphBitmapBoxSubpixel(info, glyph, scale_x, scale_y, shift_x, shift_y, &ix0,&iy0,&ix1,&iy1); - /* now we get the size */ + // now we get the size gbm.w = (ix1 - ix0); gbm.h = (iy1 - iy0); - gbm.pixels = NULL; /* in case we error */ + gbm.pixels = NULL; // in case we error if (width ) *width = gbm.w; if (height) *height = gbm.h; @@ -3747,16 +3747,16 @@ STBTT_DEF void stbtt_MakeCodepointBitmap(const stbtt_fontinfo *info, unsigned ch stbtt_MakeCodepointBitmapSubpixel(info, output, out_w, out_h, out_stride, scale_x, scale_y, 0.0f,0.0f, codepoint); } -/* //////////////////////////////////////////////////////////////////////////// */ -/* */ -/* bitmap baking */ -/* */ -/* This is SUPER-CRAPPY packing to keep source code small */ +////////////////////////////////////////////////////////////////////////////// +// +// bitmap baking +// +// This is SUPER-CRAPPY packing to keep source code small -static int stbtt_BakeFontBitmap_internal(unsigned char *data, int offset, /* font location (use offset=0 for plain .ttf) */ - float pixel_height, /* height of font in pixels */ - unsigned char *pixels, int pw, int ph, /* bitmap to be filled in */ - int first_char, int num_chars, /* characters to bake */ +static int stbtt_BakeFontBitmap_internal(unsigned char *data, int offset, // font location (use offset=0 for plain .ttf) + float pixel_height, // height of font in pixels + unsigned char *pixels, int pw, int ph, // bitmap to be filled in + int first_char, int num_chars, // characters to bake stbtt_bakedchar *chardata) { float scale; @@ -3765,7 +3765,7 @@ static int stbtt_BakeFontBitmap_internal(unsigned char *data, int offset, /* f f.userdata = NULL; if (!stbtt_InitFont(&f, data, offset)) return -1; - STBTT_memset(pixels, 0, pw*ph); /* background of 0 around pixels */ + STBTT_memset(pixels, 0, pw*ph); // background of 0 around pixels x=y=1; bottom_y = 1; @@ -3779,8 +3779,8 @@ static int stbtt_BakeFontBitmap_internal(unsigned char *data, int offset, /* f gw = x1-x0; gh = y1-y0; if (x + gw + 1 >= pw) - y = bottom_y, x = 1; /* advance to next row */ - if (y + gh + 1 >= ph) /* check if it fits vertically AFTER potentially moving to next row */ + y = bottom_y, x = 1; // advance to next row + if (y + gh + 1 >= ph) // check if it fits vertically AFTER potentially moving to next row return -i; STBTT_assert(x+gw < pw); STBTT_assert(y+gh < ph); @@ -3820,25 +3820,25 @@ STBTT_DEF void stbtt_GetBakedQuad(const stbtt_bakedchar *chardata, int pw, int p *xpos += b->xadvance; } -/* //////////////////////////////////////////////////////////////////////////// */ -/* */ -/* rectangle packing replacement routines if you don't have stb_rect_pack.h */ -/* */ +////////////////////////////////////////////////////////////////////////////// +// +// rectangle packing replacement routines if you don't have stb_rect_pack.h +// #ifndef STB_RECT_PACK_VERSION typedef int stbrp_coord; -/* ////////////////////////////////////////////////////////////////////////////////// */ -/* // */ -/* // */ -/* COMPILER WARNING ?!?!? // */ -/* // */ -/* // */ -/* if you get a compile warning due to these symbols being defined more than // */ -/* once, move #include "stb_rect_pack.h" before #include "stb_truetype.h" // */ -/* // */ -/* ////////////////////////////////////////////////////////////////////////////////// */ +//////////////////////////////////////////////////////////////////////////////////// +// // +// // +// COMPILER WARNING ?!?!? // +// // +// // +// if you get a compile warning due to these symbols being defined more than // +// once, move #include "stb_rect_pack.h" before #include "stb_truetype.h" // +// // +//////////////////////////////////////////////////////////////////////////////////// typedef struct { @@ -3890,12 +3890,12 @@ static void stbrp_pack_rects(stbrp_context *con, stbrp_rect *rects, int num_rect } #endif -/* //////////////////////////////////////////////////////////////////////////// */ -/* */ -/* bitmap baking */ -/* */ -/* This is SUPER-AWESOME (tm Ryan Gordon) packing using stb_rect_pack.h. If */ -/* stb_rect_pack.h isn't available, it uses the BakeFontBitmap strategy. */ +////////////////////////////////////////////////////////////////////////////// +// +// bitmap baking +// +// This is SUPER-AWESOME (tm Ryan Gordon) packing using stb_rect_pack.h. If +// stb_rect_pack.h isn't available, it uses the BakeFontBitmap strategy. STBTT_DEF int stbtt_PackBegin(stbtt_pack_context *spc, unsigned char *pixels, int pw, int ph, int stride_in_bytes, int padding, void *alloc_context) { @@ -3924,7 +3924,7 @@ STBTT_DEF int stbtt_PackBegin(stbtt_pack_context *spc, unsigned char *pixels, in stbrp_init_target(context, pw-padding, ph-padding, nodes, num_nodes); if (pixels) - STBTT_memset(pixels, 0, pw*ph); /* background of 0 around pixels */ + STBTT_memset(pixels, 0, pw*ph); // background of 0 around pixels return 1; } @@ -3957,7 +3957,7 @@ static void stbtt__h_prefilter(unsigned char *pixels, int w, int h, int stride_i unsigned char buffer[STBTT_MAX_OVERSAMPLE]; int safe_w = w - kernel_width; int j; - STBTT_memset(buffer, 0, STBTT_MAX_OVERSAMPLE); /* suppress bogus warning from VS2013 -analyze */ + STBTT_memset(buffer, 0, STBTT_MAX_OVERSAMPLE); // suppress bogus warning from VS2013 -analyze for (j=0; j < h; ++j) { int i; unsigned int total; @@ -3965,7 +3965,7 @@ static void stbtt__h_prefilter(unsigned char *pixels, int w, int h, int stride_i total = 0; - /* make kernel_width a constant in common cases so compiler can optimize out the divide */ + // make kernel_width a constant in common cases so compiler can optimize out the divide switch (kernel_width) { case 2: for (i=0; i <= safe_w; ++i) { @@ -4019,7 +4019,7 @@ static void stbtt__v_prefilter(unsigned char *pixels, int w, int h, int stride_i unsigned char buffer[STBTT_MAX_OVERSAMPLE]; int safe_h = h - kernel_width; int j; - STBTT_memset(buffer, 0, STBTT_MAX_OVERSAMPLE); /* suppress bogus warning from VS2013 -analyze */ + STBTT_memset(buffer, 0, STBTT_MAX_OVERSAMPLE); // suppress bogus warning from VS2013 -analyze for (j=0; j < w; ++j) { int i; unsigned int total; @@ -4027,7 +4027,7 @@ static void stbtt__v_prefilter(unsigned char *pixels, int w, int h, int stride_i total = 0; - /* make kernel_width a constant in common cases so compiler can optimize out the divide */ + // make kernel_width a constant in common cases so compiler can optimize out the divide switch (kernel_width) { case 2: for (i=0; i <= safe_h; ++i) { @@ -4081,14 +4081,14 @@ static float stbtt__oversample_shift(int oversample) if (!oversample) return 0.0f; - /* The prefilter is a box filter of width "oversample", */ - /* which shifts phase by (oversample - 1)/2 pixels in */ - /* oversampled space. We want to shift in the opposite */ - /* direction to counter this. */ + // The prefilter is a box filter of width "oversample", + // which shifts phase by (oversample - 1)/2 pixels in + // oversampled space. We want to shift in the opposite + // direction to counter this. return (float)-(oversample - 1) / (2.0f * (float)oversample); } -/* rects array must be big enough to accommodate all characters in the given ranges */ +// rects array must be big enough to accommodate all characters in the given ranges STBTT_DEF int stbtt_PackFontRangesGatherRects(stbtt_pack_context *spc, const stbtt_fontinfo *info, stbtt_pack_range *ranges, int num_ranges, stbrp_rect *rects) { int i,j,k; @@ -4147,12 +4147,12 @@ STBTT_DEF void stbtt_MakeGlyphBitmapSubpixelPrefilter(const stbtt_fontinfo *info *sub_y = stbtt__oversample_shift(prefilter_y); } -/* rects array must be big enough to accommodate all characters in the given ranges */ +// rects array must be big enough to accommodate all characters in the given ranges STBTT_DEF int stbtt_PackFontRangesRenderIntoRects(stbtt_pack_context *spc, const stbtt_fontinfo *info, stbtt_pack_range *ranges, int num_ranges, stbrp_rect *rects) { int i,j,k, missing_glyph = -1, return_value = 1; - /* save current values */ + // save current values int old_h_over = spc->h_oversample; int old_v_over = spc->v_oversample; @@ -4176,7 +4176,7 @@ STBTT_DEF int stbtt_PackFontRangesRenderIntoRects(stbtt_pack_context *spc, const int glyph = stbtt_FindGlyphIndex(info, codepoint); stbrp_coord pad = (stbrp_coord) spc->padding; - /* pad on left and top */ + // pad on left and top r->x += pad; r->y += pad; r->w -= pad; @@ -4223,14 +4223,14 @@ STBTT_DEF int stbtt_PackFontRangesRenderIntoRects(stbtt_pack_context *spc, const } else if (r->was_packed && r->w == 0 && r->h == 0 && missing_glyph >= 0) { ranges[i].chardata_for_range[j] = ranges[i].chardata_for_range[missing_glyph]; } else { - return_value = 0; /* if any fail, report failure */ + return_value = 0; // if any fail, report failure } ++k; } } - /* restore original values */ + // restore original values spc->h_oversample = old_h_over; spc->v_oversample = old_v_over; @@ -4246,10 +4246,10 @@ STBTT_DEF int stbtt_PackFontRanges(stbtt_pack_context *spc, const unsigned char { stbtt_fontinfo info; int i,j,n, return_value = 1; - /* stbrp_context *context = (stbrp_context *) spc->pack_info; */ + //stbrp_context *context = (stbrp_context *) spc->pack_info; stbrp_rect *rects; - /* flag all characters as NOT packed */ + // flag all characters as NOT packed for (i=0; i < num_ranges; ++i) for (j=0; j < ranges[i].num_chars; ++j) ranges[i].chardata_for_range[j].x0 = @@ -4330,10 +4330,10 @@ STBTT_DEF void stbtt_GetPackedQuad(const stbtt_packedchar *chardata, int pw, int *xpos += b->xadvance; } -/* //////////////////////////////////////////////////////////////////////////// */ -/* */ -/* sdf computation */ -/* */ +////////////////////////////////////////////////////////////////////////////// +// +// sdf computation +// #define STBTT_min(a,b) ((a) < (b) ? (a) : (b)) #define STBTT_max(a,b) ((a) < (b) ? (b) : (a)) @@ -4367,8 +4367,8 @@ static int stbtt__ray_intersect_bezier(float orig[2], float ray[2], float q0[2], } } } else { - /* 2*b*s + c = 0 */ - /* s = -c / (2*b) */ + // 2*b*s + c = 0 + // s = -c / (2*b) s0 = c / (-2 * b); if (s0 >= 0.0 && s0 <= 1.0) num_s = 1; @@ -4417,7 +4417,7 @@ static int stbtt__compute_crossings_x(float x, float y, int nverts, stbtt_vertex orig[0] = x; orig[1] = y; - /* make sure y never passes through a vertex of the shape */ + // make sure y never passes through a vertex of the shape y_frac = (float) STBTT_fmod(y, 1.0f); if (y_frac < 0.01f) y += 0.01f; @@ -4425,7 +4425,7 @@ static int stbtt__compute_crossings_x(float x, float y, int nverts, stbtt_vertex y -= 0.01f; orig[1] = y; - /* test a ray from (-infinity,y) to (x,y) */ + // test a ray from (-infinity,y) to (x,y) for (i=0; i < nverts; ++i) { if (verts[i].type == STBTT_vline) { int x0 = (int) verts[i-1].x, y0 = (int) verts[i-1].y; @@ -4484,7 +4484,7 @@ static float stbtt__cuberoot( float x ) return (float) STBTT_pow( x,1.0f/3.0f); } -/* x^3 + c*x^2 + b*x + a = 0 */ +// x^3 + c*x^2 + b*x + a = 0 static int stbtt__solve_cubic(float a, float b, float c, float* r) { float s = -a / 3; @@ -4502,16 +4502,16 @@ static int stbtt__solve_cubic(float a, float b, float c, float* r) return 1; } else { float u = (float) STBTT_sqrt(-p/3); - float v = (float) STBTT_acos(-STBTT_sqrt(-27/p3) * q / 2) / 3; /* p3 must be negative, since d is negative */ + float v = (float) STBTT_acos(-STBTT_sqrt(-27/p3) * q / 2) / 3; // p3 must be negative, since d is negative float m = (float) STBTT_cos(v); float n = (float) STBTT_cos(v-3.141592/2)*1.732050808f; r[0] = s + u * 2 * m; r[1] = s - u * (m + n); r[2] = s - u * (m - n); - /* STBTT_assert( STBTT_fabs(((r[0]+a)*r[0]+b)*r[0]+c) < 0.05f); // these asserts may not be safe at all scales, though they're in bezier t parameter units so maybe? */ - /* STBTT_assert( STBTT_fabs(((r[1]+a)*r[1]+b)*r[1]+c) < 0.05f); */ - /* STBTT_assert( STBTT_fabs(((r[2]+a)*r[2]+b)*r[2]+c) < 0.05f); */ + //STBTT_assert( STBTT_fabs(((r[0]+a)*r[0]+b)*r[0]+c) < 0.05f); // these asserts may not be safe at all scales, though they're in bezier t parameter units so maybe? + //STBTT_assert( STBTT_fabs(((r[1]+a)*r[1]+b)*r[1]+c) < 0.05f); + //STBTT_assert( STBTT_fabs(((r[2]+a)*r[2]+b)*r[2]+c) < 0.05f); return 3; } } @@ -4527,7 +4527,7 @@ STBTT_DEF unsigned char * stbtt_GetGlyphSDF(const stbtt_fontinfo *info, float sc stbtt_GetGlyphBitmapBoxSubpixel(info, glyph, scale, scale, 0.0f,0.0f, &ix0,&iy0,&ix1,&iy1); - /* if empty, return NULL */ + // if empty, return NULL if (ix0 == ix1 || iy0 == iy1) return NULL; @@ -4544,7 +4544,7 @@ STBTT_DEF unsigned char * stbtt_GetGlyphSDF(const stbtt_fontinfo *info, float sc if (xoff ) *xoff = ix0; if (yoff ) *yoff = iy0; - /* invert for y-downwards bitmaps */ + // invert for y-downwards bitmaps scale_y = -scale_y; { @@ -4584,12 +4584,12 @@ STBTT_DEF unsigned char * stbtt_GetGlyphSDF(const stbtt_fontinfo *info, float sc float x_gspace = (sx / scale_x); float y_gspace = (sy / scale_y); - int winding = stbtt__compute_crossings_x(x_gspace, y_gspace, num_verts, verts); /* @OPTIMIZE: this could just be a rasterization, but needs to be line vs. non-tesselated curves so a new path */ + int winding = stbtt__compute_crossings_x(x_gspace, y_gspace, num_verts, verts); // @OPTIMIZE: this could just be a rasterization, but needs to be line vs. non-tesselated curves so a new path for (i=0; i < num_verts; ++i) { float x0 = verts[i].x*scale_x, y0 = verts[i].y*scale_y; - /* check against every point here rather than inside line/curve primitives -- @TODO: wrong if multiple 'moves' in a row produce a garbage point, and given culling, probably more efficient to do within line/curve */ + // check against every point here rather than inside line/curve primitives -- @TODO: wrong if multiple 'moves' in a row produce a garbage point, and given culling, probably more efficient to do within line/curve float dist2 = (x0-sx)*(x0-sx) + (y0-sy)*(y0-sy); if (dist2 < min_dist*min_dist) min_dist = (float) STBTT_sqrt(dist2); @@ -4597,19 +4597,19 @@ STBTT_DEF unsigned char * stbtt_GetGlyphSDF(const stbtt_fontinfo *info, float sc if (verts[i].type == STBTT_vline) { float x1 = verts[i-1].x*scale_x, y1 = verts[i-1].y*scale_y; - /* coarse culling against bbox */ - /* if (sx > STBTT_min(x0,x1)-min_dist && sx < STBTT_max(x0,x1)+min_dist && */ - /* sy > STBTT_min(y0,y1)-min_dist && sy < STBTT_max(y0,y1)+min_dist) */ + // coarse culling against bbox + //if (sx > STBTT_min(x0,x1)-min_dist && sx < STBTT_max(x0,x1)+min_dist && + // sy > STBTT_min(y0,y1)-min_dist && sy < STBTT_max(y0,y1)+min_dist) float dist = (float) STBTT_fabs((x1-x0)*(y0-sy) - (y1-y0)*(x0-sx)) * precompute[i]; STBTT_assert(i != 0); if (dist < min_dist) { - /* check position along line */ - /* x' = x0 + t*(x1-x0), y' = y0 + t*(y1-y0) */ - /* minimize (x'-sx)*(x'-sx)+(y'-sy)*(y'-sy) */ + // check position along line + // x' = x0 + t*(x1-x0), y' = y0 + t*(y1-y0) + // minimize (x'-sx)*(x'-sx)+(y'-sy)*(y'-sy) float dx = x1-x0, dy = y1-y0; float px = x0-sx, py = y0-sy; - /* minimize (px+t*dx)^2 + (py+t*dy)^2 = px*px + 2*px*dx*t + t^2*dx*dx + py*py + 2*py*dy*t + t^2*dy*dy */ - /* derivative: 2*px*dx + 2*py*dy + (2*dx*dx+2*dy*dy)*t, set to 0 and solve */ + // minimize (px+t*dx)^2 + (py+t*dy)^2 = px*px + 2*px*dx*t + t^2*dx*dx + py*py + 2*py*dy*t + t^2*dy*dy + // derivative: 2*px*dx + 2*py*dy + (2*dx*dx+2*dy*dy)*t, set to 0 and solve float t = -(px*dx + py*dy) / (dx*dx + dy*dy); if (t >= 0.0f && t <= 1.0f) min_dist = dist; @@ -4621,7 +4621,7 @@ STBTT_DEF unsigned char * stbtt_GetGlyphSDF(const stbtt_fontinfo *info, float sc float box_y0 = STBTT_min(STBTT_min(y0,y1),y2); float box_x1 = STBTT_max(STBTT_max(x0,x1),x2); float box_y1 = STBTT_max(STBTT_max(y0,y1),y2); - /* coarse culling against bbox to avoid computing cubic unnecessarily */ + // coarse culling against bbox to avoid computing cubic unnecessarily if (sx > box_x0-min_dist && sx < box_x1+min_dist && sy > box_y0-min_dist && sy < box_y1+min_dist) { int num=0; float ax = x1-x0, ay = y1-y0; @@ -4629,11 +4629,11 @@ STBTT_DEF unsigned char * stbtt_GetGlyphSDF(const stbtt_fontinfo *info, float sc float mx = x0 - sx, my = y0 - sy; float res[3],px,py,t,it; float a_inv = precompute[i]; - if (a_inv == 0.0) { /* if a_inv is 0, it's 2nd degree so use quadratic formula */ + if (a_inv == 0.0) { // if a_inv is 0, it's 2nd degree so use quadratic formula float a = 3*(ax*bx + ay*by); float b = 2*(ax*ax + ay*ay) + (mx*bx+my*by); float c = mx*ax+my*ay; - if (a == 0.0) { /* if a is 0, it's linear */ + if (a == 0.0) { // if a is 0, it's linear if (b != 0.0) { res[num++] = -c/b; } @@ -4645,11 +4645,11 @@ STBTT_DEF unsigned char * stbtt_GetGlyphSDF(const stbtt_fontinfo *info, float sc float root = (float) STBTT_sqrt(discriminant); res[0] = (-b - root)/(2*a); res[1] = (-b + root)/(2*a); - num = 2; /* don't bother distinguishing 1-solution case, as code below will still work */ + num = 2; // don't bother distinguishing 1-solution case, as code below will still work } } } else { - float b = 3*(ax*bx + ay*by) * a_inv; /* could precompute this as it doesn't depend on sample point */ + float b = 3*(ax*bx + ay*by) * a_inv; // could precompute this as it doesn't depend on sample point float c = (2*(ax*ax + ay*ay) + (mx*bx+my*by)) * a_inv; float d = (mx*ax+my*ay) * a_inv; num = stbtt__solve_cubic(b, c, d, res); @@ -4682,7 +4682,7 @@ STBTT_DEF unsigned char * stbtt_GetGlyphSDF(const stbtt_fontinfo *info, float sc } } if (winding == 0) - min_dist = -min_dist; /* if outside the shape, value is negative */ + min_dist = -min_dist; // if outside the shape, value is negative val = onedge_value + pixel_dist_scale * min_dist; if (val < 0) val = 0; @@ -4707,17 +4707,17 @@ STBTT_DEF void stbtt_FreeSDF(unsigned char *bitmap, void *userdata) STBTT_free(bitmap, userdata); } -/* //////////////////////////////////////////////////////////////////////////// */ -/* */ -/* font name matching -- recommended not to use this */ -/* */ +////////////////////////////////////////////////////////////////////////////// +// +// font name matching -- recommended not to use this +// -/* check if a utf8 string contains a prefix which is the utf16 string; if so return length of matching utf8 string */ +// check if a utf8 string contains a prefix which is the utf16 string; if so return length of matching utf8 string static stbtt_int32 stbtt__CompareUTF8toUTF16_bigendian_prefix(stbtt_uint8 *s1, stbtt_int32 len1, stbtt_uint8 *s2, stbtt_int32 len2) { stbtt_int32 i=0; - /* convert utf16 to utf8 and compare the results while converting */ + // convert utf16 to utf8 and compare the results while converting while (len2) { stbtt_uint16 ch = s2[0]*256 + s2[1]; if (ch < 0x80) { @@ -4736,7 +4736,7 @@ static stbtt_int32 stbtt__CompareUTF8toUTF16_bigendian_prefix(stbtt_uint8 *s1, s if (s1[i++] != 0x80 + ((c >> 12) & 0x3f)) return -1; if (s1[i++] != 0x80 + ((c >> 6) & 0x3f)) return -1; if (s1[i++] != 0x80 + ((c ) & 0x3f)) return -1; - s2 += 2; /* plus another 2 below */ + s2 += 2; // plus another 2 below len2 -= 2; } else if (ch >= 0xdc00 && ch < 0xe000) { return -1; @@ -4757,8 +4757,8 @@ static int stbtt_CompareUTF8toUTF16_bigendian_internal(char *s1, int len1, char return len1 == stbtt__CompareUTF8toUTF16_bigendian_prefix((stbtt_uint8*) s1, len1, (stbtt_uint8*) s2, len2); } -/* returns results in whatever encoding you request... but note that 2-byte encodings */ -/* will be BIG-ENDIAN... use stbtt_CompareUTF8toUTF16_bigendian() to compare */ +// returns results in whatever encoding you request... but note that 2-byte encodings +// will be BIG-ENDIAN... use stbtt_CompareUTF8toUTF16_bigendian() to compare STBTT_DEF const char *stbtt_GetFontNameString(const stbtt_fontinfo *font, int *length, int platformID, int encodingID, int languageID, int nameID) { stbtt_int32 i,count,stringOffset; @@ -4790,18 +4790,18 @@ static int stbtt__matchpair(stbtt_uint8 *fc, stbtt_uint32 nm, stbtt_uint8 *name, stbtt_uint32 loc = nm + 6 + 12 * i; stbtt_int32 id = ttUSHORT(fc+loc+6); if (id == target_id) { - /* find the encoding */ + // find the encoding stbtt_int32 platform = ttUSHORT(fc+loc+0), encoding = ttUSHORT(fc+loc+2), language = ttUSHORT(fc+loc+4); - /* is this a Unicode encoding? */ + // is this a Unicode encoding? if (platform == 0 || (platform == 3 && encoding == 1) || (platform == 3 && encoding == 10)) { stbtt_int32 slen = ttUSHORT(fc+loc+8); stbtt_int32 off = ttUSHORT(fc+loc+10); - /* check if there's a prefix match */ + // check if there's a prefix match stbtt_int32 matchlen = stbtt__CompareUTF8toUTF16_bigendian_prefix(name, nlen, fc+stringOffset+off,slen); if (matchlen >= 0) { - /* check for target_id+1 immediately following, with same encoding & language */ + // check for target_id+1 immediately following, with same encoding & language if (i+1 < count && ttUSHORT(fc+loc+12+6) == next_id && ttUSHORT(fc+loc+12) == platform && ttUSHORT(fc+loc+12+2) == encoding && ttUSHORT(fc+loc+12+4) == language) { slen = ttUSHORT(fc+loc+12+8); off = ttUSHORT(fc+loc+12+10); @@ -4814,14 +4814,14 @@ static int stbtt__matchpair(stbtt_uint8 *fc, stbtt_uint32 nm, stbtt_uint8 *name, return 1; } } else { - /* if nothing immediately following */ + // if nothing immediately following if (matchlen == nlen) return 1; } } } - /* @TODO handle other encodings */ + // @TODO handle other encodings } } return 0; @@ -4833,7 +4833,7 @@ static int stbtt__matches(stbtt_uint8 *fc, stbtt_uint32 offset, stbtt_uint8 *nam stbtt_uint32 nm,hd; if (!stbtt__isfont(fc+offset)) return 0; - /* check italics/bold/underline flags in macStyle... */ + // check italics/bold/underline flags in macStyle... if (flags) { hd = stbtt__find_table(fc, offset, "head"); if ((ttUSHORT(fc+hd+44) & 7) != (flags & 7)) return 0; @@ -4843,7 +4843,7 @@ static int stbtt__matches(stbtt_uint8 *fc, stbtt_uint32 offset, stbtt_uint8 *nam if (!nm) return 0; if (flags) { - /* if we checked the macStyle flags, then just check the family and ignore the subfamily */ + // if we checked the macStyle flags, then just check the family and ignore the subfamily if (stbtt__matchpair(fc, nm, name, nlen, 16, -1)) return 1; if (stbtt__matchpair(fc, nm, name, nlen, 1, -1)) return 1; if (stbtt__matchpair(fc, nm, name, nlen, 3, -1)) return 1; @@ -4908,65 +4908,65 @@ STBTT_DEF int stbtt_CompareUTF8toUTF16_bigendian(const char *s1, int len1, const #pragma GCC diagnostic pop #endif -#endif /* STB_TRUETYPE_IMPLEMENTATION */ +#endif // STB_TRUETYPE_IMPLEMENTATION -/* FULL VERSION HISTORY */ -/* */ -/* 1.19 (2018-02-11) OpenType GPOS kerning (horizontal only), STBTT_fmod */ -/* 1.18 (2018-01-29) add missing function */ -/* 1.17 (2017-07-23) make more arguments const; doc fix */ -/* 1.16 (2017-07-12) SDF support */ -/* 1.15 (2017-03-03) make more arguments const */ -/* 1.14 (2017-01-16) num-fonts-in-TTC function */ -/* 1.13 (2017-01-02) support OpenType fonts, certain Apple fonts */ -/* 1.12 (2016-10-25) suppress warnings about casting away const with -Wcast-qual */ -/* 1.11 (2016-04-02) fix unused-variable warning */ -/* 1.10 (2016-04-02) allow user-defined fabs() replacement */ -/* fix memory leak if fontsize=0.0 */ -/* fix warning from duplicate typedef */ -/* 1.09 (2016-01-16) warning fix; avoid crash on outofmem; use alloc userdata for PackFontRanges */ -/* 1.08 (2015-09-13) document stbtt_Rasterize(); fixes for vertical & horizontal edges */ -/* 1.07 (2015-08-01) allow PackFontRanges to accept arrays of sparse codepoints; */ -/* allow PackFontRanges to pack and render in separate phases; */ -/* fix stbtt_GetFontOFfsetForIndex (never worked for non-0 input?); */ -/* fixed an assert() bug in the new rasterizer */ -/* replace assert() with STBTT_assert() in new rasterizer */ -/* 1.06 (2015-07-14) performance improvements (~35% faster on x86 and x64 on test machine) */ -/* also more precise AA rasterizer, except if shapes overlap */ -/* remove need for STBTT_sort */ -/* 1.05 (2015-04-15) fix misplaced definitions for STBTT_STATIC */ -/* 1.04 (2015-04-15) typo in example */ -/* 1.03 (2015-04-12) STBTT_STATIC, fix memory leak in new packing, various fixes */ -/* 1.02 (2014-12-10) fix various warnings & compile issues w/ stb_rect_pack, C++ */ -/* 1.01 (2014-12-08) fix subpixel position when oversampling to exactly match */ -/* non-oversampled; STBTT_POINT_SIZE for packed case only */ -/* 1.00 (2014-12-06) add new PackBegin etc. API, w/ support for oversampling */ -/* 0.99 (2014-09-18) fix multiple bugs with subpixel rendering (ryg) */ -/* 0.9 (2014-08-07) support certain mac/iOS fonts without an MS platformID */ -/* 0.8b (2014-07-07) fix a warning */ -/* 0.8 (2014-05-25) fix a few more warnings */ -/* 0.7 (2013-09-25) bugfix: subpixel glyph bug fixed in 0.5 had come back */ -/* 0.6c (2012-07-24) improve documentation */ -/* 0.6b (2012-07-20) fix a few more warnings */ -/* 0.6 (2012-07-17) fix warnings; added stbtt_ScaleForMappingEmToPixels, */ -/* stbtt_GetFontBoundingBox, stbtt_IsGlyphEmpty */ -/* 0.5 (2011-12-09) bugfixes: */ -/* subpixel glyph renderer computed wrong bounding box */ -/* first vertex of shape can be off-curve (FreeSans) */ -/* 0.4b (2011-12-03) fixed an error in the font baking example */ -/* 0.4 (2011-12-01) kerning, subpixel rendering (tor) */ -/* bugfixes for: */ -/* codepoint-to-glyph conversion using table fmt=12 */ -/* codepoint-to-glyph conversion using table fmt=4 */ -/* stbtt_GetBakedQuad with non-square texture (Zer) */ -/* updated Hello World! sample to use kerning and subpixel */ -/* fixed some warnings */ -/* 0.3 (2009-06-24) cmap fmt=12, compound shapes (MM) */ -/* userdata, malloc-from-userdata, non-zero fill (stb) */ -/* 0.2 (2009-03-11) Fix unsigned/signed char warnings */ -/* 0.1 (2009-03-09) First public release */ -/* */ +// FULL VERSION HISTORY +// +// 1.19 (2018-02-11) OpenType GPOS kerning (horizontal only), STBTT_fmod +// 1.18 (2018-01-29) add missing function +// 1.17 (2017-07-23) make more arguments const; doc fix +// 1.16 (2017-07-12) SDF support +// 1.15 (2017-03-03) make more arguments const +// 1.14 (2017-01-16) num-fonts-in-TTC function +// 1.13 (2017-01-02) support OpenType fonts, certain Apple fonts +// 1.12 (2016-10-25) suppress warnings about casting away const with -Wcast-qual +// 1.11 (2016-04-02) fix unused-variable warning +// 1.10 (2016-04-02) allow user-defined fabs() replacement +// fix memory leak if fontsize=0.0 +// fix warning from duplicate typedef +// 1.09 (2016-01-16) warning fix; avoid crash on outofmem; use alloc userdata for PackFontRanges +// 1.08 (2015-09-13) document stbtt_Rasterize(); fixes for vertical & horizontal edges +// 1.07 (2015-08-01) allow PackFontRanges to accept arrays of sparse codepoints; +// allow PackFontRanges to pack and render in separate phases; +// fix stbtt_GetFontOFfsetForIndex (never worked for non-0 input?); +// fixed an assert() bug in the new rasterizer +// replace assert() with STBTT_assert() in new rasterizer +// 1.06 (2015-07-14) performance improvements (~35% faster on x86 and x64 on test machine) +// also more precise AA rasterizer, except if shapes overlap +// remove need for STBTT_sort +// 1.05 (2015-04-15) fix misplaced definitions for STBTT_STATIC +// 1.04 (2015-04-15) typo in example +// 1.03 (2015-04-12) STBTT_STATIC, fix memory leak in new packing, various fixes +// 1.02 (2014-12-10) fix various warnings & compile issues w/ stb_rect_pack, C++ +// 1.01 (2014-12-08) fix subpixel position when oversampling to exactly match +// non-oversampled; STBTT_POINT_SIZE for packed case only +// 1.00 (2014-12-06) add new PackBegin etc. API, w/ support for oversampling +// 0.99 (2014-09-18) fix multiple bugs with subpixel rendering (ryg) +// 0.9 (2014-08-07) support certain mac/iOS fonts without an MS platformID +// 0.8b (2014-07-07) fix a warning +// 0.8 (2014-05-25) fix a few more warnings +// 0.7 (2013-09-25) bugfix: subpixel glyph bug fixed in 0.5 had come back +// 0.6c (2012-07-24) improve documentation +// 0.6b (2012-07-20) fix a few more warnings +// 0.6 (2012-07-17) fix warnings; added stbtt_ScaleForMappingEmToPixels, +// stbtt_GetFontBoundingBox, stbtt_IsGlyphEmpty +// 0.5 (2011-12-09) bugfixes: +// subpixel glyph renderer computed wrong bounding box +// first vertex of shape can be off-curve (FreeSans) +// 0.4b (2011-12-03) fixed an error in the font baking example +// 0.4 (2011-12-01) kerning, subpixel rendering (tor) +// bugfixes for: +// codepoint-to-glyph conversion using table fmt=12 +// codepoint-to-glyph conversion using table fmt=4 +// stbtt_GetBakedQuad with non-square texture (Zer) +// updated Hello World! sample to use kerning and subpixel +// fixed some warnings +// 0.3 (2009-06-24) cmap fmt=12, compound shapes (MM) +// userdata, malloc-from-userdata, non-zero fill (stb) +// 0.2 (2009-03-11) Fix unsigned/signed char warnings +// 0.1 (2009-03-09) First public release +// /* ------------------------------------------------------------------------------