SkPathBuilder Class Reference

#include <SkPathBuilder.h>

Public Types
enum	ArcSize { kSmall_ArcSize , kLarge_ArcSize }

Public Member Functions
	SkPathBuilder ()
	SkPathBuilder (SkPathFillType)
	SkPathBuilder (const SkPath &)
	SkPathBuilder (const SkPathBuilder &)=default
	~SkPathBuilder ()
SkPathBuilder &	operator= (const SkPath &)
SkPathBuilder &	operator= (const SkPathBuilder &)=default
SkPathFillType	fillType () const
SkRect	computeBounds () const
SkPath	snapshot () const
SkPath	detach ()
SkPathBuilder &	setFillType (SkPathFillType ft)
SkPathBuilder &	setIsVolatile (bool isVolatile)
SkPathBuilder &	reset ()
SkPathBuilder &	moveTo (SkPoint pt)
SkPathBuilder &	moveTo (SkScalar x, SkScalar y)
SkPathBuilder &	lineTo (SkPoint pt)
SkPathBuilder &	lineTo (SkScalar x, SkScalar y)
SkPathBuilder &	quadTo (SkPoint pt1, SkPoint pt2)
SkPathBuilder &	quadTo (SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2)
SkPathBuilder &	quadTo (const SkPoint pts[2])
SkPathBuilder &	conicTo (SkPoint pt1, SkPoint pt2, SkScalar w)
SkPathBuilder &	conicTo (SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2, SkScalar w)
SkPathBuilder &	conicTo (const SkPoint pts[2], SkScalar w)
SkPathBuilder &	cubicTo (SkPoint pt1, SkPoint pt2, SkPoint pt3)
SkPathBuilder &	cubicTo (SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2, SkScalar x3, SkScalar y3)
SkPathBuilder &	cubicTo (const SkPoint pts[3])
SkPathBuilder &	close ()
SkPathBuilder &	polylineTo (const SkPoint pts[], int count)
SkPathBuilder &	polylineTo (const std::initializer_list< SkPoint > &list)
SkPathBuilder &	rLineTo (SkPoint pt)
SkPathBuilder &	rLineTo (SkScalar x, SkScalar y)
SkPathBuilder &	rQuadTo (SkPoint pt1, SkPoint pt2)
SkPathBuilder &	rQuadTo (SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2)
SkPathBuilder &	rConicTo (SkPoint p1, SkPoint p2, SkScalar w)
SkPathBuilder &	rConicTo (SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2, SkScalar w)
SkPathBuilder &	rCubicTo (SkPoint pt1, SkPoint pt2, SkPoint pt3)
SkPathBuilder &	rCubicTo (SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2, SkScalar x3, SkScalar y3)
SkPathBuilder &	arcTo (const SkRect &oval, SkScalar startAngleDeg, SkScalar sweepAngleDeg, bool forceMoveTo)
SkPathBuilder &	arcTo (SkPoint p1, SkPoint p2, SkScalar radius)
SkPathBuilder &	arcTo (SkPoint r, SkScalar xAxisRotate, ArcSize largeArc, SkPathDirection sweep, SkPoint xy)
SkPathBuilder &	addArc (const SkRect &oval, SkScalar startAngleDeg, SkScalar sweepAngleDeg)
SkPathBuilder &	addRect (const SkRect &, SkPathDirection, unsigned startIndex)
SkPathBuilder &	addOval (const SkRect &, SkPathDirection, unsigned startIndex)
SkPathBuilder &	addRRect (const SkRRect &, SkPathDirection, unsigned startIndex)
SkPathBuilder &	addRect (const SkRect &rect, SkPathDirection dir=SkPathDirection::kCW)
SkPathBuilder &	addOval (const SkRect &rect, SkPathDirection dir=SkPathDirection::kCW)
SkPathBuilder &	addRRect (const SkRRect &rrect, SkPathDirection dir=SkPathDirection::kCW)
SkPathBuilder &	addCircle (SkScalar center_x, SkScalar center_y, SkScalar radius, SkPathDirection dir=SkPathDirection::kCW)
SkPathBuilder &	addPolygon (const SkPoint pts[], int count, bool isClosed)
SkPathBuilder &	addPolygon (const std::initializer_list< SkPoint > &list, bool isClosed)
SkPathBuilder &	addPath (const SkPath &)
void	incReserve (int extraPtCount, int extraVerbCount)
void	incReserve (int extraPtCount)
SkPathBuilder &	offset (SkScalar dx, SkScalar dy)
SkPathBuilder &	toggleInverseFillType ()

Friends
class	SkPathPriv

Detailed Description

Definition at line 25 of file SkPathBuilder.h.

Member Enumeration Documentation

ArcSize

enum SkPathBuilder::ArcSize

Enumerator
kSmall_ArcSize	smaller of arc pair
kLarge_ArcSize	larger of arc pair

Definition at line 141 of file SkPathBuilder.h.

                 {
        kSmall_ArcSize, //!< smaller of arc pair
        kLarge_ArcSize, //!< larger of arc pair
    };

Constructor & Destructor Documentation

SkPathBuilder() [1/4]

SkPathBuilder::SkPathBuilder

(

)

Definition at line 27 of file SkPathBuilder.cpp.

                             {
    this->reset();
}

SkPathBuilder() [2/4]

SkPathBuilder::SkPathBuilder

(

SkPathFillType

ft

)

Definition at line 31 of file SkPathBuilder.cpp.

                                              {
    this->reset();
    fFillType = ft;
}

