/***************************************************************************/ | |
/* */ | |
/* cf2hints.c */ | |
/* */ | |
/* Adobe's code for handling CFF hints (body). */ | |
/* */ | |
/* Copyright 2007-2014 Adobe Systems Incorporated. */ | |
/* */ | |
/* This software, and all works of authorship, whether in source or */ | |
/* object code form as indicated by the copyright notice(s) included */ | |
/* herein (collectively, the "Work") is made available, and may only be */ | |
/* used, modified, and distributed under the FreeType Project License, */ | |
/* LICENSE.TXT. Additionally, subject to the terms and conditions of the */ | |
/* FreeType Project License, each contributor to the Work hereby grants */ | |
/* to any individual or legal entity exercising permissions granted by */ | |
/* the FreeType Project License and this section (hereafter, "You" or */ | |
/* "Your") a perpetual, worldwide, non-exclusive, no-charge, */ | |
/* royalty-free, irrevocable (except as stated in this section) patent */ | |
/* license to make, have made, use, offer to sell, sell, import, and */ | |
/* otherwise transfer the Work, where such license applies only to those */ | |
/* patent claims licensable by such contributor that are necessarily */ | |
/* infringed by their contribution(s) alone or by combination of their */ | |
/* contribution(s) with the Work to which such contribution(s) was */ | |
/* submitted. If You institute patent litigation against any entity */ | |
/* (including a cross-claim or counterclaim in a lawsuit) alleging that */ | |
/* the Work or a contribution incorporated within the Work constitutes */ | |
/* direct or contributory patent infringement, then any patent licenses */ | |
/* granted to You under this License for that Work shall terminate as of */ | |
/* the date such litigation is filed. */ | |
/* */ | |
/* By using, modifying, or distributing the Work you indicate that you */ | |
/* have read and understood the terms and conditions of the */ | |
/* FreeType Project License as well as those provided in this section, */ | |
/* and you accept them fully. */ | |
/* */ | |
/***************************************************************************/ | |
#include "cf2ft.h" | |
#include FT_INTERNAL_DEBUG_H | |
#include "cf2glue.h" | |
#include "cf2font.h" | |
#include "cf2hints.h" | |
#include "cf2intrp.h" | |
/*************************************************************************/ | |
/* */ | |
/* The macro FT_COMPONENT is used in trace mode. It is an implicit */ | |
/* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */ | |
/* messages during execution. */ | |
/* */ | |
#undef FT_COMPONENT | |
#define FT_COMPONENT trace_cf2hints | |
typedef struct CF2_HintMoveRec_ | |
{ | |
size_t j; /* index of upper hint map edge */ | |
CF2_Fixed moveUp; /* adjustment to optimum position */ | |
} CF2_HintMoveRec, *CF2_HintMove; | |
/* Compute angular momentum for winding order detection. It is called */ | |
/* for all lines and curves, but not necessarily in element order. */ | |
static CF2_Int | |
cf2_getWindingMomentum( CF2_Fixed x1, | |
CF2_Fixed y1, | |
CF2_Fixed x2, | |
CF2_Fixed y2 ) | |
{ | |
/* cross product of pt1 position from origin with pt2 position from */ | |
/* pt1; we reduce the precision so that the result fits into 32 bits */ | |
return ( x1 >> 16 ) * ( ( y2 - y1 ) >> 16 ) - | |
( y1 >> 16 ) * ( ( x2 - x1 ) >> 16 ); | |
} | |
/* | |
* Construct from a StemHint; this is used as a parameter to | |
* `cf2_blues_capture'. | |
* `hintOrigin' is the character space displacement of a seac accent. | |
* Adjust stem hint for darkening here. | |
* | |
*/ | |
static void | |
cf2_hint_init( CF2_Hint hint, | |
const CF2_ArrStack stemHintArray, | |
size_t indexStemHint, | |
const CF2_Font font, | |
CF2_Fixed hintOrigin, | |
CF2_Fixed scale, | |
FT_Bool bottom ) | |
{ | |
CF2_Fixed width; | |
const CF2_StemHintRec* stemHint; | |
FT_ZERO( hint ); | |
stemHint = (const CF2_StemHintRec*)cf2_arrstack_getPointer( | |
stemHintArray, | |
indexStemHint ); | |
width = stemHint->max - stemHint->min; | |
if ( width == cf2_intToFixed( -21 ) ) | |
{ | |
/* ghost bottom */ | |
if ( bottom ) | |
{ | |
hint->csCoord = stemHint->max; | |
hint->flags = CF2_GhostBottom; | |
} | |
else | |
hint->flags = 0; | |
} | |
else if ( width == cf2_intToFixed( -20 ) ) | |
{ | |
/* ghost top */ | |
if ( bottom ) | |
hint->flags = 0; | |
else | |
{ | |
hint->csCoord = stemHint->min; | |
hint->flags = CF2_GhostTop; | |
} | |
} | |
else if ( width < 0 ) | |
{ | |
/* inverted pair */ | |
/* | |
* Hints with negative widths were produced by an early version of a | |
* non-Adobe font tool. The Type 2 spec allows edge (ghost) hints | |
* with negative widths, but says | |
* | |
* All other negative widths have undefined meaning. | |
* | |
* CoolType has a silent workaround that negates the hint width; for | |
* permissive mode, we do the same here. | |
* | |
* Note: Such fonts cannot use ghost hints, but should otherwise work. | |
* Note: Some poor hints in our faux fonts can produce negative | |
* widths at some blends. For example, see a light weight of | |
* `u' in ASerifMM. | |
* | |
*/ | |
if ( bottom ) | |
{ | |
hint->csCoord = stemHint->max; | |
hint->flags = CF2_PairBottom; | |
} | |
else | |
{ | |
hint->csCoord = stemHint->min; | |
hint->flags = CF2_PairTop; | |
} | |
} | |
else | |
{ | |
/* normal pair */ | |
if ( bottom ) | |
{ | |
hint->csCoord = stemHint->min; | |
hint->flags = CF2_PairBottom; | |
} | |
else | |
{ | |
hint->csCoord = stemHint->max; | |
hint->flags = CF2_PairTop; | |
} | |
} | |
/* Now that ghost hints have been detected, adjust this edge for */ | |
/* darkening. Bottoms are not changed; tops are incremented by twice */ | |
/* `darkenY'. */ | |
if ( cf2_hint_isTop( hint ) ) | |
hint->csCoord += 2 * font->darkenY; | |
hint->csCoord += hintOrigin; | |
hint->scale = scale; | |
hint->index = indexStemHint; /* index in original stem hint array */ | |
/* if original stem hint has been used, use the same position */ | |
if ( hint->flags != 0 && stemHint->used ) | |
{ | |
if ( cf2_hint_isTop( hint ) ) | |
hint->dsCoord = stemHint->maxDS; | |
else | |
hint->dsCoord = stemHint->minDS; | |
cf2_hint_lock( hint ); | |
} | |
else | |
hint->dsCoord = FT_MulFix( hint->csCoord, scale ); | |
} | |
/* initialize an invalid hint map element */ | |
static void | |
cf2_hint_initZero( CF2_Hint hint ) | |
{ | |
FT_ZERO( hint ); | |
} | |
FT_LOCAL_DEF( FT_Bool ) | |
cf2_hint_isValid( const CF2_Hint hint ) | |
{ | |
return (FT_Bool)( hint->flags != 0 ); | |
} | |
static FT_Bool | |
cf2_hint_isPair( const CF2_Hint hint ) | |
{ | |
return (FT_Bool)( ( hint->flags & | |
( CF2_PairBottom | CF2_PairTop ) ) != 0 ); | |
} | |
static FT_Bool | |
cf2_hint_isPairTop( const CF2_Hint hint ) | |
{ | |
return (FT_Bool)( ( hint->flags & CF2_PairTop ) != 0 ); | |
} | |
FT_LOCAL_DEF( FT_Bool ) | |
cf2_hint_isTop( const CF2_Hint hint ) | |
{ | |
return (FT_Bool)( ( hint->flags & | |
( CF2_PairTop | CF2_GhostTop ) ) != 0 ); | |
} | |
FT_LOCAL_DEF( FT_Bool ) | |
cf2_hint_isBottom( const CF2_Hint hint ) | |
{ | |
return (FT_Bool)( ( hint->flags & | |
( CF2_PairBottom | CF2_GhostBottom ) ) != 0 ); | |
} | |
static FT_Bool | |
cf2_hint_isLocked( const CF2_Hint hint ) | |
{ | |
return (FT_Bool)( ( hint->flags & CF2_Locked ) != 0 ); | |
} | |
static FT_Bool | |
cf2_hint_isSynthetic( const CF2_Hint hint ) | |
{ | |
return (FT_Bool)( ( hint->flags & CF2_Synthetic ) != 0 ); | |
} | |
FT_LOCAL_DEF( void ) | |
cf2_hint_lock( CF2_Hint hint ) | |
{ | |
hint->flags |= CF2_Locked; | |
} | |
FT_LOCAL_DEF( void ) | |
cf2_hintmap_init( CF2_HintMap hintmap, | |
CF2_Font font, | |
CF2_HintMap initialMap, | |
CF2_ArrStack hintMoves, | |
CF2_Fixed scale ) | |
{ | |
FT_ZERO( hintmap ); | |
/* copy parameters from font instance */ | |
hintmap->hinted = font->hinted; | |
hintmap->scale = scale; | |
hintmap->font = font; | |
hintmap->initialHintMap = initialMap; | |
/* will clear in `cf2_hintmap_adjustHints' */ | |
hintmap->hintMoves = hintMoves; | |
} | |
static FT_Bool | |
cf2_hintmap_isValid( const CF2_HintMap hintmap ) | |
{ | |
return hintmap->isValid; | |
} | |
/* transform character space coordinate to device space using hint map */ | |
static CF2_Fixed | |
cf2_hintmap_map( CF2_HintMap hintmap, | |
CF2_Fixed csCoord ) | |
{ | |
if ( hintmap->count == 0 || ! hintmap->hinted ) | |
{ | |
/* there are no hints; use uniform scale and zero offset */ | |
return FT_MulFix( csCoord, hintmap->scale ); | |
} | |
else | |
{ | |
/* start linear search from last hit */ | |
CF2_UInt i = hintmap->lastIndex; | |
FT_ASSERT( hintmap->lastIndex < CF2_MAX_HINT_EDGES ); | |
/* search up */ | |
while ( i < hintmap->count - 1 && | |
csCoord >= hintmap->edge[i + 1].csCoord ) | |
i += 1; | |
/* search down */ | |
while ( i > 0 && csCoord < hintmap->edge[i].csCoord ) | |
i -= 1; | |
hintmap->lastIndex = i; | |
if ( i == 0 && csCoord < hintmap->edge[0].csCoord ) | |
{ | |
/* special case for points below first edge: use uniform scale */ | |
return FT_MulFix( csCoord - hintmap->edge[0].csCoord, | |
hintmap->scale ) + | |
hintmap->edge[0].dsCoord; | |
} | |
else | |
{ | |
/* | |
* Note: entries with duplicate csCoord are allowed. | |
* Use edge[i], the highest entry where csCoord >= entry[i].csCoord | |
*/ | |
return FT_MulFix( csCoord - hintmap->edge[i].csCoord, | |
hintmap->edge[i].scale ) + | |
hintmap->edge[i].dsCoord; | |
} | |
} | |
} | |
/* | |
* This hinting policy moves a hint pair in device space so that one of | |
* its two edges is on a device pixel boundary (its fractional part is | |
* zero). `cf2_hintmap_insertHint' guarantees no overlap in CS | |
* space. Ensure here that there is no overlap in DS. | |
* | |
* In the first pass, edges are adjusted relative to adjacent hints. | |
* Those that are below have already been adjusted. Those that are | |
* above have not yet been adjusted. If a hint above blocks an | |
* adjustment to an optimal position, we will try again in a second | |
* pass. The second pass is top-down. | |
* | |
*/ | |
static void | |
cf2_hintmap_adjustHints( CF2_HintMap hintmap ) | |
{ | |
size_t i, j; | |
cf2_arrstack_clear( hintmap->hintMoves ); /* working storage */ | |
/* | |
* First pass is bottom-up (font hint order) without look-ahead. | |
* Locked edges are already adjusted. | |
* Unlocked edges begin with dsCoord from `initialHintMap'. | |
* Save edges that are not optimally adjusted in `hintMoves' array, | |
* and process them in second pass. | |
*/ | |
for ( i = 0; i < hintmap->count; i++ ) | |
{ | |
FT_Bool isPair = cf2_hint_isPair( &hintmap->edge[i] ); | |
/* index of upper edge (same value for ghost hint) */ | |
j = isPair ? i + 1 : i; | |
FT_ASSERT( j < hintmap->count ); | |
FT_ASSERT( cf2_hint_isValid( &hintmap->edge[i] ) ); | |
FT_ASSERT( cf2_hint_isValid( &hintmap->edge[j] ) ); | |
FT_ASSERT( cf2_hint_isLocked( &hintmap->edge[i] ) == | |
cf2_hint_isLocked( &hintmap->edge[j] ) ); | |
if ( !cf2_hint_isLocked( &hintmap->edge[i] ) ) | |
{ | |
/* hint edge is not locked, we can adjust it */ | |
CF2_Fixed fracDown = cf2_fixedFraction( hintmap->edge[i].dsCoord ); | |
CF2_Fixed fracUp = cf2_fixedFraction( hintmap->edge[j].dsCoord ); | |
/* calculate all four possibilities; moves down are negative */ | |
CF2_Fixed downMoveDown = 0 - fracDown; | |
CF2_Fixed upMoveDown = 0 - fracUp; | |
CF2_Fixed downMoveUp = fracDown == 0 | |
? 0 | |
: cf2_intToFixed( 1 ) - fracDown; | |
CF2_Fixed upMoveUp = fracUp == 0 | |
? 0 | |
: cf2_intToFixed( 1 ) - fracUp; | |
/* smallest move up */ | |
CF2_Fixed moveUp = FT_MIN( downMoveUp, upMoveUp ); | |
/* smallest move down */ | |
CF2_Fixed moveDown = FT_MAX( downMoveDown, upMoveDown ); | |
/* final amount to move edge or edge pair */ | |
CF2_Fixed move; | |
CF2_Fixed downMinCounter = CF2_MIN_COUNTER; | |
CF2_Fixed upMinCounter = CF2_MIN_COUNTER; | |
FT_Bool saveEdge = FALSE; | |
/* minimum counter constraint doesn't apply when adjacent edges */ | |
/* are synthetic */ | |
/* TODO: doesn't seem a big effect; for now, reduce the code */ | |
#if 0 | |
if ( i == 0 || | |
cf2_hint_isSynthetic( &hintmap->edge[i - 1] ) ) | |
downMinCounter = 0; | |
if ( j >= hintmap->count - 1 || | |
cf2_hint_isSynthetic( &hintmap->edge[j + 1] ) ) | |
upMinCounter = 0; | |
#endif | |
/* is there room to move up? */ | |
/* there is if we are at top of array or the next edge is at or */ | |
/* beyond proposed move up? */ | |
if ( j >= hintmap->count - 1 || | |
hintmap->edge[j + 1].dsCoord >= | |
hintmap->edge[j].dsCoord + moveUp + upMinCounter ) | |
{ | |
/* there is room to move up; is there also room to move down? */ | |
if ( i == 0 || | |
hintmap->edge[i - 1].dsCoord <= | |
hintmap->edge[i].dsCoord + moveDown - downMinCounter ) | |
{ | |
/* move smaller absolute amount */ | |
move = ( -moveDown < moveUp ) ? moveDown : moveUp; /* optimum */ | |
} | |
else | |
move = moveUp; | |
} | |
else | |
{ | |
/* is there room to move down? */ | |
if ( i == 0 || | |
hintmap->edge[i - 1].dsCoord <= | |
hintmap->edge[i].dsCoord + moveDown - downMinCounter ) | |
{ | |
move = moveDown; | |
/* true if non-optimum move */ | |
saveEdge = (FT_Bool)( moveUp < -moveDown ); | |
} | |
else | |
{ | |
/* no room to move either way without overlapping or reducing */ | |
/* the counter too much */ | |
move = 0; | |
saveEdge = TRUE; | |
} | |
} | |
/* Identify non-moves and moves down that aren't optimal, and save */ | |
/* them for second pass. */ | |
/* Do this only if there is an unlocked edge above (which could */ | |
/* possibly move). */ | |
if ( saveEdge && | |
j < hintmap->count - 1 && | |
!cf2_hint_isLocked( &hintmap->edge[j + 1] ) ) | |
{ | |
CF2_HintMoveRec savedMove; | |
savedMove.j = j; | |
/* desired adjustment in second pass */ | |
savedMove.moveUp = moveUp - move; | |
cf2_arrstack_push( hintmap->hintMoves, &savedMove ); | |
} | |
/* move the edge(s) */ | |
hintmap->edge[i].dsCoord += move; | |
if ( isPair ) | |
hintmap->edge[j].dsCoord += move; | |
} | |
/* assert there are no overlaps in device space */ | |
FT_ASSERT( i == 0 || | |
hintmap->edge[i - 1].dsCoord <= hintmap->edge[i].dsCoord ); | |
FT_ASSERT( i < j || | |
hintmap->edge[i].dsCoord <= hintmap->edge[j].dsCoord ); | |
/* adjust the scales, avoiding divide by zero */ | |
if ( i > 0 ) | |
{ | |
if ( hintmap->edge[i].csCoord != hintmap->edge[i - 1].csCoord ) | |
hintmap->edge[i - 1].scale = | |
FT_DivFix( | |
hintmap->edge[i].dsCoord - hintmap->edge[i - 1].dsCoord, | |
hintmap->edge[i].csCoord - hintmap->edge[i - 1].csCoord ); | |
} | |
if ( isPair ) | |
{ | |
if ( hintmap->edge[j].csCoord != hintmap->edge[j - 1].csCoord ) | |
hintmap->edge[j - 1].scale = | |
FT_DivFix( | |
hintmap->edge[j].dsCoord - hintmap->edge[j - 1].dsCoord, | |
hintmap->edge[j].csCoord - hintmap->edge[j - 1].csCoord ); | |
i += 1; /* skip upper edge on next loop */ | |
} | |
} | |
/* second pass tries to move non-optimal hints up, in case there is */ | |
/* room now */ | |
for ( i = cf2_arrstack_size( hintmap->hintMoves ); i > 0; i-- ) | |
{ | |
CF2_HintMove hintMove = (CF2_HintMove) | |
cf2_arrstack_getPointer( hintmap->hintMoves, i - 1 ); | |
j = hintMove->j; | |
/* this was tested before the push, above */ | |
FT_ASSERT( j < hintmap->count - 1 ); | |
/* is there room to move up? */ | |
if ( hintmap->edge[j + 1].dsCoord >= | |
hintmap->edge[j].dsCoord + hintMove->moveUp + CF2_MIN_COUNTER ) | |
{ | |
/* there is more room now, move edge up */ | |
hintmap->edge[j].dsCoord += hintMove->moveUp; | |
if ( cf2_hint_isPair( &hintmap->edge[j] ) ) | |
{ | |
FT_ASSERT( j > 0 ); | |
hintmap->edge[j - 1].dsCoord += hintMove->moveUp; | |
} | |
} | |
} | |
} | |
/* insert hint edges into map, sorted by csCoord */ | |
static void | |
cf2_hintmap_insertHint( CF2_HintMap hintmap, | |
CF2_Hint bottomHintEdge, | |
CF2_Hint topHintEdge ) | |
{ | |
CF2_UInt indexInsert; | |
/* set default values, then check for edge hints */ | |
FT_Bool isPair = TRUE; | |
CF2_Hint firstHintEdge = bottomHintEdge; | |
CF2_Hint secondHintEdge = topHintEdge; | |
/* one or none of the input params may be invalid when dealing with */ | |
/* edge hints; at least one edge must be valid */ | |
FT_ASSERT( cf2_hint_isValid( bottomHintEdge ) || | |
cf2_hint_isValid( topHintEdge ) ); | |
/* determine how many and which edges to insert */ | |
if ( !cf2_hint_isValid( bottomHintEdge ) ) | |
{ | |
/* insert only the top edge */ | |
firstHintEdge = topHintEdge; | |
isPair = FALSE; | |
} | |
else if ( !cf2_hint_isValid( topHintEdge ) ) | |
{ | |
/* insert only the bottom edge */ | |
isPair = FALSE; | |
} | |
/* paired edges must be in proper order */ | |
if ( isPair && | |
topHintEdge->csCoord < bottomHintEdge->csCoord ) | |
return; | |
/* linear search to find index value of insertion point */ | |
indexInsert = 0; | |
for ( ; indexInsert < hintmap->count; indexInsert++ ) | |
{ | |
if ( hintmap->edge[indexInsert].csCoord >= firstHintEdge->csCoord ) | |
break; | |
} | |
/* | |
* Discard any hints that overlap in character space. Most often, this | |
* is while building the initial map, where captured hints from all | |
* zones are combined. Define overlap to include hints that `touch' | |
* (overlap zero). Hiragino Sans/Gothic fonts have numerous hints that | |
* touch. Some fonts have non-ideographic glyphs that overlap our | |
* synthetic hints. | |
* | |
* Overlap also occurs when darkening stem hints that are close. | |
* | |
*/ | |
if ( indexInsert < hintmap->count ) | |
{ | |
/* we are inserting before an existing edge: */ | |
/* verify that an existing edge is not the same */ | |
if ( hintmap->edge[indexInsert].csCoord == firstHintEdge->csCoord ) | |
return; /* ignore overlapping stem hint */ | |
/* verify that a new pair does not straddle the next edge */ | |
if ( isPair && | |
hintmap->edge[indexInsert].csCoord <= secondHintEdge->csCoord ) | |
return; /* ignore overlapping stem hint */ | |
/* verify that we are not inserting between paired edges */ | |
if ( cf2_hint_isPairTop( &hintmap->edge[indexInsert] ) ) | |
return; /* ignore overlapping stem hint */ | |
} | |
/* recompute device space locations using initial hint map */ | |
if ( cf2_hintmap_isValid( hintmap->initialHintMap ) && | |
!cf2_hint_isLocked( firstHintEdge ) ) | |
{ | |
if ( isPair ) | |
{ | |
/* Use hint map to position the center of stem, and nominal scale */ | |
/* to position the two edges. This preserves the stem width. */ | |
CF2_Fixed midpoint = cf2_hintmap_map( | |
hintmap->initialHintMap, | |
( secondHintEdge->csCoord + | |
firstHintEdge->csCoord ) / 2 ); | |
CF2_Fixed halfWidth = FT_MulFix( | |
( secondHintEdge->csCoord - | |
firstHintEdge->csCoord ) / 2, | |
hintmap->scale ); | |
firstHintEdge->dsCoord = midpoint - halfWidth; | |
secondHintEdge->dsCoord = midpoint + halfWidth; | |
} | |
else | |
firstHintEdge->dsCoord = cf2_hintmap_map( hintmap->initialHintMap, | |
firstHintEdge->csCoord ); | |
} | |
/* | |
* Discard any hints that overlap in device space; this can occur | |
* because locked hints have been moved to align with blue zones. | |
* | |
* TODO: Although we might correct this later during adjustment, we | |
* don't currently have a way to delete a conflicting hint once it has | |
* been inserted. See v2.030 MinionPro-Regular, 12 ppem darkened, | |
* initial hint map for second path, glyph 945 (the perispomeni (tilde) | |
* in U+1F6E, Greek omega with psili and perispomeni). Darkening is | |
* 25. Pair 667,747 initially conflicts in design space with top edge | |
* 660. This is because 667 maps to 7.87, and the top edge was | |
* captured by a zone at 8.0. The pair is later successfully inserted | |
* in a zone without the top edge. In this zone it is adjusted to 8.0, | |
* and no longer conflicts with the top edge in design space. This | |
* means it can be included in yet a later zone which does have the top | |
* edge hint. This produces a small mismatch between the first and | |
* last points of this path, even though the hint masks are the same. | |
* The density map difference is tiny (1/256). | |
* | |
*/ | |
if ( indexInsert > 0 ) | |
{ | |
/* we are inserting after an existing edge */ | |
if ( firstHintEdge->dsCoord < hintmap->edge[indexInsert - 1].dsCoord ) | |
return; | |
} | |
if ( indexInsert < hintmap->count ) | |
{ | |
/* we are inserting before an existing edge */ | |
if ( isPair ) | |
{ | |
if ( secondHintEdge->dsCoord > hintmap->edge[indexInsert].dsCoord ) | |
return; | |
} | |
else | |
{ | |
if ( firstHintEdge->dsCoord > hintmap->edge[indexInsert].dsCoord ) | |
return; | |
} | |
} | |
/* make room to insert */ | |
{ | |
CF2_UInt iSrc = hintmap->count - 1; | |
CF2_UInt iDst = isPair ? hintmap->count + 1 : hintmap->count; | |
CF2_UInt count = hintmap->count - indexInsert; | |
if ( iDst >= CF2_MAX_HINT_EDGES ) | |
{ | |
FT_TRACE4(( "cf2_hintmap_insertHint: too many hintmaps\n" )); | |
return; | |
} | |
while ( count-- ) | |
hintmap->edge[iDst--] = hintmap->edge[iSrc--]; | |
/* insert first edge */ | |
hintmap->edge[indexInsert] = *firstHintEdge; /* copy struct */ | |
hintmap->count += 1; | |
if ( isPair ) | |
{ | |
/* insert second edge */ | |
hintmap->edge[indexInsert + 1] = *secondHintEdge; /* copy struct */ | |
hintmap->count += 1; | |
} | |
} | |
return; | |
} | |
/* | |
* Build a map from hints and mask. | |
* | |
* This function may recur one level if `hintmap->initialHintMap' is not yet | |
* valid. | |
* If `initialMap' is true, simply build initial map. | |
* | |
* Synthetic hints are used in two ways. A hint at zero is inserted, if | |
* needed, in the initial hint map, to prevent translations from | |
* propagating across the origin. If synthetic em box hints are enabled | |
* for ideographic dictionaries, then they are inserted in all hint | |
* maps, including the initial one. | |
* | |
*/ | |
FT_LOCAL_DEF( void ) | |
cf2_hintmap_build( CF2_HintMap hintmap, | |
CF2_ArrStack hStemHintArray, | |
CF2_ArrStack vStemHintArray, | |
CF2_HintMask hintMask, | |
CF2_Fixed hintOrigin, | |
FT_Bool initialMap ) | |
{ | |
FT_Byte* maskPtr; | |
CF2_Font font = hintmap->font; | |
CF2_HintMaskRec tempHintMask; | |
size_t bitCount, i; | |
FT_Byte maskByte; | |
/* check whether initial map is constructed */ | |
if ( !initialMap && !cf2_hintmap_isValid( hintmap->initialHintMap ) ) | |
{ | |
/* make recursive call with initialHintMap and temporary mask; */ | |
/* temporary mask will get all bits set, below */ | |
cf2_hintmask_init( &tempHintMask, hintMask->error ); | |
cf2_hintmap_build( hintmap->initialHintMap, | |
hStemHintArray, | |
vStemHintArray, | |
&tempHintMask, | |
hintOrigin, | |
TRUE ); | |
} | |
if ( !cf2_hintmask_isValid( hintMask ) ) | |
{ | |
/* without a hint mask, assume all hints are active */ | |
cf2_hintmask_setAll( hintMask, | |
cf2_arrstack_size( hStemHintArray ) + | |
cf2_arrstack_size( vStemHintArray ) ); | |
if ( !cf2_hintmask_isValid( hintMask ) ) | |
return; /* too many stem hints */ | |
} | |
/* begin by clearing the map */ | |
hintmap->count = 0; | |
hintmap->lastIndex = 0; | |
/* make a copy of the hint mask so we can modify it */ | |
tempHintMask = *hintMask; | |
maskPtr = cf2_hintmask_getMaskPtr( &tempHintMask ); | |
/* use the hStem hints only, which are first in the mask */ | |
bitCount = cf2_arrstack_size( hStemHintArray ); | |
/* Defense-in-depth. Should never return here. */ | |
if ( bitCount > hintMask->bitCount ) | |
return; | |
/* synthetic embox hints get highest priority */ | |
if ( font->blues.doEmBoxHints ) | |
{ | |
CF2_HintRec dummy; | |
cf2_hint_initZero( &dummy ); /* invalid hint map element */ | |
/* ghost bottom */ | |
cf2_hintmap_insertHint( hintmap, | |
&font->blues.emBoxBottomEdge, | |
&dummy ); | |
/* ghost top */ | |
cf2_hintmap_insertHint( hintmap, | |
&dummy, | |
&font->blues.emBoxTopEdge ); | |
} | |
/* insert hints captured by a blue zone or already locked (higher */ | |
/* priority) */ | |
for ( i = 0, maskByte = 0x80; i < bitCount; i++ ) | |
{ | |
if ( maskByte & *maskPtr ) | |
{ | |
/* expand StemHint into two `CF2_Hint' elements */ | |
CF2_HintRec bottomHintEdge, topHintEdge; | |
cf2_hint_init( &bottomHintEdge, | |
hStemHintArray, | |
i, | |
font, | |
hintOrigin, | |
hintmap->scale, | |
TRUE /* bottom */ ); | |
cf2_hint_init( &topHintEdge, | |
hStemHintArray, | |
i, | |
font, | |
hintOrigin, | |
hintmap->scale, | |
FALSE /* top */ ); | |
if ( cf2_hint_isLocked( &bottomHintEdge ) || | |
cf2_hint_isLocked( &topHintEdge ) || | |
cf2_blues_capture( &font->blues, | |
&bottomHintEdge, | |
&topHintEdge ) ) | |
{ | |
/* insert captured hint into map */ | |
cf2_hintmap_insertHint( hintmap, &bottomHintEdge, &topHintEdge ); | |
*maskPtr &= ~maskByte; /* turn off the bit for this hint */ | |
} | |
} | |
if ( ( i & 7 ) == 7 ) | |
{ | |
/* move to next mask byte */ | |
maskPtr++; | |
maskByte = 0x80; | |
} | |
else | |
maskByte >>= 1; | |
} | |
/* initial hint map includes only captured hints plus maybe one at 0 */ | |
/* | |
* TODO: There is a problem here because we are trying to build a | |
* single hint map containing all captured hints. It is | |
* possible for there to be conflicts between captured hints, | |
* either because of darkening or because the hints are in | |
* separate hint zones (we are ignoring hint zones for the | |
* initial map). An example of the latter is MinionPro-Regular | |
* v2.030 glyph 883 (Greek Capital Alpha with Psili) at 15ppem. | |
* A stem hint for the psili conflicts with the top edge hint | |
* for the base character. The stem hint gets priority because | |
* of its sort order. In glyph 884 (Greek Capital Alpha with | |
* Psili and Oxia), the top of the base character gets a stem | |
* hint, and the psili does not. This creates different initial | |
* maps for the two glyphs resulting in different renderings of | |
* the base character. Will probably defer this either as not | |
* worth the cost or as a font bug. I don't think there is any | |
* good reason for an accent to be captured by an alignment | |
* zone. -darnold 2/12/10 | |
*/ | |
if ( initialMap ) | |
{ | |
/* Apply a heuristic that inserts a point for (0,0), unless it's */ | |
/* already covered by a mapping. This locks the baseline for glyphs */ | |
/* that have no baseline hints. */ | |
if ( hintmap->count == 0 || | |
hintmap->edge[0].csCoord > 0 || | |
hintmap->edge[hintmap->count - 1].csCoord < 0 ) | |
{ | |
/* all edges are above 0 or all edges are below 0; */ | |
/* construct a locked edge hint at 0 */ | |
CF2_HintRec edge, invalid; | |
cf2_hint_initZero( &edge ); | |
edge.flags = CF2_GhostBottom | | |
CF2_Locked | | |
CF2_Synthetic; | |
edge.scale = hintmap->scale; | |
cf2_hint_initZero( &invalid ); | |
cf2_hintmap_insertHint( hintmap, &edge, &invalid ); | |
} | |
} | |
else | |
{ | |
/* insert remaining hints */ | |
maskPtr = cf2_hintmask_getMaskPtr( &tempHintMask ); | |
for ( i = 0, maskByte = 0x80; i < bitCount; i++ ) | |
{ | |
if ( maskByte & *maskPtr ) | |
{ | |
CF2_HintRec bottomHintEdge, topHintEdge; | |
cf2_hint_init( &bottomHintEdge, | |
hStemHintArray, | |
i, | |
font, | |
hintOrigin, | |
hintmap->scale, | |
TRUE /* bottom */ ); | |
cf2_hint_init( &topHintEdge, | |
hStemHintArray, | |
i, | |
font, | |
hintOrigin, | |
hintmap->scale, | |
FALSE /* top */ ); | |
cf2_hintmap_insertHint( hintmap, &bottomHintEdge, &topHintEdge ); | |
} | |
if ( ( i & 7 ) == 7 ) | |
{ | |
/* move to next mask byte */ | |
maskPtr++; | |
maskByte = 0x80; | |
} | |
else | |
maskByte >>= 1; | |
} | |
} | |
/* | |
* Note: The following line is a convenient place to break when | |
* debugging hinting. Examine `hintmap->edge' for the list of | |
* enabled hints, then step over the call to see the effect of | |
* adjustment. We stop here first on the recursive call that | |
* creates the initial map, and then on each counter group and | |
* hint zone. | |
*/ | |
/* adjust positions of hint edges that are not locked to blue zones */ | |
cf2_hintmap_adjustHints( hintmap ); | |
/* save the position of all hints that were used in this hint map; */ | |
/* if we use them again, we'll locate them in the same position */ | |
if ( !initialMap ) | |
{ | |
for ( i = 0; i < hintmap->count; i++ ) | |
{ | |
if ( !cf2_hint_isSynthetic( &hintmap->edge[i] ) ) | |
{ | |
/* Note: include both valid and invalid edges */ | |
/* Note: top and bottom edges are copied back separately */ | |
CF2_StemHint stemhint = (CF2_StemHint) | |
cf2_arrstack_getPointer( hStemHintArray, | |
hintmap->edge[i].index ); | |
if ( cf2_hint_isTop( &hintmap->edge[i] ) ) | |
stemhint->maxDS = hintmap->edge[i].dsCoord; | |
else | |
stemhint->minDS = hintmap->edge[i].dsCoord; | |
stemhint->used = TRUE; | |
} | |
} | |
} | |
/* hint map is ready to use */ | |
hintmap->isValid = TRUE; | |
/* remember this mask has been used */ | |
cf2_hintmask_setNew( hintMask, FALSE ); | |
} | |
FT_LOCAL_DEF( void ) | |
cf2_glyphpath_init( CF2_GlyphPath glyphpath, | |
CF2_Font font, | |
CF2_OutlineCallbacks callbacks, | |
CF2_Fixed scaleY, | |
/* CF2_Fixed hShift, */ | |
CF2_ArrStack hStemHintArray, | |
CF2_ArrStack vStemHintArray, | |
CF2_HintMask hintMask, | |
CF2_Fixed hintOriginY, | |
const CF2_Blues blues, | |
const FT_Vector* fractionalTranslation ) | |
{ | |
FT_ZERO( glyphpath ); | |
glyphpath->font = font; | |
glyphpath->callbacks = callbacks; | |
cf2_arrstack_init( &glyphpath->hintMoves, | |
font->memory, | |
&font->error, | |
sizeof ( CF2_HintMoveRec ) ); | |
cf2_hintmap_init( &glyphpath->initialHintMap, | |
font, | |
&glyphpath->initialHintMap, | |
&glyphpath->hintMoves, | |
scaleY ); | |
cf2_hintmap_init( &glyphpath->firstHintMap, | |
font, | |
&glyphpath->initialHintMap, | |
&glyphpath->hintMoves, | |
scaleY ); | |
cf2_hintmap_init( &glyphpath->hintMap, | |
font, | |
&glyphpath->initialHintMap, | |
&glyphpath->hintMoves, | |
scaleY ); | |
glyphpath->scaleX = font->innerTransform.a; | |
glyphpath->scaleC = font->innerTransform.c; | |
glyphpath->scaleY = font->innerTransform.d; | |
glyphpath->fractionalTranslation = *fractionalTranslation; | |
#if 0 | |
glyphpath->hShift = hShift; /* for fauxing */ | |
#endif | |
glyphpath->hStemHintArray = hStemHintArray; | |
glyphpath->vStemHintArray = vStemHintArray; | |
glyphpath->hintMask = hintMask; /* ptr to current mask */ | |
glyphpath->hintOriginY = hintOriginY; | |
glyphpath->blues = blues; | |
glyphpath->darken = font->darkened; /* TODO: should we make copies? */ | |
glyphpath->xOffset = font->darkenX; | |
glyphpath->yOffset = font->darkenY; | |
glyphpath->miterLimit = 2 * FT_MAX( | |
cf2_fixedAbs( glyphpath->xOffset ), | |
cf2_fixedAbs( glyphpath->yOffset ) ); | |
/* .1 character space unit */ | |
glyphpath->snapThreshold = cf2_floatToFixed( 0.1f ); | |
glyphpath->moveIsPending = TRUE; | |
glyphpath->pathIsOpen = FALSE; | |
glyphpath->pathIsClosing = FALSE; | |
glyphpath->elemIsQueued = FALSE; | |
} | |
FT_LOCAL_DEF( void ) | |
cf2_glyphpath_finalize( CF2_GlyphPath glyphpath ) | |
{ | |
cf2_arrstack_finalize( &glyphpath->hintMoves ); | |
} | |
/* | |
* Hint point in y-direction and apply outerTransform. | |
* Input `current' hint map (which is actually delayed by one element). | |
* Input x,y point in Character Space. | |
* Output x,y point in Device Space, including translation. | |
*/ | |
static void | |
cf2_glyphpath_hintPoint( CF2_GlyphPath glyphpath, | |
CF2_HintMap hintmap, | |
FT_Vector* ppt, | |
CF2_Fixed x, | |
CF2_Fixed y ) | |
{ | |
FT_Vector pt; /* hinted point in upright DS */ | |
pt.x = FT_MulFix( glyphpath->scaleX, x ) + | |
FT_MulFix( glyphpath->scaleC, y ); | |
pt.y = cf2_hintmap_map( hintmap, y ); | |
ppt->x = FT_MulFix( glyphpath->font->outerTransform.a, pt.x ) + | |
FT_MulFix( glyphpath->font->outerTransform.c, pt.y ) + | |
glyphpath->fractionalTranslation.x; | |
ppt->y = FT_MulFix( glyphpath->font->outerTransform.b, pt.x ) + | |
FT_MulFix( glyphpath->font->outerTransform.d, pt.y ) + | |
glyphpath->fractionalTranslation.y; | |
} | |
/* | |
* From two line segments, (u1,u2) and (v1,v2), compute a point of | |
* intersection on the corresponding lines. | |
* Return false if no intersection is found, or if the intersection is | |
* too far away from the ends of the line segments, u2 and v1. | |
* | |
*/ | |
static FT_Bool | |
cf2_glyphpath_computeIntersection( CF2_GlyphPath glyphpath, | |
const FT_Vector* u1, | |
const FT_Vector* u2, | |
const FT_Vector* v1, | |
const FT_Vector* v2, | |
FT_Vector* intersection ) | |
{ | |
/* | |
* Let `u' be a zero-based vector from the first segment, `v' from the | |
* second segment. | |
* Let `w 'be the zero-based vector from `u1' to `v1'. | |
* `perp' is the `perpendicular dot product'; see | |
* http://mathworld.wolfram.com/PerpDotProduct.html. | |
* `s' is the parameter for the parametric line for the first segment | |
* (`u'). | |
* | |
* See notation in | |
* http://softsurfer.com/Archive/algorithm_0104/algorithm_0104B.htm. | |
* Calculations are done in 16.16, but must handle the squaring of | |
* line lengths in character space. We scale all vectors by 1/32 to | |
* avoid overflow. This allows values up to 4095 to be squared. The | |
* scale factor cancels in the divide. | |
* | |
* TODO: the scale factor could be computed from UnitsPerEm. | |
* | |
*/ | |
#define cf2_perp( a, b ) \ | |
( FT_MulFix( a.x, b.y ) - FT_MulFix( a.y, b.x ) ) | |
/* round and divide by 32 */ | |
#define CF2_CS_SCALE( x ) \ | |
( ( (x) + 0x10 ) >> 5 ) | |
FT_Vector u, v, w; /* scaled vectors */ | |
CF2_Fixed denominator, s; | |
u.x = CF2_CS_SCALE( u2->x - u1->x ); | |
u.y = CF2_CS_SCALE( u2->y - u1->y ); | |
v.x = CF2_CS_SCALE( v2->x - v1->x ); | |
v.y = CF2_CS_SCALE( v2->y - v1->y ); | |
w.x = CF2_CS_SCALE( v1->x - u1->x ); | |
w.y = CF2_CS_SCALE( v1->y - u1->y ); | |
denominator = cf2_perp( u, v ); | |
if ( denominator == 0 ) | |
return FALSE; /* parallel or coincident lines */ | |
s = FT_DivFix( cf2_perp( w, v ), denominator ); | |
intersection->x = u1->x + FT_MulFix( s, u2->x - u1->x ); | |
intersection->y = u1->y + FT_MulFix( s, u2->y - u1->y ); | |
/* | |
* Special case snapping for horizontal and vertical lines. | |
* This cleans up intersections and reduces problems with winding | |
* order detection. | |
* Sample case is sbc cd KozGoPr6N-Medium.otf 20 16685. | |
* Note: these calculations are in character space. | |
* | |
*/ | |
if ( u1->x == u2->x && | |
cf2_fixedAbs( intersection->x - u1->x ) < glyphpath->snapThreshold ) | |
intersection->x = u1->x; | |
if ( u1->y == u2->y && | |
cf2_fixedAbs( intersection->y - u1->y ) < glyphpath->snapThreshold ) | |
intersection->y = u1->y; | |
if ( v1->x == v2->x && | |
cf2_fixedAbs( intersection->x - v1->x ) < glyphpath->snapThreshold ) | |
intersection->x = v1->x; | |
if ( v1->y == v2->y && | |
cf2_fixedAbs( intersection->y - v1->y ) < glyphpath->snapThreshold ) | |
intersection->y = v1->y; | |
/* limit the intersection distance from midpoint of u2 and v1 */ | |
if ( cf2_fixedAbs( intersection->x - ( u2->x + v1->x ) / 2 ) > | |
glyphpath->miterLimit || | |
cf2_fixedAbs( intersection->y - ( u2->y + v1->y ) / 2 ) > | |
glyphpath->miterLimit ) | |
return FALSE; | |
return TRUE; | |
} | |
/* | |
* Push the cached element (glyphpath->prevElem*) to the outline | |
* consumer. When a darkening offset is used, the end point of the | |
* cached element may be adjusted to an intersection point or we may | |
* synthesize a connecting line to the current element. If we are | |
* closing a subpath, we may also generate a connecting line to the start | |
* point. | |
* | |
* This is where Character Space (CS) is converted to Device Space (DS) | |
* using a hint map. This calculation must use a HintMap that was valid | |
* at the time the element was saved. For the first point in a subpath, | |
* that is a saved HintMap. For most elements, it just means the caller | |
* has delayed building a HintMap from the current HintMask. | |
* | |
* Transform each point with outerTransform and call the outline | |
* callbacks. This is a general 3x3 transform: | |
* | |
* x' = a*x + c*y + tx, y' = b*x + d*y + ty | |
* | |
* but it uses 4 elements from CF2_Font and the translation part | |
* from CF2_GlyphPath. | |
* | |
*/ | |
static void | |
cf2_glyphpath_pushPrevElem( CF2_GlyphPath glyphpath, | |
CF2_HintMap hintmap, | |
FT_Vector* nextP0, | |
FT_Vector nextP1, | |
FT_Bool close ) | |
{ | |
CF2_CallbackParamsRec params; | |
FT_Vector* prevP0; | |
FT_Vector* prevP1; | |
FT_Vector intersection = { 0, 0 }; | |
FT_Bool useIntersection = FALSE; | |
FT_ASSERT( glyphpath->prevElemOp == CF2_PathOpLineTo || | |
glyphpath->prevElemOp == CF2_PathOpCubeTo ); | |
if ( glyphpath->prevElemOp == CF2_PathOpLineTo ) | |
{ | |
prevP0 = &glyphpath->prevElemP0; | |
prevP1 = &glyphpath->prevElemP1; | |
} | |
else | |
{ | |
prevP0 = &glyphpath->prevElemP2; | |
prevP1 = &glyphpath->prevElemP3; | |
} | |
/* optimization: if previous and next elements are offset by the same */ | |
/* amount, then there will be no gap, and no need to compute an */ | |
/* intersection. */ | |
if ( prevP1->x != nextP0->x || prevP1->y != nextP0->y ) | |
{ | |
/* previous element does not join next element: */ | |
/* adjust end point of previous element to the intersection */ | |
useIntersection = cf2_glyphpath_computeIntersection( glyphpath, | |
prevP0, | |
prevP1, | |
nextP0, | |
&nextP1, | |
&intersection ); | |
if ( useIntersection ) | |
{ | |
/* modify the last point of the cached element (either line or */ | |
/* curve) */ | |
*prevP1 = intersection; | |
} | |
} | |
params.pt0 = glyphpath->currentDS; | |
switch( glyphpath->prevElemOp ) | |
{ | |
case CF2_PathOpLineTo: | |
params.op = CF2_PathOpLineTo; | |
/* note: pt2 and pt3 are unused */ | |
if ( close ) | |
{ | |
/* use first hint map if closing */ | |
cf2_glyphpath_hintPoint( glyphpath, | |
&glyphpath->firstHintMap, | |
¶ms.pt1, | |
glyphpath->prevElemP1.x, | |
glyphpath->prevElemP1.y ); | |
} | |
else | |
{ | |
cf2_glyphpath_hintPoint( glyphpath, | |
hintmap, | |
¶ms.pt1, | |
glyphpath->prevElemP1.x, | |
glyphpath->prevElemP1.y ); | |
} | |
/* output only non-zero length lines */ | |
if ( params.pt0.x != params.pt1.x || params.pt0.y != params.pt1.y ) | |
{ | |
glyphpath->callbacks->lineTo( glyphpath->callbacks, ¶ms ); | |
glyphpath->currentDS = params.pt1; | |
} | |
break; | |
case CF2_PathOpCubeTo: | |
params.op = CF2_PathOpCubeTo; | |
/* TODO: should we intersect the interior joins (p1-p2 and p2-p3)? */ | |
cf2_glyphpath_hintPoint( glyphpath, | |
hintmap, | |
¶ms.pt1, | |
glyphpath->prevElemP1.x, | |
glyphpath->prevElemP1.y ); | |
cf2_glyphpath_hintPoint( glyphpath, | |
hintmap, | |
¶ms.pt2, | |
glyphpath->prevElemP2.x, | |
glyphpath->prevElemP2.y ); | |
cf2_glyphpath_hintPoint( glyphpath, | |
hintmap, | |
¶ms.pt3, | |
glyphpath->prevElemP3.x, | |
glyphpath->prevElemP3.y ); | |
glyphpath->callbacks->cubeTo( glyphpath->callbacks, ¶ms ); | |
glyphpath->currentDS = params.pt3; | |
break; | |
} | |
if ( !useIntersection || close ) | |
{ | |
/* insert connecting line between end of previous element and start */ | |
/* of current one */ | |
/* note: at the end of a subpath, we might do both, so use `nextP0' */ | |
/* before we change it, below */ | |
if ( close ) | |
{ | |
/* if we are closing the subpath, then nextP0 is in the first */ | |
/* hint zone */ | |
cf2_glyphpath_hintPoint( glyphpath, | |
&glyphpath->firstHintMap, | |
¶ms.pt1, | |
nextP0->x, | |
nextP0->y ); | |
} | |
else | |
{ | |
cf2_glyphpath_hintPoint( glyphpath, | |
hintmap, | |
¶ms.pt1, | |
nextP0->x, | |
nextP0->y ); | |
} | |
if ( params.pt1.x != glyphpath->currentDS.x || | |
params.pt1.y != glyphpath->currentDS.y ) | |
{ | |
/* length is nonzero */ | |
params.op = CF2_PathOpLineTo; | |
params.pt0 = glyphpath->currentDS; | |
/* note: pt2 and pt3 are unused */ | |
glyphpath->callbacks->lineTo( glyphpath->callbacks, ¶ms ); | |
glyphpath->currentDS = params.pt1; | |
} | |
} | |
if ( useIntersection ) | |
{ | |
/* return intersection point to caller */ | |
*nextP0 = intersection; | |
} | |
} | |
/* push a MoveTo element based on current point and offset of current */ | |
/* element */ | |
static void | |
cf2_glyphpath_pushMove( CF2_GlyphPath glyphpath, | |
FT_Vector start ) | |
{ | |
CF2_CallbackParamsRec params; | |
params.op = CF2_PathOpMoveTo; | |
params.pt0 = glyphpath->currentDS; | |
/* Test if move has really happened yet; it would have called */ | |
/* `cf2_hintmap_build' to set `isValid'. */ | |
if ( !cf2_hintmap_isValid( &glyphpath->hintMap ) ) | |
{ | |
/* we are here iff first subpath is missing a moveto operator: */ | |
/* synthesize first moveTo to finish initialization of hintMap */ | |
cf2_glyphpath_moveTo( glyphpath, | |
glyphpath->start.x, | |
glyphpath->start.y ); | |
} | |
cf2_glyphpath_hintPoint( glyphpath, | |
&glyphpath->hintMap, | |
¶ms.pt1, | |
start.x, | |
start.y ); | |
/* note: pt2 and pt3 are unused */ | |
glyphpath->callbacks->moveTo( glyphpath->callbacks, ¶ms ); | |
glyphpath->currentDS = params.pt1; | |
glyphpath->offsetStart0 = start; | |
} | |
/* | |
* All coordinates are in character space. | |
* On input, (x1, y1) and (x2, y2) give line segment. | |
* On output, (x, y) give offset vector. | |
* We use a piecewise approximation to trig functions. | |
* | |
* TODO: Offset true perpendicular and proper length | |
* supply the y-translation for hinting here, too, | |
* that adds yOffset unconditionally to *y. | |
*/ | |
static void | |
cf2_glyphpath_computeOffset( CF2_GlyphPath glyphpath, | |
CF2_Fixed x1, | |
CF2_Fixed y1, | |
CF2_Fixed x2, | |
CF2_Fixed y2, | |
CF2_Fixed* x, | |
CF2_Fixed* y ) | |
{ | |
CF2_Fixed dx = x2 - x1; | |
CF2_Fixed dy = y2 - y1; | |
/* note: negative offsets don't work here; negate deltas to change */ | |
/* quadrants, below */ | |
if ( glyphpath->font->reverseWinding ) | |
{ | |
dx = -dx; | |
dy = -dy; | |
} | |
*x = *y = 0; | |
if ( !glyphpath->darken ) | |
return; | |
/* add momentum for this path element */ | |
glyphpath->callbacks->windingMomentum += | |
cf2_getWindingMomentum( x1, y1, x2, y2 ); | |
/* note: allow mixed integer and fixed multiplication here */ | |
if ( dx >= 0 ) | |
{ | |
if ( dy >= 0 ) | |
{ | |
/* first quadrant, +x +y */ | |
if ( dx > 2 * dy ) | |
{ | |
/* +x */ | |
*x = 0; | |
*y = 0; | |
} | |
else if ( dy > 2 * dx ) | |
{ | |
/* +y */ | |
*x = glyphpath->xOffset; | |
*y = glyphpath->yOffset; | |
} | |
else | |
{ | |
/* +x +y */ | |
*x = FT_MulFix( cf2_floatToFixed( 0.7 ), | |
glyphpath->xOffset ); | |
*y = FT_MulFix( cf2_floatToFixed( 1.0 - 0.7 ), | |
glyphpath->yOffset ); | |
} | |
} | |
else | |
{ | |
/* fourth quadrant, +x -y */ | |
if ( dx > -2 * dy ) | |
{ | |
/* +x */ | |
*x = 0; | |
*y = 0; | |
} | |
else if ( -dy > 2 * dx ) | |
{ | |
/* -y */ | |
*x = -glyphpath->xOffset; | |
*y = glyphpath->yOffset; | |
} | |
else | |
{ | |
/* +x -y */ | |
*x = FT_MulFix( cf2_floatToFixed( -0.7 ), | |
glyphpath->xOffset ); | |
*y = FT_MulFix( cf2_floatToFixed( 1.0 - 0.7 ), | |
glyphpath->yOffset ); | |
} | |
} | |
} | |
else | |
{ | |
if ( dy >= 0 ) | |
{ | |
/* second quadrant, -x +y */ | |
if ( -dx > 2 * dy ) | |
{ | |
/* -x */ | |
*x = 0; | |
*y = 2 * glyphpath->yOffset; | |
} | |
else if ( dy > -2 * dx ) | |
{ | |
/* +y */ | |
*x = glyphpath->xOffset; | |
*y = glyphpath->yOffset; | |
} | |
else | |
{ | |
/* -x +y */ | |
*x = FT_MulFix( cf2_floatToFixed( 0.7 ), | |
glyphpath->xOffset ); | |
*y = FT_MulFix( cf2_floatToFixed( 1.0 + 0.7 ), | |
glyphpath->yOffset ); | |
} | |
} | |
else | |
{ | |
/* third quadrant, -x -y */ | |
if ( -dx > -2 * dy ) | |
{ | |
/* -x */ | |
*x = 0; | |
*y = 2 * glyphpath->yOffset; | |
} | |
else if ( -dy > -2 * dx ) | |
{ | |
/* -y */ | |
*x = -glyphpath->xOffset; | |
*y = glyphpath->yOffset; | |
} | |
else | |
{ | |
/* -x -y */ | |
*x = FT_MulFix( cf2_floatToFixed( -0.7 ), | |
glyphpath->xOffset ); | |
*y = FT_MulFix( cf2_floatToFixed( 1.0 + 0.7 ), | |
glyphpath->yOffset ); | |
} | |
} | |
} | |
} | |
/* | |
* The functions cf2_glyphpath_{moveTo,lineTo,curveTo,closeOpenPath} are | |
* called by the interpreter with Character Space (CS) coordinates. Each | |
* path element is placed into a queue of length one to await the | |
* calculation of the following element. At that time, the darkening | |
* offset of the following element is known and joins can be computed, | |
* including possible modification of this element, before mapping to | |
* Device Space (DS) and passing it on to the outline consumer. | |
* | |
*/ | |
FT_LOCAL_DEF( void ) | |
cf2_glyphpath_moveTo( CF2_GlyphPath glyphpath, | |
CF2_Fixed x, | |
CF2_Fixed y ) | |
{ | |
cf2_glyphpath_closeOpenPath( glyphpath ); | |
/* save the parameters of the move for later, when we'll know how to */ | |
/* offset it; */ | |
/* also save last move point */ | |
glyphpath->currentCS.x = glyphpath->start.x = x; | |
glyphpath->currentCS.y = glyphpath->start.y = y; | |
glyphpath->moveIsPending = TRUE; | |
/* ensure we have a valid map with current mask */ | |
if ( !cf2_hintmap_isValid( &glyphpath->hintMap ) || | |
cf2_hintmask_isNew( glyphpath->hintMask ) ) | |
cf2_hintmap_build( &glyphpath->hintMap, | |
glyphpath->hStemHintArray, | |
glyphpath->vStemHintArray, | |
glyphpath->hintMask, | |
glyphpath->hintOriginY, | |
FALSE ); | |
/* save a copy of current HintMap to use when drawing initial point */ | |
glyphpath->firstHintMap = glyphpath->hintMap; /* structure copy */ | |
} | |
FT_LOCAL_DEF( void ) | |
cf2_glyphpath_lineTo( CF2_GlyphPath glyphpath, | |
CF2_Fixed x, | |
CF2_Fixed y ) | |
{ | |
CF2_Fixed xOffset, yOffset; | |
FT_Vector P0, P1; | |
FT_Bool newHintMap; | |
/* | |
* New hints will be applied after cf2_glyphpath_pushPrevElem has run. | |
* In case this is a synthesized closing line, any new hints should be | |
* delayed until this path is closed (`cf2_hintmask_isNew' will be | |
* called again before the next line or curve). | |
*/ | |
/* true if new hint map not on close */ | |
newHintMap = cf2_hintmask_isNew( glyphpath->hintMask ) && | |
!glyphpath->pathIsClosing; | |
/* | |
* Zero-length lines may occur in the charstring. Because we cannot | |
* compute darkening offsets or intersections from zero-length lines, | |
* it is best to remove them and avoid artifacts. However, zero-length | |
* lines in CS at the start of a new hint map can generate non-zero | |
* lines in DS due to hint substitution. We detect a change in hint | |
* map here and pass those zero-length lines along. | |
*/ | |
/* | |
* Note: Find explicitly closed paths here with a conditional | |
* breakpoint using | |
* | |
* !gp->pathIsClosing && gp->start.x == x && gp->start.y == y | |
* | |
*/ | |
if ( glyphpath->currentCS.x == x && | |
glyphpath->currentCS.y == y && | |
!newHintMap ) | |
/* | |
* Ignore zero-length lines in CS where the hint map is the same | |
* because the line in DS will also be zero length. | |
* | |
* Ignore zero-length lines when we synthesize a closing line because | |
* the close will be handled in cf2_glyphPath_pushPrevElem. | |
*/ | |
return; | |
cf2_glyphpath_computeOffset( glyphpath, | |
glyphpath->currentCS.x, | |
glyphpath->currentCS.y, | |
x, | |
y, | |
&xOffset, | |
&yOffset ); | |
/* construct offset points */ | |
P0.x = glyphpath->currentCS.x + xOffset; | |
P0.y = glyphpath->currentCS.y + yOffset; | |
P1.x = x + xOffset; | |
P1.y = y + yOffset; | |
if ( glyphpath->moveIsPending ) | |
{ | |
/* emit offset 1st point as MoveTo */ | |
cf2_glyphpath_pushMove( glyphpath, P0 ); | |
glyphpath->moveIsPending = FALSE; /* adjust state machine */ | |
glyphpath->pathIsOpen = TRUE; | |
glyphpath->offsetStart1 = P1; /* record second point */ | |
} | |
if ( glyphpath->elemIsQueued ) | |
{ | |
FT_ASSERT( cf2_hintmap_isValid( &glyphpath->hintMap ) || | |
glyphpath->hintMap.count == 0 ); | |
cf2_glyphpath_pushPrevElem( glyphpath, | |
&glyphpath->hintMap, | |
&P0, | |
P1, | |
FALSE ); | |
} | |
/* queue the current element with offset points */ | |
glyphpath->elemIsQueued = TRUE; | |
glyphpath->prevElemOp = CF2_PathOpLineTo; | |
glyphpath->prevElemP0 = P0; | |
glyphpath->prevElemP1 = P1; | |
/* update current map */ | |
if ( newHintMap ) | |
cf2_hintmap_build( &glyphpath->hintMap, | |
glyphpath->hStemHintArray, | |
glyphpath->vStemHintArray, | |
glyphpath->hintMask, | |
glyphpath->hintOriginY, | |
FALSE ); | |
glyphpath->currentCS.x = x; /* pre-offset current point */ | |
glyphpath->currentCS.y = y; | |
} | |
FT_LOCAL_DEF( void ) | |
cf2_glyphpath_curveTo( CF2_GlyphPath glyphpath, | |
CF2_Fixed x1, | |
CF2_Fixed y1, | |
CF2_Fixed x2, | |
CF2_Fixed y2, | |
CF2_Fixed x3, | |
CF2_Fixed y3 ) | |
{ | |
CF2_Fixed xOffset1, yOffset1, xOffset3, yOffset3; | |
FT_Vector P0, P1, P2, P3; | |
/* TODO: ignore zero length portions of curve?? */ | |
cf2_glyphpath_computeOffset( glyphpath, | |
glyphpath->currentCS.x, | |
glyphpath->currentCS.y, | |
x1, | |
y1, | |
&xOffset1, | |
&yOffset1 ); | |
cf2_glyphpath_computeOffset( glyphpath, | |
x2, | |
y2, | |
x3, | |
y3, | |
&xOffset3, | |
&yOffset3 ); | |
/* add momentum from the middle segment */ | |
glyphpath->callbacks->windingMomentum += | |
cf2_getWindingMomentum( x1, y1, x2, y2 ); | |
/* construct offset points */ | |
P0.x = glyphpath->currentCS.x + xOffset1; | |
P0.y = glyphpath->currentCS.y + yOffset1; | |
P1.x = x1 + xOffset1; | |
P1.y = y1 + yOffset1; | |
/* note: preserve angle of final segment by using offset3 at both ends */ | |
P2.x = x2 + xOffset3; | |
P2.y = y2 + yOffset3; | |
P3.x = x3 + xOffset3; | |
P3.y = y3 + yOffset3; | |
if ( glyphpath->moveIsPending ) | |
{ | |
/* emit offset 1st point as MoveTo */ | |
cf2_glyphpath_pushMove( glyphpath, P0 ); | |
glyphpath->moveIsPending = FALSE; | |
glyphpath->pathIsOpen = TRUE; | |
glyphpath->offsetStart1 = P1; /* record second point */ | |
} | |
if ( glyphpath->elemIsQueued ) | |
{ | |
FT_ASSERT( cf2_hintmap_isValid( &glyphpath->hintMap ) || | |
glyphpath->hintMap.count == 0 ); | |
cf2_glyphpath_pushPrevElem( glyphpath, | |
&glyphpath->hintMap, | |
&P0, | |
P1, | |
FALSE ); | |
} | |
/* queue the current element with offset points */ | |
glyphpath->elemIsQueued = TRUE; | |
glyphpath->prevElemOp = CF2_PathOpCubeTo; | |
glyphpath->prevElemP0 = P0; | |
glyphpath->prevElemP1 = P1; | |
glyphpath->prevElemP2 = P2; | |
glyphpath->prevElemP3 = P3; | |
/* update current map */ | |
if ( cf2_hintmask_isNew( glyphpath->hintMask ) ) | |
cf2_hintmap_build( &glyphpath->hintMap, | |
glyphpath->hStemHintArray, | |
glyphpath->vStemHintArray, | |
glyphpath->hintMask, | |
glyphpath->hintOriginY, | |
FALSE ); | |
glyphpath->currentCS.x = x3; /* pre-offset current point */ | |
glyphpath->currentCS.y = y3; | |
} | |
FT_LOCAL_DEF( void ) | |
cf2_glyphpath_closeOpenPath( CF2_GlyphPath glyphpath ) | |
{ | |
if ( glyphpath->pathIsOpen ) | |
{ | |
/* | |
* A closing line in Character Space line is always generated below | |
* with `cf2_glyphPath_lineTo'. It may be ignored later if it turns | |
* out to be zero length in Device Space. | |
*/ | |
glyphpath->pathIsClosing = TRUE; | |
cf2_glyphpath_lineTo( glyphpath, | |
glyphpath->start.x, | |
glyphpath->start.y ); | |
/* empty the final element from the queue and close the path */ | |
if ( glyphpath->elemIsQueued ) | |
cf2_glyphpath_pushPrevElem( glyphpath, | |
&glyphpath->hintMap, | |
&glyphpath->offsetStart0, | |
glyphpath->offsetStart1, | |
TRUE ); | |
/* reset state machine */ | |
glyphpath->moveIsPending = TRUE; | |
glyphpath->pathIsOpen = FALSE; | |
glyphpath->pathIsClosing = FALSE; | |
glyphpath->elemIsQueued = FALSE; | |
} | |
} | |
/* END */ |