mirror of
https://github.com/MaSzyna-EU07/maszyna.git
synced 2026-11-21 16:44:58 +01:00
reformat: use auto on certain types
This commit is contained in:
@@ -1186,7 +1186,7 @@ static stbtt__buf stbtt__cff_get_index(stbtt__buf *b)
|
||||
|
||||
static stbtt_uint32 stbtt__cff_int(stbtt__buf *b)
|
||||
{
|
||||
int b0 = stbtt__buf_get8(b);
|
||||
const int b0 = stbtt__buf_get8(b);
|
||||
if (b0 >= 32 && b0 <= 246) return b0 - 139;
|
||||
else if (b0 >= 247 && b0 <= 250) return (b0 - 247)*256 + stbtt__buf_get8(b) + 108;
|
||||
else if (b0 >= 251 && b0 <= 254) return -(b0 - 251)*256 - stbtt__buf_get8(b) - 108;
|
||||
@@ -1288,11 +1288,11 @@ static int stbtt__isfont(stbtt_uint8 *font)
|
||||
// @OPTIMIZE: binary search
|
||||
static stbtt_uint32 stbtt__find_table(stbtt_uint8 *data, stbtt_uint32 fontstart, const char *tag)
|
||||
{
|
||||
stbtt_int32 num_tables = ttUSHORT(data+fontstart+4);
|
||||
stbtt_uint32 tabledir = fontstart + 12;
|
||||
const stbtt_int32 num_tables = ttUSHORT(data+fontstart+4);
|
||||
const stbtt_uint32 tabledir = fontstart + 12;
|
||||
stbtt_int32 i;
|
||||
for (i=0; i < num_tables; ++i) {
|
||||
stbtt_uint32 loc = tabledir + 16*i;
|
||||
const stbtt_uint32 loc = tabledir + 16*i;
|
||||
if (stbtt_tag(data+loc+0, tag))
|
||||
return ttULONG(data+loc+8);
|
||||
}
|
||||
@@ -1309,7 +1309,7 @@ static int stbtt_GetFontOffsetForIndex_internal(unsigned char *font_collection,
|
||||
if (stbtt_tag(font_collection, "ttcf")) {
|
||||
// version 1?
|
||||
if (ttULONG(font_collection+4) == 0x00010000 || ttULONG(font_collection+4) == 0x00020000) {
|
||||
stbtt_int32 n = ttLONG(font_collection+8);
|
||||
const stbtt_int32 n = ttLONG(font_collection+8);
|
||||
if (index >= n)
|
||||
return -1;
|
||||
return ttULONG(font_collection+12+index*4);
|
||||
@@ -1432,7 +1432,7 @@ static int stbtt_InitFont_internal(stbtt_fontinfo *info, unsigned char *data, in
|
||||
numTables = ttUSHORT(data + cmap + 2);
|
||||
info->index_map = 0;
|
||||
for (i=0; i < numTables; ++i) {
|
||||
stbtt_uint32 encoding_record = cmap + 4 + 8 * i;
|
||||
const stbtt_uint32 encoding_record = cmap + 4 + 8 * i;
|
||||
// find an encoding we understand:
|
||||
switch(ttUSHORT(data+encoding_record)) {
|
||||
case STBTT_PLATFORM_ID_MICROSOFT:
|
||||
@@ -1461,17 +1461,17 @@ static int stbtt_InitFont_internal(stbtt_fontinfo *info, unsigned char *data, in
|
||||
STBTT_DEF int stbtt_FindGlyphIndex(const stbtt_fontinfo *info, int unicode_codepoint)
|
||||
{
|
||||
stbtt_uint8 *data = info->data;
|
||||
stbtt_uint32 index_map = info->index_map;
|
||||
const stbtt_uint32 index_map = info->index_map;
|
||||
|
||||
stbtt_uint16 format = ttUSHORT(data + index_map + 0);
|
||||
const stbtt_uint16 format = ttUSHORT(data + index_map + 0);
|
||||
if (format == 0) { // apple byte encoding
|
||||
stbtt_int32 bytes = ttUSHORT(data + index_map + 2);
|
||||
const stbtt_int32 bytes = ttUSHORT(data + index_map + 2);
|
||||
if (unicode_codepoint < bytes-6)
|
||||
return ttBYTE(data + index_map + 6 + unicode_codepoint);
|
||||
return 0;
|
||||
} else if (format == 6) {
|
||||
stbtt_uint32 first = ttUSHORT(data + index_map + 6);
|
||||
stbtt_uint32 count = ttUSHORT(data + index_map + 8);
|
||||
const stbtt_uint32 first = ttUSHORT(data + index_map + 6);
|
||||
const stbtt_uint32 count = ttUSHORT(data + index_map + 8);
|
||||
if ((stbtt_uint32) unicode_codepoint >= first && (stbtt_uint32) unicode_codepoint < first+count)
|
||||
return ttUSHORT(data + index_map + 10 + (unicode_codepoint - first)*2);
|
||||
return 0;
|
||||
@@ -1479,13 +1479,13 @@ STBTT_DEF int stbtt_FindGlyphIndex(const stbtt_fontinfo *info, int unicode_codep
|
||||
STBTT_assert(0); // @TODO: high-byte mapping for japanese/chinese/korean
|
||||
return 0;
|
||||
} else if (format == 4) { // standard mapping for windows fonts: binary search collection of ranges
|
||||
stbtt_uint16 segcount = ttUSHORT(data+index_map+6) >> 1;
|
||||
const stbtt_uint16 segcount = ttUSHORT(data+index_map+6) >> 1;
|
||||
stbtt_uint16 searchRange = ttUSHORT(data+index_map+8) >> 1;
|
||||
stbtt_uint16 entrySelector = ttUSHORT(data+index_map+10);
|
||||
stbtt_uint16 rangeShift = ttUSHORT(data+index_map+12) >> 1;
|
||||
const stbtt_uint16 rangeShift = ttUSHORT(data+index_map+12) >> 1;
|
||||
|
||||
// do a binary search of the segments
|
||||
stbtt_uint32 endCount = index_map + 14;
|
||||
const stbtt_uint32 endCount = index_map + 14;
|
||||
stbtt_uint32 search = endCount;
|
||||
|
||||
if (unicode_codepoint > 0xffff)
|
||||
@@ -1510,7 +1510,7 @@ STBTT_DEF int stbtt_FindGlyphIndex(const stbtt_fontinfo *info, int unicode_codep
|
||||
|
||||
{
|
||||
stbtt_uint16 offset, start;
|
||||
stbtt_uint16 item = (stbtt_uint16) ((search - endCount) >> 1);
|
||||
const 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);
|
||||
@@ -1524,20 +1524,20 @@ STBTT_DEF int stbtt_FindGlyphIndex(const stbtt_fontinfo *info, int unicode_codep
|
||||
return ttUSHORT(data + offset + (unicode_codepoint-start)*2 + index_map + 14 + segcount*6 + 2 + 2*item);
|
||||
}
|
||||
} else if (format == 12 || format == 13) {
|
||||
stbtt_uint32 ngroups = ttULONG(data+index_map+12);
|
||||
const stbtt_uint32 ngroups = ttULONG(data+index_map+12);
|
||||
stbtt_int32 low,high;
|
||||
low = 0; high = (stbtt_int32)ngroups;
|
||||
// Binary search the right group.
|
||||
while (low < high) {
|
||||
stbtt_int32 mid = low + ((high-low) >> 1); // rounds down, so low <= mid < high
|
||||
stbtt_uint32 start_char = ttULONG(data+index_map+16+mid*12);
|
||||
stbtt_uint32 end_char = ttULONG(data+index_map+16+mid*12+4);
|
||||
const stbtt_int32 mid = low + ((high-low) >> 1); // rounds down, so low <= mid < high
|
||||
const stbtt_uint32 start_char = ttULONG(data+index_map+16+mid*12);
|
||||
const stbtt_uint32 end_char = ttULONG(data+index_map+16+mid*12+4);
|
||||
if ((stbtt_uint32) unicode_codepoint < start_char)
|
||||
high = mid;
|
||||
else if ((stbtt_uint32) unicode_codepoint > end_char)
|
||||
low = mid+1;
|
||||
else {
|
||||
stbtt_uint32 start_glyph = ttULONG(data+index_map+16+mid*12+8);
|
||||
const stbtt_uint32 start_glyph = ttULONG(data+index_map+16+mid*12+8);
|
||||
if (format == 12)
|
||||
return start_glyph + unicode_codepoint-start_char;
|
||||
else // format == 13
|
||||
@@ -1592,7 +1592,7 @@ STBTT_DEF int stbtt_GetGlyphBox(const stbtt_fontinfo *info, int glyph_index, int
|
||||
if (info->cff.size) {
|
||||
stbtt__GetGlyphInfoT2(info, glyph_index, x0, y0, x1, y1);
|
||||
} else {
|
||||
int g = stbtt__GetGlyfOffset(info, glyph_index);
|
||||
const int g = stbtt__GetGlyfOffset(info, glyph_index);
|
||||
if (g < 0) return 0;
|
||||
|
||||
if (x0) *x0 = ttSHORT(info->data + g + 2);
|
||||
@@ -1924,10 +1924,10 @@ static void stbtt__csctx_rline_to(stbtt__csctx *ctx, float dx, float dy)
|
||||
|
||||
static void stbtt__csctx_rccurve_to(stbtt__csctx *ctx, float dx1, float dy1, float dx2, float dy2, float dx3, float dy3)
|
||||
{
|
||||
float cx1 = ctx->x + dx1;
|
||||
float cy1 = ctx->y + dy1;
|
||||
float cx2 = cx1 + dx2;
|
||||
float cy2 = cy1 + dy2;
|
||||
const float cx1 = ctx->x + dx1;
|
||||
const float cy1 = ctx->y + dy1;
|
||||
const float cx2 = cx1 + dx2;
|
||||
const float cy2 = cy1 + dy2;
|
||||
ctx->x = cx2 + dx3;
|
||||
ctx->y = cy2 + dy3;
|
||||
stbtt__csctx_v(ctx, STBTT_vcubic, (int)ctx->x, (int)ctx->y, (int)cx1, (int)cy1, (int)cx2, (int)cy2);
|
||||
@@ -1935,7 +1935,7 @@ static void stbtt__csctx_rccurve_to(stbtt__csctx *ctx, float dx1, float dy1, flo
|
||||
|
||||
static stbtt__buf stbtt__get_subr(stbtt__buf idx, int n)
|
||||
{
|
||||
int count = stbtt__cff_index_count(&idx);
|
||||
const int count = stbtt__cff_index_count(&idx);
|
||||
int bias = 107;
|
||||
if (count >= 33900)
|
||||
bias = 32768;
|
||||
@@ -2254,7 +2254,7 @@ static int stbtt__GetGlyphShapeT2(const stbtt_fontinfo *info, int glyph_index, s
|
||||
static int stbtt__GetGlyphInfoT2(const stbtt_fontinfo *info, int glyph_index, int *x0, int *y0, int *x1, int *y1)
|
||||
{
|
||||
stbtt__csctx c = STBTT__CSCTX_INIT(1);
|
||||
int r = stbtt__run_charstring(info, glyph_index, &c);
|
||||
const int r = stbtt__run_charstring(info, glyph_index, &c);
|
||||
if (x0) *x0 = r ? c.min_x : 0;
|
||||
if (y0) *y0 = r ? c.min_y : 0;
|
||||
if (x1) *x1 = r ? c.max_x : 0;
|
||||
@@ -2272,7 +2272,7 @@ STBTT_DEF int stbtt_GetGlyphShape(const stbtt_fontinfo *info, int glyph_index, s
|
||||
|
||||
STBTT_DEF void stbtt_GetGlyphHMetrics(const stbtt_fontinfo *info, int glyph_index, int *advanceWidth, int *leftSideBearing)
|
||||
{
|
||||
stbtt_uint16 numOfLongHorMetrics = ttUSHORT(info->data+info->hhea + 34);
|
||||
const stbtt_uint16 numOfLongHorMetrics = ttUSHORT(info->data+info->hhea + 34);
|
||||
if (glyph_index < numOfLongHorMetrics) {
|
||||
if (advanceWidth) *advanceWidth = ttSHORT(info->data + info->hmtx + 4*glyph_index);
|
||||
if (leftSideBearing) *leftSideBearing = ttSHORT(info->data + info->hmtx + 4*glyph_index + 2);
|
||||
@@ -2314,10 +2314,10 @@ static int stbtt__GetGlyphKernInfoAdvance(const stbtt_fontinfo *info, int glyph
|
||||
|
||||
static stbtt_int32 stbtt__GetCoverageIndex(stbtt_uint8 *coverageTable, int glyph)
|
||||
{
|
||||
stbtt_uint16 coverageFormat = ttUSHORT(coverageTable);
|
||||
const stbtt_uint16 coverageFormat = ttUSHORT(coverageTable);
|
||||
switch(coverageFormat) {
|
||||
case 1: {
|
||||
stbtt_uint16 glyphCount = ttUSHORT(coverageTable + 2);
|
||||
const stbtt_uint16 glyphCount = ttUSHORT(coverageTable + 2);
|
||||
|
||||
// Binary search.
|
||||
stbtt_int32 l=0, r=glyphCount-1, m;
|
||||
@@ -2339,7 +2339,7 @@ static stbtt_int32 stbtt__GetCoverageIndex(stbtt_uint8 *coverageTable, int glyp
|
||||
} break;
|
||||
|
||||
case 2: {
|
||||
stbtt_uint16 rangeCount = ttUSHORT(coverageTable + 2);
|
||||
const stbtt_uint16 rangeCount = ttUSHORT(coverageTable + 2);
|
||||
stbtt_uint8 *rangeArray = coverageTable + 4;
|
||||
|
||||
// Binary search.
|
||||
@@ -2356,7 +2356,7 @@ static stbtt_int32 stbtt__GetCoverageIndex(stbtt_uint8 *coverageTable, int glyp
|
||||
else if (needle > strawEnd)
|
||||
l = m + 1;
|
||||
else {
|
||||
stbtt_uint16 startCoverageIndex = ttUSHORT(rangeRecord + 4);
|
||||
const stbtt_uint16 startCoverageIndex = ttUSHORT(rangeRecord + 4);
|
||||
return startCoverageIndex + glyph - strawStart;
|
||||
}
|
||||
}
|
||||
@@ -2373,12 +2373,12 @@ static stbtt_int32 stbtt__GetCoverageIndex(stbtt_uint8 *coverageTable, int glyp
|
||||
|
||||
static stbtt_int32 stbtt__GetGlyphClass(stbtt_uint8 *classDefTable, int glyph)
|
||||
{
|
||||
stbtt_uint16 classDefFormat = ttUSHORT(classDefTable);
|
||||
const stbtt_uint16 classDefFormat = ttUSHORT(classDefTable);
|
||||
switch(classDefFormat)
|
||||
{
|
||||
case 1: {
|
||||
stbtt_uint16 startGlyphID = ttUSHORT(classDefTable + 2);
|
||||
stbtt_uint16 glyphCount = ttUSHORT(classDefTable + 4);
|
||||
const stbtt_uint16 startGlyphID = ttUSHORT(classDefTable + 2);
|
||||
const stbtt_uint16 glyphCount = ttUSHORT(classDefTable + 4);
|
||||
stbtt_uint8 *classDef1ValueArray = classDefTable + 6;
|
||||
|
||||
if (glyph >= startGlyphID && glyph < startGlyphID + glyphCount)
|
||||
@@ -2389,7 +2389,7 @@ static stbtt_int32 stbtt__GetGlyphClass(stbtt_uint8 *classDefTable, int glyph)
|
||||
} break;
|
||||
|
||||
case 2: {
|
||||
stbtt_uint16 classRangeCount = ttUSHORT(classDefTable + 2);
|
||||
const stbtt_uint16 classRangeCount = ttUSHORT(classDefTable + 2);
|
||||
stbtt_uint8 *classRangeRecords = classDefTable + 4;
|
||||
|
||||
// Binary search.
|
||||
@@ -2445,34 +2445,34 @@ static stbtt_int32 stbtt__GetGlyphGPOSInfoAdvance(const stbtt_fontinfo *info, i
|
||||
lookupCount = ttUSHORT(lookupList);
|
||||
|
||||
for (i=0; i<lookupCount; ++i) {
|
||||
stbtt_uint16 lookupOffset = ttUSHORT(lookupList + 2 + 2 * i);
|
||||
const stbtt_uint16 lookupOffset = ttUSHORT(lookupList + 2 + 2 * i);
|
||||
stbtt_uint8 *lookupTable = lookupList + lookupOffset;
|
||||
|
||||
stbtt_uint16 lookupType = ttUSHORT(lookupTable);
|
||||
stbtt_uint16 subTableCount = ttUSHORT(lookupTable + 4);
|
||||
const stbtt_uint16 lookupType = ttUSHORT(lookupTable);
|
||||
const 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);
|
||||
const 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);
|
||||
const stbtt_uint16 posFormat = ttUSHORT(table);
|
||||
const stbtt_uint16 coverageOffset = ttUSHORT(table + 2);
|
||||
const 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);
|
||||
const stbtt_uint16 valueFormat1 = ttUSHORT(table + 4);
|
||||
const stbtt_uint16 valueFormat2 = ttUSHORT(table + 6);
|
||||
const stbtt_int32 valueRecordPairSizeInBytes = 2;
|
||||
const stbtt_uint16 pairSetCount = ttUSHORT(table + 8);
|
||||
const stbtt_uint16 pairPosOffset = ttUSHORT(table + 10 + 2 * coverageIndex);
|
||||
stbtt_uint8 *pairValueTable = table + pairPosOffset;
|
||||
stbtt_uint16 pairValueCount = ttUSHORT(pairValueTable);
|
||||
const stbtt_uint16 pairValueCount = ttUSHORT(pairValueTable);
|
||||
stbtt_uint8 *pairValueArray = pairValueTable + 2;
|
||||
// TODO: Support more formats.
|
||||
STBTT_GPOS_TODO_assert(valueFormat1 == 4);
|
||||
@@ -2500,23 +2500,23 @@ static stbtt_int32 stbtt__GetGlyphGPOSInfoAdvance(const stbtt_fontinfo *info, i
|
||||
else if (needle > straw)
|
||||
l = m + 1;
|
||||
else {
|
||||
stbtt_int16 xAdvance = ttSHORT(pairValue + 2);
|
||||
const stbtt_int16 xAdvance = ttSHORT(pairValue + 2);
|
||||
return xAdvance;
|
||||
}
|
||||
}
|
||||
} break;
|
||||
|
||||
case 2: {
|
||||
stbtt_uint16 valueFormat1 = ttUSHORT(table + 4);
|
||||
stbtt_uint16 valueFormat2 = ttUSHORT(table + 6);
|
||||
const stbtt_uint16 valueFormat1 = ttUSHORT(table + 4);
|
||||
const 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);
|
||||
const stbtt_uint16 classDef1Offset = ttUSHORT(table + 8);
|
||||
const stbtt_uint16 classDef2Offset = ttUSHORT(table + 10);
|
||||
const int glyph1class = stbtt__GetGlyphClass(table + classDef1Offset, glyph1);
|
||||
const int glyph2class = stbtt__GetGlyphClass(table + classDef2Offset, glyph2);
|
||||
|
||||
stbtt_uint16 class1Count = ttUSHORT(table + 12);
|
||||
stbtt_uint16 class2Count = ttUSHORT(table + 14);
|
||||
const stbtt_uint16 class1Count = ttUSHORT(table + 12);
|
||||
const stbtt_uint16 class2Count = ttUSHORT(table + 14);
|
||||
STBTT_assert(glyph1class < class1Count);
|
||||
STBTT_assert(glyph2class < class2Count);
|
||||
|
||||
@@ -2529,7 +2529,7 @@ static stbtt_int32 stbtt__GetGlyphGPOSInfoAdvance(const stbtt_fontinfo *info, i
|
||||
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);
|
||||
const stbtt_int16 xAdvance = ttSHORT(class2Records + 2 * glyph2class);
|
||||
return xAdvance;
|
||||
}
|
||||
} break;
|
||||
@@ -2587,7 +2587,7 @@ STBTT_DEF void stbtt_GetFontVMetrics(const stbtt_fontinfo *info, int *ascent, in
|
||||
|
||||
STBTT_DEF int stbtt_GetFontVMetricsOS2(const stbtt_fontinfo *info, int *typoAscent, int *typoDescent, int *typoLineGap)
|
||||
{
|
||||
int tab = stbtt__find_table(info->data, info->fontstart, "OS/2");
|
||||
const int tab = stbtt__find_table(info->data, info->fontstart, "OS/2");
|
||||
if (!tab)
|
||||
return 0;
|
||||
if (typoAscent ) *typoAscent = ttSHORT(info->data+tab + 68);
|
||||
@@ -2606,13 +2606,13 @@ STBTT_DEF void stbtt_GetFontBoundingBox(const stbtt_fontinfo *info, int *x0, int
|
||||
|
||||
STBTT_DEF float stbtt_ScaleForPixelHeight(const stbtt_fontinfo *info, float height)
|
||||
{
|
||||
int fheight = ttSHORT(info->data + info->hhea + 4) - ttSHORT(info->data + info->hhea + 6);
|
||||
const int fheight = ttSHORT(info->data + info->hhea + 4) - ttSHORT(info->data + info->hhea + 6);
|
||||
return (float) height / fheight;
|
||||
}
|
||||
|
||||
STBTT_DEF float stbtt_ScaleForMappingEmToPixels(const stbtt_fontinfo *info, float pixels)
|
||||
{
|
||||
int unitsPerEm = ttUSHORT(info->data + info->head + 18);
|
||||
const int unitsPerEm = ttUSHORT(info->data + info->head + 18);
|
||||
return pixels / unitsPerEm;
|
||||
}
|
||||
|
||||
@@ -2683,8 +2683,8 @@ static void *stbtt__hheap_alloc(stbtt__hheap *hh, size_t size, void *userdata)
|
||||
return p;
|
||||
} else {
|
||||
if (hh->num_remaining_in_head_chunk == 0) {
|
||||
int count = (size < 32 ? 2000 : size < 128 ? 800 : 100);
|
||||
auto c = (stbtt__hheap_chunk *) STBTT_malloc(sizeof(stbtt__hheap_chunk) + size * count, userdata);
|
||||
const int count = (size < 32 ? 2000 : size < 128 ? 800 : 100);
|
||||
const auto c = (stbtt__hheap_chunk *) STBTT_malloc(sizeof(stbtt__hheap_chunk) + size * count, userdata);
|
||||
if (c == NULL)
|
||||
return NULL;
|
||||
c->next = hh->head;
|
||||
@@ -2972,7 +2972,7 @@ static void stbtt__handle_clipped_edge(float *scanline, int x, stbtt__active_edg
|
||||
|
||||
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;
|
||||
const float y_bottom = y_top+1;
|
||||
|
||||
while (e) {
|
||||
// brute force every pixel
|
||||
@@ -2981,7 +2981,7 @@ static void stbtt__fill_active_edges_new(float *scanline, float *scanline_fill,
|
||||
STBTT_assert(e->ey >= y_top);
|
||||
|
||||
if (e->fdx == 0) {
|
||||
float x0 = e->fx;
|
||||
const float x0 = e->fx;
|
||||
if (x0 < len) {
|
||||
if (x0 >= 0) {
|
||||
stbtt__handle_clipped_edge(scanline,(int) x0,e, x0,y_top, x0,y_bottom);
|
||||
@@ -3023,7 +3023,7 @@ static void stbtt__fill_active_edges_new(float *scanline, float *scanline_fill,
|
||||
if ((int) x_top == (int) x_bottom) {
|
||||
float height;
|
||||
// simple case, only spans one pixel
|
||||
int x = (int) x_top;
|
||||
const int x = (int) x_top;
|
||||
height = sy1 - sy0;
|
||||
STBTT_assert(x >= 0 && x < len);
|
||||
scanline[x] += e->direction * (1-((x_top - x) + (x_bottom-x))/2) * height;
|
||||
@@ -3091,17 +3091,17 @@ static void stbtt__fill_active_edges_new(float *scanline, float *scanline_fill,
|
||||
// that, we need to explicitly produce segments based on x positions.
|
||||
|
||||
// rename variables to clearly-defined pairs
|
||||
float y0 = y_top;
|
||||
float x1 = (float) (x);
|
||||
float x2 = (float) (x+1);
|
||||
float x3 = xb;
|
||||
float y3 = y_bottom;
|
||||
const float y0 = y_top;
|
||||
const float x1 = (float) (x);
|
||||
const float x2 = (float) (x+1);
|
||||
const float x3 = xb;
|
||||
const float y3 = y_bottom;
|
||||
|
||||
// x = e->x + e->dx * (y-y_top)
|
||||
// (y-y_top) = (x - e->x) / e->dx
|
||||
// y = (x - e->x) / e->dx + y_top
|
||||
float y1 = (x - x0) / dx + y_top;
|
||||
float y2 = (x+1 - x0) / dx + y_top;
|
||||
const float y1 = (x - x0) / dx + y_top;
|
||||
const float y2 = (x+1 - x0) / dx + y_top;
|
||||
|
||||
if (x0 < x1 && x3 > x2) { // three segments descending down-right
|
||||
stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x1,y1);
|
||||
@@ -3155,8 +3155,8 @@ static void stbtt__rasterize_sorted_edges(stbtt__bitmap *result, stbtt__edge *e,
|
||||
|
||||
while (j < result->h) {
|
||||
// find center of pixel for this scanline
|
||||
float scan_y_top = y + 0.0f;
|
||||
float scan_y_bottom = y + 1.0f;
|
||||
const float scan_y_top = y + 0.0f;
|
||||
const float scan_y_bottom = y + 1.0f;
|
||||
stbtt__active_edge **step = &active;
|
||||
|
||||
STBTT_memset(scanline , 0, result->w*sizeof(scanline[0]));
|
||||
@@ -3243,8 +3243,8 @@ static void stbtt__sort_edges_ins_sort(stbtt__edge *p, int n)
|
||||
stbtt__edge t = p[i], *a = &t;
|
||||
j = i;
|
||||
while (j > 0) {
|
||||
stbtt__edge *b = &p[j-1];
|
||||
int c = STBTT__COMPARE(a,b);
|
||||
const stbtt__edge *b = &p[j-1];
|
||||
const int c = STBTT__COMPARE(a,b);
|
||||
if (!c) break;
|
||||
p[j] = p[j-1];
|
||||
--j;
|
||||
@@ -3329,13 +3329,13 @@ typedef struct
|
||||
|
||||
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)
|
||||
{
|
||||
float y_scale_inv = invert ? -scale_y : scale_y;
|
||||
const float y_scale_inv = invert ? -scale_y : scale_y;
|
||||
stbtt__edge *e;
|
||||
int n,i,j,k,m;
|
||||
#if STBTT_RASTERIZER_VERSION == 1
|
||||
int vsubsample = result->h < 8 ? 15 : 5;
|
||||
#elif STBTT_RASTERIZER_VERSION == 2
|
||||
int vsubsample = 1;
|
||||
const int vsubsample = 1;
|
||||
#else
|
||||
#error "Unrecognized value of STBTT_RASTERIZER_VERSION"
|
||||
#endif
|
||||
@@ -3352,7 +3352,7 @@ static void stbtt__rasterize(stbtt__bitmap *result, stbtt__point *pts, int *wcou
|
||||
|
||||
m=0;
|
||||
for (i=0; i < windings; ++i) {
|
||||
stbtt__point *p = pts + m;
|
||||
const stbtt__point *p = pts + m;
|
||||
m += wcount[i];
|
||||
j = wcount[i]-1;
|
||||
for (k=0; k < wcount[i]; j=k++) {
|
||||
@@ -3395,11 +3395,11 @@ static void stbtt__add_point(stbtt__point *points, int n, float x, float y)
|
||||
static int stbtt__tesselate_curve(stbtt__point *points, int *num_points, float x0, float y0, float x1, float y1, float x2, float y2, float objspace_flatness_squared, int n)
|
||||
{
|
||||
// midpoint
|
||||
float mx = (x0 + 2*x1 + x2)/4;
|
||||
float my = (y0 + 2*y1 + y2)/4;
|
||||
const float mx = (x0 + 2*x1 + x2)/4;
|
||||
const float my = (y0 + 2*y1 + y2)/4;
|
||||
// versus directly drawn line
|
||||
float dx = (x0+x2)/2 - mx;
|
||||
float dy = (y0+y2)/2 - my;
|
||||
const float dx = (x0+x2)/2 - mx;
|
||||
const float dy = (y0+y2)/2 - my;
|
||||
if (n > 16) // 65536 segments on one curve better be enough!
|
||||
return 1;
|
||||
if (dx*dx+dy*dy > objspace_flatness_squared) { // half-pixel error allowed... need to be smaller if AA
|
||||
@@ -3415,36 +3415,36 @@ static int stbtt__tesselate_curve(stbtt__point *points, int *num_points, float x
|
||||
static void stbtt__tesselate_cubic(stbtt__point *points, int *num_points, float x0, float y0, float x1, float y1, float x2, float y2, float x3, float y3, float objspace_flatness_squared, int n)
|
||||
{
|
||||
// @TODO this "flatness" calculation is just made-up nonsense that seems to work well enough
|
||||
float dx0 = x1-x0;
|
||||
float dy0 = y1-y0;
|
||||
float dx1 = x2-x1;
|
||||
float dy1 = y2-y1;
|
||||
float dx2 = x3-x2;
|
||||
float dy2 = y3-y2;
|
||||
float dx = x3-x0;
|
||||
float dy = y3-y0;
|
||||
float longlen = (float) (STBTT_sqrt(dx0*dx0+dy0*dy0)+STBTT_sqrt(dx1*dx1+dy1*dy1)+STBTT_sqrt(dx2*dx2+dy2*dy2));
|
||||
float shortlen = (float) STBTT_sqrt(dx*dx+dy*dy);
|
||||
float flatness_squared = longlen*longlen-shortlen*shortlen;
|
||||
const float dx0 = x1-x0;
|
||||
const float dy0 = y1-y0;
|
||||
const float dx1 = x2-x1;
|
||||
const float dy1 = y2-y1;
|
||||
const float dx2 = x3-x2;
|
||||
const float dy2 = y3-y2;
|
||||
const float dx = x3-x0;
|
||||
const float dy = y3-y0;
|
||||
const float longlen = (float) (STBTT_sqrt(dx0*dx0+dy0*dy0)+STBTT_sqrt(dx1*dx1+dy1*dy1)+STBTT_sqrt(dx2*dx2+dy2*dy2));
|
||||
const float shortlen = (float) STBTT_sqrt(dx*dx+dy*dy);
|
||||
const float flatness_squared = longlen*longlen-shortlen*shortlen;
|
||||
|
||||
if (n > 16) // 65536 segments on one curve better be enough!
|
||||
return;
|
||||
|
||||
if (flatness_squared > objspace_flatness_squared) {
|
||||
float x01 = (x0+x1)/2;
|
||||
float y01 = (y0+y1)/2;
|
||||
float x12 = (x1+x2)/2;
|
||||
float y12 = (y1+y2)/2;
|
||||
float x23 = (x2+x3)/2;
|
||||
float y23 = (y2+y3)/2;
|
||||
const float x01 = (x0+x1)/2;
|
||||
const float y01 = (y0+y1)/2;
|
||||
const float x12 = (x1+x2)/2;
|
||||
const float y12 = (y1+y2)/2;
|
||||
const float x23 = (x2+x3)/2;
|
||||
const float y23 = (y2+y3)/2;
|
||||
|
||||
float xa = (x01+x12)/2;
|
||||
float ya = (y01+y12)/2;
|
||||
float xb = (x12+x23)/2;
|
||||
float yb = (y12+y23)/2;
|
||||
const float xa = (x01+x12)/2;
|
||||
const float ya = (y01+y12)/2;
|
||||
const float xb = (x12+x23)/2;
|
||||
const float yb = (y12+y23)/2;
|
||||
|
||||
float mx = (xa+xb)/2;
|
||||
float my = (ya+yb)/2;
|
||||
const float mx = (xa+xb)/2;
|
||||
const float my = (ya+yb)/2;
|
||||
|
||||
stbtt__tesselate_cubic(points, num_points, x0,y0, x01,y01, xa,ya, mx,my, objspace_flatness_squared,n+1);
|
||||
stbtt__tesselate_cubic(points, num_points, mx,my, xb,yb, x23,y23, x3,y3, objspace_flatness_squared,n+1);
|
||||
@@ -3460,7 +3460,7 @@ static stbtt__point *stbtt_FlattenCurves(stbtt_vertex *vertices, int num_verts,
|
||||
stbtt__point *points=0;
|
||||
int num_points=0;
|
||||
|
||||
float objspace_flatness_squared = objspace_flatness * objspace_flatness;
|
||||
const float objspace_flatness_squared = objspace_flatness * objspace_flatness;
|
||||
int i,n=0,start=0, pass;
|
||||
|
||||
// count how many "moves" there are to get the contour count
|
||||
@@ -3534,7 +3534,7 @@ error:
|
||||
|
||||
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)
|
||||
{
|
||||
float scale = scale_x > scale_y ? scale_y : scale_x;
|
||||
const float scale = scale_x > scale_y ? scale_y : scale_x;
|
||||
int winding_count = 0;
|
||||
int *winding_lengths = NULL;
|
||||
stbtt__point *windings = stbtt_FlattenCurves(vertices, num_verts, flatness_in_pixels / scale, &winding_lengths, &winding_count, userdata);
|
||||
@@ -3554,8 +3554,8 @@ STBTT_DEF unsigned char *stbtt_GetGlyphBitmapSubpixel(const stbtt_fontinfo *info
|
||||
{
|
||||
int ix0,iy0,ix1,iy1;
|
||||
stbtt__bitmap gbm;
|
||||
stbtt_vertex *vertices;
|
||||
int num_verts = stbtt_GetGlyphShape(info, glyph, &vertices);
|
||||
stbtt_vertex *vertices;
|
||||
const int num_verts = stbtt_GetGlyphShape(info, glyph, &vertices);
|
||||
|
||||
if (scale_x == 0) scale_x = scale_y;
|
||||
if (scale_y == 0) {
|
||||
@@ -3599,7 +3599,7 @@ STBTT_DEF void stbtt_MakeGlyphBitmapSubpixel(const stbtt_fontinfo *info, unsigne
|
||||
{
|
||||
int ix0,iy0;
|
||||
stbtt_vertex *vertices;
|
||||
int num_verts = stbtt_GetGlyphShape(info, glyph, &vertices);
|
||||
const int num_verts = stbtt_GetGlyphShape(info, glyph, &vertices);
|
||||
stbtt__bitmap gbm;
|
||||
|
||||
stbtt_GetGlyphBitmapBoxSubpixel(info, glyph, scale_x, scale_y, shift_x, shift_y, &ix0,&iy0,0,0);
|
||||
@@ -3670,7 +3670,7 @@ static int stbtt_BakeFontBitmap_internal(unsigned char *data, int offset, // fo
|
||||
|
||||
for (i=0; i < num_chars; ++i) {
|
||||
int advance, lsb, x0,y0,x1,y1,gw,gh;
|
||||
int g = stbtt_FindGlyphIndex(&f, first_char + i);
|
||||
const int g = stbtt_FindGlyphIndex(&f, first_char + i);
|
||||
stbtt_GetGlyphHMetrics(&f, g, &advance, &lsb);
|
||||
stbtt_GetGlyphBitmapBox(&f, g, scale,scale, &x0,&y0,&x1,&y1);
|
||||
gw = x1-x0;
|
||||
@@ -3698,11 +3698,11 @@ static int stbtt_BakeFontBitmap_internal(unsigned char *data, int offset, // fo
|
||||
|
||||
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)
|
||||
{
|
||||
float d3d_bias = opengl_fillrule ? 0 : -0.5f;
|
||||
const float d3d_bias = opengl_fillrule ? 0 : -0.5f;
|
||||
float ipw = 1.0f / pw, iph = 1.0f / ph;
|
||||
const stbtt_bakedchar *b = chardata + char_index;
|
||||
int round_x = STBTT_ifloor((*xpos + b->xoff) + 0.5f);
|
||||
int round_y = STBTT_ifloor((*ypos + b->yoff) + 0.5f);
|
||||
const int round_x = STBTT_ifloor((*xpos + b->xoff) + 0.5f);
|
||||
const int round_y = STBTT_ifloor((*ypos + b->yoff) + 0.5f);
|
||||
|
||||
q->x0 = round_x + d3d_bias;
|
||||
q->y0 = round_y + d3d_bias;
|
||||
@@ -3852,7 +3852,7 @@ STBTT_DEF void stbtt_PackSetSkipMissingCodepoints(stbtt_pack_context *spc, int s
|
||||
static void stbtt__h_prefilter(unsigned char *pixels, int w, int h, int stride_in_bytes, unsigned int kernel_width)
|
||||
{
|
||||
unsigned char buffer[STBTT_MAX_OVERSAMPLE];
|
||||
int safe_w = w - kernel_width;
|
||||
const int safe_w = w - kernel_width;
|
||||
int j;
|
||||
STBTT_memset(buffer, 0, STBTT_MAX_OVERSAMPLE); // suppress bogus warning from VS2013 -analyze
|
||||
for (j=0; j < h; ++j) {
|
||||
@@ -3914,7 +3914,7 @@ static void stbtt__h_prefilter(unsigned char *pixels, int w, int h, int stride_i
|
||||
static void stbtt__v_prefilter(unsigned char *pixels, int w, int h, int stride_in_bytes, unsigned int kernel_width)
|
||||
{
|
||||
unsigned char buffer[STBTT_MAX_OVERSAMPLE];
|
||||
int safe_h = h - kernel_width;
|
||||
const int safe_h = h - kernel_width;
|
||||
int j;
|
||||
STBTT_memset(buffer, 0, STBTT_MAX_OVERSAMPLE); // suppress bogus warning from VS2013 -analyze
|
||||
for (j=0; j < w; ++j) {
|
||||
@@ -3992,14 +3992,14 @@ STBTT_DEF int stbtt_PackFontRangesGatherRects(stbtt_pack_context *spc, const stb
|
||||
|
||||
k=0;
|
||||
for (i=0; i < num_ranges; ++i) {
|
||||
float fh = ranges[i].font_size;
|
||||
float scale = fh > 0 ? stbtt_ScaleForPixelHeight(info, fh) : stbtt_ScaleForMappingEmToPixels(info, -fh);
|
||||
const float fh = ranges[i].font_size;
|
||||
const float scale = fh > 0 ? stbtt_ScaleForPixelHeight(info, fh) : stbtt_ScaleForMappingEmToPixels(info, -fh);
|
||||
ranges[i].h_oversample = (unsigned char) spc->h_oversample;
|
||||
ranges[i].v_oversample = (unsigned char) spc->v_oversample;
|
||||
for (j=0; j < ranges[i].num_chars; ++j) {
|
||||
int x0,y0,x1,y1;
|
||||
int codepoint = ranges[i].array_of_unicode_codepoints == NULL ? ranges[i].first_unicode_codepoint_in_range + j : ranges[i].array_of_unicode_codepoints[j];
|
||||
int glyph = stbtt_FindGlyphIndex(info, codepoint);
|
||||
const int codepoint = ranges[i].array_of_unicode_codepoints == NULL ? ranges[i].first_unicode_codepoint_in_range + j : ranges[i].array_of_unicode_codepoints[j];
|
||||
const int glyph = stbtt_FindGlyphIndex(info, codepoint);
|
||||
if (glyph == 0 && spc->skip_missing) {
|
||||
rects[k].w = rects[k].h = 0;
|
||||
} else {
|
||||
@@ -4047,13 +4047,13 @@ STBTT_DEF int stbtt_PackFontRangesRenderIntoRects(stbtt_pack_context *spc, const
|
||||
int i,j,k, return_value = 1;
|
||||
|
||||
// save current values
|
||||
int old_h_over = spc->h_oversample;
|
||||
int old_v_over = spc->v_oversample;
|
||||
const int old_h_over = spc->h_oversample;
|
||||
const int old_v_over = spc->v_oversample;
|
||||
|
||||
k = 0;
|
||||
for (i=0; i < num_ranges; ++i) {
|
||||
float fh = ranges[i].font_size;
|
||||
float scale = fh > 0 ? stbtt_ScaleForPixelHeight(info, fh) : stbtt_ScaleForMappingEmToPixels(info, -fh);
|
||||
const float fh = ranges[i].font_size;
|
||||
const float scale = fh > 0 ? stbtt_ScaleForPixelHeight(info, fh) : stbtt_ScaleForMappingEmToPixels(info, -fh);
|
||||
float recip_h,recip_v,sub_x,sub_y;
|
||||
spc->h_oversample = ranges[i].h_oversample;
|
||||
spc->v_oversample = ranges[i].v_oversample;
|
||||
@@ -4066,9 +4066,9 @@ STBTT_DEF int stbtt_PackFontRangesRenderIntoRects(stbtt_pack_context *spc, const
|
||||
if (r->was_packed && r->w != 0 && r->h != 0) {
|
||||
stbtt_packedchar *bc = &ranges[i].chardata_for_range[j];
|
||||
int advance, lsb, x0,y0,x1,y1;
|
||||
int codepoint = ranges[i].array_of_unicode_codepoints == NULL ? ranges[i].first_unicode_codepoint_in_range + j : ranges[i].array_of_unicode_codepoints[j];
|
||||
int glyph = stbtt_FindGlyphIndex(info, codepoint);
|
||||
stbrp_coord pad = (stbrp_coord) spc->padding;
|
||||
const int codepoint = ranges[i].array_of_unicode_codepoints == NULL ? ranges[i].first_unicode_codepoint_in_range + j : ranges[i].array_of_unicode_codepoints[j];
|
||||
const int glyph = stbtt_FindGlyphIndex(info, codepoint);
|
||||
const stbrp_coord pad = (stbrp_coord) spc->padding;
|
||||
|
||||
// pad on left and top
|
||||
r->x += pad;
|
||||
@@ -4196,8 +4196,8 @@ STBTT_DEF void stbtt_GetPackedQuad(const stbtt_packedchar *chardata, int pw, int
|
||||
const stbtt_packedchar *b = chardata + char_index;
|
||||
|
||||
if (align_to_integer) {
|
||||
float x = (float) STBTT_ifloor((*xpos + b->xoff) + 0.5f);
|
||||
float y = (float) STBTT_ifloor((*ypos + b->yoff) + 0.5f);
|
||||
const float x = (float) STBTT_ifloor((*xpos + b->xoff) + 0.5f);
|
||||
const float y = (float) STBTT_ifloor((*ypos + b->yoff) + 0.5f);
|
||||
q->x0 = x;
|
||||
q->y0 = y;
|
||||
q->x1 = x + b->xoff2 - b->xoff;
|
||||
@@ -4227,23 +4227,23 @@ STBTT_DEF void stbtt_GetPackedQuad(const stbtt_packedchar *chardata, int pw, int
|
||||
|
||||
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])
|
||||
{
|
||||
float q0perp = q0[1]*ray[0] - q0[0]*ray[1];
|
||||
float q1perp = q1[1]*ray[0] - q1[0]*ray[1];
|
||||
float q2perp = q2[1]*ray[0] - q2[0]*ray[1];
|
||||
float roperp = orig[1]*ray[0] - orig[0]*ray[1];
|
||||
const float q0perp = q0[1]*ray[0] - q0[0]*ray[1];
|
||||
const float q1perp = q1[1]*ray[0] - q1[0]*ray[1];
|
||||
const float q2perp = q2[1]*ray[0] - q2[0]*ray[1];
|
||||
const float roperp = orig[1]*ray[0] - orig[0]*ray[1];
|
||||
|
||||
float a = q0perp - 2*q1perp + q2perp;
|
||||
float b = q1perp - q0perp;
|
||||
float c = q0perp - roperp;
|
||||
const float a = q0perp - 2*q1perp + q2perp;
|
||||
const float b = q1perp - q0perp;
|
||||
const float c = q0perp - roperp;
|
||||
|
||||
float s0 = 0., s1 = 0.;
|
||||
int num_s = 0;
|
||||
|
||||
if (a != 0.0) {
|
||||
float discr = b*b - a*c;
|
||||
const float discr = b*b - a*c;
|
||||
if (discr > 0.0) {
|
||||
float rcpna = -1 / a;
|
||||
float d = (float) STBTT_sqrt(discr);
|
||||
const float rcpna = -1 / a;
|
||||
const float d = (float) STBTT_sqrt(discr);
|
||||
s0 = (b+d) * rcpna;
|
||||
s1 = (b-d) * rcpna;
|
||||
if (s0 >= 0.0 && s0 <= 1.0)
|
||||
@@ -4264,17 +4264,17 @@ static int stbtt__ray_intersect_bezier(float orig[2], float ray[2], float q0[2],
|
||||
if (num_s == 0)
|
||||
return 0;
|
||||
else {
|
||||
float rcp_len2 = 1 / (ray[0]*ray[0] + ray[1]*ray[1]);
|
||||
const float rcp_len2 = 1 / (ray[0]*ray[0] + ray[1]*ray[1]);
|
||||
float rayn_x = ray[0] * rcp_len2, rayn_y = ray[1] * rcp_len2;
|
||||
|
||||
float q0d = q0[0]*rayn_x + q0[1]*rayn_y;
|
||||
float q1d = q1[0]*rayn_x + q1[1]*rayn_y;
|
||||
float q2d = q2[0]*rayn_x + q2[1]*rayn_y;
|
||||
float rod = orig[0]*rayn_x + orig[1]*rayn_y;
|
||||
const float q0d = q0[0]*rayn_x + q0[1]*rayn_y;
|
||||
const float q1d = q1[0]*rayn_x + q1[1]*rayn_y;
|
||||
const float q2d = q2[0]*rayn_x + q2[1]*rayn_y;
|
||||
const float rod = orig[0]*rayn_x + orig[1]*rayn_y;
|
||||
|
||||
float q10d = q1d - q0d;
|
||||
float q20d = q2d - q0d;
|
||||
float q0rd = q0d - rod;
|
||||
const float q10d = q1d - q0d;
|
||||
const float q20d = q2d - q0d;
|
||||
const float q0rd = q0d - rod;
|
||||
|
||||
hits[0][0] = q0rd + s0*(2.0f - 2.0f*s0)*q10d + s0*s0*q20d;
|
||||
hits[0][1] = a*s0+b;
|
||||
@@ -4318,7 +4318,7 @@ static int stbtt__compute_crossings_x(float x, float y, int nverts, stbtt_vertex
|
||||
int x0 = (int) verts[i-1].x, y0 = (int) verts[i-1].y;
|
||||
int x1 = (int) verts[i ].x, y1 = (int) verts[i ].y;
|
||||
if (y > STBTT_min(y0,y1) && y < STBTT_max(y0,y1) && x > STBTT_min(x0,x1)) {
|
||||
float x_inter = (y - y0) / (y1 - y0) * (x1-x0) + x0;
|
||||
const float x_inter = (y - y0) / (y1 - y0) * (x1-x0) + x0;
|
||||
if (x_inter < x)
|
||||
winding += (y0 < y1) ? 1 : -1;
|
||||
}
|
||||
@@ -4328,7 +4328,7 @@ static int stbtt__compute_crossings_x(float x, float y, int nverts, stbtt_vertex
|
||||
int x1 = (int) verts[i ].cx, y1 = (int) verts[i ].cy;
|
||||
int x2 = (int) verts[i ].x , y2 = (int) verts[i ].y ;
|
||||
int ax = STBTT_min(x0,STBTT_min(x1,x2)), ay = STBTT_min(y0,STBTT_min(y1,y2));
|
||||
int by = STBTT_max(y0,STBTT_max(y1,y2));
|
||||
const int by = STBTT_max(y0,STBTT_max(y1,y2));
|
||||
if (y > ay && y < by && x > ax) {
|
||||
float q0[2],q1[2],q2[2];
|
||||
float hits[2][2];
|
||||
@@ -4344,12 +4344,12 @@ static int stbtt__compute_crossings_x(float x, float y, int nverts, stbtt_vertex
|
||||
x1 = (int)verts[i ].x;
|
||||
y1 = (int)verts[i ].y;
|
||||
if (y > STBTT_min(y0,y1) && y < STBTT_max(y0,y1) && x > STBTT_min(x0,x1)) {
|
||||
float x_inter = (y - y0) / (y1 - y0) * (x1-x0) + x0;
|
||||
const float x_inter = (y - y0) / (y1 - y0) * (x1-x0) + x0;
|
||||
if (x_inter < x)
|
||||
winding += (y0 < y1) ? 1 : -1;
|
||||
}
|
||||
} else {
|
||||
int num_hits = stbtt__ray_intersect_bezier(orig, ray, q0, q1, q2, hits);
|
||||
const int num_hits = stbtt__ray_intersect_bezier(orig, ray, q0, q1, q2, hits);
|
||||
if (num_hits >= 1)
|
||||
if (hits[0][0] < 0)
|
||||
winding += (hits[0][1] < 0 ? -1 : 1);
|
||||
@@ -4374,13 +4374,13 @@ static float stbtt__cuberoot( float x )
|
||||
// x^3 + c*x^2 + b*x + a = 0
|
||||
static int stbtt__solve_cubic(float a, float b, float c, float* r)
|
||||
{
|
||||
float s = -a / 3;
|
||||
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;
|
||||
const float s = -a / 3;
|
||||
const float p = b - a*a / 3;
|
||||
const float q = a * (2*a*a - 9*b) / 27 + c;
|
||||
const float p3 = p*p*p;
|
||||
const float d = q*q + 4*p3 / 27;
|
||||
if (d >= 0) {
|
||||
float z = (float) STBTT_sqrt(d);
|
||||
const float z = (float) STBTT_sqrt(d);
|
||||
float u = (-q + z) / 2;
|
||||
float v = (-q - z) / 2;
|
||||
u = stbtt__cuberoot(u);
|
||||
@@ -4388,10 +4388,10 @@ static int stbtt__solve_cubic(float a, float b, float c, float* r)
|
||||
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;
|
||||
const float u = (float) STBTT_sqrt(-p/3);
|
||||
const float v = (float) STBTT_acos(-STBTT_sqrt(-27/p3) * q / 2) / 3; // p3 must be negative, since d is negative
|
||||
const float m = (float) STBTT_cos(v);
|
||||
const 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);
|
||||
@@ -4611,7 +4611,7 @@ static stbtt_int32 stbtt__CompareUTF8toUTF16_bigendian_prefix(stbtt_uint8 *s1, s
|
||||
|
||||
// convert utf16 to utf8 and compare the results while converting
|
||||
while (len2) {
|
||||
stbtt_uint16 ch = s2[0]*256 + s2[1];
|
||||
const stbtt_uint16 ch = s2[0]*256 + s2[1];
|
||||
if (ch < 0x80) {
|
||||
if (i >= len1) return -1;
|
||||
if (s1[i++] != ch) return -1;
|
||||
@@ -4621,7 +4621,7 @@ static stbtt_int32 stbtt__CompareUTF8toUTF16_bigendian_prefix(stbtt_uint8 *s1, s
|
||||
if (s1[i++] != 0x80 + (ch & 0x3f)) return -1;
|
||||
} else if (ch >= 0xd800 && ch < 0xdc00) {
|
||||
stbtt_uint32 c;
|
||||
stbtt_uint16 ch2 = s2[2]*256 + s2[3];
|
||||
const stbtt_uint16 ch2 = s2[2]*256 + s2[3];
|
||||
if (i+3 >= len1) return -1;
|
||||
c = ((ch - 0xd800) << 10) + (ch2 - 0xdc00) + 0x10000;
|
||||
if (s1[i++] != 0xf0 + (c >> 18)) return -1;
|
||||
@@ -4655,14 +4655,14 @@ STBTT_DEF const char *stbtt_GetFontNameString(const stbtt_fontinfo *font, int *l
|
||||
{
|
||||
stbtt_int32 i,count,stringOffset;
|
||||
stbtt_uint8 *fc = font->data;
|
||||
stbtt_uint32 offset = font->fontstart;
|
||||
stbtt_uint32 nm = stbtt__find_table(fc, offset, "name");
|
||||
const stbtt_uint32 offset = font->fontstart;
|
||||
const stbtt_uint32 nm = stbtt__find_table(fc, offset, "name");
|
||||
if (!nm) return NULL;
|
||||
|
||||
count = ttUSHORT(fc+nm+2);
|
||||
stringOffset = nm + ttUSHORT(fc+nm+4);
|
||||
for (i=0; i < count; ++i) {
|
||||
stbtt_uint32 loc = nm + 6 + 12 * i;
|
||||
const stbtt_uint32 loc = nm + 6 + 12 * i;
|
||||
if (platformID == ttUSHORT(fc+loc+0) && encodingID == ttUSHORT(fc+loc+2)
|
||||
&& languageID == ttUSHORT(fc+loc+4) && nameID == ttUSHORT(fc+loc+6)) {
|
||||
*length = ttUSHORT(fc+loc+8);
|
||||
@@ -4675,12 +4675,12 @@ STBTT_DEF const char *stbtt_GetFontNameString(const stbtt_fontinfo *font, int *l
|
||||
static int stbtt__matchpair(stbtt_uint8 *fc, stbtt_uint32 nm, stbtt_uint8 *name, stbtt_int32 nlen, stbtt_int32 target_id, stbtt_int32 next_id)
|
||||
{
|
||||
stbtt_int32 i;
|
||||
stbtt_int32 count = ttUSHORT(fc+nm+2);
|
||||
stbtt_int32 stringOffset = nm + ttUSHORT(fc+nm+4);
|
||||
const stbtt_int32 count = ttUSHORT(fc+nm+2);
|
||||
const stbtt_int32 stringOffset = nm + ttUSHORT(fc+nm+4);
|
||||
|
||||
for (i=0; i < count; ++i) {
|
||||
stbtt_uint32 loc = nm + 6 + 12 * i;
|
||||
stbtt_int32 id = ttUSHORT(fc+loc+6);
|
||||
const stbtt_uint32 loc = nm + 6 + 12 * i;
|
||||
const stbtt_int32 id = ttUSHORT(fc+loc+6);
|
||||
if (id == target_id) {
|
||||
// find the encoding
|
||||
stbtt_int32 platform = ttUSHORT(fc+loc+0), encoding = ttUSHORT(fc+loc+2), language = ttUSHORT(fc+loc+4);
|
||||
@@ -4721,7 +4721,7 @@ static int stbtt__matchpair(stbtt_uint8 *fc, stbtt_uint32 nm, stbtt_uint8 *name,
|
||||
|
||||
static int stbtt__matches(stbtt_uint8 *fc, stbtt_uint32 offset, stbtt_uint8 *name, stbtt_int32 flags)
|
||||
{
|
||||
stbtt_int32 nlen = (stbtt_int32) STBTT_strlen((char *) name);
|
||||
const stbtt_int32 nlen = (stbtt_int32) STBTT_strlen((char *) name);
|
||||
stbtt_uint32 nm,hd;
|
||||
if (!stbtt__isfont(fc+offset)) return 0;
|
||||
|
||||
@@ -4752,7 +4752,7 @@ static int stbtt_FindMatchingFont_internal(unsigned char *font_collection, char
|
||||
{
|
||||
stbtt_int32 i;
|
||||
for (i=0;;++i) {
|
||||
stbtt_int32 off = stbtt_GetFontOffsetForIndex(font_collection, i);
|
||||
const stbtt_int32 off = stbtt_GetFontOffsetForIndex(font_collection, i);
|
||||
if (off < 0) return off;
|
||||
if (stbtt__matches((stbtt_uint8 *) font_collection, off, (stbtt_uint8*) name_utf8, flags))
|
||||
return off;
|
||||
|
||||
Reference in New Issue
Block a user