SkPathBuilder() [3/4]

SkPathBuilder::SkPathBuilder

(

const SkPath &

src

)

Definition at line 36 of file SkPathBuilder.cpp.

                                              {
    *this = src;
}

SkPathBuilder() [4/4]

SkPathBuilder::SkPathBuilder ( const SkPathBuilder &  )

default

~SkPathBuilder()

SkPathBuilder::~SkPathBuilder

(

)

Definition at line 40 of file SkPathBuilder.cpp.

                              {
}

Member Function Documentation

addArc()

SkPathBuilder & SkPathBuilder::addArc	(	const SkRect &	oval,
		SkScalar	startAngleDeg,
		SkScalar	sweepAngleDeg
	)

Appends arc to the builder, as the start of new contour. Arc added is part of ellipse bounded by oval, from startAngle through sweepAngle. Both startAngle and sweepAngle are measured in degrees, where zero degrees is aligned with the positive x-axis, and positive sweeps extends arc clockwise.

If sweepAngle <= -360, or sweepAngle >= 360; and startAngle modulo 90 is nearly zero, append oval instead of arc. Otherwise, sweepAngle values are treated modulo 360, and arc may or may not draw depending on numeric rounding.

Parameters

oval	bounds of ellipse containing arc
startAngleDeg	starting angle of arc in degrees
sweepAngleDeg	sweep, in degrees. Positive is clockwise; treated modulo 360

Returns

reference to this builder

Definition at line 394 of file SkPathBuilder.cpp.

                                                                                                 {
    if (oval.isEmpty() || 0 == sweepAngle) {
        return *this;
    }
 
    const SkScalar kFullCircleAngle = SkIntToScalar(360);
 
    if (sweepAngle >= kFullCircleAngle || sweepAngle <= -kFullCircleAngle) {
        // We can treat the arc as an oval if it begins at one of our legal starting positions.
        // See SkPath::addOval() docs.
        SkScalar startOver90 = startAngle / 90.f;
        SkScalar startOver90I = SkScalarRoundToScalar(startOver90);
        SkScalar error = startOver90 - startOver90I;
        if (SkScalarNearlyEqual(error, 0)) {
            // Index 1 is at startAngle == 0.
            SkScalar startIndex = std::fmod(startOver90I + 1.f, 4.f);
            startIndex = startIndex < 0 ? startIndex + 4.f : startIndex;
            return this->addOval(oval, sweepAngle > 0 ? SkPathDirection::kCW : SkPathDirection::kCCW,
                                 (unsigned) startIndex);
        }
    }
    return this->arcTo(oval, startAngle, sweepAngle, true);
}

addCircle()

SkPathBuilder & SkPathBuilder::addCircle	(	SkScalar	center_x,
		SkScalar	center_y,
		SkScalar	radius,
		SkPathDirection	dir = SkPathDirection::kCW
	)

Definition at line 759 of file SkPathBuilder.cpp.

                                                                                               {
    if (r >= 0) {
        this->addOval(SkRect::MakeLTRB(x - r, y - r, x + r, y + r), dir);
    }
    return *this;
}

addOval() [1/2]

SkPathBuilder & SkPathBuilder::addOval	(	const SkRect &	oval,
		SkPathDirection	dir,
		unsigned	startIndex
	)

Definition at line 682 of file SkPathBuilder.cpp.

                                                                                             {
    const IsA prevIsA = fIsA;
 
    const int kPts   = 9;   // moveTo + 4 conics(2 pts each)
    const int kVerbs = 6;   // moveTo + 4 conics + close
    this->incReserve(kPts, kVerbs);
 
    OvalPointIterator ovalIter(oval, dir, index);
    RectPointIterator rectIter(oval, dir, index + (dir == SkPathDirection::kCW ? 0 : 1));
 
    // The corner iterator pts are tracking "behind" the oval/radii pts.
 
    this->moveTo(ovalIter.current());
    for (unsigned i = 0; i < 4; ++i) {
        this->conicTo(rectIter.next(), ovalIter.next(), SK_ScalarRoot2Over2);
    }
    this->close();
 
    if (prevIsA == kIsA_JustMoves) {
        fIsA      = kIsA_Oval;
        fIsACCW   = (dir == SkPathDirection::kCCW);
        fIsAStart = index % 4;
    }
    return *this;
}

addOval() [2/2]

SkPathBuilder & SkPathBuilder::addOval ( const SkRect &  rect, SkPathDirection  dir = SkPathDirection::kCW  )

inline

Definition at line 197 of file SkPathBuilder.h.

                                                                                         {
        // legacy start index: 1
        return this->addOval(rect, dir, 1);
    }

addPath()

SkPathBuilder & SkPathBuilder::addPath

(

const SkPath &

src

)

Definition at line 800 of file SkPathBuilder.cpp.

                                                       {
    SkPath::RawIter iter(src);
    SkPoint pts[4];
    SkPath::Verb verb;
 
    while ((verb = iter.next(pts)) != SkPath::kDone_Verb) {
        switch (verb) {
            case SkPath::kMove_Verb:  this->moveTo (pts[0]); break;
            case SkPath::kLine_Verb:  this->lineTo (pts[1]); break;
            case SkPath::kQuad_Verb:  this->quadTo (pts[1], pts[2]); break;
            case SkPath::kCubic_Verb: this->cubicTo(pts[1], pts[2], pts[3]); break;
            case SkPath::kConic_Verb: this->conicTo(pts[1], pts[2], iter.conicWeight()); break;
            case SkPath::kClose_Verb: this->close(); break;
            case SkPath::kDone_Verb: SkUNREACHABLE;
        }
    }
 
    return *this;
}

