#include <SkPath.h>

Inheritance diagram for SkPath:

Classes
class	Iter

class	RawIter

Public Types
enum	ArcSize { kSmall_ArcSize , kLarge_ArcSize }

enum	AddPathMode { kAppend_AddPathMode , kExtend_AddPathMode }

enum	SegmentMask { kLine_SegmentMask = kLine_SkPathSegmentMask , kQuad_SegmentMask = kQuad_SkPathSegmentMask , kConic_SegmentMask = kConic_SkPathSegmentMask , kCubic_SegmentMask = kCubic_SkPathSegmentMask }

enum	Verb { kMove_Verb = static_cast<int>(SkPathVerb::kMove) , kLine_Verb = static_cast<int>(SkPathVerb::kLine) , kQuad_Verb = static_cast<int>(SkPathVerb::kQuad) , kConic_Verb = static_cast<int>(SkPathVerb::kConic) , kCubic_Verb = static_cast<int>(SkPathVerb::kCubic) , kClose_Verb = static_cast<int>(SkPathVerb::kClose) , kDone_Verb = kClose_Verb + 1 }

using	sk_is_trivially_relocatable = std::true_type

Public Member Functions
	SkPath ()

	SkPath (const SkPath &path)

	~SkPath ()

SkPath	snapshot () const

SkPath	detach ()

SkPath &	operator= (const SkPath &path)

bool	isInterpolatable (const SkPath &compare) const

bool	interpolate (const SkPath &ending, SkScalar weight, SkPath *out) const

SkPathFillType	getFillType () const

void	setFillType (SkPathFillType ft)

bool	isInverseFillType () const

void	toggleInverseFillType ()

bool	isConvex () const

bool	isOval (SkRect *bounds) const

bool	isRRect (SkRRect *rrect) const

bool	isArc (SkArc *arc) const

SkPath &	reset ()

SkPath &	rewind ()

bool	isEmpty () const

bool	isLastContourClosed () const

bool	isFinite () const

bool	isVolatile () const

SkPath &	setIsVolatile (bool isVolatile)

bool	isLine (SkPoint line[2]) const

int	countPoints () const

SkPoint	getPoint (int index) const

int	getPoints (SkPoint points[], int max) const

int	countVerbs () const

int	getVerbs (uint8_t verbs[], int max) const

size_t	approximateBytesUsed () const

void	swap (SkPath &other)

const SkRect &	getBounds () const

void	updateBoundsCache () const

SkRect	computeTightBounds () const

bool	conservativelyContainsRect (const SkRect &rect) const

void	incReserve (int extraPtCount, int extraVerbCount=0, int extraConicCount=0)

SkPath &	moveTo (SkScalar x, SkScalar y)

SkPath &	moveTo (const SkPoint &p)

SkPath &	rMoveTo (SkScalar dx, SkScalar dy)

SkPath &	lineTo (SkScalar x, SkScalar y)

SkPath &	lineTo (const SkPoint &p)

SkPath &	rLineTo (SkScalar dx, SkScalar dy)

SkPath &	quadTo (SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2)

SkPath &	quadTo (const SkPoint &p1, const SkPoint &p2)

SkPath &	rQuadTo (SkScalar dx1, SkScalar dy1, SkScalar dx2, SkScalar dy2)

SkPath &	conicTo (SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2, SkScalar w)

SkPath &	conicTo (const SkPoint &p1, const SkPoint &p2, SkScalar w)

SkPath &	rConicTo (SkScalar dx1, SkScalar dy1, SkScalar dx2, SkScalar dy2, SkScalar w)

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

SkPath &	cubicTo (const SkPoint &p1, const SkPoint &p2, const SkPoint &p3)

SkPath &	rCubicTo (SkScalar dx1, SkScalar dy1, SkScalar dx2, SkScalar dy2, SkScalar dx3, SkScalar dy3)

SkPath &	arcTo (const SkRect &oval, SkScalar startAngle, SkScalar sweepAngle, bool forceMoveTo)

SkPath &	arcTo (SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2, SkScalar radius)

SkPath &	arcTo (const SkPoint p1, const SkPoint p2, SkScalar radius)

SkPath &	arcTo (SkScalar rx, SkScalar ry, SkScalar xAxisRotate, ArcSize largeArc, SkPathDirection sweep, SkScalar x, SkScalar y)

SkPath &	arcTo (const SkPoint r, SkScalar xAxisRotate, ArcSize largeArc, SkPathDirection sweep, const SkPoint xy)

SkPath &	rArcTo (SkScalar rx, SkScalar ry, SkScalar xAxisRotate, ArcSize largeArc, SkPathDirection sweep, SkScalar dx, SkScalar dy)

SkPath &	close ()

bool	isRect (SkRect rect, bool isClosed=nullptr, SkPathDirection *direction=nullptr) const

SkPath &	addRect (const SkRect &rect, SkPathDirection dir, unsigned start)

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

SkPath &	addRect (SkScalar left, SkScalar top, SkScalar right, SkScalar bottom, SkPathDirection dir=SkPathDirection::kCW)

SkPath &	addOval (const SkRect &oval, SkPathDirection dir=SkPathDirection::kCW)

SkPath &	addOval (const SkRect &oval, SkPathDirection dir, unsigned start)

SkPath &	addOpenOval (const SkRect &oval, SkPathDirection dir, unsigned start)

SkPath &	addCircle (SkScalar x, SkScalar y, SkScalar radius, SkPathDirection dir=SkPathDirection::kCW)

SkPath &	addArc (const SkRect &oval, SkScalar startAngle, SkScalar sweepAngle)

SkPath &	addRoundRect (const SkRect &rect, SkScalar rx, SkScalar ry, SkPathDirection dir=SkPathDirection::kCW)

SkPath &	addRoundRect (const SkRect &rect, const SkScalar radii[], SkPathDirection dir=SkPathDirection::kCW)

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

SkPath &	addRRect (const SkRRect &rrect, SkPathDirection dir, unsigned start)

SkPath &	addPoly (const SkPoint pts[], int count, bool close)

SkPath &	addPoly (const std::initializer_list< SkPoint > &list, bool close)

SkPath &	addPath (const SkPath &src, SkScalar dx, SkScalar dy, AddPathMode mode=kAppend_AddPathMode)

SkPath &	addPath (const SkPath &src, AddPathMode mode=kAppend_AddPathMode)

SkPath &	addPath (const SkPath &src, const SkMatrix &matrix, AddPathMode mode=kAppend_AddPathMode)

SkPath &	reverseAddPath (const SkPath &src)

void	offset (SkScalar dx, SkScalar dy, SkPath *dst) const

SkPath &	offset (SkScalar dx, SkScalar dy)

void	transform (const SkMatrix &matrix, SkPath *dst, SkApplyPerspectiveClip pc=SkApplyPerspectiveClip::kYes) const

SkPath &	transform (const SkMatrix &matrix, SkApplyPerspectiveClip pc=SkApplyPerspectiveClip::kYes)

SkPath	makeTransform (const SkMatrix &m, SkApplyPerspectiveClip pc=SkApplyPerspectiveClip::kYes) const

SkPath	makeScale (SkScalar sx, SkScalar sy)

bool	getLastPt (SkPoint *lastPt) const

void	setLastPt (SkScalar x, SkScalar y)

void	setLastPt (const SkPoint &p)

uint32_t	getSegmentMasks () const

bool	contains (SkScalar x, SkScalar y) const

void	dump (SkWStream *stream, bool dumpAsHex) const

void	dump () const

void	dumpHex () const

void	dumpArrays (SkWStream *stream, bool dumpAsHex) const

void	dumpArrays () const

size_t	writeToMemory (void *buffer) const

sk_sp< SkData >	serialize () const

size_t	readFromMemory (const void *buffer, size_t length)

uint32_t	getGenerationID () const

bool	isValid () const

Static Public Member Functions
static SkPath	Make (const SkPoint[], int pointCount, const uint8_t[], int verbCount, const SkScalar[], int conicWeightCount, SkPathFillType, bool isVolatile=false)

static SkPath	Rect (const SkRect &, SkPathDirection=SkPathDirection::kCW, unsigned startIndex=0)

static SkPath	Oval (const SkRect &, SkPathDirection=SkPathDirection::kCW)

static SkPath	Oval (const SkRect &, SkPathDirection, unsigned startIndex)

static SkPath	Circle (SkScalar center_x, SkScalar center_y, SkScalar radius, SkPathDirection dir=SkPathDirection::kCW)

static SkPath	RRect (const SkRRect &, SkPathDirection dir=SkPathDirection::kCW)

static SkPath	RRect (const SkRRect &, SkPathDirection, unsigned startIndex)

static SkPath	RRect (const SkRect &bounds, SkScalar rx, SkScalar ry, SkPathDirection dir=SkPathDirection::kCW)

static SkPath	Polygon (const SkPoint pts[], int count, bool isClosed, SkPathFillType=SkPathFillType::kWinding, bool isVolatile=false)

static SkPath	Polygon (const std::initializer_list< SkPoint > &list, bool isClosed, SkPathFillType fillType=SkPathFillType::kWinding, bool isVolatile=false)

static SkPath	Line (const SkPoint a, const SkPoint b)

static bool	IsLineDegenerate (const SkPoint &p1, const SkPoint &p2, bool exact)

static bool	IsQuadDegenerate (const SkPoint &p1, const SkPoint &p2, const SkPoint &p3, bool exact)

static bool	IsCubicDegenerate (const SkPoint &p1, const SkPoint &p2, const SkPoint &p3, const SkPoint &p4, bool exact)

static int	ConvertConicToQuads (const SkPoint &p0, const SkPoint &p1, const SkPoint &p2, SkScalar w, SkPoint pts[], int pow2)

Friends
class	Iter

class	SkPathPriv

class	SkPathStroker

class	SkAutoPathBoundsUpdate

class	SkAutoDisableOvalCheck

class	SkAutoDisableDirectionCheck

class	SkPathBuilder

class	SkPathEdgeIter

class	SkPathWriter

class	SkOpBuilder

class	SkBench_AddPathTest

class	PathTest_Private

class	ForceIsRRect_Private

class	FuzzPath

SK_API bool	operator== (const SkPath &a, const SkPath &b)

bool	operator!= (const SkPath &a, const SkPath &b)

Detailed Description

SkPath contain geometry. SkPath may be empty, or contain one or more verbs that outline a figure. SkPath always starts with a move verb to a Cartesian coordinate, and may be followed by additional verbs that add lines or curves. Adding a close verb makes the geometry into a continuous loop, a closed contour. SkPath may contain any number of contours, each beginning with a move verb.

SkPath contours may contain only a move verb, or may also contain lines, quadratic beziers, conics, and cubic beziers. SkPath contours may be open or closed.

When used to draw a filled area, SkPath describes whether the fill is inside or outside the geometry. SkPath also describes the winding rule used to fill overlapping contours.

Internally, SkPath lazily computes metrics likes bounds and convexity. Call SkPath::updateBoundsCache to make SkPath thread safe.

Definition at line 59 of file SkPath.h.

Member Typedef Documentation

◆ sk_is_trivially_relocatable

using SkPath::sk_is_trivially_relocatable = std::true_type

Definition at line 1811 of file SkPath.h.

Member Enumeration Documentation

◆ AddPathMode

enum SkPath::AddPathMode

Enumerator
kAppend_AddPathMode	Contours are appended to the destination path as new contours.
kExtend_AddPathMode	Extends the last contour of the destination path with the first countour of the source path, connecting them with a line. If the last contour is closed, a new empty contour starting at its start point is extended instead. If the destination path is empty, the result is the source path. The last path of the result is closed only if the last path of the source is.

Definition at line 1283 of file SkPath.h.

                     {
        /** Contours are appended to the destination path as new contours.
        */
        kAppend_AddPathMode,
        /** Extends the last contour of the destination path with the first countour
            of the source path, connecting them with a line.  If the last contour is
            closed, a new empty contour starting at its start point is extended instead.
            If the destination path is empty, the result is the source path.
            The last path of the result is closed only if the last path of the source is.
        */
        kExtend_AddPathMode,
    };

◆ ArcSize

enum SkPath::ArcSize

Enumerator
kSmall_ArcSize	smaller of arc pair
kLarge_ArcSize	larger of arc pair

Definition at line 923 of file SkPath.h.

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

◆ SegmentMask

enum SkPath::SegmentMask

Enumerator
kLine_SegmentMask
kQuad_SegmentMask
kConic_SegmentMask
kCubic_SegmentMask

Definition at line 1444 of file SkPath.h.

                     {
        kLine_SegmentMask  = kLine_SkPathSegmentMask,
        kQuad_SegmentMask  = kQuad_SkPathSegmentMask,
        kConic_SegmentMask = kConic_SkPathSegmentMask,
        kCubic_SegmentMask = kCubic_SkPathSegmentMask,
    };

◆ Verb

enum SkPath::Verb

Enumerator
kMove_Verb
kLine_Verb
kQuad_Verb
kConic_Verb
kCubic_Verb
kClose_Verb
kDone_Verb

Definition at line 1465 of file SkPath.h.

              {
        kMove_Verb  = static_cast<int>(SkPathVerb::kMove),
        kLine_Verb  = static_cast<int>(SkPathVerb::kLine),
        kQuad_Verb  = static_cast<int>(SkPathVerb::kQuad),
        kConic_Verb = static_cast<int>(SkPathVerb::kConic),
        kCubic_Verb = static_cast<int>(SkPathVerb::kCubic),
        kClose_Verb = static_cast<int>(SkPathVerb::kClose),
        kDone_Verb  = kClose_Verb + 1
    };

Constructor & Destructor Documentation

◆ SkPath() [1/2]

SkPath::SkPath ( )

Constructs an empty SkPath. By default, SkPath has no verbs, no SkPoint, and no weights. FillType is set to kWinding.

Returns: empty SkPath

example: https://fiddle.skia.org/c/@Path_empty_constructor

Definition at line 156 of file SkPath.cpp.

    : fPathRef(SkPathRef::CreateEmpty()) {
    this->resetFields();
    fIsVolatile = false;
}

◆ SkPath() [2/2]

SkPath::SkPath ( const SkPath & path )

Constructs a copy of an existing path. Copy constructor makes two paths identical by value. Internally, path and the returned result share pointer values. The underlying verb array, SkPoint array and weights are copied when modified.

Creating a SkPath copy is very efficient and never allocates memory. SkPath are always copied by value from the interface; the underlying shared pointers are not exposed.

Parameters

path	SkPath to copy by value

Returns: copy of SkPath

example: https://fiddle.skia.org/c/@Path_copy_const_SkPath

Definition at line 180 of file SkPath.cpp.

    : fPathRef(SkRef(that.fPathRef.get())) {
    this->copyFields(that);
    SkDEBUGCODE(that.validate();)
}

◆ ~SkPath()

SkPath::~SkPath ( )

Releases ownership of any shared data and deletes data if SkPath is sole owner.

example: https://fiddle.skia.org/c/@Path_destructor

Definition at line 186 of file SkPath.cpp.

                {
    SkDEBUGCODE(this->validate();)
}

Member Function Documentation

◆ addArc()

SkPath & SkPath::addArc	(	const SkRect &	oval,
		SkScalar	startAngle,
		SkScalar	sweepAngle
	)

Appends arc to SkPath, 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
startAngle	starting angle of arc in degrees
sweepAngle	sweep, in degrees. Positive is clockwise; treated modulo 360

Returns: reference to SkPath

example: https://fiddle.skia.org/c/@Path_addArc

Definition at line 1439 of file SkPath.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()

SkPath & SkPath::addCircle	(	SkScalar	x,
		SkScalar	y,
		SkScalar	radius,
		SkPathDirection	dir = `SkPathDirection::kCW`
	)

Adds circle centered at (x, y) of size radius to SkPath, appending kMove_Verb, four kConic_Verb, and kClose_Verb. Circle begins at: (x + radius, y), continuing clockwise if dir is kCW_Direction, and counterclockwise if dir is kCCW_Direction.

Has no effect if radius is zero or negative.

Parameters

x	center of circle
y	center of circle
radius	distance from center to edge
dir	SkPath::Direction to wind circle

Returns: reference to SkPath

