#define FILTER_HEIGHT_LARGE SkIntToScalar(256)
static sk_sp<SkImageFilter> make_brightness(float amount, sk_sp<SkImageFilter> input) {
- SkScalar amount255 = SkScalarMul(amount, SkIntToScalar(255));
+ SkScalar amount255 = amount * 255;
SkScalar matrix[20] = { 1, 0, 0, 0, amount255,
0, 1, 0, 0, amount255,
0, 0, 1, 0, amount255,
static const SkScalar kMaxOffset = 100 * SK_Scalar1;
static const SkScalar kOffsetRange = kMaxOffset - kMinOffset;
for (int i = 0; i < N; ++i) {
- fRects[i].fLeft = -kMinOffset - SkScalarMul(rand.nextUScalar1(), kOffsetRange);
- fRects[i].fTop = -kMinOffset - SkScalarMul(rand.nextUScalar1(), kOffsetRange);
- fRects[i].fRight = W + kMinOffset + SkScalarMul(rand.nextUScalar1(), kOffsetRange);
- fRects[i].fBottom = H + kMinOffset + SkScalarMul(rand.nextUScalar1(), kOffsetRange);
+ fRects[i].fLeft = -kMinOffset - rand.nextUScalar1() * kOffsetRange;
+ fRects[i].fTop = -kMinOffset - rand.nextUScalar1() * kOffsetRange;
+ fRects[i].fRight = W + kMinOffset + rand.nextUScalar1() * kOffsetRange;
+ fRects[i].fBottom = H + kMinOffset + rand.nextUScalar1() * kOffsetRange;
fColors[i] = rand.nextU() | 0xFF000000;
}
fInit = true;
};
static sk_sp<SkColorFilter> make_brightness(float amount) {
- SkScalar amount255 = SkScalarMul(amount, SkIntToScalar(255));
+ SkScalar amount255 = amount * 255;
SkScalar matrix[20] = { 1, 0, 0, 0, amount255,
0, 1, 0, 0, amount255,
0, 0, 1, 0, amount255,
static SkPoint3 GetDistantDirection() {
static SkScalar azimuthRad = SkDegreesToRadians(SkIntToScalar(225));
static SkScalar elevationRad = SkDegreesToRadians(SkIntToScalar(5));
- static SkPoint3 distantDirection = SkPoint3::Make(SkScalarMul(SkScalarCos(azimuthRad),
- SkScalarCos(elevationRad)),
- SkScalarMul(SkScalarSin(azimuthRad),
- SkScalarCos(elevationRad)),
- SkScalarSin(elevationRad));
+ static SkPoint3 distantDirection = SkPoint3::Make(
+ SkScalarCos(azimuthRad) * SkScalarCos(elevationRad),
+ SkScalarSin(azimuthRad) * SkScalarCos(elevationRad),
+ SkScalarSin(elevationRad));
return distantDirection;
}
SkRandom rand (12);
int i;
for (i = 0; i < 100; i++) {
- path->quadTo(SkScalarMul(rand.nextUScalar1(), SkIntToScalar(640)),
- SkScalarMul(rand.nextUScalar1(), SkIntToScalar(480)),
- SkScalarMul(rand.nextUScalar1(), SkIntToScalar(640)),
- SkScalarMul(rand.nextUScalar1(), SkIntToScalar(480)));
+ path->quadTo(rand.nextUScalar1() * 640, rand.nextUScalar1() * 480,
+ rand.nextUScalar1() * 640, rand.nextUScalar1() * 480);
}
path->close();
}
}
inline SkScalar smoothCurve(SkScalar t) {
- static const SkScalar SK_Scalar3 = 3.0f;
-
- // returns t * t * (3 - 2 * t)
- return SkScalarMul(SkScalarSquare(t), SK_Scalar3 - 2 * t);
+ return t * t * (3 - 2 * t);
}
} // end namespace
for (int channel = 0; channel < 4; ++channel) {
for (int i = 0; i < kBlockSize; ++i) {
fGradient[channel][i] = SkPoint::Make(
- SkScalarMul(SkIntToScalar(fNoise[channel][i][0] - kBlockSize),
- gInvBlockSizef),
- SkScalarMul(SkIntToScalar(fNoise[channel][i][1] - kBlockSize),
- gInvBlockSizef));
+ (fNoise[channel][i][0] - kBlockSize) * gInvBlockSizef,
+ (fNoise[channel][i][1] - kBlockSize) * gInvBlockSizef);
fGradient[channel][i].normalize();
// Put the normalized gradient back into the noise data
- fNoise[channel][i][0] = SkScalarRoundToInt(SkScalarMul(
- fGradient[channel][i].fX + SK_Scalar1, gHalfMax16bits));
- fNoise[channel][i][1] = SkScalarRoundToInt(SkScalarMul(
- fGradient[channel][i].fY + SK_Scalar1, gHalfMax16bits));
+ fNoise[channel][i][0] = SkScalarRoundToInt(
+ (fGradient[channel][i].fX + 1) * gHalfMax16bits);
+ fNoise[channel][i][1] = SkScalarRoundToInt(
+ (fGradient[channel][i].fY + 1) * gHalfMax16bits);
}
}
}
stitchData = fPaintingData->fStitchDataInit;
}
SkScalar turbulenceFunctionResult = 0;
- SkPoint noiseVector(SkPoint::Make(SkScalarMul(point.x(), fPaintingData->fBaseFrequency.fX),
- SkScalarMul(point.y(), fPaintingData->fBaseFrequency.fY)));
+ SkPoint noiseVector(SkPoint::Make(point.x() * fPaintingData->fBaseFrequency.fX,
+ point.y() * fPaintingData->fBaseFrequency.fY));
SkScalar ratio = SK_Scalar1;
for (int octave = 0; octave < perlinNoiseShader.fNumOctaves; ++octave) {
SkScalar noise = noise2D(channel, stitchData, noiseVector);
// The value of turbulenceFunctionResult comes from ((turbulenceFunctionResult) + 1) / 2
// by fractalNoise and (turbulenceFunctionResult) by turbulence.
if (perlinNoiseShader.fType == kFractalNoise_Type) {
- turbulenceFunctionResult =
- SkScalarMul(turbulenceFunctionResult, SK_ScalarHalf) + SK_ScalarHalf;
+ turbulenceFunctionResult = SkScalarHalf(turbulenceFunctionResult + 1);
}
if (channel == 3) { // Scale alpha by paint value
SkScalar y0 = pts0[i].fY - ave0.fY;
SkScalar x1 = pts1[i].fX - ave1.fX;
SkScalar y1 = pts1[i].fY - ave1.fY;
- op[0] += SkScalarMul(x0, x1);
- op[1] += SkScalarMul(x0, y1);
- op[2] += SkScalarMul(y0, x1);
- op[3] += SkScalarMul(y0, y1);
+ op[0] += x0 * x1;
+ op[1] += x0 * y1;
+ op[2] += y0 * x1;
+ op[3] += y0 * y1;
}
}
static SkScalar dot(SkScalar ax, SkScalar ay, SkScalar bx, SkScalar by) {
- return SkScalarMul(ax, bx) + SkScalarMul(ay, by);
+ return ax * bx + ay * by;
}
bool SkSetPoly3To3(SkMatrix* matrix, const SkPoint src[3], const SkPoint dst[3]) {
computeOuterProduct(srcOP, src, srcAve, src, srcAve);
computeOuterProduct(dstOP, src, srcAve, dst, dstAve);
- SkScalar det = SkScalarMul(srcOP[0], srcOP[3]) - SkScalarMul(srcOP[1], srcOP[2]);
+ SkScalar det = srcOP[0] * srcOP[3] - srcOP[1] * srcOP[2];
// need SkScalarNearlyZeroSquared for this (to match Chrome's fix)
if (SkScalarNearlyZero(det)) {
// now compute invDet * [srcOP]T * [dstOP]
// scale and transpose
- const SkScalar srcOP0 = SkScalarMul( srcOP[3], invDet);
- const SkScalar srcOP1 = SkScalarMul(-srcOP[1], invDet);
- const SkScalar srcOP2 = SkScalarMul(-srcOP[2], invDet);
- const SkScalar srcOP3 = SkScalarMul( srcOP[0], invDet);
+ const SkScalar srcOP0 = srcOP[3] * invDet;
+ const SkScalar srcOP1 = -srcOP[1] * invDet;
+ const SkScalar srcOP2 = -srcOP[2] * invDet;
+ const SkScalar srcOP3 = srcOP[0] * invDet;
matrix->reset();
matrix->setScaleX(dot(srcOP0, srcOP1, dstOP[0], dstOP[2]));
SkScalar y0 = pts0[i].fY - ave0.fY;
SkScalar x1 = pts1[i].fX - ave1.fX;
SkScalar y1 = pts1[i].fY - ave1.fY;
- op[0] += SkScalarMul(x0, x1);
- op[1] += SkScalarMul(x0, y1);
- op[2] += SkScalarMul(y0, x1);
- op[3] += SkScalarMul(y0, y1);
+ op[0] += x0 * x1;
+ op[1] += x0 * y1;
+ op[2] += y0 * x1;
+ op[3] += y0 * y1;
}
}
if (!gp) {
continue;
}
- SkScalar x = SkScalarMul(col, w);
- SkScalar y = SkScalarMul(row, h);
+ SkScalar x = col * w;
+ SkScalar y = row * h;
SkPoint controlPts[] = {
{x + baseControlPts[0].fX, y + baseControlPts[0].fY},
{x + baseControlPts[1].fX, y + baseControlPts[1].fY},
continue;
}
- SkScalar x = SkScalarMul(col, w);
- SkScalar y = SkScalarMul(row, h);
+ SkScalar x = col * w;
+ SkScalar y = row * h;
SkPoint controlPts[] = {
{x + baseControlPts[0].fX, y + baseControlPts[0].fY},
{x + baseControlPts[1].fX, y + baseControlPts[1].fY},
continue;
}
- SkScalar x = SkScalarMul(col, w);
- SkScalar y = SkScalarMul(row, h);
+ SkScalar x = col * w;
+ SkScalar y = row * h;
SkPoint controlPts[] = {
{x + baseControlPts[0].fX, y + baseControlPts[0].fY},
{x + baseControlPts[1].fX, y + baseControlPts[1].fY},
#define MARGIN SkIntToScalar(10)
static sk_sp<SkColorFilter> cf_make_brightness(float brightness) {
- SkScalar amount255 = SkScalarMul(brightness, SkIntToScalar(255));
+ SkScalar amount255 = brightness * 255;
SkScalar matrix[20] = {
1, 0, 0, 0, amount255,
0, 1, 0, 0, amount255,
static sk_sp<SkImage> make_gradient_circle(int width, int height) {
SkScalar x = SkIntToScalar(width / 2);
SkScalar y = SkIntToScalar(height / 2);
- SkScalar radius = SkScalarMul(SkMinScalar(x, y), SkIntToScalar(4) / SkIntToScalar(5));
+ SkScalar radius = SkMinScalar(x, y) * 4 / 5;
sk_sp<SkSurface> surface(SkSurface::MakeRasterN32Premul(width, height));
SkCanvas* canvas = surface->getCanvas();
canvas->clear(0x00000000);
SkIntToScalar(10));
SkScalar elevationRad = SkDegreesToRadians(SkIntToScalar(5));
- SkPoint3 distantDirection = SkPoint3::Make(SkScalarMul(cosAzimuth,
- SkScalarCos(elevationRad)),
- SkScalarMul(sinAzimuth,
- SkScalarCos(elevationRad)),
+ SkPoint3 distantDirection = SkPoint3::Make(cosAzimuth * SkScalarCos(elevationRad),
+ sinAzimuth * SkScalarCos(elevationRad),
SkScalarSin(elevationRad));
SkScalar cutoffAngle = SkIntToScalar(15);
SkScalar kd = SkIntToScalar(2);
for (int i = 1; i < n; i++) {
rad += drad;
SkScalar cosV, sinV = SkScalarSinCos(rad, &cosV);
- path->lineTo(c + SkScalarMul(cosV, r), c + SkScalarMul(sinV, r));
+ path->lineTo(c + cosV * r, c + sinV * r);
}
path->close();
return r * 2 * 6 / 5;
for (int i = 1; i < n; i++) {
rad += drad;
SkScalar cosV, sinV = SkScalarSinCos(rad, &cosV);
- path->lineTo(c + SkScalarMul(cosV, r), c + SkScalarMul(sinV, r));
+ path->lineTo(c + cosV * r, c + sinV * r);
}
path->close();
return r * 2 * 6 / 5;
SkScalar fakeBoldScale = SkScalarInterpFunc(p.getTextSize(),
kStdFakeBoldInterpKeys, kStdFakeBoldInterpValues,
kStdFakeBoldInterpLength);
- SkScalar extra = SkScalarMul(p.getTextSize(), fakeBoldScale);
+ SkScalar extra = p.getTextSize() * fakeBoldScale;
p.setStrokeWidth(extra);
canvas->save();
canvas->translate(0, 120);
"SK_SUPPORT_LEGACY_SHADER_ISABITMAP",
"SK_SUPPORT_LEGACY_EMBOSSMASKFILTER",
"SK_SUPPORT_EXOTIC_CLIPOPS",
+ "SK_SUPPORT_LEGACY_SCALARMUL",
]
static inline SkScalar SkScalarSquare(SkScalar x) { return x * x; }
-#define SkScalarMul(a, b) ((SkScalar)(a) * (b))
-#define SkScalarMulAdd(a, b, c) ((SkScalar)(a) * (b) + (c))
-#define SkScalarMulDiv(a, b, c) ((SkScalar)(a) * (b) / (c))
#define SkScalarInvert(x) (SK_Scalar1 / (x))
#define SkScalarFastInvert(x) (SK_Scalar1 / (x))
#define SkScalarAve(a, b) (((a) + (b)) * SK_ScalarHalf)
return true;
}
+#ifdef SK_SUPPORT_LEGACY_SCALARMUL
+ #define SkScalarMul(a, b) ((SkScalar)(a) * (b))
+ #define SkScalarMulAdd(a, b, c) ((SkScalar)(a) * (b) + (c))
+ #define SkScalarMulDiv(a, b, c) ((SkScalar)(a) * (b) / (c))
+#endif
+
#endif
"SK_NO_ANALYTIC_AA",
"SK_SUPPORT_LEGACY_BITMAP_SETPIXELREF",
"SK_SUPPORT_LEGACY_CLIPOP_EXOTIC_NAMES",
+ "SK_SUPPORT_LEGACY_SCALARMUL",
]
################################################################################
string.appendf("(%i, %i)", fMouseX, fMouseY);
SkScalar left = dest.fLeft + SkIntToScalar(3);
SkScalar i = SK_Scalar1;
- drawText(canvas, string, left, SkScalarMulAdd(lineHeight, i, dest.fTop), paint);
+ drawText(canvas, string, left, lineHeight * i + dest.fTop, paint);
// Alpha
i += SK_Scalar1;
string.reset();
string.appendf("A: %X", SkColorGetA(color));
- drawText(canvas, string, left, SkScalarMulAdd(lineHeight, i, dest.fTop), paint);
+ drawText(canvas, string, left, lineHeight * i + dest.fTop, paint);
// Red
i += SK_Scalar1;
string.reset();
string.appendf("R: %X", SkColorGetR(color));
paint.setColor(SK_ColorRED);
- drawText(canvas, string, left, SkScalarMulAdd(lineHeight, i, dest.fTop), paint);
+ drawText(canvas, string, left, lineHeight * i + dest.fTop, paint);
// Green
i += SK_Scalar1;
string.reset();
string.appendf("G: %X", SkColorGetG(color));
paint.setColor(0xFF008800);
- drawText(canvas, string, left, SkScalarMulAdd(lineHeight, i, dest.fTop), paint);
+ drawText(canvas, string, left, lineHeight * i + dest.fTop, paint);
// Blue
i += SK_Scalar1;
string.reset();
string.appendf("B: %X", SkColorGetB(color));
paint.setColor(SK_ColorBLUE);
- drawText(canvas, string, left, SkScalarMulAdd(lineHeight, i, dest.fTop), paint);
+ drawText(canvas, string, left, lineHeight * i + dest.fTop, paint);
canvas->restoreToCount(count);
}
static SkScalar randRange(SkRandom& rand, SkScalar min, SkScalar max) {
SkASSERT(min <= max);
- return min + SkScalarMul(rand.nextUScalar1(), max - min);
+ return min + rand.nextUScalar1() * (max - min);
}
static void show_stroke(SkCanvas* canvas, bool doAA, SkScalar strokeWidth, int n) {
SkScalar u = SkIntToScalar(iu) / nu;
SkScalar v = SkIntToScalar(iv) / nv;
- SkScalar uv = SkScalarMul(u, v);
- SkScalar Uv = SkScalarMul(SK_Scalar1 - u, v);
- SkScalar uV = SkScalarMul(u, SK_Scalar1 - v);
- SkScalar UV = SkScalarMul(SK_Scalar1 - u, SK_Scalar1 - v);
-
- SkScalar x0 = SkScalarMul(UV, edge[TL].fX) + SkScalarMul(uV, edge[TR].fX) +
- SkScalarMul(Uv, edge[BL].fX) + SkScalarMul(uv, edge[BR].fX);
- SkScalar y0 = SkScalarMul(UV, edge[TL].fY) + SkScalarMul(uV, edge[TR].fY) +
- SkScalarMul(Uv, edge[BL].fY) + SkScalarMul(uv, edge[BR].fY);
-
- SkScalar x = SkScalarMul(SK_Scalar1 - v, edge[TL+iu].fX) +
- SkScalarMul(u, edge[TR+iv].fX) +
- SkScalarMul(v, edge[BR+nu-iu].fX) +
- SkScalarMul(SK_Scalar1 - u, edge[BL+nv-iv].fX) - x0;
- SkScalar y = SkScalarMul(SK_Scalar1 - v, edge[TL+iu].fY) +
- SkScalarMul(u, edge[TR+iv].fY) +
- SkScalarMul(v, edge[BR+nu-iu].fY) +
- SkScalarMul(SK_Scalar1 - u, edge[BL+nv-iv].fY) - y0;
+ SkScalar uv = u * v;
+ SkScalar Uv = (1 - u) * v;
+ SkScalar uV = u * (1 - v);
+ SkScalar UV = (1 - u) * (1 - v);
+
+ SkScalar x0 = UV * edge[TL].fX + uV * edge[TR].fX + Uv * edge[BL].fX + uv * edge[BR].fX;
+ SkScalar y0 = UV * edge[TL].fY + uV * edge[TR].fY + Uv * edge[BL].fY + uv * edge[BR].fY;
+
+ SkScalar x = (1 - v) * edge[TL+iu].fX + u * edge[TR+iv].fX +
+ v * edge[BR+nu-iu].fX + (1 - u) * edge[BL+nv-iv].fX - x0;
+ SkScalar y = (1 - v) * edge[TL+iu].fY + u * edge[TR+iv].fY +
+ v * edge[BR+nu-iu].fY + (1 - u) * edge[BL+nv-iv].fY - y0;
pt->set(x, y);
}
for (int i = 1; i < n; i++) {
rad += drad;
SkScalar cosV, sinV = SkScalarSinCos(rad, &cosV);
- path->lineTo(c + SkScalarMul(cosV, r), c + SkScalarMul(sinV, r));
+ path->lineTo(c + cosV * r, c + sinV * r);
}
path->close();
return r * 2 * 6 / 5;
bool doSave = r.nextBool();
SkSize size = SkSize::Make(
- SkScalarMul(kBounds.width(), r.nextRangeScalar(kMinElemSizeFrac, kMaxElemSizeFrac)),
- SkScalarMul(kBounds.height(), r.nextRangeScalar(kMinElemSizeFrac, kMaxElemSizeFrac)));
+ kBounds.width() * r.nextRangeScalar(kMinElemSizeFrac, kMaxElemSizeFrac),
+ kBounds.height() * r.nextRangeScalar(kMinElemSizeFrac, kMaxElemSizeFrac));
SkPoint xy = {r.nextRangeScalar(kBounds.fLeft, kBounds.fRight - size.fWidth),
r.nextRangeScalar(kBounds.fTop, kBounds.fBottom - size.fHeight)};
SkRect maxR = fillR;
SkScalar miter = SkMaxScalar(SK_Scalar1, paint.getStrokeMiter());
SkScalar inset = paint.getStrokeJoin() == SkPaint::kMiter_Join ?
- SkScalarMul(paint.getStrokeWidth(), miter) :
+ paint.getStrokeWidth() * miter :
paint.getStrokeWidth();
maxR.inset(-inset, -inset);
// A circle that bounds kBaseRect (with a significant amount of slop)
SkScalar circleR = SkMaxScalar(kBaseRect.width(), kBaseRect.height());
- circleR = SkScalarMul(circleR, 1.75f) / 2;
+ circleR *= 1.75f / 2;
static const SkPoint kCircleC = {kBaseRect.centerX(), kBaseRect.centerY()};
// round-rect radii
// Radii are scaled.
for (int i = 0; i < 4; ++i) {
REPORTER_ASSERT(reporter, SkScalarNearlyEqual(dst.radii((SkRRect::Corner) i).fX,
- SkScalarMul(orig.radii((SkRRect::Corner) i).fX, xScale)));
+ orig.radii((SkRRect::Corner) i).fX * xScale));
REPORTER_ASSERT(reporter, SkScalarNearlyEqual(dst.radii((SkRRect::Corner) i).fY,
- SkScalarMul(orig.radii((SkRRect::Corner) i).fY, yScale)));
+ orig.radii((SkRRect::Corner) i).fY * yScale));
}
REPORTER_ASSERT(reporter, SkScalarNearlyEqual(dst.rect().width(),
- SkScalarMul(orig.rect().width(), xScale)));
+ orig.rect().width() * xScale));
REPORTER_ASSERT(reporter, SkScalarNearlyEqual(dst.rect().height(),
- SkScalarMul(orig.rect().height(), yScale)));
+ orig.rect().height() * yScale));
REPORTER_ASSERT(reporter, SkScalarNearlyEqual(dst.rect().left(),
- SkScalarMul(orig.rect().left(), xScale)));
+ orig.rect().left() * xScale));
REPORTER_ASSERT(reporter, SkScalarNearlyEqual(dst.rect().top(),
- SkScalarMul(orig.rect().top(), yScale)));
+ orig.rect().top() * yScale));
}
static void test_round_rect_transform(skiatest::Reporter* reporter) {