addPolygon() [1/2]

SkPathBuilder & SkPathBuilder::addPolygon	(	const SkPoint	pts[],
		int	count,
		bool	isClosed
	)

Definition at line 766 of file SkPathBuilder.cpp.

                                                                                      {
    if (count <= 0) {
        return *this;
    }
 
    this->moveTo(pts[0]);
    this->polylineTo(&pts[1], count - 1);
    if (isClosed) {
        this->close();
    }
    return *this;
}

addPolygon() [2/2]

SkPathBuilder & SkPathBuilder::addPolygon ( const std::initializer_list< SkPoint > &  list, bool  isClosed  )

inline

Definition at line 210 of file SkPathBuilder.h.

                                                                                       {
        return this->addPolygon(list.begin(), SkToInt(list.size()), isClosed);
    }

addRect() [1/2]

SkPathBuilder & SkPathBuilder::addRect	(	const SkRect &	rect,
		SkPathDirection	dir,
		unsigned	startIndex
	)

Definition at line 668 of file SkPathBuilder.cpp.

                                                                                             {
    const int kPts   = 4;   // moveTo + 3 lines
    const int kVerbs = 5;   // moveTo + 3 lines + close
    this->incReserve(kPts, kVerbs);
 
    RectPointIterator iter(rect, dir, index);
 
    this->moveTo(iter.current());
    this->lineTo(iter.next());
    this->lineTo(iter.next());
    this->lineTo(iter.next());
    return this->close();
}

addRect() [2/2]

SkPathBuilder & SkPathBuilder::addRect ( const SkRect &  rect, SkPathDirection  dir = SkPathDirection::kCW  )

inline

Definition at line 194 of file SkPathBuilder.h.

                                                                                         {
        return this->addRect(rect, dir, 0);
    }

addRRect() [1/2]

SkPathBuilder & SkPathBuilder::addRRect	(	const SkRRect &	rrect,
		SkPathDirection	dir,
		unsigned	startIndex
	)

Definition at line 708 of file SkPathBuilder.cpp.

                                                                                                {
    const IsA prevIsA = fIsA;
    const SkRect& bounds = rrect.getBounds();
 
    if (rrect.isRect() || rrect.isEmpty()) {
        // degenerate(rect) => radii points are collapsing
        this->addRect(bounds, dir, (index + 1) / 2);
    } else if (rrect.isOval()) {
        // degenerate(oval) => line points are collapsing
        this->addOval(bounds, dir, index / 2);
    } else {
        // we start with a conic on odd indices when moving CW vs. even indices when moving CCW
        const bool startsWithConic = ((index & 1) == (dir == SkPathDirection::kCW));
        const SkScalar weight = SK_ScalarRoot2Over2;
 
        const int kVerbs = startsWithConic
            ? 9   // moveTo + 4x conicTo + 3x lineTo + close
            : 10; // moveTo + 4x lineTo + 4x conicTo + close
        this->incReserve(kVerbs);
 
        RRectPointIterator rrectIter(rrect, dir, index);
        // Corner iterator indices follow the collapsed radii model,
        // adjusted such that the start pt is "behind" the radii start pt.
        const unsigned rectStartIndex = index / 2 + (dir == SkPathDirection::kCW ? 0 : 1);
        RectPointIterator rectIter(bounds, dir, rectStartIndex);
 
        this->moveTo(rrectIter.current());
        if (startsWithConic) {
            for (unsigned i = 0; i < 3; ++i) {
                this->conicTo(rectIter.next(), rrectIter.next(), weight);
                this->lineTo(rrectIter.next());
            }
            this->conicTo(rectIter.next(), rrectIter.next(), weight);
            // final lineTo handled by close().
        } else {
            for (unsigned i = 0; i < 4; ++i) {
                this->lineTo(rrectIter.next());
                this->conicTo(rectIter.next(), rrectIter.next(), weight);
            }
        }
        this->close();
    }
 
    if (prevIsA == kIsA_JustMoves) {
        fIsA      = kIsA_RRect;
        fIsACCW   = (dir == SkPathDirection::kCCW);
        fIsAStart = index % 8;
    }
    return *this;
}

addRRect() [2/2]

SkPathBuilder & SkPathBuilder::addRRect ( const SkRRect &  rrect, SkPathDirection  dir = SkPathDirection::kCW  )

inline

Definition at line 201 of file SkPathBuilder.h.

                                                                                            {
        // legacy start indices: 6 (CW) and 7 (CCW)
        return this->addRRect(rrect, dir, dir == SkPathDirection::kCW ? 6 : 7);
    }

arcTo() [1/3]

SkPathBuilder & SkPathBuilder::arcTo	(	const SkRect &	oval,
		SkScalar	startAngleDeg,
		SkScalar	sweepAngleDeg,
		bool	forceMoveTo
	)

Appends arc to the builder. Arc added is part of ellipse bounded by oval, from startAngle through sweepAngle. Both startAngle and sweepAngle are measured in degrees, where zero degrees is aligned with the positive x-axis, and positive sweeps extends arc clockwise.

arcTo() adds line connecting the builder's last point to initial arc point if forceMoveTo is false and the builder is not empty. Otherwise, added contour begins with first point of arc. Angles greater than -360 and less than 360 are treated modulo 360.

