| /* |
| * Copyright 2012 Google Inc. |
| * |
| * Use of this source code is governed by a BSD-style license that can be |
| * found in the LICENSE file. |
| */ |
| |
| #ifndef SkPathRef_DEFINED |
| #define SkPathRef_DEFINED |
| |
| #include "include/core/SkArc.h" |
| #include "include/core/SkPoint.h" |
| #include "include/core/SkRect.h" |
| #include "include/core/SkRefCnt.h" |
| #include "include/core/SkScalar.h" |
| #include "include/core/SkTypes.h" |
| #include "include/private/SkIDChangeListener.h" |
| #include "include/private/base/SkDebug.h" |
| #include "include/private/base/SkTArray.h" |
| #include "include/private/base/SkTo.h" |
| |
| #include <atomic> |
| #include <cstddef> |
| #include <cstdint> |
| #include <tuple> |
| #include <utility> |
| |
| class SkMatrix; |
| class SkRRect; |
| |
| // These are computed from a stream of verbs |
| struct SkPathVerbAnalysis { |
| bool valid; |
| int points, weights; |
| unsigned segmentMask; |
| }; |
| SkPathVerbAnalysis sk_path_analyze_verbs(const uint8_t verbs[], int count); |
| |
| |
| /** |
| * 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). |
| */ |
| |
| class SK_API SkPathRef final : public SkNVRefCnt<SkPathRef> { |
| public: |
| // See https://bugs.chromium.org/p/skia/issues/detail?id=13817 for how these sizes were |
| // determined. |
| using PointsArray = skia_private::STArray<4, SkPoint>; |
| using VerbsArray = skia_private::STArray<4, uint8_t>; |
| using ConicWeightsArray = skia_private::STArray<2, SkScalar>; |
| |
| enum class PathType : uint8_t { |
| kGeneral, |
| kOval, |
| kOpenOval, // An unclosed oval, as is generated by canvas2d ellipse or arc |
| kRRect, |
| kArc, |
| }; |
| |
| SkPathRef(PointsArray points, VerbsArray verbs, ConicWeightsArray weights, |
| unsigned segmentMask) |
| : 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; |
| fArcType = SkArc::Type::kArc; |
| SkDEBUGCODE(fEditorsAttached.store(0);) |
| |
| this->computeBounds(); // do this now, before we worry about multiple owners/threads |
| SkDEBUGCODE(this->validate();) |
| } |
| |
| class Editor { |
| public: |
| Editor(sk_sp<SkPathRef>* pathRef, |
| int incReserveVerbs = 0, |
| int incReservePoints = 0, |
| int incReserveConics = 0); |
| |
| ~Editor() { SkDEBUGCODE(fPathRef->fEditorsAttached--;) } |
| |
| /** |
| * Returns the array of points. |
| */ |
| SkPoint* writablePoints() { return fPathRef->getWritablePoints(); } |
| const SkPoint* points() const { return fPathRef->points(); } |
| |
| /** |
| * Gets the ith point. Shortcut for this->points() + i |
| */ |
| SkPoint* atPoint(int i) { return fPathRef->getWritablePoints() + i; } |
| const SkPoint* atPoint(int i) const { return &fPathRef->fPoints[i]; } |
| |
| /** |
| * Adds the verb and allocates space for the number of points indicated by the verb. The |
| * return value is a pointer to where the points for the verb should be written. |
| * 'weight' is only used if 'verb' is kConic_Verb |
| */ |
| SkPoint* growForVerb(int /*SkPath::Verb*/ verb, SkScalar weight = 0) { |
| SkDEBUGCODE(fPathRef->validate();) |
| return fPathRef->growForVerb(verb, weight); |
| } |
| |
| /** |
| * Allocates space for multiple instances of a particular verb and the |
| * requisite points & weights. |
| * The return pointer points at the first new point (indexed normally [<i>]). |
| * If 'verb' is kConic_Verb, 'weights' will return a pointer to the |
| * space for the conic weights (indexed normally). |
| */ |
| SkPoint* growForRepeatedVerb(int /*SkPath::Verb*/ verb, |
| int numVbs, |
| SkScalar** weights = nullptr) { |
| return fPathRef->growForRepeatedVerb(verb, numVbs, weights); |
| } |
| |
| /** |
| * Concatenates all verbs from 'path' onto the pathRef's verbs array. Increases the point |
| * count by the number of points in 'path', and the conic weight count by the number of |
| * conics in 'path'. |
| * |
| * Returns pointers to the uninitialized points and conic weights data. |
| */ |
| std::tuple<SkPoint*, SkScalar*> growForVerbsInPath(const SkPathRef& path) { |
| return fPathRef->growForVerbsInPath(path); |
| } |
| |
| /** |
| * Resets the path ref to a new verb and point count. The new verbs and points are |
| * uninitialized. |
| */ |
| void resetToSize(int newVerbCnt, int newPointCnt, int newConicCount) { |
| fPathRef->resetToSize(newVerbCnt, newPointCnt, newConicCount); |
| } |
| |
| /** |
| * Gets the path ref that is wrapped in the Editor. |
| */ |
| SkPathRef* pathRef() { return fPathRef; } |
| |
| void setIsOval(bool isCCW, unsigned start, bool isClosed) { |
| fPathRef->setIsOval(isCCW, start, isClosed); |
| } |
| |
| void setIsRRect(bool isCCW, unsigned start) { |
| fPathRef->setIsRRect(isCCW, start); |
| } |
| |
| void setIsArc(const SkArc& arc) { |
| fPathRef->setIsArc(arc); |
| } |
| |
| void setBounds(const SkRect& rect) { fPathRef->setBounds(rect); } |
| |
| private: |
| SkPathRef* fPathRef; |
| }; |
| |
| class SK_API Iter { |
| public: |
| Iter(); |
| Iter(const SkPathRef&); |
| |
| void setPathRef(const SkPathRef&); |
| |
| /** Return the next verb in this iteration of the path. When all |
| segments have been visited, return kDone_Verb. |
| |
| If any point in the path is non-finite, return kDone_Verb immediately. |
| |
| @param pts The points representing the current verb and/or segment |
| This must not be NULL. |
| @return The verb for the current segment |
| */ |
| uint8_t next(SkPoint pts[4]); |
| uint8_t peek() const; |
| |
| SkScalar conicWeight() const { return *fConicWeights; } |
| |
| private: |
| const SkPoint* fPts; |
| const uint8_t* fVerbs; |
| const uint8_t* fVerbStop; |
| const SkScalar* fConicWeights; |
| }; |
| |
| public: |
| /** |
| * Gets a path ref with no verbs or points. |
| */ |
| static SkPathRef* CreateEmpty(); |
| |
| /** |
| * Returns true if all of the points in this path are finite, meaning there |
| * are no infinities and no NaNs. |
| */ |
| bool isFinite() const { |
| if (fBoundsIsDirty) { |
| this->computeBounds(); |
| } |
| return SkToBool(fIsFinite); |
| } |
| |
| /** |
| * 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). |
| */ |
| uint32_t getSegmentMasks() const { return fSegmentMask; } |
| |
| /** Returns true if the path is an oval. |
| * |
| * @param rect returns the bounding rect of this oval. It's a circle |
| * if the height and width are the same. |
| * @param isCCW is the oval CCW (or CW if false). |
| * @param start indicates where the contour starts on the oval (see |
| * SkPath::addOval for intepretation of the index). |
| * |
| * @return 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. |
| */ |
| bool isOval(SkRect* rect, bool* isCCW, unsigned* start) const { |
| if (fType == PathType::kOval) { |
| if (rect) { |
| *rect = this->getBounds(); |
| } |
| if (isCCW) { |
| *isCCW = SkToBool(fRRectOrOvalIsCCW); |
| } |
| if (start) { |
| *start = fRRectOrOvalStartIdx; |
| } |
| } |
| |
| return fType == PathType::kOval; |
| } |
| |
| bool isRRect(SkRRect* rrect, bool* isCCW, unsigned* start) const; |
| |
| bool isArc(SkArc* arc) const { |
| if (fType == PathType::kArc) { |
| if (arc) { |
| *arc = SkArc::Make(fArcOval, fArcStartAngle, fArcSweepAngle, fArcType); |
| } |
| } |
| |
| return fType == PathType::kArc; |
| } |
| |
| bool hasComputedBounds() const { |
| return !fBoundsIsDirty; |
| } |
| |
| /** 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. |
| */ |
| const SkRect& getBounds() const { |
| if (fBoundsIsDirty) { |
| this->computeBounds(); |
| } |
| return fBounds; |
| } |
| |
| SkRRect getRRect() const; |
| |
| /** |
| * Transforms a path ref by a matrix, allocating a new one only if necessary. |
| */ |
| static void CreateTransformedCopy(sk_sp<SkPathRef>* dst, |
| const SkPathRef& src, |
| const SkMatrix& matrix); |
| |
| // static SkPathRef* CreateFromBuffer(SkRBuffer* buffer); |
| |
| /** |
| * 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. |
| */ |
| static void Rewind(sk_sp<SkPathRef>* pathRef); |
| |
| ~SkPathRef(); |
| int countPoints() const { return fPoints.size(); } |
| int countVerbs() const { return fVerbs.size(); } |
| int countWeights() const { return fConicWeights.size(); } |
| |
| size_t approximateBytesUsed() const; |
| |
| /** |
| * Returns a pointer one beyond the first logical verb (last verb in memory order). |
| */ |
| const uint8_t* verbsBegin() const { return fVerbs.begin(); } |
| |
| /** |
| * Returns a const pointer to the first verb in memory (which is the last logical verb). |
| */ |
| const uint8_t* verbsEnd() const { return fVerbs.end(); } |
| |
| /** |
| * Returns a const pointer to the first point. |
| */ |
| const SkPoint* points() const { return fPoints.begin(); } |
| |
| /** |
| * Shortcut for this->points() + this->countPoints() |
| */ |
| const SkPoint* pointsEnd() const { return this->points() + this->countPoints(); } |
| |
| const SkScalar* conicWeights() const { return fConicWeights.begin(); } |
| const SkScalar* conicWeightsEnd() const { return fConicWeights.end(); } |
| |
| /** |
| * Convenience methods for getting to a verb or point by index. |
| */ |
| uint8_t atVerb(int index) const { return fVerbs[index]; } |
| const SkPoint& atPoint(int index) const { return fPoints[index]; } |
| |
| bool operator== (const SkPathRef& ref) const; |
| |
| void interpolate(const SkPathRef& ending, SkScalar weight, SkPathRef* out) 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). |
| */ |
| uint32_t genID(uint8_t fillType) const; |
| |
| void addGenIDChangeListener(sk_sp<SkIDChangeListener>); // Threadsafe. |
| int genIDChangeListenerCount(); // Threadsafe |
| |
| bool dataMatchesVerbs() const; |
| bool isValid() const; |
| SkDEBUGCODE(void validate() const { SkASSERT(this->isValid()); } ) |
| |
| /** |
| * Resets this SkPathRef to a clean state. |
| */ |
| void reset(); |
| |
| bool isInitialEmptyPathRef() const { |
| return fGenerationID == kEmptyGenID; |
| } |
| |
| private: |
| enum SerializationOffsets { |
| kLegacyRRectOrOvalStartIdx_SerializationShift = 28, // requires 3 bits, ignored. |
| kLegacyRRectOrOvalIsCCW_SerializationShift = 27, // requires 1 bit, ignored. |
| kLegacyIsRRect_SerializationShift = 26, // requires 1 bit, ignored. |
| kIsFinite_SerializationShift = 25, // requires 1 bit |
| kLegacyIsOval_SerializationShift = 24, // requires 1 bit, ignored. |
| kSegmentMask_SerializationShift = 0 // requires 4 bits (deprecated) |
| }; |
| |
| SkPathRef(int numVerbs = 0, int numPoints = 0, int numConics = 0) { |
| fBoundsIsDirty = true; // this also invalidates fIsFinite |
| fGenerationID = kEmptyGenID; |
| fSegmentMask = 0; |
| 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; |
| fArcType = SkArc::Type::kArc; |
| if (numPoints > 0) { |
| fPoints.reserve_exact(numPoints); |
| } |
| if (numVerbs > 0) { |
| fVerbs.reserve_exact(numVerbs); |
| } |
| if (numConics > 0) { |
| fConicWeights.reserve_exact(numConics); |
| } |
| SkDEBUGCODE(fEditorsAttached.store(0);) |
| SkDEBUGCODE(this->validate();) |
| } |
| |
| void copy(const SkPathRef& ref, int additionalReserveVerbs, int additionalReservePoints, int additionalReserveConics); |
| |
| // Return true if the computed bounds are finite. |
| static bool ComputePtBounds(SkRect* bounds, const SkPathRef& ref) { |
| return bounds->setBoundsCheck(ref.points(), ref.countPoints()); |
| } |
| |
| // called, if dirty, by getBounds() |
| void computeBounds() const { |
| SkDEBUGCODE(this->validate();) |
| // TODO: remove fBoundsIsDirty and fIsFinite, |
| // using an inverted rect instead of fBoundsIsDirty and always recalculating fIsFinite. |
| SkASSERT(fBoundsIsDirty); |
| |
| fIsFinite = ComputePtBounds(&fBounds, *this); |
| fBoundsIsDirty = false; |
| } |
| |
| void setBounds(const SkRect& rect) { |
| SkASSERT(rect.fLeft <= rect.fRight && rect.fTop <= rect.fBottom); |
| fBounds = rect; |
| fBoundsIsDirty = false; |
| fIsFinite = fBounds.isFinite(); |
| } |
| |
| /** Makes additional room but does not change the counts or change the genID */ |
| void incReserve(int additionalVerbs, int additionalPoints, int additionalConics) { |
| SkDEBUGCODE(this->validate();) |
| // Use reserve() so that if there is not enough space, the array will grow with some |
| // additional space. This ensures repeated calls to grow won't always allocate. |
| if (additionalPoints > 0) { |
| fPoints.reserve(fPoints.size() + additionalPoints); |
| } |
| if (additionalVerbs > 0) { |
| fVerbs.reserve(fVerbs.size() + additionalVerbs); |
| } |
| if (additionalConics > 0) { |
| fConicWeights.reserve(fConicWeights.size() + additionalConics); |
| } |
| SkDEBUGCODE(this->validate();) |
| } |
| |
| /** |
| * Resets all state except that of the verbs, points, and conic-weights. |
| * Intended to be called from other functions that reset state. |
| */ |
| void commonReset() { |
| SkDEBUGCODE(this->validate();) |
| this->callGenIDChangeListeners(); |
| fBoundsIsDirty = true; // this also invalidates fIsFinite |
| fGenerationID = 0; |
| |
| fSegmentMask = 0; |
| fType = PathType::kGeneral; |
| } |
| |
| /** Resets the path ref with verbCount verbs and pointCount points, all uninitialized. Also |
| * allocates space for reserveVerb additional verbs and reservePoints additional points.*/ |
| void resetToSize(int verbCount, int pointCount, int conicCount, |
| int reserveVerbs = 0, int reservePoints = 0, |
| int reserveConics = 0) { |
| this->commonReset(); |
| // Use reserve_exact() so the arrays are sized to exactly fit the data. |
| fPoints.reserve_exact(pointCount + reservePoints); |
| fPoints.resize_back(pointCount); |
| |
| fVerbs.reserve_exact(verbCount + reserveVerbs); |
| fVerbs.resize_back(verbCount); |
| |
| fConicWeights.reserve_exact(conicCount + reserveConics); |
| fConicWeights.resize_back(conicCount); |
| SkDEBUGCODE(this->validate();) |
| } |
| |
| /** |
| * Increases the verb count by numVbs and point count by the required amount. |
| * The new points are uninitialized. All the new verbs are set to the specified |
| * verb. If 'verb' is kConic_Verb, 'weights' will return a pointer to the |
| * uninitialized conic weights. |
| */ |
| SkPoint* growForRepeatedVerb(int /*SkPath::Verb*/ verb, int numVbs, SkScalar** weights); |
| |
| /** |
| * Increases the verb count 1, records the new verb, and creates room for the requisite number |
| * of additional points. A pointer to the first point is returned. Any new points are |
| * uninitialized. |
| */ |
| SkPoint* growForVerb(int /*SkPath::Verb*/ verb, SkScalar weight); |
| |
| /** |
| * Concatenates all verbs from 'path' onto our own verbs array. Increases the point count by the |
| * number of points in 'path', and the conic weight count by the number of conics in 'path'. |
| * |
| * Returns pointers to the uninitialized points and conic weights data. |
| */ |
| std::tuple<SkPoint*, SkScalar*> growForVerbsInPath(const SkPathRef& path); |
| |
| /** |
| * Private, non-const-ptr version of the public function verbsMemBegin(). |
| */ |
| uint8_t* verbsBeginWritable() { return fVerbs.begin(); } |
| |
| /** |
| * Called the first time someone calls CreateEmpty to actually create the singleton. |
| */ |
| friend SkPathRef* sk_create_empty_pathref(); |
| |
| void setIsOval(bool isCCW, unsigned start, bool isClosed) { |
| fType = isClosed ? PathType::kOval : PathType::kOpenOval; |
| fRRectOrOvalIsCCW = isCCW; |
| fRRectOrOvalStartIdx = SkToU8(start); |
| } |
| |
| void setIsRRect(bool isCCW, unsigned start) { |
| fType = PathType::kRRect; |
| fRRectOrOvalIsCCW = isCCW; |
| fRRectOrOvalStartIdx = SkToU8(start); |
| } |
| |
| void setIsArc(const SkArc& arc) { |
| fType = PathType::kArc; |
| fArcOval = arc.fOval; |
| fArcStartAngle = arc.fStartAngle; |
| fArcSweepAngle = arc.fSweepAngle; |
| fArcType = arc.fType; |
| } |
| |
| // called only by the editor. Note that this is not a const function. |
| SkPoint* getWritablePoints() { |
| SkDEBUGCODE(this->validate();) |
| fType = PathType::kGeneral; |
| return fPoints.begin(); |
| } |
| |
| const SkPoint* getPoints() const { |
| SkDEBUGCODE(this->validate();) |
| return fPoints.begin(); |
| } |
| |
| void callGenIDChangeListeners(); |
| |
| mutable SkRect fBounds; |
| |
| enum { |
| kEmptyGenID = 1, // GenID reserved for path ref with zero points and zero verbs. |
| }; |
| mutable uint32_t fGenerationID; |
| SkIDChangeListener::List fGenIDChangeListeners; |
| |
| PointsArray fPoints; |
| VerbsArray fVerbs; |
| ConicWeightsArray fConicWeights; |
| |
| SkDEBUGCODE(std::atomic<int> fEditorsAttached;) // assert only one editor in use at any time. |
| |
| mutable uint8_t fBoundsIsDirty; |
| mutable bool fIsFinite; // only meaningful if bounds are valid |
| |
| PathType fType; |
| // Both the circle and rrect special cases have a notion of direction and starting point |
| // The next two variables store that information for either. |
| bool fRRectOrOvalIsCCW; |
| uint8_t fRRectOrOvalStartIdx; |
| uint8_t fSegmentMask; |
| // If the path is an arc, these four variables store that information. |
| // We should just store an SkArc, but alignment would cost us 8 more bytes. |
| SkArc::Type fArcType; |
| SkRect fArcOval; |
| SkScalar fArcStartAngle; |
| SkScalar fArcSweepAngle; |
| |
| friend class PathRefTest_Private; |
| friend class ForceIsRRect_Private; // unit test isRRect |
| friend class SkPath; |
| friend class SkPathBuilder; |
| friend class SkPathPriv; |
| }; |
| |
| #endif |