Definition at line 1213 of file SkPath.cpp.

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

◆ addOpenOval()

SkPath & SkPath::addOpenOval	(	const SkRect &	oval,
		SkPathDirection	dir,
		unsigned	start
	)

Experimental, subject to change or removal.

Adds an "open" oval to SkPath. This follows canvas2D semantics: The oval is not a separate contour. If the path was empty, then kMove_Verb is appended. Otherwise, kLine_Verb is appended. Four kConic_Verbs are appended. kClose_Verb is not appended.

Definition at line 1161 of file SkPath.cpp.

                                                                                             {
    assert_known_direction(dir);
 
    // Canvas2D semantics are different than our standard addOval. In the case of an empty
    // initial path, we inject a moveTo. In any other case, we actually start with a lineTo
    // (as if we simply called arcTo). Thus, we only treat the result as an (open) oval for
    // future queries if we started out empty.
    bool wasEmpty = this->isEmpty();
    if (wasEmpty) {
        this->setFirstDirection((SkPathFirstDirection)dir);
    } else {
        this->setFirstDirection(SkPathFirstDirection::kUnknown);
    }
 
    SkAutoDisableDirectionCheck addc(this);
    SkAutoPathBoundsUpdate apbu(this, oval);
 
    SkDEBUGCODE(int initialVerbCount = fPathRef->countVerbs());
    SkDEBUGCODE(int initialPointCount = fPathRef->countPoints());
    SkDEBUGCODE(int initialWeightCount = fPathRef->countWeights());
    // We reserve space for one extra verb. The caller usually adds kClose immediately
    const int kVerbs = 6; // moveTo/lineTo + 4x conicTo + (kClose)?
    const int kPoints = 9;
    const int kWeights = 4;
    this->incReserve(kPoints, kVerbs, kWeights);
 
    SkPath_OvalPointIterator ovalIter(oval, dir, startPointIndex);
    // The corner iterator pts are tracking "behind" the oval/radii pts.
    SkPath_RectPointIterator rectIter(
            oval, dir, startPointIndex + (dir == SkPathDirection::kCW ? 0 : 1));
    const SkScalar kConicWeight = SK_ScalarRoot2Over2;
 
    if (wasEmpty) {
        this->moveTo(ovalIter.current());
    } else {
        this->lineTo(ovalIter.current());
    }
    for (unsigned i = 0; i < 4; ++i) {
        this->conicTo(rectIter.next(), ovalIter.next(), kConicWeight);
    }
 
    SkASSERT(fPathRef->countVerbs() == initialVerbCount + kVerbs - 1); // See comment above
    SkASSERT(fPathRef->countPoints() == initialPointCount + kPoints);
    SkASSERT(fPathRef->countWeights() == initialWeightCount + kWeights);
 
    if (wasEmpty) {
        SkPathRef::Editor ed(&fPathRef);
        ed.setIsOval(SkPathDirection::kCCW == dir, startPointIndex % 4, /*isClosed=*/false);
    }
    return *this;
}

◆ addOval() [1/2]

SkPath & SkPath::addOval	(	const SkRect &	oval,
		SkPathDirection	dir,
		unsigned	start
	)

Adds oval to SkPath, appending kMove_Verb, four kConic_Verb, and kClose_Verb. Oval is upright ellipse bounded by SkRect oval with radii equal to half oval width and half oval height. Oval begins at start and continues clockwise if dir is kCW_Direction, counterclockwise if dir is kCCW_Direction.

Parameters

oval	bounds of ellipse added
dir	SkPath::Direction to wind ellipse
start	index of initial point of ellipse

Returns: reference to SkPath

example: https://fiddle.skia.org/c/@Path_addOval_2

Definition at line 1111 of file SkPath.cpp.

                                                                                         {
    assert_known_direction(dir);
 
    /* If addOval() is called after previous moveTo(),
       this path is still marked as an oval. This is used to
       fit into WebKit's calling sequences.
       We can't simply check isEmpty() in this case, as additional
       moveTo() would mark the path non empty.
     */
    bool isOval = hasOnlyMoveTos();
    if (isOval) {
        this->setFirstDirection((SkPathFirstDirection)dir);
    } else {
        this->setFirstDirection(SkPathFirstDirection::kUnknown);
    }
 
    SkAutoDisableDirectionCheck addc(this);
    SkAutoPathBoundsUpdate apbu(this, oval);
 
    SkDEBUGCODE(int initialVerbCount = fPathRef->countVerbs());
    SkDEBUGCODE(int initialPointCount = fPathRef->countPoints());
    SkDEBUGCODE(int initialWeightCount = fPathRef->countWeights());
    const int kVerbs = 6; // moveTo + 4x conicTo + close
    const int kPoints = 9;
    const int kWeights = 4;
    this->incReserve(kPoints, kVerbs, kWeights);
 
    SkPath_OvalPointIterator ovalIter(oval, dir, startPointIndex);
    // The corner iterator pts are tracking "behind" the oval/radii pts.
    SkPath_RectPointIterator rectIter(
            oval, dir, startPointIndex + (dir == SkPathDirection::kCW ? 0 : 1));
    const SkScalar kConicWeight = SK_ScalarRoot2Over2;
 
    this->moveTo(ovalIter.current());
    for (unsigned i = 0; i < 4; ++i) {
        this->conicTo(rectIter.next(), ovalIter.next(), kConicWeight);
    }
    this->close();
 
    SkASSERT(fPathRef->countVerbs() == initialVerbCount + kVerbs);
    SkASSERT(fPathRef->countPoints() == initialPointCount + kPoints);
    SkASSERT(fPathRef->countWeights() == initialWeightCount + kWeights);
 
    if (isOval) {
        SkPathRef::Editor ed(&fPathRef);
        ed.setIsOval(SkPathDirection::kCCW == dir, startPointIndex % 4, /*isClosed=*/true);
    }
    return *this;
}

◆ addOval() [2/2]

SkPath & SkPath::addOval	(	const SkRect &	oval,
		SkPathDirection	dir = `SkPathDirection::kCW`
	)

Adds oval to path, appending kMove_Verb, four kConic_Verb, and kClose_Verb. Oval is upright ellipse bounded by SkRect oval with radii equal to half oval width and half oval height. Oval begins at (oval.fRight, oval.centerY()) and continues clockwise if dir is kCW_Direction, counterclockwise if dir is kCCW_Direction.

Parameters

oval	bounds of ellipse added
dir	SkPath::Direction to wind ellipse

Returns: reference to SkPath

example: https://fiddle.skia.org/c/@Path_addOval

Definition at line 1106 of file SkPath.cpp.

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

◆ addPath() [1/3]

SkPath & SkPath::addPath	(	const SkPath &	src,
		AddPathMode	mode = `kAppend_AddPathMode`
	)

inline

Appends src to SkPath.

If mode is kAppend_AddPathMode, src verb array, SkPoint array, and conic weights are added unaltered. If mode is kExtend_AddPathMode, add line before appending verbs, SkPoint, and conic weights.

Parameters

src	SkPath verbs, SkPoint, and conic weights to add
mode	kAppend_AddPathMode or kExtend_AddPathMode

Returns: reference to SkPath

Definition at line 1321 of file SkPath.h.

                                                                               {
        SkMatrix m;
        m.reset();
        return this->addPath(src, m, mode);
    }

◆ addPath() [2/3]

SkPath & SkPath::addPath	(	const SkPath &	src,
		const SkMatrix &	matrix,
		AddPathMode	mode = `kAppend_AddPathMode`
	)

Appends src to SkPath, transformed by matrix. Transformed curves may have different verbs, SkPoint, and conic weights.

If mode is kAppend_AddPathMode, src verb array, SkPoint array, and conic weights are added unaltered. If mode is kExtend_AddPathMode, add line before appending verbs, SkPoint, and conic weights.

Parameters

src	SkPath verbs, SkPoint, and conic weights to add
matrix	transform applied to src
mode	kAppend_AddPathMode or kExtend_AddPathMode

Returns: reference to SkPath

Definition at line 1513 of file SkPath.cpp.

                                                                                       {
    if (srcPath.isEmpty()) {
        return *this;
    }
 
    if (this->isEmpty() && matrix.isIdentity()) {
        const uint8_t fillType = fFillType;
        *this = srcPath;
        fFillType = fillType;
        return *this;
    }
 
    // Detect if we're trying to add ourself
    const SkPath* src = &srcPath;
    SkTLazy<SkPath> tmp;
    if (this == src) {
        src = tmp.set(srcPath);
    }
 
    if (kAppend_AddPathMode == mode && !matrix.hasPerspective()) {
        if (src->fLastMoveToIndex >= 0) {
            fLastMoveToIndex = src->fLastMoveToIndex + this->countPoints();
        } else {
            fLastMoveToIndex = src->fLastMoveToIndex - this->countPoints();
        }
        SkPathRef::Editor ed(&fPathRef);
        auto [newPts, newWeights] = ed.growForVerbsInPath(*src->fPathRef);
        matrix.mapPoints(newPts, src->fPathRef->points(), src->countPoints());
        if (int numWeights = src->fPathRef->countWeights()) {
            memcpy(newWeights, src->fPathRef->conicWeights(), numWeights * sizeof(newWeights[0]));
        }
        return this->dirtyAfterEdit();
    }
 
    SkMatrixPriv::MapPtsProc mapPtsProc = SkMatrixPriv::GetMapPtsProc(matrix);
    bool firstVerb = true;
    for (auto [verb, pts, w] : SkPathPriv::Iterate(*src)) {
        SkPoint mappedPts[3];
        switch (verb) {
            case SkPathVerb::kMove:
                mapPtsProc(matrix, mappedPts, &pts[0], 1);
                if (firstVerb && mode == kExtend_AddPathMode && !isEmpty()) {
                    injectMoveToIfNeeded(); // In case last contour is closed
                    SkPoint lastPt;
                    // don't add lineTo if it is degenerate
                    if (!this->getLastPt(&lastPt) || lastPt != mappedPts[0]) {
                        this->lineTo(mappedPts[0]);
                    }
                } else {
                    this->moveTo(mappedPts[0]);
                }
                break;
            case SkPathVerb::kLine:
                mapPtsProc(matrix, mappedPts, &pts[1], 1);
                this->lineTo(mappedPts[0]);
                break;
            case SkPathVerb::kQuad:
                mapPtsProc(matrix, mappedPts, &pts[1], 2);
                this->quadTo(mappedPts[0], mappedPts[1]);
                break;
            case SkPathVerb::kConic:
                mapPtsProc(matrix, mappedPts, &pts[1], 2);
                this->conicTo(mappedPts[0], mappedPts[1], *w);
                break;
            case SkPathVerb::kCubic:
                mapPtsProc(matrix, mappedPts, &pts[1], 3);
                this->cubicTo(mappedPts[0], mappedPts[1], mappedPts[2]);
                break;
            case SkPathVerb::kClose:
                this->close();
                break;
        }
        firstVerb = false;
    }
    return *this;
}

◆ addPath() [3/3]

SkPath & SkPath::addPath	(	const SkPath &	src,
		SkScalar	dx,
		SkScalar	dy,
		AddPathMode	mode = `kAppend_AddPathMode`
	)

Appends src to SkPath, offset by (dx, dy).

If mode is kAppend_AddPathMode, src verb array, SkPoint array, and conic weights are added unaltered. If mode is kExtend_AddPathMode, add line before appending verbs, SkPoint, and conic weights.

Parameters

src	SkPath verbs, SkPoint, and conic weights to add
dx	offset added to src SkPoint array x-axis coordinates
dy	offset added to src SkPoint array y-axis coordinates
mode	kAppend_AddPathMode or kExtend_AddPathMode

Returns: reference to SkPath

Definition at line 1506 of file SkPath.cpp.

                                                                                      {
    SkMatrix matrix;
 
    matrix.setTranslate(dx, dy);
    return this->addPath(path, matrix, mode);
}

◆ addPoly() [1/2]

SkPath & SkPath::addPoly	(	const SkPoint	pts[],
		int	count,
		bool	close
	)

Adds contour created from line array, adding (count - 1) line segments. Contour added starts at pts[0], then adds a line for every additional SkPoint in pts array. If close is true, appends kClose_Verb to SkPath, connecting pts[count - 1] and pts[0].

If count is zero, append kMove_Verb to path. Has no effect if count is less than one.

Parameters

pts	array of line sharing end and start SkPoint
count	length of SkPoint array
close	true to add line connecting contour end and start

Returns: reference to SkPath

example: https://fiddle.skia.org/c/@Path_addPoly

Definition at line 890 of file SkPath.cpp.

                                                                  {
    SkDEBUGCODE(this->validate();)
    if (count <= 0) {
        return *this;
    }
 
    fLastMoveToIndex = fPathRef->countPoints();
 
    // +close makes room for the extra kClose_Verb
    SkPathRef::Editor ed(&fPathRef, count+close, count);
 
    ed.growForVerb(kMove_Verb)->set(pts[0].fX, pts[0].fY);
    if (count > 1) {
        SkPoint* p = ed.growForRepeatedVerb(kLine_Verb, count - 1);
        memcpy(p, &pts[1], (count-1) * sizeof(SkPoint));
    }
 
    if (close) {
        ed.growForVerb(kClose_Verb);
        fLastMoveToIndex ^= ~fLastMoveToIndex >> (8 * sizeof(fLastMoveToIndex) - 1);
    }
 
    (void)this->dirtyAfterEdit();
    SkDEBUGCODE(this->validate();)
    return *this;
}

◆ addPoly() [2/2]

SkPath & SkPath::addPoly	(	const std::initializer_list< SkPoint > &	list,
		bool	close
	)

inline

Adds contour created from list. Contour added starts at list[0], then adds a line for every additional SkPoint in list. If close is true, appends kClose_Verb to SkPath, connecting last and first SkPoint in list.

If list is empty, append kMove_Verb to path.

Parameters

list	array of SkPoint
close	true to add line connecting contour end and start

Returns: reference to SkPath

Definition at line 1271 of file SkPath.h.

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

◆ addRect() [1/3]

SkPath & SkPath::addRect	(	const SkRect &	rect,
		SkPathDirection	dir,
		unsigned	start
	)

Adds a new contour to the path, defined by the rect, and wound in the specified direction. The verbs added to the path will be:

kMove, kLine, kLine, kLine, kClose

start specifies which corner to begin the contour: 0: upper-left corner 1: upper-right corner 2: lower-right corner 3: lower-left corner

This start point also acts as the implied beginning of the subsequent, contour, if it does not have an explicit moveTo(). e.g.

path.addRect(...)

if we don't say moveTo() here, we will use the rect's start point path.lineTo(...)

Parameters

rect	SkRect to add as a closed contour
dir	SkPath::Direction to orient the new contour
start	initial corner of SkRect to add

Returns: reference to SkPath

example: https://fiddle.skia.org/c/@Path_addRect_2

Definition at line 864 of file SkPath.cpp.

                                                                                    {
    assert_known_direction(dir);
    this->setFirstDirection(this->hasOnlyMoveTos() ? (SkPathFirstDirection)dir
                                                   : SkPathFirstDirection::kUnknown);
    SkAutoDisableDirectionCheck addc(this);
    SkAutoPathBoundsUpdate apbu(this, rect);
 
    SkDEBUGCODE(int initialVerbCount = this->countVerbs());
 
    const int kVerbs = 5; // moveTo + 3x lineTo + close
    SkPathRef::Editor ed(&fPathRef, kVerbs, /* points */ 4);
 
    SkPath_RectPointIterator iter(rect, dir, startIndex);
    fLastMoveToIndex = fPathRef->countPoints();
 
    *ed.growForVerb(kMove_Verb) = iter.current();
    *ed.growForVerb(kLine_Verb) = iter.next();
    *ed.growForVerb(kLine_Verb) = iter.next();
    *ed.growForVerb(kLine_Verb) = iter.next();
    this->close();
    (void)this->dirtyAfterEdit();
 
    SkASSERT(this->countVerbs() == initialVerbCount + kVerbs);
    return *this;
}

◆ addRect() [2/3]

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

inline

Definition at line 1106 of file SkPath.h.

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

◆ addRect() [3/3]

