void TShearY( LPTFORM lpTForm, int width, int dy )
/***********************************************************************/
{
LFIXED a;
unsigned int h;
h = lsqrt(((long)width * (long)width) + ((long)dy * (long)dy));
a = FGET(dy, h);
lpTForm->ay += FIXMUL( lpTForm->ax, a );
lpTForm->by += FIXMUL( lpTForm->bx, a );
lpTForm->cy += FIXMUL( lpTForm->cx, a );
}
void TShearX( LPTFORM lpTForm, int height, int dx )
/***********************************************************************/
{
LFIXED b;
unsigned int h;
h = lsqrt(((long)height * (long)height) + ((long)dx * (long)dx));
b = FGET(dx, h);
lpTForm->ax += FIXMUL( lpTForm->ay, b );
lpTForm->bx += FIXMUL( lpTForm->by, b );
lpTForm->cx += FIXMUL( lpTForm->cy, b );
}
void TScale( LPTFORM lpTForm, LFIXED sx, LFIXED sy )
/***********************************************************************/
{
if ( sx && (sx != FUNITY) )
{
lpTForm->ax = FIXMUL( lpTForm->ax, sx );
lpTForm->bx = FIXMUL( lpTForm->bx, sx );
lpTForm->cx = FIXMUL( lpTForm->cx, sx );
}
if ( sy && (sy != FUNITY) )
{
lpTForm->ay = FIXMUL( lpTForm->ay, sy );
lpTForm->by = FIXMUL( lpTForm->by, sy );
lpTForm->cy = FIXMUL( lpTForm->cy, sy );
}
}
void TInvert( LPTFORM lpTForm )
/***********************************************************************/
{
LFIXED ax, bx, cx, ay, by, cy;
LFIXED term1, term2, term3;
ax = lpTForm->ax;
ay = lpTForm->ay;
bx = lpTForm->bx;
by = lpTForm->by;
cx = lpTForm->cx;
cy = lpTForm->cy;
/* ax*by - bx*ay */ term1 = FIXMUL( ax, by ) - FIXMUL( bx, ay );
/* cy*bx - cx*by */ term2 = FIXMUL( cy, bx ) - FIXMUL( cx, by );
/* cx*ay - cy*ax */ term3 = FIXMUL( cx, ay ) - FIXMUL( cy, ax );
lpTForm->ax = FGET( by, term1 );
lpTForm->bx = FGET( -bx, term1 );
lpTForm->cx = FGET( term2, term1 );
lpTForm->ay = FGET( -ay, term1 );
lpTForm->by = FGET( ax, term1 );
lpTForm->cy = FGET( term3, term1 );
}
void TMultiply( LPTFORM lpTFormS1, LPTFORM lpTFormS2, LPTFORM lpTFormD)
/***********************************************************************/
{
lpTFormD->ax = FIXMUL(lpTFormS1->ax, lpTFormS2->ax) +
FIXMUL(lpTFormS1->ay, lpTFormS2->bx);
lpTFormD->bx = FIXMUL(lpTFormS1->bx, lpTFormS2->ax) +
FIXMUL(lpTFormS1->by, lpTFormS2->bx);
lpTFormD->cx = FIXMUL(lpTFormS1->cx, lpTFormS2->ax) +
FIXMUL(lpTFormS1->cy, lpTFormS2->bx) +
lpTFormS2->cx;
lpTFormD->ay = FIXMUL(lpTFormS1->ax, lpTFormS2->ay) +
FIXMUL(lpTFormS1->ay, lpTFormS2->by);
lpTFormD->by = FIXMUL(lpTFormS1->bx, lpTFormS2->ay) +
FIXMUL(lpTFormS1->by, lpTFormS2->by);
lpTFormD->cy = FIXMUL(lpTFormS1->cx, lpTFormS2->ay) +
FIXMUL(lpTFormS1->cy, lpTFormS2->by) +
lpTFormS2->cy;
}
void TRotate( LPTFORM lpTForm, LFIXED anglex, LFIXED angley )
/***********************************************************************/
{
LFIXED sinx, cosx, siny, cosy;
LFIXED ax, bx, cx;
SinCos( anglex, &sinx, &cosx );
SinCos( angley, &siny, &cosy );
ax = lpTForm->ax;
bx = lpTForm->bx;
cx = lpTForm->cx;
if ( siny || cosx )
{
lpTForm->ax = FIXMUL( ax, cosx ) - FIXMUL( lpTForm->ay, siny );
lpTForm->bx = FIXMUL( bx, cosx ) - FIXMUL( lpTForm->by, siny );
lpTForm->cx = FIXMUL( cx, cosx ) - FIXMUL( lpTForm->cy, siny );
}
if ( cosy || sinx )
{
lpTForm->ay = FIXMUL( ax, sinx ) + FIXMUL( lpTForm->ay, cosy );
lpTForm->by = FIXMUL( bx, sinx ) + FIXMUL( lpTForm->by, cosy );
lpTForm->cy = FIXMUL( cx, sinx ) + FIXMUL( lpTForm->cy, cosy );
}
}
//=======================================================================
// int CurveToPoints
// lpPoints: Bezier handle points.
// type: BEZIER_MARKER is the only type supported.
// lpOutputPoints: Result. - must be at least MAX_BEZIER_OUT or NULL
//
// returns the number of points written (or needed if !lpOutputPoints)
//=======================================================================
int CurveToPoints(LPPOINT lpPoints, int type, LPPOINT lpOutputPoints )
//=======================================================================
{
int n, t, i, nOutPoints, lastx, lasty, x, y;
int nMaxPoints;
int nPoints;
LFIXED tscale, fdx, fdy, tscalebase;
FPOINT ptR[MAX_BEZIER_IN];
LPFPOINT R;
LPPOINT P;
if (type != BEZIER_MARKER)
return(0);
nPoints = BEZIER_IN;
// determine the maximum number of points we will want (may effect quality)
x = y = INT_MAX;
lastx = lasty = INT_MIN;
for (i=0;i<nPoints;i++)
{
x = min(x, lpPoints[i].x);
y = min(y, lpPoints[i].y);
lastx = max(lastx, lpPoints[i].x);
lasty = max(lasty, lpPoints[i].y);
}
// get delta
x = lastx-x;
y = lasty-y;
nMaxPoints = (x+y)/4;
nMaxPoints = bound(nMaxPoints, 5, MAX_BEZIER_OUT);
// Transformer(lpTForm, lpPoints, &lastx, &lasty);
if (lpOutputPoints)
*lpOutputPoints++ = *lpPoints; //lastx,lasty;
nOutPoints = 1;
tscalebase = FGET( 1, nMaxPoints );
tscale = 0;
for ( t=1; t<nMaxPoints; t++ )
{
R = ptR;
P = lpPoints;
n = nPoints;
tscale += tscalebase;
while (--n >= 0)
{
// FTransformer(lpTForm, P, &R->fx, &R->fy);
R->fx = MAKEFIXED(P->x);
R->fy = MAKEFIXED(P->y);
R++;
P++;
}
n = nPoints - 1;
while ( --n >= 0 )
{
R = ptR;
for ( i=0; i<=n; i++ )
{
fdx = (R+1)->fx - R->fx;
fdy = (R+1)->fy - R->fy;
R->fx += FIXMUL( fdx, tscale );
R->fy += FIXMUL( fdy, tscale );
R++;
}
}
x = WHOLE(ptR[0].fx);
y = WHOLE(ptR[0].fy);
if (x != lastx || y != lasty)
{
lastx = x;
lasty = y;
if (lpOutputPoints)
{
lpOutputPoints->x = lastx;
lpOutputPoints->y = lasty;
lpOutputPoints++;
}
++nOutPoints;
}
}
n = nPoints - 1;
x = WHOLE(ptR[n].fx);
y = WHOLE(ptR[n].fy);
if (x != lastx || y != lasty)
{
if (lpOutputPoints)
{
lpOutputPoints->x = x;
lpOutputPoints->y = y;
}
++nOutPoints;
}
return( nOutPoints );
}
