@shopify/react-native-skia 0.1.115

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

@@ -0,0 +1,268 @@
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkPathBuilder_DEFINED
+#define SkPathBuilder_DEFINED
+
+#include "include/core/SkMatrix.h"
+#include "include/core/SkPath.h"
+#include "include/core/SkPathTypes.h"
+#include "include/private/SkTDArray.h"
+
+class SK_API SkPathBuilder {
+public:
+    SkPathBuilder();
+    SkPathBuilder(SkPathFillType);
+    SkPathBuilder(const SkPath&);
+    SkPathBuilder(const SkPathBuilder&) = default;
+    ~SkPathBuilder();
+
+    SkPathBuilder& operator=(const SkPath&);
+    SkPathBuilder& operator=(const SkPathBuilder&) = default;
+
+    SkPathFillType fillType() const { return fFillType; }
+    SkRect computeBounds() const;
+
+    SkPath snapshot() const;  // the builder is unchanged after returning this path
+    SkPath detach();    // the builder is reset to empty after returning this path
+
+    SkPathBuilder& setFillType(SkPathFillType ft) { fFillType = ft; return *this; }
+    SkPathBuilder& setIsVolatile(bool isVolatile) { fIsVolatile = isVolatile; return *this; }
+
+    SkPathBuilder& reset();
+
+    SkPathBuilder& moveTo(SkPoint pt);
+    SkPathBuilder& moveTo(SkScalar x, SkScalar y) { return this->moveTo(SkPoint::Make(x, y)); }
+
+    SkPathBuilder& lineTo(SkPoint pt);
+    SkPathBuilder& lineTo(SkScalar x, SkScalar y) { return this->lineTo(SkPoint::Make(x, y)); }
+
+    SkPathBuilder& quadTo(SkPoint pt1, SkPoint pt2);
+    SkPathBuilder& quadTo(SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2) {
+        return this->quadTo(SkPoint::Make(x1, y1), SkPoint::Make(x2, y2));
+    }
+    SkPathBuilder& quadTo(const SkPoint pts[2]) { return this->quadTo(pts[0], pts[1]); }
+
+    SkPathBuilder& conicTo(SkPoint pt1, SkPoint pt2, SkScalar w);
+    SkPathBuilder& conicTo(SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2, SkScalar w) {
+        return this->conicTo(SkPoint::Make(x1, y1), SkPoint::Make(x2, y2), w);
+    }
+    SkPathBuilder& conicTo(const SkPoint pts[2], SkScalar w) {
+        return this->conicTo(pts[0], pts[1], w);
+    }
+
+    SkPathBuilder& cubicTo(SkPoint pt1, SkPoint pt2, SkPoint pt3);
+    SkPathBuilder& cubicTo(SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2, SkScalar x3, SkScalar y3) {
+        return this->cubicTo(SkPoint::Make(x1, y1), SkPoint::Make(x2, y2), SkPoint::Make(x3, y3));
+    }
+    SkPathBuilder& cubicTo(const SkPoint pts[3]) {
+        return this->cubicTo(pts[0], pts[1], pts[2]);
+    }
+
+    SkPathBuilder& close();
+
+    // Append a series of lineTo(...)
+    SkPathBuilder& polylineTo(const SkPoint pts[], int count);
+    SkPathBuilder& polylineTo(const std::initializer_list<SkPoint>& list) {
+        return this->polylineTo(list.begin(), SkToInt(list.size()));
+    }
+
+    // Relative versions of segments, relative to the previous position.
+
+    SkPathBuilder& rLineTo(SkPoint pt);
+    SkPathBuilder& rLineTo(SkScalar x, SkScalar y) { return this->rLineTo({x, y}); }
+    SkPathBuilder& rQuadTo(SkPoint pt1, SkPoint pt2);
+    SkPathBuilder& rQuadTo(SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2) {
+        return this->rQuadTo({x1, y1}, {x2, y2});
+    }
+    SkPathBuilder& rConicTo(SkPoint p1, SkPoint p2, SkScalar w);
+    SkPathBuilder& rConicTo(SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2, SkScalar w) {
+        return this->rConicTo({x1, y1}, {x2, y2}, w);
+    }
+    SkPathBuilder& rCubicTo(SkPoint pt1, SkPoint pt2, SkPoint pt3);
+    SkPathBuilder& rCubicTo(SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2, SkScalar x3, SkScalar y3) {
+        return this->rCubicTo({x1, y1}, {x2, y2}, {x3, y3});
+    }
+
+    // Arcs
+
+    /** Appends arc to the builder. Arc added is part of ellipse
+        bounded by oval, from startAngle through sweepAngle. Both startAngle and
+        sweepAngle are measured in degrees, where zero degrees is aligned with the
+        positive x-axis, and positive sweeps extends arc clockwise.
+
+        arcTo() adds line connecting the builder's last point to initial arc point if forceMoveTo
+        is false and the builder is not empty. Otherwise, added contour begins with first point
+        of arc. Angles greater than -360 and less than 360 are treated modulo 360.
+
+        @param oval          bounds of ellipse containing arc
+        @param startAngleDeg starting angle of arc in degrees
+        @param sweepAngleDeg sweep, in degrees. Positive is clockwise; treated modulo 360
+        @param forceMoveTo   true to start a new contour with arc
+        @return              reference to the builder
+    */
+    SkPathBuilder& arcTo(const SkRect& oval, SkScalar startAngleDeg, SkScalar sweepAngleDeg,
+                         bool forceMoveTo);
+
+    /** 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.
+
+        @param p1      SkPoint common to pair of tangents
+        @param p2      end of second tangent
+        @param radius  distance from arc to circle center
+        @return        reference to SkPath
+    */
+    SkPathBuilder& arcTo(SkPoint p1, SkPoint p2, SkScalar radius);
+
+    enum ArcSize {
+        kSmall_ArcSize, //!< smaller of arc pair
+        kLarge_ArcSize, //!< larger of arc pair
+    };
+
+    /** 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.
+
+        @param r            radii on axes before x-axis rotation
+        @param xAxisRotate  x-axis rotation in degrees; positive values are clockwise
+        @param largeArc     chooses smaller or larger arc
+        @param sweep        chooses clockwise or counterclockwise arc
+        @param xy           end of arc
+        @return             reference to SkPath
+    */
+    SkPathBuilder& arcTo(SkPoint r, SkScalar xAxisRotate, ArcSize largeArc, SkPathDirection sweep,
+                         SkPoint xy);
+
+    /** Appends arc to the builder, as the start of new contour. Arc added is part of ellipse
+        bounded by oval, from startAngle through sweepAngle. Both startAngle and
+        sweepAngle are measured in degrees, where zero degrees is aligned with the
+        positive x-axis, and positive sweeps extends arc clockwise.
+
+        If sweepAngle <= -360, or sweepAngle >= 360; and startAngle modulo 90 is nearly
+        zero, append oval instead of arc. Otherwise, sweepAngle values are treated
+        modulo 360, and arc may or may not draw depending on numeric rounding.
+
+        @param oval          bounds of ellipse containing arc
+        @param startAngleDeg starting angle of arc in degrees
+        @param sweepAngleDeg sweep, in degrees. Positive is clockwise; treated modulo 360
+        @return              reference to this builder
+    */
+    SkPathBuilder& addArc(const SkRect& oval, SkScalar startAngleDeg, SkScalar sweepAngleDeg);
+
+    // Add a new contour
+
+    SkPathBuilder& addRect(const SkRect&, SkPathDirection, unsigned startIndex);
+    SkPathBuilder& addOval(const SkRect&, SkPathDirection, unsigned startIndex);
+    SkPathBuilder& addRRect(const SkRRect&, SkPathDirection, unsigned startIndex);
+
+    SkPathBuilder& addRect(const SkRect& rect, SkPathDirection dir = SkPathDirection::kCW) {
+        return this->addRect(rect, dir, 0);
+    }
+    SkPathBuilder& addOval(const SkRect& rect, SkPathDirection dir = SkPathDirection::kCW) {
+        // legacy start index: 1
+        return this->addOval(rect, dir, 1);
+    }
+    SkPathBuilder& addRRect(const SkRRect& rrect, SkPathDirection dir = SkPathDirection::kCW) {
+        // legacy start indices: 6 (CW) and 7 (CCW)
+        return this->addRRect(rrect, dir, dir == SkPathDirection::kCW ? 6 : 7);
+    }
+
+    SkPathBuilder& addCircle(SkScalar center_x, SkScalar center_y, SkScalar radius,
+                             SkPathDirection dir = SkPathDirection::kCW);
+
+    SkPathBuilder& addPolygon(const SkPoint pts[], int count, bool isClosed);
+    SkPathBuilder& addPolygon(const std::initializer_list<SkPoint>& list, bool isClosed) {
+        return this->addPolygon(list.begin(), SkToInt(list.size()), isClosed);
+    }
+
+    SkPathBuilder& addPath(const SkPath&);
+
+    // Performance hint, to reserve extra storage for subsequent calls to lineTo, quadTo, etc.
+
+    void incReserve(int extraPtCount, int extraVerbCount);
+    void incReserve(int extraPtCount) {
+        this->incReserve(extraPtCount, extraPtCount);
+    }
+
+    SkPathBuilder& offset(SkScalar dx, SkScalar dy);
+
+    SkPathBuilder& toggleInverseFillType() {
+        fFillType = (SkPathFillType)((unsigned)fFillType ^ 2);
+        return *this;
+    }
+
+private:
+    SkTDArray<SkPoint>  fPts;
+    SkTDArray<uint8_t>  fVerbs;
+    SkTDArray<SkScalar> fConicWeights;
+
+    SkPathFillType      fFillType;
+    bool                fIsVolatile;
+
+    unsigned    fSegmentMask;
+    SkPoint     fLastMovePoint;
+    int         fLastMoveIndex; // only needed until SkPath is immutable
+    bool        fNeedsMoveVerb;
+
+    enum IsA {
+        kIsA_JustMoves,     // we only have 0 or more moves
+        kIsA_MoreThanMoves, // we have verbs other than just move
+        kIsA_Oval,          // we are 0 or more moves followed by an oval
+        kIsA_RRect,         // we are 0 or more moves followed by a rrect
+    };
+    IsA fIsA      = kIsA_JustMoves;
+    int fIsAStart = -1;     // tracks direction iff fIsA is not unknown
+    bool fIsACCW  = false;  // tracks direction iff fIsA is not unknown
+
+    // for testing
+    SkPathConvexity fOverrideConvexity = SkPathConvexity::kUnknown;
+
+    int countVerbs() const { return fVerbs.count(); }
+
+    // called right before we add a (non-move) verb
+    void ensureMove() {
+        fIsA = kIsA_MoreThanMoves;
+        if (fNeedsMoveVerb) {
+            this->moveTo(fLastMovePoint);
+        }
+    }
+
+    SkPath make(sk_sp<SkPathRef>) const;
+
+    SkPathBuilder& privateReverseAddPath(const SkPath&);
+
+    // For testing
+    void privateSetConvexity(SkPathConvexity c) { fOverrideConvexity = c; }
+
+    friend class SkPathPriv;
+};
+
+#endif
+

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