SkPath & SkPath::addRect	(	SkScalar	left,
		SkScalar	top,
		SkScalar	right,
		SkScalar	bottom,
		SkPathDirection	dir = `SkPathDirection::kCW`
	)

inline

Definition at line 1110 of file SkPath.h.

                                                              {
        return this->addRect({left, top, right, bottom}, dir, 0);
    }

◆ addRoundRect() [1/2]

SkPath & SkPath::addRoundRect	(	const SkRect &	rect,
		const SkScalar	radii[],
		SkPathDirection	dir = `SkPathDirection::kCW`
	)

Appends SkRRect to SkPath, creating a new closed contour. SkRRect has bounds equal to rect; each corner is 90 degrees of an ellipse with radii from the array.

Parameters

rect	bounds of SkRRect
radii	array of 8 SkScalar values, a radius pair for each corner
dir	SkPath::Direction to wind SkRRect

Returns: reference to SkPath

Definition at line 993 of file SkPath.cpp.

                                               {
    SkRRect rrect;
    rrect.setRectRadii(rect, (const SkVector*) radii);
    return this->addRRect(rrect, dir);
}

◆ addRoundRect() [2/2]

SkPath & SkPath::addRoundRect	(	const SkRect &	rect,
		SkScalar	rx,
		SkScalar	ry,
		SkPathDirection	dir = `SkPathDirection::kCW`
	)

Appends SkRRect to SkPath, creating a new closed contour. SkRRect has bounds equal to rect; each corner is 90 degrees of an ellipse with radii (rx, ry). If dir is kCW_Direction, SkRRect starts at top-left of the lower-left corner and winds clockwise. If dir is kCCW_Direction, SkRRect starts at the bottom-left of the upper-left corner and winds counterclockwise.

If either rx or ry is too large, rx and ry are scaled uniformly until the corners fit. If rx or ry is less than or equal to zero, addRoundRect() appends SkRect rect to SkPath.

After appending, SkPath may be empty, or may contain: SkRect, oval, or SkRRect.

Parameters

rect	bounds of SkRRect
rx	x-axis radius of rounded corners on the SkRRect
ry	y-axis radius of rounded corners on the SkRRect
dir	SkPath::Direction to wind SkRRect

Returns: reference to SkPath

Definition at line 1093 of file SkPath.cpp.

                                                  {
    assert_known_direction(dir);
 
    if (rx < 0 || ry < 0) {
        return *this;
    }
 
    SkRRect rrect;
    rrect.setRectXY(rect, rx, ry);
    return this->addRRect(rrect, dir);
}

◆ addRRect() [1/2]

SkPath & SkPath::addRRect	(	const SkRRect &	rrect,
		SkPathDirection	dir,
		unsigned	start
	)

Adds rrect to SkPath, creating a new closed contour. If dir is kCW_Direction, rrect winds clockwise; if dir is kCCW_Direction, rrect winds counterclockwise. start determines the first point of rrect to add.

Parameters

rrect	bounds and radii of rounded rectangle
dir	SkPath::Direction to wind SkRRect
start	index of initial point of SkRRect

Returns: reference to SkPath

example: https://fiddle.skia.org/c/@Path_addRRect_2

Definition at line 1005 of file SkPath.cpp.

                                                                                       {
    assert_known_direction(dir);
 
    bool isRRect = hasOnlyMoveTos();
    const SkRect& bounds = rrect.getBounds();
 
    if (rrect.isRect() || rrect.isEmpty()) {
        // degenerate(rect) => radii points are collapsing
        this->addRect(bounds, dir, (startIndex + 1) / 2);
    } else if (rrect.isOval()) {
        // degenerate(oval) => line points are collapsing
        this->addOval(bounds, dir, startIndex / 2);
    } else {
        this->setFirstDirection(this->hasOnlyMoveTos() ? (SkPathFirstDirection)dir
                                                       : SkPathFirstDirection::kUnknown);
 
        SkAutoPathBoundsUpdate apbu(this, bounds);
        SkAutoDisableDirectionCheck addc(this);
 
        // we start with a conic on odd indices when moving CW vs. even indices when moving CCW
        const bool startsWithConic = ((startIndex & 1) == (dir == SkPathDirection::kCW));
        const SkScalar weight = SK_ScalarRoot2Over2;
 
        SkDEBUGCODE(int initialVerbCount = fPathRef->countVerbs());
        SkDEBUGCODE(int initialPointCount = fPathRef->countPoints());
        SkDEBUGCODE(int initialWeightCount = fPathRef->countWeights());
        const int kVerbs = startsWithConic
            ? 9   // moveTo + 4x conicTo + 3x lineTo + close
            : 10; // moveTo + 4x lineTo + 4x conicTo + close
        const int kPoints = startsWithConic
            ? 12  // moveTo (1) + 4x conicTo (2) + 3x lineTo (1) + close
            : 13; // moveTo (1) + 4x lineTo (1) + 4x conicTo (2) + close
        const int kWeights = 4; // 4x conicTo
        this->incReserve(kPoints, kVerbs, kWeights);
 
        SkPath_RRectPointIterator rrectIter(rrect, dir, startIndex);
        // Corner iterator indices follow the collapsed radii model,
        // adjusted such that the start pt is "behind" the radii start pt.
        const unsigned rectStartIndex = startIndex / 2 + (dir == SkPathDirection::kCW ? 0 : 1);
        SkPath_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 (isRRect) {
            SkPathRef::Editor ed(&fPathRef);
            ed.setIsRRect(dir == SkPathDirection::kCCW, startIndex % 8);
        }
 
        SkASSERT(fPathRef->countVerbs() == initialVerbCount + kVerbs);
        SkASSERT(fPathRef->countPoints() == initialPointCount + kPoints);
        SkASSERT(fPathRef->countWeights() == initialWeightCount + kWeights);
    }
 
    SkDEBUGCODE(fPathRef->validate();)
    return *this;
}

◆ addRRect() [2/2]

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

Adds rrect to SkPath, creating a new closed contour. If dir is kCW_Direction, rrect starts at top-left of the lower-left corner and winds clockwise. If dir is kCCW_Direction, rrect starts at the bottom-left of the upper-left corner and winds counterclockwise.

After appending, SkPath may be empty, or may contain: SkRect, oval, or SkRRect.

Parameters

rrect	bounds and radii of rounded rectangle
dir	SkPath::Direction to wind SkRRect

Returns: reference to SkPath

example: https://fiddle.skia.org/c/@Path_addRRect

Definition at line 1000 of file SkPath.cpp.

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

◆ approximateBytesUsed()

size_t SkPath::approximateBytesUsed ( ) const

Returns the approximate byte size of the SkPath in memory.

Returns: approximate size

Definition at line 572 of file SkPath.cpp.

                                          {
    size_t size = sizeof (SkPath);
    if (fPathRef != nullptr) {
        size += fPathRef->approximateBytesUsed();
    }
    return size;
}

◆ arcTo() [1/5]

SkPath & SkPath::arcTo	(	const SkPoint	p1,
		const SkPoint	p2,
		SkScalar	radius
	)

inline

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 915 of file SkPath.h.

                                                                       {
        return this->arcTo(p1.fX, p1.fY, p2.fX, p2.fY, radius);
    }

◆ arcTo() [2/5]

SkPath & SkPath::arcTo	(	const SkPoint	r,
		SkScalar	xAxisRotate,
		ArcSize	largeArc,
		SkPathDirection	sweep,
		const SkPoint	xy
	)

inline

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 978 of file SkPath.h.

                                 {
        return this->arcTo(r.fX, r.fY, xAxisRotate, largeArc, sweep, xy.fX, xy.fY);
    }

◆ arcTo() [3/5]

SkPath & SkPath::arcTo	(	const SkRect &	oval,
		SkScalar	startAngle,
		SkScalar	sweepAngle,
		bool	forceMoveTo
	)

Appends arc to SkPath. 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 SkPath last SkPoint to initial arc SkPoint if forceMoveTo is false and SkPath 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
startAngle	starting angle of arc in degrees
sweepAngle	sweep, in degrees. Positive is clockwise; treated modulo 360
forceMoveTo	true to start a new contour with arc

Returns: reference to SkPath

example: https://fiddle.skia.org/c/@Path_arcTo

Definition at line 1220 of file SkPath.cpp.

                                        {
    if (oval.width() < 0 || oval.height() < 0) {
        return *this;
    }
 
    startAngle = SkScalarMod(startAngle, 360.0f);
 
    if (fPathRef->countVerbs() == 0) {
        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;
 
    bool isArc = this->hasOnlyMoveTos();
 
    // 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, &isArc, this](const SkPoint& pt) {
        SkPoint lastPt;
        if (forceMoveTo) {
            this->moveTo(pt);
        } else if (!this->getLastPt(&lastPt) ||
                   !SkScalarNearlyEqual(lastPt.fX, pt.fX) ||
                   !SkScalarNearlyEqual(lastPt.fY, pt.fY)) {
            this->lineTo(pt);
            isArc = false;
        }
    };
 
    // 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) {
        // Conics take two points. Add one to the verb in case there is a moveto.
        this->incReserve(count * 2 + 1, count + 1, count);
        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);
        }
        if (isArc) {
            SkPathRef::Editor ed(&fPathRef);
            ed.setIsArc(SkArc::Make(oval, startAngle, sweepAngle, SkArc::Type::kArc));
        }
    } else {
        addPt(singlePt);
    }
    return *this;
}

◆ arcTo() [4/5]

SkPath & SkPath::arcTo	(	SkScalar	rx,
		SkScalar	ry,
		SkScalar	xAxisRotate,
		SkPath::ArcSize	arcLarge,
		SkPathDirection	sweep,
		SkScalar	x,
		SkScalar	y
	)

Appends arc to SkPath. Arc is implemented by one or more conics weighted to describe part of oval with radii (rx, ry) rotated by xAxisRotate degrees. Arc curves from last SkPath SkPoint to (x, y), 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 (x, y) if either radii are zero, or if last SkPath SkPoint equals (x, y). arcTo() scales radii (rx, ry) to fit last SkPath SkPoint and (x, y) if both are greater than zero but too small.

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

rx	radius on x-axis before x-axis rotation
ry	radius on y-axis 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
x	end of arc
y	end of arc

Returns: reference to SkPath

Definition at line 1302 of file SkPath.cpp.

                                                                        {
    this->injectMoveToIfNeeded();
    SkPoint srcPts[2];
    this->getLastPt(&srcPts[0]);
    // 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 (!rx || !ry) {
        return this->lineTo(x, y);
    }
    // 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.
    srcPts[1].set(x, y);
    if (srcPts[0] == srcPts[1]) {
        return this->lineTo(x, y);
    }
    rx = SkScalarAbs(rx);
    ry = SkScalarAbs(ry);
    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(x, y);
    }
 
    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(x) && scalar_is_integer(y);
 
    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.
    this->setLastPt(x, y);
    return *this;
}

◆ arcTo() [5/5]

SkPath & SkPath::arcTo	(	SkScalar	x1,
		SkScalar	y1,
		SkScalar	x2,
		SkScalar	y2,
		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 (x1, y1), and tangent from (x1, y1) to (x2, y2). Arc is part of circle sized to radius, positioned so it touches both tangent lines.

If last Path Point does not start Arc, arcTo appends connecting Line to Path. The length of Vector from (x1, y1) to (x2, y2) 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 Path Point to (x1, y1).

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

Parameters

x1	x-axis value common to pair of tangents
y1	y-axis value common to pair of tangents
x2	x-axis value end of second tangent
y2	y-axis value end of second tangent
radius	distance from arc to circle center

Returns: reference to SkPath

example: https://fiddle.skia.org/c/@Path_arcTo_2_a example: https://fiddle.skia.org/c/@Path_arcTo_2_b example: https://fiddle.skia.org/c/@Path_arcTo_2_c

Definition at line 1467 of file SkPath.cpp.

                                                                                         {
    this->injectMoveToIfNeeded();
 
    if (radius == 0) {
        return this->lineTo(x1, y1);
    }
 
    // need to know our prev pt so we can construct tangent vectors
    SkPoint start;
    this->getLastPt(&start);
 
    // need double precision for these calcs.
    skvx::double2 befored = normalize(skvx::double2{x1 - start.fX, y1 - start.fY});
    skvx::double2 afterd = normalize(skvx::double2{x2 - x1, y2 - y1});
    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(x1, y1);
    }
 
    // safe to convert back to floats now
    SkScalar dist = SkScalarAbs(SkDoubleToScalar(radius * (1 - cosh) / sinh));
    SkScalar xx = x1 - dist * befored[0];
    SkScalar yy = y1 - 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(x1, y1, x1 + after.fX, y1 + after.fY, weight);
}

◆ Circle()

SkPath SkPath::Circle	(	SkScalar	center_x,
		SkScalar	center_y,
		SkScalar	radius,
		SkPathDirection	dir = `SkPathDirection::kCW`
	)

static

Definition at line 3598 of file SkPath.cpp.

                                                                             {
    return SkPathBuilder().addCircle(x, y, r, dir).detach();
}

◆ close()

SkPath & SkPath::close ( )

Appends kClose_Verb to SkPath. A closed contour connects the first and last SkPoint with line, forming a continuous loop. Open and closed contour draw the same with SkPaint::kFill_Style. With SkPaint::kStroke_Style, open contour draws SkPaint::Cap at contour start and end; closed contour draws SkPaint::Join at contour start and end.

close() has no effect if SkPath is empty or last SkPath SkPath::Verb is kClose_Verb.

Returns: reference to SkPath

example: https://fiddle.skia.org/c/@Path_close

Definition at line 823 of file SkPath.cpp.

                      {
    SkDEBUGCODE(this->validate();)
 
    int count = fPathRef->countVerbs();
    if (count > 0) {
        switch (fPathRef->atVerb(count - 1)) {
            case kLine_Verb:
            case kQuad_Verb:
            case kConic_Verb:
            case kCubic_Verb:
            case kMove_Verb: {
                SkPathRef::Editor ed(&fPathRef);
                ed.growForVerb(kClose_Verb);
                break;
            }
            case kClose_Verb:
                // don't add a close if it's the first verb or a repeat
                break;
            default:
                SkDEBUGFAIL("unexpected verb");
                break;
        }
    }
 
    // signal that we need a moveTo to follow us (unless we're done)
#if 0
    if (fLastMoveToIndex >= 0) {
        fLastMoveToIndex = ~fLastMoveToIndex;
    }
#else
    fLastMoveToIndex ^= ~fLastMoveToIndex >> (8 * sizeof(fLastMoveToIndex) - 1);
#endif
    return *this;
}

◆ computeTightBounds()

SkRect SkPath::computeTightBounds ( ) const

Returns minimum and maximum axes values of the lines and curves in SkPath. Returns (0, 0, 0, 0) if SkPath contains no points. Returned bounds width and height may be larger or smaller than area affected when SkPath is drawn.

Includes SkPoint associated with kMove_Verb that define empty contours.

Behaves identically to getBounds() when SkPath contains only lines. If SkPath contains curves, computed bounds includes the maximum extent of the quad, conic, or cubic; is slower than getBounds(); and unlike getBounds(), does not cache the result.

Returns: tight bounds of curves in SkPath

example: https://fiddle.skia.org/c/@Path_computeTightBounds

Definition at line 3446 of file SkPath.cpp.

                                        {
    if (0 == this->countVerbs()) {
        return SkRect::MakeEmpty();
    }
 
    if (this->getSegmentMasks() == SkPath::kLine_SegmentMask) {
        return this->getBounds();
    }
 
    SkPoint extremas[5]; // big enough to hold worst-case curve type (cubic) extremas + 1
 
    // initial with the first MoveTo, so we don't have to check inside the switch
    skvx::float2 min, max;
    min = max = from_point(this->getPoint(0));
    for (auto [verb, pts, w] : SkPathPriv::Iterate(*this)) {
        int count = 0;
        switch (verb) {
            case SkPathVerb::kMove:
                extremas[0] = pts[0];
                count = 1;
                break;
            case SkPathVerb::kLine:
                extremas[0] = pts[1];
                count = 1;
                break;
            case SkPathVerb::kQuad:
                count = compute_quad_extremas(pts, extremas);
                break;
            case SkPathVerb::kConic:
                count = compute_conic_extremas(pts, *w, extremas);
                break;
            case SkPathVerb::kCubic:
                count = compute_cubic_extremas(pts, extremas);
                break;
            case SkPathVerb::kClose:
                break;
        }
        for (int i = 0; i < count; ++i) {
            skvx::float2 tmp = from_point(extremas[i]);
            min = skvx::min(min, tmp);
            max = skvx::max(max, tmp);
        }
    }
    SkRect bounds;
    min.store((SkPoint*)&bounds.fLeft);
    max.store((SkPoint*)&bounds.fRight);
    return bounds;
}

