#include <SkPathRef.h>

Inheritance diagram for SkPathRef:

Classes
class	Editor

class	Iter

Public Types
enum class	PathType : uint8_t { kGeneral , kOval , kRRect , kArc }

using	PointsArray = skia_private::STArray< 4, SkPoint >

using	VerbsArray = skia_private::STArray< 4, uint8_t >

using	ConicWeightsArray = skia_private::STArray< 2, SkScalar >

Public Member Functions
	SkPathRef (PointsArray points, VerbsArray verbs, ConicWeightsArray weights, unsigned segmentMask)

bool	isFinite () const

uint32_t	getSegmentMasks () const

bool	isOval (SkRect rect, bool isCCW, unsigned *start) const

bool	isRRect (SkRRect rrect, bool isCCW, unsigned *start) const

bool	isArc (SkArc *arc) const

bool	hasComputedBounds () const

const SkRect &	getBounds () const

SkRRect	getRRect () const

	~SkPathRef ()

int	countPoints () const

int	countVerbs () const

int	countWeights () const

size_t	approximateBytesUsed () const

const uint8_t *	verbsBegin () const

const uint8_t *	verbsEnd () const

const SkPoint *	points () const

const SkPoint *	pointsEnd () const

const SkScalar *	conicWeights () const

const SkScalar *	conicWeightsEnd () const

uint8_t	atVerb (int index) const

const SkPoint &	atPoint (int index) const

bool	operator== (const SkPathRef &ref) const

void	interpolate (const SkPathRef &ending, SkScalar weight, SkPathRef *out) const

uint32_t	genID (uint8_t fillType) const

void	addGenIDChangeListener (sk_sp< SkIDChangeListener >)

int	genIDChangeListenerCount ()

bool	dataMatchesVerbs () const

bool	isValid () const

	SkDEBUGCODE (void validate() const { SkASSERT(this->isValid());}) void reset()

bool	isInitialEmptyPathRef () const

Public Member Functions inherited from SkNVRefCnt< SkPathRef >
	SkNVRefCnt ()

	~SkNVRefCnt ()

bool	unique () const

void	ref () const

void	unref () const

void	deref () const

bool	refCntGreaterThan (int32_t threadIsolatedTestCnt) const

Static Public Member Functions
static SkPathRef *	CreateEmpty ()

static void	CreateTransformedCopy (sk_sp< SkPathRef > *dst, const SkPathRef &src, const SkMatrix &matrix)

static void	Rewind (sk_sp< SkPathRef > *pathRef)

Friends
class	PathRefTest_Private

class	ForceIsRRect_Private

class	SkPath

class	SkPathBuilder

class	SkPathPriv

SkPathRef *	sk_create_empty_pathref ()

Detailed Description

Holds the path verbs and points. It is versioned by a generation ID. None of its public methods modify the contents. To modify or append to the verbs/points wrap the SkPathRef in an SkPathRef::Editor object. Installing the editor resets the generation ID. It also performs copy-on-write if the SkPathRef is shared by multiple SkPaths. The caller passes the Editor's constructor a pointer to a sk_sp<SkPathRef>, which may be updated to point to a new SkPathRef after the editor's constructor returns.

The points and verbs are stored in a single allocation. The points are at the begining of the allocation while the verbs are stored at end of the allocation, in reverse order. Thus the points and verbs both grow into the middle of the allocation until the meet. To access verb i in the verb array use ref.verbs()[~i] (because verbs() returns a pointer just beyond the first logical verb or the last verb in memory).

Definition at line 55 of file SkPathRef.h.

Member Typedef Documentation

◆ ConicWeightsArray

using SkPathRef::ConicWeightsArray = skia_private::STArray<2, SkScalar>

Definition at line 61 of file SkPathRef.h.

◆ PointsArray

using SkPathRef::PointsArray = skia_private::STArray<4, SkPoint>

Definition at line 59 of file SkPathRef.h.

◆ VerbsArray

using SkPathRef::VerbsArray = skia_private::STArray<4, uint8_t>

Definition at line 60 of file SkPathRef.h.

Member Enumeration Documentation

◆ PathType