@@ -0,0 +1,106 @@
+/*
+ * Copyright 2006 The Android Open Source Project
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkPathEffect_DEFINED
+#define SkPathEffect_DEFINED
+
+#include "include/core/SkFlattenable.h"
+#include "include/core/SkScalar.h"
+// not needed, but some of our clients need it (they don't IWYU)
+#include "include/core/SkPath.h"
+
+class SkPath;
+struct SkRect;
+class SkStrokeRec;
+
+/** \class SkPathEffect
+
+    SkPathEffect is the base class for objects in the SkPaint that affect
+    the geometry of a drawing primitive before it is transformed by the
+    canvas' matrix and drawn.
+
+    Dashing is implemented as a subclass of SkPathEffect.
+*/
+class SK_API SkPathEffect : public SkFlattenable {
+public:
+    /**
+     *  Returns a patheffect that apples each effect (first and second) to the original path,
+     *  and returns a path with the sum of these.
+     *
+     *  result = first(path) + second(path)
+     *
+     */
+    static sk_sp<SkPathEffect> MakeSum(sk_sp<SkPathEffect> first, sk_sp<SkPathEffect> second);
+
+    /**
+     *  Returns a patheffect that applies the inner effect to the path, and then applies the
+     *  outer effect to the result of the inner's.
+     *
+     *  result = outer(inner(path))
+     */
+    static sk_sp<SkPathEffect> MakeCompose(sk_sp<SkPathEffect> outer, sk_sp<SkPathEffect> inner);
+
+    static SkFlattenable::Type GetFlattenableType() {
+        return kSkPathEffect_Type;
+    }
+
+    // move to base?
+
+    enum DashType {
+        kNone_DashType, //!< ignores the info parameter
+        kDash_DashType, //!< fills in all of the info parameter
+    };
+
+    struct DashInfo {
+        DashInfo() : fIntervals(nullptr), fCount(0), fPhase(0) {}
+        DashInfo(SkScalar* intervals, int32_t count, SkScalar phase)
+            : fIntervals(intervals), fCount(count), fPhase(phase) {}
+
+        SkScalar*   fIntervals;         //!< Length of on/off intervals for dashed lines
+                                        //   Even values represent ons, and odds offs
+        int32_t     fCount;             //!< Number of intervals in the dash. Should be even number
+        SkScalar    fPhase;             //!< Offset into the dashed interval pattern
+                                        //   mod the sum of all intervals
+    };
+
+    DashType asADash(DashInfo* info) const;
+
+    /**
+     *  Given a src path (input) and a stroke-rec (input and output), apply
+     *  this effect to the src path, returning the new path in dst, and return
+     *  true. If this effect cannot be applied, return false and ignore dst
+     *  and stroke-rec.
+     *
+     *  The stroke-rec specifies the initial request for stroking (if any).
+     *  The effect can treat this as input only, or it can choose to change
+     *  the rec as well. For example, the effect can decide to change the
+     *  stroke's width or join, or the effect can change the rec from stroke
+     *  to fill (or fill to stroke) in addition to returning a new (dst) path.
+     *
+     *  If this method returns true, the caller will apply (as needed) the
+     *  resulting stroke-rec to dst and then draw.
+     */
+    bool filterPath(SkPath* dst, const SkPath& src, SkStrokeRec*, const SkRect* cullR) const;
+
+    /** Version of filterPath that can be called when the CTM is known. */
+    bool filterPath(SkPath* dst, const SkPath& src, SkStrokeRec*, const SkRect* cullR,
+                    const SkMatrix& ctm) const;
+
+    /** True if this path effect requires a valid CTM */
+    bool needsCTM() const;
+
+    static sk_sp<SkPathEffect> Deserialize(const void* data, size_t size,
+                                           const SkDeserialProcs* procs = nullptr);
+
+private:
+    SkPathEffect() = default;
+    friend class SkPathEffectBase;
+
+    using INHERITED = SkFlattenable;
+};
+
+#endif

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

