virtual void onDraw(SkCanvas* canvas) { SkPoint pts[2] = { { 0, 0 }, { SkIntToScalar(100), SkIntToScalar(100) } }; SkShader::TileMode tm = SkShader::kClamp_TileMode; SkRect r = { 0, 0, SkIntToScalar(100), SkIntToScalar(100) }; SkPaint paint; paint.setAntiAlias(true); canvas->translate(SkIntToScalar(20), SkIntToScalar(20)); for (size_t i = 0; i < SK_ARRAY_COUNT(gGradData); i++) { canvas->save(); for (size_t j = 0; j < SK_ARRAY_COUNT(gGradMakers); j++) { SkShader* shader = gGradMakers[j](pts, gGradData[i], tm, NULL); // apply an increasing y perspective as we move to the right SkMatrix perspective; perspective.setIdentity(); perspective.setPerspY(SkScalarDiv(SkIntToScalar((unsigned) i+1), SkIntToScalar(500))); perspective.setSkewX(SkScalarDiv(SkIntToScalar((unsigned) i+1), SkIntToScalar(10))); shader->setLocalMatrix(perspective); paint.setShader(shader); canvas->drawRect(r, paint); shader->unref(); canvas->translate(0, SkIntToScalar(120)); } canvas->restore(); canvas->translate(SkIntToScalar(120), 0); } }
static IntersectionType intersection(const SkPoint& p1, const SkPoint& p2, const SkPoint& p3, const SkPoint& p4, SkPoint& res) { // Store the values for fast access and easy // equations-to-code conversion SkScalar x1 = p1.x(), x2 = p2.x(), x3 = p3.x(), x4 = p4.x(); SkScalar y1 = p1.y(), y2 = p2.y(), y3 = p3.y(), y4 = p4.y(); SkScalar d = SkScalarMul(x1 - x2, y3 - y4) - SkScalarMul(y1 - y2, x3 - x4); // If d is zero, there is no intersection if (SkScalarNearlyZero(d)) { return kNone_IntersectionType; } // Get the x and y SkScalar pre = SkScalarMul(x1, y2) - SkScalarMul(y1, x2), post = SkScalarMul(x3, y4) - SkScalarMul(y3, x4); // Compute the point of intersection res.set(SkScalarDiv(SkScalarMul(pre, x3 - x4) - SkScalarMul(x1 - x2, post), d), SkScalarDiv(SkScalarMul(pre, y3 - y4) - SkScalarMul(y1 - y2, post), d)); // Check if the x and y coordinates are within both lines return (res.x() < GrMin(x1, x2) || res.x() > GrMax(x1, x2) || res.x() < GrMin(x3, x4) || res.x() > GrMax(x3, x4) || res.y() < GrMin(y1, y2) || res.y() > GrMax(y1, y2) || res.y() < GrMin(y3, y4) || res.y() > GrMax(y3, y4)) ? kOut_IntersectionType : kIn_IntersectionType; }
void draw(SkCanvas* canvas, const SkRect& rect, const SkSize& deviceSize, SkPaint::FilterLevel filterLevel, SkImageFilter* input = NULL) { SkRect dstRect; canvas->getTotalMatrix().mapRect(&dstRect, rect); canvas->save(); SkScalar deviceScaleX = SkScalarDiv(deviceSize.width(), dstRect.width()); SkScalar deviceScaleY = SkScalarDiv(deviceSize.height(), dstRect.height()); canvas->translate(rect.x(), rect.y()); canvas->scale(deviceScaleX, deviceScaleY); canvas->translate(-rect.x(), -rect.y()); SkMatrix matrix; matrix.setScale(SkScalarInvert(deviceScaleX), SkScalarInvert(deviceScaleY)); SkAutoTUnref<SkImageFilter> imageFilter( SkMatrixImageFilter::Create(matrix, filterLevel, input)); SkPaint filteredPaint; filteredPaint.setImageFilter(imageFilter.get()); canvas->saveLayer(&rect, &filteredPaint); SkPaint paint; paint.setColor(0xFF00FF00); SkRect ovalRect = rect; ovalRect.inset(SkIntToScalar(4), SkIntToScalar(4)); canvas->drawOval(ovalRect, paint); canvas->restore(); // for saveLayer canvas->restore(); }
static SkScalar RGB_to_HSV(SkColor color, HSV_Choice choice) { SkScalar red = SkIntToScalar(SkColorGetR(color)); SkScalar green = SkIntToScalar(SkColorGetG(color)); SkScalar blue = SkIntToScalar(SkColorGetB(color)); SkScalar min = SkMinScalar(SkMinScalar(red, green), blue); SkScalar value = SkMaxScalar(SkMaxScalar(red, green), blue); if (choice == kGetValue) return value/255; SkScalar delta = value - min; SkScalar saturation = value == 0 ? 0 : SkScalarDiv(delta, value); if (choice == kGetSaturation) return saturation; SkScalar hue; if (saturation == 0) hue = 0; else { SkScalar part60 = SkScalarDiv(60 * SK_Scalar1, delta); if (red == value) { hue = SkScalarMul(green - blue, part60); if (hue < 0) hue += 360 * SK_Scalar1; } else if (green == value) hue = 120 * SK_Scalar1 + SkScalarMul(blue - red, part60); else // blue == value hue = 240 * SK_Scalar1 + SkScalarMul(red - green, part60); } SkASSERT(choice == kGetHue); return hue; }
void SkGridView::onSizeChange() { fScrollBar->setHeight(this->height()); fScrollBar->setLoc(this->locX() + this->width() - fScrollBar->width(), 0); if (fCellSize.equals(0, 0)) { fVisibleCount.set(0, 0); return; } SkScalar rows = SkScalarDiv(this->height(), fCellSize.fY); SkScalar cols = SkScalarDiv(this->width(), fCellSize.fX); int y = SkScalarFloor(rows); int x = SkScalarFloor(cols); y = check_count(y, rows); x = check_count(x, cols); if (!fVisibleCount.equals(x, y)) { fVisibleCount.set(x, y); this->ensureSelectionIsVisible(); // this->dirtyStrCache(); } }
bool SkXRayCrossesLine(const SkXRay& pt, const SkPoint pts[2]) { // Determine quick discards. // Consider query line going exactly through point 0 to not // intersect, for symmetry with SkXRayCrossesMonotonicCubic. if (pt.fY == pts[0].fY) return false; if (pt.fY < pts[0].fY && pt.fY < pts[1].fY) return false; if (pt.fY > pts[0].fY && pt.fY > pts[1].fY) return false; if (pt.fX > pts[0].fX && pt.fX > pts[1].fX) return false; // Determine degenerate cases if (SkScalarNearlyZero(pts[0].fY - pts[1].fY)) return false; if (SkScalarNearlyZero(pts[0].fX - pts[1].fX)) // We've already determined the query point lies within the // vertical range of the line segment. return pt.fX <= pts[0].fX; // Full line segment evaluation SkScalar delta_y = pts[1].fY - pts[0].fY; SkScalar delta_x = pts[1].fX - pts[0].fX; SkScalar slope = SkScalarDiv(delta_y, delta_x); SkScalar b = pts[0].fY - SkScalarMul(slope, pts[0].fX); // Solve for x coordinate at y = pt.fY SkScalar x = SkScalarDiv(pt.fY - b, slope); return pt.fX <= x; }
void SkRRect::setRectXY(const SkRect& rect, SkScalar xRad, SkScalar yRad) { if (rect.isEmpty() || !rect.isFinite()) { this->setEmpty(); return; } if (!SkScalarsAreFinite(xRad, yRad)) { xRad = yRad = 0; // devolve into a simple rect } if (xRad <= 0 || yRad <= 0) { // all corners are square in this case this->setRect(rect); return; } if (rect.width() < xRad+xRad || rect.height() < yRad+yRad) { SkScalar scale = SkMinScalar(SkScalarDiv(rect.width(), xRad + xRad), SkScalarDiv(rect.height(), yRad + yRad)); SkASSERT(scale < SK_Scalar1); xRad = SkScalarMul(xRad, scale); yRad = SkScalarMul(yRad, scale); } fRect = rect; for (int i = 0; i < 4; ++i) { fRadii[i].set(xRad, yRad); } fType = kSimple_Type; if (xRad >= SkScalarHalf(fRect.width()) && yRad >= SkScalarHalf(fRect.height())) { fType = kOval_Type; // TODO: assert that all the x&y radii are already W/2 & H/2 } SkDEBUGCODE(this->validate();) }
void SkRRect::setNinePatch(const SkRect& rect, SkScalar leftRad, SkScalar topRad, SkScalar rightRad, SkScalar bottomRad) { if (rect.isEmpty() || !rect.isFinite()) { this->setEmpty(); return; } const SkScalar array[4] = { leftRad, topRad, rightRad, bottomRad }; if (!SkScalarsAreFinite(array, 4)) { this->setRect(rect); // devolve into a simple rect return; } leftRad = SkMaxScalar(leftRad, 0); topRad = SkMaxScalar(topRad, 0); rightRad = SkMaxScalar(rightRad, 0); bottomRad = SkMaxScalar(bottomRad, 0); SkScalar scale = SK_Scalar1; if (leftRad + rightRad > rect.width()) { scale = SkScalarDiv(rect.width(), leftRad + rightRad); } if (topRad + bottomRad > rect.height()) { scale = SkMinScalar(scale, SkScalarDiv(rect.height(), topRad + bottomRad)); } if (scale < SK_Scalar1) { leftRad = SkScalarMul(leftRad, scale); topRad = SkScalarMul(topRad, scale); rightRad = SkScalarMul(rightRad, scale); bottomRad = SkScalarMul(bottomRad, scale); } if (leftRad == rightRad && topRad == bottomRad) { if (leftRad >= SkScalarHalf(rect.width()) && topRad >= SkScalarHalf(rect.height())) { fType = kOval_Type; } else if (0 == leftRad || 0 == topRad) { // If the left and (by equality check above) right radii are zero then it is a rect. // Same goes for top/bottom. fType = kRect_Type; leftRad = 0; topRad = 0; rightRad = 0; bottomRad = 0; } else { fType = kSimple_Type; } } else { fType = kNinePatch_Type; } fRect = rect; fRadii[kUpperLeft_Corner].set(leftRad, topRad); fRadii[kUpperRight_Corner].set(rightRad, topRad); fRadii[kLowerRight_Corner].set(rightRad, bottomRad); fRadii[kLowerLeft_Corner].set(leftRad, bottomRad); SkDEBUGCODE(this->validate();) }
virtual void onDraw(SkCanvas* canvas) { SkMatrix perspective; perspective.setIdentity(); perspective.setPerspY(SkScalarDiv(SK_Scalar1, SkIntToScalar(1000))); perspective.setSkewX(SkScalarDiv(SkIntToScalar(8), SkIntToScalar(25))); canvas->concat(perspective); INHERITED::onDraw(canvas); }
virtual Click* onFindClickHandler(SkScalar x, SkScalar y) { int ix = (int)(SkScalarDiv(x * N, W)); int iy = (int)(SkScalarDiv(y * N, H)); if (ix >= 0 && iy >= 0) { SkEvent evt("set-curr-index"); evt.setFast32(iy * N + ix); this->sendEventToParents(evt); } return NULL; }
void GrGLDisplacementMapEffect::setData(const GrGLProgramDataManager& pdman, const GrProcessor& proc) { const GrDisplacementMapEffect& displacementMap = proc.cast<GrDisplacementMapEffect>(); GrTexture* colorTex = displacementMap.texture(1); SkScalar scaleX = SkScalarDiv(displacementMap.scale().fX, SkIntToScalar(colorTex->width())); SkScalar scaleY = SkScalarDiv(displacementMap.scale().fY, SkIntToScalar(colorTex->height())); pdman.set2f(fScaleUni, SkScalarToFloat(scaleX), colorTex->origin() == kTopLeft_GrSurfaceOrigin ? SkScalarToFloat(scaleY) : SkScalarToFloat(-scaleY)); fGLDomain.setData(pdman, displacementMap.domain(), colorTex->origin()); }
static SkShader* Make2ConicalOutsideFlip(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm, const SkMatrix& localMatrix) { SkPoint center0, center1; SkScalar radius0 = SkScalarDiv(pts[1].fX - pts[0].fX, 10); SkScalar radius1 = SkScalarDiv(pts[1].fX - pts[0].fX, 3); center0.set(pts[0].fX + radius0, pts[0].fY + radius0); center1.set(pts[1].fX - radius1, pts[1].fY - radius1); return SkGradientShader::CreateTwoPointConical(center1, radius1, center0, radius0, data.fColors, data.fPos, data.fCount, tm, 0, &localMatrix); }
static SkShader* Make2ConicalTouchY(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm, const SkMatrix& localMatrix) { SkPoint center0, center1; SkScalar radius0 = SkScalarDiv(pts[1].fX - pts[0].fX, 7); SkScalar radius1 = SkScalarDiv(pts[1].fX - pts[0].fX, 3); center1.set(SkScalarAve(pts[0].fX, pts[1].fX), SkScalarAve(pts[0].fY, pts[1].fY)); center0.set(center1.fX, center1.fY + radius1 - radius0); return SkGradientShader::CreateTwoPointConical(center0, radius0, center1, radius1, data.fColors, data.fPos, data.fCount, tm, 0, &localMatrix); }
void SkSet::dump(SkAnimateMaker* maker) { INHERITED::dump(maker); if (dur != 1) { #ifdef SK_CAN_USE_FLOAT SkDebugf("dur=\"%g\" ", SkScalarToFloat(SkScalarDiv(dur,1000))); #else SkDebugf("dur=\"%x\" ", SkScalarDiv(dur,1000)); #endif } //don't want double />\n's SkDebugf("/>\n"); }
virtual void onDraw(SkCanvas* canvas) { canvas->clear(0x00000000); SkRect srcRect = SkRect::MakeWH(96, 96); SkSize deviceSize = SkSize::Make(16, 16); draw(canvas, srcRect, deviceSize, SkPaint::kNone_FilterLevel); canvas->translate(srcRect.width() + SkIntToScalar(10), 0); draw(canvas, srcRect, deviceSize, SkPaint::kLow_FilterLevel); canvas->translate(srcRect.width() + SkIntToScalar(10), 0); draw(canvas, srcRect, deviceSize, SkPaint::kMedium_FilterLevel); canvas->translate(srcRect.width() + SkIntToScalar(10), 0); draw(canvas, srcRect, deviceSize, SkPaint::kHigh_FilterLevel); SkBitmap bitmap; bitmap.allocN32Pixels(16, 16); bitmap.eraseARGB(0x00, 0x00, 0x00, 0x00); { SkBitmapDevice bitmapDevice(bitmap); SkCanvas bitmapCanvas(&bitmapDevice); SkPaint paint; paint.setColor(0xFF00FF00); SkRect ovalRect = SkRect::MakeWH(16, 16); ovalRect.inset(SkScalarDiv(2.0f, 3.0f), SkScalarDiv(2.0f, 3.0f)); bitmapCanvas.drawOval(ovalRect, paint); } SkRect inRect = SkRect::MakeXYWH(-4, -4, 20, 20); SkRect outRect = SkRect::MakeXYWH(-24, -24, 120, 120); SkAutoTUnref<SkBitmapSource> source(SkBitmapSource::Create(bitmap, inRect, outRect)); canvas->translate(srcRect.width() + SkIntToScalar(10), 0); draw(canvas, srcRect, deviceSize, SkPaint::kHigh_FilterLevel, source.get()); }
virtual bool onClick(Click* click) { SkScalar center = this->width()/2; fSaturation = SkScalarDiv(click->fCurr.fX - center, center/2); center = this->height()/2; fAngle = SkScalarDiv(click->fCurr.fY - center, center) * 180; fDX += click->fCurr.fX - click->fPrev.fX; fDY += click->fCurr.fY - click->fPrev.fY; fScale = SkScalarDiv(click->fCurr.fX, this->width()); this->inval(NULL); return true; return this->INHERITED::onClick(click); }
static ECode native_draw( /* [in] */ SkCanvas* canvas, /* [in] */ SkRect& bounds, /* [in] */ const SkBitmap* bitmap, /* [in] */ ArrayOf<Byte>* chunkObj, /* [in] */ const SkPaint* paint, /* [in] */ Int32 destDensity, /* [in] */ Int32 srcDensity) { ECode ec = NOERROR; Int32 chunkSize = chunkObj->GetLength(); void* storage = chunkObj->GetPayload(); // need to deserialize the chunk android::Res_png_9patch* chunk = static_cast<android::Res_png_9patch*>(storage); assert(chunkSize == (Int32)chunk->serializedSize()); // this relies on deserialization being done in place android::Res_png_9patch::deserialize(chunk); if (destDensity == srcDensity || destDensity == 0 || srcDensity == 0) { // Logger::V(TAG, "Drawing unscaled 9-patch: (%g,%g)-(%g,%g)", // SkScalarToFloat(bounds.fLeft), SkScalarToFloat(bounds.fTop), // SkScalarToFloat(bounds.fRight), SkScalarToFloat(bounds.fBottom)); ec = NinePatch_Draw(canvas, bounds, *bitmap, *chunk, paint, NULL); } else { canvas->save(); SkScalar scale = SkFloatToScalar(destDensity / (float)srcDensity); canvas->translate(bounds.fLeft, bounds.fTop); canvas->scale(scale, scale); bounds.fRight = SkScalarDiv(bounds.fRight-bounds.fLeft, scale); bounds.fBottom = SkScalarDiv(bounds.fBottom-bounds.fTop, scale); bounds.fLeft = bounds.fTop = 0; Logger::V(TAG, "Drawing scaled 9-patch: (%g,%g)-(%g,%g) srcDensity=%d destDensity=%d", SkScalarToFloat(bounds.fLeft), SkScalarToFloat(bounds.fTop), SkScalarToFloat(bounds.fRight), SkScalarToFloat(bounds.fBottom), srcDensity, destDensity); ec = NinePatch_Draw(canvas, bounds, *bitmap, *chunk, paint, NULL); canvas->restore(); } return ec; }
void SkAnimate::dump(SkAnimateMaker* maker) { INHERITED::dump(maker); //from animateBase //SkSet inherits from this class if (getType() != SkType_Set) { if (fMirror) SkDebugf("mirror=\"true\" "); if (fReset) SkDebugf("reset=\"true\" "); SkDebugf("dur=\"%g\" ", SkScalarToFloat(SkScalarDiv(dur,1000))); if (repeat != SK_Scalar1) SkDebugf("repeat=\"%g\" ", SkScalarToFloat(repeat)); //if (fHasValues) // SkDebugf("values=\"%s\" ", values); if (blend.count() != 1 || blend[0] != SK_Scalar1) { SkDebugf("blend=\"["); bool firstElem = true; for (int i = 0; i < blend.count(); i++) { if (!firstElem) SkDebugf(","); firstElem = false; SkDebugf("%g", SkScalarToFloat(blend[i])); } SkDebugf("]\" "); } SkDebugf("/>\n");//i assume that if it IS, we will do it separately } }
virtual void onDraw(SkCanvas* canvas) { SkScalar angle = kAngle*SK_ScalarPI + SkScalarHalf(SK_ScalarPI); SkScalar size = SkIntToScalar(SkMin32(kWidth, kHeight)); SkPoint center = SkPoint::Make(SkScalarHalf(kWidth), SkScalarHalf(kHeight)); SkScalar length = 5; SkScalar step = angle; SkPath path; path.moveTo(center); while (length < (SkScalarHalf(size) - 10.f)) { SkPoint rp = SkPoint::Make(length*SkScalarCos(step) + center.fX, length*SkScalarSin(step) + center.fY); path.lineTo(rp); length += SkScalarDiv(angle, SkScalarHalf(SK_ScalarPI)); step += angle; } path.close(); SkPaint paint; paint.setAntiAlias(true); paint.setStyle(SkPaint::kStroke_Style); paint.setColor(0xFF007700); canvas->drawPath(path, paint); }
void SkPathStroker::quad_to(const SkPoint pts[3], const SkVector& normalAB, const SkVector& unitNormalAB, SkVector* normalBC, SkVector* unitNormalBC, int subDivide) { if (!set_normal_unitnormal(pts[1], pts[2], fRadius, normalBC, unitNormalBC)) { // pts[1] nearly equals pts[2], so just draw a line to pts[2] this->line_to(pts[2], normalAB); *normalBC = normalAB; *unitNormalBC = unitNormalAB; return; } if (--subDivide >= 0 && normals_too_curvy(unitNormalAB, *unitNormalBC)) { SkPoint tmp[5]; SkVector norm, unit; SkChopQuadAtHalf(pts, tmp); this->quad_to(&tmp[0], normalAB, unitNormalAB, &norm, &unit, subDivide); this->quad_to(&tmp[2], norm, unit, normalBC, unitNormalBC, subDivide); } else { SkVector normalB; normalB = pts[2] - pts[0]; normalB.rotateCCW(); SkScalar dot = SkPoint::DotProduct(unitNormalAB, *unitNormalBC); SkAssertResult(normalB.setLength(SkScalarDiv(fRadius, SkScalarSqrt((SK_Scalar1 + dot)/2)))); fOuter.quadTo( pts[1].fX + normalB.fX, pts[1].fY + normalB.fY, pts[2].fX + normalBC->fX, pts[2].fY + normalBC->fY); fInner.quadTo( pts[1].fX - normalB.fX, pts[1].fY - normalB.fY, pts[2].fX - normalBC->fX, pts[2].fY - normalBC->fY); } }
void onDrawContent(SkCanvas* canvas) override { SkScalar angle = fAngle*SK_ScalarPI + SkScalarHalf(SK_ScalarPI); SkPoint center = SkPoint::Make(SkScalarHalf(this->width()), SkScalarHalf(this->height())); SkScalar length = 5; SkScalar step = angle; SkPath path; path.moveTo(center); while (length < (SkScalarHalf(SkMinScalar(this->width(), this->height())) - 10.f)) { SkPoint rp = SkPoint::Make(length*SkScalarCos(step) + center.fX, length*SkScalarSin(step) + center.fY); path.lineTo(rp); length += SkScalarDiv(angle, SkScalarHalf(SK_ScalarPI)); step += angle; } path.close(); SkPaint paint; paint.setAntiAlias(true); paint.setStyle(SkPaint::kStroke_Style); paint.setColor(0xFF007700); canvas->drawPath(path, paint); }
void SkListView::ensureVisibleRowCount() { SkScalar height = this->height(); int n = 0; if (height > 0) { n = 1; height -= fHeights[kSelected_Height]; if (height > 0) { SkScalar count = SkScalarDiv(height, fHeights[kNormal_Height]); n += SkScalarFloor(count); if (count - SkIntToScalar(n) > SK_Scalar1*3/4) n += 1; // SkDebugf("count %g, n %d\n", count/65536., n); } } if (fVisibleRowCount != n) { if (fScrollBar) fScrollBar->setShown(n); fVisibleRowCount = n; this->ensureSelectionIsVisible(); this->dirtyCache(kAnimCount_DirtyFlag | kAnimContent_DirtyFlag); } }
uint32_t GrPathUtils::quadraticPointCount(const GrPoint points[], GrScalar tol) { if (tol < gMinCurveTol) { tol == gMinCurveTol; } GrAssert(tol > 0); GrScalar d = points[1].distanceToLineSegmentBetween(points[0], points[2]); if (d <= tol) { return 1; } else { // Each time we subdivide, d should be cut in 4. So we need to // subdivide x = log4(d/tol) times. x subdivisions creates 2^(x) // points. // 2^(log4(x)) = sqrt(x); int temp = SkScalarCeil(SkScalarSqrt(SkScalarDiv(d, tol))); int pow2 = GrNextPow2(temp); // Because of NaNs & INFs we can wind up with a degenerate temp // such that pow2 comes out negative. Also, our point generator // will always output at least one pt. if (pow2 < 1) { pow2 = 1; } return GrMin(pow2, MAX_POINTS_PER_CURVE); } }
void SkPDFGraphicState::emitObject(SkWStream* stream, const SkPDFObjNumMap& objNumMap, const SkPDFSubstituteMap& substitutes) { SkAutoTUnref<SkPDFDict> dict(SkNEW_ARGS(SkPDFDict, ("ExtGState"))); dict->insertName("Type", "ExtGState"); SkScalar alpha = SkScalarDiv(fAlpha, 0xFF); dict->insertScalar("CA", alpha); dict->insertScalar("ca", alpha); SkPaint::Cap strokeCap = (SkPaint::Cap)fStrokeCap; SkPaint::Join strokeJoin = (SkPaint::Join)fStrokeJoin; SkXfermode::Mode xferMode = (SkXfermode::Mode)fMode; SK_COMPILE_ASSERT(SkPaint::kButt_Cap == 0, paint_cap_mismatch); SK_COMPILE_ASSERT(SkPaint::kRound_Cap == 1, paint_cap_mismatch); SK_COMPILE_ASSERT(SkPaint::kSquare_Cap == 2, paint_cap_mismatch); SK_COMPILE_ASSERT(SkPaint::kCapCount == 3, paint_cap_mismatch); SkASSERT(strokeCap >= 0 && strokeCap <= 2); dict->insertInt("LC", strokeCap); SK_COMPILE_ASSERT(SkPaint::kMiter_Join == 0, paint_join_mismatch); SK_COMPILE_ASSERT(SkPaint::kRound_Join == 1, paint_join_mismatch); SK_COMPILE_ASSERT(SkPaint::kBevel_Join == 2, paint_join_mismatch); SK_COMPILE_ASSERT(SkPaint::kJoinCount == 3, paint_join_mismatch); SkASSERT(strokeJoin >= 0 && strokeJoin <= 2); dict->insertInt("LJ", strokeJoin); dict->insertScalar("LW", fStrokeWidth); dict->insertScalar("ML", fStrokeMiter); dict->insertBool("SA", true); // SA = Auto stroke adjustment. dict->insertName("BM", as_blend_mode(xferMode)); dict->emitObject(stream, objNumMap, substitutes); }
uint32_t GrPathUtils::cubicPointCount(const GrPoint points[], GrScalar tol) { if (tol < gMinCurveTol) { tol == gMinCurveTol; } GrAssert(tol > 0); GrScalar d = GrMax( points[1].distanceToLineSegmentBetweenSqd(points[0], points[3]), points[2].distanceToLineSegmentBetweenSqd(points[0], points[3])); d = SkScalarSqrt(d); if (d <= tol) { return 1; } else { int temp = SkScalarCeil(SkScalarSqrt(SkScalarDiv(d, tol))); int pow2 = GrNextPow2(temp); // Because of NaNs & INFs we can wind up with a degenerate temp // such that pow2 comes out negative. Also, our point generator // will always output at least one pt. if (pow2 < 1) { pow2 = 1; } return GrMin(pow2, MAX_POINTS_PER_CURVE); } }
static void normalize(SkScalar v[3]) { SkScalar mag = SkScalarSquare(v[0]) + SkScalarSquare(v[1]) + SkScalarSquare(v[2]); mag = SkScalarSqrt(mag); for (int i = 0; i < 3; i++) { v[i] = SkScalarDiv(v[i], mag); } }
SkScalar SkInterpolatorBase::ComputeRelativeT(SkMSec time, SkMSec prevTime, SkMSec nextTime, const SkScalar blend[4]) { SkASSERT(time > prevTime && time < nextTime); SkScalar t = SkScalarDiv((SkScalar)(time - prevTime), (SkScalar)(nextTime - prevTime)); return blend ? SkUnitCubicInterp(t, blend[0], blend[1], blend[2], blend[3]) : t; }
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); turbulenceFunctionResult += SkScalarDiv( (perlinNoiseShader.fType == kFractalNoise_Type) ? noise : SkScalarAbs(noise), 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 = SkScalarMul(turbulenceFunctionResult, SkScalarDiv(SkIntToScalar(getPaintAlpha()), SkIntToScalar(255))); } // Clamp result return SkScalarPin(turbulenceFunctionResult, 0, SK_Scalar1); }
bool SkSliderView::onClick(Click* click) { if (fMax) { SkScalar percent = SkScalarDiv(click->fCurr.fX + SK_Scalar1, this->width() - SK_Scalar1*2); percent = SkMaxScalar(0, SkMinScalar(percent, SK_Scalar1)); this->setValue(SkScalarRound(percent * fMax)); return true; } return false; }
SkBBoxHierarchy* SkPicture::createBBoxHierarchy() const { // These values were empirically determined to produce reasonable // performance in most cases. static const int kRTreeMinChildren = 6; static const int kRTreeMaxChildren = 11; SkScalar aspectRatio = SkScalarDiv(SkIntToScalar(fWidth), SkIntToScalar(fHeight)); return SkRTree::Create(kRTreeMinChildren, kRTreeMaxChildren, aspectRatio); }