enum class SkPathRef::PathType : uint8_t

strong

Enumerator
kGeneral
kOval
kRRect
kArc

Definition at line 63 of file SkPathRef.h.

                        : uint8_t {
        kGeneral,
        kOval,
        kRRect,
        kArc,
    };

Constructor & Destructor Documentation

◆ SkPathRef()

SkPathRef::SkPathRef	(	PointsArray	points,
		VerbsArray	verbs,
		ConicWeightsArray	weights,
		unsigned	segmentMask
	)

inline

Definition at line 70 of file SkPathRef.h.

        : fPoints(std::move(points))
        , fVerbs(std::move(verbs))
        , fConicWeights(std::move(weights))
    {
        fBoundsIsDirty = true;    // this also invalidates fIsFinite
        fGenerationID = 0;        // recompute
        fSegmentMask = segmentMask;
        fType = PathType::kGeneral;
        // The next two values don't matter unless fType is kOval or kRRect
        fRRectOrOvalIsCCW = false;
        fRRectOrOvalStartIdx = 0xAC;
        fArcOval.setEmpty();
        fArcStartAngle = fArcSweepAngle = 0.0f;
        fArcUseCenter = false;
        SkDEBUGCODE(fEditorsAttached.store(0);)
 
        this->computeBounds();  // do this now, before we worry about multiple owners/threads
        SkDEBUGCODE(this->validate();)
    }

◆ ~SkPathRef()

SkPathRef::~SkPathRef ( )

Definition at line 67 of file SkPathRef.cpp.

                      {
    // Deliberately don't validate() this path ref, otherwise there's no way
    // to read one that's not valid and then free its memory without asserting.
    SkDEBUGCODE(fGenerationID = 0xEEEEEEEE;)
    SkDEBUGCODE(fEditorsAttached.store(0x7777777);)
}

Member Function Documentation

◆ addGenIDChangeListener()

void SkPathRef::addGenIDChangeListener ( sk_sp< SkIDChangeListener > listener )

Definition at line 461 of file SkPathRef.cpp.

                                                                         {
    if (this == gEmpty) {
        return;
    }
    fGenIDChangeListeners.add(std::move(listener));
}

◆ approximateBytesUsed()

size_t SkPathRef::approximateBytesUsed ( ) const

Definition at line 60 of file SkPathRef.cpp.

                                             {
    return sizeof(SkPathRef)
         + fPoints      .capacity() * sizeof(fPoints      [0])
         + fVerbs       .capacity() * sizeof(fVerbs       [0])
         + fConicWeights.capacity() * sizeof(fConicWeights[0]);
}

◆ atPoint()

const SkPoint & SkPathRef::atPoint ( int index ) const

inline

Definition at line 342 of file SkPathRef.h.

342{ return fPoints[index]; }

◆ atVerb()

uint8_t SkPathRef::atVerb ( int index ) const

inline

Convenience methods for getting to a verb or point by index.

Definition at line 341 of file SkPathRef.h.

341{ return fVerbs[index]; }

◆ conicWeights()

const SkScalar * SkPathRef::conicWeights ( ) const

inline

Definition at line 335 of file SkPathRef.h.

335{ return fConicWeights.begin(); }

skia_private::TArray::begin

T * begin()

Definition SkTArray.h:393

◆ conicWeightsEnd()

const SkScalar * SkPathRef::conicWeightsEnd ( ) const

inline

Definition at line 336 of file SkPathRef.h.

336{ return fConicWeights.end(); }

skia_private::TArray::end

T * end()

Definition SkTArray.h:402

◆ countPoints()

int SkPathRef::countPoints ( ) const

inline

Definition at line 309 of file SkPathRef.h.

309{ return fPoints.size(); }

skia_private::TArray::size

int size() const

Definition SkTArray.h:416

◆ countVerbs()

int SkPathRef::countVerbs ( ) const

inline

Definition at line 310 of file SkPathRef.h.

310{ return fVerbs.size(); }

◆ countWeights()

int SkPathRef::countWeights ( ) const

inline

Definition at line 311 of file SkPathRef.h.

311{ return fConicWeights.size(); }

