@shopify/react-native-skia 2.4.7 → 2.4.14

package/cpp/skia/include/core/SkPath.h

@@ -28,15 +28,33 @@
 #include <tuple>
 
 class SkData;
-class SkPathRef;
 class SkRRect;
 class SkWStream;
 enum class SkPathConvexity;
+enum class SkResolveConvexity;
 struct SkPathRaw;
 struct SkPathVerbAnalysis;
+struct SkPathOvalInfo;
+struct SkPathRRectInfo;
 
 // WIP -- define this locally, and fix call-sites to use SkPathBuilder (skbug.com/40040287)
+#ifndef SK_HIDE_PATH_EDIT_METHODS
 //#define SK_HIDE_PATH_EDIT_METHODS
+#endif
+
+// Migrate clients so this is unneeded
+#define SK_LEGACY_PATH_ACCESSORS
+
+#ifdef SK_HIDE_PATH_EDIT_METHODS
+    // enable this to try using SkPathData
+    #define SK_PATH_USES_PATHDATA
+#endif
+
+#ifdef SK_PATH_USES_PATHDATA
+class SkPathData;
+#else
+class SkPathRef;
+#endif
 
 /** \class SkPath
     SkPath contain geometry. SkPath may be empty, or contain one or more verbs that
@@ -82,8 +100,12 @@ public:
                       SkSpan<const SkScalar> conics,
                       SkPathFillType, bool isVolatile = false);
 
-    static SkPath Rect(const SkRect&, SkPathDirection = SkPathDirection::kDefault,
+    static SkPath Rect(const SkRect&, SkPathFillType, SkPathDirection = SkPathDirection::kDefault,
                        unsigned startIndex = 0);
+    static SkPath Rect(const SkRect& r, SkPathDirection direction = SkPathDirection::kDefault,
+                       unsigned startIndex = 0) {
+        return Rect(r, SkPathFillType::kDefault, direction, startIndex);
+    }
     static SkPath Oval(const SkRect&, SkPathDirection = SkPathDirection::kDefault);
     static SkPath Oval(const SkRect&, SkPathDirection, unsigned startIndex);
     static SkPath Circle(SkScalar center_x, SkScalar center_y, SkScalar radius,
@@ -97,8 +119,8 @@ public:
                           SkPathFillType fillType = SkPathFillType::kDefault,
                           bool isVolatile = false);
 
-    static SkPath Line(const SkPoint a, const SkPoint b) {
-        return Polygon({a, b}, false);
+    static SkPath Line(SkPoint a, SkPoint b) {
+        return Polygon({{a, b}}, false);
     }
 
     // Deprecated: use Raw()
@@ -111,14 +133,15 @@ public:
                    conics, fillType, isVolatile);
     }
 
-    /** Constructs an empty SkPath. By default, SkPath has no verbs, no SkPoint, and no weights.
-        FillType is set to kWinding.
+    /** Constructs an empty SkPath: no verbs, no points, no conic weights.
 
         @return  empty SkPath
 
         example: https://fiddle.skia.org/c/@Path_empty_constructor
     */
-    SkPath();
+    explicit SkPath(SkPathFillType);
+
+    SkPath() : SkPath(SkPathFillType::kDefault) {}
 
     /** Constructs a copy of an existing path.
         Copy constructor makes two paths identical by value. Internally, path and
@@ -183,6 +206,9 @@ public:
         return !(a == b);
     }
 
+// Note: These 3 interpolate() methods no long use any private access/info,
+//       and could trivially be implemented directly by the client.
+
     /** Returns true if SkPath contain equal verbs and equal weights.
         If SkPath contain one or more conics, the weights must match.
 
@@ -219,6 +245,29 @@ public:
     */
     SkPath makeInterpolate(const SkPath& ending, SkScalar weight) 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().