@@ -0,0 +1,88 @@
+/*
+ * Copyright 2006 The Android Open Source Project
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkPathMeasure_DEFINED
+#define SkPathMeasure_DEFINED
+
+#include "include/core/SkContourMeasure.h"
+#include "include/core/SkPath.h"
+#include "include/private/SkTDArray.h"
+
+class SK_API SkPathMeasure {
+public:
+    SkPathMeasure();
+    /** Initialize the pathmeasure with the specified path. The parts of the path that are needed
+     *  are copied, so the client is free to modify/delete the path after this call.
+     *
+     *  resScale controls the precision of the measure. values > 1 increase the
+     *  precision (and possibly slow down the computation).
+     */
+    SkPathMeasure(const SkPath& path, bool forceClosed, SkScalar resScale = 1);
+    ~SkPathMeasure();
+
+    /** Reset the pathmeasure with the specified path. The parts of the path that are needed
+     *  are copied, so the client is free to modify/delete the path after this call..
+     */
+    void setPath(const SkPath*, bool forceClosed);
+
+    /** Return the total length of the current contour, or 0 if no path
+        is associated (e.g. resetPath(null))
+    */
+    SkScalar getLength();
+
+    /** Pins distance to 0 <= distance <= getLength(), and then computes
+        the corresponding position and tangent.
+        Returns false if there is no path, or a zero-length path was specified, in which case
+        position and tangent are unchanged.
+    */
+    bool SK_WARN_UNUSED_RESULT getPosTan(SkScalar distance, SkPoint* position,
+                                         SkVector* tangent);
+
+    enum MatrixFlags {
+        kGetPosition_MatrixFlag     = 0x01,
+        kGetTangent_MatrixFlag      = 0x02,
+        kGetPosAndTan_MatrixFlag    = kGetPosition_MatrixFlag | kGetTangent_MatrixFlag
+    };
+
+    /** Pins distance to 0 <= distance <= getLength(), and then computes
+        the corresponding matrix (by calling getPosTan).
+        Returns false if there is no path, or a zero-length path was specified, in which case
+        matrix is unchanged.
+    */
+    bool SK_WARN_UNUSED_RESULT getMatrix(SkScalar distance, SkMatrix* matrix,
+                                  MatrixFlags flags = kGetPosAndTan_MatrixFlag);
+
+    /** Given a start and stop distance, return in dst the intervening segment(s).
+        If the segment is zero-length, return false, else return true.
+        startD and stopD are pinned to legal values (0..getLength()). If startD > stopD
+        then return false (and leave dst untouched).
+        Begin the segment with a moveTo if startWithMoveTo is true
+    */
+    bool getSegment(SkScalar startD, SkScalar stopD, SkPath* dst, bool startWithMoveTo);
+
+    /** Return true if the current contour is closed()
+    */
+    bool isClosed();
+
+    /** Move to the next contour in the path. Return true if one exists, or false if
+        we're done with the path.
+    */
+    bool nextContour();
+
+#ifdef SK_DEBUG
+    void    dump();
+#endif
+
+private:
+    SkContourMeasureIter    fIter;
+    sk_sp<SkContourMeasure> fContour;
+
+    SkPathMeasure(const SkPathMeasure&) = delete;
+    SkPathMeasure& operator=(const SkPathMeasure&) = delete;
+};
+
+#endif

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

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2019 Google LLC.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkPathTypes_DEFINED
+#define SkPathTypes_DEFINED
+
+#include "include/core/SkTypes.h"
+
+enum class SkPathFillType {
+    /** Specifies that "inside" is computed by a non-zero sum of signed edge crossings */
+    kWinding,
+    /** Specifies that "inside" is computed by an odd number of edge crossings */
+    kEvenOdd,
+    /** Same as Winding, but draws outside of the path, rather than inside */
+    kInverseWinding,
+    /** Same as EvenOdd, but draws outside of the path, rather than inside */
+    kInverseEvenOdd
+};
+
+static inline bool SkPathFillType_IsEvenOdd(SkPathFillType ft) {
+    return (static_cast<int>(ft) & 1) != 0;
+}
+
+static inline bool SkPathFillType_IsInverse(SkPathFillType ft) {
+    return (static_cast<int>(ft) & 2) != 0;
+}
+
+static inline SkPathFillType SkPathFillType_ConvertToNonInverse(SkPathFillType ft) {
+    return static_cast<SkPathFillType>(static_cast<int>(ft) & 1);
+}
+
+enum class SkPathDirection {
+    /** clockwise direction for adding closed contours */
+    kCW,
+    /** counter-clockwise direction for adding closed contours */
+    kCCW,
+};
+
+enum SkPathSegmentMask {
+    kLine_SkPathSegmentMask   = 1 << 0,
+    kQuad_SkPathSegmentMask   = 1 << 1,
+    kConic_SkPathSegmentMask  = 1 << 2,
+    kCubic_SkPathSegmentMask  = 1 << 3,
+};
+
+enum class SkPathVerb {
+    kMove,   //!< SkPath::RawIter returns 1 point
+    kLine,   //!< SkPath::RawIter returns 2 points
+    kQuad,   //!< SkPath::RawIter returns 3 points
+    kConic,  //!< SkPath::RawIter returns 3 points + 1 weight
+    kCubic,  //!< SkPath::RawIter returns 4 points
+    kClose   //!< SkPath::RawIter returns 0 points
+};
+
+#endif