SkDashPath Namespace Reference

Enumerations
enum class	StrokeRecApplication { kDisallow , kAllow }

Functions
void	CalcDashParameters (SkScalar phase, const SkScalar intervals[], int32_t count, SkScalar *initialDashLength, int32_t *initialDashIndex, SkScalar *intervalLength, SkScalar *adjustedPhase=nullptr)
bool	FilterDashPath (SkPath *dst, const SkPath &src, SkStrokeRec *, const SkRect *, const SkPathEffect::DashInfo &info)
bool	InternalFilter (SkPath *dst, const SkPath &src, SkStrokeRec *rec, const SkRect *cullRect, const SkScalar aIntervals[], int32_t count, SkScalar initialDashLength, int32_t initialDashIndex, SkScalar intervalLength, SkScalar startPhase, StrokeRecApplication=StrokeRecApplication::kAllow)
bool	ValidDashPath (SkScalar phase, const SkScalar intervals[], int32_t count)

Variables
const SkScalar	kMaxDashCount = 1000000

Enumeration Type Documentation

StrokeRecApplication

enum class SkDashPath::StrokeRecApplication

strong

See comments for InternalFilter

Enumerator
kDisallow
kAllow

Definition at line 36 of file SkDashPathPriv.h.

                                    {
        kDisallow,
        kAllow,
    };

Function Documentation

CalcDashParameters()

void SkDashPath::CalcDashParameters	(	SkScalar	phase,
		const SkScalar	intervals[],
		int32_t	count,
		SkScalar *	initialDashLength,
		int32_t *	initialDashIndex,
		SkScalar *	intervalLength,
		SkScalar *	adjustedPhase = nullptr
	)

Calculates the initialDashLength, initialDashIndex, and intervalLength based on the inputed phase and intervals. If adjustedPhase is passed in, then the phase will be adjusted to be between 0 and intervalLength. The result will be stored in adjustedPhase. If adjustedPhase is nullptr then it is assumed phase is already between 0 and intervalLength

Caller should have already used ValidDashPath to exclude invalid data.

Definition at line 54 of file SkDashPath.cpp.

                                                                                       {
    SkScalar len = 0;
    for (int i = 0; i < count; i++) {
        len += intervals[i];
    }
    *intervalLength = len;
    // Adjust phase to be between 0 and len, "flipping" phase if negative.
    // e.g., if len is 100, then phase of -20 (or -120) is equivalent to 80
    if (adjustedPhase) {
        if (phase < 0) {
            phase = -phase;
            if (phase > len) {
                phase = SkScalarMod(phase, len);
            }
            phase = len - phase;
 
            // Due to finite precision, it's possible that phase == len,
            // even after the subtract (if len >>> phase), so fix that here.
            // This fixes http://crbug.com/124652 .
            SkASSERT(phase <= len);
            if (phase == len) {
                phase = 0;
            }
        } else if (phase >= len) {
            phase = SkScalarMod(phase, len);
        }
        *adjustedPhase = phase;
    }
    SkASSERT(phase >= 0 && phase < len);
 
    *initialDashLength = find_first_interval(intervals, phase,
                                            initialDashIndex, count);
 
    SkASSERT(*initialDashLength >= 0);
    SkASSERT(*initialDashIndex >= 0 && *initialDashIndex < count);
}

FilterDashPath()

bool SkDashPath::FilterDashPath	(	SkPath *	dst,
		const SkPath &	src,
		SkStrokeRec *	rec,
		const SkRect *	cullRect,
		const SkPathEffect::DashInfo &	info
	)

Definition at line 462 of file SkDashPath.cpp.

                                                                                          {
    if (!ValidDashPath(info.fPhase, info.fIntervals, info.fCount)) {
        return false;
    }
    SkScalar initialDashLength = 0;
    int32_t initialDashIndex = 0;
    SkScalar intervalLength = 0;
    CalcDashParameters(info.fPhase, info.fIntervals, info.fCount,
                       &initialDashLength, &initialDashIndex, &intervalLength);
    return InternalFilter(dst, src, rec, cullRect, info.fIntervals, info.fCount, initialDashLength,
                          initialDashIndex, intervalLength, info.fPhase);
}

InternalFilter()

bool SkDashPath::InternalFilter	(	SkPath *	dst,
		const SkPath &	src,
		SkStrokeRec *	rec,
		const SkRect *	cullRect,
		const SkScalar	aIntervals[],
		int32_t	count,
		SkScalar	initialDashLength,
		int32_t	initialDashIndex,
		SkScalar	intervalLength,
		SkScalar	startPhase,
		StrokeRecApplication	strokeRecApplication = StrokeRecApplication::kAllow
	)

Caller should have already used ValidDashPath to exclude invalid data. Typically, this leaves the strokeRec unmodified. However, for some simple shapes (e.g. a line) it may directly evaluate the dash and stroke to produce a stroked output path with a fill strokeRec. Passing true for disallowStrokeRecApplication turns this behavior off.