+
+        @param ending  SkPoint array averaged with this SkPoint array
+        @param weight  contribution of this SkPoint array, and
+                       one minus contribution of ending SkPoint array
+        @param out     SkPath replaced by interpolated averages
+        @return        true if SkPath contain same number of SkPoint
+
+        example: https://fiddle.skia.org/c/@Path_interpolate
+    */
+    bool interpolate(const SkPath& ending, SkScalar weight, SkPath* out) const;
+
     /** Returns SkPathFillType, the rule used to fill SkPath.
 
         @return  current SkPathFillType setting
@@ -387,48 +436,53 @@ public:
     */
     bool isLine(SkPoint line[2]) const;
 
-    /** Returns the number of points in SkPath.
-        SkPoint count is initially zero.
+    /*
+     *  Return a read-only view into the path's points.
+     */
+    SkSpan<const SkPoint> points() const;
 
-        @return  SkPath SkPoint array length
+    /*
+     *  Return a read-only view into the path's verbs.
+     */
+    SkSpan<const SkPathVerb> verbs() const;
+
+    /*
+     *  Return a read-only view into the path's conic-weights.
+     */
+    SkSpan<const float> conicWeights() const;
+
+    int countPoints() const { return SkToInt(this->points().size()); }
+    int countVerbs() const { return SkToInt(this->verbs().size()); }
 
-        example: https://fiddle.skia.org/c/@Path_countPoints
+    /** Return the last point, or {}
+
+        @return The last if the path contains one or more SkPoint, else returns {}
+
+        example: https://fiddle.skia.org/c/@Path_getLastPt
     */
-    int countPoints() const;
+    std::optional<SkPoint> getLastPt() const;
 
+#ifdef SK_LEGACY_PATH_ACCESSORS
     /** 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.
-
+        DEPRECATED
         @param index  SkPoint array element selector
         @return       SkPoint array value or (0, 0)
-
-        example: https://fiddle.skia.org/c/@Path_getPoint
     */
     SkPoint getPoint(int index) const;
 
     /** Returns number of points in SkPath.
         Copies N points from the path into the span, where N = min(#points, span capacity)
-
+        DEPRECATED
         @param points  span to receive the points. may be empty
         @return the number of points in the path
-
-        example: https://fiddle.skia.org/c/@Path_getPoints
     */
     size_t getPoints(SkSpan<SkPoint> points) const;
 
-    /** Returns the number of verbs: kMove_Verb, kLine_Verb, kQuad_Verb, kConic_Verb,
-        kCubic_Verb, and kClose_Verb; added to SkPath.
-
-        @return  length of verb array
-
-        example: https://fiddle.skia.org/c/@Path_countVerbs
-    */
-    int countVerbs() const;
-
     /** Returns number of points in SkPath.
         Copies N points from the path into the span, where N = min(#points, span capacity)
-
+        DEPRECATED
         @param verbs span to store the verbs. may be empty.
         @return the number of verbs in the path
 
@@ -436,6 +490,21 @@ public:
     */
     size_t getVerbs(SkSpan<uint8_t> verbs) const;
 
+    // DEPRECATED
+    bool getLastPt(SkPoint* lastPt) const {
+        if (auto lp = this->getLastPt()) {
+            if (lastPt) {
+                *lastPt = *lp;
+            }
+            return true;
+        }
+        if (lastPt) {
+            *lastPt = {0, 0};
+        }
+        return false;
+    }
+#endif
+
     /** Returns the approximate byte size of the SkPath in memory.
 
         @return  approximate size
@@ -571,66 +640,49 @@ public:
         kExtend_AddPathMode,
     };
 
-    /** Returns SkPath with SkPoint array offset by (dx, dy).
-
-        @param dx  offset added to SkPoint array x-axis coordinates
-        @param dy  offset added to SkPoint array y-axis coordinates
-    */
-    SkPath makeOffset(SkScalar dx, SkScalar dy) const {
-        SkPath dst;
-        this->offset(dx, dy, &dst);
-        return dst;
-    }
-
     /** Return a copy of SkPath with verb array, SkPoint array, and weight transformed
         by matrix. makeTransform may change verbs and increase their number.
 
+        If the resulting path has any non-finite values, returns {}.
+
         @param matrix  SkMatrix to apply to SkPath
-        @param pc      whether to apply perspective clipping
-        @return        SkPath
+        @return        SkPath if finite, or {}
     */