◆ conicTo() [1/2]

SkPath & SkPath::conicTo	(	const SkPoint &	p1,
		const SkPoint &	p2,
		SkScalar	w
	)

inline

Adds conic from last point towards SkPoint p1, to SkPoint p2, weighted by w. If SkPath is empty, or last SkPath::Verb is kClose_Verb, last point is set to (0, 0) before adding conic.

Appends kMove_Verb to verb array and (0, 0) to SkPoint array, if needed.

If w is finite and not one, appends kConic_Verb to verb array; and SkPoint p1, p2 to SkPoint array; and w to conic weights.

If w is one, appends kQuad_Verb to verb array, and SkPoint p1, p2 to SkPoint array.

If w is not finite, appends kLine_Verb twice to verb array, and SkPoint p1, p2 to SkPoint array.

Parameters

p1	control SkPoint of added conic
p2	end SkPoint of added conic
w	weight of added conic

Returns: reference to SkPath

Definition at line 759 of file SkPath.h.

                                                                      {
        return this->conicTo(p1.fX, p1.fY, p2.fX, p2.fY, w);
    }

◆ conicTo() [2/2]

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

Adds conic from last point towards (x1, y1), to (x2, y2), weighted by w. If SkPath is empty, or last SkPath::Verb is kClose_Verb, last point is set to (0, 0) before adding conic.

Appends kMove_Verb to verb array and (0, 0) to SkPoint array, if needed.

If w is finite and not one, appends kConic_Verb to verb array; and (x1, y1), (x2, y2) to SkPoint array; and w to conic weights.

If w is one, appends kQuad_Verb to verb array, and (x1, y1), (x2, y2) to SkPoint array.

If w is not finite, appends kLine_Verb twice to verb array, and (x1, y1), (x2, y2) to SkPoint array.

Parameters

x1	control SkPoint of conic on x-axis
y1	control SkPoint of conic on y-axis
x2	end SkPoint of conic on x-axis
y2	end SkPoint of conic on y-axis
w	weight of added conic

Returns: reference to SkPath

Definition at line 766 of file SkPath.cpp.

                                    {
    // check for <= 0 or NaN with this test
    if (!(w > 0)) {
        this->lineTo(x2, y2);
    } else if (!SkIsFinite(w)) {
        this->lineTo(x1, y1);
        this->lineTo(x2, y2);
    } else if (SK_Scalar1 == w) {
        this->quadTo(x1, y1, x2, y2);
    } else {
        SkDEBUGCODE(this->validate();)
 
        this->injectMoveToIfNeeded();
 
        SkPathRef::Editor ed(&fPathRef);
        SkPoint* pts = ed.growForVerb(kConic_Verb, w);
        pts[0].set(x1, y1);
        pts[1].set(x2, y2);
 
        (void)this->dirtyAfterEdit();
    }
    return *this;
}

◆ conservativelyContainsRect()

bool SkPath::conservativelyContainsRect ( const SkRect & rect ) const

Returns true if rect is contained by SkPath. May return false when rect is contained by SkPath.

For now, only returns true if SkPath has one contour and is convex. rect may share points and edges with SkPath and be contained. Returns true if rect is empty, that is, it has zero width or height; and the SkPoint or line described by rect is contained by SkPath.

Parameters

rect	SkRect, line, or SkPoint checked for containment

Returns: true if rect is contained

example: https://fiddle.skia.org/c/@Path_conservativelyContainsRect

Definition at line 291 of file SkPath.cpp.

                                                                {
    // This only handles non-degenerate convex paths currently.
    if (!this->isConvex()) {
        return false;
    }
 
    SkPathFirstDirection direction = SkPathPriv::ComputeFirstDirection(*this);
    if (direction == SkPathFirstDirection::kUnknown) {
        return false;
    }
 
    SkPoint firstPt;
    SkPoint prevPt;
    int segmentCount = 0;
    SkDEBUGCODE(int moveCnt = 0;)
 
    for (auto [verb, pts, weight] : SkPathPriv::Iterate(*this)) {
        if (verb == SkPathVerb::kClose || (segmentCount > 0 && verb == SkPathVerb::kMove)) {
            // Closing the current contour; but since convexity is a precondition, it's the only
            // contour that matters.
            SkASSERT(moveCnt);
            segmentCount++;
            break;
        } else if (verb == SkPathVerb::kMove) {
            // A move at the start of the contour (or multiple leading moves, in which case we
            // keep the last one before a non-move verb).
            SkASSERT(!segmentCount);
            SkDEBUGCODE(++moveCnt);
            firstPt = prevPt = pts[0];
        } else {
            int pointCount = SkPathPriv::PtsInVerb((unsigned) verb);
            SkASSERT(pointCount > 0);
 
            if (!SkPathPriv::AllPointsEq(pts, pointCount + 1)) {
                SkASSERT(moveCnt);
                int nextPt = pointCount;
                segmentCount++;
 
                if (prevPt == pts[nextPt]) {
                    // A pre-condition to getting here is that the path is convex, so if a
                    // verb's start and end points are the same, it means it's the only
                    // verb in the contour (and the only contour). While it's possible for
                    // such a single verb to be a convex curve, we do not have any non-zero
                    // length edges to conservatively test against without splitting or
                    // evaluating the curve. For simplicity, just reject the rectangle.
                    return false;
                } else if (SkPathVerb::kConic == verb) {
                    SkConic orig;
                    orig.set(pts, *weight);
                    SkPoint quadPts[5];
                    int count = orig.chopIntoQuadsPOW2(quadPts, 1);
                    SkASSERT_RELEASE(2 == count);
 
                    if (!check_edge_against_rect(quadPts[0], quadPts[2], rect, direction)) {
                        return false;
                    }
                    if (!check_edge_against_rect(quadPts[2], quadPts[4], rect, direction)) {
                        return false;
                    }
                } else {
                    if (!check_edge_against_rect(prevPt, pts[nextPt], rect, direction)) {
                        return false;
                    }
                }
                prevPt = pts[nextPt];
            }
        }
    }
 
    if (segmentCount) {
        return check_edge_against_rect(prevPt, firstPt, rect, direction);
    }
    return false;
}

◆ contains()

bool SkPath::contains	(	SkScalar	x,
		SkScalar	y
	)		const

Returns true if the point (x, y) is contained by SkPath, taking into account FillType.

Parameters

x	x-axis value of containment test
y	y-axis value of containment test

Returns: true if SkPoint is in SkPath

example: https://fiddle.skia.org/c/@Path_contains

Definition at line 3118 of file SkPath.cpp.

                                                  {
    bool isInverse = this->isInverseFillType();
    if (this->isEmpty()) {
        return isInverse;
    }
 
    if (!contains_inclusive(this->getBounds(), x, y)) {
        return isInverse;
    }
 
    SkPath::Iter iter(*this, true);
    bool done = false;
    int w = 0;
    int onCurveCount = 0;
    do {
        SkPoint pts[4];
        switch (iter.next(pts)) {
            case SkPath::kMove_Verb:
            case SkPath::kClose_Verb:
                break;
            case SkPath::kLine_Verb:
                w += winding_line(pts, x, y, &onCurveCount);
                break;
            case SkPath::kQuad_Verb:
                w += winding_quad(pts, x, y, &onCurveCount);
                break;
            case SkPath::kConic_Verb:
                w += winding_conic(pts, x, y, iter.conicWeight(), &onCurveCount);
                break;
            case SkPath::kCubic_Verb:
                w += winding_cubic(pts, x, y, &onCurveCount);
                break;
            case SkPath::kDone_Verb:
                done = true;
                break;
       }
    } while (!done);
    bool evenOddFill = SkPathFillType::kEvenOdd        == this->getFillType()
                    || SkPathFillType::kInverseEvenOdd == this->getFillType();
    if (evenOddFill) {
        w &= 1;
    }
    if (w) {
        return !isInverse;
    }
    if (onCurveCount <= 1) {
        return SkToBool(onCurveCount) ^ isInverse;
    }
    if ((onCurveCount & 1) || evenOddFill) {
        return SkToBool(onCurveCount & 1) ^ isInverse;
    }
    // If the point touches an even number of curves, and the fill is winding, check for
    // coincidence. Count coincidence as places where the on curve points have identical tangents.
    iter.setPath(*this, true);
    done = false;
    SkTDArray<SkVector> tangents;
    do {
        SkPoint pts[4];
        int oldCount = tangents.size();
        switch (iter.next(pts)) {
            case SkPath::kMove_Verb:
            case SkPath::kClose_Verb:
                break;
            case SkPath::kLine_Verb:
                tangent_line(pts, x, y, &tangents);
                break;
            case SkPath::kQuad_Verb:
                tangent_quad(pts, x, y, &tangents);
                break;
            case SkPath::kConic_Verb:
                tangent_conic(pts, x, y, iter.conicWeight(), &tangents);
                break;
            case SkPath::kCubic_Verb:
                tangent_cubic(pts, x, y, &tangents);
                break;
            case SkPath::kDone_Verb:
                done = true;
                break;
       }
       if (tangents.size() > oldCount) {
            int last = tangents.size() - 1;
            const SkVector& tangent = tangents[last];
            if (SkScalarNearlyZero(SkPointPriv::LengthSqd(tangent))) {
                tangents.remove(last);
            } else {
                for (int index = 0; index < last; ++index) {
                    const SkVector& test = tangents[index];
                    if (SkScalarNearlyZero(test.cross(tangent))
                            && SkScalarSignAsInt(tangent.fX * test.fX) <= 0
                            && SkScalarSignAsInt(tangent.fY * test.fY) <= 0) {
                        tangents.remove(last);
                        tangents.removeShuffle(index);
                        break;
                    }
                }
            }
        }
    } while (!done);
    return SkToBool(tangents.size()) ^ isInverse;
}

◆ ConvertConicToQuads()

int SkPath::ConvertConicToQuads	(	const SkPoint &	p0,
		const SkPoint &	p1,
		const SkPoint &	p2,
		SkScalar	w,
		SkPoint	pts[],
		int	pow2
	)

static

Approximates conic with quad array. Conic is constructed from start SkPoint p0, control SkPoint p1, end SkPoint p2, and weight w. Quad array is stored in pts; this storage is supplied by caller. Maximum quad count is 2 to the pow2. Every third point in array shares last SkPoint of previous quad and first SkPoint of next quad. Maximum pts storage size is given by: (1 + 2 * (1 << pow2)) * sizeof(SkPoint).

Returns quad count used the approximation, which may be smaller than the number requested.

conic weight determines the amount of influence conic control point has on the curve. w less than one represents an elliptical section. w greater than one represents a hyperbolic section. w equal to one represents a parabolic section.

Two quad curves are sufficient to approximate an elliptical conic with a sweep of up to 90 degrees; in this case, set pow2 to one.

Parameters

p0	conic start SkPoint
p1	conic control SkPoint
p2	conic end SkPoint
w	conic weight
pts	storage for quad array
pow2	quad count, as power of two, normally 0 to 5 (1 to 32 quad curves)

Returns: number of quad curves written to pts

Definition at line 3238 of file SkPath.cpp.

                                                                     {
    const SkConic conic(p0, p1, p2, w);
    return conic.chopIntoQuadsPOW2(pts, pow2);
}

◆ countPoints()

int SkPath::countPoints ( ) const

Returns the number of points in SkPath. SkPoint count is initially zero.

Returns: SkPath SkPoint array length

example: https://fiddle.skia.org/c/@Path_countPoints

Definition at line 535 of file SkPath.cpp.

                              {
    return fPathRef->countPoints();
}

◆ countVerbs()

int SkPath::countVerbs ( ) const

Returns the number of verbs: kMove_Verb, kLine_Verb, kQuad_Verb, kConic_Verb, kCubic_Verb, and kClose_Verb; added to SkPath.

Returns: length of verb array

example: https://fiddle.skia.org/c/@Path_countVerbs

Definition at line 556 of file SkPath.cpp.

                             {
    return fPathRef->countVerbs();
}

◆ cubicTo() [1/2]

SkPath & SkPath::cubicTo	(	const SkPoint &	p1,
		const SkPoint &	p2,
		const SkPoint &	p3
	)

inline

Adds cubic from last point towards SkPoint p1, then towards SkPoint p2, ending at SkPoint p3. If SkPath is empty, or last SkPath::Verb is kClose_Verb, last point is set to (0, 0) before adding cubic.

Appends kMove_Verb to verb array and (0, 0) to SkPoint array, if needed; then appends kCubic_Verb to verb array; and SkPoint p1, p2, p3 to SkPoint array.

Parameters

p1	first control SkPoint of cubic
p2	second control SkPoint of cubic
p3	end SkPoint of cubic

Returns: reference to SkPath

Definition at line 823 of file SkPath.h.

                                                                             {
        return this->cubicTo(p1.fX, p1.fY, p2.fX, p2.fY, p3.fX, p3.fY);
    }

◆ cubicTo() [2/2]

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

Adds cubic from last point towards (x1, y1), then towards (x2, y2), ending at (x3, y3). If SkPath is empty, or last SkPath::Verb is kClose_Verb, last point is set to (0, 0) before adding cubic.

Appends kMove_Verb to verb array and (0, 0) to SkPoint array, if needed; then appends kCubic_Verb to verb array; and (x1, y1), (x2, y2), (x3, y3) to SkPoint array.

Parameters

x1	first control SkPoint of cubic on x-axis
y1	first control SkPoint of cubic on y-axis
x2	second control SkPoint of cubic on x-axis
y2	second control SkPoint of cubic on y-axis
x3	end SkPoint of cubic on x-axis
y3	end SkPoint of cubic on y-axis

Returns: reference to SkPath

Definition at line 799 of file SkPath.cpp.

                                                  {
    SkDEBUGCODE(this->validate();)
 
    this->injectMoveToIfNeeded();
 
    SkPathRef::Editor ed(&fPathRef);
    SkPoint* pts = ed.growForVerb(kCubic_Verb);
    pts[0].set(x1, y1);
    pts[1].set(x2, y2);
    pts[2].set(x3, y3);
 
    return this->dirtyAfterEdit();
}

◆ detach()

SkPath SkPath::detach ( )

inline

Returns a copy of this path in the current state, and resets the path to empty.

Definition at line 147 of file SkPath.h.

                    {
        SkPath result = *this;
        this->reset();
        return result;
    }

◆ dump() [1/2]

void SkPath::dump ( ) const

inline

Definition at line 1734 of file SkPath.h.

1734{ this->dump(nullptr, false); }

SkPath::dump

void dump() const

Definition: SkPath.h:1734

◆ dump() [2/2]

void SkPath::dump	(	SkWStream *	stream,
		bool	dumpAsHex
	)		const

Writes text representation of SkPath to stream. If stream is nullptr, writes to standard output. Set dumpAsHex true to generate exact binary representations of floating point numbers used in SkPoint array and conic weights.

Parameters

stream	writable SkWStream receiving SkPath text representation; may be nullptr
dumpAsHex	true if SkScalar values are written as hexadecimal

example: https://fiddle.skia.org/c/@Path_dump