Definition at line 309 of file SkDashPath.cpp.

                                                                           {
    // we must always have an even number of intervals
    SkASSERT(is_even(count));
 
    // we do nothing if the src wants to be filled
    SkStrokeRec::Style style = rec->getStyle();
    if (SkStrokeRec::kFill_Style == style || SkStrokeRec::kStrokeAndFill_Style == style) {
        return false;
    }
 
    const SkScalar* intervals = aIntervals;
    SkScalar        dashCount = 0;
    int             segCount = 0;
 
    SkPath cullPathStorage;
    const SkPath* srcPtr = &src;
    if (cull_path(src, *rec, cullRect, intervalLength, &cullPathStorage)) {
        // if rect is closed, starts in a dash, and ends in a dash, add the initial join
        // potentially a better fix is described here: bug.skia.org/7445
        if (src.isRect(nullptr) && src.isLastContourClosed() && is_even(initialDashIndex)) {
            SkScalar pathLength = SkPathMeasure(src, false, rec->getResScale()).getLength();
#if defined(SK_LEGACY_RECT_DASHING_BUG)
            SkScalar endPhase = SkScalarMod(pathLength + initialDashLength, intervalLength);
#else
            SkScalar endPhase = SkScalarMod(pathLength + startPhase, intervalLength);
#endif
            int index = 0;
            while (endPhase > intervals[index]) {
                endPhase -= intervals[index++];
                SkASSERT(index <= count);
                if (index == count) {
                    // We have run out of intervals. endPhase "should" never get to this point,
                    // but it could if the subtracts underflowed. Hence we will pin it as if it
                    // perfectly ran through the intervals.
                    // See crbug.com/875494 (and skbug.com/8274)
                    endPhase = 0;
                    break;
                }
            }
            // if dash ends inside "on", or ends at beginning of "off"
            if (is_even(index) == (endPhase > 0)) {
                SkPoint midPoint = src.getPoint(0);
                // get vector at end of rect
                int last = src.countPoints() - 1;
                while (midPoint == src.getPoint(last)) {
                    --last;
                    SkASSERT(last >= 0);
                }
                // get vector at start of rect
                int next = 1;
                while (midPoint == src.getPoint(next)) {
                    ++next;
                    SkASSERT(next < last);
                }
                SkVector v = midPoint - src.getPoint(last);
                const SkScalar kTinyOffset = SK_ScalarNearlyZero;
                // scale vector to make start of tiny right angle
                v *= kTinyOffset;
                cullPathStorage.moveTo(midPoint - v);
                cullPathStorage.lineTo(midPoint);
                v = midPoint - src.getPoint(next);
                // scale vector to make end of tiny right angle
                v *= kTinyOffset;
                cullPathStorage.lineTo(midPoint - v);
            }
        }
        srcPtr = &cullPathStorage;
    }
 
    SpecialLineRec lineRec;
    bool specialLine = (StrokeRecApplication::kAllow == strokeRecApplication) &&
                       lineRec.init(*srcPtr, dst, rec, count >> 1, intervalLength);
 
    SkPathMeasure   meas(*srcPtr, false, rec->getResScale());
 
    do {
        bool        skipFirstSegment = meas.isClosed();
        bool        addedSegment = false;
        SkScalar    length = meas.getLength();
        int         index = initialDashIndex;
 
        // Since the path length / dash length ratio may be arbitrarily large, we can exert
        // significant memory pressure while attempting to build the filtered path. To avoid this,
        // we simply give up dashing beyond a certain threshold.
        //
        // The original bug report (http://crbug.com/165432) is based on a path yielding more than
        // 90 million dash segments and crashing the memory allocator. A limit of 1 million
        // segments seems reasonable: at 2 verbs per segment * 9 bytes per verb, this caps the
        // maximum dash memory overhead at roughly 17MB per path.
        dashCount += length * (count >> 1) / intervalLength;
        if (dashCount > kMaxDashCount) {
            dst->reset();
            return false;
        }
 
        // Using double precision to avoid looping indefinitely due to single precision rounding
        // (for extreme path_length/dash_length ratios). See test_infinite_dash() unittest.
        double  distance = 0;
        double  dlen = initialDashLength;
 
        while (distance < length) {
            SkASSERT(dlen >= 0);
            addedSegment = false;
            if (is_even(index) && !skipFirstSegment) {
                addedSegment = true;
                ++segCount;
 
                if (specialLine) {
                    lineRec.addSegment(SkDoubleToScalar(distance),
                                       SkDoubleToScalar(distance + dlen),
                                       dst);
                } else {
                    meas.getSegment(SkDoubleToScalar(distance),
                                    SkDoubleToScalar(distance + dlen),
                                    dst, true);
                }
            }
            distance += dlen;
 
            // clear this so we only respect it the first time around
            skipFirstSegment = false;
 
            // wrap around our intervals array if necessary
            index += 1;
            SkASSERT(index <= count);
            if (index == count) {
                index = 0;
            }
 
            // fetch our next dlen
            dlen = intervals[index];
        }
 
        // extend if we ended on a segment and we need to join up with the (skipped) initial segment
        if (meas.isClosed() && is_even(initialDashIndex) &&
            initialDashLength >= 0) {
            meas.getSegment(0, initialDashLength, dst, !addedSegment);
            ++segCount;
        }
    } while (meas.nextContour());
 
    // TODO: do we still need this?
    if (segCount > 1) {
        SkPathPriv::SetConvexity(*dst, SkPathConvexity::kConcave);
    }
 
    return true;
}

ValidDashPath()

bool SkDashPath::ValidDashPath	(	SkScalar	phase,
		const SkScalar	intervals[],
		int32_t	count
	)

Definition at line 476 of file SkDashPath.cpp.

                                                                                        {
    if (count < 2 || !SkIsAlign2(count)) {
        return false;
    }
    SkScalar length = 0;
    for (int i = 0; i < count; i++) {
        if (intervals[i] < 0) {
            return false;
        }
        length += intervals[i];
    }
    // watch out for values that might make us go out of bounds
    return length > 0 && SkIsFinite(phase, length);
}

Variable Documentation

kMaxDashCount

const SkScalar SkDashPath::kMaxDashCount = 1000000

Definition at line 32 of file SkDashPathPriv.h.