Parameters

oval	bounds of ellipse containing arc
startAngleDeg	starting angle of arc in degrees
sweepAngleDeg	sweep, in degrees. Positive is clockwise; treated modulo 360
forceMoveTo	true to start a new contour with arc

Returns

reference to the builder

Definition at line 331 of file SkPathBuilder.cpp.

                                                      {
    if (oval.width() < 0 || oval.height() < 0) {
        return *this;
    }
 
    if (fVerbs.empty()) {
        forceMoveTo = true;
    }
 
    SkPoint lonePt;
    if (arc_is_lone_point(oval, startAngle, sweepAngle, &lonePt)) {
        return forceMoveTo ? this->moveTo(lonePt) : this->lineTo(lonePt);
    }
 
    SkVector startV, stopV;
    SkRotationDirection dir;
    angles_to_unit_vectors(startAngle, sweepAngle, &startV, &stopV, &dir);
 
    SkPoint singlePt;
 
    // Adds a move-to to 'pt' if forceMoveTo is true. Otherwise a lineTo unless we're sufficiently
    // close to 'pt' currently. This prevents spurious lineTos when adding a series of contiguous
    // arcs from the same oval.
    auto addPt = [forceMoveTo, this](const SkPoint& pt) {
        if (forceMoveTo) {
            this->moveTo(pt);
        } else if (!nearly_equal(fPts.back(), pt)) {
            this->lineTo(pt);
        }
    };
 
    // At this point, we know that the arc is not a lone point, but startV == stopV
    // indicates that the sweepAngle is too small such that angles_to_unit_vectors
    // cannot handle it.
    if (startV == stopV) {
        SkScalar endAngle = SkDegreesToRadians(startAngle + sweepAngle);
        SkScalar radiusX = oval.width() / 2;
        SkScalar radiusY = oval.height() / 2;
        // We do not use SkScalar[Sin|Cos]SnapToZero here. When sin(startAngle) is 0 and sweepAngle
        // is very small and radius is huge, the expected behavior here is to draw a line. But
        // calling SkScalarSinSnapToZero will make sin(endAngle) be 0 which will then draw a dot.
        singlePt.set(oval.centerX() + radiusX * SkScalarCos(endAngle),
                     oval.centerY() + radiusY * SkScalarSin(endAngle));
        addPt(singlePt);
        return *this;
    }
 
    SkConic conics[SkConic::kMaxConicsForArc];
    int count = build_arc_conics(oval, startV, stopV, dir, conics, &singlePt);
    if (count) {
        this->incReserve(count * 2 + 1);
        const SkPoint& pt = conics[0].fPts[0];
        addPt(pt);
        for (int i = 0; i < count; ++i) {
            this->conicTo(conics[i].fPts[1], conics[i].fPts[2], conics[i].fW);
        }
    } else {
        addPt(singlePt);
    }
    return *this;
}

arcTo() [2/3]

SkPathBuilder & SkPathBuilder::arcTo	(	SkPoint	p1,
		SkPoint	p2,
		SkScalar	radius
	)

Appends arc to SkPath, after appending line if needed. Arc is implemented by conic weighted to describe part of circle. Arc is contained by tangent from last SkPath point to p1, and tangent from p1 to p2. Arc is part of circle sized to radius, positioned so it touches both tangent lines.

If last SkPath SkPoint does not start arc, arcTo() appends connecting line to SkPath. The length of vector from p1 to p2 does not affect arc.

Arc sweep is always less than 180 degrees. If radius is zero, or if tangents are nearly parallel, arcTo() appends line from last SkPath SkPoint to p1.

arcTo() appends at most one line and one conic. arcTo() implements the functionality of PostScript arct and HTML Canvas arcTo.

Parameters

p1	SkPoint common to pair of tangents
p2	end of second tangent
radius	distance from arc to circle center

Returns

reference to SkPath

Definition at line 418 of file SkPathBuilder.cpp.

                                                                           {
    this->ensureMove();
 
    if (radius == 0) {
        return this->lineTo(p1);
    }
 
    // need to know our prev pt so we can construct tangent vectors
    SkPoint start = fPts.back();
 
    // need double precision for these calcs.
    skvx::double2 befored = normalize(skvx::double2{p1.fX - start.fX, p1.fY - start.fY});
    skvx::double2 afterd = normalize(skvx::double2{p2.fX - p1.fX, p2.fY - p1.fY});
    double cosh = dot(befored, afterd);
    double sinh = cross(befored, afterd);
 
    // If the previous point equals the first point, befored will be denormalized.
    // If the two points equal, afterd will be denormalized.
    // If the second point equals the first point, sinh will be zero.
    // In all these cases, we cannot construct an arc, so we construct a line to the first point.
    if (!isfinite(befored) || !isfinite(afterd) || SkScalarNearlyZero(SkDoubleToScalar(sinh))) {
        return this->lineTo(p1);
    }
 
    // safe to convert back to floats now
    SkScalar dist = SkScalarAbs(SkDoubleToScalar(radius * (1 - cosh) / sinh));
    SkScalar xx = p1.fX - dist * befored[0];
    SkScalar yy = p1.fY - dist * befored[1];
 
    SkVector after = SkVector::Make(afterd[0], afterd[1]);
    after.setLength(dist);
    this->lineTo(xx, yy);
    SkScalar weight = SkScalarSqrt(SkDoubleToScalar(SK_ScalarHalf + cosh * 0.5));
    return this->conicTo(p1, p1 + after, weight);
}

