bool SkBitmapController::State::processHighRequest(const SkBitmapProvider& provider) {
if (fQuality != kHigh_SkFilterQuality) {
return false;
}
fQuality = kMedium_SkFilterQuality;
SkScalar invScaleX = fInvMatrix.getScaleX();
SkScalar invScaleY = fInvMatrix.getScaleY();
if (fInvMatrix.getType() & SkMatrix::kAffine_Mask) {
SkSize scale;
if (!fInvMatrix.decomposeScale(&scale)) {
return false;
}
invScaleX = scale.width();
invScaleY = scale.height();
}
invScaleX = SkScalarAbs(invScaleX);
invScaleY = SkScalarAbs(invScaleY);
if (invScaleX >= 1 - SK_ScalarNearlyZero || invScaleY >= 1 - SK_ScalarNearlyZero) {
// we're down-scaling so abort HQ
return false;
}
// Confirmed that we can use HQ (w/ rasterpipeline)
fQuality = kHigh_SkFilterQuality;
(void)provider.asBitmap(&fResultBitmap);
return true;
}
SkIRect SkDisplacementMapEffect::onFilterNodeBounds(const SkIRect& src, const SkMatrix& ctm,
MapDirection) const {
SkVector scale = SkVector::Make(fScale, fScale);
ctm.mapVectors(&scale, 1);
return src.makeOutset(SkScalarCeilToInt(SkScalarAbs(scale.fX) * SK_ScalarHalf),
SkScalarCeilToInt(SkScalarAbs(scale.fY) * SK_ScalarHalf));
}
static SkVector map_sigma(const SkSize& localSigma, const SkMatrix& ctm) {
SkVector sigma = SkVector::Make(localSigma.width(), localSigma.height());
ctm.mapVectors(&sigma, 1);
sigma.fX = SkMinScalar(SkScalarAbs(sigma.fX), MAX_SIGMA);
sigma.fY = SkMinScalar(SkScalarAbs(sigma.fY), MAX_SIGMA);
return sigma;
}
bool draw(SkCanvas* canvas, const SkString& newText, SkScalar x, SkScalar y, SkPaint& paint)
{
SkScalar scale;
if (fInterp.timeToValues(SkTime::GetMSecs(), &scale) == SkInterpolator::kFreezeEnd_Result)
{
canvas->drawText(newText.c_str(), newText.size(), x, y, paint);
return false;
}
else
{
U8 alpha = paint.getAlpha();
SkScalar above, below;
(void)paint.measureText(nil, 0, &above, &below);
SkScalar height = below - above;
SkScalar dy = SkScalarMul(height, scale);
if (scale < 0)
height = -height;
// draw the old
paint.setAlpha((U8)SkScalarMul(alpha, SK_Scalar1 - SkScalarAbs(scale)));
canvas->drawText(fOldText.c_str(), fOldText.size(), x, y - dy, paint);
// draw the new
paint.setAlpha((U8)SkScalarMul(alpha, SkScalarAbs(scale)));
canvas->drawText(newText.c_str(), newText.size(), x, y + height - dy, paint);
// restore the paint
paint.setAlpha(alpha);
return true;
}
}
/* Returns 0 for 1 quad, and 1 for two quads, either way the answer is
stored in dst[]. Guarantees that the 1/2 quads will be monotonic.
*/
int SkChopQuadAtXExtrema(const SkPoint src[3], SkPoint dst[5])
{
SkASSERT(src);
SkASSERT(dst);
SkScalar a = src[0].fX;
SkScalar b = src[1].fX;
SkScalar c = src[2].fX;
if (is_not_monotonic(a, b, c)) {
SkScalar tValue;
if (valid_unit_divide(a - b, a - b - b + c, &tValue)) {
SkChopQuadAt(src, dst, tValue);
flatten_double_quad_extrema(&dst[0].fX);
return 1;
}
// if we get here, we need to force dst to be monotonic, even though
// we couldn't compute a unit_divide value (probably underflow).
b = SkScalarAbs(a - b) < SkScalarAbs(b - c) ? a : c;
}
dst[0].set(a, src[0].fY);
dst[1].set(b, src[1].fY);
dst[2].set(c, src[2].fY);
return 0;
}
void SkDisplacementMapEffect::computeFastBounds(const SkRect& src, SkRect* dst) const {
if (this->getColorInput()) {
this->getColorInput()->computeFastBounds(src, dst);
} else {
*dst = src;
}
dst->outset(SkScalarAbs(fScale) * SK_ScalarHalf, SkScalarAbs(fScale) * SK_ScalarHalf);
}
bool SkPathMeasure::conic_too_curvy(const SkPoint& firstPt, const SkPoint& midTPt,
const SkPoint& lastPt) {
SkPoint midEnds = firstPt + lastPt;
midEnds *= 0.5f;
SkVector dxy = midTPt - midEnds;
SkScalar dist = SkMaxScalar(SkScalarAbs(dxy.fX), SkScalarAbs(dxy.fY));
return dist > fTolerance;
}
// very tiny points cause numerical instability : don't allow them
static void force_small_to_zero(SkPoint* pt) {
if (SkScalarAbs(pt->fX) < FLT_EPSILON_ORDERABLE_ERR) {
pt->fX = 0;
}
if (SkScalarAbs(pt->fY) < FLT_EPSILON_ORDERABLE_ERR) {
pt->fY = 0;
}
}
static void unit_axis_align(SkVector* unit) {
const SkScalar TOLERANCE = SkDoubleToScalar(0.15);
if (SkScalarAbs(unit->fX) < TOLERANCE) {
unit->fX = 0;
unit->fY = SkScalarSign(unit->fY);
} else if (SkScalarAbs(unit->fY) < TOLERANCE) {
unit->fX = SkScalarSign(unit->fX);
unit->fY = 0;
}
}
static bool has_aligned_samples(const SkRect& srcRect, const SkRect& transformedRect) {
// detect pixel disalignment
if (SkScalarAbs(SkScalarRoundToScalar(transformedRect.left()) - transformedRect.left()) < kColorBleedTolerance &&
SkScalarAbs(SkScalarRoundToScalar(transformedRect.top()) - transformedRect.top()) < kColorBleedTolerance &&
SkScalarAbs(transformedRect.width() - srcRect.width()) < kColorBleedTolerance &&
SkScalarAbs(transformedRect.height() - srcRect.height()) < kColorBleedTolerance) {
return true;
}
return false;
}
static bool quad_too_curvy(const SkPoint pts[3]) {
// diff = (a/4 + b/2 + c/4) - (a/2 + c/2)
// diff = -a/4 + b/2 - c/4
SkScalar dx = SkScalarHalf(pts[1].fX) -
SkScalarHalf(SkScalarHalf(pts[0].fX + pts[2].fX));
SkScalar dy = SkScalarHalf(pts[1].fY) -
SkScalarHalf(SkScalarHalf(pts[0].fY + pts[2].fY));
SkScalar dist = SkMaxScalar(SkScalarAbs(dx), SkScalarAbs(dy));
return dist > CHEAP_DIST_LIMIT;
}
bool SkPathMeasure::quad_too_curvy(const SkPoint pts[3]) {
// diff = (a/4 + b/2 + c/4) - (a/2 + c/2)
// diff = -a/4 + b/2 - c/4
SkScalar dx = SkScalarHalf(pts[1].fX) -
SkScalarHalf(SkScalarHalf(pts[0].fX + pts[2].fX));
SkScalar dy = SkScalarHalf(pts[1].fY) -
SkScalarHalf(SkScalarHalf(pts[0].fY + pts[2].fY));
SkScalar dist = SkMaxScalar(SkScalarAbs(dx), SkScalarAbs(dy));
return dist > fTolerance;
}
virtual bool onClick(SkView::Click* click) {
SkPoint prev = click->fPrev;
SkPoint curr = click->fCurr;
bool handled = true;
switch (click->fState) {
case SkView::Click::kDown_State:
if (SkScalarAbs(curr.fX - fCommands->width()) <= SKDEBUGGER_RESIZEBARSIZE) {
fCommandsResizing = true;
}
else if (SkScalarAbs(curr.fY - (this->height() - fState->height())) <= SKDEBUGGER_RESIZEBARSIZE &&
curr.fX > fCommands->width()) {
fStateResizing = true;
}
else if (curr.fX < fCommands->width()) {
fAtomsToRead = fCommands->selectHighlight(
SkScalarFloorToInt(curr.fY));
}
else
handled = false;
break;
case SkView::Click::kMoved_State:
if (fCommandsResizing)
fCommands->setSize(curr.fX, this->height());
else if (fStateResizing)
fState->setSize(this->width(), this->height() - curr.fY);
else if (curr.fX < fCommands->width()) {
if (curr.fY - prev.fY < 0) {
fCommands->scrollDown();
}
if (curr.fY - prev.fY > 0) {
fCommands->scrollUp();
}
}
else
handled = false;
break;
case SkView::Click::kUp_State:
fStateResizing = fCommandsResizing = false;
break;
default:
break;
}
fStateOffset = fCommands->width();
fState->setSize(this->width() - fStateOffset, fState->height());
fState->setLoc(fStateOffset, this->height() - fState->height());
if (handled)
this->inval(NULL);
return handled;
}
static bool CurvesAreEqual(const SkPoint c0[4],
const SkPoint c1[4],
float tol) {
for (int i = 0; i < 4; i++) {
if (SkScalarAbs(c0[i].fX - c1[i].fX) > tol ||
SkScalarAbs(c0[i].fY - c1[i].fY) > tol
) {
PrintCurve("c0", c0);
PrintCurve("c1", c1);
return false;
}
}
return true;
}
// k = (y2 - y0, x0 - x2, (x2 - x0)*y0 - (y2 - y0)*x0 )
// l = (2*w * (y1 - y0), 2*w * (x0 - x1), 2*w * (x1*y0 - x0*y1))
// m = (2*w * (y2 - y1), 2*w * (x1 - x2), 2*w * (x2*y1 - x1*y2))
void GrPathUtils::getConicKLM(const SkPoint p[3], const SkScalar weight, SkScalar klm[9]) {
const SkScalar w2 = 2.f * weight;
klm[0] = p[2].fY - p[0].fY;
klm[1] = p[0].fX - p[2].fX;
klm[2] = (p[2].fX - p[0].fX) * p[0].fY - (p[2].fY - p[0].fY) * p[0].fX;
klm[3] = w2 * (p[1].fY - p[0].fY);
klm[4] = w2 * (p[0].fX - p[1].fX);
klm[5] = w2 * (p[1].fX * p[0].fY - p[0].fX * p[1].fY);
klm[6] = w2 * (p[2].fY - p[1].fY);
klm[7] = w2 * (p[1].fX - p[2].fX);
klm[8] = w2 * (p[2].fX * p[1].fY - p[1].fX * p[2].fY);
// scale the max absolute value of coeffs to 10
SkScalar scale = 0.f;
for (int i = 0; i < 9; ++i) {
scale = SkMaxScalar(scale, SkScalarAbs(klm[i]));
}
SkASSERT(scale > 0.f);
scale = 10.f / scale;
for (int i = 0; i < 9; ++i) {
klm[i] *= scale;
}
}
static void update_degenerate_test(DegenerateTestData* data, const SkPoint& pt) {
switch (data->fStage) {
case DegenerateTestData::kInitial:
data->fFirstPoint = pt;
data->fStage = DegenerateTestData::kPoint;
break;
case DegenerateTestData::kPoint:
if (pt.distanceToSqd(data->fFirstPoint) > kCloseSqd) {
data->fLineNormal = pt - data->fFirstPoint;
data->fLineNormal.normalize();
data->fLineNormal.setOrthog(data->fLineNormal);
data->fLineC = -data->fLineNormal.dot(data->fFirstPoint);
data->fStage = DegenerateTestData::kLine;
}
break;
case DegenerateTestData::kLine:
if (SkScalarAbs(data->fLineNormal.dot(pt) + data->fLineC) > kClose) {
data->fStage = DegenerateTestData::kNonDegenerate;
}
case DegenerateTestData::kNonDegenerate:
break;
default:
SkFAIL("Unexpected degenerate test stage.");
}
}
// Draws the given bitmap to the given canvas. The subset of the source bitmap
// identified by src_rect is drawn to the given destination rect. The bitmap
// will be resampled to resample_width * resample_height (this is the size of
// the whole image, not the subset). See shouldResampleBitmap for more.
//
// This does a lot of computation to resample only the portion of the bitmap
// that will only be drawn. This is critical for performance since when we are
// scrolling, for example, we are only drawing a small strip of the image.
// Resampling the whole image every time is very slow, so this speeds up things
// dramatically.
//
// Note: this code is only used when the canvas transformation is limited to
// scaling or translation.
static void drawResampledBitmap(SkCanvas& canvas, SkPaint& paint, const NativeImageSkia& bitmap, const SkIRect& srcIRect, const SkRect& destRect)
{
#if PLATFORM(CHROMIUM)
TRACE_EVENT0("skia", "drawResampledBitmap");
#endif
// Apply forward transform to destRect to estimate required size of
// re-sampled bitmap, and use only in calls required to resize, or that
// check for the required size.
SkRect destRectTransformed;
canvas.getTotalMatrix().mapRect(&destRectTransformed, destRect);
SkIRect destRectTransformedRounded;
destRectTransformed.round(&destRectTransformedRounded);
// Compute the visible portion of our rect.
SkRect destRectVisibleSubset;
ClipRectToCanvas(canvas, destRect, &destRectVisibleSubset);
// ClipRectToCanvas often overshoots, resulting in a larger region than our
// original destRect. Intersecting gets us back inside.
if (!destRectVisibleSubset.intersect(destRect))
return; // Nothing visible in destRect.
// Compute the image-relative (bitmap space) subset.
SkRect destBitmapSubset = destRectVisibleSubset;
destBitmapSubset.offset(-destRect.x(), -destRect.y());
// Scale the subset to the requested size. The canvas scale can be negative,
// but the resampling code is only interested in positive scaling in its normal space.
SkMatrix subsetTransform;
subsetTransform.setScale(SkScalarAbs(canvas.getTotalMatrix().getScaleX()),
SkScalarAbs(canvas.getTotalMatrix().getScaleY()));
SkRect destBitmapSubsetTransformed;
subsetTransform.mapRect(&destBitmapSubsetTransformed, destBitmapSubset);
SkIRect destBitmapSubsetTransformedRounded;
destBitmapSubsetTransformed.round(&destBitmapSubsetTransformedRounded);
// Transforms above plus rounding may cause destBitmapSubsetTransformedRounded
// to go outside the image, so need to clip to avoid problems.
if (!destBitmapSubsetTransformedRounded.intersect(
0, 0, destRectTransformedRounded.width(), destRectTransformedRounded.height()))
return; // Image is not visible.
SkBitmap resampled = bitmap.resizedBitmap(srcIRect,
destRectTransformedRounded.width(),
destRectTransformedRounded.height(),
destBitmapSubsetTransformedRounded);
canvas.drawBitmapRect(resampled, 0, destRectVisibleSubset, &paint);
}
// For test_matrix_decomposition, below.
static bool scalar_nearly_equal_relative(SkScalar a, SkScalar b,
SkScalar tolerance = SK_ScalarNearlyZero) {
// from Bruce Dawson
SkScalar diff = SkScalarAbs(a - b);
if (diff < tolerance) {
return true;
}
a = SkScalarAbs(a);
b = SkScalarAbs(b);
SkScalar largest = (b > a) ? b : a;
if (diff <= largest*tolerance) {
return true;
}
return false;
}
// Calc coefficients of I(s,t) where roots of I are inflection points of curve
// I(s,t) = t*(3*d0*s^2 - 3*d1*s*t + d2*t^2)
// d0 = a1 - 2*a2+3*a3
// d1 = -a2 + 3*a3
// d2 = 3*a3
// a1 = p0 . (p3 x p2)
// a2 = p1 . (p0 x p3)
// a3 = p2 . (p1 x p0)
// Places the values of d1, d2, d3 in array d passed in
static void calc_cubic_inflection_func(const SkPoint p[4], SkScalar d[3]) {
SkScalar a1 = calc_dot_cross_cubic(p[0], p[3], p[2]);
SkScalar a2 = calc_dot_cross_cubic(p[1], p[0], p[3]);
SkScalar a3 = calc_dot_cross_cubic(p[2], p[1], p[0]);
// need to scale a's or values in later calculations will grow to high
SkScalar max = SkScalarAbs(a1);
max = SkMaxScalar(max, SkScalarAbs(a2));
max = SkMaxScalar(max, SkScalarAbs(a3));
max = 1.f/max;
a1 = a1 * max;
a2 = a2 * max;
a3 = a3 * max;
d[2] = 3.f * a3;
d[1] = d[2] - a2;
d[0] = d[1] - a2 + a1;
}
static bool nearly_equal_scalar(SkScalar a, SkScalar b) {
#ifdef SK_SCALAR_IS_FLOAT
const float tolerance = 0.000005f;
#else
const int32_t tolerance = 3;
#endif
return SkScalarAbs(a - b) <= tolerance;
}
/* given a quad-curve and a point (x,y), chop the quad at that point and return
the new quad's offCurve point. Should only return false if the computed pos
is the start of the curve (i.e. root == 0)
*/
static bool quad_pt2OffCurve(const SkPoint quad[3], SkScalar x, SkScalar y, SkPoint* offCurve)
{
const SkScalar* base;
SkScalar value;
if (SkScalarAbs(x) < SkScalarAbs(y)) {
base = &quad[0].fX;
value = x;
} else {
base = &quad[0].fY;
value = y;
}
// note: this returns 0 if it thinks value is out of range, meaning the
// root might return something outside of [0, 1)
SkScalar t = quad_solve(base[0], base[2], base[4], value);
if (t > 0)
{
SkPoint tmp[5];
SkChopQuadAt(quad, tmp, t);
*offCurve = tmp[1];
return true;
} else {
/* t == 0 means either the value triggered a root outside of [0, 1)
For our purposes, we can ignore the <= 0 roots, but we want to
catch the >= 1 roots (which given our caller, will basically mean
a root of 1, give-or-take numerical instability). If we are in the
>= 1 case, return the existing offCurve point.
The test below checks to see if we are close to the "end" of the
curve (near base[4]). Rather than specifying a tolerance, I just
check to see if value is on to the right/left of the middle point
(depending on the direction/sign of the end points).
*/
if ((base[0] < base[4] && value > base[2]) ||
(base[0] > base[4] && value < base[2])) // should root have been 1
{
*offCurve = quad[1];
return true;
}
}
return false;
}
SkIRect SkDropShadowImageFilter::onFilterNodeBounds(const SkIRect& src, const SkMatrix& ctm,
MapDirection direction) const {
SkVector offsetVec = SkVector::Make(fDx, fDy);
if (kReverse_MapDirection == direction) {
offsetVec.negate();
}
ctm.mapVectors(&offsetVec, 1);
SkIRect dst = src.makeOffset(SkScalarCeilToInt(offsetVec.x()),
SkScalarCeilToInt(offsetVec.y()));
SkVector sigma = SkVector::Make(fSigmaX, fSigmaY);
ctm.mapVectors(&sigma, 1);
dst.outset(
SkScalarCeilToInt(SkScalarAbs(sigma.x() * 3)),
SkScalarCeilToInt(SkScalarAbs(sigma.y() * 3)));
if (fShadowMode == kDrawShadowAndForeground_ShadowMode) {
dst.join(src);
}
return dst;
}
static bool nearly_equal_scalar(SkScalar a, SkScalar b) {
// Note that we get more compounded error for multiple operations when
// SK_SCALAR_IS_FIXED.
#ifdef SK_SCALAR_IS_FLOAT
const SkScalar tolerance = SK_Scalar1 / 200000;
#else
const SkScalar tolerance = SK_Scalar1 / 1024;
#endif
return SkScalarAbs(a - b) <= tolerance;
}
/* Returns 0 for 1 quad, and 1 for two quads, either way the answer is
stored in dst[]. Guarantees that the 1/2 quads will be monotonic.
*/
int SkChopQuadAtYExtrema(const SkPoint src[3], SkPoint dst[5])
{
SkASSERT(src);
SkASSERT(dst);
#if 0
static bool once = true;
if (once)
{
once = false;
SkPoint s[3] = { 0, 26398, 0, 26331, 0, 20621428 };
SkPoint d[6];
int n = SkChopQuadAtYExtrema(s, d);
SkDebugf("chop=%d, Y=[%x %x %x %x %x %x]\n", n, d[0].fY, d[1].fY, d[2].fY, d[3].fY, d[4].fY, d[5].fY);
}
#endif
SkScalar a = src[0].fY;
SkScalar b = src[1].fY;
SkScalar c = src[2].fY;
if (is_not_monotonic(a, b, c))
{
SkScalar tValue;
if (valid_unit_divide(a - b, a - b - b + c, &tValue))
{
SkChopQuadAt(src, dst, tValue);
flatten_double_quad_extrema(&dst[0].fY);
return 1;
}
// if we get here, we need to force dst to be monotonic, even though
// we couldn't compute a unit_divide value (probably underflow).
b = SkScalarAbs(a - b) < SkScalarAbs(b - c) ? a : c;
}
dst[0].set(src[0].fX, a);
dst[1].set(src[1].fX, b);
dst[2].set(src[2].fX, c);
return 0;
}
bool SkAnimatorScript::IsFinite(const char* function, size_t len, SkTDArray<SkScriptValue>& params,
void* eng, SkScriptValue* value) {
if (SK_LITERAL_STR_EQUAL(function, "isFinite", len) == false)
return false;
if (params.count() != 1)
return false;
SkScriptValue* scriptValue = params.begin();
SkDisplayTypes type = scriptValue->fType;
SkScalar scalar = scriptValue->fOperand.fScalar;
value->fType = SkType_Int;
value->fOperand.fS32 = type == SkType_Float ? SkScalarIsNaN(scalar) == false &&
SkScalarAbs(scalar) != SK_ScalarInfinity : type == SkType_Int;
return true;
}
SkScalar ScaleFactor(const SkPath& path) {
static const SkScalar twoTo10 = 1024.f;
SkScalar largest = 0;
const SkScalar* oneBounds = &path.getBounds().fLeft;
for (int index = 0; index < 4; ++index) {
largest = SkTMax(largest, SkScalarAbs(oneBounds[index]));
}
SkScalar scale = twoTo10;
SkScalar next;
while ((next = scale * twoTo10) < largest) {
scale = next;
}
return scale == twoTo10 ? SK_Scalar1 : scale;
}
void SkNormalMapSourceImpl::Provider::fillScanLine(int x, int y, SkPoint3 output[],
int count) const {
SkPMColor tmpNormalColors[BUFFER_MAX];
do {
int n = SkTMin(count, BUFFER_MAX);
fMapContext->shadeSpan(x, y, tmpNormalColors, n);
for (int i = 0; i < n; i++) {
SkPoint3 tempNorm;
tempNorm.set(SkIntToScalar(SkGetPackedR32(tmpNormalColors[i])) - 127.0f,
SkIntToScalar(SkGetPackedG32(tmpNormalColors[i])) - 127.0f,
SkIntToScalar(SkGetPackedB32(tmpNormalColors[i])) - 127.0f);
tempNorm.normalize();
if (!SkScalarNearlyEqual(SkScalarAbs(tempNorm.fZ), 1.0f)) {
SkVector transformed = fSource.fInvCTM.mapVector(tempNorm.fX, tempNorm.fY);
// Normalizing the transformed X and Y, while keeping constant both Z and the
// vector's angle in the XY plane. This maintains the "slope" for the surface while
// appropriately rotating the normal for any anisotropic scaling that occurs.
// Here, we call scaling factor the number that must divide the transformed X and Y
// so that the normal's length remains equal to 1.
SkScalar scalingFactorSquared =
(SkScalarSquare(transformed.fX) + SkScalarSquare(transformed.fY))
/ (1.0f - SkScalarSquare(tempNorm.fZ));
SkScalar invScalingFactor = SkScalarInvert(SkScalarSqrt(scalingFactorSquared));
output[i].fX = transformed.fX * invScalingFactor;
output[i].fY = transformed.fY * invScalingFactor;
output[i].fZ = tempNorm.fZ;
} else {
output[i] = {0.0f, 0.0f, tempNorm.fZ};
output[i].normalize();
}
SkASSERT(SkScalarNearlyEqual(output[i].length(), 1.0f));
}
output += n;
x += n;
count -= n;
} while (count > 0);
}
SkGradientShaderBase::GpuColorType SkGradientShaderBase::getGpuColorType(SkColor colors[3]) const {
if (fColorCount <= 3) {
memcpy(colors, fOrigColors, fColorCount * sizeof(SkColor));
}
if (SkShader::kClamp_TileMode == fTileMode) {
if (2 == fColorCount) {
return kTwo_GpuColorType;
} else if (3 == fColorCount &&
(SkScalarAbs(
SkFixedToScalar(fRecs[1].fPos) - SK_ScalarHalf) < SK_Scalar1 / 1000)) {
return kThree_GpuColorType;
}
}
return kTexture_GpuColorType;
}
SkScalar SkPerlinNoiseShader::PerlinNoiseShaderContext::calculateTurbulenceValueForPoint(
int channel, StitchData& stitchData, const SkPoint& point) const {
const SkPerlinNoiseShader& perlinNoiseShader = static_cast<const SkPerlinNoiseShader&>(fShader);
if (perlinNoiseShader.fStitchTiles) {
// Set up TurbulenceInitial stitch values.
stitchData = fPaintingData->fStitchDataInit;
}
SkScalar turbulenceFunctionResult = 0;
SkPoint noiseVector(SkPoint::Make(SkScalarMul(point.x(), fPaintingData->fBaseFrequency.fX),
SkScalarMul(point.y(), fPaintingData->fBaseFrequency.fY)));
SkScalar ratio = SK_Scalar1;
for (int octave = 0; octave < perlinNoiseShader.fNumOctaves; ++octave) {
SkScalar noise = noise2D(channel, stitchData, noiseVector);
SkScalar numer = (perlinNoiseShader.fType == kFractalNoise_Type) ?
noise : SkScalarAbs(noise);
turbulenceFunctionResult += numer / ratio;
noiseVector.fX *= 2;
noiseVector.fY *= 2;
ratio *= 2;
if (perlinNoiseShader.fStitchTiles) {
// Update stitch values
stitchData.fWidth *= 2;
stitchData.fWrapX = stitchData.fWidth + kPerlinNoise;
stitchData.fHeight *= 2;
stitchData.fWrapY = stitchData.fHeight + kPerlinNoise;
}
}
// 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;
}
if (channel == 3) { // Scale alpha by paint value
turbulenceFunctionResult *= SkIntToScalar(getPaintAlpha()) / 255;
}
// Clamp result
return SkScalarPin(turbulenceFunctionResult, 0, SK_Scalar1);
}
void SkAnimatorScript::UnitTest() {
#if defined(SK_SUPPORT_UNITTEST)
SkAnimator animator;
SkASSERT(animator.decodeMemory(scriptTestSetup, sizeof(scriptTestSetup)-1));
SkEvent evt;
evt.setString("id", "evt");
evt.setS32("x", 3);
animator.doUserEvent(evt);
// set up animator with memory script above, then run value tests
for (unsigned index = 0; index < SkScriptNAnswer_testCount; index++) {
SkAnimatorScript engine(*animator.fMaker, NULL, scriptTests[index].fType);
SkScriptValue value;
const char* script = scriptTests[index].fScript;
bool success = engine.evaluateScript(&script, &value);
if (success == false) {
SkDebugf("script failed: %s\n", scriptTests[index].fScript);
SkASSERT(scriptTests[index].fType == SkType_Unknown);
continue;
}
SkASSERT(value.fType == scriptTests[index].fType);
SkScalar error;
switch (value.fType) {
case SkType_Int:
SkASSERT(value.fOperand.fS32 == scriptTests[index].fIntAnswer);
break;
case SkType_Float:
error = SkScalarAbs(value.fOperand.fScalar - scriptTests[index].fScalarAnswer);
SkASSERT(error < SK_Scalar1 / 10000);
break;
case SkType_String:
SkASSERT(strcmp(value.fOperand.fString->c_str(), scriptTests[index].fStringAnswer) == 0);
break;
default:
SkASSERT(0);
}
}
#endif
}