◆ CreateEmpty()

SkPathRef * SkPathRef::CreateEmpty ( )

static

Gets a path ref with no verbs or points.

Definition at line 76 of file SkPathRef.cpp.

                                  {
    static SkOnce once;
    once([]{
        gEmpty = new SkPathRef;
        gEmpty->computeBounds();   // Avoids races later to be the first to do this.
    });
    return SkRef(gEmpty);
}

◆ CreateTransformedCopy()

void SkPathRef::CreateTransformedCopy	(	sk_sp< SkPathRef > *	dst,
		const SkPathRef &	src,
		const SkMatrix &	matrix
	)

static

Transforms a path ref by a matrix, allocating a new one only if necessary.

Definition at line 140 of file SkPathRef.cpp.

                                                              {
    SkDEBUGCODE(src.validate();)
    if (matrix.isIdentity()) {
        if (dst->get() != &src) {
            src.ref();
            dst->reset(const_cast<SkPathRef*>(&src));
            SkDEBUGCODE((*dst)->validate();)
        }
        return;
    }
 
    sk_sp<const SkPathRef> srcKeepAlive;
    if (!(*dst)->unique()) {
        // If dst and src are the same then we are about to drop our only ref on the common path
        // ref. Some other thread may have owned src when we checked unique() above but it may not
        // continue to do so. Add another ref so we continue to be an owner until we're done.
        if (dst->get() == &src) {
            srcKeepAlive.reset(SkRef(&src));
        }
        dst->reset(new SkPathRef);
    }
 
    if (dst->get() != &src) {
        (*dst)->fVerbs = src.fVerbs;
        (*dst)->fConicWeights = src.fConicWeights;
        (*dst)->callGenIDChangeListeners();
        (*dst)->fGenerationID = 0;  // mark as dirty
        // don't copy, just allocate the points
        (*dst)->fPoints.resize(src.fPoints.size());
    }
    matrix.mapPoints((*dst)->fPoints.begin(), src.fPoints.begin(), src.fPoints.size());
 
    // Need to check this here in case (&src == dst)
    bool canXformBounds = !src.fBoundsIsDirty && matrix.rectStaysRect() && src.countPoints() > 1;
 
    /*
     *  Here we optimize the bounds computation, by noting if the bounds are
     *  already known, and if so, we just transform those as well and mark
     *  them as "known", rather than force the transformed path to have to
     *  recompute them.
     *
     *  Special gotchas if the path is effectively empty (<= 1 point) or
     *  if it is non-finite. In those cases bounds need to stay empty,
     *  regardless of the matrix.
     */
    if (canXformBounds) {
        (*dst)->fBoundsIsDirty = false;
        if (src.fIsFinite) {
            matrix.mapRect(&(*dst)->fBounds, src.fBounds);
            if (!((*dst)->fIsFinite = (*dst)->fBounds.isFinite())) {
                (*dst)->fBounds.setEmpty();
            }
        } else {
            (*dst)->fIsFinite = false;
            (*dst)->fBounds.setEmpty();
        }
    } else {
        (*dst)->fBoundsIsDirty = true;
    }
 
    (*dst)->fSegmentMask = src.fSegmentMask;
 
    // It's an oval only if it stays a rect. Technically if scale is uniform, then it would stay an
    // arc. For now, don't bother handling that (we'd also need to fixup the angles for negative
    // scale, etc.)
    bool rectStaysRect = matrix.rectStaysRect();
    const PathType newType =
            (rectStaysRect && src.fType != PathType::kArc) ? src.fType : PathType::kGeneral;
    (*dst)->fType = newType;
    if (newType == PathType::kOval || newType == PathType::kRRect) {
        unsigned start = src.fRRectOrOvalStartIdx;
        bool isCCW = SkToBool(src.fRRectOrOvalIsCCW);
        transform_dir_and_start(matrix, newType == PathType::kRRect, &isCCW, &start);
        (*dst)->fRRectOrOvalIsCCW = isCCW;
        (*dst)->fRRectOrOvalStartIdx = start;
    }
 
    if (dst->get() == &src) {
        (*dst)->callGenIDChangeListeners();
        (*dst)->fGenerationID = 0;
    }
 
    SkDEBUGCODE((*dst)->validate();)
}