arcTo() [3/3]

SkPathBuilder & SkPathBuilder::arcTo	(	SkPoint	r,
		SkScalar	xAxisRotate,
		SkPathBuilder::ArcSize	arcLarge,
		SkPathDirection	sweep,
		SkPoint	xy
	)

Appends arc to SkPath. Arc is implemented by one or more conic weighted to describe part of oval with radii (r.fX, r.fY) rotated by xAxisRotate degrees. Arc curves from last SkPath SkPoint to (xy.fX, xy.fY), choosing one of four possible routes: clockwise or counterclockwise, and smaller or larger.

Arc sweep is always less than 360 degrees. arcTo() appends line to xy if either radii are zero, or if last SkPath SkPoint equals (xy.fX, xy.fY). arcTo() scales radii r to fit last SkPath SkPoint and xy if both are greater than zero but too small to describe an arc.

arcTo() appends up to four conic curves. arcTo() implements the functionality of SVG arc, although SVG sweep-flag value is opposite the integer value of sweep; SVG sweep-flag uses 1 for clockwise, while kCW_Direction cast to int is zero.

Parameters

r	radii on axes before x-axis rotation
xAxisRotate	x-axis rotation in degrees; positive values are clockwise
largeArc	chooses smaller or larger arc
sweep	chooses clockwise or counterclockwise arc
xy	end of arc

Returns

reference to SkPath

Definition at line 460 of file SkPathBuilder.cpp.

                                                                             {
    this->ensureMove();
 
    SkPoint srcPts[2] = { fPts.back(), endPt };
 
    // If rx = 0 or ry = 0 then this arc is treated as a straight line segment (a "lineto")
    // joining the endpoints.
    // http://www.w3.org/TR/SVG/implnote.html#ArcOutOfRangeParameters
    if (!rad.fX || !rad.fY) {
        return this->lineTo(endPt);
    }
    // If the current point and target point for the arc are identical, it should be treated as a
    // zero length path. This ensures continuity in animations.
    if (srcPts[0] == srcPts[1]) {
        return this->lineTo(endPt);
    }
    SkScalar rx = SkScalarAbs(rad.fX);
    SkScalar ry = SkScalarAbs(rad.fY);
    SkVector midPointDistance = srcPts[0] - srcPts[1];
    midPointDistance *= 0.5f;
 
    SkMatrix pointTransform;
    pointTransform.setRotate(-angle);
 
    SkPoint transformedMidPoint;
    pointTransform.mapPoints(&transformedMidPoint, &midPointDistance, 1);
    SkScalar squareRx = rx * rx;
    SkScalar squareRy = ry * ry;
    SkScalar squareX = transformedMidPoint.fX * transformedMidPoint.fX;
    SkScalar squareY = transformedMidPoint.fY * transformedMidPoint.fY;
 
    // Check if the radii are big enough to draw the arc, scale radii if not.
    // http://www.w3.org/TR/SVG/implnote.html#ArcCorrectionOutOfRangeRadii
    SkScalar radiiScale = squareX / squareRx + squareY / squareRy;
    if (radiiScale > 1) {
        radiiScale = SkScalarSqrt(radiiScale);
        rx *= radiiScale;
        ry *= radiiScale;
    }
 
    pointTransform.setScale(1 / rx, 1 / ry);
    pointTransform.preRotate(-angle);
 
    SkPoint unitPts[2];
    pointTransform.mapPoints(unitPts, srcPts, (int) std::size(unitPts));
    SkVector delta = unitPts[1] - unitPts[0];
 
    SkScalar d = delta.fX * delta.fX + delta.fY * delta.fY;
    SkScalar scaleFactorSquared = std::max(1 / d - 0.25f, 0.f);
 
    SkScalar scaleFactor = SkScalarSqrt(scaleFactorSquared);
    if ((arcSweep == SkPathDirection::kCCW) != SkToBool(arcLarge)) {  // flipped from the original implementation
        scaleFactor = -scaleFactor;
    }
    delta.scale(scaleFactor);
    SkPoint centerPoint = unitPts[0] + unitPts[1];
    centerPoint *= 0.5f;
    centerPoint.offset(-delta.fY, delta.fX);
    unitPts[0] -= centerPoint;
    unitPts[1] -= centerPoint;
    SkScalar theta1 = SkScalarATan2(unitPts[0].fY, unitPts[0].fX);
    SkScalar theta2 = SkScalarATan2(unitPts[1].fY, unitPts[1].fX);
    SkScalar thetaArc = theta2 - theta1;
    if (thetaArc < 0 && (arcSweep == SkPathDirection::kCW)) {  // arcSweep flipped from the original implementation
        thetaArc += SK_ScalarPI * 2;
    } else if (thetaArc > 0 && (arcSweep != SkPathDirection::kCW)) {  // arcSweep flipped from the original implementation
        thetaArc -= SK_ScalarPI * 2;
    }
 
    // Very tiny angles cause our subsequent math to go wonky (skbug.com/9272)
    // so we do a quick check here. The precise tolerance amount is just made up.
    // PI/million happens to fix the bug in 9272, but a larger value is probably
    // ok too.
    if (SkScalarAbs(thetaArc) < (SK_ScalarPI / (1000 * 1000))) {
        return this->lineTo(endPt);
    }
 
    pointTransform.setRotate(angle);
    pointTransform.preScale(rx, ry);
 
    // the arc may be slightly bigger than 1/4 circle, so allow up to 1/3rd
    int segments = SkScalarCeilToInt(SkScalarAbs(thetaArc / (2 * SK_ScalarPI / 3)));
    SkScalar thetaWidth = thetaArc / segments;
    SkScalar t = SkScalarTan(0.5f * thetaWidth);
    if (!SkIsFinite(t)) {
        return *this;
    }
    SkScalar startTheta = theta1;
    SkScalar w = SkScalarSqrt(SK_ScalarHalf + SkScalarCos(thetaWidth) * SK_ScalarHalf);
    auto scalar_is_integer = [](SkScalar scalar) -> bool {
        return scalar == SkScalarFloorToScalar(scalar);
    };
    bool expectIntegers = SkScalarNearlyZero(SK_ScalarPI/2 - SkScalarAbs(thetaWidth)) &&
        scalar_is_integer(rx) && scalar_is_integer(ry) &&
        scalar_is_integer(endPt.fX) && scalar_is_integer(endPt.fY);
 
    for (int i = 0; i < segments; ++i) {
        SkScalar endTheta    = startTheta + thetaWidth,
                 sinEndTheta = SkScalarSinSnapToZero(endTheta),
                 cosEndTheta = SkScalarCosSnapToZero(endTheta);
 
        unitPts[1].set(cosEndTheta, sinEndTheta);
        unitPts[1] += centerPoint;
        unitPts[0] = unitPts[1];
        unitPts[0].offset(t * sinEndTheta, -t * cosEndTheta);
        SkPoint mapped[2];
        pointTransform.mapPoints(mapped, unitPts, (int) std::size(unitPts));
        /*
        Computing the arc width introduces rounding errors that cause arcs to start
        outside their marks. A round rect may lose convexity as a result. If the input
        values are on integers, place the conic on integers as well.
         */
        if (expectIntegers) {
            for (SkPoint& point : mapped) {
                point.fX = SkScalarRoundToScalar(point.fX);
                point.fY = SkScalarRoundToScalar(point.fY);
            }
        }
        this->conicTo(mapped[0], mapped[1], w);
        startTheta = endTheta;
    }
 
    // The final point should match the input point (by definition); replace it to
    // ensure that rounding errors in the above math don't cause any problems.
    fPts.back() = endPt;
    return *this;
}

