зеркало из https://github.com/mozilla/moz-skia.git
remove last remnant of SK_SCALAR_IS_FIXED code
move SkScalarMean into its only caller, reducing out public API exposure BUG= Review URL: https://codereview.chromium.org/117133004 git-svn-id: http://skia.googlecode.com/svn/trunk@12733 2bbb7eff-a529-9590-31e7-b0007b416f81
This commit is contained in:
reed@google.com
Родитель
6e252d49c9
Коммит
83c6a22525
|
|
@ -313,11 +313,6 @@ bool SkMatrix::preScale(SkScalar sx, SkScalar sy) {
|
|||
return true;
|
||||
}
|
||||
|
||||
#ifdef SK_SCALAR_IS_FIXED
|
||||
SkMatrix m;
|
||||
m.setScale(sx, sy);
|
||||
return this->preConcat(m);
|
||||
#else
|
||||
// the assumption is that these multiplies are very cheap, and that
|
||||
// a full concat and/or just computing the matrix type is more expensive.
|
||||
// Also, the fixed-point case checks for overflow, but the float doesn't,
|
||||
|
|
@ -333,7 +328,6 @@ bool SkMatrix::preScale(SkScalar sx, SkScalar sy) {
|
|||
|
||||
this->orTypeMask(kScale_Mask);
|
||||
return true;
|
||||
#endif
|
||||
}
|
||||
|
||||
bool SkMatrix::postScale(SkScalar sx, SkScalar sy, SkScalar px, SkScalar py) {
|
||||
|
|
@ -354,19 +348,6 @@ bool SkMatrix::postScale(SkScalar sx, SkScalar sy) {
|
|||
return this->postConcat(m);
|
||||
}
|
||||
|
||||
#ifdef SK_SCALAR_IS_FIXED
|
||||
static inline SkFixed roundidiv(SkFixed numer, int denom) {
|
||||
int ns = numer >> 31;
|
||||
int ds = denom >> 31;
|
||||
numer = (numer ^ ns) - ns;
|
||||
denom = (denom ^ ds) - ds;
|
||||
|
||||
SkFixed answer = (numer + (denom >> 1)) / denom;
|
||||
int as = ns ^ ds;
|
||||
return (answer ^ as) - as;
|
||||
}
|
||||
#endif
|
||||
|
||||
// this guy perhaps can go away, if we have a fract/high-precision way to
|
||||
// scale matrices
|
||||
bool SkMatrix::postIDiv(int divx, int divy) {
|
||||
|
|
@ -374,15 +355,6 @@ bool SkMatrix::postIDiv(int divx, int divy) {
|
|||
return false;
|
||||
}
|
||||
|
||||
#ifdef SK_SCALAR_IS_FIXED
|
||||
fMat[kMScaleX] = roundidiv(fMat[kMScaleX], divx);
|
||||
fMat[kMSkewX] = roundidiv(fMat[kMSkewX], divx);
|
||||
fMat[kMTransX] = roundidiv(fMat[kMTransX], divx);
|
||||
|
||||
fMat[kMScaleY] = roundidiv(fMat[kMScaleY], divy);
|
||||
fMat[kMSkewY] = roundidiv(fMat[kMSkewY], divy);
|
||||
fMat[kMTransY] = roundidiv(fMat[kMTransY], divy);
|
||||
#else
|
||||
const float invX = 1.f / divx;
|
||||
const float invY = 1.f / divy;
|
||||
|
||||
|
|
@ -393,7 +365,6 @@ bool SkMatrix::postIDiv(int divx, int divy) {
|
|||
fMat[kMScaleY] *= invY;
|
||||
fMat[kMSkewY] *= invY;
|
||||
fMat[kMTransY] *= invY;
|
||||
#endif
|
||||
|
||||
this->setTypeMask(kUnknown_Mask);
|
||||
return true;
|
||||
|
|
@ -856,57 +827,7 @@ bool SkMatrix::invertNonIdentity(SkMatrix* inv) const {
|
|||
inv->fMat[kMPersp0] = SkScalarMulShift(SkScalarMul(fMat[kMSkewY], fMat[kMPersp1]) - SkScalarMul(fMat[kMScaleY], fMat[kMPersp0]), scale, shift);
|
||||
inv->fMat[kMPersp1] = SkScalarMulShift(SkScalarMul(fMat[kMSkewX], fMat[kMPersp0]) - SkScalarMul(fMat[kMScaleX], fMat[kMPersp1]), scale, shift);
|
||||
inv->fMat[kMPersp2] = SkScalarMulShift(SkScalarMul(fMat[kMScaleX], fMat[kMScaleY]) - SkScalarMul(fMat[kMSkewX], fMat[kMSkewY]), scale, shift);
|
||||
#ifdef SK_SCALAR_IS_FIXED
|
||||
if (SkAbs32(inv->fMat[kMPersp2]) > SK_Fixed1) {
|
||||
Sk64 tmp;
|
||||
|
||||
tmp.set(SK_Fract1);
|
||||
tmp.shiftLeft(16);
|
||||
tmp.div(inv->fMat[kMPersp2], Sk64::kRound_DivOption);
|
||||
|
||||
SkFract scale = tmp.get32();
|
||||
|
||||
for (int i = 0; i < 9; i++) {
|
||||
inv->fMat[i] = SkFractMul(inv->fMat[i], scale);
|
||||
}
|
||||
}
|
||||
inv->fMat[kMPersp2] = SkFixedToFract(inv->fMat[kMPersp2]);
|
||||
#endif
|
||||
} else { // not perspective
|
||||
#ifdef SK_SCALAR_IS_FIXED
|
||||
Sk64 tx, ty;
|
||||
int clzNumer;
|
||||
|
||||
// check the 2x2 for overflow
|
||||
{
|
||||
int32_t value = SkAbs32(fMat[kMScaleY]);
|
||||
value |= SkAbs32(fMat[kMSkewX]);
|
||||
value |= SkAbs32(fMat[kMScaleX]);
|
||||
value |= SkAbs32(fMat[kMSkewY]);
|
||||
clzNumer = SkCLZ(value);
|
||||
if (shift - clzNumer > 31)
|
||||
return false; // overflow
|
||||
}
|
||||
|
||||
set_muladdmul(&tx, fMat[kMSkewX], fMat[kMTransY], -fMat[kMScaleY], fMat[kMTransX]);
|
||||
set_muladdmul(&ty, fMat[kMSkewY], fMat[kMTransX], -fMat[kMScaleX], fMat[kMTransY]);
|
||||
// check tx,ty for overflow
|
||||
clzNumer = SkCLZ(SkAbs32(tx.fHi) | SkAbs32(ty.fHi));
|
||||
if (shift - clzNumer > 14) {
|
||||
return false; // overflow
|
||||
}
|
||||
|
||||
int fixedShift = 61 - shift;
|
||||
int sk64shift = 44 - shift + clzNumer;
|
||||
|
||||
inv->fMat[kMScaleX] = SkMulShift(fMat[kMScaleY], scale, fixedShift);
|
||||
inv->fMat[kMSkewX] = SkMulShift(-fMat[kMSkewX], scale, fixedShift);
|
||||
inv->fMat[kMTransX] = SkMulShift(tx.getShiftRight(33 - clzNumer), scale, sk64shift);
|
||||
|
||||
inv->fMat[kMSkewY] = SkMulShift(-fMat[kMSkewY], scale, fixedShift);
|
||||
inv->fMat[kMScaleY] = SkMulShift(fMat[kMScaleX], scale, fixedShift);
|
||||
inv->fMat[kMTransY] = SkMulShift(ty.getShiftRight(33 - clzNumer), scale, sk64shift);
|
||||
#else
|
||||
inv->fMat[kMScaleX] = SkDoubleToFloat(fMat[kMScaleY] * scale);
|
||||
inv->fMat[kMSkewX] = SkDoubleToFloat(-fMat[kMSkewX] * scale);
|
||||
inv->fMat[kMTransX] = mul_diff_scale(fMat[kMSkewX], fMat[kMTransY],
|
||||
|
|
@ -916,7 +837,7 @@ bool SkMatrix::invertNonIdentity(SkMatrix* inv) const {
|
|||
inv->fMat[kMScaleY] = SkDoubleToFloat(fMat[kMScaleX] * scale);
|
||||
inv->fMat[kMTransY] = mul_diff_scale(fMat[kMSkewY], fMat[kMTransX],
|
||||
fMat[kMScaleX], fMat[kMTransY], scale);
|
||||
#endif
|
||||
|
||||
inv->fMat[kMPersp0] = 0;
|
||||
inv->fMat[kMPersp1] = 0;
|
||||
inv->fMat[kMPersp2] = kMatrix22Elem;
|
||||
|
|
@ -1038,10 +959,6 @@ void SkMatrix::Persp_pts(const SkMatrix& m, SkPoint dst[],
|
|||
const SkPoint src[], int count) {
|
||||
SkASSERT(m.hasPerspective());
|
||||
|
||||
#ifdef SK_SCALAR_IS_FIXED
|
||||
SkFixed persp2 = SkFractToFixed(m.fMat[kMPersp2]);
|
||||
#endif
|
||||
|
||||
if (count > 0) {
|
||||
do {
|
||||
SkScalar sy = src->fY;
|
||||
|
|
@ -1052,13 +969,8 @@ void SkMatrix::Persp_pts(const SkMatrix& m, SkPoint dst[],
|
|||
SkScalarMul(sy, m.fMat[kMSkewX]) + m.fMat[kMTransX];
|
||||
SkScalar y = SkScalarMul(sx, m.fMat[kMSkewY]) +
|
||||
SkScalarMul(sy, m.fMat[kMScaleY]) + m.fMat[kMTransY];
|
||||
#ifdef SK_SCALAR_IS_FIXED
|
||||
SkFixed z = SkFractMul(sx, m.fMat[kMPersp0]) +
|
||||
SkFractMul(sy, m.fMat[kMPersp1]) + persp2;
|
||||
#else
|
||||
float z = SkScalarMul(sx, m.fMat[kMPersp0]) +
|
||||
SkScalarMulAdd(sy, m.fMat[kMPersp1], m.fMat[kMPersp2]);
|
||||
#endif
|
||||
SkScalar z = SkScalarMul(sx, m.fMat[kMPersp0]) +
|
||||
SkScalarMulAdd(sy, m.fMat[kMPersp1], m.fMat[kMPersp2]);
|
||||
if (z) {
|
||||
z = SkScalarFastInvert(z);
|
||||
}
|
||||
|
|
@ -1191,14 +1103,8 @@ void SkMatrix::Persp_xy(const SkMatrix& m, SkScalar sx, SkScalar sy,
|
|||
SkScalarMul(sy, m.fMat[kMSkewX]) + m.fMat[kMTransX];
|
||||
SkScalar y = SkScalarMul(sx, m.fMat[kMSkewY]) +
|
||||
SkScalarMul(sy, m.fMat[kMScaleY]) + m.fMat[kMTransY];
|
||||
#ifdef SK_SCALAR_IS_FIXED
|
||||
SkFixed z = SkFractMul(sx, m.fMat[kMPersp0]) +
|
||||
SkFractMul(sy, m.fMat[kMPersp1]) +
|
||||
SkFractToFixed(m.fMat[kMPersp2]);
|
||||
#else
|
||||
float z = SkScalarMul(sx, m.fMat[kMPersp0]) +
|
||||
SkScalarMul(sy, m.fMat[kMPersp1]) + m.fMat[kMPersp2];
|
||||
#endif
|
||||
SkScalar z = SkScalarMul(sx, m.fMat[kMPersp0]) +
|
||||
SkScalarMul(sy, m.fMat[kMPersp1]) + m.fMat[kMPersp2];
|
||||
if (z) {
|
||||
z = SkScalarFastInvert(z);
|
||||
}
|
||||
|
|
@ -1206,33 +1112,14 @@ void SkMatrix::Persp_xy(const SkMatrix& m, SkScalar sx, SkScalar sy,
|
|||
pt->fY = SkScalarMul(y, z);
|
||||
}
|
||||
|
||||
#ifdef SK_SCALAR_IS_FIXED
|
||||
static SkFixed fixmuladdmul(SkFixed a, SkFixed b, SkFixed c, SkFixed d) {
|
||||
Sk64 tmp, tmp1;
|
||||
|
||||
tmp.setMul(a, b);
|
||||
tmp1.setMul(c, d);
|
||||
return tmp.addGetFixed(tmp1);
|
||||
// tmp.add(tmp1);
|
||||
// return tmp.getFixed();
|
||||
}
|
||||
#endif
|
||||
|
||||
void SkMatrix::RotTrans_xy(const SkMatrix& m, SkScalar sx, SkScalar sy,
|
||||
SkPoint* pt) {
|
||||
SkASSERT((m.getType() & (kAffine_Mask | kPerspective_Mask)) == kAffine_Mask);
|
||||
|
||||
#ifdef SK_SCALAR_IS_FIXED
|
||||
pt->fX = fixmuladdmul(sx, m.fMat[kMScaleX], sy, m.fMat[kMSkewX]) +
|
||||
m.fMat[kMTransX];
|
||||
pt->fY = fixmuladdmul(sx, m.fMat[kMSkewY], sy, m.fMat[kMScaleY]) +
|
||||
m.fMat[kMTransY];
|
||||
#else
|
||||
pt->fX = SkScalarMul(sx, m.fMat[kMScaleX]) +
|
||||
SkScalarMulAdd(sy, m.fMat[kMSkewX], m.fMat[kMTransX]);
|
||||
pt->fY = SkScalarMul(sx, m.fMat[kMSkewY]) +
|
||||
SkScalarMulAdd(sy, m.fMat[kMScaleY], m.fMat[kMTransY]);
|
||||
#endif
|
||||
}
|
||||
|
||||
void SkMatrix::Rot_xy(const SkMatrix& m, SkScalar sx, SkScalar sy,
|
||||
|
|
@ -1241,15 +1128,10 @@ void SkMatrix::Rot_xy(const SkMatrix& m, SkScalar sx, SkScalar sy,
|
|||
SkASSERT(0 == m.fMat[kMTransX]);
|
||||
SkASSERT(0 == m.fMat[kMTransY]);
|
||||
|
||||
#ifdef SK_SCALAR_IS_FIXED
|
||||
pt->fX = fixmuladdmul(sx, m.fMat[kMScaleX], sy, m.fMat[kMSkewX]);
|
||||
pt->fY = fixmuladdmul(sx, m.fMat[kMSkewY], sy, m.fMat[kMScaleY]);
|
||||
#else
|
||||
pt->fX = SkScalarMul(sx, m.fMat[kMScaleX]) +
|
||||
SkScalarMulAdd(sy, m.fMat[kMSkewX], m.fMat[kMTransX]);
|
||||
pt->fY = SkScalarMul(sx, m.fMat[kMSkewY]) +
|
||||
SkScalarMulAdd(sy, m.fMat[kMScaleY], m.fMat[kMTransY]);
|
||||
#endif
|
||||
}
|
||||
|
||||
void SkMatrix::ScaleTrans_xy(const SkMatrix& m, SkScalar sx, SkScalar sy,
|
||||
|
|
@ -1303,13 +1185,7 @@ const SkMatrix::MapXYProc SkMatrix::gMapXYProcs[] = {
|
|||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
// if its nearly zero (just made up 26, perhaps it should be bigger or smaller)
|
||||
#ifdef SK_SCALAR_IS_FIXED
|
||||
typedef SkFract SkPerspElemType;
|
||||
#define PerspNearlyZero(x) (SkAbs32(x) < (SK_Fract1 >> 26))
|
||||
#else
|
||||
typedef float SkPerspElemType;
|
||||
#define PerspNearlyZero(x) SkScalarNearlyZero(x, (1.0f / (1 << 26)))
|
||||
#endif
|
||||
#define PerspNearlyZero(x) SkScalarNearlyZero(x, (1.0f / (1 << 26)))
|
||||
|
||||
bool SkMatrix::fixedStepInX(SkScalar y, SkFixed* stepX, SkFixed* stepY) const {
|
||||
if (PerspNearlyZero(fMat[kMPersp0])) {
|
||||
|
|
@ -1323,12 +1199,7 @@ bool SkMatrix::fixedStepInX(SkScalar y, SkFixed* stepX, SkFixed* stepY) const {
|
|||
*stepY = SkScalarToFixed(fMat[kMSkewY]);
|
||||
}
|
||||
} else {
|
||||
#ifdef SK_SCALAR_IS_FIXED
|
||||
SkFixed z = SkFractMul(y, fMat[kMPersp1]) +
|
||||
SkFractToFixed(fMat[kMPersp2]);
|
||||
#else
|
||||
float z = y * fMat[kMPersp1] + fMat[kMPersp2];
|
||||
#endif
|
||||
SkScalar z = y * fMat[kMPersp1] + fMat[kMPersp2];
|
||||
if (stepX) {
|
||||
*stepX = SkScalarToFixed(SkScalarDiv(fMat[kMScaleX], z));
|
||||
}
|
||||
|
|
@ -1395,143 +1266,6 @@ int SkPerspIter::next() {
|
|||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifdef SK_SCALAR_IS_FIXED
|
||||
|
||||
static inline bool poly_to_point(SkPoint* pt, const SkPoint poly[], int count) {
|
||||
SkFixed x = SK_Fixed1, y = SK_Fixed1;
|
||||
SkPoint pt1, pt2;
|
||||
Sk64 w1, w2;
|
||||
|
||||
if (count > 1) {
|
||||
pt1.fX = poly[1].fX - poly[0].fX;
|
||||
pt1.fY = poly[1].fY - poly[0].fY;
|
||||
y = SkPoint::Length(pt1.fX, pt1.fY);
|
||||
if (y == 0) {
|
||||
return false;
|
||||
}
|
||||
switch (count) {
|
||||
case 2:
|
||||
break;
|
||||
case 3:
|
||||
pt2.fX = poly[0].fY - poly[2].fY;
|
||||
pt2.fY = poly[2].fX - poly[0].fX;
|
||||
goto CALC_X;
|
||||
default:
|
||||
pt2.fX = poly[0].fY - poly[3].fY;
|
||||
pt2.fY = poly[3].fX - poly[0].fX;
|
||||
CALC_X:
|
||||
w1.setMul(pt1.fX, pt2.fX);
|
||||
w2.setMul(pt1.fY, pt2.fY);
|
||||
w1.add(w2);
|
||||
w1.div(y, Sk64::kRound_DivOption);
|
||||
if (!w1.is32()) {
|
||||
return false;
|
||||
}
|
||||
x = w1.get32();
|
||||
break;
|
||||
}
|
||||
}
|
||||
pt->set(x, y);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool SkMatrix::Poly2Proc(const SkPoint srcPt[], SkMatrix* dst,
|
||||
const SkPoint& scalePt) {
|
||||
// need to check if SkFixedDiv overflows...
|
||||
|
||||
const SkFixed scale = scalePt.fY;
|
||||
dst->fMat[kMScaleX] = SkFixedDiv(srcPt[1].fY - srcPt[0].fY, scale);
|
||||
dst->fMat[kMSkewY] = SkFixedDiv(srcPt[0].fX - srcPt[1].fX, scale);
|
||||
dst->fMat[kMPersp0] = 0;
|
||||
dst->fMat[kMSkewX] = SkFixedDiv(srcPt[1].fX - srcPt[0].fX, scale);
|
||||
dst->fMat[kMScaleY] = SkFixedDiv(srcPt[1].fY - srcPt[0].fY, scale);
|
||||
dst->fMat[kMPersp1] = 0;
|
||||
dst->fMat[kMTransX] = srcPt[0].fX;
|
||||
dst->fMat[kMTransY] = srcPt[0].fY;
|
||||
dst->fMat[kMPersp2] = SK_Fract1;
|
||||
dst->setTypeMask(kUnknown_Mask);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool SkMatrix::Poly3Proc(const SkPoint srcPt[], SkMatrix* dst,
|
||||
const SkPoint& scale) {
|
||||
// really, need to check if SkFixedDiv overflow'd
|
||||
|
||||
dst->fMat[kMScaleX] = SkFixedDiv(srcPt[2].fX - srcPt[0].fX, scale.fX);
|
||||
dst->fMat[kMSkewY] = SkFixedDiv(srcPt[2].fY - srcPt[0].fY, scale.fX);
|
||||
dst->fMat[kMPersp0] = 0;
|
||||
dst->fMat[kMSkewX] = SkFixedDiv(srcPt[1].fX - srcPt[0].fX, scale.fY);
|
||||
dst->fMat[kMScaleY] = SkFixedDiv(srcPt[1].fY - srcPt[0].fY, scale.fY);
|
||||
dst->fMat[kMPersp1] = 0;
|
||||
dst->fMat[kMTransX] = srcPt[0].fX;
|
||||
dst->fMat[kMTransY] = srcPt[0].fY;
|
||||
dst->fMat[kMPersp2] = SK_Fract1;
|
||||
dst->setTypeMask(kUnknown_Mask);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool SkMatrix::Poly4Proc(const SkPoint srcPt[], SkMatrix* dst,
|
||||
const SkPoint& scale) {
|
||||
SkFract a1, a2;
|
||||
SkFixed x0, y0, x1, y1, x2, y2;
|
||||
|
||||
x0 = srcPt[2].fX - srcPt[0].fX;
|
||||
y0 = srcPt[2].fY - srcPt[0].fY;
|
||||
x1 = srcPt[2].fX - srcPt[1].fX;
|
||||
y1 = srcPt[2].fY - srcPt[1].fY;
|
||||
x2 = srcPt[2].fX - srcPt[3].fX;
|
||||
y2 = srcPt[2].fY - srcPt[3].fY;
|
||||
|
||||
/* check if abs(x2) > abs(y2) */
|
||||
if ( x2 > 0 ? y2 > 0 ? x2 > y2 : x2 > -y2 : y2 > 0 ? -x2 > y2 : x2 < y2) {
|
||||
SkFixed denom = SkMulDiv(x1, y2, x2) - y1;
|
||||
if (0 == denom) {
|
||||
return false;
|
||||
}
|
||||
a1 = SkFractDiv(SkMulDiv(x0 - x1, y2, x2) - y0 + y1, denom);
|
||||
} else {
|
||||
SkFixed denom = x1 - SkMulDiv(y1, x2, y2);
|
||||
if (0 == denom) {
|
||||
return false;
|
||||
}
|
||||
a1 = SkFractDiv(x0 - x1 - SkMulDiv(y0 - y1, x2, y2), denom);
|
||||
}
|
||||
|
||||
/* check if abs(x1) > abs(y1) */
|
||||
if ( x1 > 0 ? y1 > 0 ? x1 > y1 : x1 > -y1 : y1 > 0 ? -x1 > y1 : x1 < y1) {
|
||||
SkFixed denom = y2 - SkMulDiv(x2, y1, x1);
|
||||
if (0 == denom) {
|
||||
return false;
|
||||
}
|
||||
a2 = SkFractDiv(y0 - y2 - SkMulDiv(x0 - x2, y1, x1), denom);
|
||||
} else {
|
||||
SkFixed denom = SkMulDiv(y2, x1, y1) - x2;
|
||||
if (0 == denom) {
|
||||
return false;
|
||||
}
|
||||
a2 = SkFractDiv(SkMulDiv(y0 - y2, x1, y1) - x0 + x2, denom);
|
||||
}
|
||||
|
||||
// need to check if SkFixedDiv overflows...
|
||||
dst->fMat[kMScaleX] = SkFixedDiv(SkFractMul(a2, srcPt[3].fX) +
|
||||
srcPt[3].fX - srcPt[0].fX, scale.fX);
|
||||
dst->fMat[kMSkewY] = SkFixedDiv(SkFractMul(a2, srcPt[3].fY) +
|
||||
srcPt[3].fY - srcPt[0].fY, scale.fX);
|
||||
dst->fMat[kMPersp0] = SkFixedDiv(a2, scale.fX);
|
||||
dst->fMat[kMSkewX] = SkFixedDiv(SkFractMul(a1, srcPt[1].fX) +
|
||||
srcPt[1].fX - srcPt[0].fX, scale.fY);
|
||||
dst->fMat[kMScaleY] = SkFixedDiv(SkFractMul(a1, srcPt[1].fY) +
|
||||
srcPt[1].fY - srcPt[0].fY, scale.fY);
|
||||
dst->fMat[kMPersp1] = SkFixedDiv(a1, scale.fY);
|
||||
dst->fMat[kMTransX] = srcPt[0].fX;
|
||||
dst->fMat[kMTransY] = srcPt[0].fY;
|
||||
dst->fMat[kMPersp2] = SK_Fract1;
|
||||
dst->setTypeMask(kUnknown_Mask);
|
||||
return true;
|
||||
}
|
||||
|
||||
#else /* Scalar is float */
|
||||
|
||||
static inline bool checkForZero(float x) {
|
||||
return x*x == 0;
|
||||
}
|
||||
|
|
@ -1664,8 +1398,6 @@ bool SkMatrix::Poly4Proc(const SkPoint srcPt[], SkMatrix* dst,
|
|||
return true;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
typedef bool (*PolyMapProc)(const SkPoint[], SkMatrix*, const SkPoint&);
|
||||
|
||||
/* Taken from Rob Johnson's original sample code in QuickDraw GX
|
||||
|
|
|
|||
Загрузка…
Ссылка в новой задаче