◆ dataMatchesVerbs()

bool SkPathRef::dataMatchesVerbs ( ) const

Definition at line 680 of file SkPathRef.cpp.

                                       {
    const auto info = sk_path_analyze_verbs(fVerbs.begin(), fVerbs.size());
    return info.valid                          &&
           info.segmentMask == fSegmentMask    &&
           info.points      == fPoints.size()  &&
           info.weights     == fConicWeights.size();
}

◆ genID()

uint32_t SkPathRef::genID ( uint8_t fillType ) const

Gets an ID that uniquely identifies the contents of the path ref. If two path refs have the same ID then they have the same verbs and points. However, two path refs may have the same contents but different genIDs. skbug.com/1762 for background on why fillType is necessary (for now).

Definition at line 440 of file SkPathRef.cpp.

                                                {
    SkASSERT(fEditorsAttached.load() == 0);
    static const uint32_t kMask = (static_cast<int64_t>(1) << kPathRefGenIDBitCnt) - 1;
 
    if (fGenerationID == 0) {
        if (fPoints.empty() && fVerbs.empty()) {
            fGenerationID = kEmptyGenID;
        } else {
            static std::atomic<uint32_t> nextID{kEmptyGenID + 1};
            do {
                fGenerationID = nextID.fetch_add(1, std::memory_order_relaxed) & kMask;
            } while (fGenerationID == 0 || fGenerationID == kEmptyGenID);
        }
    }
    #if defined(SK_BUILD_FOR_ANDROID_FRAMEWORK)
        SkASSERT((unsigned)fillType < (1 << (32 - kPathRefGenIDBitCnt)));
        fGenerationID |= static_cast<uint32_t>(fillType) << kPathRefGenIDBitCnt;
    #endif
    return fGenerationID;
}

◆ genIDChangeListenerCount()

int SkPathRef::genIDChangeListenerCount ( )

Definition at line 468 of file SkPathRef.cpp.

468{ return fGenIDChangeListeners.count(); }

SkIDChangeListener::List::count

int count() const SK_EXCLUDES(fMutex)

Definition SkIDChangeListener.cpp:55

◆ getBounds()

const SkRect & SkPathRef::getBounds ( ) const

inline

Returns the bounds of the path's points. If the path contains 0 or 1 points, the bounds is set to (0,0,0,0), and isEmpty() will return true. Note: this bounds may be larger than the actual shape, since curves do not extend as far as their control points.

Definition at line 283 of file SkPathRef.h.

                                    {
        if (fBoundsIsDirty) {
            this->computeBounds();
        }
        return fBounds;
    }

◆ getRRect()

SkRRect SkPathRef::getRRect ( ) const

Definition at line 475 of file SkPathRef.cpp.

                                  {
    const SkRect& bounds = this->getBounds();
    SkVector radii[4] = {{0, 0}, {0, 0}, {0, 0}, {0, 0}};
    Iter iter(*this);
    SkPoint pts[4];
    uint8_t verb = iter.next(pts);
    SkASSERT(SkPath::kMove_Verb == verb);
    while ((verb = iter.next(pts)) != SkPath::kDone_Verb) {
        if (SkPath::kConic_Verb == verb) {
            SkVector v1_0 = pts[1] - pts[0];
            SkVector v2_1 = pts[2] - pts[1];
            SkVector dxdy;
            if (v1_0.fX) {
                SkASSERT(!v2_1.fX && !v1_0.fY);
                dxdy.set(SkScalarAbs(v1_0.fX), SkScalarAbs(v2_1.fY));
            } else if (!v1_0.fY) {
                SkASSERT(!v2_1.fX || !v2_1.fY);
                dxdy.set(SkScalarAbs(v2_1.fX), SkScalarAbs(v2_1.fY));
            } else {
                SkASSERT(!v2_1.fY);
                dxdy.set(SkScalarAbs(v2_1.fX), SkScalarAbs(v1_0.fY));
            }
            SkRRect::Corner corner =
                    pts[1].fX == bounds.fLeft ?
                        pts[1].fY == bounds.fTop ?
                            SkRRect::kUpperLeft_Corner : SkRRect::kLowerLeft_Corner :
                    pts[1].fY == bounds.fTop ?
                            SkRRect::kUpperRight_Corner : SkRRect::kLowerRight_Corner;
            SkASSERT(!radii[corner].fX && !radii[corner].fY);
            radii[corner] = dxdy;
        } else {
            SkASSERT((verb == SkPath::kLine_Verb
                    && (!(pts[1].fX - pts[0].fX) || !(pts[1].fY - pts[0].fY)))
                    || verb == SkPath::kClose_Verb);
        }
    }
    SkRRect rrect;
    rrect.setRectRadii(bounds, radii);
    return rrect;
}