close()

SkPathBuilder & SkPathBuilder::close

(

)

Definition at line 155 of file SkPathBuilder.cpp.

                                    {
    if (!fVerbs.empty()) {
        this->ensureMove();
 
        fVerbs.push_back((uint8_t)SkPathVerb::kClose);
 
        // fLastMovePoint stays where it is -- the previous moveTo
        fNeedsMoveVerb = true;
    }
    return *this;
}

computeBounds()

SkRect SkPathBuilder::computeBounds

(

)

const

Definition at line 81 of file SkPathBuilder.cpp.

                                          {
    SkRect bounds;
    bounds.setBounds(fPts.begin(), fPts.size());
    return bounds;
}

conicTo() [1/3]

SkPathBuilder & SkPathBuilder::conicTo ( const SkPoint  pts[2], SkScalar  w  )

inline

Definition at line 63 of file SkPathBuilder.h.

                                                             {
        return this->conicTo(pts[0], pts[1], w);
    }

conicTo() [2/3]

SkPathBuilder & SkPathBuilder::conicTo	(	SkPoint	pt1,
		SkPoint	pt2,
		SkScalar	w
	)

Definition at line 129 of file SkPathBuilder.cpp.

                                                                          {
    this->ensureMove();
 
    SkPoint* p = fPts.push_back_n(2);
    p[0] = pt1;
    p[1] = pt2;
    fVerbs.push_back((uint8_t)SkPathVerb::kConic);
    fConicWeights.push_back(w);
 
    fSegmentMask |= kConic_SkPathSegmentMask;
    return *this;
}

conicTo() [3/3]

SkPathBuilder & SkPathBuilder::conicTo ( SkScalar  x1, SkScalar  y1, SkScalar  x2, SkScalar  y2, SkScalar  w  )

inline

Definition at line 60 of file SkPathBuilder.h.

                                                                                           {
        return this->conicTo(SkPoint::Make(x1, y1), SkPoint::Make(x2, y2), w);
    }

cubicTo() [1/3]

SkPathBuilder & SkPathBuilder::cubicTo ( const SkPoint  pts[3] )

inline

Definition at line 71 of file SkPathBuilder.h.

                                                 {
        return this->cubicTo(pts[0], pts[1], pts[2]);
    }

cubicTo() [2/3]

SkPathBuilder & SkPathBuilder::cubicTo	(	SkPoint	pt1,
		SkPoint	pt2,
		SkPoint	pt3
	)

Definition at line 142 of file SkPathBuilder.cpp.

                                                                           {
    this->ensureMove();
 
    SkPoint* p = fPts.push_back_n(3);
    p[0] = pt1;
    p[1] = pt2;
    p[2] = pt3;
    fVerbs.push_back((uint8_t)SkPathVerb::kCubic);
 
    fSegmentMask |= kCubic_SkPathSegmentMask;
    return *this;
}

cubicTo() [3/3]

SkPathBuilder & SkPathBuilder::cubicTo ( SkScalar  x1, SkScalar  y1, SkScalar  x2, SkScalar  y2, SkScalar  x3, SkScalar  y3  )