Definition at line 2040 of file SkPath.cpp.

                                                          {
    SkScalarAsStringType asType = dumpAsHex ? kHex_SkScalarAsStringType : kDec_SkScalarAsStringType;
    Iter    iter(*this, false);
    SkPoint pts[4];
    Verb    verb;
 
    SkString builder;
    char const * const gFillTypeStrs[] = {
        "Winding",
        "EvenOdd",
        "InverseWinding",
        "InverseEvenOdd",
    };
    builder.printf("path.setFillType(SkPathFillType::k%s);\n",
            gFillTypeStrs[(int) this->getFillType()]);
    while ((verb = iter.next(pts)) != kDone_Verb) {
        switch (verb) {
            case kMove_Verb:
                append_params(&builder, "path.moveTo", &pts[0], 1, asType);
                break;
            case kLine_Verb:
                append_params(&builder, "path.lineTo", &pts[1], 1, asType);
                break;
            case kQuad_Verb:
                append_params(&builder, "path.quadTo", &pts[1], 2, asType);
                break;
            case kConic_Verb:
                append_params(&builder, "path.conicTo", &pts[1], 2, asType, iter.conicWeight());
                break;
            case kCubic_Verb:
                append_params(&builder, "path.cubicTo", &pts[1], 3, asType);
                break;
            case kClose_Verb:
                builder.append("path.close();\n");
                break;
            default:
                SkDebugf("  path: UNKNOWN VERB %d, aborting dump...\n", verb);
                verb = kDone_Verb;  // stop the loop
                break;
        }
        if (!wStream && builder.size()) {
            SkDebugf("%s", builder.c_str());
            builder.reset();
        }
    }
    if (wStream) {
        wStream->writeText(builder.c_str());
    }
}

◆ dumpArrays() [1/2]

void SkPath::dumpArrays ( ) const

inline

Definition at line 1739 of file SkPath.h.

1739{ this->dumpArrays(nullptr, false); }

SkPath::dumpArrays

void dumpArrays() const

Definition: SkPath.h:1739

◆ dumpArrays() [2/2]

void SkPath::dumpArrays	(	SkWStream *	stream,
		bool	dumpAsHex
	)		const

Definition at line 2090 of file SkPath.cpp.

                                                                {
    SkString builder;
 
    auto bool_str = [](bool v) { return v ? "true" : "false"; };
 
    builder.appendf("// fBoundsIsDirty = %s\n", bool_str(fPathRef->fBoundsIsDirty));
    builder.appendf("// fGenerationID = %u\n", fPathRef->fGenerationID);
    builder.appendf("// fSegmentMask = %d\n", fPathRef->fSegmentMask);
 
    const char* gTypeStrs[] = {
        "General", "Oval", "RRect",
    };
    builder.appendf("// fType = %s\n", gTypeStrs[static_cast<int>(fPathRef->fType)]);
 
    auto append_scalar = [&](SkScalar v) {
        if (dumpAsHex) {
            builder.appendf("SkBits2Float(0x%08X) /* %g */", SkFloat2Bits(v), v);
        } else {
            builder.appendf("%g", v);
        }
    };
 
    builder.append("const SkPoint path_points[] = {\n");
    for (int i = 0; i < this->countPoints(); ++i) {
        SkPoint p = this->getPoint(i);
        builder.append("    { ");
        append_scalar(p.fX);
        builder.append(", ");
        append_scalar(p.fY);
        builder.append(" },\n");
    }
    builder.append("};\n");
 
    const char* gVerbStrs[] = {
        "Move", "Line", "Quad", "Conic", "Cubic", "Close"
    };
    builder.append("const uint8_t path_verbs[] = {\n    ");
    for (auto v = fPathRef->verbsBegin(); v != fPathRef->verbsEnd(); ++v) {
        builder.appendf("(uint8_t)SkPathVerb::k%s, ", gVerbStrs[*v]);
    }
    builder.append("\n};\n");
 
    const int nConics = fPathRef->conicWeightsEnd() - fPathRef->conicWeights();
    if (nConics) {
        builder.append("const SkScalar path_conics[] = {\n    ");
        for (auto c = fPathRef->conicWeights(); c != fPathRef->conicWeightsEnd(); ++c) {
            append_scalar(*c);
            builder.append(", ");
        }
        builder.append("\n};\n");
    }
 
    char const * const gFillTypeStrs[] = {
        "Winding",
        "EvenOdd",
        "InverseWinding",
        "InverseEvenOdd",
    };
 
    builder.appendf("SkPath path = SkPath::Make(path_points, %d, path_verbs, %d, %s, %d,\n",
                    this->countPoints(), this->countVerbs(),
                    nConics ? "path_conics" : "nullptr", nConics);
    builder.appendf("                           SkPathFillType::k%s, %s);\n",
                    gFillTypeStrs[(int)this->getFillType()],
                    bool_str(fIsVolatile));
 
    if (wStream) {
        wStream->writeText(builder.c_str());
    } else {
        SkDebugf("%s\n", builder.c_str());
    }
}

◆ dumpHex()

void SkPath::dumpHex ( ) const

inline

Definition at line 1735 of file SkPath.h.

1735{ this->dump(nullptr, true); }

◆ getBounds()

const SkRect & SkPath::getBounds ( ) const

Returns minimum and maximum axes values of SkPoint array. Returns (0, 0, 0, 0) if SkPath contains no points. Returned bounds width and height may be larger or smaller than area affected when SkPath is drawn.

SkRect returned includes all SkPoint added to SkPath, including SkPoint associated with kMove_Verb that define empty contours.

Returns: bounds of all SkPoint in SkPoint array

Definition at line 430 of file SkPath.cpp.

                                      {
    return fPathRef->getBounds();
}

◆ getFillType()

SkPathFillType SkPath::getFillType ( ) const

inline

Returns SkPathFillType, the rule used to fill SkPath.

Returns: current SkPathFillType setting

Definition at line 230 of file SkPath.h.

230{ return (SkPathFillType)fFillType; }

SkPathFillType

Definition: SkPathTypes.h:11

◆ getGenerationID()

uint32_t SkPath::getGenerationID ( ) const

(See Skia bug 1762.) Returns a non-zero, globally unique value. A different value is returned if verb array, SkPoint array, or conic weight changes.

Setting SkPath::FillType does not change generation identifier.

Each time the path is modified, a different generation identifier will be returned. SkPath::FillType does affect generation identifier on Android framework.

Returns: non-zero, globally unique value

example: https://fiddle.skia.org/c/@Path_getGenerationID

Definition at line 366 of file SkPath.cpp.

                                       {
    return fPathRef->genID(fFillType);
}

◆ getLastPt()

bool SkPath::getLastPt ( SkPoint * lastPt ) const

Returns last point on SkPath in lastPt. Returns false if SkPoint array is empty, storing (0, 0) if lastPt is not nullptr.

Parameters

lastPt storage for final SkPoint in SkPoint array; may be nullptr

Returns: true if SkPoint array contains one or more SkPoint

example: https://fiddle.skia.org/c/@Path_getLastPt

Definition at line 580 of file SkPath.cpp.

                                            {
    SkDEBUGCODE(this->validate();)
 
    int count = fPathRef->countPoints();
    if (count > 0) {
        if (lastPt) {
            *lastPt = fPathRef->atPoint(count - 1);
        }
        return true;
    }
    if (lastPt) {
        lastPt->set(0, 0);
    }
    return false;
}

◆ getPoint()

SkPoint SkPath::getPoint ( int index ) const

Returns SkPoint at index in SkPoint array. Valid range for index is 0 to countPoints() - 1. Returns (0, 0) if index is out of range.

Parameters

index SkPoint array element selector

Returns: SkPoint array value or (0, 0)

example: https://fiddle.skia.org/c/@Path_getPoint

Definition at line 549 of file SkPath.cpp.

                                        {
    if ((unsigned)index < (unsigned)fPathRef->countPoints()) {
        return fPathRef->atPoint(index);
    }
    return SkPoint::Make(0, 0);
}

◆ getPoints()

int SkPath::getPoints	(	SkPoint	points[],
		int	max
	)		const

Returns number of points in SkPath. Up to max points are copied. points may be nullptr; then, max must be zero. If max is greater than number of points, excess points storage is unaltered.

Parameters

points	storage for SkPath SkPoint array. May be nullptr
max	maximum to copy; must be greater than or equal to zero

Returns: SkPath SkPoint array length

example: https://fiddle.skia.org/c/@Path_getPoints

Definition at line 539 of file SkPath.cpp.

                                                  {
    SkDEBUGCODE(this->validate();)
 
    SkASSERT(max >= 0);
    SkASSERT(!max || dst);
    int count = std::min(max, fPathRef->countPoints());
    sk_careful_memcpy(dst, fPathRef->points(), count * sizeof(SkPoint));
    return fPathRef->countPoints();
}

◆ getSegmentMasks()

uint32_t SkPath::getSegmentMasks ( ) const

Returns a mask, where each set bit corresponds to a SegmentMask constant if SkPath contains one or more verbs of that type. Returns zero if SkPath contains no lines, or curves: quads, conics, or cubics.

getSegmentMasks() returns a cached result; it is very fast.

Returns: SegmentMask bits or zero

Definition at line 434 of file SkPath.cpp.

                                       {
    return fPathRef->getSegmentMasks();
}

◆ getVerbs()

int SkPath::getVerbs	(	uint8_t	verbs[],
		int	max
	)		const

Returns the number of verbs in the path. Up to max verbs are copied. The verbs are copied as one byte per verb.

Parameters

verbs	storage for verbs, may be nullptr
max	maximum number to copy into verbs

Returns: the actual number of verbs in the path

example: https://fiddle.skia.org/c/@Path_getVerbs

Definition at line 560 of file SkPath.cpp.

                                                 {
    SkDEBUGCODE(this->validate();)
 
    SkASSERT(max >= 0);
    SkASSERT(!max || dst);
    int count = std::min(max, fPathRef->countVerbs());
    if (count) {
        memcpy(dst, fPathRef->verbsBegin(), count);
    }
    return fPathRef->countVerbs();
}

◆ incReserve()

void SkPath::incReserve	(	int	extraPtCount,
		int	extraVerbCount = `0`,
		int	extraConicCount = `0`
	)

Grows SkPath verb array, SkPoint array, and conics to contain additional space. May improve performance and use less memory by reducing the number and size of allocations when creating SkPath.

Parameters

extraPtCount	number of additional SkPoint to allocate
extraVerbCount	number of additional verbs
extraConicCount	number of additional conics

example: https://fiddle.skia.org/c/@Path_incReserve

Definition at line 678 of file SkPath.cpp.

                                                                                 {
    SkDEBUGCODE(this->validate();)
    if (extraPtCount > 0) {
        // For compat with when this function only took a single argument, use
        // extraPtCount if extraVerbCount is 0 (default value).
        SkPathRef::Editor(&fPathRef, extraVerbCount == 0 ? extraPtCount : extraVerbCount, extraPtCount, extraConicCount);
    }
    SkDEBUGCODE(this->validate();)
}

◆ interpolate()

bool SkPath::interpolate	(	const SkPath &	ending,
		SkScalar	weight,
		SkPath *	out
	)		const

Interpolates between SkPath with SkPoint array of equal size. Copy verb array and weights to out, and set out SkPoint array to a weighted average of this SkPoint array and ending SkPoint array, using the formula: (Path Point * weight) + ending Point * (1 - weight).

weight is most useful when between zero (ending SkPoint array) and one (this Point_Array); will work with values outside of this range.

interpolate() returns false and leaves out unchanged if SkPoint array is not the same size as ending SkPoint array. Call isInterpolatable() to check SkPath compatibility prior to calling interpolate().

Parameters

ending	SkPoint array averaged with this SkPoint array
weight	contribution of this SkPoint array, and one minus contribution of ending SkPoint array
out	SkPath replaced by interpolated averages

Returns: true if SkPath contain same number of SkPoint

example: https://fiddle.skia.org/c/@Path_interpolate

Definition at line 250 of file SkPath.cpp.

                                                                                 {
    int pointCount = fPathRef->countPoints();
    if (pointCount != ending.fPathRef->countPoints()) {
        return false;
    }
    if (!pointCount) {
        return true;
    }
    out->reset();
    out->addPath(*this);
    SkPathRef::Editor editor(&(out->fPathRef));
    fPathRef->interpolate(*ending.fPathRef, weight, out->fPathRef.get());
    return true;
}

◆ isArc()

bool SkPath::isArc ( SkArc * arc ) const

Returns true if path is representable as an oval arc. In other words, could this path be drawn using SkCanvas::drawArc.

arc receives parameters of arc

Parameters

arc	storage for arc; may be nullptr

Returns: true if SkPath contains only a single arc from an oval

Definition at line 531 of file SkPath.cpp.

                                   {
    return fPathRef->isArc(arc);
}

◆ isConvex()

bool SkPath::isConvex ( ) const

Returns true if the path is convex. If necessary, it will first compute the convexity.

Definition at line 426 of file SkPath.cpp.

                            {
    return SkPathConvexity::kConvex == this->getConvexity();
}

◆ IsCubicDegenerate()

bool SkPath::IsCubicDegenerate	(	const SkPoint &	p1,
		const SkPoint &	p2,
		const SkPoint &	p3,
		const SkPoint &	p4,
		bool	exact
	)

static

Tests if cubic is degenerate. Cubic with no length or that moves a very short distance is degenerate; it is treated as a point.

Parameters

p1	cubic start point
p2	cubic control point 1
p3	cubic control point 2
p4	cubic end point
exact	if true, returns true only if p1, p2, p3, and p4 are equal; if false, returns true if p1, p2, p3, and p4 are equal or nearly equal

Returns: true if cubic is degenerate; its length is effectively zero

Definition at line 3505 of file SkPath.cpp.

                                                                                  {
    return exact ? p1 == p2 && p2 == p3 && p3 == p4 :
            SkPointPriv::EqualsWithinTolerance(p1, p2) &&
            SkPointPriv::EqualsWithinTolerance(p2, p3) &&
            SkPointPriv::EqualsWithinTolerance(p3, p4);
}

◆ isEmpty()

bool SkPath::isEmpty ( ) const

Returns if SkPath is empty. Empty SkPath may have FillType but has no SkPoint, SkPath::Verb, or conic weight. SkPath() constructs empty SkPath; reset() and rewind() make SkPath empty.

Returns: true if the path contains no SkPath::Verb array

Definition at line 416 of file SkPath.cpp.

                           {
    SkDEBUGCODE(this->validate();)
    return 0 == fPathRef->countVerbs();
}

◆ isFinite()

bool SkPath::isFinite ( ) const

Returns true for finite SkPoint array values between negative SK_ScalarMax and positive SK_ScalarMax. Returns false for any SkPoint array value of SK_ScalarInfinity, SK_ScalarNegativeInfinity, or SK_ScalarNaN.

Returns: true if all SkPoint values are finite

Definition at line 421 of file SkPath.cpp.

                            {
    SkDEBUGCODE(this->validate();)
    return fPathRef->isFinite();
}

◆ isInterpolatable()

bool SkPath::isInterpolatable ( const SkPath & compare ) const

Returns true if SkPath contain equal verbs and equal weights. If SkPath contain one or more conics, the weights must match.

conicTo() may add different verbs depending on conic weight, so it is not trivial to interpolate a pair of SkPath containing conics with different conic weight values.

Parameters

compare SkPath to compare

Returns: true if SkPath verb array and weights are equivalent

example: https://fiddle.skia.org/c/@Path_isInterpolatable

Definition at line 243 of file SkPath.cpp.

                                                         {
    // need the same structure (verbs, conicweights) and same point-count
    return fPathRef->fPoints.size() == compare.fPathRef->fPoints.size() &&
           fPathRef->fVerbs == compare.fPathRef->fVerbs &&
           fPathRef->fConicWeights == compare.fPathRef->fConicWeights;
}

◆ isInverseFillType()

bool SkPath::isInverseFillType ( ) const

inline

Returns if FillType describes area outside SkPath geometry. The inverse fill area extends indefinitely.

Returns: true if FillType is kInverseWinding or kInverseEvenOdd

Definition at line 244 of file SkPath.h.

244{ return SkPathFillType_IsInverse(this->getFillType()); }

SkPathFillType_IsInverse

static bool SkPathFillType_IsInverse(SkPathFillType ft)

Definition: SkPathTypes.h:26

◆ isLastContourClosed()

bool SkPath::isLastContourClosed ( ) const

Returns if contour is closed. Contour is closed if SkPath SkPath::Verb array was last modified by close(). When stroked, closed contour draws SkPaint::Join instead of SkPaint::Cap at first and last SkPoint.