◆ getSegmentMasks()

uint32_t SkPathRef::getSegmentMasks ( ) const

inline

Returns a mask, where each bit corresponding to a SegmentMask is set if the path contains 1 or more segments of that type. Returns 0 for an empty path (no segments).

Definition at line 228 of file SkPathRef.h.

228{ return fSegmentMask; }

◆ hasComputedBounds()

bool SkPathRef::hasComputedBounds ( ) const

inline

Definition at line 274 of file SkPathRef.h.

                                   {
        return !fBoundsIsDirty;
    }

◆ interpolate()

void SkPathRef::interpolate	(	const SkPathRef &	ending,
		SkScalar	weight,
		SkPathRef *	out
	)		const

Definition at line 300 of file SkPathRef.cpp.

                                                                                          {
    const SkScalar* inValues = &ending.getPoints()->fX;
    SkScalar* outValues = &out->getWritablePoints()->fX;
    int count = out->countPoints() * 2;
    for (int index = 0; index < count; ++index) {
        outValues[index] = outValues[index] * weight + inValues[index] * (1 - weight);
    }
    out->fBoundsIsDirty = true;
    out->fType = PathType::kGeneral;
}

◆ isArc()

bool SkPathRef::isArc ( SkArc * arc ) const

inline

Definition at line 261 of file SkPathRef.h.

                                 {
        if (fType == PathType::kArc) {
            if (arc) {
                arc->fOval = fArcOval;
                arc->fStartAngle = fArcStartAngle;
                arc->fSweepAngle = fArcSweepAngle;
                arc->fUseCenter = fArcUseCenter;
            }
        }
 
        return fType == PathType::kArc;
    }

◆ isFinite()

bool SkPathRef::isFinite ( ) const

inline

Returns true if all of the points in this path are finite, meaning there are no infinities and no NaNs.

Definition at line 216 of file SkPathRef.h.

                          {
        if (fBoundsIsDirty) {
            this->computeBounds();
        }
        return SkToBool(fIsFinite);
    }

◆ isInitialEmptyPathRef()

bool SkPathRef::isInitialEmptyPathRef ( ) const

inline

Definition at line 368 of file SkPathRef.h.

                                       {
        return fGenerationID == kEmptyGenID;
    }

◆ isOval()

bool SkPathRef::isOval	(	SkRect *	rect,
		bool *	isCCW,
		unsigned *	start
	)		const

inline

Returns true if the path is an oval.

Parameters

rect	returns the bounding rect of this oval. It's a circle if the height and width are the same.
isCCW	is the oval CCW (or CW if false).
start	indicates where the contour starts on the oval (see SkPath::addOval for intepretation of the index).

Returns: true if this path is an oval. Tracking whether a path is an oval is considered an optimization for performance and so some paths that are in fact ovals can report false.

Definition at line 243 of file SkPathRef.h.

                                                                  {
        if (fType == PathType::kOval) {
            if (rect) {
                *rect = this->getBounds();
            }
            if (isCCW) {
                *isCCW = SkToBool(fRRectOrOvalIsCCW);
            }
            if (start) {
                *start = fRRectOrOvalStartIdx;
            }
        }
 
        return fType == PathType::kOval;
    }

◆ isRRect()

bool SkPathRef::isRRect	(	SkRRect *	rrect,
		bool *	isCCW,
		unsigned *	start
	)		const