-    SkPath makeTransform(const SkMatrix& matrix) const {
-        SkPath dst;
-        this->transform(matrix, &dst);
-        return dst;
-    }
+    std::optional<SkPath> tryMakeTransform(const SkMatrix& matrix) const;
 
-    SkPath makeScale(SkScalar sx, SkScalar sy) const {
-        return this->makeTransform(SkMatrix::Scale(sx, sy));
+    std::optional<SkPath> tryMakeOffset(float dx, float dy) const {
+        return this->tryMakeTransform(SkMatrix::Translate(dx, dy));
     }
 
-#ifdef SK_SUPPORT_LEGACY_APPLYPERSPECTIVECLIP
-    void transform(const SkMatrix& matrix, SkPath* dst, SkApplyPerspectiveClip) const {
-        this->transform(matrix, dst);
-    }
-    void transform(const SkMatrix& matrix, SkApplyPerspectiveClip) {
-        this->transform(matrix);
-    }
-    SkPath makeTransform(const SkMatrix& m, SkApplyPerspectiveClip) const {
-        return this->makeTransform(m);
+    std::optional<SkPath> tryMakeScale(float sx, float sy) const {
+        return this->tryMakeTransform(SkMatrix::Scale(sx, sy));
     }
-#endif
 
-    /** Return the last point, or {}
+    /** Return a copy of SkPath with verb array, SkPoint array, and weight transformed
+        by matrix. makeTransform may change verbs and increase their number.
 
-        @return The last if the path contains one or more SkPoint, else returns {}
+        If the resulting path has any non-finite values, this will still return a path
+        but that path will return true for isFinite().
 
-        example: https://fiddle.skia.org/c/@Path_getLastPt
+        The newer pattern is to call tryMakeTransform(matrix) which will only return a
+        path if the result is finite.
+
+        @param matrix  SkMatrix to apply to SkPath
+        @return        SkPath
     */
-    std::optional<SkPoint> getLastPt() const;
+    SkPath makeTransform(const SkMatrix& matrix) const;
 
-    // DEPRECATED
-    bool getLastPt(SkPoint* lastPt) const {
-        if (auto lp = this->getLastPt()) {
-            if (lastPt) {
-                *lastPt = *lp;
-            }
-            return true;
-        }
-        if (lastPt) {
-            *lastPt = {0, 0};
-        }
-        return false;
+    /** Returns SkPath with SkPoint array offset by (dx, dy).
+
+        @param dx  offset added to SkPoint array x-axis coordinates
+        @param dy  offset added to SkPoint array y-axis coordinates
+    */
+    SkPath makeOffset(SkScalar dx, SkScalar dy) const {
+        return this->makeTransform(SkMatrix::Translate(dx, dy));
+    }
+
+    SkPath makeScale(SkScalar sx, SkScalar sy) const {
+        return this->makeTransform(SkMatrix::Scale(sx, sy));
     }
 
     /** \enum SkPath::SegmentMask
@@ -703,51 +755,18 @@ public:
     */
     void swap(SkPath& other);
 
-    /** 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().
-
-        @param ending  SkPoint array averaged with this SkPoint array
-        @param weight  contribution of this SkPoint array, and
-                       one minus contribution of ending SkPoint array
-        @param out     SkPath replaced by interpolated averages
-        @return        true if SkPath contain same number of SkPoint
-
-        example: https://fiddle.skia.org/c/@Path_interpolate
-    */
-    bool interpolate(const SkPath& ending, SkScalar weight, SkPath* out) const;
-
     /** Sets SkPathFillType, the rule used to fill SkPath. While there is no
         check that ft is legal, values outside of SkPathFillType are not supported.
     */
     void setFillType(SkPathFillType ft) {
-        fFillType = SkToU8(ft);
+        fFillType = ft;
     }
 
     /** Replaces SkPathFillType with its inverse. The inverse of SkPathFillType describes the area
         unmodified by the original SkPathFillType.
     */
     void toggleInverseFillType() {
-        fFillType ^= 2;
-    }
-
-#ifdef SK_HIDE_PATH_EDIT_METHODS
-private:
-#endif
-    /** Returns a copy of this path in the current state, and resets the path to empty. */
-    SkPath detach() {
-        SkPath result = *this;
-        this->reset();
-        return result;
+        fFillType = SkPathFillType_ToggleInverse(fFillType);
     }
 
     /** Sets SkPath to its initial state.
@@ -760,6 +779,14 @@ private:
     */
     SkPath& reset();
 
+#ifndef SK_HIDE_PATH_EDIT_METHODS
+    /** Returns a copy of this path in the current state, and resets the path to empty. */
+    SkPath detach() {
+        SkPath result = *this;
+        this->reset();
+        return result;
+    }
+
     /** 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.
@@ -1113,7 +1140,7 @@ private:
         @param radius  distance from arc to circle center
         @return        reference to SkPath
     */
-    SkPath& arcTo(const SkPoint p1, const SkPoint p2, SkScalar radius) {
+    SkPath& arcTo(SkPoint p1, SkPoint p2, SkScalar radius) {
         return this->arcTo(p1.fX, p1.fY, p2.fX, p2.fY, radius);
     }
 
@@ -1167,8 +1194,11 @@ private:
         @param xy           end of arc
         @return             reference to SkPath
     */
-    SkPath& arcTo(const SkPoint r, SkScalar xAxisRotate, ArcSize largeArc, SkPathDirection sweep,
-               const SkPoint xy) {
+    SkPath& arcTo(SkPoint r,
+                  SkScalar xAxisRotate,
+                  ArcSize largeArc,
+                  SkPathDirection sweep,
+                  const SkPoint xy) {
         return this->arcTo(r.fX, r.fY, xAxisRotate, largeArc, sweep, xy.fX, xy.fY);
     }
 
@@ -1445,6 +1475,31 @@ private:
     */
     SkPath& reverseAddPath(const SkPath& src);
 
+    /** Sets last point to (x, y). If SkPoint array is empty, append kMove_Verb to
+        verb array and append (x, y) to SkPoint array.
+
+        @param x  set x-axis value of last point
+        @param y  set y-axis value of last point
+
+        example: https://fiddle.skia.org/c/@Path_setLastPt
+    */
+    void setLastPt(SkScalar x, SkScalar y);
+
+    /** Sets the last point on the path. If SkPoint array is empty, append kMove_Verb to
+        verb array and append p to SkPoint array.
+
+        @param p  set value of last point
+    */
+    void setLastPt(const SkPoint& p) {
+        this->setLastPt(p.fX, p.fY);
+    }
+#endif
+
+#ifdef SK_HIDE_PATH_EDIT_METHODS
+private:
+#endif
+
+#ifndef SK_PATH_USES_PATHDATA
     /** Offsets SkPoint array by (dx, dy). Offset SkPath replaces dst.
         If dst is nullptr, SkPath is replaced by offset data.
 
@@ -1490,29 +1545,12 @@ private:
         this->transform(matrix, this);
         return *this;
     }
-
-    /** Sets last point to (x, y). If SkPoint array is empty, append kMove_Verb to
-        verb array and append (x, y) to SkPoint array.
-
-        @param x  set x-axis value of last point
-        @param y  set y-axis value of last point
-
-        example: https://fiddle.skia.org/c/@Path_setLastPt
-    */
-    void setLastPt(SkScalar x, SkScalar y);
-
-    /** Sets the last point on the path. If SkPoint array is empty, append kMove_Verb to
-        verb array and append p to SkPoint array.
-
-        @param p  set value of last point
-    */
-    void setLastPt(const SkPoint& p) {
-        this->setLastPt(p.fX, p.fY);
-    }
+#endif
 
 #ifdef SK_HIDE_PATH_EDIT_METHODS
 public:
 #endif
+
 #ifdef SK_SUPPORT_UNSPANNED_APIS
     static SkPath Make(const SkPoint points[], int pointCount,
                        const uint8_t verbs[], int verbCount,
@@ -1534,6 +1572,7 @@ public:
     int getVerbs(uint8_t verbs[], int max) const {
         return (int)this->getVerbs({verbs, max});
     }
+#ifndef SK_HIDE_PATH_EDIT_METHODS
     SkPath& addRoundRect(const SkRect& rect, const SkScalar radii[],
                          SkPathDirection dir = SkPathDirection::kCW) {
         return this->addRoundRect(rect, {radii, radii ? 8 : 0}, dir);
@@ -1541,7 +1580,8 @@ public:
     SkPath& addPoly(const SkPoint pts[], int count, bool close) {
         return this->addPoly({pts, count}, close);
     }
-#endif
+#endif  // SK_HIDE_PATH_EDIT_METHODS
+#endif  // SK_SUPPORT_UNSPANNED_APIS
 
     SkPathIter iter() const;
 
@@ -1657,6 +1697,10 @@ public:
     };
 
 private:
+    std::optional<SkPathOvalInfo> getOvalInfo() const;
+    std::optional<SkPathRRectInfo> getRRectInfo() const;
+    std::optional<SkPathRaw> raw(SkResolveConvexity) const;
+
     /** \class SkPath::RangeIter
         Iterates through a raw range of path verbs, points, and conics. All values are returned
         unaltered.
@@ -1798,16 +1842,18 @@ public:
 
     };
 
-    /** Returns true if the point (x, y) is contained by SkPath, taking into
+    /** Returns true if the point is contained by SkPath, taking into
         account FillType.
 
-        @param x  x-axis value of containment test
-        @param y  y-axis value of containment test
-        @return   true if SkPoint is in SkPath
-
-        example: https://fiddle.skia.org/c/@Path_contains
+        @param point the point to test
+        @return true if SkPoint is in SkPath
     */
-    bool contains(SkScalar x, SkScalar y) const;
+    bool contains(SkPoint point) const;
+
+    // deprecated
+    bool contains(SkScalar x, SkScalar y) const {
+        return this->contains({x, y});
+    }
 
     /** Writes text representation of SkPath to stream. If stream is nullptr, writes to
         standard output. Set dumpAsHex true to generate exact binary representations
@@ -1823,10 +1869,6 @@ public:
     void dump() const { this->dump(nullptr, false); }
     void dumpHex() const { this->dump(nullptr, true); }
 
-    // Like dump(), but outputs for the SkPath::Make() factory
-    void dumpArrays(SkWStream* stream, bool dumpAsHex) const;
-    void dumpArrays() const { this->dumpArrays(nullptr, false); }
-
     /** Writes SkPath to buffer, returning the number of bytes written.
         Pass nullptr to obtain the storage size.
 
@@ -1906,13 +1948,23 @@ public:
     using sk_is_trivially_relocatable = std::true_type;
 
 private:
+#ifdef SK_PATH_USES_PATHDATA
+    static SkPath MakeNullCheck(sk_sp<SkPathData>, SkPathFillType, bool isVolatile);
+    static SkPathData* PeekErrorSingleton();
+
+    SkPath(sk_sp<SkPathData>, SkPathFillType, bool isVolatile);
+
+    sk_sp<SkPathData> fPathData;
+    SkPathFillType    fFillType;
+    bool              fIsVolatile;
+#else
     SkPath(sk_sp<SkPathRef>, SkPathFillType, bool isVolatile, SkPathConvexity);
 
-    sk_sp<SkPathRef>               fPathRef;
-    int                            fLastMoveToIndex;
-    mutable std::atomic<uint8_t>   fConvexity;      // SkPathConvexity
-    uint8_t                        fFillType    : 2;
-    uint8_t                        fIsVolatile  : 1;
+    sk_sp<SkPathRef>             fPathRef;
+    int                          fLastMoveToIndex;
+    mutable std::atomic<uint8_t> fConvexity;      // SkPathConvexity
+    SkPathFillType               fFillType;
+    bool                         fIsVolatile;
 
     static_assert(::sk_is_trivially_relocatable<decltype(fPathRef)>::value);
 
@@ -1927,6 +1979,16 @@ private:
      */
     void copyFields(const SkPath& that);
 
+    // Creates a new Path after the supplied arguments have been validated by
+    // SkPathPriv::AnalyzeVerbs().
+    static SkPath MakeInternal(const SkPathVerbAnalysis&,
+                               const SkPoint[],
+                               SkSpan<const SkPathVerb>,
+                               const float conics[],
+                               SkPathFillType,
+                               bool isVolatile);
+#endif
+
     size_t writeToMemoryAsRRect(void* buffer) const;
     size_t readAsRRect(const void*, size_t);
 
@@ -1946,9 +2008,11 @@ private:
     //  SkPath path; path.lineTo(...);   <--- need a leading moveTo(0, 0)
     // SkPath path; ... path.close(); path.lineTo(...) <-- need a moveTo(previous moveTo)
     //
-    inline void injectMoveToIfNeeded();
+    void injectMoveToIfNeeded();
 
-    inline bool hasOnlyMoveTos() const;
+    bool hasOnlyMoveTos() const {
+        return this->getSegmentMasks() == 0;
+    }
 
     SkPathConvexity computeConvexity() const;
 
@@ -1976,10 +2040,6 @@ private:
 
     SkPath& dirtyAfterEdit();
 
-    // Bottlenecks for working with fConvexity and fFirstDirection.
-    // Notice the setters are const... these are mutable atomic fields.
-    void setConvexity(SkPathConvexity) const;
-
     void addRaw(const SkPathRaw&);
 
     /** Returns the comvexity type, computing if needed. Never returns kUnknown.
@@ -1989,44 +2049,15 @@ private:
 
     SkPathConvexity getConvexityOrUnknown() const;
 
-    // Compares the cached value with a freshly computed one (computeConvexity())
-    bool isConvexityAccurate() const;
-
     /** Stores a convexity type for this path. This is what will be returned if
      *  getConvexityOrUnknown() is called. If you pass kUnknown, then if getContexityType()
      *  is called, the real convexity will be computed.
-     *
-     *  example: https://fiddle.skia.org/c/@Path_setConvexity
-     */
-    void setConvexity(SkPathConvexity convexity);
-
-    /** Shrinks SkPath verb array and SkPoint array storage to discard unused capacity.
-     *  May reduce the heap overhead for SkPath known to be fully constructed.
-     *
-     *  NOTE: This may relocate the underlying buffers, and thus any Iterators referencing
-     *        this path should be discarded after calling shrinkToFit().
      */
-    void shrinkToFit();
-
-    // Creates a new Path after the supplied arguments have been validated by
-    // SkPathPriv::AnalyzeVerbs().
-    static SkPath MakeInternal(const SkPathVerbAnalysis& analsis,
-                               const SkPoint points[],
-                               SkSpan<const SkPathVerb> verbs,
-                               const SkScalar conics[],
-                               SkPathFillType fillType,
-                               bool isVolatile);
+    void setConvexity(SkPathConvexity) const;
 
-    friend class SkAutoAddSimpleShape;
-    friend class SkAutoDisableOvalCheck;
+    friend class SkAutoAddSimpleShape;  // setConvexity
     friend class SkPathBuilder;
-    friend class SkPathEdgeIter;
-    friend class SkPathWriter;
-    friend class SkOpBuilder;
-    friend class SkBench_AddPathTest; // perf test reversePathTo
     friend class PathTest_Private; // unit test reversePathTo
-    friend class ForceIsRRect_Private; // unit test isRRect
-    friend class FuzzPath; // for legacy access to validateRef
 };
 
 #endif