SkDashPath.cpp File Reference

#include "src/utils/SkDashPathPriv.h"
#include "include/core/SkPaint.h"
#include "include/core/SkPath.h"
#include "include/core/SkPathEffect.h"
#include "include/core/SkPathMeasure.h"
#include "include/core/SkPoint.h"
#include "include/core/SkRect.h"
#include "include/core/SkScalar.h"
#include "include/core/SkStrokeRec.h"
#include "include/core/SkTypes.h"
#include "include/private/base/SkAlign.h"
#include "include/private/base/SkFloatingPoint.h"
#include "include/private/base/SkTo.h"
#include "src/core/SkPathEnums.h"
#include "src/core/SkPathPriv.h"
#include "src/core/SkPointPriv.h"
#include <algorithm>
#include <cmath>
#include <cstdint>
#include <iterator>

Go to the source code of this file.

Classes
class	SpecialLineRec

Functions
static int	is_even (int x)
static SkScalar	find_first_interval (const SkScalar intervals[], SkScalar phase, int32_t *index, int count)
static void	outset_for_stroke (SkRect *rect, const SkStrokeRec &rec)
static void	adjust_zero_length_line (SkPoint pts[2])
static bool	clip_line (SkPoint pts[2], const SkRect &bounds, SkScalar intervalLength, SkScalar priorPhase)
static bool	cull_path (const SkPath &srcPath, const SkStrokeRec &rec, const SkRect *cullRect, SkScalar intervalLength, SkPath *dstPath)

Function Documentation

adjust_zero_length_line()

static void adjust_zero_length_line ( SkPoint  pts[2] )

static

Definition at line 109 of file SkDashPath.cpp.

                                                    {
    SkASSERT(pts[0] == pts[1]);
    pts[1].fX += std::max(1.001f, pts[1].fX) * SK_ScalarNearlyZero;
}

clip_line()

static bool clip_line ( SkPoint  pts[2], const SkRect &  bounds, SkScalar  intervalLength, SkScalar  priorPhase  )

static

Definition at line 114 of file SkDashPath.cpp.

                                           {
    SkVector dxy = pts[1] - pts[0];
 
    // only horizontal or vertical lines
    if (dxy.fX && dxy.fY) {
        return false;
    }
    int xyOffset = SkToBool(dxy.fY);  // 0 to adjust horizontal, 1 to adjust vertical
 
    SkScalar minXY = (&pts[0].fX)[xyOffset];
    SkScalar maxXY = (&pts[1].fX)[xyOffset];
    bool swapped = maxXY < minXY;
    if (swapped) {
        using std::swap;
        swap(minXY, maxXY);
    }
 
    SkASSERT(minXY <= maxXY);
    SkScalar leftTop = (&bounds.fLeft)[xyOffset];
    SkScalar rightBottom = (&bounds.fRight)[xyOffset];
    if (maxXY < leftTop || minXY > rightBottom) {
        return false;
    }
 
    // Now we actually perform the chop, removing the excess to the left/top and
    // right/bottom of the bounds (keeping our new line "in phase" with the dash,
    // hence the (mod intervalLength).
 
    if (minXY < leftTop) {
        minXY = leftTop - SkScalarMod(leftTop - minXY, intervalLength);
        if (!swapped) {
            minXY -= priorPhase;  // for rectangles, adjust by prior phase
        }
    }
    if (maxXY > rightBottom) {
        maxXY = rightBottom + SkScalarMod(maxXY - rightBottom, intervalLength);
        if (swapped) {
            maxXY += priorPhase;  // for rectangles, adjust by prior phase
        }
    }
 
    SkASSERT(maxXY >= minXY);
    if (swapped) {
        using std::swap;
        swap(minXY, maxXY);
    }
    (&pts[0].fX)[xyOffset] = minXY;
    (&pts[1].fX)[xyOffset] = maxXY;
 
    if (minXY == maxXY) {
        adjust_zero_length_line(pts);
    }
    return true;
}

cull_path()

static bool cull_path ( const SkPath &  srcPath, const SkStrokeRec &  rec, const SkRect *  cullRect, SkScalar  intervalLength, SkPath *  dstPath  )

static

Definition at line 173 of file SkDashPath.cpp.

                                                                                        {
    if (!cullRect) {
        SkPoint pts[2];
        if (srcPath.isLine(pts) && pts[0] == pts[1]) {
            adjust_zero_length_line(pts);
            dstPath->moveTo(pts[0]);
            dstPath->lineTo(pts[1]);
            return true;
        }
        return false;
    }
 
    SkRect bounds;
    bounds = *cullRect;
    outset_for_stroke(&bounds, rec);
 
    {
        SkPoint pts[2];
        if (srcPath.isLine(pts)) {
            if (clip_line(pts, bounds, intervalLength, 0)) {
                dstPath->moveTo(pts[0]);
                dstPath->lineTo(pts[1]);
                return true;
            }
            return false;
        }
    }
 
    if (srcPath.isRect(nullptr)) {
        // We'll break the rect into four lines, culling each separately.
        SkPath::Iter iter(srcPath, false);
 
        SkPoint pts[4];  // Rects are all moveTo and lineTo, so we'll only use pts[0] and pts[1].
        SkAssertResult(SkPath::kMove_Verb == iter.next(pts));
 
        double accum = 0;  // Sum of unculled edge lengths to keep the phase correct.
                           // Intentionally a double to minimize the risk of overflow and drift.
        while (iter.next(pts) == SkPath::kLine_Verb) {
            // Notice this vector v and accum work with the original unclipped length.
            SkVector v = pts[1] - pts[0];
 
            if (clip_line(pts, bounds, intervalLength, std::fmod(accum, intervalLength))) {
                // pts[0] may have just been changed by clip_line().
                // If that's not where we ended the previous lineTo(), we need to moveTo() there.
                SkPoint last;
                if (!dstPath->getLastPt(&last) || last != pts[0]) {
                    dstPath->moveTo(pts[0]);
                }
                dstPath->lineTo(pts[1]);
            }
 
            // We either just traveled v.fX horizontally or v.fY vertically.
            SkASSERT(v.fX == 0 || v.fY == 0);
            accum += SkScalarAbs(v.fX + v.fY);
        }
        return !dstPath->isEmpty();
    }
 
    return false;
}

find_first_interval()

static SkScalar find_first_interval ( const SkScalar  intervals[], SkScalar  phase, int32_t *  index, int  count  )

static

Definition at line 35 of file SkDashPath.cpp.

                                                               {
    for (int i = 0; i < count; ++i) {
        SkScalar gap = intervals[i];
        if (phase > gap || (phase == gap && gap)) {
            phase -= gap;
        } else {
            *index = i;
            return gap - phase;
        }
    }
    // If we get here, phase "appears" to be larger than our length. This
    // shouldn't happen with perfect precision, but we can accumulate errors
    // during the initial length computation (rounding can make our sum be too
    // big or too small. In that event, we just have to eat the error here.
    *index = 0;
    return intervals[0];
}

is_even()

static int is_even ( int  x )

inlinestatic

Definition at line 31 of file SkDashPath.cpp.

                                 {
    return !(x & 1);
}

outset_for_stroke()

static void outset_for_stroke ( SkRect *  rect, const SkStrokeRec &  rec  )

static

Definition at line 93 of file SkDashPath.cpp.

                                                                    {
    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);
}