Definition at line 516 of file SkPathRef.cpp.

                                                                          {
    if (fType == PathType::kRRect) {
        if (rrect) {
            *rrect = this->getRRect();
        }
        if (isCCW) {
            *isCCW = SkToBool(fRRectOrOvalIsCCW);
        }
        if (start) {
            *start = fRRectOrOvalStartIdx;
        }
    }
    return fType == PathType::kRRect;
}

◆ isValid()

bool SkPathRef::isValid ( ) const

Definition at line 618 of file SkPathRef.cpp.

                              {
    switch (fType) {
        case PathType::kGeneral:
            break;
        case PathType::kOval:
            if (fRRectOrOvalStartIdx >= 4) {
                return false;
            }
            break;
        case PathType::kRRect:
            if (fRRectOrOvalStartIdx >= 8) {
                return false;
            }
            break;
        case PathType::kArc:
            if (!(fArcOval.isFinite() && SkIsFinite(fArcStartAngle, fArcSweepAngle))) {
                return false;
            }
            break;
    }
 
    if (!fBoundsIsDirty && !fBounds.isEmpty()) {
        bool isFinite = true;
        auto leftTop = skvx::float2(fBounds.fLeft, fBounds.fTop);
        auto rightBot = skvx::float2(fBounds.fRight, fBounds.fBottom);
        for (int i = 0; i < fPoints.size(); ++i) {
            auto point = skvx::float2(fPoints[i].fX, fPoints[i].fY);
#ifdef SK_DEBUG
            if (fPoints[i].isFinite() && (any(point < leftTop)|| any(point > rightBot))) {
                SkDebugf("bad SkPathRef bounds: %g %g %g %g\n",
                         fBounds.fLeft, fBounds.fTop, fBounds.fRight, fBounds.fBottom);
                for (int j = 0; j < fPoints.size(); ++j) {
                    if (i == j) {
                        SkDebugf("*** bounds do not contain: ");
                    }
                    SkDebugf("%g %g\n", fPoints[j].fX, fPoints[j].fY);
                }
                return false;
            }
#endif
 
            if (fPoints[i].isFinite() && any(point < leftTop) && !any(point > rightBot))
                return false;
            if (!fPoints[i].isFinite()) {
                isFinite = false;
            }
        }
        if (SkToBool(fIsFinite) != isFinite) {
            return false;
        }
    }
    return true;
}

◆ operator==()

bool SkPathRef::operator== ( const SkPathRef & ref ) const

Definition at line 247 of file SkPathRef.cpp.

                                                      {
    SkDEBUGCODE(this->validate();)
    SkDEBUGCODE(ref.validate();)
 
    // We explicitly check fSegmentMask as a quick-reject. We could skip it,
    // since it is only a cache of info in the fVerbs, but its a fast way to
    // notice a difference
    if (fSegmentMask != ref.fSegmentMask) {
        return false;
    }
 
    bool genIDMatch = fGenerationID && fGenerationID == ref.fGenerationID;
#ifdef SK_RELEASE
    if (genIDMatch) {
        return true;
    }
#endif
    if (fPoints != ref.fPoints || fConicWeights != ref.fConicWeights || fVerbs != ref.fVerbs) {
        SkASSERT(!genIDMatch);
        return false;
    }
    if (ref.fVerbs.empty()) {
        SkASSERT(ref.fPoints.empty());
    }
    return true;
}

◆ points()

const SkPoint * SkPathRef::points ( ) const

inline

Returns a const pointer to the first point.

Definition at line 328 of file SkPathRef.h.

328{ return fPoints.begin(); }

◆ pointsEnd()

const SkPoint * SkPathRef::pointsEnd ( ) const

inline

Shortcut for this->points() + this->countPoints()

Definition at line 333 of file SkPathRef.h.

333{ return this->points() + this->countPoints(); }

SkPathRef::countPoints

int countPoints() const

Definition SkPathRef.h:309

◆ Rewind()

void SkPathRef::Rewind ( sk_sp< SkPathRef > * pathRef )

static

