244 #define STB_TRUETYPE_IMPLEMENTATION
247 unsigned char ttf_buffer[1<<20];
248 unsigned char temp_bitmap[512*512];
253 void my_stbtt_initfont(
void)
255 fread(ttf_buffer, 1, 1<<20, fopen(
"c:/windows/fonts/times.ttf",
"rb"));
258 glGenTextures(1, &ftex);
259 glBindTexture(GL_TEXTURE_2D, ftex);
260 glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, 512,512, 0, GL_ALPHA, GL_UNSIGNED_BYTE, temp_bitmap);
262 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
265 void my_stbtt_print(
float x,
float y,
char *text)
268 glEnable(GL_TEXTURE_2D);
269 glBindTexture(GL_TEXTURE_2D, ftex);
272 if (*text >= 32 && *text < 128) {
275 glTexCoord2f(q.
s0,q.
t1); glVertex2f(q.
x0,q.
y0);
276 glTexCoord2f(q.
s1,q.
t1); glVertex2f(q.
x1,q.
y0);
277 glTexCoord2f(q.
s1,q.
t0); glVertex2f(q.
x1,q.
y1);
278 glTexCoord2f(q.
s0,q.
t0); glVertex2f(q.
x0,q.
y1);
293 #define STB_TRUETYPE_IMPLEMENTATION
296 char ttf_buffer[1<<25];
298 int main(
int argc,
char **argv)
301 unsigned char *bitmap;
302 int w,h,i,j,c = (argc > 1 ? atoi(argv[1]) :
'a'), s = (argc > 2 ? atoi(argv[2]) : 20);
304 fread(ttf_buffer, 1, 1<<25, fopen(argc > 3 ? argv[3] :
"c:/windows/fonts/arialbd.ttf",
"rb"));
309 for (j=0; j < h; ++j) {
310 for (i=0; i < w; ++i)
311 putchar(
" .:ioVM@"[bitmap[j*w+i]>>5]);
337 unsigned char screen[20][79];
339 int main(
int arg,
char **argv)
342 int i,j,ascent,baseline,ch=0;
344 char *text =
"Heljo World!";
346 fread(buffer, 1, 1000000, fopen(
"c:/windows/fonts/arialbd.ttf",
"rb"));
351 baseline = (int) (ascent*scale);
354 int advance,lsb,x0,y0,x1,y1;
355 float x_shift = xpos - (float) floor(xpos);
363 xpos += (advance * scale);
369 for (j=0; j < 20; ++j) {
370 for (i=0; i < 78; ++i)
371 putchar(
" .:ioVM@"[screen[j][i]>>5]);
388 #ifdef STB_TRUETYPE_IMPLEMENTATION
391 typedef unsigned char stbtt_uint8;
392 typedef signed char stbtt_int8;
393 typedef unsigned short stbtt_uint16;
394 typedef signed short stbtt_int16;
395 typedef unsigned int stbtt_uint32;
396 typedef signed int stbtt_int32;
399 typedef char stbtt__check_size32[
sizeof(stbtt_int32)==4 ? 1 : -1];
400 typedef char stbtt__check_size16[
sizeof(stbtt_int16)==2 ? 1 : -1];
405 #define STBTT_ifloor(x) ((int) floor(x))
406 #define STBTT_iceil(x) ((int) ceil(x))
411 #define STBTT_sqrt(x) sqrt(x)
412 #define STBTT_pow(x,y) pow(x,y)
417 #define STBTT_cos(x) cos(x)
418 #define STBTT_acos(x) acos(x)
423 #define STBTT_fabs(x) fabs(x)
428 #define STBTT_fabs(x) fabs(x)
434 #define STBTT_malloc(x,u) ((void)(u),malloc(x))
435 #define STBTT_free(x,u) ((void)(u),free(x))
440 #define STBTT_assert(x) assert(x)
445 #define STBTT_strlen(x) strlen(x)
450 #define STBTT_memcpy memcpy
451 #define STBTT_memset memset
462 #ifndef __STB_INCLUDE_STB_TRUETYPE_H__
463 #define __STB_INCLUDE_STB_TRUETYPE_H__
466 #define STBTT_DEF static
468 #define STBTT_DEF extern
492 unsigned short x0,y0,x1,y1;
498 unsigned char *pixels,
int pw,
int ph,
499 int first_char,
int num_chars,
514 float *xpos,
float *ypos,
516 int opengl_fillrule);
538 unsigned short x0,y0,x1,y1;
545 #ifndef STB_RECT_PACK_VERSION
563 #define STBTT_POINT_SIZE(x) (-(x))
566 int first_unicode_char_in_range,
int num_chars_in_range,
stbtt_packedchar *chardata_for_range);
614 float *xpos,
float *ypos,
616 int align_to_integer);
769 #define stbtt_vertex_type short
826 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);
847 STBTT_DEF void stbtt_MakeGlyphBitmapSubpixelPrefilter(
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 glyph);
861 float flatness_in_pixels,
864 float scale_x,
float scale_y,
865 float shift_x,
float shift_y,
866 int x_off,
int y_off,
955 #define STBTT_MACSTYLE_DONTCARE 0
956 #define STBTT_MACSTYLE_BOLD 1
957 #define STBTT_MACSTYLE_ITALIC 2
958 #define STBTT_MACSTYLE_UNDERSCORE 4
959 #define STBTT_MACSTYLE_NONE 8
1035 #ifdef STB_TRUETYPE_IMPLEMENTATION
1037 #ifndef STBTT_MAX_OVERSAMPLE
1038 #define STBTT_MAX_OVERSAMPLE 8
1041 #if STBTT_MAX_OVERSAMPLE > 255
1042 #error "STBTT_MAX_OVERSAMPLE cannot be > 255"
1045 typedef int stbtt__test_oversample_pow2[(STBTT_MAX_OVERSAMPLE & (STBTT_MAX_OVERSAMPLE-1)) == 0 ? 1 : -1];
1047 #ifndef STBTT_RASTERIZER_VERSION
1048 #define STBTT_RASTERIZER_VERSION 2
1052 #define STBTT__NOTUSED(v) (void)(v)
1054 #define STBTT__NOTUSED(v) (void)sizeof(v)
1062 static stbtt_uint8 stbtt__buf_get8(
stbtt__buf *b)
1069 static stbtt_uint8 stbtt__buf_peek8(
stbtt__buf *b)
1076 static void stbtt__buf_seek(
stbtt__buf *b,
int o)
1078 STBTT_assert(!(o > b->
size || o < 0));
1082 static void stbtt__buf_skip(
stbtt__buf *b,
int o)
1084 stbtt__buf_seek(b, b->
cursor + o);
1087 static stbtt_uint32 stbtt__buf_get(
stbtt__buf *b,
int n)
1091 STBTT_assert(n >= 1 && n <= 4);
1092 for (i = 0; i < n; i++)
1093 v = (v << 8) | stbtt__buf_get8(b);
1097 static stbtt__buf stbtt__new_buf(
const void *p,
size_t size)
1100 STBTT_assert(size < 0x40000000);
1101 r.
data = (stbtt_uint8*) p;
1102 r.
size = (int) size;
1107 #define stbtt__buf_get16(b) stbtt__buf_get((b), 2)
1108 #define stbtt__buf_get32(b) stbtt__buf_get((b), 4)
1113 if (o < 0 || s < 0 || o > b->
size || s > b->
size - o)
return r;
1121 int count, start, offsize;
1123 count = stbtt__buf_get16(b);
1125 offsize = stbtt__buf_get8(b);
1126 STBTT_assert(offsize >= 1 && offsize <= 4);
1127 stbtt__buf_skip(b, offsize * count);
1128 stbtt__buf_skip(b, stbtt__buf_get(b, offsize) - 1);
1130 return stbtt__buf_range(b, start, b->
cursor - start);
1133 static stbtt_uint32 stbtt__cff_int(
stbtt__buf *b)
1135 int b0 = stbtt__buf_get8(b);
1136 if (b0 >= 32 && b0 <= 246)
return b0 - 139;
1137 else if (b0 >= 247 && b0 <= 250)
return (b0 - 247)*256 + stbtt__buf_get8(b) + 108;
1138 else if (b0 >= 251 && b0 <= 254)
return -(b0 - 251)*256 - stbtt__buf_get8(b) - 108;
1139 else if (b0 == 28)
return stbtt__buf_get16(b);
1140 else if (b0 == 29)
return stbtt__buf_get32(b);
1145 static void stbtt__cff_skip_operand(
stbtt__buf *b) {
1146 int v, b0 = stbtt__buf_peek8(b);
1147 STBTT_assert(b0 >= 28);
1149 stbtt__buf_skip(b, 1);
1151 v = stbtt__buf_get8(b);
1152 if ((v & 0xF) == 0xF || (v >> 4) == 0xF)
1162 stbtt__buf_seek(b, 0);
1164 int start = b->
cursor, end, op;
1165 while (stbtt__buf_peek8(b) >= 28)
1166 stbtt__cff_skip_operand(b);
1168 op = stbtt__buf_get8(b);
1169 if (op == 12) op = stbtt__buf_get8(b) | 0x100;
1170 if (op == key)
return stbtt__buf_range(b, start, end-start);
1172 return stbtt__buf_range(b, 0, 0);
1175 static void stbtt__dict_get_ints(
stbtt__buf *b,
int key,
int outcount, stbtt_uint32 *out)
1178 stbtt__buf operands = stbtt__dict_get(b, key);
1179 for (i = 0; i < outcount && operands.
cursor < operands.
size; i++)
1180 out[i] = stbtt__cff_int(&operands);
1183 static int stbtt__cff_index_count(
stbtt__buf *b)
1185 stbtt__buf_seek(b, 0);
1186 return stbtt__buf_get16(b);
1191 int count, offsize, start, end;
1192 stbtt__buf_seek(&b, 0);
1193 count = stbtt__buf_get16(&b);
1194 offsize = stbtt__buf_get8(&b);
1195 STBTT_assert(i >= 0 && i < count);
1196 STBTT_assert(offsize >= 1 && offsize <= 4);
1197 stbtt__buf_skip(&b, i*offsize);
1198 start = stbtt__buf_get(&b, offsize);
1199 end = stbtt__buf_get(&b, offsize);
1200 return stbtt__buf_range(&b, 2+(count+1)*offsize+start, end - start);
1211 #define ttBYTE(p) (* (stbtt_uint8 *) (p))
1212 #define ttCHAR(p) (* (stbtt_int8 *) (p))
1213 #define ttFixed(p) ttLONG(p)
1215 static stbtt_uint16 ttUSHORT(stbtt_uint8 *p) {
return p[0]*256 + p[1]; }
1216 static stbtt_int16 ttSHORT(stbtt_uint8 *p) {
return p[0]*256 + p[1]; }
1217 static stbtt_uint32 ttULONG(stbtt_uint8 *p) {
return (p[0]<<24) + (p[1]<<16) + (p[2]<<8) + p[3]; }
1218 static stbtt_int32 ttLONG(stbtt_uint8 *p) {
return (p[0]<<24) + (p[1]<<16) + (p[2]<<8) + p[3]; }
1220 #define stbtt_tag4(p,c0,c1,c2,c3) ((p)[0] == (c0) && (p)[1] == (c1) && (p)[2] == (c2) && (p)[3] == (c3))
1221 #define stbtt_tag(p,str) stbtt_tag4(p,str[0],str[1],str[2],str[3])
1223 static int stbtt__isfont(stbtt_uint8 *font)
1226 if (stbtt_tag4(font,
'1',0,0,0))
return 1;
1227 if (stbtt_tag(font,
"typ1"))
return 1;
1228 if (stbtt_tag(font,
"OTTO"))
return 1;
1229 if (stbtt_tag4(font, 0,1,0,0))
return 1;
1230 if (stbtt_tag(font,
"true"))
return 1;
1235 static stbtt_uint32 stbtt__find_table(stbtt_uint8 *data, stbtt_uint32 fontstart,
const char *tag)
1237 stbtt_int32 num_tables = ttUSHORT(data+fontstart+4);
1238 stbtt_uint32 tabledir = fontstart + 12;
1240 for (i=0; i < num_tables; ++i) {
1241 stbtt_uint32 loc = tabledir + 16*i;
1242 if (stbtt_tag(data+loc+0, tag))
1243 return ttULONG(data+loc+8);
1248 static int stbtt_GetFontOffsetForIndex_internal(
unsigned char *font_collection,
int index)
1251 if (stbtt__isfont(font_collection))
1252 return index == 0 ? 0 : -1;
1255 if (stbtt_tag(font_collection,
"ttcf")) {
1257 if (ttULONG(font_collection+4) == 0x00010000 || ttULONG(font_collection+4) == 0x00020000) {
1258 stbtt_int32 n = ttLONG(font_collection+8);
1261 return ttULONG(font_collection+12+index*4);
1267 static int stbtt_GetNumberOfFonts_internal(
unsigned char *font_collection)
1270 if (stbtt__isfont(font_collection))
1274 if (stbtt_tag(font_collection,
"ttcf")) {
1276 if (ttULONG(font_collection+4) == 0x00010000 || ttULONG(font_collection+4) == 0x00020000) {
1277 return ttLONG(font_collection+8);
1285 stbtt_uint32 subrsoff = 0, private_loc[2] = { 0, 0 };
1287 stbtt__dict_get_ints(&fontdict, 18, 2, private_loc);
1288 if (!private_loc[1] || !private_loc[0])
return stbtt__new_buf(NULL, 0);
1289 pdict = stbtt__buf_range(&cff, private_loc[1], private_loc[0]);
1290 stbtt__dict_get_ints(&pdict, 19, 1, &subrsoff);
1291 if (!subrsoff)
return stbtt__new_buf(NULL, 0);
1292 stbtt__buf_seek(&cff, private_loc[1]+subrsoff);
1293 return stbtt__cff_get_index(&cff);
1296 static int stbtt_InitFont_internal(
stbtt_fontinfo *info,
unsigned char *data,
int fontstart)
1298 stbtt_uint32 cmap, t;
1299 stbtt_int32 i,numTables;
1303 info->
cff = stbtt__new_buf(NULL, 0);
1305 cmap = stbtt__find_table(data, fontstart,
"cmap");
1306 info->
loca = stbtt__find_table(data, fontstart,
"loca");
1307 info->
head = stbtt__find_table(data, fontstart,
"head");
1308 info->
glyf = stbtt__find_table(data, fontstart,
"glyf");
1309 info->
hhea = stbtt__find_table(data, fontstart,
"hhea");
1310 info->
hmtx = stbtt__find_table(data, fontstart,
"hmtx");
1311 info->
kern = stbtt__find_table(data, fontstart,
"kern");
1313 if (!cmap || !info->
head || !info->
hhea || !info->
hmtx)
1317 if (!info->
loca)
return 0;
1321 stbtt_uint32 cstype = 2, charstrings = 0, fdarrayoff = 0, fdselectoff = 0;
1324 cff = stbtt__find_table(data, fontstart,
"CFF ");
1327 info->
fontdicts = stbtt__new_buf(NULL, 0);
1328 info->
fdselect = stbtt__new_buf(NULL, 0);
1331 info->
cff = stbtt__new_buf(data+cff, 512*1024*1024);
1335 stbtt__buf_skip(&b, 2);
1336 stbtt__buf_seek(&b, stbtt__buf_get8(&b));
1340 stbtt__cff_get_index(&b);
1341 topdictidx = stbtt__cff_get_index(&b);
1342 topdict = stbtt__cff_index_get(topdictidx, 0);
1343 stbtt__cff_get_index(&b);
1344 info->
gsubrs = stbtt__cff_get_index(&b);
1346 stbtt__dict_get_ints(&topdict, 17, 1, &charstrings);
1347 stbtt__dict_get_ints(&topdict, 0x100 | 6, 1, &cstype);
1348 stbtt__dict_get_ints(&topdict, 0x100 | 36, 1, &fdarrayoff);
1349 stbtt__dict_get_ints(&topdict, 0x100 | 37, 1, &fdselectoff);
1350 info->
subrs = stbtt__get_subrs(b, topdict);
1353 if (cstype != 2)
return 0;
1354 if (charstrings == 0)
return 0;
1358 if (!fdselectoff)
return 0;
1359 stbtt__buf_seek(&b, fdarrayoff);
1360 info->
fontdicts = stbtt__cff_get_index(&b);
1361 info->
fdselect = stbtt__buf_range(&b, fdselectoff, b.
size-fdselectoff);
1364 stbtt__buf_seek(&b, charstrings);
1368 t = stbtt__find_table(data, fontstart,
"maxp");
1377 numTables = ttUSHORT(data + cmap + 2);
1379 for (i=0; i < numTables; ++i) {
1380 stbtt_uint32 encoding_record = cmap + 4 + 8 * i;
1382 switch(ttUSHORT(data+encoding_record)) {
1384 switch (ttUSHORT(data+encoding_record+2)) {
1388 info->
index_map = cmap + ttULONG(data+encoding_record+4);
1395 info->
index_map = cmap + ttULONG(data+encoding_record+4);
1408 stbtt_uint8 *data = info->
data;
1409 stbtt_uint32 index_map = info->
index_map;
1411 stbtt_uint16 format = ttUSHORT(data + index_map + 0);
1413 stbtt_int32 bytes = ttUSHORT(data + index_map + 2);
1414 if (unicode_codepoint < bytes-6)
1415 return ttBYTE(data + index_map + 6 + unicode_codepoint);
1417 }
else if (format == 6) {
1418 stbtt_uint32 first = ttUSHORT(data + index_map + 6);
1419 stbtt_uint32 count = ttUSHORT(data + index_map + 8);
1420 if ((stbtt_uint32) unicode_codepoint >= first && (stbtt_uint32) unicode_codepoint < first+count)
1421 return ttUSHORT(data + index_map + 10 + (unicode_codepoint - first)*2);
1423 }
else if (format == 2) {
1426 }
else if (format == 4) {
1427 stbtt_uint16 segcount = ttUSHORT(data+index_map+6) >> 1;
1428 stbtt_uint16 searchRange = ttUSHORT(data+index_map+8) >> 1;
1429 stbtt_uint16 entrySelector = ttUSHORT(data+index_map+10);
1430 stbtt_uint16 rangeShift = ttUSHORT(data+index_map+12) >> 1;
1433 stbtt_uint32 endCount = index_map + 14;
1434 stbtt_uint32 search = endCount;
1436 if (unicode_codepoint > 0xffff)
1441 if (unicode_codepoint >= ttUSHORT(data + search + rangeShift*2))
1442 search += rangeShift*2;
1446 while (entrySelector) {
1449 end = ttUSHORT(data + search + searchRange*2);
1450 if (unicode_codepoint > end)
1451 search += searchRange*2;
1457 stbtt_uint16 offset, start;
1458 stbtt_uint16 item = (stbtt_uint16) ((search - endCount) >> 1);
1460 STBTT_assert(unicode_codepoint <= ttUSHORT(data + endCount + 2*item));
1461 start = ttUSHORT(data + index_map + 14 + segcount*2 + 2 + 2*item);
1462 if (unicode_codepoint < start)
1465 offset = ttUSHORT(data + index_map + 14 + segcount*6 + 2 + 2*item);
1467 return (stbtt_uint16) (unicode_codepoint + ttSHORT(data + index_map + 14 + segcount*4 + 2 + 2*item));
1469 return ttUSHORT(data + offset + (unicode_codepoint-start)*2 + index_map + 14 + segcount*6 + 2 + 2*item);
1471 }
else if (format == 12 || format == 13) {
1472 stbtt_uint32 ngroups = ttULONG(data+index_map+12);
1473 stbtt_int32 low,high;
1474 low = 0; high = (stbtt_int32)ngroups;
1476 while (low < high) {
1477 stbtt_int32 mid = low + ((high-low) >> 1);
1478 stbtt_uint32 start_char = ttULONG(data+index_map+16+mid*12);
1479 stbtt_uint32 end_char = ttULONG(data+index_map+16+mid*12+4);
1480 if ((stbtt_uint32) unicode_codepoint < start_char)
1482 else if ((stbtt_uint32) unicode_codepoint > end_char)
1485 stbtt_uint32 start_glyph = ttULONG(data+index_map+16+mid*12+8);
1487 return start_glyph + unicode_codepoint-start_char;
1504 static void stbtt_setvertex(
stbtt_vertex *v, stbtt_uint8 type, stbtt_int32 x, stbtt_int32 y, stbtt_int32 cx, stbtt_int32 cy)
1507 v->
x = (stbtt_int16) x;
1508 v->
y = (stbtt_int16) y;
1509 v->
cx = (stbtt_int16) cx;
1510 v->
cy = (stbtt_int16) cy;
1513 static int stbtt__GetGlyfOffset(
const stbtt_fontinfo *info,
int glyph_index)
1517 STBTT_assert(!info->
cff.
size);
1519 if (glyph_index >= info->
numGlyphs)
return -1;
1523 g1 = info->
glyf + ttUSHORT(info->
data + info->
loca + glyph_index * 2) * 2;
1524 g2 = info->
glyf + ttUSHORT(info->
data + info->
loca + glyph_index * 2 + 2) * 2;
1526 g1 = info->
glyf + ttULONG (info->
data + info->
loca + glyph_index * 4);
1527 g2 = info->
glyf + ttULONG (info->
data + info->
loca + glyph_index * 4 + 4);
1530 return g1==g2 ? -1 : g1;
1533 static int stbtt__GetGlyphInfoT2(
const stbtt_fontinfo *info,
int glyph_index,
int *x0,
int *y0,
int *x1,
int *y1);
1538 stbtt__GetGlyphInfoT2(info, glyph_index, x0, y0, x1, y1);
1540 int g = stbtt__GetGlyfOffset(info, glyph_index);
1541 if (g < 0)
return 0;
1543 if (x0) *x0 = ttSHORT(info->
data + g + 2);
1544 if (y0) *y0 = ttSHORT(info->
data + g + 4);
1545 if (x1) *x1 = ttSHORT(info->
data + g + 6);
1546 if (y1) *y1 = ttSHORT(info->
data + g + 8);
1558 stbtt_int16 numberOfContours;
1561 return stbtt__GetGlyphInfoT2(info, glyph_index, NULL, NULL, NULL, NULL) == 0;
1562 g = stbtt__GetGlyfOffset(info, glyph_index);
1563 if (g < 0)
return 1;
1564 numberOfContours = ttSHORT(info->
data + g);
1565 return numberOfContours == 0;
1568 static int stbtt__close_shape(
stbtt_vertex *vertices,
int num_vertices,
int was_off,
int start_off,
1569 stbtt_int32 sx, stbtt_int32 sy, stbtt_int32 scx, stbtt_int32 scy, stbtt_int32 cx, stbtt_int32 cy)
1573 stbtt_setvertex(&vertices[num_vertices++],
STBTT_vcurve, (cx+scx)>>1, (cy+scy)>>1, cx,cy);
1574 stbtt_setvertex(&vertices[num_vertices++],
STBTT_vcurve, sx,sy,scx,scy);
1577 stbtt_setvertex(&vertices[num_vertices++],
STBTT_vcurve,sx,sy,cx,cy);
1579 stbtt_setvertex(&vertices[num_vertices++],
STBTT_vline,sx,sy,0,0);
1581 return num_vertices;
1586 stbtt_int16 numberOfContours;
1587 stbtt_uint8 *endPtsOfContours;
1588 stbtt_uint8 *data = info->
data;
1591 int g = stbtt__GetGlyfOffset(info, glyph_index);
1595 if (g < 0)
return 0;
1597 numberOfContours = ttSHORT(data + g);
1599 if (numberOfContours > 0) {
1600 stbtt_uint8 flags=0,flagcount;
1601 stbtt_int32 ins, i,j=0,m,n, next_move, was_off=0, off, start_off=0;
1602 stbtt_int32 x,y,cx,cy,sx,sy, scx,scy;
1603 stbtt_uint8 *points;
1604 endPtsOfContours = (data + g + 10);
1605 ins = ttUSHORT(data + g + 10 + numberOfContours * 2);
1606 points = data + g + 10 + numberOfContours * 2 + 2 + ins;
1608 n = 1+ttUSHORT(endPtsOfContours + numberOfContours*2-2);
1610 m = n + 2*numberOfContours;
1626 for (i=0; i < n; ++i) {
1627 if (flagcount == 0) {
1630 flagcount = *points++;
1633 vertices[off+i].
type = flags;
1638 for (i=0; i < n; ++i) {
1639 flags = vertices[off+i].
type;
1641 stbtt_int16 dx = *points++;
1642 x += (flags & 16) ? dx : -dx;
1644 if (!(flags & 16)) {
1645 x = x + (stbtt_int16) (points[0]*256 + points[1]);
1649 vertices[off+i].
x = (stbtt_int16) x;
1654 for (i=0; i < n; ++i) {
1655 flags = vertices[off+i].
type;
1657 stbtt_int16 dy = *points++;
1658 y += (flags & 32) ? dy : -dy;
1660 if (!(flags & 32)) {
1661 y = y + (stbtt_int16) (points[0]*256 + points[1]);
1665 vertices[off+i].
y = (stbtt_int16) y;
1670 sx = sy = cx = cy = scx = scy = 0;
1671 for (i=0; i < n; ++i) {
1672 flags = vertices[off+i].
type;
1673 x = (stbtt_int16) vertices[off+i].x;
1674 y = (stbtt_int16) vertices[off+i].y;
1676 if (next_move == i) {
1678 num_vertices = stbtt__close_shape(vertices, num_vertices, was_off, start_off, sx,sy,scx,scy,cx,cy);
1681 start_off = !(flags & 1);
1687 if (!(vertices[off+i+1].type & 1)) {
1689 sx = (x + (stbtt_int32) vertices[off+i+1].x) >> 1;
1690 sy = (y + (stbtt_int32) vertices[off+i+1].y) >> 1;
1693 sx = (stbtt_int32) vertices[off+i+1].x;
1694 sy = (stbtt_int32) vertices[off+i+1].y;
1701 stbtt_setvertex(&vertices[num_vertices++],
STBTT_vmove,sx,sy,0,0);
1703 next_move = 1 + ttUSHORT(endPtsOfContours+j*2);
1708 stbtt_setvertex(&vertices[num_vertices++],
STBTT_vcurve, (cx+x)>>1, (cy+y)>>1, cx, cy);
1714 stbtt_setvertex(&vertices[num_vertices++],
STBTT_vcurve, x,y, cx, cy);
1716 stbtt_setvertex(&vertices[num_vertices++],
STBTT_vline, x,y,0,0);
1721 num_vertices = stbtt__close_shape(vertices, num_vertices, was_off, start_off, sx,sy,scx,scy,cx,cy);
1722 }
else if (numberOfContours == -1) {
1725 stbtt_uint8 *comp = data + g + 10;
1729 stbtt_uint16 flags, gidx;
1730 int comp_num_verts = 0, i;
1732 float mtx[6] = {1,0,0,1,0,0}, m, n;
1734 flags = ttSHORT(comp); comp+=2;
1735 gidx = ttSHORT(comp); comp+=2;
1739 mtx[4] = ttSHORT(comp); comp+=2;
1740 mtx[5] = ttSHORT(comp); comp+=2;
1742 mtx[4] = ttCHAR(comp); comp+=1;
1743 mtx[5] = ttCHAR(comp); comp+=1;
1750 if (flags & (1<<3)) {
1751 mtx[0] = mtx[3] = ttSHORT(comp)/16384.0f; comp+=2;
1752 mtx[1] = mtx[2] = 0;
1753 }
else if (flags & (1<<6)) {
1754 mtx[0] = ttSHORT(comp)/16384.0f; comp+=2;
1755 mtx[1] = mtx[2] = 0;
1756 mtx[3] = ttSHORT(comp)/16384.0f; comp+=2;
1757 }
else if (flags & (1<<7)) {
1758 mtx[0] = ttSHORT(comp)/16384.0f; comp+=2;
1759 mtx[1] = ttSHORT(comp)/16384.0f; comp+=2;
1760 mtx[2] = ttSHORT(comp)/16384.0f; comp+=2;
1761 mtx[3] = ttSHORT(comp)/16384.0f; comp+=2;
1765 m = (float) STBTT_sqrt(mtx[0]*mtx[0] + mtx[1]*mtx[1]);
1766 n = (float) STBTT_sqrt(mtx[2]*mtx[2] + mtx[3]*mtx[3]);
1770 if (comp_num_verts > 0) {
1772 for (i = 0; i < comp_num_verts; ++i) {
1785 if (vertices) STBTT_free(vertices, info->
userdata);
1786 if (comp_verts) STBTT_free(comp_verts, info->
userdata);
1789 if (num_vertices > 0) STBTT_memcpy(tmp, vertices, num_vertices*
sizeof(
stbtt_vertex));
1790 STBTT_memcpy(tmp+num_vertices, comp_verts, comp_num_verts*
sizeof(
stbtt_vertex));
1791 if (vertices) STBTT_free(vertices, info->
userdata);
1793 STBTT_free(comp_verts, info->
userdata);
1794 num_vertices += comp_num_verts;
1797 more = flags & (1<<5);
1799 }
else if (numberOfContours < 0) {
1806 *pvertices = vertices;
1807 return num_vertices;
1814 float first_x, first_y;
1816 stbtt_int32 min_x, max_x, min_y, max_y;
1822 #define STBTT__CSCTX_INIT(bounds) {bounds,0, 0,0, 0,0, 0,0,0,0, NULL, 0}
1824 static void stbtt__track_vertex(stbtt__csctx *c, stbtt_int32 x, stbtt_int32 y)
1826 if (x > c->max_x || !c->started) c->max_x = x;
1827 if (y > c->max_y || !c->started) c->max_y = y;
1828 if (x < c->min_x || !c->started) c->min_x = x;
1829 if (y < c->min_y || !c->started) c->min_y = y;
1833 static void stbtt__csctx_v(stbtt__csctx *c, stbtt_uint8 type, stbtt_int32 x, stbtt_int32 y, stbtt_int32 cx, stbtt_int32 cy, stbtt_int32 cx1, stbtt_int32 cy1)
1836 stbtt__track_vertex(c, x, y);
1838 stbtt__track_vertex(c, cx, cy);
1839 stbtt__track_vertex(c, cx1, cy1);
1842 stbtt_setvertex(&c->pvertices[c->num_vertices], type, x, y, cx, cy);
1843 c->pvertices[c->num_vertices].cx1 = (stbtt_int16) cx1;
1844 c->pvertices[c->num_vertices].cy1 = (stbtt_int16) cy1;
1849 static void stbtt__csctx_close_shape(stbtt__csctx *ctx)
1851 if (ctx->first_x != ctx->x || ctx->first_y != ctx->y)
1852 stbtt__csctx_v(ctx,
STBTT_vline, (
int)ctx->first_x, (
int)ctx->first_y, 0, 0, 0, 0);
1855 static void stbtt__csctx_rmove_to(stbtt__csctx *ctx,
float dx,
float dy)
1857 stbtt__csctx_close_shape(ctx);
1858 ctx->first_x = ctx->x = ctx->x + dx;
1859 ctx->first_y = ctx->y = ctx->y + dy;
1860 stbtt__csctx_v(ctx,
STBTT_vmove, (
int)ctx->x, (
int)ctx->y, 0, 0, 0, 0);
1863 static void stbtt__csctx_rline_to(stbtt__csctx *ctx,
float dx,
float dy)
1867 stbtt__csctx_v(ctx,
STBTT_vline, (
int)ctx->x, (
int)ctx->y, 0, 0, 0, 0);
1870 static void stbtt__csctx_rccurve_to(stbtt__csctx *ctx,
float dx1,
float dy1,
float dx2,
float dy2,
float dx3,
float dy3)
1872 float cx1 = ctx->x + dx1;
1873 float cy1 = ctx->y + dy1;
1874 float cx2 = cx1 + dx2;
1875 float cy2 = cy1 + dy2;
1878 stbtt__csctx_v(ctx,
STBTT_vcubic, (
int)ctx->x, (
int)ctx->y, (
int)cx1, (
int)cy1, (
int)cx2, (
int)cy2);
1883 int count = stbtt__cff_index_count(&idx);
1887 else if (count >= 1240)
1890 if (n < 0 || n >= count)
1891 return stbtt__new_buf(NULL, 0);
1892 return stbtt__cff_index_get(idx, n);
1898 int nranges, start, end, v, fmt, fdselector = -1, i;
1900 stbtt__buf_seek(&fdselect, 0);
1901 fmt = stbtt__buf_get8(&fdselect);
1904 stbtt__buf_skip(&fdselect, glyph_index);
1905 fdselector = stbtt__buf_get8(&fdselect);
1906 }
else if (fmt == 3) {
1907 nranges = stbtt__buf_get16(&fdselect);
1908 start = stbtt__buf_get16(&fdselect);
1909 for (i = 0; i < nranges; i++) {
1910 v = stbtt__buf_get8(&fdselect);
1911 end = stbtt__buf_get16(&fdselect);
1912 if (glyph_index >= start && glyph_index < end) {
1919 if (fdselector == -1) stbtt__new_buf(NULL, 0);
1920 return stbtt__get_subrs(info->
cff, stbtt__cff_index_get(info->
fontdicts, fdselector));
1923 static int stbtt__run_charstring(
const stbtt_fontinfo *info,
int glyph_index, stbtt__csctx *c)
1925 int in_header = 1, maskbits = 0, subr_stack_height = 0, sp = 0, v, i, b0;
1926 int has_subrs = 0, clear_stack;
1931 #define STBTT__CSERR(s) (0)
1934 b = stbtt__cff_index_get(info->
charstrings, glyph_index);
1938 b0 = stbtt__buf_get8(&b);
1944 maskbits += (sp / 2);
1946 stbtt__buf_skip(&b, (maskbits + 7) / 8);
1953 maskbits += (sp / 2);
1958 if (sp < 2)
return STBTT__CSERR(
"rmoveto stack");
1959 stbtt__csctx_rmove_to(c, s[sp-2], s[sp-1]);
1963 if (sp < 1)
return STBTT__CSERR(
"vmoveto stack");
1964 stbtt__csctx_rmove_to(c, 0, s[sp-1]);
1968 if (sp < 1)
return STBTT__CSERR(
"hmoveto stack");
1969 stbtt__csctx_rmove_to(c, s[sp-1], 0);
1973 if (sp < 2)
return STBTT__CSERR(
"rlineto stack");
1974 for (; i + 1 < sp; i += 2)
1975 stbtt__csctx_rline_to(c, s[i], s[i+1]);
1982 if (sp < 1)
return STBTT__CSERR(
"vlineto stack");
1985 if (sp < 1)
return STBTT__CSERR(
"hlineto stack");
1988 stbtt__csctx_rline_to(c, s[i], 0);
1992 stbtt__csctx_rline_to(c, 0, s[i]);
1998 if (sp < 4)
return STBTT__CSERR(
"hvcurveto stack");
2001 if (sp < 4)
return STBTT__CSERR(
"vhcurveto stack");
2003 if (i + 3 >= sp)
break;
2004 stbtt__csctx_rccurve_to(c, 0, s[i], s[i+1], s[i+2], s[i+3], (sp - i == 5) ? s[i + 4] : 0.0f);
2007 if (i + 3 >= sp)
break;
2008 stbtt__csctx_rccurve_to(c, s[i], 0, s[i+1], s[i+2], (sp - i == 5) ? s[i+4] : 0.0f, s[i+3]);
2014 if (sp < 6)
return STBTT__CSERR(
"rcurveline stack");
2015 for (; i + 5 < sp; i += 6)
2016 stbtt__csctx_rccurve_to(c, s[i], s[i+1], s[i+2], s[i+3], s[i+4], s[i+5]);
2020 if (sp < 8)
return STBTT__CSERR(
"rcurveline stack");
2021 for (; i + 5 < sp - 2; i += 6)
2022 stbtt__csctx_rccurve_to(c, s[i], s[i+1], s[i+2], s[i+3], s[i+4], s[i+5]);
2023 if (i + 1 >= sp)
return STBTT__CSERR(
"rcurveline stack");
2024 stbtt__csctx_rline_to(c, s[i], s[i+1]);
2028 if (sp < 8)
return STBTT__CSERR(
"rlinecurve stack");
2029 for (; i + 1 < sp - 6; i += 2)
2030 stbtt__csctx_rline_to(c, s[i], s[i+1]);
2031 if (i + 5 >= sp)
return STBTT__CSERR(
"rlinecurve stack");
2032 stbtt__csctx_rccurve_to(c, s[i], s[i+1], s[i+2], s[i+3], s[i+4], s[i+5]);
2037 if (sp < 4)
return STBTT__CSERR(
"(vv|hh)curveto stack");
2039 if (sp & 1) { f = s[i]; i++; }
2040 for (; i + 3 < sp; i += 4) {
2042 stbtt__csctx_rccurve_to(c, s[i], f, s[i+1], s[i+2], s[i+3], 0.0);
2044 stbtt__csctx_rccurve_to(c, f, s[i], s[i+1], s[i+2], 0.0, s[i+3]);
2052 subrs = stbtt__cid_get_glyph_subrs(info, glyph_index);
2057 if (sp < 1)
return STBTT__CSERR(
"call(g|)subr stack");
2059 if (subr_stack_height >= 10)
return STBTT__CSERR(
"recursion limit");
2060 subr_stack[subr_stack_height++] = b;
2061 b = stbtt__get_subr(b0 == 0x0A ? subrs : info->
gsubrs, v);
2062 if (b.
size == 0)
return STBTT__CSERR(
"subr not found");
2068 if (subr_stack_height <= 0)
return STBTT__CSERR(
"return outside subr");
2069 b = subr_stack[--subr_stack_height];
2074 stbtt__csctx_close_shape(c);
2078 float dx1, dx2, dx3, dx4, dx5, dx6, dy1, dy2, dy3, dy4, dy5, dy6;
2080 int b1 = stbtt__buf_get8(&b);
2085 if (sp < 7)
return STBTT__CSERR(
"hflex stack");
2093 stbtt__csctx_rccurve_to(c, dx1, 0, dx2, dy2, dx3, 0);
2094 stbtt__csctx_rccurve_to(c, dx4, 0, dx5, -dy2, dx6, 0);
2098 if (sp < 13)
return STBTT__CSERR(
"flex stack");
2112 stbtt__csctx_rccurve_to(c, dx1, dy1, dx2, dy2, dx3, dy3);
2113 stbtt__csctx_rccurve_to(c, dx4, dy4, dx5, dy5, dx6, dy6);
2117 if (sp < 9)
return STBTT__CSERR(
"hflex1 stack");
2127 stbtt__csctx_rccurve_to(c, dx1, dy1, dx2, dy2, dx3, 0);
2128 stbtt__csctx_rccurve_to(c, dx4, 0, dx5, dy5, dx6, -(dy1+dy2+dy5));
2132 if (sp < 11)
return STBTT__CSERR(
"flex1 stack");
2144 dx = dx1+dx2+dx3+dx4+dx5;
2145 dy = dy1+dy2+dy3+dy4+dy5;
2146 if (STBTT_fabs(dx) > STBTT_fabs(dy))
2150 stbtt__csctx_rccurve_to(c, dx1, dy1, dx2, dy2, dx3, dy3);
2151 stbtt__csctx_rccurve_to(c, dx4, dy4, dx5, dy5, dx6, dy6);
2155 return STBTT__CSERR(
"unimplemented");
2160 if (b0 != 255 && b0 != 28 && (b0 < 32 || b0 > 254))
2161 return STBTT__CSERR(
"reserved operator");
2165 f = (float)stbtt__buf_get32(&b) / 0x10000;
2167 stbtt__buf_skip(&b, -1);
2168 f = (float)(stbtt_int16)stbtt__cff_int(&b);
2170 if (sp >= 48)
return STBTT__CSERR(
"push stack overflow");
2175 if (clear_stack) sp = 0;
2177 return STBTT__CSERR(
"no endchar");
2185 stbtt__csctx count_ctx = STBTT__CSCTX_INIT(1);
2186 stbtt__csctx output_ctx = STBTT__CSCTX_INIT(0);
2187 if (stbtt__run_charstring(info, glyph_index, &count_ctx)) {
2189 output_ctx.pvertices = *pvertices;
2190 if (stbtt__run_charstring(info, glyph_index, &output_ctx)) {
2191 STBTT_assert(output_ctx.num_vertices == count_ctx.num_vertices);
2192 return output_ctx.num_vertices;
2199 static int stbtt__GetGlyphInfoT2(
const stbtt_fontinfo *info,
int glyph_index,
int *x0,
int *y0,
int *x1,
int *y1)
2201 stbtt__csctx c = STBTT__CSCTX_INIT(1);
2202 int r = stbtt__run_charstring(info, glyph_index, &c);
2204 *x0 = r ? c.min_x : 0;
2205 *y0 = r ? c.min_y : 0;
2206 *x1 = r ? c.max_x : 0;
2207 *y1 = r ? c.max_y : 0;
2209 return r ? c.num_vertices : 0;
2215 return stbtt__GetGlyphShapeTT(info, glyph_index, pvertices);
2217 return stbtt__GetGlyphShapeT2(info, glyph_index, pvertices);
2222 stbtt_uint16 numOfLongHorMetrics = ttUSHORT(info->
data+info->
hhea + 34);
2223 if (glyph_index < numOfLongHorMetrics) {
2224 if (advanceWidth) *advanceWidth = ttSHORT(info->
data + info->
hmtx + 4*glyph_index);
2225 if (leftSideBearing) *leftSideBearing = ttSHORT(info->
data + info->
hmtx + 4*glyph_index + 2);
2227 if (advanceWidth) *advanceWidth = ttSHORT(info->
data + info->
hmtx + 4*(numOfLongHorMetrics-1));
2228 if (leftSideBearing) *leftSideBearing = ttSHORT(info->
data + info->
hmtx + 4*numOfLongHorMetrics + 2*(glyph_index - numOfLongHorMetrics));
2234 stbtt_uint8 *data = info->
data + info->
kern;
2235 stbtt_uint32 needle, straw;
2241 if (ttUSHORT(data+2) < 1)
2243 if (ttUSHORT(data+8) != 1)
2247 r = ttUSHORT(data+10) - 1;
2248 needle = glyph1 << 16 | glyph2;
2251 straw = ttULONG(data+18+(m*6));
2254 else if (needle > straw)
2257 return ttSHORT(data+22+(m*6));
2276 if (ascent ) *ascent = ttSHORT(info->
data+info->
hhea + 4);
2277 if (descent) *descent = ttSHORT(info->
data+info->
hhea + 6);
2278 if (lineGap) *lineGap = ttSHORT(info->
data+info->
hhea + 8);
2283 *x0 = ttSHORT(info->
data + info->
head + 36);
2284 *y0 = ttSHORT(info->
data + info->
head + 38);
2285 *x1 = ttSHORT(info->
data + info->
head + 40);
2286 *y1 = ttSHORT(info->
data + info->
head + 42);
2291 int fheight = ttSHORT(info->
data + info->
hhea + 4) - ttSHORT(info->
data + info->
hhea + 6);
2292 return (
float) height / fheight;
2297 int unitsPerEm = ttUSHORT(info->
data + info->
head + 18);
2298 return pixels / unitsPerEm;
2313 int x0=0,y0=0,x1,y1;
2322 if (ix0) *ix0 = STBTT_ifloor( x0 * scale_x + shift_x);
2323 if (iy0) *iy0 = STBTT_ifloor(-y1 * scale_y + shift_y);
2324 if (ix1) *ix1 = STBTT_iceil ( x1 * scale_x + shift_x);
2325 if (iy1) *iy1 = STBTT_iceil (-y0 * scale_y + shift_y);
2336 stbtt_GetGlyphBitmapBoxSubpixel(font,
stbtt_FindGlyphIndex(font,codepoint), scale_x, scale_y,shift_x,shift_y, ix0,iy0,ix1,iy1);
2348 typedef struct stbtt__hheap_chunk
2350 struct stbtt__hheap_chunk *next;
2351 } stbtt__hheap_chunk;
2353 typedef struct stbtt__hheap
2355 struct stbtt__hheap_chunk *head;
2357 int num_remaining_in_head_chunk;
2360 static void *stbtt__hheap_alloc(stbtt__hheap *hh,
size_t size,
void *userdata)
2362 if (hh->first_free) {
2363 void *p = hh->first_free;
2364 hh->first_free = * (
void **) p;
2367 if (hh->num_remaining_in_head_chunk == 0) {
2368 int count = (size < 32 ? 2000 : size < 128 ? 800 : 100);
2369 stbtt__hheap_chunk *c = (stbtt__hheap_chunk *) STBTT_malloc(
sizeof(stbtt__hheap_chunk) + size * count, userdata);
2374 hh->num_remaining_in_head_chunk = count;
2376 --hh->num_remaining_in_head_chunk;
2377 return (
char *) (hh->head) + size * hh->num_remaining_in_head_chunk;
2381 static void stbtt__hheap_free(stbtt__hheap *hh,
void *p)
2383 *(
void **) p = hh->first_free;
2387 static void stbtt__hheap_cleanup(stbtt__hheap *hh,
void *userdata)
2389 stbtt__hheap_chunk *c = hh->head;
2391 stbtt__hheap_chunk *n = c->next;
2392 STBTT_free(c, userdata);
2397 typedef struct stbtt__edge {
2403 typedef struct stbtt__active_edge
2405 struct stbtt__active_edge *next;
2406 #if STBTT_RASTERIZER_VERSION==1
2410 #elif STBTT_RASTERIZER_VERSION==2
2416 #error "Unrecognized value of STBTT_RASTERIZER_VERSION"
2418 } stbtt__active_edge;
2420 #if STBTT_RASTERIZER_VERSION == 1
2421 #define STBTT_FIXSHIFT 10
2422 #define STBTT_FIX (1 << STBTT_FIXSHIFT)
2423 #define STBTT_FIXMASK (STBTT_FIX-1)
2425 static stbtt__active_edge *stbtt__new_active(stbtt__hheap *hh, stbtt__edge *e,
int off_x,
float start_point,
void *userdata)
2427 stbtt__active_edge *z = (stbtt__active_edge *) stbtt__hheap_alloc(hh,
sizeof(*z), userdata);
2428 float dxdy = (e->x1 - e->x0) / (e->y1 - e->y0);
2429 STBTT_assert(z != NULL);
2434 z->dx = -STBTT_ifloor(STBTT_FIX * -dxdy);
2436 z->dx = STBTT_ifloor(STBTT_FIX * dxdy);
2438 z->x = STBTT_ifloor(STBTT_FIX * e->x0 + z->dx * (start_point - e->y0));
2439 z->x -= off_x * STBTT_FIX;
2443 z->direction = e->invert ? 1 : -1;
2446 #elif STBTT_RASTERIZER_VERSION == 2
2447 static stbtt__active_edge *stbtt__new_active(stbtt__hheap *hh, stbtt__edge *e,
int off_x,
float start_point,
void *userdata)
2449 stbtt__active_edge *z = (stbtt__active_edge *) stbtt__hheap_alloc(hh,
sizeof(*z), userdata);
2450 float dxdy = (e->x1 - e->x0) / (e->y1 - e->y0);
2451 STBTT_assert(z != NULL);
2455 z->fdy = dxdy != 0.0f ? (1.0f/dxdy) : 0.0f;
2456 z->fx = e->x0 + dxdy * (start_point - e->y0);
2458 z->direction = e->invert ? 1.0f : -1.0f;
2465 #error "Unrecognized value of STBTT_RASTERIZER_VERSION"
2468 #if STBTT_RASTERIZER_VERSION == 1
2472 static void stbtt__fill_active_edges(
unsigned char *scanline,
int len, stbtt__active_edge *e,
int max_weight)
2480 x0 = e->x; w += e->direction;
2482 int x1 = e->x; w += e->direction;
2485 int i = x0 >> STBTT_FIXSHIFT;
2486 int j = x1 >> STBTT_FIXSHIFT;
2488 if (i < len && j >= 0) {
2491 scanline[i] = scanline[i] + (stbtt_uint8) ((x1 - x0) * max_weight >> STBTT_FIXSHIFT);
2494 scanline[i] = scanline[i] + (stbtt_uint8) (((STBTT_FIX - (x0 & STBTT_FIXMASK)) * max_weight) >> STBTT_FIXSHIFT);
2499 scanline[j] = scanline[j] + (stbtt_uint8) (((x1 & STBTT_FIXMASK) * max_weight) >> STBTT_FIXSHIFT);
2503 for (++i; i < j; ++i)
2504 scanline[i] = scanline[i] + (stbtt_uint8) max_weight;
2514 static void stbtt__rasterize_sorted_edges(
stbtt__bitmap *result, stbtt__edge *e,
int n,
int vsubsample,
int off_x,
int off_y,
void *userdata)
2516 stbtt__hheap hh = { 0, 0, 0 };
2517 stbtt__active_edge *active = NULL;
2519 int max_weight = (255 / vsubsample);
2521 unsigned char scanline_data[512], *scanline;
2523 if (result->
w > 512)
2524 scanline = (
unsigned char *) STBTT_malloc(result->
w, userdata);
2526 scanline = scanline_data;
2528 y = off_y * vsubsample;
2529 e[n].y0 = (off_y + result->
h) * (
float) vsubsample + 1;
2531 while (j < result->h) {
2532 STBTT_memset(scanline, 0, result->
w);
2533 for (s=0; s < vsubsample; ++s) {
2535 float scan_y = y + 0.5f;
2536 stbtt__active_edge **step = &active;
2541 stbtt__active_edge * z = *step;
2542 if (z->ey <= scan_y) {
2544 STBTT_assert(z->direction);
2546 stbtt__hheap_free(&hh, z);
2549 step = &((*step)->next);
2557 while (*step && (*step)->next) {
2558 if ((*step)->x > (*step)->next->x) {
2559 stbtt__active_edge *t = *step;
2560 stbtt__active_edge *q = t->next;
2567 step = &(*step)->next;
2569 if (!changed)
break;
2573 while (e->y0 <= scan_y) {
2574 if (e->y1 > scan_y) {
2575 stbtt__active_edge *z = stbtt__new_active(&hh, e, off_x, scan_y, userdata);
2580 else if (z->x < active->x) {
2586 stbtt__active_edge *p = active;
2587 while (p->next && p->next->x < z->x)
2600 stbtt__fill_active_edges(scanline, result->
w, active, max_weight);
2604 STBTT_memcpy(result->
pixels + j * result->
stride, scanline, result->
w);
2608 stbtt__hheap_cleanup(&hh, userdata);
2610 if (scanline != scanline_data)
2611 STBTT_free(scanline, userdata);
2614 #elif STBTT_RASTERIZER_VERSION == 2
2618 static void stbtt__handle_clipped_edge(
float *scanline,
int x, stbtt__active_edge *e,
float x0,
float y0,
float x1,
float y1)
2620 if (y0 == y1)
return;
2621 STBTT_assert(y0 < y1);
2622 STBTT_assert(e->sy <= e->ey);
2623 if (y0 > e->ey)
return;
2624 if (y1 < e->sy)
return;
2626 x0 += (x1-x0) * (e->sy - y0) / (y1-y0);
2630 x1 += (x1-x0) * (e->ey - y1) / (y1-y0);
2635 STBTT_assert(x1 <= x+1);
2637 STBTT_assert(x1 >= x);
2639 STBTT_assert(x1 <= x);
2641 STBTT_assert(x1 >= x+1);
2643 STBTT_assert(x1 >= x && x1 <= x+1);
2645 if (x0 <= x && x1 <= x)
2646 scanline[x] += e->direction * (y1-y0);
2647 else if (x0 >= x+1 && x1 >= x+1)
2650 STBTT_assert(x0 >= x && x0 <= x+1 && x1 >= x && x1 <= x+1);
2651 scanline[x] += e->direction * (y1-y0) * (1-((x0-x)+(x1-x))/2);
2655 static void stbtt__fill_active_edges_new(
float *scanline,
float *scanline_fill,
int len, stbtt__active_edge *e,
float y_top)
2657 float y_bottom = y_top+1;
2663 STBTT_assert(e->ey >= y_top);
2669 stbtt__handle_clipped_edge(scanline,(
int) x0,e, x0,y_top, x0,y_bottom);
2670 stbtt__handle_clipped_edge(scanline_fill-1,(
int) x0+1,e, x0,y_top, x0,y_bottom);
2672 stbtt__handle_clipped_edge(scanline_fill-1,0,e, x0,y_top, x0,y_bottom);
2679 float x_top, x_bottom;
2682 STBTT_assert(e->sy <= y_bottom && e->ey >= y_top);
2687 if (e->sy > y_top) {
2688 x_top = x0 + dx * (e->sy - y_top);
2694 if (e->ey < y_bottom) {
2695 x_bottom = x0 + dx * (e->ey - y_top);
2702 if (x_top >= 0 && x_bottom >= 0 && x_top < len && x_bottom < len) {
2705 if ((
int) x_top == (int) x_bottom) {
2708 int x = (int) x_top;
2710 STBTT_assert(x >= 0 && x < len);
2711 scanline[x] += e->direction * (1-((x_top - x) + (x_bottom-x))/2) * height;
2712 scanline_fill[x] += e->direction * height;
2715 float y_crossing, step, sign, area;
2717 if (x_top > x_bottom) {
2720 sy0 = y_bottom - (sy0 - y_top);
2721 sy1 = y_bottom - (sy1 - y_top);
2722 t = sy0, sy0 = sy1, sy1 = t;
2723 t = x_bottom, x_bottom = x_top, x_top = t;
2726 t = x0, x0 = xb, xb = t;
2730 x2 = (int) x_bottom;
2732 y_crossing = (x1+1 - x0) * dy + y_top;
2734 sign = e->direction;
2736 area = sign * (y_crossing-sy0);
2738 scanline[x1] += area * (1-((x_top - x1)+(x1+1-x1))/2);
2741 for (x = x1+1; x < x2; ++x) {
2742 scanline[x] += area + step/2;
2745 y_crossing += dy * (x2 - (x1+1));
2747 STBTT_assert(STBTT_fabs(area) <= 1.01f);
2749 scanline[x2] += area + sign * (1-((x2-x2)+(x_bottom-x2))/2) * (sy1-y_crossing);
2751 scanline_fill[x2] += sign * (sy1-sy0);
2759 for (x=0; x < len; ++x) {
2775 float x1 = (float) (x);
2776 float x2 = (float) (x+1);
2778 float y3 = y_bottom;
2783 float y1 = (x - x0) / dx + y_top;
2784 float y2 = (x+1 - x0) / dx + y_top;
2786 if (x0 < x1 && x3 > x2) {
2787 stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x1,y1);
2788 stbtt__handle_clipped_edge(scanline,x,e, x1,y1, x2,y2);
2789 stbtt__handle_clipped_edge(scanline,x,e, x2,y2, x3,y3);
2790 }
else if (x3 < x1 && x0 > x2) {
2791 stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x2,y2);
2792 stbtt__handle_clipped_edge(scanline,x,e, x2,y2, x1,y1);
2793 stbtt__handle_clipped_edge(scanline,x,e, x1,y1, x3,y3);
2794 }
else if (x0 < x1 && x3 > x1) {
2795 stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x1,y1);
2796 stbtt__handle_clipped_edge(scanline,x,e, x1,y1, x3,y3);
2797 }
else if (x3 < x1 && x0 > x1) {
2798 stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x1,y1);
2799 stbtt__handle_clipped_edge(scanline,x,e, x1,y1, x3,y3);
2800 }
else if (x0 < x2 && x3 > x2) {
2801 stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x2,y2);
2802 stbtt__handle_clipped_edge(scanline,x,e, x2,y2, x3,y3);
2803 }
else if (x3 < x2 && x0 > x2) {
2804 stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x2,y2);
2805 stbtt__handle_clipped_edge(scanline,x,e, x2,y2, x3,y3);
2807 stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x3,y3);
2817 static void stbtt__rasterize_sorted_edges(
stbtt__bitmap *result, stbtt__edge *e,
int n,
int vsubsample,
int off_x,
int off_y,
void *userdata)
2819 stbtt__hheap hh = { 0, 0, 0 };
2820 stbtt__active_edge *active = NULL;
2822 float scanline_data[129], *scanline, *scanline2;
2824 STBTT__NOTUSED(vsubsample);
2827 scanline = (
float *) STBTT_malloc((result->
w*2+1) *
sizeof(float), userdata);
2829 scanline = scanline_data;
2831 scanline2 = scanline + result->
w;
2834 e[n].y0 = (float) (off_y + result->
h) + 1;
2836 while (j < result->h) {
2838 float scan_y_top = y + 0.0f;
2839 float scan_y_bottom = y + 1.0f;
2840 stbtt__active_edge **step = &active;
2842 STBTT_memset(scanline , 0, result->
w*
sizeof(scanline[0]));
2843 STBTT_memset(scanline2, 0, (result->
w+1)*
sizeof(scanline[0]));
2848 stbtt__active_edge * z = *step;
2849 if (z->ey <= scan_y_top) {
2851 STBTT_assert(z->direction);
2853 stbtt__hheap_free(&hh, z);
2855 step = &((*step)->next);
2860 while (e->y0 <= scan_y_bottom) {
2861 if (e->y0 != e->y1) {
2862 stbtt__active_edge *z = stbtt__new_active(&hh, e, off_x, scan_y_top, userdata);
2864 STBTT_assert(z->ey >= scan_y_top);
2875 stbtt__fill_active_edges_new(scanline, scanline2+1, result->
w, active, scan_y_top);
2879 for (i=0; i < result->
w; ++i) {
2882 sum += scanline2[i];
2883 k = scanline[i] + sum;
2884 k = (float) STBTT_fabs(k)*255 + 0.5f;
2886 if (m > 255) m = 255;
2887 result->
pixels[j*result->
stride + i] = (
unsigned char) m;
2893 stbtt__active_edge *z = *step;
2895 step = &((*step)->next);
2902 stbtt__hheap_cleanup(&hh, userdata);
2904 if (scanline != scanline_data)
2905 STBTT_free(scanline, userdata);
2908 #error "Unrecognized value of STBTT_RASTERIZER_VERSION"
2911 #define STBTT__COMPARE(a,b) ((a)->y0 < (b)->y0)
2913 static void stbtt__sort_edges_ins_sort(stbtt__edge *p,
int n)
2916 for (i=1; i < n; ++i) {
2917 stbtt__edge t = p[i], *a = &t;
2920 stbtt__edge *b = &p[j-1];
2921 int c = STBTT__COMPARE(a,b);
2931 static void stbtt__sort_edges_quicksort(stbtt__edge *p,
int n)
2936 int c01,c12,c,m,i,j;
2940 c01 = STBTT__COMPARE(&p[0],&p[m]);
2941 c12 = STBTT__COMPARE(&p[m],&p[n-1]);
2946 c = STBTT__COMPARE(&p[0],&p[n-1]);
2949 z = (c == c12) ? 0 : n-1;
2967 if (!STBTT__COMPARE(&p[i], &p[0]))
break;
2970 if (!STBTT__COMPARE(&p[0], &p[j]))
break;
2983 stbtt__sort_edges_quicksort(p,j);
2987 stbtt__sort_edges_quicksort(p+i, n-i);
2993 static void stbtt__sort_edges(stbtt__edge *p,
int n)
2995 stbtt__sort_edges_quicksort(p, n);
2996 stbtt__sort_edges_ins_sort(p, n);
3004 static void stbtt__rasterize(
stbtt__bitmap *result, stbtt__point *pts,
int *wcount,
int windings,
float scale_x,
float scale_y,
float shift_x,
float shift_y,
int off_x,
int off_y,
int invert,
void *userdata)
3006 float y_scale_inv = invert ? -scale_y : scale_y;
3009 #if STBTT_RASTERIZER_VERSION == 1
3010 int vsubsample = result->
h < 8 ? 15 : 5;
3011 #elif STBTT_RASTERIZER_VERSION == 2
3014 #error "Unrecognized value of STBTT_RASTERIZER_VERSION"
3020 for (i=0; i < windings; ++i)
3023 e = (stbtt__edge *) STBTT_malloc(
sizeof(*e) * (n+1), userdata);
3028 for (i=0; i < windings; ++i) {
3029 stbtt__point *p = pts + m;
3032 for (k=0; k < wcount[i]; j=k++) {
3035 if (p[j].y == p[k].y)
3039 if (invert ? p[j].y > p[k].y : p[j].y < p[k].y) {
3043 e[n].x0 = p[a].x * scale_x + shift_x;
3044 e[n].y0 = (p[a].y * y_scale_inv + shift_y) * vsubsample;
3045 e[n].x1 = p[b].x * scale_x + shift_x;
3046 e[n].y1 = (p[b].y * y_scale_inv + shift_y) * vsubsample;
3053 stbtt__sort_edges(e, n);
3056 stbtt__rasterize_sorted_edges(result, e, n, vsubsample, off_x, off_y, userdata);
3058 STBTT_free(e, userdata);
3061 static void stbtt__add_point(stbtt__point *points,
int n,
float x,
float y)
3063 if (!points)
return;
3069 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)
3072 float mx = (x0 + 2*x1 + x2)/4;
3073 float my = (y0 + 2*y1 + y2)/4;
3075 float dx = (x0+x2)/2 - mx;
3076 float dy = (y0+y2)/2 - my;
3079 if (dx*dx+dy*dy > objspace_flatness_squared) {
3080 stbtt__tesselate_curve(points, num_points, x0,y0, (x0+x1)/2.0f,(y0+y1)/2.0f, mx,my, objspace_flatness_squared,n+1);
3081 stbtt__tesselate_curve(points, num_points, mx,my, (x1+x2)/2.0f,(y1+y2)/2.0f, x2,y2, objspace_flatness_squared,n+1);
3083 stbtt__add_point(points, *num_points,x2,y2);
3084 *num_points = *num_points+1;
3089 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)
3100 float longlen = (float) (STBTT_sqrt(dx0*dx0+dy0*dy0)+STBTT_sqrt(dx1*dx1+dy1*dy1)+STBTT_sqrt(dx2*dx2+dy2*dy2));
3101 float shortlen = (float) STBTT_sqrt(dx*dx+dy*dy);
3102 float flatness_squared = longlen*longlen-shortlen*shortlen;
3107 if (flatness_squared > objspace_flatness_squared) {
3108 float x01 = (x0+x1)/2;
3109 float y01 = (y0+y1)/2;
3110 float x12 = (x1+x2)/2;
3111 float y12 = (y1+y2)/2;
3112 float x23 = (x2+x3)/2;
3113 float y23 = (y2+y3)/2;
3115 float xa = (x01+x12)/2;
3116 float ya = (y01+y12)/2;
3117 float xb = (x12+x23)/2;
3118 float yb = (y12+y23)/2;
3120 float mx = (xa+xb)/2;
3121 float my = (ya+yb)/2;
3123 stbtt__tesselate_cubic(points, num_points, x0,y0, x01,y01, xa,ya, mx,my, objspace_flatness_squared,n+1);
3124 stbtt__tesselate_cubic(points, num_points, mx,my, xb,yb, x23,y23, x3,y3, objspace_flatness_squared,n+1);
3126 stbtt__add_point(points, *num_points,x3,y3);
3127 *num_points = *num_points+1;
3132 static stbtt__point *stbtt_FlattenCurves(
stbtt_vertex *vertices,
int num_verts,
float objspace_flatness,
int **contour_lengths,
int *num_contours,
void *userdata)
3134 stbtt__point *points=0;
3137 float objspace_flatness_squared = objspace_flatness * objspace_flatness;
3138 int i,n=0,start=0, pass;
3141 for (i=0; i < num_verts; ++i)
3146 if (n == 0)
return 0;
3148 *contour_lengths = (
int *) STBTT_malloc(
sizeof(**contour_lengths) * n, userdata);
3150 if (*contour_lengths == 0) {
3156 for (pass=0; pass < 2; ++pass) {
3159 points = (stbtt__point *) STBTT_malloc(num_points *
sizeof(points[0]), userdata);
3160 if (points == NULL)
goto error;
3164 for (i=0; i < num_verts; ++i) {
3165 switch (vertices[i].type) {
3169 (*contour_lengths)[n] = num_points - start;
3173 x = vertices[i].
x, y = vertices[i].
y;
3174 stbtt__add_point(points, num_points++, x,y);
3177 x = vertices[i].
x, y = vertices[i].
y;
3178 stbtt__add_point(points, num_points++, x, y);
3181 stbtt__tesselate_curve(points, &num_points, x,y,
3182 vertices[i].cx, vertices[i].cy,
3183 vertices[i].x, vertices[i].y,
3184 objspace_flatness_squared, 0);
3185 x = vertices[i].
x, y = vertices[i].
y;
3188 stbtt__tesselate_cubic(points, &num_points, x,y,
3189 vertices[i].cx, vertices[i].cy,
3190 vertices[i].cx1, vertices[i].cy1,
3191 vertices[i].x, vertices[i].y,
3192 objspace_flatness_squared, 0);
3193 x = vertices[i].
x, y = vertices[i].
y;
3197 (*contour_lengths)[n] = num_points - start;
3202 STBTT_free(points, userdata);
3203 STBTT_free(*contour_lengths, userdata);
3204 *contour_lengths = 0;
3209 STBTT_DEF void stbtt_Rasterize(
stbtt__bitmap *result,
float flatness_in_pixels,
stbtt_vertex *vertices,
int num_verts,
float scale_x,
float scale_y,
float shift_x,
float shift_y,
int x_off,
int y_off,
int invert,
void *userdata)
3211 float scale = scale_x > scale_y ? scale_y : scale_x;
3212 int winding_count, *winding_lengths;
3213 stbtt__point *windings = stbtt_FlattenCurves(vertices, num_verts, flatness_in_pixels / scale, &winding_lengths, &winding_count, userdata);
3215 stbtt__rasterize(result, windings, winding_lengths, winding_count, scale_x, scale_y, shift_x, shift_y, x_off, y_off, invert, userdata);
3216 STBTT_free(winding_lengths, userdata);
3217 STBTT_free(windings, userdata);
3223 STBTT_free(bitmap, userdata);
3228 int ix0,iy0,ix1,iy1;
3233 if (scale_x == 0) scale_x = scale_y;
3236 STBTT_free(vertices, info->
userdata);
3245 gbm.
w = (ix1 - ix0);
3246 gbm.
h = (iy1 - iy0);
3249 if (width ) *width = gbm.
w;
3250 if (height) *height = gbm.
h;
3251 if (xoff ) *xoff = ix0;
3252 if (yoff ) *yoff = iy0;
3254 if (gbm.
w && gbm.
h) {
3255 gbm.
pixels = (
unsigned char *) STBTT_malloc(gbm.
w * gbm.
h, info->
userdata);
3259 stbtt_Rasterize(&gbm, 0.35f, vertices, num_verts, scale_x, scale_y, shift_x, shift_y, ix0, iy0, 1, info->
userdata);
3262 STBTT_free(vertices, info->
userdata);
3285 stbtt_Rasterize(&gbm, 0.35f, vertices, num_verts, scale_x, scale_y, shift_x, shift_y, ix0,iy0, 1, info->
userdata);
3287 STBTT_free(vertices, info->
userdata);
3297 return stbtt_GetGlyphBitmapSubpixel(info, scale_x, scale_y,shift_x,shift_y,
stbtt_FindGlyphIndex(info,codepoint), width,height,xoff,yoff);
3302 stbtt_MakeGlyphBitmapSubpixel(info, output, out_w, out_h, out_stride, scale_x, scale_y, shift_x, shift_y,
stbtt_FindGlyphIndex(info,codepoint));
3321 static int stbtt_BakeFontBitmap_internal(
unsigned char *data,
int offset,
3323 unsigned char *pixels,
int pw,
int ph,
3324 int first_char,
int num_chars,
3328 int x,y,bottom_y, i;
3333 STBTT_memset(pixels, 0, pw*ph);
3339 for (i=0; i < num_chars; ++i) {
3340 int advance, lsb, x0,y0,x1,y1,gw,gh;
3346 if (x + gw + 1 >= pw)
3347 y = bottom_y, x = 1;
3348 if (y + gh + 1 >= ph)
3350 STBTT_assert(x+gw < pw);
3351 STBTT_assert(y+gh < ph);
3353 chardata[i].
x0 = (stbtt_int16) x;
3354 chardata[i].
y0 = (stbtt_int16) y;
3355 chardata[i].
x1 = (stbtt_int16) (x + gw);
3356 chardata[i].
y1 = (stbtt_int16) (y + gh);
3357 chardata[i].
xadvance = scale * advance;
3358 chardata[i].
xoff = (float) x0;
3359 chardata[i].
yoff = (float) y0;
3361 if (y+gh+1 > bottom_y)
3369 float d3d_bias = opengl_fillrule ? 0 : -0.5f;
3370 float ipw = 1.0f / pw, iph = 1.0f / ph;
3372 int round_x = STBTT_ifloor((*xpos + b->
xoff) + 0.5f);
3373 int round_y = STBTT_ifloor((*ypos + b->
yoff) + 0.5f);
3375 q->
x0 = round_x + d3d_bias;
3376 q->
y0 = round_y + d3d_bias;
3377 q->
x1 = round_x + b->
x1 - b->
x0 + d3d_bias;
3378 q->
y1 = round_y + b->
y1 - b->
y0 + d3d_bias;
3380 q->
s0 = b->
x0 * ipw;
3381 q->
t0 = b->
y0 * iph;
3382 q->
s1 = b->
x1 * ipw;
3383 q->
t1 = b->
y1 * iph;
3393 #ifndef STB_RECT_PACK_VERSION
3395 typedef int stbrp_coord;
3422 int id,w,h,was_packed;
3425 static void stbrp_init_target(stbrp_context *con,
int pw,
int ph, stbrp_node *nodes,
int num_nodes)
3432 STBTT__NOTUSED(nodes);
3433 STBTT__NOTUSED(num_nodes);
3436 static void stbrp_pack_rects(stbrp_context *con,
stbrp_rect *rects,
int num_rects)
3439 for (i=0; i < num_rects; ++i) {
3440 if (con->x + rects[i].w > con->width) {
3442 con->y = con->bottom_y;
3444 if (con->y + rects[i].h > con->height)
3446 rects[i].x = con->x;
3447 rects[i].y = con->y;
3448 rects[i].was_packed = 1;
3449 con->x += rects[i].w;
3450 if (con->y + rects[i].h > con->bottom_y)
3451 con->bottom_y = con->y + rects[i].h;
3453 for ( ; i < num_rects; ++i)
3454 rects[i].was_packed = 0;
3467 stbrp_context *context = (stbrp_context *) STBTT_malloc(
sizeof(*context) ,alloc_context);
3468 int num_nodes = pw - padding;
3469 stbrp_node *nodes = (stbrp_node *) STBTT_malloc(
sizeof(*nodes ) * num_nodes,alloc_context);
3471 if (context == NULL || nodes == NULL) {
3472 if (context != NULL) STBTT_free(context, alloc_context);
3473 if (nodes != NULL) STBTT_free(nodes , alloc_context);
3488 stbrp_init_target(context, pw-padding, ph-padding, nodes, num_nodes);
3491 STBTT_memset(pixels, 0, pw*ph);
3504 STBTT_assert(h_oversample <= STBTT_MAX_OVERSAMPLE);
3505 STBTT_assert(v_oversample <= STBTT_MAX_OVERSAMPLE);
3506 if (h_oversample <= STBTT_MAX_OVERSAMPLE)
3508 if (v_oversample <= STBTT_MAX_OVERSAMPLE)
3512 #define STBTT__OVER_MASK (STBTT_MAX_OVERSAMPLE-1)
3514 static void stbtt__h_prefilter(
unsigned char *pixels,
int w,
int h,
int stride_in_bytes,
unsigned int kernel_width)
3516 unsigned char buffer[STBTT_MAX_OVERSAMPLE];
3517 int safe_w = w - kernel_width;
3519 STBTT_memset(buffer, 0, STBTT_MAX_OVERSAMPLE);
3520 for (j=0; j < h; ++j) {
3523 STBTT_memset(buffer, 0, kernel_width);
3528 switch (kernel_width) {
3530 for (i=0; i <= safe_w; ++i) {
3531 total += pixels[i] - buffer[i & STBTT__OVER_MASK];
3532 buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i];
3533 pixels[i] = (
unsigned char) (total / 2);
3537 for (i=0; i <= safe_w; ++i) {
3538 total += pixels[i] - buffer[i & STBTT__OVER_MASK];
3539 buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i];
3540 pixels[i] = (
unsigned char) (total / 3);
3544 for (i=0; i <= safe_w; ++i) {
3545 total += pixels[i] - buffer[i & STBTT__OVER_MASK];
3546 buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i];
3547 pixels[i] = (
unsigned char) (total / 4);
3551 for (i=0; i <= safe_w; ++i) {
3552 total += pixels[i] - buffer[i & STBTT__OVER_MASK];
3553 buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i];
3554 pixels[i] = (
unsigned char) (total / 5);
3558 for (i=0; i <= safe_w; ++i) {
3559 total += pixels[i] - buffer[i & STBTT__OVER_MASK];
3560 buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i];
3561 pixels[i] = (
unsigned char) (total / kernel_width);
3566 for (; i < w; ++i) {
3567 STBTT_assert(pixels[i] == 0);
3568 total -= buffer[i & STBTT__OVER_MASK];
3569 pixels[i] = (
unsigned char) (total / kernel_width);
3572 pixels += stride_in_bytes;
3576 static void stbtt__v_prefilter(
unsigned char *pixels,
int w,
int h,
int stride_in_bytes,
unsigned int kernel_width)
3578 unsigned char buffer[STBTT_MAX_OVERSAMPLE];
3579 int safe_h = h - kernel_width;
3581 STBTT_memset(buffer, 0, STBTT_MAX_OVERSAMPLE);
3582 for (j=0; j < w; ++j) {
3585 STBTT_memset(buffer, 0, kernel_width);
3590 switch (kernel_width) {
3592 for (i=0; i <= safe_h; ++i) {
3593 total += pixels[i*stride_in_bytes] - buffer[i & STBTT__OVER_MASK];
3594 buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i*stride_in_bytes];
3595 pixels[i*stride_in_bytes] = (
unsigned char) (total / 2);
3599 for (i=0; i <= safe_h; ++i) {
3600 total += pixels[i*stride_in_bytes] - buffer[i & STBTT__OVER_MASK];
3601 buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i*stride_in_bytes];
3602 pixels[i*stride_in_bytes] = (
unsigned char) (total / 3);
3606 for (i=0; i <= safe_h; ++i) {
3607 total += pixels[i*stride_in_bytes] - buffer[i & STBTT__OVER_MASK];
3608 buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i*stride_in_bytes];
3609 pixels[i*stride_in_bytes] = (
unsigned char) (total / 4);
3613 for (i=0; i <= safe_h; ++i) {
3614 total += pixels[i*stride_in_bytes] - buffer[i & STBTT__OVER_MASK];
3615 buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i*stride_in_bytes];
3616 pixels[i*stride_in_bytes] = (
unsigned char) (total / 5);
3620 for (i=0; i <= safe_h; ++i) {
3621 total += pixels[i*stride_in_bytes] - buffer[i & STBTT__OVER_MASK];
3622 buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i*stride_in_bytes];
3623 pixels[i*stride_in_bytes] = (
unsigned char) (total / kernel_width);
3628 for (; i < h; ++i) {
3629 STBTT_assert(pixels[i*stride_in_bytes] == 0);
3630 total -= buffer[i & STBTT__OVER_MASK];
3631 pixels[i*stride_in_bytes] = (
unsigned char) (total / kernel_width);
3638 static float stbtt__oversample_shift(
int oversample)
3647 return (
float)-(oversample - 1) / (2.0f * (
float)oversample);
3656 for (i=0; i < num_ranges; ++i) {
3660 ranges[i].v_oversample = (
unsigned char) spc->
v_oversample;
3661 for (j=0; j < ranges[i].
num_chars; ++j) {
3679 STBTT_DEF void stbtt_MakeGlyphBitmapSubpixelPrefilter(
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 prefilter_x,
int prefilter_y,
float *sub_x,
float *sub_y,
int glyph)
3683 out_w - (prefilter_x - 1),
3684 out_h - (prefilter_y - 1),
3692 if (prefilter_x > 1)
3693 stbtt__h_prefilter(output, out_w, out_h, out_stride, prefilter_x);
3695 if (prefilter_y > 1)
3696 stbtt__v_prefilter(output, out_w, out_h, out_stride, prefilter_y);
3698 *sub_x = stbtt__oversample_shift(prefilter_x);
3699 *sub_y = stbtt__oversample_shift(prefilter_y);
3705 int i,j,k, return_value = 1;
3712 for (i=0; i < num_ranges; ++i) {
3715 float recip_h,recip_v,sub_x,sub_y;
3722 for (j=0; j < ranges[i].
num_chars; ++j) {
3724 if (r->was_packed) {
3726 int advance, lsb, x0,y0,x1,y1;
3729 stbrp_coord pad = (stbrp_coord) spc->
padding;
3761 bc->
x0 = (stbtt_int16) r->x;
3762 bc->
y0 = (stbtt_int16) r->y;
3763 bc->
x1 = (stbtt_int16) (r->x + r->w);
3764 bc->
y1 = (stbtt_int16) (r->y + r->h);
3766 bc->
xoff = (float) x0 * recip_h + sub_x;
3767 bc->
yoff = (float) y0 * recip_v + sub_y;
3768 bc->
xoff2 = (x0 + r->w) * recip_h + sub_x;
3769 bc->
yoff2 = (y0 + r->h) * recip_v + sub_y;
3782 return return_value;
3787 stbrp_pack_rects((stbrp_context *) spc->
pack_info, rects, num_rects);
3793 int i,j,n, return_value = 1;
3798 for (i=0; i < num_ranges; ++i)
3800 ranges[i].chardata_for_range[j].x0 =
3801 ranges[i].chardata_for_range[j].y0 =
3802 ranges[i].chardata_for_range[j].x1 =
3803 ranges[i].chardata_for_range[j].y1 = 0;
3806 for (i=0; i < num_ranges; ++i)
3807 n += ranges[i].num_chars;
3823 return return_value;
3827 int first_unicode_codepoint_in_range,
int num_chars_in_range,
stbtt_packedchar *chardata_for_range)
3840 float ipw = 1.0f / pw, iph = 1.0f / ph;
3843 if (align_to_integer) {
3844 float x = (float) STBTT_ifloor((*xpos + b->
xoff) + 0.5f);
3845 float y = (float) STBTT_ifloor((*ypos + b->
yoff) + 0.5f);
3857 q->
s0 = b->
x0 * ipw;
3858 q->
t0 = b->
y0 * iph;
3859 q->
s1 = b->
x1 * ipw;
3860 q->
t1 = b->
y1 * iph;
3870 #define STBTT_min(a,b) ((a) < (b) ? (a) : (b))
3871 #define STBTT_max(a,b) ((a) < (b) ? (b) : (a))
3873 static int stbtt__ray_intersect_bezier(
float orig[2],
float ray[2],
float q0[2],
float q1[2],
float q2[2],
float hits[2][2])
3875 float q0perp = q0[1]*ray[0] - q0[0]*ray[1];
3876 float q1perp = q1[1]*ray[0] - q1[0]*ray[1];
3877 float q2perp = q2[1]*ray[0] - q2[0]*ray[1];
3878 float roperp = orig[1]*ray[0] - orig[0]*ray[1];
3880 float a = q0perp - 2*q1perp + q2perp;
3881 float b = q1perp - q0perp;
3882 float c = q0perp - roperp;
3884 float s0 = 0., s1 = 0.;
3888 float discr = b*b - a*c;
3890 float rcpna = -1 / a;
3891 float d = (float) sqrt(discr);
3894 if (s0 >= 0.0 && s0 <= 1.0)
3896 if (d > 0.0 && s1 >= 0.0 && s1 <= 1.0) {
3897 if (num_s == 0) s0 = s1;
3905 if (s0 >= 0.0 && s0 <= 1.0)
3912 float rcp_len2 = 1 / (ray[0]*ray[0] + ray[1]*ray[1]);
3913 float rayn_x = ray[0] * rcp_len2, rayn_y = ray[1] * rcp_len2;
3915 float q0d = q0[0]*rayn_x + q0[1]*rayn_y;
3916 float q1d = q1[0]*rayn_x + q1[1]*rayn_y;
3917 float q2d = q2[0]*rayn_x + q2[1]*rayn_y;
3918 float rod = orig[0]*rayn_x + orig[1]*rayn_y;
3920 float q10d = q1d - q0d;
3921 float q20d = q2d - q0d;
3922 float q0rd = q0d - rod;
3924 hits[0][0] = q0rd + s0*(2.0f - 2.0f*s0)*q10d + s0*s0*q20d;
3925 hits[0][1] = a*s0+b;
3928 hits[1][0] = q0rd + s1*(2.0f - 2.0f*s1)*q10d + s1*s1*q20d;
3929 hits[1][1] = a*s1+b;
3937 static int equal(
float *a,
float *b)
3939 return (a[0] == b[0] && a[1] == b[1]);
3942 static int stbtt__compute_crossings_x(
float x,
float y,
int nverts,
stbtt_vertex *verts)
3945 float orig[2], ray[2] = { 1, 0 };
3953 y_frac = (float) fmod(y, 1.0f);
3956 else if (y_frac > 0.99f)
3961 for (i=0; i < nverts; ++i) {
3963 int x0 = (int) verts[i-1].x, y0 = (
int) verts[i-1].
y;
3964 int x1 = (int) verts[i ].x, y1 = (
int) verts[i ].
y;
3965 if (y > STBTT_min(y0,y1) && y < STBTT_max(y0,y1) && x > STBTT_min(x0,x1)) {
3966 float x_inter = (y - y0) / (y1 - y0) * (x1-x0) + x0;
3968 winding += (y0 < y1) ? 1 : -1;
3972 int x0 = (int) verts[i-1].x , y0 = (
int) verts[i-1].
y ;
3973 int x1 = (int) verts[i ].cx, y1 = (
int) verts[i ].
cy;
3974 int x2 = (int) verts[i ].x , y2 = (
int) verts[i ].
y ;
3975 int ax = STBTT_min(x0,STBTT_min(x1,x2)), ay = STBTT_min(y0,STBTT_min(y1,y2));
3976 int by = STBTT_max(y0,STBTT_max(y1,y2));
3977 if (y > ay && y < by && x > ax) {
3978 float q0[2],q1[2],q2[2];
3986 if (equal(q0,q1) || equal(q1,q2)) {
3987 x0 = (int)verts[i-1].x;
3988 y0 = (int)verts[i-1].y;
3989 x1 = (int)verts[i ].x;
3990 y1 = (int)verts[i ].y;
3991 if (y > STBTT_min(y0,y1) && y < STBTT_max(y0,y1) && x > STBTT_min(x0,x1)) {
3992 float x_inter = (y - y0) / (y1 - y0) * (x1-x0) + x0;
3994 winding += (y0 < y1) ? 1 : -1;
3997 int num_hits = stbtt__ray_intersect_bezier(orig, ray, q0, q1, q2, hits);
4000 winding += (hits[0][1] < 0 ? -1 : 1);
4003 winding += (hits[1][1] < 0 ? -1 : 1);
4011 static float stbtt__cuberoot(
float x )
4014 return -(float) STBTT_pow(-x,1.0f/3.0f);
4016 return (
float) STBTT_pow( x,1.0f/3.0f);
4020 static int stbtt__solve_cubic(
float a,
float b,
float c,
float* r)
4023 float p = b - a*a / 3;
4024 float q = a * (2*a*a - 9*b) / 27 + c;
4026 float d = q*q + 4*p3 / 27;
4028 float z = (float) STBTT_sqrt(d);
4029 float u = (-q + z) / 2;
4030 float v = (-q - z) / 2;
4031 u = stbtt__cuberoot(u);
4032 v = stbtt__cuberoot(v);
4036 float u = (float) STBTT_sqrt(-p/3);
4037 float v = (float) STBTT_acos(-STBTT_sqrt(-27/p3) * q / 2) / 3;
4038 float m = (float) STBTT_cos(v);
4039 float n = (float) STBTT_cos(v-3.141592/2)*1.732050808f;
4040 r[0] = s + u * 2 * m;
4041 r[1] = s - u * (m + n);
4042 r[2] = s - u * (m - n);
4051 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)
4053 float scale_x = scale, scale_y = scale;
4054 int ix0,iy0,ix1,iy1;
4056 unsigned char *data;
4059 if (scale_x == 0) scale_x = scale_y;
4061 if (scale_x == 0)
return NULL;
4068 if (ix0 == ix1 || iy0 == iy1)
4079 if (width ) *width = w;
4080 if (height) *height = h;
4081 if (xoff ) *xoff = ix0;
4082 if (yoff ) *yoff = iy0;
4092 data = (
unsigned char *) STBTT_malloc(w * h, info->
userdata);
4093 precompute = (
float *) STBTT_malloc(num_verts *
sizeof(
float), info->
userdata);
4095 for (i=0,j=num_verts-1; i < num_verts; j=i++) {
4097 float x0 = verts[i].
x*scale_x, y0 = verts[i].
y*scale_y;
4098 float x1 = verts[j].
x*scale_x, y1 = verts[j].
y*scale_y;
4099 float dist = (float) STBTT_sqrt((x1-x0)*(x1-x0) + (y1-y0)*(y1-y0));
4100 precompute[i] = (dist == 0) ? 0.0f : 1.0f / dist;
4102 float x2 = verts[j].
x *scale_x, y2 = verts[j].
y *scale_y;
4103 float x1 = verts[i].
cx*scale_x, y1 = verts[i].
cy*scale_y;
4104 float x0 = verts[i].
x *scale_x, y0 = verts[i].
y *scale_y;
4105 float bx = x0 - 2*x1 + x2, by = y0 - 2*y1 + y2;
4106 float len2 = bx*bx + by*by;
4108 precompute[i] = 1.0f / (bx*bx + by*by);
4110 precompute[i] = 0.0f;
4112 precompute[i] = 0.0f;
4115 for (y=iy0; y < iy1; ++y) {
4116 for (x=ix0; x < ix1; ++x) {
4118 float min_dist = 999999.0f;
4119 float sx = (float) x + 0.5f;
4120 float sy = (float) y + 0.5f;
4121 float x_gspace = (sx / scale_x);
4122 float y_gspace = (sy / scale_y);
4124 int winding = stbtt__compute_crossings_x(x_gspace, y_gspace, num_verts, verts);
4126 for (i=0; i < num_verts; ++i) {
4127 float x0 = verts[i].
x*scale_x, y0 = verts[i].
y*scale_y;
4130 float dist2 = (x0-sx)*(x0-sx) + (y0-sy)*(y0-sy);
4131 if (dist2 < min_dist*min_dist)
4132 min_dist = (float) STBTT_sqrt(dist2);
4135 float x1 = verts[i-1].
x*scale_x, y1 = verts[i-1].
y*scale_y;
4140 float dist = (float) STBTT_fabs((x1-x0)*(y0-sy) - (y1-y0)*(x0-sx)) * precompute[i];
4141 STBTT_assert(i != 0);
4142 if (dist < min_dist) {
4146 float dx = x1-x0, dy = y1-y0;
4147 float px = x0-sx, py = y0-sy;
4150 float t = -(px*dx + py*dy) / (dx*dx + dy*dy);
4151 if (t >= 0.0f && t <= 1.0f)
4155 float x2 = verts[i-1].
x *scale_x, y2 = verts[i-1].
y *scale_y;
4156 float x1 = verts[i ].
cx*scale_x, y1 = verts[i ].
cy*scale_y;
4157 float box_x0 = STBTT_min(STBTT_min(x0,x1),x2);
4158 float box_y0 = STBTT_min(STBTT_min(y0,y1),y2);
4159 float box_x1 = STBTT_max(STBTT_max(x0,x1),x2);
4160 float box_y1 = STBTT_max(STBTT_max(y0,y1),y2);
4162 if (sx > box_x0-min_dist && sx < box_x1+min_dist && sy > box_y0-min_dist && sy < box_y1+min_dist) {
4164 float ax = x1-x0, ay = y1-y0;
4165 float bx = x0 - 2*x1 + x2, by = y0 - 2*y1 + y2;
4166 float mx = x0 - sx, my = y0 - sy;
4167 float res[3],px,py,t,it;
4168 float a_inv = precompute[i];
4170 float a = 3*(ax*bx + ay*by);
4171 float b = 2*(ax*ax + ay*ay) + (mx*bx+my*by);
4172 float c = mx*ax+my*ay;
4178 float discriminant = b*b - 4*a*c;
4179 if (discriminant < 0)
4182 float root = (float) STBTT_sqrt(discriminant);
4183 res[0] = (-b - root)/(2*a);
4184 res[1] = (-b + root)/(2*a);
4189 float b = 3*(ax*bx + ay*by) * a_inv;
4190 float c = (2*(ax*ax + ay*ay) + (mx*bx+my*by)) * a_inv;
4191 float d = (mx*ax+my*ay) * a_inv;
4192 num = stbtt__solve_cubic(b, c, d, res);
4194 if (num >= 1 && res[0] >= 0.0f && res[0] <= 1.0f) {
4195 t = res[0], it = 1.0f - t;
4196 px = it*it*x0 + 2*t*it*x1 + t*t*x2;
4197 py = it*it*y0 + 2*t*it*y1 + t*t*y2;
4198 dist2 = (px-sx)*(px-sx) + (py-sy)*(py-sy);
4199 if (dist2 < min_dist * min_dist)
4200 min_dist = (float) STBTT_sqrt(dist2);
4202 if (num >= 2 && res[1] >= 0.0f && res[1] <= 1.0f) {
4203 t = res[1], it = 1.0f - t;
4204 px = it*it*x0 + 2*t*it*x1 + t*t*x2;
4205 py = it*it*y0 + 2*t*it*y1 + t*t*y2;
4206 dist2 = (px-sx)*(px-sx) + (py-sy)*(py-sy);
4207 if (dist2 < min_dist * min_dist)
4208 min_dist = (float) STBTT_sqrt(dist2);
4210 if (num >= 3 && res[2] >= 0.0f && res[2] <= 1.0f) {
4211 t = res[2], it = 1.0f - t;
4212 px = it*it*x0 + 2*t*it*x1 + t*t*x2;
4213 py = it*it*y0 + 2*t*it*y1 + t*t*y2;
4214 dist2 = (px-sx)*(px-sx) + (py-sy)*(py-sy);
4215 if (dist2 < min_dist * min_dist)
4216 min_dist = (float) STBTT_sqrt(dist2);
4222 min_dist = -min_dist;
4223 val = onedge_value + pixel_dist_scale * min_dist;
4228 data[(y-iy0)*w+(x-ix0)] = (
unsigned char) val;
4231 STBTT_free(precompute, info->
userdata);
4237 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)
4239 return stbtt_GetGlyphSDF(info, scale,
stbtt_FindGlyphIndex(info, codepoint), padding, onedge_value, pixel_dist_scale, width, height, xoff, yoff);
4244 STBTT_free(bitmap, userdata);
4253 static stbtt_int32 stbtt__CompareUTF8toUTF16_bigendian_prefix(stbtt_uint8 *s1, stbtt_int32 len1, stbtt_uint8 *s2, stbtt_int32 len2)
4259 stbtt_uint16 ch = s2[0]*256 + s2[1];
4261 if (i >= len1)
return -1;
4262 if (s1[i++] != ch)
return -1;
4263 }
else if (ch < 0x800) {
4264 if (i+1 >= len1)
return -1;
4265 if (s1[i++] != 0xc0 + (ch >> 6))
return -1;
4266 if (s1[i++] != 0x80 + (ch & 0x3f))
return -1;
4267 }
else if (ch >= 0xd800 && ch < 0xdc00) {
4269 stbtt_uint16 ch2 = s2[2]*256 + s2[3];
4270 if (i+3 >= len1)
return -1;
4271 c = ((ch - 0xd800) << 10) + (ch2 - 0xdc00) + 0x10000;
4272 if (s1[i++] != 0xf0 + (c >> 18))
return -1;
4273 if (s1[i++] != 0x80 + ((c >> 12) & 0x3f))
return -1;
4274 if (s1[i++] != 0x80 + ((c >> 6) & 0x3f))
return -1;
4275 if (s1[i++] != 0x80 + ((c ) & 0x3f))
return -1;
4278 }
else if (ch >= 0xdc00 && ch < 0xe000) {
4281 if (i+2 >= len1)
return -1;
4282 if (s1[i++] != 0xe0 + (ch >> 12))
return -1;
4283 if (s1[i++] != 0x80 + ((ch >> 6) & 0x3f))
return -1;
4284 if (s1[i++] != 0x80 + ((ch ) & 0x3f))
return -1;
4292 static int stbtt_CompareUTF8toUTF16_bigendian_internal(
char *s1,
int len1,
char *s2,
int len2)
4294 return len1 == stbtt__CompareUTF8toUTF16_bigendian_prefix((stbtt_uint8*) s1, len1, (stbtt_uint8*) s2, len2);
4301 stbtt_int32 i,count,stringOffset;
4302 stbtt_uint8 *fc = font->
data;
4304 stbtt_uint32 nm = stbtt__find_table(fc, offset,
"name");
4305 if (!nm)
return NULL;
4307 count = ttUSHORT(fc+nm+2);
4308 stringOffset = nm + ttUSHORT(fc+nm+4);
4309 for (i=0; i < count; ++i) {
4310 stbtt_uint32 loc = nm + 6 + 12 * i;
4311 if (platformID == ttUSHORT(fc+loc+0) && encodingID == ttUSHORT(fc+loc+2)
4312 && languageID == ttUSHORT(fc+loc+4) && nameID == ttUSHORT(fc+loc+6)) {
4313 *length = ttUSHORT(fc+loc+8);
4314 return (
const char *) (fc+stringOffset+ttUSHORT(fc+loc+10));
4320 static int stbtt__matchpair(stbtt_uint8 *fc, stbtt_uint32 nm, stbtt_uint8 *name, stbtt_int32 nlen, stbtt_int32 target_id, stbtt_int32 next_id)
4323 stbtt_int32 count = ttUSHORT(fc+nm+2);
4324 stbtt_int32 stringOffset = nm + ttUSHORT(fc+nm+4);
4326 for (i=0; i < count; ++i) {
4327 stbtt_uint32 loc = nm + 6 + 12 * i;
4328 stbtt_int32
id = ttUSHORT(fc+loc+6);
4329 if (
id == target_id) {
4331 stbtt_int32 platform = ttUSHORT(fc+loc+0), encoding = ttUSHORT(fc+loc+2), language = ttUSHORT(fc+loc+4);
4334 if (platform == 0 || (platform == 3 && encoding == 1) || (platform == 3 && encoding == 10)) {
4335 stbtt_int32 slen = ttUSHORT(fc+loc+8);
4336 stbtt_int32 off = ttUSHORT(fc+loc+10);
4339 stbtt_int32 matchlen = stbtt__CompareUTF8toUTF16_bigendian_prefix(name, nlen, fc+stringOffset+off,slen);
4340 if (matchlen >= 0) {
4342 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) {
4343 slen = ttUSHORT(fc+loc+12+8);
4344 off = ttUSHORT(fc+loc+12+10);
4346 if (matchlen == nlen)
4348 }
else if (matchlen < nlen && name[matchlen] ==
' ') {
4350 if (stbtt_CompareUTF8toUTF16_bigendian_internal((
char*) (name+matchlen), nlen-matchlen, (
char*)(fc+stringOffset+off),slen))
4355 if (matchlen == nlen)
4367 static int stbtt__matches(stbtt_uint8 *fc, stbtt_uint32 offset, stbtt_uint8 *name, stbtt_int32 flags)
4369 stbtt_int32 nlen = (stbtt_int32) STBTT_strlen((
char *) name);
4371 if (!stbtt__isfont(fc+offset))
return 0;
4375 hd = stbtt__find_table(fc, offset,
"head");
4376 if ((ttUSHORT(fc+hd+44) & 7) != (flags & 7))
return 0;
4379 nm = stbtt__find_table(fc, offset,
"name");
4384 if (stbtt__matchpair(fc, nm, name, nlen, 16, -1))
return 1;
4385 if (stbtt__matchpair(fc, nm, name, nlen, 1, -1))
return 1;
4386 if (stbtt__matchpair(fc, nm, name, nlen, 3, -1))
return 1;
4388 if (stbtt__matchpair(fc, nm, name, nlen, 16, 17))
return 1;
4389 if (stbtt__matchpair(fc, nm, name, nlen, 1, 2))
return 1;
4390 if (stbtt__matchpair(fc, nm, name, nlen, 3, -1))
return 1;
4396 static int stbtt_FindMatchingFont_internal(
unsigned char *font_collection,
char *name_utf8, stbtt_int32 flags)
4401 if (off < 0)
return off;
4402 if (stbtt__matches((stbtt_uint8 *) font_collection, off, (stbtt_uint8*) name_utf8, flags))
4407 #if defined(__GNUC__) || defined(__clang__)
4408 #pragma GCC diagnostic push
4409 #pragma GCC diagnostic ignored "-Wcast-qual"
4413 float pixel_height,
unsigned char *pixels,
int pw,
int ph,
4416 return stbtt_BakeFontBitmap_internal((
unsigned char *) data, offset, pixel_height, pixels, pw, ph, first_char, num_chars, chardata);
4421 return stbtt_GetFontOffsetForIndex_internal((
unsigned char *) data, index);
4426 return stbtt_GetNumberOfFonts_internal((
unsigned char *) data);
4431 return stbtt_InitFont_internal(info, (
unsigned char *) data, offset);
4436 return stbtt_FindMatchingFont_internal((
unsigned char *) fontdata, (
char *) name, flags);
4441 return stbtt_CompareUTF8toUTF16_bigendian_internal((
char *) s1, len1, (
char *) s2, len2);
4444 #if defined(__GNUC__) || defined(__clang__)
4445 #pragma GCC diagnostic pop
int main(int argc, char *argv[])
STBTT_DEF void stbtt_MakeGlyphBitmapSubpixelPrefilter(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 glyph)
STBTT_DEF void stbtt_GetCodepointHMetrics(const stbtt_fontinfo *info, int codepoint, int *advanceWidth, int *leftSideBearing)
STBTT_DEF int stbtt_GetCodepointShape(const stbtt_fontinfo *info, int unicode_codepoint, stbtt_vertex **vertices)
STBTT_DEF void stbtt_FreeSDF(unsigned char *bitmap, void *userdata)
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)
STBTT_DEF int stbtt_FindGlyphIndex(const stbtt_fontinfo *info, int unicode_codepoint)
STBTT_DEF void stbtt_GetFontVMetrics(const stbtt_fontinfo *info, int *ascent, int *descent, int *lineGap)
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)
STBTT_DEF int stbtt_IsGlyphEmpty(const stbtt_fontinfo *info, int glyph_index)
STBTT_DEF int stbtt_PackFontRanges(stbtt_pack_context *spc, unsigned char *fontdata, int font_index, stbtt_pack_range *ranges, int num_ranges)
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 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)
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)
STBTT_DEF void stbtt_PackSetOversampling(stbtt_pack_context *spc, unsigned int h_oversample, unsigned int v_oversample)
STBTT_DEF void stbtt_GetFontBoundingBox(const stbtt_fontinfo *info, int *x0, int *y0, int *x1, int *y1)
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)
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)
STBTT_DEF void stbtt_Rasterize(stbtt__bitmap *result, float flatness_in_pixels, stbtt_vertex *vertices, int num_verts, float scale_x, float scale_y, float shift_x, float shift_y, int x_off, int y_off, int invert, void *userdata)
STBTT_DEF int stbtt_GetFontOffsetForIndex(const unsigned char *data, int index)
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 int stbtt_GetGlyphShape(const stbtt_fontinfo *info, int glyph_index, stbtt_vertex **vertices)
@ STBTT_MAC_LANG_CHINESE_SIMPLIFIED
@ STBTT_MAC_LANG_JAPANESE
@ STBTT_MAC_LANG_CHINESE_TRAD
STBTT_DEF float stbtt_ScaleForMappingEmToPixels(const stbtt_fontinfo *info, float pixels)
STBTT_DEF int stbtt_FindMatchingFont(const unsigned char *fontdata, const char *name, int flags)
STBTT_DEF void stbtt_GetGlyphBitmapBox(const stbtt_fontinfo *font, int glyph, float scale_x, float scale_y, int *ix0, int *iy0, int *ix1, int *iy1)
struct stbrp_rect stbrp_rect
STBTT_DEF void stbtt_FreeBitmap(unsigned char *bitmap, void *userdata)
STBTT_DEF int stbtt_GetCodepointKernAdvance(const stbtt_fontinfo *info, int ch1, int ch2)
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)
STBTT_DEF void stbtt_FreeShape(const stbtt_fontinfo *info, stbtt_vertex *vertices)
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_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)
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_UNICODE_EID_ISO_10646
@ STBTT_UNICODE_EID_UNICODE_2_0_BMP
@ STBTT_UNICODE_EID_UNICODE_2_0_FULL
@ STBTT_UNICODE_EID_UNICODE_1_1
@ STBTT_UNICODE_EID_UNICODE_1_0
STBTT_DEF int stbtt_PackFontRange(stbtt_pack_context *spc, 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)
STBTT_DEF int stbtt_BakeFontBitmap(const unsigned char *data, int offset, float pixel_height, unsigned char *pixels, int pw, int ph, int first_char, int num_chars, stbtt_bakedchar *chardata)
STBTT_DEF void stbtt_MakeGlyphBitmapSubpixel(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 glyph)
STBTT_DEF float stbtt_ScaleForPixelHeight(const stbtt_fontinfo *info, float pixels)
STBTT_DEF int stbtt_CompareUTF8toUTF16_bigendian(const char *s1, int len1, const char *s2, int len2)
STBTT_DEF void stbtt_PackEnd(stbtt_pack_context *spc)
STBTT_DEF void stbtt_GetGlyphHMetrics(const stbtt_fontinfo *info, int glyph_index, int *advanceWidth, int *leftSideBearing)
STBTT_DEF int stbtt_PackFontRangesRenderIntoRects(stbtt_pack_context *spc, const stbtt_fontinfo *info, stbtt_pack_range *ranges, int num_ranges, stbrp_rect *rects)
STBTT_DEF void stbtt_GetBakedQuad(const stbtt_bakedchar *chardata, int pw, int ph, int char_index, float *xpos, float *ypos, stbtt_aligned_quad *q, int opengl_fillrule)
#define stbtt_vertex_type
STBTT_DEF void stbtt_GetPackedQuad(const stbtt_packedchar *chardata, int pw, int ph, int char_index, float *xpos, float *ypos, stbtt_aligned_quad *q, int align_to_integer)
STBTT_DEF int stbtt_GetCodepointBox(const stbtt_fontinfo *info, int codepoint, int *x0, int *y0, int *x1, int *y1)
@ STBTT_MS_EID_UNICODE_FULL
@ STBTT_MS_EID_UNICODE_BMP
STBTT_DEF int stbtt_InitFont(stbtt_fontinfo *info, const unsigned char *data, int offset)
STBTT_DEF int stbtt_GetGlyphBox(const stbtt_fontinfo *info, int glyph_index, int *x0, int *y0, int *x1, int *y1)
STBTT_DEF int stbtt_GetGlyphKernAdvance(const stbtt_fontinfo *info, int glyph1, int glyph2)
@ STBTT_MAC_EID_CHINESE_TRAD
@ STBTT_PLATFORM_ID_UNICODE
@ STBTT_PLATFORM_ID_MICROSOFT
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)
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)
STBTT_DEF const char * stbtt_GetFontNameString(const stbtt_fontinfo *font, int *length, int platformID, int encodingID, int languageID, int nameID)
STBTT_DEF void stbtt_PackFontRangesPackRects(stbtt_pack_context *spc, stbrp_rect *rects, int num_rects)
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)
STBTT_DEF int stbtt_GetNumberOfFonts(const unsigned char *data)
void * user_allocator_context
unsigned int v_oversample
unsigned int h_oversample
int * array_of_unicode_codepoints
int first_unicode_codepoint_in_range
unsigned char v_oversample
unsigned char h_oversample
stbtt_packedchar * chardata_for_range