diff options
Diffstat (limited to 'gfx/skia/skia/src/effects/SkDashPathEffect.cpp')
-rw-r--r-- | gfx/skia/skia/src/effects/SkDashPathEffect.cpp | 413 |
1 files changed, 413 insertions, 0 deletions
diff --git a/gfx/skia/skia/src/effects/SkDashPathEffect.cpp b/gfx/skia/skia/src/effects/SkDashPathEffect.cpp new file mode 100644 index 0000000000..49ed5fea1c --- /dev/null +++ b/gfx/skia/skia/src/effects/SkDashPathEffect.cpp @@ -0,0 +1,413 @@ +/* + * Copyright 2006 The Android Open Source Project + * + * Use of this source code is governed by a BSD-style license that can be + * found in the LICENSE file. + */ + +#include "include/effects/SkDashPathEffect.h" + +#include "include/core/SkFlattenable.h" +#include "include/core/SkMatrix.h" +#include "include/core/SkPaint.h" +#include "include/core/SkPath.h" +#include "include/core/SkPathEffect.h" +#include "include/core/SkPoint.h" +#include "include/core/SkRect.h" +#include "include/core/SkStrokeRec.h" +#include "include/private/base/SkAlign.h" +#include "include/private/base/SkMalloc.h" +#include "include/private/base/SkTemplates.h" +#include "include/private/base/SkTo.h" +#include "src/core/SkReadBuffer.h" +#include "src/core/SkWriteBuffer.h" +#include "src/effects/SkDashImpl.h" +#include "src/utils/SkDashPathPriv.h" + +#include <algorithm> +#include <cstdint> +#include <cstring> + +using namespace skia_private; + +SkDashImpl::SkDashImpl(const SkScalar intervals[], int count, SkScalar phase) + : fPhase(0) + , fInitialDashLength(-1) + , fInitialDashIndex(0) + , fIntervalLength(0) { + SkASSERT(intervals); + SkASSERT(count > 1 && SkIsAlign2(count)); + + fIntervals = (SkScalar*)sk_malloc_throw(sizeof(SkScalar) * count); + fCount = count; + for (int i = 0; i < count; i++) { + fIntervals[i] = intervals[i]; + } + + // set the internal data members + SkDashPath::CalcDashParameters(phase, fIntervals, fCount, + &fInitialDashLength, &fInitialDashIndex, &fIntervalLength, &fPhase); +} + +SkDashImpl::~SkDashImpl() { + sk_free(fIntervals); +} + +bool SkDashImpl::onFilterPath(SkPath* dst, const SkPath& src, SkStrokeRec* rec, + const SkRect* cullRect, const SkMatrix&) const { + return SkDashPath::InternalFilter(dst, src, rec, cullRect, fIntervals, fCount, + fInitialDashLength, fInitialDashIndex, fIntervalLength, + fPhase); +} + +static void outset_for_stroke(SkRect* rect, const SkStrokeRec& rec) { + SkScalar radius = SkScalarHalf(rec.getWidth()); + if (0 == radius) { + radius = SK_Scalar1; // hairlines + } + if (SkPaint::kMiter_Join == rec.getJoin()) { + radius *= rec.getMiter(); + } + rect->outset(radius, radius); +} + +// Attempt to trim the line to minimally cover the cull rect (currently +// only works for horizontal and vertical lines). +// Return true if processing should continue; false otherwise. +static bool cull_line(SkPoint* pts, const SkStrokeRec& rec, + const SkMatrix& ctm, const SkRect* cullRect, + const SkScalar intervalLength) { + if (nullptr == cullRect) { + SkASSERT(false); // Shouldn't ever occur in practice + return false; + } + + SkScalar dx = pts[1].x() - pts[0].x(); + SkScalar dy = pts[1].y() - pts[0].y(); + + if ((dx && dy) || (!dx && !dy)) { + return false; + } + + SkRect bounds = *cullRect; + outset_for_stroke(&bounds, rec); + + // cullRect is in device space while pts are in the local coordinate system + // defined by the ctm. We want our answer in the local coordinate system. + + SkASSERT(ctm.rectStaysRect()); + SkMatrix inv; + if (!ctm.invert(&inv)) { + return false; + } + + inv.mapRect(&bounds); + + if (dx) { + SkASSERT(dx && !dy); + SkScalar minX = pts[0].fX; + SkScalar maxX = pts[1].fX; + + if (dx < 0) { + using std::swap; + swap(minX, maxX); + } + + SkASSERT(minX < maxX); + if (maxX <= bounds.fLeft || minX >= bounds.fRight) { + return false; + } + + // Now we actually perform the chop, removing the excess to the left and + // right of the bounds (keeping our new line "in phase" with the dash, + // hence the (mod intervalLength). + + if (minX < bounds.fLeft) { + minX = bounds.fLeft - SkScalarMod(bounds.fLeft - minX, intervalLength); + } + if (maxX > bounds.fRight) { + maxX = bounds.fRight + SkScalarMod(maxX - bounds.fRight, intervalLength); + } + + SkASSERT(maxX > minX); + if (dx < 0) { + using std::swap; + swap(minX, maxX); + } + pts[0].fX = minX; + pts[1].fX = maxX; + } else { + SkASSERT(dy && !dx); + SkScalar minY = pts[0].fY; + SkScalar maxY = pts[1].fY; + + if (dy < 0) { + using std::swap; + swap(minY, maxY); + } + + SkASSERT(minY < maxY); + if (maxY <= bounds.fTop || minY >= bounds.fBottom) { + return false; + } + + // Now we actually perform the chop, removing the excess to the top and + // bottom of the bounds (keeping our new line "in phase" with the dash, + // hence the (mod intervalLength). + + if (minY < bounds.fTop) { + minY = bounds.fTop - SkScalarMod(bounds.fTop - minY, intervalLength); + } + if (maxY > bounds.fBottom) { + maxY = bounds.fBottom + SkScalarMod(maxY - bounds.fBottom, intervalLength); + } + + SkASSERT(maxY > minY); + if (dy < 0) { + using std::swap; + swap(minY, maxY); + } + pts[0].fY = minY; + pts[1].fY = maxY; + } + + return true; +} + +// Currently asPoints is more restrictive then it needs to be. In the future +// we need to: +// allow kRound_Cap capping (could allow rotations in the matrix with this) +// allow paths to be returned +bool SkDashImpl::onAsPoints(PointData* results, const SkPath& src, const SkStrokeRec& rec, + const SkMatrix& matrix, const SkRect* cullRect) const { + // width < 0 -> fill && width == 0 -> hairline so requiring width > 0 rules both out + if (0 >= rec.getWidth()) { + return false; + } + + // TODO: this next test could be eased up. We could allow any number of + // intervals as long as all the ons match and all the offs match. + // Additionally, they do not necessarily need to be integers. + // We cannot allow arbitrary intervals since we want the returned points + // to be uniformly sized. + if (fCount != 2 || + !SkScalarNearlyEqual(fIntervals[0], fIntervals[1]) || + !SkScalarIsInt(fIntervals[0]) || + !SkScalarIsInt(fIntervals[1])) { + return false; + } + + SkPoint pts[2]; + + if (!src.isLine(pts)) { + return false; + } + + // TODO: this test could be eased up to allow circles + if (SkPaint::kButt_Cap != rec.getCap()) { + return false; + } + + // TODO: this test could be eased up for circles. Rotations could be allowed. + if (!matrix.rectStaysRect()) { + return false; + } + + // See if the line can be limited to something plausible. + if (!cull_line(pts, rec, matrix, cullRect, fIntervalLength)) { + return false; + } + + SkScalar length = SkPoint::Distance(pts[1], pts[0]); + + SkVector tangent = pts[1] - pts[0]; + if (tangent.isZero()) { + return false; + } + + tangent.scale(SkScalarInvert(length)); + + // TODO: make this test for horizontal & vertical lines more robust + bool isXAxis = true; + if (SkScalarNearlyEqual(SK_Scalar1, tangent.fX) || + SkScalarNearlyEqual(-SK_Scalar1, tangent.fX)) { + results->fSize.set(SkScalarHalf(fIntervals[0]), SkScalarHalf(rec.getWidth())); + } else if (SkScalarNearlyEqual(SK_Scalar1, tangent.fY) || + SkScalarNearlyEqual(-SK_Scalar1, tangent.fY)) { + results->fSize.set(SkScalarHalf(rec.getWidth()), SkScalarHalf(fIntervals[0])); + isXAxis = false; + } else if (SkPaint::kRound_Cap != rec.getCap()) { + // Angled lines don't have axis-aligned boxes. + return false; + } + + if (results) { + results->fFlags = 0; + SkScalar clampedInitialDashLength = std::min(length, fInitialDashLength); + + if (SkPaint::kRound_Cap == rec.getCap()) { + results->fFlags |= PointData::kCircles_PointFlag; + } + + results->fNumPoints = 0; + SkScalar len2 = length; + if (clampedInitialDashLength > 0 || 0 == fInitialDashIndex) { + SkASSERT(len2 >= clampedInitialDashLength); + if (0 == fInitialDashIndex) { + if (clampedInitialDashLength > 0) { + if (clampedInitialDashLength >= fIntervals[0]) { + ++results->fNumPoints; // partial first dash + } + len2 -= clampedInitialDashLength; + } + len2 -= fIntervals[1]; // also skip first space + if (len2 < 0) { + len2 = 0; + } + } else { + len2 -= clampedInitialDashLength; // skip initial partial empty + } + } + // Too many midpoints can cause results->fNumPoints to overflow or + // otherwise cause the results->fPoints allocation below to OOM. + // Cap it to a sane value. + SkScalar numIntervals = len2 / fIntervalLength; + if (!SkScalarIsFinite(numIntervals) || numIntervals > SkDashPath::kMaxDashCount) { + return false; + } + int numMidPoints = SkScalarFloorToInt(numIntervals); + results->fNumPoints += numMidPoints; + len2 -= numMidPoints * fIntervalLength; + bool partialLast = false; + if (len2 > 0) { + if (len2 < fIntervals[0]) { + partialLast = true; + } else { + ++numMidPoints; + ++results->fNumPoints; + } + } + + results->fPoints = new SkPoint[results->fNumPoints]; + + SkScalar distance = 0; + int curPt = 0; + + if (clampedInitialDashLength > 0 || 0 == fInitialDashIndex) { + SkASSERT(clampedInitialDashLength <= length); + + if (0 == fInitialDashIndex) { + if (clampedInitialDashLength > 0) { + // partial first block + SkASSERT(SkPaint::kRound_Cap != rec.getCap()); // can't handle partial circles + SkScalar x = pts[0].fX + tangent.fX * SkScalarHalf(clampedInitialDashLength); + SkScalar y = pts[0].fY + tangent.fY * SkScalarHalf(clampedInitialDashLength); + SkScalar halfWidth, halfHeight; + if (isXAxis) { + halfWidth = SkScalarHalf(clampedInitialDashLength); + halfHeight = SkScalarHalf(rec.getWidth()); + } else { + halfWidth = SkScalarHalf(rec.getWidth()); + halfHeight = SkScalarHalf(clampedInitialDashLength); + } + if (clampedInitialDashLength < fIntervals[0]) { + // This one will not be like the others + results->fFirst.addRect(x - halfWidth, y - halfHeight, + x + halfWidth, y + halfHeight); + } else { + SkASSERT(curPt < results->fNumPoints); + results->fPoints[curPt].set(x, y); + ++curPt; + } + + distance += clampedInitialDashLength; + } + + distance += fIntervals[1]; // skip over the next blank block too + } else { + distance += clampedInitialDashLength; + } + } + + if (0 != numMidPoints) { + distance += SkScalarHalf(fIntervals[0]); + + for (int i = 0; i < numMidPoints; ++i) { + SkScalar x = pts[0].fX + tangent.fX * distance; + SkScalar y = pts[0].fY + tangent.fY * distance; + + SkASSERT(curPt < results->fNumPoints); + results->fPoints[curPt].set(x, y); + ++curPt; + + distance += fIntervalLength; + } + + distance -= SkScalarHalf(fIntervals[0]); + } + + if (partialLast) { + // partial final block + SkASSERT(SkPaint::kRound_Cap != rec.getCap()); // can't handle partial circles + SkScalar temp = length - distance; + SkASSERT(temp < fIntervals[0]); + SkScalar x = pts[0].fX + tangent.fX * (distance + SkScalarHalf(temp)); + SkScalar y = pts[0].fY + tangent.fY * (distance + SkScalarHalf(temp)); + SkScalar halfWidth, halfHeight; + if (isXAxis) { + halfWidth = SkScalarHalf(temp); + halfHeight = SkScalarHalf(rec.getWidth()); + } else { + halfWidth = SkScalarHalf(rec.getWidth()); + halfHeight = SkScalarHalf(temp); + } + results->fLast.addRect(x - halfWidth, y - halfHeight, + x + halfWidth, y + halfHeight); + } + + SkASSERT(curPt == results->fNumPoints); + } + + return true; +} + +SkPathEffect::DashType SkDashImpl::onAsADash(DashInfo* info) const { + if (info) { + if (info->fCount >= fCount && info->fIntervals) { + memcpy(info->fIntervals, fIntervals, fCount * sizeof(SkScalar)); + } + info->fCount = fCount; + info->fPhase = fPhase; + } + return kDash_DashType; +} + +void SkDashImpl::flatten(SkWriteBuffer& buffer) const { + buffer.writeScalar(fPhase); + buffer.writeScalarArray(fIntervals, fCount); +} + +sk_sp<SkFlattenable> SkDashImpl::CreateProc(SkReadBuffer& buffer) { + const SkScalar phase = buffer.readScalar(); + uint32_t count = buffer.getArrayCount(); + + // Don't allocate gigantic buffers if there's not data for them. + if (!buffer.validateCanReadN<SkScalar>(count)) { + return nullptr; + } + + AutoSTArray<32, SkScalar> intervals(count); + if (buffer.readScalarArray(intervals.get(), count)) { + return SkDashPathEffect::Make(intervals.get(), SkToInt(count), phase); + } + return nullptr; +} + +////////////////////////////////////////////////////////////////////////////////////////////////// + +sk_sp<SkPathEffect> SkDashPathEffect::Make(const SkScalar intervals[], int count, SkScalar phase) { + if (!SkDashPath::ValidDashPath(phase, intervals, count)) { + return nullptr; + } + return sk_sp<SkPathEffect>(new SkDashImpl(intervals, count, phase)); +} |