Rollsback a path ref to zero verbs and points with the assumption that the path ref will be repopulated with approximately the same number of verbs and points. A new path ref is created only if necessary.

Definition at line 227 of file SkPathRef.cpp.

                                                {
    if ((*pathRef)->unique()) {
        SkDEBUGCODE((*pathRef)->validate();)
        (*pathRef)->callGenIDChangeListeners();
        (*pathRef)->fBoundsIsDirty = true;  // this also invalidates fIsFinite
        (*pathRef)->fGenerationID = 0;
        (*pathRef)->fPoints.clear();
        (*pathRef)->fVerbs.clear();
        (*pathRef)->fConicWeights.clear();
        (*pathRef)->fSegmentMask = 0;
        (*pathRef)->fType = PathType::kGeneral;
        SkDEBUGCODE((*pathRef)->validate();)
    } else {
        int oldVCnt = (*pathRef)->countVerbs();
        int oldPCnt = (*pathRef)->countPoints();
        pathRef->reset(new SkPathRef);
        (*pathRef)->resetToSize(0, 0, 0, oldVCnt, oldPCnt);
    }
}

◆ SkDEBUGCODE()

SkPathRef::SkDEBUGCODE ( void validate() const { SkASSERT(this->isValid());} )

Resets this SkPathRef to a clean state.

◆ verbsBegin()

const uint8_t * SkPathRef::verbsBegin ( ) const

inline

Returns a pointer one beyond the first logical verb (last verb in memory order).

Definition at line 318 of file SkPathRef.h.

318{ return fVerbs.begin(); }

◆ verbsEnd()

const uint8_t * SkPathRef::verbsEnd ( ) const

inline

Returns a const pointer to the first verb in memory (which is the last logical verb).

Definition at line 323 of file SkPathRef.h.

323{ return fVerbs.end(); }

Friends And Related Symbol Documentation

◆ ForceIsRRect_Private

friend class ForceIsRRect_Private

friend

Definition at line 578 of file SkPathRef.h.

◆ PathRefTest_Private

friend class PathRefTest_Private

friend

Definition at line 577 of file SkPathRef.h.

◆ sk_create_empty_pathref

SkPathRef * sk_create_empty_pathref ( )

friend

Called the first time someone calls CreateEmpty to actually create the singleton.

◆ SkPath

friend class SkPath

friend

Definition at line 579 of file SkPathRef.h.

◆ SkPathBuilder

friend class SkPathBuilder

friend

Definition at line 580 of file SkPathRef.h.

◆ SkPathPriv

friend class SkPathPriv

friend

Definition at line 581 of file SkPathRef.h.

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

third_party/skia/include/private/SkPathRef.h
third_party/skia/src/core/SkPathRef.cpp

Classes

Public Types

Public Member Functions

Static Public Member Functions

Friends

Detailed Description

Member Typedef Documentation

◆ ConicWeightsArray

◆ PointsArray

◆ VerbsArray

Member Enumeration Documentation

◆ PathType

Constructor & Destructor Documentation

◆ SkPathRef()

◆ ~SkPathRef()

Member Function Documentation

◆ addGenIDChangeListener()

◆ approximateBytesUsed()

◆ atPoint()

◆ atVerb()

◆ conicWeights()

◆ conicWeightsEnd()

◆ countPoints()

◆ countVerbs()

◆ countWeights()

◆ CreateEmpty()

◆ CreateTransformedCopy()

◆ dataMatchesVerbs()

◆ genID()

◆ genIDChangeListenerCount()

◆ getBounds()

◆ getRRect()

◆ getSegmentMasks()

◆ hasComputedBounds()

◆ interpolate()

◆ isArc()

◆ isFinite()

◆ isInitialEmptyPathRef()

◆ isOval()

◆ isRRect()

◆ isValid()

◆ operator==()

◆ points()

◆ pointsEnd()

◆ Rewind()

◆ SkDEBUGCODE()

◆ verbsBegin()

◆ verbsEnd()

Friends And Related Symbol Documentation

◆ ForceIsRRect_Private

◆ PathRefTest_Private

◆ sk_create_empty_pathref

◆ SkPath

◆ SkPathBuilder

◆ SkPathPriv