Returns: true if the last contour ends with a kClose_Verb

example: https://fiddle.skia.org/c/@Path_isLastContourClosed

Definition at line 390 of file SkPath.cpp.

                                       {
    int verbCount = fPathRef->countVerbs();
    if (0 == verbCount) {
        return false;
    }
    return kClose_Verb == fPathRef->atVerb(verbCount - 1);
}

◆ isLine()

bool SkPath::isLine ( SkPoint line[2] ) const

Returns true if SkPath contains only one line; SkPath::Verb array has two entries: kMove_Verb, kLine_Verb. If SkPath contains one line and line is not nullptr, line is set to line start point and line end point. Returns false if SkPath is not one line; line is unaltered.

Parameters

line	storage for line. May be nullptr

Returns: true if SkPath contains exactly one line

example: https://fiddle.skia.org/c/@Path_isLine

Definition at line 398 of file SkPath.cpp.

                                         {
    int verbCount = fPathRef->countVerbs();
 
    if (2 == verbCount) {
        SkASSERT(kMove_Verb == fPathRef->atVerb(0));
        if (kLine_Verb == fPathRef->atVerb(1)) {
            SkASSERT(2 == fPathRef->countPoints());
            if (line) {
                const SkPoint* pts = fPathRef->points();
                line[0] = pts[0];
                line[1] = pts[1];
            }
            return true;
        }
    }
    return false;
}

◆ IsLineDegenerate()

bool SkPath::IsLineDegenerate	(	const SkPoint &	p1,
		const SkPoint &	p2,
		bool	exact
	)

static

Tests if line between SkPoint pair is degenerate. Line with no length or that moves a very short distance is degenerate; it is treated as a point.

exact changes the equality test. If true, returns true only if p1 equals p2. If false, returns true if p1 equals or nearly equals p2.

Parameters

p1	line start point
p2	line end point
exact	if false, allow nearly equals

Returns: true if line is degenerate; its length is effectively zero

example: https://fiddle.skia.org/c/@Path_IsLineDegenerate

Definition at line 3495 of file SkPath.cpp.

                                                                              {
    return exact ? p1 == p2 : SkPointPriv::EqualsWithinTolerance(p1, p2);
}

◆ isOval()

bool SkPath::isOval ( SkRect * bounds ) const

Returns true if this path is recognized as an oval or circle.

bounds receives bounds of oval.

bounds is unmodified if oval is not found.

Parameters

bounds storage for bounding SkRect of oval; may be nullptr

Returns: true if SkPath is recognized as an oval or circle

example: https://fiddle.skia.org/c/@Path_isOval

Definition at line 523 of file SkPath.cpp.

                                        {
    return SkPathPriv::IsOval(*this, bounds, nullptr, nullptr);
}

◆ IsQuadDegenerate()

bool SkPath::IsQuadDegenerate	(	const SkPoint &	p1,
		const SkPoint &	p2,
		const SkPoint &	p3,
		bool	exact
	)

static

Tests if quad is degenerate. Quad with no length or that moves a very short distance is degenerate; it is treated as a point.

Parameters

p1	quad start point
p2	quad control point
p3	quad end point
exact	if true, returns true only if p1, p2, and p3 are equal; if false, returns true if p1, p2, and p3 are equal or nearly equal

Returns: true if quad is degenerate; its length is effectively zero

Definition at line 3499 of file SkPath.cpp.

                                                               {
    return exact ? p1 == p2 && p2 == p3 : SkPointPriv::EqualsWithinTolerance(p1, p2) &&
            SkPointPriv::EqualsWithinTolerance(p2, p3);
}

◆ isRect()

bool SkPath::isRect	(	SkRect *	rect,
		bool *	isClosed = `nullptr`,
		SkPathDirection *	direction = `nullptr`
	)		const

Returns true if SkPath is equivalent to SkRect when filled. If false: rect, isClosed, and direction are unchanged. If true: rect, isClosed, and direction are written to if not nullptr.

rect may be smaller than the SkPath bounds. SkPath bounds may include kMove_Verb points that do not alter the area drawn by the returned rect.

Parameters

rect	storage for bounds of SkRect; may be nullptr
isClosed	storage set to true if SkPath is closed; may be nullptr
direction	storage set to SkRect direction; may be nullptr

Returns: true if SkPath contains SkRect

example: https://fiddle.skia.org/c/@Path_isRect

Definition at line 516 of file SkPath.cpp.

                                                                                  {
    SkDEBUGCODE(this->validate();)
    int currVerb = 0;
    const SkPoint* pts = fPathRef->points();
    return SkPathPriv::IsRectContour(*this, false, &currVerb, &pts, isClosed, direction, rect);
}

◆ isRRect()

bool SkPath::isRRect ( SkRRect * rrect ) const

Returns true if path is representable as SkRRect. Returns false if path is representable as oval, circle, or SkRect.

rrect receives bounds of SkRRect.

rrect is unmodified if SkRRect is not found.

Parameters

rrect storage for bounding SkRect of SkRRect; may be nullptr

Returns: true if SkPath contains only SkRRect

example: https://fiddle.skia.org/c/@Path_isRRect

Definition at line 527 of file SkPath.cpp.

                                         {
    return SkPathPriv::IsRRect(*this, rrect, nullptr, nullptr);
}

◆ isValid()

bool SkPath::isValid ( ) const

Returns if SkPath data is consistent. Corrupt SkPath data is detected if internal values are out of range or internal storage does not match array dimensions.

Returns: true if SkPath data is consistent

Definition at line 438 of file SkPath.cpp.

                           {
    return this->isValidImpl() && fPathRef->isValid();
}

◆ isVolatile()

bool SkPath::isVolatile ( ) const

inline

Returns true if the path is volatile; it will not be altered or discarded by the caller after it is drawn. SkPath by default have volatile set false, allowing SkSurface to attach a cache of data which speeds repeated drawing. If true, SkSurface may not speed repeated drawing.

Returns: true if caller will alter SkPath after drawing

Definition at line 350 of file SkPath.h.

                            {
        return SkToBool(fIsVolatile);
    }

◆ Line()

static SkPath SkPath::Line	(	const SkPoint	a,
		const SkPoint	b
	)

inlinestatic

Definition at line 106 of file SkPath.h.

                                                         {
        return Polygon({a, b}, false);
    }

◆ lineTo() [1/2]

SkPath & SkPath::lineTo ( const SkPoint & p )

inline

Adds line from last point to SkPoint p. If SkPath is empty, or last SkPath::Verb is kClose_Verb, last point is set to (0, 0) before adding line.

lineTo() first appends kMove_Verb to verb array and (0, 0) to SkPoint array, if needed. lineTo() then appends kLine_Verb to verb array and SkPoint p to SkPoint array.

Parameters

p	end SkPoint of added line

Returns: reference to SkPath

Definition at line 634 of file SkPath.h.

                                     {
        return this->lineTo(p.fX, p.fY);
    }

◆ lineTo() [2/2]

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

Adds line from last point to (x, y). If SkPath is empty, or last SkPath::Verb is kClose_Verb, last point is set to (0, 0) before adding line.

lineTo() appends kMove_Verb to verb array and (0, 0) to SkPoint array, if needed. lineTo() then appends kLine_Verb to verb array and (x, y) to SkPoint array.

Parameters

x	end of added line on x-axis
y	end of added line on y-axis

Returns: reference to SkPath

example: https://fiddle.skia.org/c/@Path_lineTo

Definition at line 728 of file SkPath.cpp.

                                             {
    SkDEBUGCODE(this->validate();)
 
    this->injectMoveToIfNeeded();
 
    SkPathRef::Editor ed(&fPathRef);
    ed.growForVerb(kLine_Verb)->set(x, y);
 
    return this->dirtyAfterEdit();
}

◆ Make()

SkPath SkPath::Make	(	const SkPoint	pts[],
		int	pointCount,
		const uint8_t	vbs[],
		int	verbCount,
		const SkScalar	ws[],
		int	conicWeightCount,
		SkPathFillType	ft,
		bool	isVolatile = `false`
	)

static

Create a new path with the specified segments.

The points and weights arrays are read in order, based on the sequence of verbs.

Move 1 point Line 1 point Quad 2 points Conic 2 points and 1 weight Cubic 3 points Close 0 points

If an illegal sequence of verbs is encountered, or the specified number of points or weights is not sufficient given the verbs, an empty Path is returned.

A legal sequence of verbs consists of any number of Contours. A contour always begins with a Move verb, followed by 0 or more segments: Line, Quad, Conic, Cubic, followed by an optional Close.

Definition at line 3569 of file SkPath.cpp.

                                                        {
    if (verbCount <= 0) {
        return SkPath();
    }
 
    const auto info = sk_path_analyze_verbs(vbs, verbCount);
    if (!info.valid || info.points > pointCount || info.weights > wCount) {
        SkDEBUGFAIL("invalid verbs and number of points/weights");
        return SkPath();
    }
 
    return MakeInternal(info, pts, vbs, verbCount, ws, ft, isVolatile);
}

◆ makeScale()

SkPath SkPath::makeScale	(	SkScalar	sx,
		SkScalar	sy
	)

inline

Definition at line 1407 of file SkPath.h.

                                               {
        return this->makeTransform(SkMatrix::Scale(sx, sy), SkApplyPerspectiveClip::kNo);
    }

◆ makeTransform()

SkPath SkPath::makeTransform	(	const SkMatrix &	m,
		SkApplyPerspectiveClip	pc = `SkApplyPerspectiveClip::kYes`
	)		const

inline

Definition at line 1400 of file SkPath.h.

                                                                                       {
        SkPath dst;
        this->transform(m, &dst, pc);
        return dst;
    }

◆ moveTo() [1/2]

SkPath & SkPath::moveTo ( const SkPoint & p )

inline

Adds beginning of contour at SkPoint p.

Parameters

p	contour start

Returns: reference to SkPath

Definition at line 594 of file SkPath.h.

                                     {
        return this->moveTo(p.fX, p.fY);
    }

◆ moveTo() [2/2]

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

Adds beginning of contour at SkPoint (x, y).

Parameters

x	x-axis value of contour start
y	y-axis value of contour start

Returns: reference to SkPath

example: https://fiddle.skia.org/c/@Path_moveTo

Definition at line 688 of file SkPath.cpp.

                                             {
    SkDEBUGCODE(this->validate();)
 
    SkPathRef::Editor ed(&fPathRef);
 
    // remember our index
    fLastMoveToIndex = fPathRef->countPoints();
 
    ed.growForVerb(kMove_Verb)->set(x, y);
 
    return this->dirtyAfterEdit();
}

◆ offset() [1/2]

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

inline

Offsets SkPoint array by (dx, dy). SkPath is replaced by offset data.

Parameters

dx	offset added to SkPoint array x-axis coordinates
dy	offset added to SkPoint array y-axis coordinates

Definition at line 1368 of file SkPath.h.

                                             {
        this->offset(dx, dy, this);
        return *this;
    }

◆ offset() [2/2]

void SkPath::offset	(	SkScalar	dx,
		SkScalar	dy,
		SkPath *	dst
	)		const

Offsets SkPoint array by (dx, dy). Offset SkPath replaces dst. If dst is nullptr, SkPath is replaced by offset data.

Parameters

dx	offset added to SkPoint array x-axis coordinates
dy	offset added to SkPoint array y-axis coordinates
dst	overwritten, translated copy of SkPath; may be nullptr

example: https://fiddle.skia.org/c/@Path_offset

Definition at line 1691 of file SkPath.cpp.

                                                               {
    SkMatrix    matrix;
 
    matrix.setTranslate(dx, dy);
    this->transform(matrix, dst);
}

◆ operator=()

SkPath & SkPath::operator= ( const SkPath & path )

Constructs a copy of an existing path. SkPath assignment makes two paths identical by value. Internally, assignment shares pointer values. The underlying verb array, SkPoint array and weights are copied when modified.

Copying SkPath by assignment is very efficient and never allocates memory. SkPath are always copied by value from the interface; the underlying shared pointers are not exposed.

Parameters

path	verb array, SkPoint array, weights, and SkPath::FillType to copy

Returns: SkPath copied by value

example: https://fiddle.skia.org/c/@Path_copy_operator

Definition at line 190 of file SkPath.cpp.

                                            {
    SkDEBUGCODE(that.validate();)
 
    if (this != &that) {
        fPathRef.reset(SkRef(that.fPathRef.get()));
        this->copyFields(that);
    }
    SkDEBUGCODE(this->validate();)
    return *this;
}

◆ Oval() [1/2]

SkPath SkPath::Oval	(	const SkRect &	r,
		SkPathDirection	dir,
		unsigned	startIndex
	)

static

Definition at line 3594 of file SkPath.cpp.

                                                                             {
    return SkPathBuilder().addOval(r, dir, startIndex).detach();
}

◆ Oval() [2/2]

SkPath SkPath::Oval	(	const SkRect &	r,
		SkPathDirection	dir = `SkPathDirection::kCW`
	)

static

Definition at line 3590 of file SkPath.cpp.

                                                        {
    return SkPathBuilder().addOval(r, dir).detach();
}

◆ Polygon() [1/2]

SkPath SkPath::Polygon	(	const SkPoint	pts[],
		int	count,
		bool	isClosed,
		SkPathFillType	ft = `SkPathFillType::kWinding`,
		bool	isVolatile = `false`
	)

static

Definition at line 3614 of file SkPath.cpp.

                                                           {
    return SkPathBuilder().addPolygon(pts, count, isClosed)
                          .setFillType(ft)
                          .setIsVolatile(isVolatile)
                          .detach();
}

◆ Polygon() [2/2]

static SkPath SkPath::Polygon	(	const std::initializer_list< SkPoint > &	list,
		bool	isClosed,
		SkPathFillType	fillType = `SkPathFillType::kWinding`,
		bool	isVolatile = `false`
	)

inlinestatic

Definition at line 100 of file SkPath.h.

                                                   {
        return Polygon(list.begin(), SkToInt(list.size()), isClosed, fillType, isVolatile);
    }

◆ quadTo() [1/2]

SkPath & SkPath::quadTo	(	const SkPoint &	p1,
		const SkPoint &	p2
	)

inline

Adds quad from last point towards SkPoint p1, to SkPoint p2. If SkPath is empty, or last SkPath::Verb is kClose_Verb, last point is set to (0, 0) before adding quad.

Appends kMove_Verb to verb array and (0, 0) to SkPoint array, if needed; then appends kQuad_Verb to verb array; and SkPoint p1, p2 to SkPoint array.

Parameters

p1	control SkPoint of added quad
p2	end SkPoint of added quad

Returns: reference to SkPath

Definition at line 686 of file SkPath.h.

                                                         {
        return this->quadTo(p1.fX, p1.fY, p2.fX, p2.fY);
    }

◆ quadTo() [2/2]

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

Adds quad from last point towards (x1, y1), to (x2, y2). If SkPath is empty, or last SkPath::Verb is kClose_Verb, last point is set to (0, 0) before adding quad.

Appends kMove_Verb to verb array and (0, 0) to SkPoint array, if needed; then appends kQuad_Verb to verb array; and (x1, y1), (x2, y2) to SkPoint array.

Parameters

x1	control SkPoint of quad on x-axis
y1	control SkPoint of quad on y-axis
x2	end SkPoint of quad on x-axis
y2	end SkPoint of quad on y-axis

Returns: reference to SkPath

example: https://fiddle.skia.org/c/@Path_quadTo

Definition at line 746 of file SkPath.cpp.

                                                                         {
    SkDEBUGCODE(this->validate();)
 
    this->injectMoveToIfNeeded();
 
    SkPathRef::Editor ed(&fPathRef);
    SkPoint* pts = ed.growForVerb(kQuad_Verb);
    pts[0].set(x1, y1);
    pts[1].set(x2, y2);
 
    return this->dirtyAfterEdit();
}

◆ rArcTo()

SkPath & SkPath::rArcTo	(	SkScalar	rx,
		SkScalar	ry,
		SkScalar	xAxisRotate,
		SkPath::ArcSize	largeArc,
		SkPathDirection	sweep,
		SkScalar	dx,
		SkScalar	dy
	)

