|
|
@@ -10714,12 +10714,18 @@ nk__draw_next(const struct nk_draw_command *cmd,
|
|
|
#endif
|
|
|
|
|
|
|
|
|
-/* stb_rect_pack.h - v1.00 - public domain - rectangle packing */
|
|
|
+/* stb_rect_pack.h - v1.01 - public domain - rectangle packing */
|
|
|
/* Sean Barrett 2014 */
|
|
|
/* */
|
|
|
/* Useful for e.g. packing rectangular textures into an atlas. */
|
|
|
/* Does not do rotation. */
|
|
|
/* */
|
|
|
+/* Before #including, */
|
|
|
+/* */
|
|
|
+/* #define STB_RECT_PACK_IMPLEMENTATION */
|
|
|
+/* */
|
|
|
+/* in the file that you want to have the implementation. */
|
|
|
+/* */
|
|
|
/* 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). */
|
|
|
@@ -10751,6 +10757,7 @@ nk__draw_next(const struct nk_draw_command *cmd,
|
|
|
/* */
|
|
|
/* Version history: */
|
|
|
/* */
|
|
|
+/* 1.01 (2021-07-11) always use large rect mode, expose STBRP__MAXVAL in public section */
|
|
|
/* 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 */
|
|
|
@@ -10791,11 +10798,10 @@ typedef struct stbrp_context stbrp_context;
|
|
|
typedef struct stbrp_node stbrp_node;
|
|
|
typedef struct stbrp_rect stbrp_rect;
|
|
|
|
|
|
-#ifdef STBRP_LARGE_RECTS
|
|
|
typedef int stbrp_coord;
|
|
|
-#else
|
|
|
-typedef unsigned short stbrp_coord;
|
|
|
-#endif
|
|
|
+
|
|
|
+#define STBRP__MAXVAL 0x7fffffff
|
|
|
+/* Mostly for internal use, but this is the maximum supported coordinate value. */
|
|
|
|
|
|
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 */
|
|
|
@@ -10925,8 +10931,10 @@ struct stbrp_context
|
|
|
|
|
|
#ifdef _MSC_VER
|
|
|
#define STBRP__NOTUSED(v) (void)(v)
|
|
|
+#define STBRP__CDECL __cdecl
|
|
|
#else
|
|
|
#define STBRP__NOTUSED(v) (void)sizeof(v)
|
|
|
+#define STBRP__CDECL
|
|
|
#endif
|
|
|
|
|
|
enum
|
|
|
@@ -10969,9 +10977,6 @@ STBRP_DEF void stbrp_setup_allow_out_of_mem(stbrp_context *context, int allow_ou
|
|
|
STBRP_DEF void stbrp_init_target(stbrp_context *context, int width, int height, stbrp_node *nodes, int num_nodes)
|
|
|
{
|
|
|
int i;
|
|
|
-#ifndef STBRP_LARGE_RECTS
|
|
|
- STBRP_ASSERT(width <= 0xffff && height <= 0xffff);
|
|
|
-#endif
|
|
|
|
|
|
for (i=0; i < num_nodes-1; ++i)
|
|
|
nodes[i].next = &nodes[i+1];
|
|
|
@@ -10990,11 +10995,7 @@ STBRP_DEF void stbrp_init_target(stbrp_context *context, int width, int height,
|
|
|
context->extra[0].y = 0;
|
|
|
context->extra[0].next = &context->extra[1];
|
|
|
context->extra[1].x = (stbrp_coord) width;
|
|
|
-#ifdef STBRP_LARGE_RECTS
|
|
|
context->extra[1].y = (1<<30);
|
|
|
-#else
|
|
|
- context->extra[1].y = 65535;
|
|
|
-#endif
|
|
|
context->extra[1].next = NULL;
|
|
|
}
|
|
|
|
|
|
@@ -11026,7 +11027,7 @@ static int stbrp__skyline_find_min_y(stbrp_context *c, stbrp_node *first, int x0
|
|
|
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 visited */
|
|
|
+ /* 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 */
|
|
|
@@ -11236,7 +11237,7 @@ static stbrp__findresult stbrp__skyline_pack_rectangle(stbrp_context *context, i
|
|
|
return res;
|
|
|
}
|
|
|
|
|
|
-static int rect_height_compare(const void *a, const void *b)
|
|
|
+static int STBRP__CDECL rect_height_compare(const void *a, const void *b)
|
|
|
{
|
|
|
const stbrp_rect *p = (const stbrp_rect *) a;
|
|
|
const stbrp_rect *q = (const stbrp_rect *) b;
|
|
|
@@ -11247,19 +11248,13 @@ static int rect_height_compare(const void *a, const void *b)
|
|
|
return (p->w > q->w) ? -1 : (p->w < q->w);
|
|
|
}
|
|
|
|
|
|
-static int rect_original_order(const void *a, const void *b)
|
|
|
+static int STBRP__CDECL rect_original_order(const void *a, const void *b)
|
|
|
{
|
|
|
const stbrp_rect *p = (const stbrp_rect *) a;
|
|
|
const stbrp_rect *q = (const stbrp_rect *) b;
|
|
|
return (p->was_packed < q->was_packed) ? -1 : (p->was_packed > q->was_packed);
|
|
|
}
|
|
|
|
|
|
-#ifdef STBRP_LARGE_RECTS
|
|
|
-#define STBRP__MAXVAL 0xffffffff
|
|
|
-#else
|
|
|
-#define STBRP__MAXVAL 0xffff
|
|
|
-#endif
|
|
|
-
|
|
|
STBRP_DEF int stbrp_pack_rects(stbrp_context *context, stbrp_rect *rects, int num_rects)
|
|
|
{
|
|
|
int i, all_rects_packed = 1;
|
|
|
@@ -11343,8 +11338,8 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
------------------------------------------------------------------------------
|
|
|
*/
|
|
|
|
|
|
-/* stb_truetype.h - v1.24 - public domain */
|
|
|
-/* authored from 2009-2020 by Sean Barrett / RAD Game Tools */
|
|
|
+/* stb_truetype.h - v1.26 - public domain */
|
|
|
+/* authored from 2009-2021 by Sean Barrett / RAD Game Tools */
|
|
|
/* */
|
|
|
/* ======================================================================= */
|
|
|
/* */
|
|
|
@@ -11398,11 +11393,13 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
/* Johan Duparc Thomas Fields */
|
|
|
/* Hou Qiming Derek Vinyard */
|
|
|
/* Rob Loach Cort Stratton */
|
|
|
-/* Kenney Phillis Jr. Brian Costabile */
|
|
|
-/* Ken Voskuil (kaesve) */
|
|
|
+/* Kenney Phillis Jr. Brian Costabile */
|
|
|
+/* Ken Voskuil (kaesve) */
|
|
|
/* */
|
|
|
/* VERSION HISTORY */
|
|
|
/* */
|
|
|
+/* 1.26 (2021-08-28) fix broken rasterizer */
|
|
|
+/* 1.25 (2021-07-11) many fixes */
|
|
|
/* 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 */
|
|
|
@@ -11615,8 +11612,8 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
/* // SAMPLE PROGRAMS */
|
|
|
/* // */
|
|
|
/* */
|
|
|
-/* Incomplete text-in-3d-api example, which draws quads properly aligned to be lossless */
|
|
|
-/* */
|
|
|
+/* Incomplete text-in-3d-api example, which draws quads properly aligned to be lossless. */
|
|
|
+/* See "tests/truetype_demo_win32.c" for a complete version. */
|
|
|
#if 0
|
|
|
#define STB_TRUETYPE_IMPLEMENTATION /* force following include to generate implementation */
|
|
|
#include "stb_truetype.h"
|
|
|
@@ -11642,6 +11639,8 @@ void my_stbtt_initfont(void)
|
|
|
void my_stbtt_print(float x, float y, char *text)
|
|
|
{
|
|
|
/* assume orthographic projection with units = screen pixels, origin at top left */
|
|
|
+ glEnable(GL_BLEND);
|
|
|
+ glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
|
|
|
glEnable(GL_TEXTURE_2D);
|
|
|
glBindTexture(GL_TEXTURE_2D, ftex);
|
|
|
glBegin(GL_QUADS);
|
|
|
@@ -11649,10 +11648,10 @@ void my_stbtt_print(float x, float y, char *text)
|
|
|
if (*text >= 32 && *text < 128) {
|
|
|
stbtt_aligned_quad q;
|
|
|
stbtt_GetBakedQuad(cdata, 512,512, *text-32, &x,&y,&q,1);/* 1=opengl & d3d10+,0=d3d9 */
|
|
|
- glTexCoord2f(q.s0,q.t1); glVertex2f(q.x0,q.y0);
|
|
|
- glTexCoord2f(q.s1,q.t1); glVertex2f(q.x1,q.y0);
|
|
|
- glTexCoord2f(q.s1,q.t0); glVertex2f(q.x1,q.y1);
|
|
|
- glTexCoord2f(q.s0,q.t0); glVertex2f(q.x0,q.y1);
|
|
|
+ glTexCoord2f(q.s0,q.t0); glVertex2f(q.x0,q.y0);
|
|
|
+ glTexCoord2f(q.s1,q.t0); glVertex2f(q.x1,q.y0);
|
|
|
+ glTexCoord2f(q.s1,q.t1); glVertex2f(q.x1,q.y1);
|
|
|
+ glTexCoord2f(q.s0,q.t1); glVertex2f(q.x0,q.y1);
|
|
|
}
|
|
|
++text;
|
|
|
}
|
|
|
@@ -11992,7 +11991,7 @@ STBTT_DEF void stbtt_PackSetOversampling(stbtt_pack_context *spc, unsigned int h
|
|
|
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 received the font's "missing character" glyph, */
|
|
|
+/* 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 */
|
|
|
@@ -12198,6 +12197,7 @@ STBTT_DEF int stbtt_GetGlyphShape(const stbtt_fontinfo *info, int glyph_index, s
|
|
|
STBTT_DEF void stbtt_FreeShape(const stbtt_fontinfo *info, stbtt_vertex *vertices);
|
|
|
/* frees the data allocated above */
|
|
|
|
|
|
+STBTT_DEF unsigned char *stbtt_FindSVGDoc(const stbtt_fontinfo *info, int gl);
|
|
|
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. */
|
|
|
@@ -12884,12 +12884,12 @@ STBTT_DEF int stbtt_FindGlyphIndex(const stbtt_fontinfo *info, int unicode_codep
|
|
|
search += 2;
|
|
|
|
|
|
{
|
|
|
- stbtt_uint16 offset, start;
|
|
|
+ stbtt_uint16 offset, start, last;
|
|
|
stbtt_uint16 item = (stbtt_uint16) ((search - endCount) >> 1);
|
|
|
|
|
|
- STBTT_assert(unicode_codepoint <= ttUSHORT(data + endCount + 2*item));
|
|
|
start = ttUSHORT(data + index_map + 14 + segcount*2 + 2 + 2*item);
|
|
|
- if (unicode_codepoint < start)
|
|
|
+ last = ttUSHORT(data + endCount + 2*item);
|
|
|
+ if (unicode_codepoint < start || unicode_codepoint > last)
|
|
|
return 0;
|
|
|
|
|
|
offset = ttUSHORT(data + index_map + 14 + segcount*6 + 2 + 2*item);
|
|
|
@@ -13216,7 +13216,7 @@ static int stbtt__GetGlyphShapeTT(const stbtt_fontinfo *info, int glyph_index, s
|
|
|
if (comp_verts) STBTT_free(comp_verts, info->userdata);
|
|
|
return 0;
|
|
|
}
|
|
|
- if (num_vertices > 0) STBTT_memcpy(tmp, vertices, num_vertices*sizeof(stbtt_vertex));
|
|
|
+ if (num_vertices > 0 && vertices) STBTT_memcpy(tmp, vertices, num_vertices*sizeof(stbtt_vertex));
|
|
|
STBTT_memcpy(tmp+num_vertices, comp_verts, comp_num_verts*sizeof(stbtt_vertex));
|
|
|
if (vertices) STBTT_free(vertices, info->userdata);
|
|
|
vertices = tmp;
|
|
|
@@ -13479,7 +13479,7 @@ static int stbtt__run_charstring(const stbtt_fontinfo *info, int glyph_index, st
|
|
|
subrs = stbtt__cid_get_glyph_subrs(info, glyph_index);
|
|
|
has_subrs = 1;
|
|
|
}
|
|
|
- /* fallthrough */
|
|
|
+ /* FALLTHROUGH */
|
|
|
case 0x1D: /* callgsubr */
|
|
|
if (sp < 1) return STBTT__CSERR("call(g|)subr stack");
|
|
|
v = (int) s[--sp];
|
|
|
@@ -13584,7 +13584,7 @@ static int stbtt__run_charstring(const stbtt_fontinfo *info, int glyph_index, st
|
|
|
} break;
|
|
|
|
|
|
default:
|
|
|
- if (b0 != 255 && b0 != 28 && (b0 < 32 || b0 > 254))
|
|
|
+ if (b0 != 255 && b0 != 28 && b0 < 32)
|
|
|
return STBTT__CSERR("reserved operator");
|
|
|
|
|
|
/* push immediate */
|
|
|
@@ -13696,7 +13696,7 @@ STBTT_DEF int stbtt_GetKerningTable(const stbtt_fontinfo *info, stbtt_kerningent
|
|
|
return length;
|
|
|
}
|
|
|
|
|
|
-static int stbtt__GetGlyphKernInfoAdvance(const stbtt_fontinfo *info, int glyph1, int glyph2)
|
|
|
+static int stbtt__GetGlyphKernInfoAdvance(const stbtt_fontinfo *info, int glyph1, int glyph2)
|
|
|
{
|
|
|
stbtt_uint8 *data = info->data + info->kern;
|
|
|
stbtt_uint32 needle, straw;
|
|
|
@@ -13726,243 +13726,225 @@ static int stbtt__GetGlyphKernInfoAdvance(const stbtt_fontinfo *info, int glyph
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
-static stbtt_int32 stbtt__GetCoverageIndex(stbtt_uint8 *coverageTable, int glyph)
|
|
|
-{
|
|
|
- stbtt_uint16 coverageFormat = ttUSHORT(coverageTable);
|
|
|
- switch(coverageFormat) {
|
|
|
- case 1: {
|
|
|
- stbtt_uint16 glyphCount = ttUSHORT(coverageTable + 2);
|
|
|
-
|
|
|
- /* Binary search. */
|
|
|
- stbtt_int32 l=0, r=glyphCount-1, m;
|
|
|
- int straw, needle=glyph;
|
|
|
- while (l <= r) {
|
|
|
- stbtt_uint8 *glyphArray = coverageTable + 4;
|
|
|
- stbtt_uint16 glyphID;
|
|
|
- m = (l + r) >> 1;
|
|
|
- glyphID = ttUSHORT(glyphArray + 2 * m);
|
|
|
- straw = glyphID;
|
|
|
- if (needle < straw)
|
|
|
- r = m - 1;
|
|
|
- else if (needle > straw)
|
|
|
- l = m + 1;
|
|
|
- else {
|
|
|
- return m;
|
|
|
- }
|
|
|
+static stbtt_int32 stbtt__GetCoverageIndex(stbtt_uint8 *coverageTable, int glyph)
|
|
|
+{
|
|
|
+ stbtt_uint16 coverageFormat = ttUSHORT(coverageTable);
|
|
|
+ switch (coverageFormat) {
|
|
|
+ case 1: {
|
|
|
+ stbtt_uint16 glyphCount = ttUSHORT(coverageTable + 2);
|
|
|
+
|
|
|
+ /* Binary search. */
|
|
|
+ stbtt_int32 l=0, r=glyphCount-1, m;
|
|
|
+ int straw, needle=glyph;
|
|
|
+ while (l <= r) {
|
|
|
+ stbtt_uint8 *glyphArray = coverageTable + 4;
|
|
|
+ stbtt_uint16 glyphID;
|
|
|
+ m = (l + r) >> 1;
|
|
|
+ glyphID = ttUSHORT(glyphArray + 2 * m);
|
|
|
+ straw = glyphID;
|
|
|
+ if (needle < straw)
|
|
|
+ r = m - 1;
|
|
|
+ else if (needle > straw)
|
|
|
+ l = m + 1;
|
|
|
+ else {
|
|
|
+ return m;
|
|
|
}
|
|
|
- } break;
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ }
|
|
|
|
|
|
- case 2: {
|
|
|
- stbtt_uint16 rangeCount = ttUSHORT(coverageTable + 2);
|
|
|
- stbtt_uint8 *rangeArray = coverageTable + 4;
|
|
|
-
|
|
|
- /* Binary search. */
|
|
|
- stbtt_int32 l=0, r=rangeCount-1, m;
|
|
|
- int strawStart, strawEnd, needle=glyph;
|
|
|
- while (l <= r) {
|
|
|
- stbtt_uint8 *rangeRecord;
|
|
|
- m = (l + r) >> 1;
|
|
|
- rangeRecord = rangeArray + 6 * m;
|
|
|
- strawStart = ttUSHORT(rangeRecord);
|
|
|
- strawEnd = ttUSHORT(rangeRecord + 2);
|
|
|
- if (needle < strawStart)
|
|
|
- r = m - 1;
|
|
|
- else if (needle > strawEnd)
|
|
|
- l = m + 1;
|
|
|
- else {
|
|
|
- stbtt_uint16 startCoverageIndex = ttUSHORT(rangeRecord + 4);
|
|
|
- return startCoverageIndex + glyph - strawStart;
|
|
|
- }
|
|
|
+ case 2: {
|
|
|
+ stbtt_uint16 rangeCount = ttUSHORT(coverageTable + 2);
|
|
|
+ stbtt_uint8 *rangeArray = coverageTable + 4;
|
|
|
+
|
|
|
+ /* Binary search. */
|
|
|
+ stbtt_int32 l=0, r=rangeCount-1, m;
|
|
|
+ int strawStart, strawEnd, needle=glyph;
|
|
|
+ while (l <= r) {
|
|
|
+ stbtt_uint8 *rangeRecord;
|
|
|
+ m = (l + r) >> 1;
|
|
|
+ rangeRecord = rangeArray + 6 * m;
|
|
|
+ strawStart = ttUSHORT(rangeRecord);
|
|
|
+ strawEnd = ttUSHORT(rangeRecord + 2);
|
|
|
+ if (needle < strawStart)
|
|
|
+ r = m - 1;
|
|
|
+ else if (needle > strawEnd)
|
|
|
+ l = m + 1;
|
|
|
+ else {
|
|
|
+ stbtt_uint16 startCoverageIndex = ttUSHORT(rangeRecord + 4);
|
|
|
+ return startCoverageIndex + glyph - strawStart;
|
|
|
}
|
|
|
- } break;
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ }
|
|
|
|
|
|
- default: {
|
|
|
- /* There are no other cases. */
|
|
|
- STBTT_assert(0);
|
|
|
- } break;
|
|
|
- }
|
|
|
+ default: return -1; /* unsupported */
|
|
|
+ }
|
|
|
|
|
|
- return -1;
|
|
|
+ return -1;
|
|
|
}
|
|
|
|
|
|
static stbtt_int32 stbtt__GetGlyphClass(stbtt_uint8 *classDefTable, int glyph)
|
|
|
{
|
|
|
- stbtt_uint16 classDefFormat = ttUSHORT(classDefTable);
|
|
|
- switch(classDefFormat)
|
|
|
- {
|
|
|
- case 1: {
|
|
|
- stbtt_uint16 startGlyphID = ttUSHORT(classDefTable + 2);
|
|
|
- stbtt_uint16 glyphCount = ttUSHORT(classDefTable + 4);
|
|
|
- stbtt_uint8 *classDef1ValueArray = classDefTable + 6;
|
|
|
-
|
|
|
- if (glyph >= startGlyphID && glyph < startGlyphID + glyphCount)
|
|
|
- return (stbtt_int32)ttUSHORT(classDef1ValueArray + 2 * (glyph - startGlyphID));
|
|
|
-
|
|
|
- classDefTable = classDef1ValueArray + 2 * glyphCount;
|
|
|
- } break;
|
|
|
+ stbtt_uint16 classDefFormat = ttUSHORT(classDefTable);
|
|
|
+ switch (classDefFormat)
|
|
|
+ {
|
|
|
+ case 1: {
|
|
|
+ stbtt_uint16 startGlyphID = ttUSHORT(classDefTable + 2);
|
|
|
+ stbtt_uint16 glyphCount = ttUSHORT(classDefTable + 4);
|
|
|
+ stbtt_uint8 *classDef1ValueArray = classDefTable + 6;
|
|
|
|
|
|
- case 2: {
|
|
|
- stbtt_uint16 classRangeCount = ttUSHORT(classDefTable + 2);
|
|
|
- stbtt_uint8 *classRangeRecords = classDefTable + 4;
|
|
|
-
|
|
|
- /* Binary search. */
|
|
|
- stbtt_int32 l=0, r=classRangeCount-1, m;
|
|
|
- int strawStart, strawEnd, needle=glyph;
|
|
|
- while (l <= r) {
|
|
|
- stbtt_uint8 *classRangeRecord;
|
|
|
- m = (l + r) >> 1;
|
|
|
- classRangeRecord = classRangeRecords + 6 * m;
|
|
|
- strawStart = ttUSHORT(classRangeRecord);
|
|
|
- strawEnd = ttUSHORT(classRangeRecord + 2);
|
|
|
- if (needle < strawStart)
|
|
|
- r = m - 1;
|
|
|
- else if (needle > strawEnd)
|
|
|
- l = m + 1;
|
|
|
- else
|
|
|
- return (stbtt_int32)ttUSHORT(classRangeRecord + 4);
|
|
|
- }
|
|
|
+ if (glyph >= startGlyphID && glyph < startGlyphID + glyphCount)
|
|
|
+ return (stbtt_int32)ttUSHORT(classDef1ValueArray + 2 * (glyph - startGlyphID));
|
|
|
+ break;
|
|
|
+ }
|
|
|
|
|
|
- classDefTable = classRangeRecords + 6 * classRangeCount;
|
|
|
- } break;
|
|
|
+ case 2: {
|
|
|
+ stbtt_uint16 classRangeCount = ttUSHORT(classDefTable + 2);
|
|
|
+ stbtt_uint8 *classRangeRecords = classDefTable + 4;
|
|
|
+
|
|
|
+ /* Binary search. */
|
|
|
+ stbtt_int32 l=0, r=classRangeCount-1, m;
|
|
|
+ int strawStart, strawEnd, needle=glyph;
|
|
|
+ while (l <= r) {
|
|
|
+ stbtt_uint8 *classRangeRecord;
|
|
|
+ m = (l + r) >> 1;
|
|
|
+ classRangeRecord = classRangeRecords + 6 * m;
|
|
|
+ strawStart = ttUSHORT(classRangeRecord);
|
|
|
+ strawEnd = ttUSHORT(classRangeRecord + 2);
|
|
|
+ if (needle < strawStart)
|
|
|
+ r = m - 1;
|
|
|
+ else if (needle > strawEnd)
|
|
|
+ l = m + 1;
|
|
|
+ else
|
|
|
+ return (stbtt_int32)ttUSHORT(classRangeRecord + 4);
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ }
|
|
|
|
|
|
- default: {
|
|
|
- /* There are no other cases. */
|
|
|
- STBTT_assert(0);
|
|
|
- } break;
|
|
|
- }
|
|
|
+ default:
|
|
|
+ return -1; /* Unsupported definition type, return an error. */
|
|
|
+ }
|
|
|
|
|
|
- return -1;
|
|
|
+ /* "All glyphs not assigned to a class fall into class 0". (OpenType spec) */
|
|
|
+ return 0;
|
|
|
}
|
|
|
|
|
|
/* 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)
|
|
|
-{
|
|
|
- stbtt_uint16 lookupListOffset;
|
|
|
- stbtt_uint8 *lookupList;
|
|
|
- stbtt_uint16 lookupCount;
|
|
|
- stbtt_uint8 *data;
|
|
|
- stbtt_int32 i;
|
|
|
-
|
|
|
- if (!info->gpos) return 0;
|
|
|
-
|
|
|
- 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 */
|
|
|
-
|
|
|
- lookupListOffset = ttUSHORT(data+8);
|
|
|
- lookupList = data + lookupListOffset;
|
|
|
- lookupCount = ttUSHORT(lookupList);
|
|
|
-
|
|
|
- for (i=0; i<lookupCount; ++i) {
|
|
|
- stbtt_uint16 lookupOffset = ttUSHORT(lookupList + 2 + 2 * i);
|
|
|
- stbtt_uint8 *lookupTable = lookupList + lookupOffset;
|
|
|
-
|
|
|
- stbtt_uint16 lookupType = ttUSHORT(lookupTable);
|
|
|
- stbtt_uint16 subTableCount = ttUSHORT(lookupTable + 4);
|
|
|
- stbtt_uint8 *subTableOffsets = lookupTable + 6;
|
|
|
- switch(lookupType) {
|
|
|
- case 2: { /* Pair Adjustment Positioning Subtable */
|
|
|
- stbtt_int32 sti;
|
|
|
- for (sti=0; sti<subTableCount; sti++) {
|
|
|
- stbtt_uint16 subtableOffset = ttUSHORT(subTableOffsets + 2 * sti);
|
|
|
- stbtt_uint8 *table = lookupTable + subtableOffset;
|
|
|
- stbtt_uint16 posFormat = ttUSHORT(table);
|
|
|
- stbtt_uint16 coverageOffset = ttUSHORT(table + 2);
|
|
|
- stbtt_int32 coverageIndex = stbtt__GetCoverageIndex(table + coverageOffset, glyph1);
|
|
|
- if (coverageIndex == -1) continue;
|
|
|
-
|
|
|
- switch (posFormat) {
|
|
|
- case 1: {
|
|
|
- stbtt_int32 l, r, m;
|
|
|
- int straw, needle;
|
|
|
- stbtt_uint16 valueFormat1 = ttUSHORT(table + 4);
|
|
|
- stbtt_uint16 valueFormat2 = ttUSHORT(table + 6);
|
|
|
- stbtt_int32 valueRecordPairSizeInBytes = 2;
|
|
|
- stbtt_uint16 pairSetCount = ttUSHORT(table + 8);
|
|
|
- stbtt_uint16 pairPosOffset = ttUSHORT(table + 10 + 2 * coverageIndex);
|
|
|
- stbtt_uint8 *pairValueTable = table + pairPosOffset;
|
|
|
- stbtt_uint16 pairValueCount = ttUSHORT(pairValueTable);
|
|
|
- stbtt_uint8 *pairValueArray = pairValueTable + 2;
|
|
|
- /* TODO: Support more formats. */
|
|
|
- STBTT_GPOS_TODO_assert(valueFormat1 == 4);
|
|
|
- if (valueFormat1 != 4) return 0;
|
|
|
- STBTT_GPOS_TODO_assert(valueFormat2 == 0);
|
|
|
- if (valueFormat2 != 0) return 0;
|
|
|
-
|
|
|
- STBTT_assert(coverageIndex < pairSetCount);
|
|
|
- STBTT__NOTUSED(pairSetCount);
|
|
|
-
|
|
|
- needle=glyph2;
|
|
|
- r=pairValueCount-1;
|
|
|
- l=0;
|
|
|
-
|
|
|
- /* Binary search. */
|
|
|
- while (l <= r) {
|
|
|
- stbtt_uint16 secondGlyph;
|
|
|
- stbtt_uint8 *pairValue;
|
|
|
- m = (l + r) >> 1;
|
|
|
- pairValue = pairValueArray + (2 + valueRecordPairSizeInBytes) * m;
|
|
|
- secondGlyph = ttUSHORT(pairValue);
|
|
|
- straw = secondGlyph;
|
|
|
- if (needle < straw)
|
|
|
- r = m - 1;
|
|
|
- else if (needle > straw)
|
|
|
- l = m + 1;
|
|
|
- else {
|
|
|
- stbtt_int16 xAdvance = ttSHORT(pairValue + 2);
|
|
|
- return xAdvance;
|
|
|
- }
|
|
|
- }
|
|
|
- } break;
|
|
|
-
|
|
|
- case 2: {
|
|
|
- stbtt_uint16 valueFormat1 = ttUSHORT(table + 4);
|
|
|
- stbtt_uint16 valueFormat2 = ttUSHORT(table + 6);
|
|
|
-
|
|
|
- stbtt_uint16 classDef1Offset = ttUSHORT(table + 8);
|
|
|
- stbtt_uint16 classDef2Offset = ttUSHORT(table + 10);
|
|
|
- int glyph1class = stbtt__GetGlyphClass(table + classDef1Offset, glyph1);
|
|
|
- int glyph2class = stbtt__GetGlyphClass(table + classDef2Offset, glyph2);
|
|
|
-
|
|
|
- stbtt_uint16 class1Count = ttUSHORT(table + 12);
|
|
|
- stbtt_uint16 class2Count = ttUSHORT(table + 14);
|
|
|
- STBTT_assert(glyph1class < class1Count);
|
|
|
- STBTT_assert(glyph2class < class2Count);
|
|
|
-
|
|
|
- /* TODO: Support more formats. */
|
|
|
- STBTT_GPOS_TODO_assert(valueFormat1 == 4);
|
|
|
- if (valueFormat1 != 4) return 0;
|
|
|
- STBTT_GPOS_TODO_assert(valueFormat2 == 0);
|
|
|
- if (valueFormat2 != 0) return 0;
|
|
|
-
|
|
|
- if (glyph1class >= 0 && glyph1class < class1Count && glyph2class >= 0 && glyph2class < class2Count) {
|
|
|
- stbtt_uint8 *class1Records = table + 16;
|
|
|
- stbtt_uint8 *class2Records = class1Records + 2 * (glyph1class * class2Count);
|
|
|
- stbtt_int16 xAdvance = ttSHORT(class2Records + 2 * glyph2class);
|
|
|
- return xAdvance;
|
|
|
- }
|
|
|
- } break;
|
|
|
-
|
|
|
- default: {
|
|
|
- /* There are no other cases. */
|
|
|
- STBTT_assert(0);
|
|
|
- break;
|
|
|
- };
|
|
|
- }
|
|
|
- }
|
|
|
- break;
|
|
|
- };
|
|
|
+static stbtt_int32 stbtt__GetGlyphGPOSInfoAdvance(const stbtt_fontinfo *info, int glyph1, int glyph2)
|
|
|
+{
|
|
|
+ stbtt_uint16 lookupListOffset;
|
|
|
+ stbtt_uint8 *lookupList;
|
|
|
+ stbtt_uint16 lookupCount;
|
|
|
+ stbtt_uint8 *data;
|
|
|
+ stbtt_int32 i, sti;
|
|
|
+
|
|
|
+ if (!info->gpos) return 0;
|
|
|
+
|
|
|
+ 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 */
|
|
|
+
|
|
|
+ lookupListOffset = ttUSHORT(data+8);
|
|
|
+ lookupList = data + lookupListOffset;
|
|
|
+ lookupCount = ttUSHORT(lookupList);
|
|
|
+
|
|
|
+ for (i=0; i<lookupCount; ++i) {
|
|
|
+ stbtt_uint16 lookupOffset = ttUSHORT(lookupList + 2 + 2 * i);
|
|
|
+ stbtt_uint8 *lookupTable = lookupList + lookupOffset;
|
|
|
+
|
|
|
+ stbtt_uint16 lookupType = ttUSHORT(lookupTable);
|
|
|
+ stbtt_uint16 subTableCount = ttUSHORT(lookupTable + 4);
|
|
|
+ stbtt_uint8 *subTableOffsets = lookupTable + 6;
|
|
|
+ if (lookupType != 2) /* Pair Adjustment Positioning Subtable */
|
|
|
+ continue;
|
|
|
+
|
|
|
+ for (sti=0; sti<subTableCount; sti++) {
|
|
|
+ stbtt_uint16 subtableOffset = ttUSHORT(subTableOffsets + 2 * sti);
|
|
|
+ stbtt_uint8 *table = lookupTable + subtableOffset;
|
|
|
+ stbtt_uint16 posFormat = ttUSHORT(table);
|
|
|
+ stbtt_uint16 coverageOffset = ttUSHORT(table + 2);
|
|
|
+ stbtt_int32 coverageIndex = stbtt__GetCoverageIndex(table + coverageOffset, glyph1);
|
|
|
+ if (coverageIndex == -1) continue;
|
|
|
+
|
|
|
+ switch (posFormat) {
|
|
|
+ case 1: {
|
|
|
+ stbtt_int32 l, r, m;
|
|
|
+ int straw, needle;
|
|
|
+ stbtt_uint16 valueFormat1 = ttUSHORT(table + 4);
|
|
|
+ stbtt_uint16 valueFormat2 = ttUSHORT(table + 6);
|
|
|
+ if (valueFormat1 == 4 && valueFormat2 == 0) { /* Support more formats? */
|
|
|
+ stbtt_int32 valueRecordPairSizeInBytes = 2;
|
|
|
+ stbtt_uint16 pairSetCount = ttUSHORT(table + 8);
|
|
|
+ stbtt_uint16 pairPosOffset = ttUSHORT(table + 10 + 2 * coverageIndex);
|
|
|
+ stbtt_uint8 *pairValueTable = table + pairPosOffset;
|
|
|
+ stbtt_uint16 pairValueCount = ttUSHORT(pairValueTable);
|
|
|
+ stbtt_uint8 *pairValueArray = pairValueTable + 2;
|
|
|
+
|
|
|
+ if (coverageIndex >= pairSetCount) return 0;
|
|
|
+
|
|
|
+ needle=glyph2;
|
|
|
+ r=pairValueCount-1;
|
|
|
+ l=0;
|
|
|
+
|
|
|
+ /* Binary search. */
|
|
|
+ while (l <= r) {
|
|
|
+ stbtt_uint16 secondGlyph;
|
|
|
+ stbtt_uint8 *pairValue;
|
|
|
+ m = (l + r) >> 1;
|
|
|
+ pairValue = pairValueArray + (2 + valueRecordPairSizeInBytes) * m;
|
|
|
+ secondGlyph = ttUSHORT(pairValue);
|
|
|
+ straw = secondGlyph;
|
|
|
+ if (needle < straw)
|
|
|
+ r = m - 1;
|
|
|
+ else if (needle > straw)
|
|
|
+ l = m + 1;
|
|
|
+ else {
|
|
|
+ stbtt_int16 xAdvance = ttSHORT(pairValue + 2);
|
|
|
+ return xAdvance;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } else
|
|
|
+ return 0;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ case 2: {
|
|
|
+ stbtt_uint16 valueFormat1 = ttUSHORT(table + 4);
|
|
|
+ stbtt_uint16 valueFormat2 = ttUSHORT(table + 6);
|
|
|
+ if (valueFormat1 == 4 && valueFormat2 == 0) { /* Support more formats? */
|
|
|
+ stbtt_uint16 classDef1Offset = ttUSHORT(table + 8);
|
|
|
+ stbtt_uint16 classDef2Offset = ttUSHORT(table + 10);
|
|
|
+ int glyph1class = stbtt__GetGlyphClass(table + classDef1Offset, glyph1);
|
|
|
+ int glyph2class = stbtt__GetGlyphClass(table + classDef2Offset, glyph2);
|
|
|
+
|
|
|
+ stbtt_uint16 class1Count = ttUSHORT(table + 12);
|
|
|
+ stbtt_uint16 class2Count = ttUSHORT(table + 14);
|
|
|
+ stbtt_uint8 *class1Records, *class2Records;
|
|
|
+ stbtt_int16 xAdvance;
|
|
|
+
|
|
|
+ if (glyph1class < 0 || glyph1class >= class1Count) return 0; /* malformed */
|
|
|
+ if (glyph2class < 0 || glyph2class >= class2Count) return 0; /* malformed */
|
|
|
+
|
|
|
+ class1Records = table + 16;
|
|
|
+ class2Records = class1Records + 2 * (glyph1class * class2Count);
|
|
|
+ xAdvance = ttSHORT(class2Records + 2 * glyph2class);
|
|
|
+ return xAdvance;
|
|
|
+ } else
|
|
|
+ return 0;
|
|
|
+ break;
|
|
|
+ }
|
|
|
|
|
|
default:
|
|
|
- /* TODO: Implement other stuff. */
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
+ return 0; /* Unsupported position format */
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
|
|
|
- return 0;
|
|
|
+ return 0;
|
|
|
}
|
|
|
|
|
|
STBTT_DEF int stbtt_GetGlyphKernAdvance(const stbtt_fontinfo *info, int g1, int g2)
|
|
|
@@ -14420,6 +14402,23 @@ static void stbtt__handle_clipped_edge(float *scanline, int x, stbtt__active_edg
|
|
|
}
|
|
|
}
|
|
|
|
|
|
+static float stbtt__sized_trapezoid_area(float height, float top_width, float bottom_width)
|
|
|
+{
|
|
|
+ STBTT_assert(top_width >= 0);
|
|
|
+ STBTT_assert(bottom_width >= 0);
|
|
|
+ return (top_width + bottom_width) / 2.0f * height;
|
|
|
+}
|
|
|
+
|
|
|
+static float stbtt__position_trapezoid_area(float height, float tx0, float tx1, float bx0, float bx1)
|
|
|
+{
|
|
|
+ return stbtt__sized_trapezoid_area(height, tx1 - tx0, bx1 - bx0);
|
|
|
+}
|
|
|
+
|
|
|
+static float stbtt__sized_triangle_area(float height, float width)
|
|
|
+{
|
|
|
+ return height * width / 2;
|
|
|
+}
|
|
|
+
|
|
|
static void stbtt__fill_active_edges_new(float *scanline, float *scanline_fill, int len, stbtt__active_edge *e, float y_top)
|
|
|
{
|
|
|
float y_bottom = y_top+1;
|
|
|
@@ -14474,13 +14473,13 @@ static void stbtt__fill_active_edges_new(float *scanline, float *scanline_fill,
|
|
|
float height;
|
|
|
/* simple case, only spans one pixel */
|
|
|
int x = (int) x_top;
|
|
|
- height = sy1 - sy0;
|
|
|
+ height = (sy1 - sy0) * e->direction;
|
|
|
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[x] += stbtt__position_trapezoid_area(height, x_top, x+1.0f, x_bottom, x+1.0f);
|
|
|
+ scanline_fill[x] += height; /* everything right of this pixel is filled */
|
|
|
} else {
|
|
|
int x,x1,x2;
|
|
|
- float y_crossing, step, sign, area;
|
|
|
+ float y_crossing, y_final, step, sign, area;
|
|
|
/* covers 2+ pixels */
|
|
|
if (x_top > x_bottom) {
|
|
|
/* flip scanline vertically; signed area is the same */
|
|
|
@@ -14493,29 +14492,79 @@ static void stbtt__fill_active_edges_new(float *scanline, float *scanline_fill,
|
|
|
dy = -dy;
|
|
|
t = x0, x0 = xb, xb = t;
|
|
|
}
|
|
|
+ STBTT_assert(dy >= 0);
|
|
|
+ STBTT_assert(dx >= 0);
|
|
|
|
|
|
x1 = (int) x_top;
|
|
|
x2 = (int) x_bottom;
|
|
|
/* compute intersection with y axis at x1+1 */
|
|
|
- y_crossing = (x1+1 - x0) * dy + y_top;
|
|
|
+ y_crossing = y_top + dy * (x1+1 - x0);
|
|
|
+
|
|
|
+ /* compute intersection with y axis at x2 */
|
|
|
+ y_final = y_top + dy * (x2 - x0);
|
|
|
+
|
|
|
+ /* x1 x_top x2 x_bottom */
|
|
|
+ /* y_top +------|-----+------------+------------+--------|---+------------+ */
|
|
|
+ /* | | | | | | */
|
|
|
+ /* | | | | | | */
|
|
|
+ /* sy0 | Txxxxx|............|............|............|............| */
|
|
|
+ /* y_crossing | *xxxxx.......|............|............|............| */
|
|
|
+ /* | | xxxxx..|............|............|............| */
|
|
|
+ /* | | /- xx*xxxx........|............|............| */
|
|
|
+ /* | | dy < | xxxxxx..|............|............| */
|
|
|
+ /* y_final | | \- | xx*xxx.........|............| */
|
|
|
+ /* sy1 | | | | xxxxxB...|............| */
|
|
|
+ /* | | | | | | */
|
|
|
+ /* | | | | | | */
|
|
|
+ /* y_bottom +------------+------------+------------+------------+------------+ */
|
|
|
+ /* */
|
|
|
+ /* goal is to measure the area covered by '.' in each pixel */
|
|
|
+
|
|
|
+ /* if x2 is right at the right edge of x1, y_crossing can blow up, github #1057 */
|
|
|
+ /* @TODO: maybe test against sy1 rather than y_bottom? */
|
|
|
+ if (y_crossing > y_bottom)
|
|
|
+ y_crossing = y_bottom;
|
|
|
|
|
|
sign = e->direction;
|
|
|
- /* area of the rectangle covered from y0..y_crossing */
|
|
|
+
|
|
|
+ /* area of the rectangle covered from sy0..y_crossing */
|
|
|
area = sign * (y_crossing-sy0);
|
|
|
- /* 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;
|
|
|
+ /* area of the triangle (x_top,sy0), (x1+1,sy0), (x1+1,y_crossing) */
|
|
|
+ scanline[x1] += stbtt__sized_triangle_area(area, x1+1 - x_top);
|
|
|
+
|
|
|
+ /* check if final y_crossing is blown up; no test case for this */
|
|
|
+ if (y_final > y_bottom) {
|
|
|
+ y_final = y_bottom;
|
|
|
+ dy = (y_final - y_crossing ) / (x2 - (x1+1)); /* if denom=0, y_final = y_crossing, so y_final <= y_bottom */
|
|
|
+ }
|
|
|
+
|
|
|
+ /* in second pixel, area covered by line segment found in first pixel */
|
|
|
+ /* is always a rectangle 1 wide * the height of that line segment; this */
|
|
|
+ /* is exactly what the variable 'area' stores. it also gets a contribution */
|
|
|
+ /* from the line segment within it. the THIRD pixel will get the first */
|
|
|
+ /* pixel's rectangle contribution, the second pixel's rectangle contribution, */
|
|
|
+ /* and its own contribution. the 'own contribution' is the same in every pixel except */
|
|
|
+ /* the leftmost and rightmost, a trapezoid that slides down in each pixel. */
|
|
|
+ /* the second pixel's contribution to the third pixel will be the */
|
|
|
+ /* rectangle 1 wide times the height change in the second pixel, which is dy. */
|
|
|
+
|
|
|
+ step = sign * dy * 1; /* dy is dy/dx, change in y for every 1 change in x, */
|
|
|
+ /* which multiplied by 1-pixel-width is how much pixel area changes for each step in x */
|
|
|
+ /* so the area advances by 'step' every time */
|
|
|
+
|
|
|
for (x = x1+1; x < x2; ++x) {
|
|
|
- scanline[x] += area + step/2;
|
|
|
+ scanline[x] += area + step/2; /* area of trapezoid is 1*step/2 */
|
|
|
area += step;
|
|
|
}
|
|
|
- y_crossing += dy * (x2 - (x1+1));
|
|
|
-
|
|
|
- STBTT_assert(STBTT_fabs(area) <= 1.01f);
|
|
|
+ STBTT_assert(STBTT_fabs(area) <= 1.01f); /* accumulated error from area += step unless we round step down */
|
|
|
+ STBTT_assert(sy1 > y_final-0.01f);
|
|
|
|
|
|
- scanline[x2] += area + sign * (1-((x2-x2)+(x_bottom-x2))/2) * (sy1-y_crossing);
|
|
|
+ /* area covered in the last pixel is the rectangle from all the pixels to the left, */
|
|
|
+ /* plus the trapezoid filled by the line segment in this pixel all the way to the right edge */
|
|
|
+ scanline[x2] += area + sign * stbtt__position_trapezoid_area(sy1-y_final, (float) x2, x2+1.0f, x_bottom, x2+1.0f);
|
|
|
|
|
|
+ /* the rest of the line is filled based on the total height of the line segment in this pixel */
|
|
|
scanline_fill[x2] += sign * (sy1-sy0);
|
|
|
}
|
|
|
} else {
|
|
|
@@ -14523,6 +14572,9 @@ static void stbtt__fill_active_edges_new(float *scanline, float *scanline_fill,
|
|
|
/* clipping logic. since this does not match the intended use */
|
|
|
/* of this library, we use a different, very slow brute */
|
|
|
/* force implementation */
|
|
|
+ /* note though that this does happen some of the time because */
|
|
|
+ /* x_top and x_bottom can be extrapolated at the top & bottom of */
|
|
|
+ /* the shape and actually lie outside the bounding box */
|
|
|
int x;
|
|
|
for (x=0; x < len; ++x) {
|
|
|
/* cases: */
|
|
|
@@ -15759,15 +15811,14 @@ static int stbtt__compute_crossings_x(float x, float y, int nverts, stbtt_vertex
|
|
|
float y_frac;
|
|
|
int winding = 0;
|
|
|
|
|
|
- orig[0] = x;
|
|
|
- orig[1] = y;
|
|
|
-
|
|
|
/* 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;
|
|
|
else if (y_frac > 0.99f)
|
|
|
y -= 0.01f;
|
|
|
+
|
|
|
+ orig[0] = x;
|
|
|
orig[1] = y;
|
|
|
|
|
|
/* test a ray from (-infinity,y) to (x,y) */
|
|
|
@@ -15829,35 +15880,35 @@ 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 + a*x^2 + b*x + c = 0 */
|
|
|
static int stbtt__solve_cubic(float a, float b, float c, float* r)
|
|
|
{
|
|
|
- float s = -a / 3;
|
|
|
- float p = b - a*a / 3;
|
|
|
- float q = a * (2*a*a - 9*b) / 27 + c;
|
|
|
+ float s = -a / 3;
|
|
|
+ float p = b - a*a / 3;
|
|
|
+ float q = a * (2*a*a - 9*b) / 27 + c;
|
|
|
float p3 = p*p*p;
|
|
|
- float d = q*q + 4*p3 / 27;
|
|
|
- if (d >= 0) {
|
|
|
- float z = (float) STBTT_sqrt(d);
|
|
|
- float u = (-q + z) / 2;
|
|
|
- float v = (-q - z) / 2;
|
|
|
- u = stbtt__cuberoot(u);
|
|
|
- v = stbtt__cuberoot(v);
|
|
|
- r[0] = s + u + v;
|
|
|
- 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 m = (float) STBTT_cos(v);
|
|
|
+ float d = q*q + 4*p3 / 27;
|
|
|
+ if (d >= 0) {
|
|
|
+ float z = (float) STBTT_sqrt(d);
|
|
|
+ float u = (-q + z) / 2;
|
|
|
+ float v = (-q - z) / 2;
|
|
|
+ u = stbtt__cuberoot(u);
|
|
|
+ v = stbtt__cuberoot(v);
|
|
|
+ r[0] = s + u + v;
|
|
|
+ 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 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);
|
|
|
+ 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); */
|
|
|
- return 3;
|
|
|
+ return 3;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
@@ -15934,18 +15985,17 @@ STBTT_DEF unsigned char * stbtt_GetGlyphSDF(const stbtt_fontinfo *info, float sc
|
|
|
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 */
|
|
|
- float dist2 = (x0-sx)*(x0-sx) + (y0-sy)*(y0-sy);
|
|
|
- if (dist2 < min_dist*min_dist)
|
|
|
- min_dist = (float) STBTT_sqrt(dist2);
|
|
|
-
|
|
|
- if (verts[i].type == STBTT_vline) {
|
|
|
+ if (verts[i].type == STBTT_vline && precompute[i] != 0.0f) {
|
|
|
float x1 = verts[i-1].x*scale_x, y1 = verts[i-1].y*scale_y;
|
|
|
|
|
|
+ float dist,dist2 = (x0-sx)*(x0-sx) + (y0-sy)*(y0-sy);
|
|
|
+ if (dist2 < min_dist*min_dist)
|
|
|
+ min_dist = (float) STBTT_sqrt(dist2);
|
|
|
+
|
|
|
/* 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];
|
|
|
+ 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 */
|
|
|
@@ -15972,7 +16022,8 @@ STBTT_DEF unsigned char * stbtt_GetGlyphSDF(const stbtt_fontinfo *info, float sc
|
|
|
float ax = x1-x0, ay = y1-y0;
|
|
|
float bx = x0 - 2*x1 + x2, by = y0 - 2*y1 + y2;
|
|
|
float mx = x0 - sx, my = y0 - sy;
|
|
|
- float res[3],px,py,t,it;
|
|
|
+ float res[3] = {0.f,0.f,0.f};
|
|
|
+ float px,py,t,it,dist2;
|
|
|
float a_inv = precompute[i];
|
|
|
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);
|
|
|
@@ -15999,6 +16050,10 @@ STBTT_DEF unsigned char * stbtt_GetGlyphSDF(const stbtt_fontinfo *info, float sc
|
|
|
float d = (mx*ax+my*ay) * a_inv;
|
|
|
num = stbtt__solve_cubic(b, c, d, res);
|
|
|
}
|
|
|
+ dist2 = (x0-sx)*(x0-sx) + (y0-sy)*(y0-sy);
|
|
|
+ if (dist2 < min_dist*min_dist)
|
|
|
+ min_dist = (float) STBTT_sqrt(dist2);
|
|
|
+
|
|
|
if (num >= 1 && res[0] >= 0.0f && res[0] <= 1.0f) {
|
|
|
t = res[0], it = 1.0f - t;
|
|
|
px = it*it*x0 + 2*t*it*x1 + t*t*x2;
|
|
|
@@ -16258,6 +16313,12 @@ STBTT_DEF int stbtt_CompareUTF8toUTF16_bigendian(const char *s1, int len1, const
|
|
|
|
|
|
/* FULL VERSION HISTORY */
|
|
|
/* */
|
|
|
+/* 1.25 (2021-07-11) many fixes */
|
|
|
+/* 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) 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 */
|
|
|
@@ -29560,6 +29621,7 @@ nk_tooltipfv(struct nk_context *ctx, const char *fmt, va_list args)
|
|
|
/// - [yy]: Minor version with non-breaking API and library changes
|
|
|
/// - [zz]: Bug fix version with no direct changes to API
|
|
|
///
|
|
|
+/// - 2021/12/14 (4.09.1) - Update to stb_rect_pack.h v1.01 and stb_truetype.h v1.26
|
|
|
/// - 2021/10/16 (4.09.0) - Added nk_spacer() widget
|
|
|
/// - 2021/09/22 (4.08.6) - Fix "may be used uninitialized" warnings in nk_widget
|
|
|
/// - 2021/09/22 (4.08.5) - GCC __builtin_offsetof only exists in version 4 and later
|
Rob Loach