inline

Definition at line 68 of file SkPathBuilder.h.

                                                                                                         {
        return this->cubicTo(SkPoint::Make(x1, y1), SkPoint::Make(x2, y2), SkPoint::Make(x3, y3));
    }

detach()

SkPath SkPathBuilder::detach

(

)

Definition at line 239 of file SkPathBuilder.cpp.

                             {
    auto path = this->make(sk_sp<SkPathRef>(new SkPathRef(std::move(fPts),
                                                          std::move(fVerbs),
                                                          std::move(fConicWeights),
                                                          fSegmentMask)));
    this->reset();
    return path;
}

fillType()

SkPathFillType SkPathBuilder::fillType ( ) const

inline

Definition at line 36 of file SkPathBuilder.h.

{ return fFillType; }

incReserve() [1/2]

void SkPathBuilder::incReserve ( int  extraPtCount )

inline

Definition at line 219 of file SkPathBuilder.h.

                                      {
        this->incReserve(extraPtCount, extraPtCount);
    }

incReserve() [2/2]

void SkPathBuilder::incReserve	(	int	extraPtCount,
		int	extraVerbCount
	)

Definition at line 76 of file SkPathBuilder.cpp.

                                                                 {
    fPts.reserve_exact(Sk32_sat_add(fPts.size(), extraPtCount));
    fVerbs.reserve_exact(Sk32_sat_add(fVerbs.size(), extraVbCount));
}

lineTo() [1/2]

SkPathBuilder & SkPathBuilder::lineTo

(

SkPoint

pt

)

Definition at line 107 of file SkPathBuilder.cpp.

                                               {
    this->ensureMove();
 
    fPts.push_back(pt);
    fVerbs.push_back((uint8_t)SkPathVerb::kLine);
 
    fSegmentMask |= kLine_SkPathSegmentMask;
    return *this;
}

lineTo() [2/2]

SkPathBuilder & SkPathBuilder::lineTo ( SkScalar  x, SkScalar  y  )

inline

Definition at line 51 of file SkPathBuilder.h.

{ return this->lineTo(SkPoint::Make(x, y)); }

moveTo() [1/2]

SkPathBuilder & SkPathBuilder::moveTo

(

SkPoint

pt

)

Definition at line 95 of file SkPathBuilder.cpp.

                                               {
    // only needed while SkPath is mutable
    fLastMoveIndex = SkToInt(fPts.size());
 
    fPts.push_back(pt);
    fVerbs.push_back((uint8_t)SkPathVerb::kMove);
 
    fLastMovePoint = pt;
    fNeedsMoveVerb = false;
    return *this;
}

moveTo() [2/2]

SkPathBuilder & SkPathBuilder::moveTo ( SkScalar  x, SkScalar  y  )

inline

Definition at line 48 of file SkPathBuilder.h.

{ return this->moveTo(SkPoint::Make(x, y)); }

offset()

SkPathBuilder & SkPathBuilder::offset	(	SkScalar	dx,
		SkScalar	dy
	)

Definition at line 793 of file SkPathBuilder.cpp.

                                                             {
    for (auto& p : fPts) {
        p += {dx, dy};
    }
    return *this;
}

operator=() [1/2]

SkPathBuilder & SkPathBuilder::operator=

(

const SkPath &

src

)

Definition at line 60 of file SkPathBuilder.cpp.

                                                         {
    this->reset().setFillType(src.getFillType());
 
    for (auto [verb, pts, w] : SkPathPriv::Iterate(src)) {
        switch (verb) {
            case SkPathVerb::kMove:  this->moveTo(pts[0]); break;
            case SkPathVerb::kLine:  this->lineTo(pts[1]); break;
            case SkPathVerb::kQuad:  this->quadTo(pts[1], pts[2]); break;
            case SkPathVerb::kConic: this->conicTo(pts[1], pts[2], w[0]); break;
            case SkPathVerb::kCubic: this->cubicTo(pts[1], pts[2], pts[3]); break;
            case SkPathVerb::kClose: this->close(); break;
        }
    }
    return *this;
}

operator=() [2/2]

SkPathBuilder & SkPathBuilder::operator= ( const SkPathBuilder &  )

default

polylineTo() [1/2]

SkPathBuilder & SkPathBuilder::polylineTo	(	const SkPoint	pts[],
		int	count
	)

Definition at line 779 of file SkPathBuilder.cpp.

                                                                       {
    if (count > 0) {
        this->ensureMove();
 
        this->incReserve(count, count);
        memcpy(fPts.push_back_n(count), pts, count * sizeof(SkPoint));
        memset(fVerbs.push_back_n(count), (uint8_t)SkPathVerb::kLine, count);
        fSegmentMask |= kLine_SkPathSegmentMask;
    }
    return *this;
}

polylineTo() [2/2]

SkPathBuilder & SkPathBuilder::polylineTo ( const std::initializer_list< SkPoint > &  list )

inline

Definition at line 79 of file SkPathBuilder.h.

                                                                        {
        return this->polylineTo(list.begin(), SkToInt(list.size()));
    }

quadTo() [1/3]

SkPathBuilder & SkPathBuilder::quadTo ( const SkPoint  pts[2] )

inline

Definition at line 57 of file SkPathBuilder.h.

{ return this->quadTo(pts[0], pts[1]); }

quadTo() [2/3]

SkPathBuilder & SkPathBuilder::quadTo	(	SkPoint	pt1,
		SkPoint	pt2
	)