Appends arc to SkPath, relative to last SkPath SkPoint. Arc is implemented by one or more conic, weighted to describe part of oval with radii (rx, ry) rotated by xAxisRotate degrees. Arc curves from last SkPath SkPoint to relative end SkPoint: (dx, dy), choosing one of four possible routes: clockwise or counterclockwise, and smaller or larger. If SkPath is empty, the start arc SkPoint is (0, 0).

Arc sweep is always less than 360 degrees. arcTo() appends line to end SkPoint if either radii are zero, or if last SkPath SkPoint equals end SkPoint. arcTo() scales radii (rx, ry) to fit last SkPath SkPoint and end SkPoint 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

rx	radius before x-axis rotation
ry	radius 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
dx	x-axis offset end of arc from last SkPath SkPoint
dy	y-axis offset end of arc from last SkPath SkPoint

Returns: reference to SkPath

Definition at line 1431 of file SkPath.cpp.

                                                                        {
    SkPoint currentPoint;
    this->getLastPt(&currentPoint);
    return this->arcTo(rx, ry, xAxisRotate, largeArc, sweep,
                       currentPoint.fX + dx, currentPoint.fY + dy);
}

◆ rConicTo()

SkPath & SkPath::rConicTo	(	SkScalar	dx1,
		SkScalar	dy1,
		SkScalar	dx2,
		SkScalar	dy2,
		SkScalar	w
	)

Adds conic from last point towards vector (dx1, dy1), to vector (dx2, dy2), weighted by w. If SkPath is empty, or last SkPath::Verb is kClose_Verb, last point is set to (0, 0) before adding conic.

Appends kMove_Verb to verb array and (0, 0) to SkPoint array, if needed.

If w is finite and not one, next appends kConic_Verb to verb array, and w is recorded as conic weight; otherwise, if w is one, appends kQuad_Verb to verb array; or if w is not finite, appends kLine_Verb twice to verb array.

In all cases appends SkPoint control and end to SkPoint array. control is last point plus vector (dx1, dy1). end is last point plus vector (dx2, dy2).

Function name stands for "relative conic to".

Parameters

dx1	offset from last point to conic control on x-axis
dy1	offset from last point to conic control on y-axis
dx2	offset from last point to conic end on x-axis
dy2	offset from last point to conic end on y-axis
w	weight of added conic

Returns: reference to SkPath

Definition at line 791 of file SkPath.cpp.

                                     {
    this->injectMoveToIfNeeded();  // This can change the result of this->getLastPt().
    SkPoint pt;
    this->getLastPt(&pt);
    return this->conicTo(pt.fX + dx1, pt.fY + dy1, pt.fX + dx2, pt.fY + dy2, w);
}

◆ rCubicTo()

SkPath & SkPath::rCubicTo	(	SkScalar	dx1,
		SkScalar	dy1,
		SkScalar	dx2,
		SkScalar	dy2,
		SkScalar	dx3,
		SkScalar	dy3
	)

Adds cubic from last point towards vector (dx1, dy1), then towards vector (dx2, dy2), to vector (dx3, dy3). If SkPath is empty, or last SkPath::Verb is kClose_Verb, last point is set to (0, 0) before adding cubic.

Appends kMove_Verb to verb array and (0, 0) to SkPoint array, if needed; then appends kCubic_Verb to verb array; and appends cubic control and cubic end to SkPoint array. Cubic control is last point plus vector (dx1, dy1). Cubic end is last point plus vector (dx2, dy2). Function name stands for "relative cubic to".

Parameters

dx1	offset from last point to first cubic control on x-axis
dy1	offset from last point to first cubic control on y-axis
dx2	offset from last point to second cubic control on x-axis
dy2	offset from last point to second cubic control on y-axis
dx3	offset from last point to cubic end on x-axis
dy3	offset from last point to cubic end on y-axis

Returns: reference to SkPath

Definition at line 814 of file SkPath.cpp.

                                                   {
    this->injectMoveToIfNeeded();  // This can change the result of this->getLastPt().
    SkPoint pt;
    this->getLastPt(&pt);
    return this->cubicTo(pt.fX + x1, pt.fY + y1, pt.fX + x2, pt.fY + y2,
                         pt.fX + x3, pt.fY + y3);
}

◆ readFromMemory()

size_t SkPath::readFromMemory	(	const void *	buffer,
		size_t	length
	)

Initializes SkPath from buffer of size length. Returns zero if the buffer is data is inconsistent, or the length is too small.

Reads SkPath::FillType, verb array, SkPoint array, conic weight, and additionally reads computed information like SkPath::Convexity and bounds.

Used only in concert with writeToMemory(); the format used for SkPath in memory is not guaranteed.

Parameters

buffer	storage for SkPath
length	buffer size in bytes; must be multiple of 4

Returns: number of bytes read, or zero on failure

example: https://fiddle.skia.org/c/@Path_readFromMemory

Definition at line 193 of file SkPath_serial.cpp.

                                                                {
    SkRBuffer buffer(storage, length);
    uint32_t packed;
    if (!buffer.readU32(&packed)) {
        return 0;
    }
    unsigned version = extract_version(packed);
 
    const bool verbsAreForward = (version == kVerbsAreStoredForward_Version);
    if (!verbsAreForward && version != kJustPublicData_Version) SK_UNLIKELY {
        // Old/unsupported version.
        return 0;
    }
 
    switch (extract_serializationtype(packed)) {
        case SerializationType::kRRect:
            return this->readAsRRect(storage, length);
        case SerializationType::kGeneral:
            break;  // fall out
        default:
            return 0;
    }
 
    // To minimize the number of reads done a structure with the counts is used.
    struct {
      int32_t pts, cnx, vbs;
    } counts;
    if (!buffer.read(&counts, sizeof(counts))) {
        return 0;
    }
 
    const SkPoint* points = buffer.skipCount<SkPoint>(counts.pts);
    const SkScalar* conics = buffer.skipCount<SkScalar>(counts.cnx);
    const uint8_t* verbs = buffer.skipCount<uint8_t>(counts.vbs);
    buffer.skipToAlign4();
    if (!buffer.isValid()) {
        return 0;
    }
    SkASSERT(buffer.pos() <= length);
 
    if (counts.vbs == 0) {
        if (counts.pts == 0 && counts.cnx == 0) {
            reset();
            setFillType(extract_filltype(packed));
            return buffer.pos();
        }
        // No verbs but points and/or conic weights is a not a valid path.
        return 0;
    }
 
    SkAutoMalloc reversedStorage;
    if (!verbsAreForward) SK_UNLIKELY {
      uint8_t* tmpVerbs = (uint8_t*)reversedStorage.reset(counts.vbs);
        for (int i = 0; i < counts.vbs; ++i) {
            tmpVerbs[i] = verbs[counts.vbs - i - 1];
        }
        verbs = tmpVerbs;
    }
 
    SkPathVerbAnalysis analysis = sk_path_analyze_verbs(verbs, counts.vbs);
    if (!analysis.valid || analysis.points != counts.pts || analysis.weights != counts.cnx) {
        return 0;
    }
    *this = SkPathPriv::MakePath(analysis, points, verbs, counts.vbs, conics,
                                 extract_filltype(packed), false);
    return buffer.pos();
}

◆ Rect()

SkPath SkPath::Rect	(	const SkRect &	r,
		SkPathDirection	dir = `SkPathDirection::kCW`,
		unsigned	startIndex = `0`
	)

static

Definition at line 3586 of file SkPath.cpp.

                                                                             {
    return SkPathBuilder().addRect(r, dir, startIndex).detach();
}

◆ reset()

SkPath & SkPath::reset ( )

Sets SkPath to its initial state. Removes verb array, SkPoint array, and weights, and sets FillType to kWinding. Internal storage associated with SkPath is released.

Returns: reference to SkPath

example: https://fiddle.skia.org/c/@Path_reset

Definition at line 370 of file SkPath.cpp.

                      {
    SkDEBUGCODE(this->validate();)
 
    if (fPathRef->unique()) {
        fPathRef->reset();
    } else {
        fPathRef.reset(SkPathRef::CreateEmpty());
    }
    this->resetFields();
    return *this;
}

◆ reverseAddPath()

SkPath & SkPath::reverseAddPath ( const SkPath & src )

Appends src to SkPath, from back to front. Reversed src always appends a new contour to SkPath.

Parameters

src	SkPath verbs, SkPoint, and conic weights to add

Returns: reference to SkPath

example: https://fiddle.skia.org/c/@Path_reverseAddPath

Definition at line 1633 of file SkPath.cpp.

                                                    {
    // Detect if we're trying to add ourself
    const SkPath* src = &srcPath;
    SkTLazy<SkPath> tmp;
    if (this == src) {
        src = tmp.set(srcPath);
    }
 
    const uint8_t* verbsBegin = src->fPathRef->verbsBegin();
    const uint8_t* verbs = src->fPathRef->verbsEnd();
    const SkPoint* pts = src->fPathRef->pointsEnd();
    const SkScalar* conicWeights = src->fPathRef->conicWeightsEnd();
 
    bool needMove = true;
    bool needClose = false;
    while (verbs > verbsBegin) {
        uint8_t v = *--verbs;
        int n = SkPathPriv::PtsInVerb(v);
 
        if (needMove) {
            --pts;
            this->moveTo(pts->fX, pts->fY);
            needMove = false;
        }
        pts -= n;
        switch (v) {
            case kMove_Verb:
                if (needClose) {
                    this->close();
                    needClose = false;
                }
                needMove = true;
                pts += 1;   // so we see the point in "if (needMove)" above
                break;
            case kLine_Verb:
                this->lineTo(pts[0]);
                break;
            case kQuad_Verb:
                this->quadTo(pts[1], pts[0]);
                break;
            case kConic_Verb:
                this->conicTo(pts[1], pts[0], *--conicWeights);
                break;
            case kCubic_Verb:
                this->cubicTo(pts[2], pts[1], pts[0]);
                break;
            case kClose_Verb:
                needClose = true;
                break;
            default:
                SkDEBUGFAIL("unexpected verb");
        }
    }
    return *this;
}

◆ rewind()

SkPath & SkPath::rewind ( )

Sets SkPath to its initial state, preserving internal storage. Removes verb array, SkPoint array, and weights, and sets FillType to kWinding. Internal storage associated with SkPath is retained.

Use rewind() instead of reset() if SkPath storage will be reused and performance is critical.

Returns: reference to SkPath

example: https://fiddle.skia.org/c/@Path_rewind

Definition at line 382 of file SkPath.cpp.

                       {
    SkDEBUGCODE(this->validate();)
 
    SkPathRef::Rewind(&fPathRef);
    this->resetFields();
    return *this;
}

◆ rLineTo()

SkPath & SkPath::rLineTo	(	SkScalar	dx,
		SkScalar	dy
	)

Adds line from last point to vector (dx, dy). If SkPath is empty, or last SkPath::Verb is kClose_Verb, last point is set to (0, 0) before adding line.

Appends kMove_Verb to verb array and (0, 0) to SkPoint array, if needed; then appends kLine_Verb to verb array and line end to SkPoint array. Line end is last point plus vector (dx, dy). Function name stands for "relative line to".

Parameters

dx	offset from last point to line end on x-axis
dy	offset from last point to line end on y-axis

Returns: reference to SkPath

example: https://fiddle.skia.org/c/@Path_rLineTo example: https://fiddle.skia.org/c/@Quad_a example: https://fiddle.skia.org/c/@Quad_b

Definition at line 739 of file SkPath.cpp.

                                              {
    this->injectMoveToIfNeeded();  // This can change the result of this->getLastPt().
    SkPoint pt;
    this->getLastPt(&pt);
    return this->lineTo(pt.fX + x, pt.fY + y);
}

◆ rMoveTo()

SkPath & SkPath::rMoveTo	(	SkScalar	dx,
		SkScalar	dy
	)

Adds beginning of contour relative to last point. If SkPath is empty, starts contour at (dx, dy). Otherwise, start contour at last point offset by (dx, dy). Function name stands for "relative move to".

Parameters

dx	offset from last point to contour start on x-axis
dy	offset from last point to contour start on y-axis

Returns: reference to SkPath

example: https://fiddle.skia.org/c/@Path_rMoveTo

Definition at line 701 of file SkPath.cpp.

                                              {
    SkPoint pt = {0,0};
    int count = fPathRef->countPoints();
    if (count > 0) {
        if (fLastMoveToIndex >= 0) {
            pt = fPathRef->atPoint(count - 1);
        } else {
            pt = fPathRef->atPoint(~fLastMoveToIndex);
        }
    }
    return this->moveTo(pt.fX + x, pt.fY + y);
}

◆ rQuadTo()

SkPath & SkPath::rQuadTo	(	SkScalar	dx1,
		SkScalar	dy1,
		SkScalar	dx2,
		SkScalar	dy2
	)

Adds quad from last point towards vector (dx1, dy1), to vector (dx2, dy2). If SkPath is empty, or last SkPath::Verb is kClose_Verb, last point is set to (0, 0) before adding quad.

Appends kMove_Verb to verb array and (0, 0) to SkPoint array, if needed; then appends kQuad_Verb to verb array; and appends quad control and quad end to SkPoint array. Quad control is last point plus vector (dx1, dy1). Quad end is last point plus vector (dx2, dy2). Function name stands for "relative quad to".

Parameters

dx1	offset from last point to quad control on x-axis
dy1	offset from last point to quad control on y-axis
dx2	offset from last point to quad end on x-axis
dy2	offset from last point to quad end on y-axis

Returns: reference to SkPath

example: https://fiddle.skia.org/c/@Conic_Weight_a example: https://fiddle.skia.org/c/@Conic_Weight_b example: https://fiddle.skia.org/c/@Conic_Weight_c example: https://fiddle.skia.org/c/@Path_rQuadTo

Definition at line 759 of file SkPath.cpp.

                                                                          {
    this->injectMoveToIfNeeded();  // This can change the result of this->getLastPt().
    SkPoint pt;
    this->getLastPt(&pt);
    return this->quadTo(pt.fX + x1, pt.fY + y1, pt.fX + x2, pt.fY + y2);
}

◆ RRect() [1/3]

SkPath SkPath::RRect	(	const SkRect &	bounds,
		SkScalar	rx,
		SkScalar	ry,
		SkPathDirection	dir = `SkPathDirection::kCW`
	)

static

Definition at line 3610 of file SkPath.cpp.

                                                                                   {
    return SkPathBuilder().addRRect(SkRRect::MakeRectXY(r, rx, ry), dir).detach();
}

◆ RRect() [2/3]

SkPath SkPath::RRect	(	const SkRRect &	rr,
		SkPathDirection	dir = `SkPathDirection::kCW`
	)

static

Definition at line 3602 of file SkPath.cpp.

                                                           {
    return SkPathBuilder().addRRect(rr, dir).detach();
}

◆ RRect() [3/3]

SkPath SkPath::RRect	(	const SkRRect &	rr,
		SkPathDirection	dir,
		unsigned	startIndex
	)

static

Definition at line 3606 of file SkPath.cpp.

                                                                                {
    return SkPathBuilder().addRRect(rr, dir, startIndex).detach();
}

◆ serialize()

sk_sp< SkData > SkPath::serialize ( ) const

Writes SkPath to buffer, returning the buffer written to, wrapped in SkData.

serialize() writes SkPath::FillType, verb array, SkPoint array, conic weight, and additionally writes computed information like SkPath::Convexity and bounds.

serialize() should only be used in concert with readFromMemory(). The format used for SkPath in memory is not guaranteed.

Returns: SkPath data wrapped in SkData buffer

example: https://fiddle.skia.org/c/@Path_serialize

Definition at line 145 of file SkPath_serial.cpp.

                                      {
    size_t size = this->writeToMemory(nullptr);
    sk_sp<SkData> data = SkData::MakeUninitialized(size);
    this->writeToMemory(data->writable_data());
    return data;
}

◆ setFillType()

void SkPath::setFillType ( SkPathFillType ft )

inline

Sets FillType, the rule used to fill SkPath. While there is no check that ft is legal, values outside of FillType are not supported.

Definition at line 235 of file SkPath.h.

                                        {
        fFillType = SkToU8(ft);
    }

◆ setIsVolatile()