Definition at line 117 of file SkPathBuilder.cpp.

                                                             {
    this->ensureMove();
 
    SkPoint* p = fPts.push_back_n(2);
    p[0] = pt1;
    p[1] = pt2;
    fVerbs.push_back((uint8_t)SkPathVerb::kQuad);
 
    fSegmentMask |= kQuad_SkPathSegmentMask;
    return *this;
}

quadTo() [3/3]

SkPathBuilder & SkPathBuilder::quadTo ( SkScalar  x1, SkScalar  y1, SkScalar  x2, SkScalar  y2  )

inline

Definition at line 54 of file SkPathBuilder.h.

                                                                              {
        return this->quadTo(SkPoint::Make(x1, y1), SkPoint::Make(x2, y2));
    }

rConicTo() [1/2]

SkPathBuilder & SkPathBuilder::rConicTo	(	SkPoint	p1,
		SkPoint	p2,
		SkScalar	w
	)

Definition at line 180 of file SkPathBuilder.cpp.

                                                                         {
    this->ensureMove();
    SkPoint base = fPts.back();
    return this->conicTo(base + p1, base + p2, w);
}

rConicTo() [2/2]

SkPathBuilder & SkPathBuilder::rConicTo ( SkScalar  x1, SkScalar  y1, SkScalar  x2, SkScalar  y2, SkScalar  w  )

inline

Definition at line 92 of file SkPathBuilder.h.

                                                                                            {
        return this->rConicTo({x1, y1}, {x2, y2}, w);
    }

rCubicTo() [1/2]

SkPathBuilder & SkPathBuilder::rCubicTo	(	SkPoint	pt1,
		SkPoint	pt2,
		SkPoint	pt3
	)

Definition at line 186 of file SkPathBuilder.cpp.

                                                                         {
    this->ensureMove();
    SkPoint base = fPts.back();
    return this->cubicTo(base + p1, base + p2, base + p3);
}

rCubicTo() [2/2]

SkPathBuilder & SkPathBuilder::rCubicTo ( SkScalar  x1, SkScalar  y1, SkScalar  x2, SkScalar  y2, SkScalar  x3, SkScalar  y3  )

inline

Definition at line 96 of file SkPathBuilder.h.

                                                                                                          {
        return this->rCubicTo({x1, y1}, {x2, y2}, {x3, y3});
    }

reset()

SkPathBuilder & SkPathBuilder::reset

(

)

Definition at line 43 of file SkPathBuilder.cpp.

                                    {
    fPts.clear();
    fVerbs.clear();
    fConicWeights.clear();
    fFillType = SkPathFillType::kWinding;
    fIsVolatile = false;
 
    // these are internal state
 
    fSegmentMask = 0;
    fLastMovePoint = {0, 0};
    fLastMoveIndex = -1;        // illegal
    fNeedsMoveVerb = true;
 
    return *this;
}

rLineTo() [1/2]

SkPathBuilder & SkPathBuilder::rLineTo

(

SkPoint

pt

)

Definition at line 169 of file SkPathBuilder.cpp.

                                                {
    this->ensureMove();
    return this->lineTo(fPts.back() + p1);
}

rLineTo() [2/2]

SkPathBuilder & SkPathBuilder::rLineTo ( SkScalar  x, SkScalar  y  )

inline

Definition at line 86 of file SkPathBuilder.h.

{ return this->rLineTo({x, y}); }

rQuadTo() [1/2]

SkPathBuilder & SkPathBuilder::rQuadTo	(	SkPoint	pt1,
		SkPoint	pt2
	)

Definition at line 174 of file SkPathBuilder.cpp.

                                                            {
    this->ensureMove();
    SkPoint base = fPts.back();
    return this->quadTo(base + p1, base + p2);
}

rQuadTo() [2/2]

SkPathBuilder & SkPathBuilder::rQuadTo ( SkScalar  x1, SkScalar  y1, SkScalar  x2, SkScalar  y2  )

inline

Definition at line 88 of file SkPathBuilder.h.

                                                                               {
        return this->rQuadTo({x1, y1}, {x2, y2});
    }

setFillType()

SkPathBuilder & SkPathBuilder::setFillType ( SkPathFillType  ft )

inline

Definition at line 42 of file SkPathBuilder.h.

{ fFillType = ft; return *this; }

setIsVolatile()

SkPathBuilder & SkPathBuilder::setIsVolatile ( bool  isVolatile )

inline

Definition at line 43 of file SkPathBuilder.h.

{ fIsVolatile = isVolatile; return *this; }

snapshot()

SkPath SkPathBuilder::snapshot

(

)

const

Definition at line 232 of file SkPathBuilder.cpp.

                                     {
    return this->make(sk_sp<SkPathRef>(new SkPathRef(fPts,
                                                     fVerbs,
                                                     fConicWeights,
                                                     fSegmentMask)));
}

toggleInverseFillType()

SkPathBuilder & SkPathBuilder::toggleInverseFillType ( )

inline

Definition at line 225 of file SkPathBuilder.h.

                                           {
        fFillType = (SkPathFillType)((unsigned)fFillType ^ 2);
        return *this;
    }

Friends And Related Function Documentation

SkPathPriv

friend class SkPathPriv

friend

Definition at line 267 of file SkPathBuilder.h.

---

The documentation for this class was generated from the following files:

• third_party/skia/include/core/SkPathBuilder.h
• third_party/skia/src/core/SkPathBuilder.cpp