SkPath & SkPath::setIsVolatile ( bool isVolatile )

inline

Specifies whether SkPath is volatile; whether it will be altered or discarded by the caller after it is drawn. SkPath by default have volatile set false, allowing Skia to attach a cache of data which speeds repeated drawing.

Mark temporary paths, discarded or modified after use, as volatile to inform Skia that the path need not be cached.

Mark animating SkPath volatile to improve performance. Mark unchanging SkPath non-volatile to improve repeated rendering.

raster surface SkPath draws are affected by volatile for some shadows. GPU surface SkPath draws are affected by volatile for some shadows and concave geometries.

Parameters

isVolatile true if caller will alter SkPath after drawing

Returns: reference to SkPath

Definition at line 370 of file SkPath.h.

                                           {
        fIsVolatile = isVolatile;
        return *this;
    }

◆ setLastPt() [1/2]

void SkPath::setLastPt ( const SkPoint & p )

inline

Sets the last point on the path. If SkPoint array is empty, append kMove_Verb to verb array and append p to SkPoint array.

Parameters

p	set value of last point

Definition at line 1436 of file SkPath.h.

                                     {
        this->setLastPt(p.fX, p.fY);
    }

◆ setLastPt() [2/2]

void SkPath::setLastPt	(	SkScalar	x,
		SkScalar	y
	)

Sets last point to (x, y). If SkPoint array is empty, append kMove_Verb to verb array and append (x, y) to SkPoint array.

Parameters

x	set x-axis value of last point
y	set y-axis value of last point

example: https://fiddle.skia.org/c/@Path_setLastPt

Definition at line 608 of file SkPath.cpp.

                                             {
    SkDEBUGCODE(this->validate();)
 
    int count = fPathRef->countPoints();
    if (count == 0) {
        this->moveTo(x, y);
    } else {
        SkPathRef::Editor ed(&fPathRef);
        ed.atPoint(count-1)->set(x, y);
    }
}

◆ snapshot()

SkPath SkPath::snapshot ( ) const

inline

Returns a copy of this path in the current state.

Definition at line 142 of file SkPath.h.

                            {
        return *this;
    }

◆ swap()

void SkPath::swap ( SkPath & other )

Exchanges the verb array, SkPoint array, weights, and SkPath::FillType with other. Cached state is also exchanged. swap() internally exchanges pointers, so it is lightweight and does not allocate memory.

swap() usage has largely been replaced by operator=(const SkPath& path). SkPath do not copy their content on assignment until they are written to, making assignment as efficient as swap().

Parameters

other SkPath exchanged by value

example: https://fiddle.skia.org/c/@Path_swap

Definition at line 219 of file SkPath.cpp.

                              {
    if (this != &that) {
        fPathRef.swap(that.fPathRef);
        std::swap(fLastMoveToIndex, that.fLastMoveToIndex);
 
        const auto ft = fFillType;
        fFillType = that.fFillType;
        that.fFillType = ft;
 
        const auto iv = fIsVolatile;
        fIsVolatile = that.fIsVolatile;
        that.fIsVolatile = iv;
 
        // Non-atomic swaps of atomic values.
        SkPathConvexity c = this->getConvexityOrUnknown();
        this->setConvexity(that.getConvexityOrUnknown());
        that.setConvexity(c);
 
        SkPathFirstDirection fd = this->getFirstDirection();
        this->setFirstDirection(that.getFirstDirection());
        that.setFirstDirection(fd);
    }
}

◆ toggleInverseFillType()

void SkPath::toggleInverseFillType ( )

inline

Replaces FillType with its inverse. The inverse of FillType describes the area unmodified by the original FillType.

Definition at line 249 of file SkPath.h.

                                 {
        fFillType ^= 2;
    }

◆ transform() [1/2]

SkPath & SkPath::transform	(	const SkMatrix &	matrix,
		SkApplyPerspectiveClip	pc = `SkApplyPerspectiveClip::kYes`
	)

inline

Transforms verb array, SkPoint array, and weight by matrix. transform may change verbs and increase their number. SkPath is replaced by transformed data.

Parameters

matrix	SkMatrix to apply to SkPath
pc	whether to apply perspective clipping

Definition at line 1394 of file SkPath.h.

                                                                           {
        this->transform(matrix, this, pc);
        return *this;
    }

◆ transform() [2/2]

void SkPath::transform	(	const SkMatrix &	matrix,
		SkPath *	dst,
		SkApplyPerspectiveClip	pc = `SkApplyPerspectiveClip::kYes`
	)		const

Transforms verb array, SkPoint array, and weight by matrix. transform may change verbs and increase their number. Transformed SkPath replaces dst; if dst is nullptr, original data is replaced.

Parameters

matrix	SkMatrix to apply to SkPath
dst	overwritten, transformed copy of SkPath; may be nullptr
pc	whether to apply perspective clipping

example: https://fiddle.skia.org/c/@Path_transform

Definition at line 1711 of file SkPath.cpp.

                                                                                           {
    if (matrix.isIdentity()) {
        if (dst != nullptr && dst != this) {
            *dst = *this;
        }
        return;
    }
 
    SkDEBUGCODE(this->validate();)
    if (dst == nullptr) {
        dst = const_cast<SkPath*>(this);
    }
 
    if (matrix.hasPerspective()) {
        SkPath  tmp;
        tmp.fFillType = fFillType;
 
        SkPath clipped;
        const SkPath* src = this;
        if (pc == SkApplyPerspectiveClip::kYes &&
            SkPathPriv::PerspectiveClip(*this, matrix, &clipped))
        {
            src = &clipped;
        }
 
        SkPath::Iter    iter(*src, false);
        SkPoint         pts[4];
        SkPath::Verb    verb;
 
        while ((verb = iter.next(pts)) != kDone_Verb) {
            switch (verb) {
                case kMove_Verb:
                    tmp.moveTo(pts[0]);
                    break;
                case kLine_Verb:
                    tmp.lineTo(pts[1]);
                    break;
                case kQuad_Verb:
                    // promote the quad to a conic
                    tmp.conicTo(pts[1], pts[2],
                                SkConic::TransformW(pts, SK_Scalar1, matrix));
                    break;
                case kConic_Verb:
                    tmp.conicTo(pts[1], pts[2],
                                SkConic::TransformW(pts, iter.conicWeight(), matrix));
                    break;
                case kCubic_Verb:
                    subdivide_cubic_to(&tmp, pts);
                    break;
                case kClose_Verb:
                    tmp.close();
                    break;
                default:
                    SkDEBUGFAIL("unknown verb");
                    break;
            }
        }
 
        dst->swap(tmp);
        SkPathRef::Editor ed(&dst->fPathRef);
        matrix.mapPoints(ed.writablePoints(), ed.pathRef()->countPoints());
        dst->setFirstDirection(SkPathFirstDirection::kUnknown);
    } else {
        SkPathConvexity convexity = this->getConvexityOrUnknown();
 
        SkPathRef::CreateTransformedCopy(&dst->fPathRef, *fPathRef, matrix);
 
        if (this != dst) {
            dst->fLastMoveToIndex = fLastMoveToIndex;
            dst->fFillType = fFillType;
            dst->fIsVolatile = fIsVolatile;
        }
 
        // Due to finite/fragile float numerics, we can't assume that a convex path remains
        // convex after a transformation, so mark it as unknown here.
        // However, some transformations are thought to be safe:
        //    axis-aligned values under scale/translate.
        //
        if (convexity == SkPathConvexity::kConvex &&
            (!matrix.isScaleTranslate() || !SkPathPriv::IsAxisAligned(*this))) {
            // Not safe to still assume we're convex...
            convexity = SkPathConvexity::kUnknown;
        }
        dst->setConvexity(convexity);
 
        if (this->getFirstDirection() == SkPathFirstDirection::kUnknown) {
            dst->setFirstDirection(SkPathFirstDirection::kUnknown);
        } else {
            SkScalar det2x2 =
                matrix.get(SkMatrix::kMScaleX) * matrix.get(SkMatrix::kMScaleY) -
                matrix.get(SkMatrix::kMSkewX)  * matrix.get(SkMatrix::kMSkewY);
            if (det2x2 < 0) {
                dst->setFirstDirection(
                        SkPathPriv::OppositeFirstDirection(
                            (SkPathFirstDirection)this->getFirstDirection()));
            } else if (det2x2 > 0) {
                dst->setFirstDirection(this->getFirstDirection());
            } else {
                dst->setFirstDirection(SkPathFirstDirection::kUnknown);
            }
        }
 
        SkDEBUGCODE(dst->validate();)
    }
}

◆ updateBoundsCache()

void SkPath::updateBoundsCache ( ) const

inline

Updates internal bounds so that subsequent calls to getBounds() are instantaneous. Unaltered copies of SkPath may also access cached bounds through getBounds().

For now, identical to calling getBounds() and ignoring the returned value.

Call to prepare SkPath subsequently drawn from multiple threads, to avoid a race condition where each draw separately computes the bounds.

Definition at line 524 of file SkPath.h.

                                   {
        // for now, just calling getBounds() is sufficient
        this->getBounds();
    }

◆ writeToMemory()

size_t SkPath::writeToMemory ( void * buffer ) const

Writes SkPath to buffer, returning the number of bytes written. Pass nullptr to obtain the storage size.

Writes SkPath::FillType, verb array, SkPoint array, conic weight, and additionally writes computed information like SkPath::Convexity and bounds.

Use only be used in concert with readFromMemory(); the format used for SkPath in memory is not guaranteed.

Parameters

buffer storage for SkPath; may be nullptr

Returns: size of storage required for SkPath; always a multiple of 4

example: https://fiddle.skia.org/c/@Path_writeToMemory

Definition at line 103 of file SkPath_serial.cpp.

                                                {
    SkDEBUGCODE(this->validate();)
 
    if (size_t bytes = this->writeToMemoryAsRRect(storage)) {
        return bytes;
    }
 
    int32_t packed = (fFillType << kFillType_SerializationShift) |
                     (SerializationType::kGeneral << kType_SerializationShift) |
                     kCurrent_Version;
 
    int32_t pts = fPathRef->countPoints();
    int32_t cnx = fPathRef->countWeights();
    int32_t vbs = fPathRef->countVerbs();
 
    SkSafeMath safe;
    size_t size = 4 * sizeof(int32_t);
    size = safe.add(size, safe.mul(pts, sizeof(SkPoint)));
    size = safe.add(size, safe.mul(cnx, sizeof(SkScalar)));
    size = safe.add(size, safe.mul(vbs, sizeof(uint8_t)));
    size = safe.alignUp(size, 4);
    if (!safe) {
        return 0;
    }
    if (!storage) {
        return size;
    }
 
    SkWBuffer buffer(storage);
    buffer.write32(packed);
    buffer.write32(pts);
    buffer.write32(cnx);
    buffer.write32(vbs);
    buffer.write(fPathRef->points(), pts * sizeof(SkPoint));
    buffer.write(fPathRef->conicWeights(), cnx * sizeof(SkScalar));
    buffer.write(fPathRef->verbsBegin(), vbs * sizeof(uint8_t));
    buffer.padToAlign4();
 
    SkASSERT(buffer.pos() == size);
    return size;
}

Friends And Related Function Documentation

◆ ForceIsRRect_Private

friend class ForceIsRRect_Private

friend

Definition at line 1938 of file SkPath.h.

◆ FuzzPath

friend class FuzzPath

friend

Definition at line 1939 of file SkPath.h.

◆ Iter

friend class Iter

friend

Definition at line 1840 of file SkPath.h.

◆ operator!=

bool operator!=	(	const SkPath &	a,
		const SkPath &	b
	)

friend

Compares a and b; returns true if SkPath::FillType, verb array, SkPoint array, and weights are not equivalent.

Parameters

a	SkPath to compare
b	SkPath to compare

Returns: true if SkPath pair are not equivalent

Definition at line 185 of file SkPath.h.

                                                             {
        return !(a == b);
    }

◆ operator==

SK_API bool operator==	(	const SkPath &	a,
		const SkPath &	b
	)

friend

Compares a and b; returns true if SkPath::FillType, verb array, SkPoint array, and weights are equivalent.

Parameters

a	SkPath to compare
b	SkPath to compare

Returns: true if SkPath pair are equivalent

Definition at line 212 of file SkPath.cpp.

                                                  {
    // note: don't need to look at isConvex or bounds, since just comparing the
    // raw data is sufficient.
    return &a == &b ||
        (a.fFillType == b.fFillType && *a.fPathRef == *b.fPathRef);
}

◆ PathTest_Private

friend class PathTest_Private

friend

Definition at line 1937 of file SkPath.h.

◆ SkAutoDisableDirectionCheck

friend class SkAutoDisableDirectionCheck

friend

Definition at line 1931 of file SkPath.h.

◆ SkAutoDisableOvalCheck

friend class SkAutoDisableOvalCheck

friend

Definition at line 1930 of file SkPath.h.

◆ SkAutoPathBoundsUpdate

friend class SkAutoPathBoundsUpdate

friend

Definition at line 1929 of file SkPath.h.

◆ SkBench_AddPathTest

friend class SkBench_AddPathTest

friend

Definition at line 1936 of file SkPath.h.

◆ SkOpBuilder

friend class SkOpBuilder

friend

Definition at line 1935 of file SkPath.h.

◆ SkPathBuilder

friend class SkPathBuilder

friend

Definition at line 1932 of file SkPath.h.

◆ SkPathEdgeIter

friend class SkPathEdgeIter

friend

Definition at line 1933 of file SkPath.h.

◆ SkPathPriv

friend class SkPathPriv

friend

Definition at line 1841 of file SkPath.h.

◆ SkPathStroker

friend class SkPathStroker

friend

Definition at line 1842 of file SkPath.h.

◆ SkPathWriter

friend class SkPathWriter

friend

Definition at line 1934 of file SkPath.h.

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

third_party/skia/include/core/SkPath.h
third_party/skia/src/core/SkPath.cpp
third_party/skia/src/core/SkPath_serial.cpp

Classes

Public Types

Public Member Functions

Static Public Member Functions

Friends

Detailed Description

Member Typedef Documentation

◆ sk_is_trivially_relocatable

Member Enumeration Documentation

◆ AddPathMode

◆ ArcSize

◆ SegmentMask

◆ Verb

Constructor & Destructor Documentation

◆ SkPath() [1/2]

◆ SkPath() [2/2]

◆ ~SkPath()

Member Function Documentation

◆ addArc()

◆ addCircle()

◆ addOpenOval()

◆ addOval() [1/2]

◆ addOval() [2/2]

◆ addPath() [1/3]

◆ addPath() [2/3]

◆ addPath() [3/3]

◆ addPoly() [1/2]

◆ addPoly() [2/2]

◆ addRect() [1/3]

◆ addRect() [2/3]

◆ addRect() [3/3]

◆ addRoundRect() [1/2]

◆ addRoundRect() [2/2]

◆ addRRect() [1/2]

◆ addRRect() [2/2]

◆ approximateBytesUsed()

◆ arcTo() [1/5]

◆ arcTo() [2/5]

◆ arcTo() [3/5]

◆ arcTo() [4/5]

◆ arcTo() [5/5]

◆ Circle()

◆ close()

◆ computeTightBounds()

◆ conicTo() [1/2]

◆ conicTo() [2/2]

◆ conservativelyContainsRect()

◆ contains()

◆ ConvertConicToQuads()

◆ countPoints()

◆ countVerbs()

◆ cubicTo() [1/2]

◆ cubicTo() [2/2]

◆ detach()

◆ dump() [1/2]

◆ dump() [2/2]

◆ dumpArrays() [1/2]

◆ dumpArrays() [2/2]

◆ dumpHex()

◆ getBounds()

◆ getFillType()

◆ getGenerationID()

◆ getLastPt()

◆ getPoint()

◆ getPoints()

◆ getSegmentMasks()

◆ getVerbs()

◆ incReserve()

◆ interpolate()

◆ isArc()

◆ isConvex()

◆ IsCubicDegenerate()

◆ isEmpty()

◆ isFinite()

◆ isInterpolatable()

◆ isInverseFillType()

◆ isLastContourClosed()

◆ isLine()

◆ IsLineDegenerate()

◆ isOval()