@shopify/react-native-skia 2.0.6 → 2.1.0

package/cpp/skia/modules/skottie/src/text/TextValue.h

@@ -0,0 +1,28 @@
+/*
+ * Copyright 2019 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkottieTextValue_DEFINED
+#define SkottieTextValue_DEFINED
+
+#include "modules/skottie/include/SkottieProperty.h"
+
+namespace skjson { class Value; }
+
+namespace skottie {
+typedef TextPropertyValue TextValue;
+
+namespace internal {
+
+class AnimationBuilder;
+
+// Unlike other types, TextValue parsing requires access to an AnimationBuilder.
+bool Parse(const skjson::Value&, const AnimationBuilder&, TextValue*);
+
+} // namespace internal
+} // namespace skottie
+
+#endif // SkottieTextValue_DEFINED

package/cpp/skia/modules/sksg/include/SkSGClipEffect.h

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2018 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkSGClipEffect_DEFINED
+#define SkSGClipEffect_DEFINED
+
+#include "include/core/SkRect.h"
+#include "include/core/SkRefCnt.h"
+#include "modules/sksg/include/SkSGEffectNode.h"
+#include "modules/sksg/include/SkSGGeometryNode.h"
+#include "modules/sksg/include/SkSGRenderNode.h"
+
+#include <utility>
+
+class SkCanvas;
+class SkMatrix;
+struct SkPoint;
+
+namespace sksg {
+class InvalidationController;
+
+/**
+ * Concrete Effect node, applying a clip to its descendants.
+ *
+ */
+class ClipEffect final : public EffectNode {
+public:
+    static sk_sp<ClipEffect> Make(sk_sp<RenderNode> child, sk_sp<GeometryNode> clip,
+                                  bool aa = false, bool force_clip = false) {
+        return (child && clip)
+            ? sk_sp<ClipEffect>(new ClipEffect(std::move(child), std::move(clip), aa, force_clip))
+            : nullptr;
+    }
+
+    ~ClipEffect() override;
+
+protected:
+    ClipEffect(sk_sp<RenderNode>, sk_sp<GeometryNode>, bool aa, bool force_clip);
+
+    void onRender(SkCanvas*, const RenderContext*) const override;
+    const RenderNode* onNodeAt(const SkPoint&)     const override;
+
+    SkRect onRevalidate(InvalidationController*, const SkMatrix&) override;
+
+private:
+    const sk_sp<GeometryNode> fClipNode;
+    const bool                fAntiAlias,
+                              fForceClip;
+
+    bool                      fNoop = false;
+
+    using INHERITED = EffectNode;
+};
+
+}  // namespace sksg
+
+#endif // SkSGClipEffect_DEFINED

package/cpp/skia/modules/sksg/include/SkSGColorFilter.h

@@ -0,0 +1,135 @@
+/*
+ * Copyright 2018 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkSGColorFilter_DEFINED
+#define SkSGColorFilter_DEFINED
+
+#include "include/core/SkColorFilter.h"
+#include "include/core/SkRect.h"
+#include "include/core/SkRefCnt.h"
+#include "modules/sksg/include/SkSGEffectNode.h"
+#include "modules/sksg/include/SkSGNode.h"
+
+#include <vector>
+
+class SkCanvas;
+class SkMatrix;
+enum class SkBlendMode;
+struct SkPoint;
+
+namespace sksg {
+
+class Color;
+class InvalidationController;
+class RenderNode;
+
+/**
+ * Base class for nodes which apply a color filter when rendering their descendants.
+ */
+class ColorFilter : public EffectNode {
+protected:
+    explicit ColorFilter(sk_sp<RenderNode>);
+
+    void onRender(SkCanvas*, const RenderContext*) const final;
+    const RenderNode* onNodeAt(const SkPoint&)     const final;
+
+    SkRect onRevalidate(InvalidationController*, const SkMatrix&) final;
+
+    virtual sk_sp<SkColorFilter> onRevalidateFilter() = 0;
+
+private:
+    sk_sp<SkColorFilter> fColorFilter;
+
+    using INHERITED = EffectNode;
+};
+
+/**
+ * Wrapper for externally-managed SkColorFilters.
+ *
+ * Allows attaching non-sksg color filters to the render tree.
+ */
+class ExternalColorFilter final : public EffectNode {
+public:
+    static sk_sp<ExternalColorFilter> Make(sk_sp<RenderNode> child);
+
+    ~ExternalColorFilter() override;
+
+    enum class Coverage {
+        kNormal,       // the effect applies to the regular content coverage
+        kBoundingBox,  // the effect applies to the full content bounding box
+    };
+
+    SG_ATTRIBUTE(ColorFilter, sk_sp<SkColorFilter>, fColorFilter)
+    SG_ATTRIBUTE(Coverage   , Coverage            , fCoverage   )
+
+protected:
+    void onRender(SkCanvas*, const RenderContext*) const override;
+
+private:
+    explicit ExternalColorFilter(sk_sp<RenderNode>);
+
+    sk_sp<SkColorFilter> fColorFilter;
+    Coverage             fCoverage = Coverage::kNormal;
+
+    using INHERITED = EffectNode;
+};
+
+/**
+ * Concrete SkBlendModeColorFilter Effect node.
+ */
+class ModeColorFilter final : public ColorFilter {
+public:
+    ~ModeColorFilter() override;
+
+    static sk_sp<ModeColorFilter> Make(sk_sp<RenderNode> child,
+                                       sk_sp<Color> color,
+                                       SkBlendMode mode);
+
+protected:
+    sk_sp<SkColorFilter> onRevalidateFilter() override;
+
+private:
+    ModeColorFilter(sk_sp<RenderNode>, sk_sp<Color>, SkBlendMode);
+
+    const sk_sp<Color> fColor;
+    const SkBlendMode  fMode;
+
+    using INHERITED = ColorFilter;
+};
+
+/**
+ * Tint/multi-tone color effect: maps RGB colors to the [C0,C1][C1,C2]..[Cn-1,Cn] gradient
+ * based on input luminance (where the colors are evenly distributed across the luminance domain),
+ * then mixes with the input based on weight.  Leaves alpha unchanged.
+ */
+class GradientColorFilter final : public ColorFilter {
+public:
+    ~GradientColorFilter() override;
+
+    static sk_sp<GradientColorFilter> Make(sk_sp<RenderNode> child,
+                                           sk_sp<Color> c0, sk_sp<Color> c1);
+    static sk_sp<GradientColorFilter> Make(sk_sp<RenderNode> child,
+                                           std::vector<sk_sp<Color>>);
+
+    SG_ATTRIBUTE(Weight, float, fWeight)
+
+protected:
+    sk_sp<SkColorFilter> onRevalidateFilter() override;
+
+private:
+    GradientColorFilter(sk_sp<RenderNode>, std::vector<sk_sp<Color>>);
+
+    const std::vector<sk_sp<Color>> fColors;
+
+    float                           fWeight = 0;
+
+    using INHERITED = ColorFilter;
+};
+
+} // namespace sksg
+
+#endif // SkSGColorFilter_DEFINED

package/cpp/skia/modules/sksg/include/SkSGDraw.h

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2017 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkSGDraw_DEFINED
+#define SkSGDraw_DEFINED
+
+#include "include/core/SkRect.h"
+#include "include/core/SkRefCnt.h"
+#include "modules/sksg/include/SkSGGeometryNode.h"
+#include "modules/sksg/include/SkSGPaint.h"
+#include "modules/sksg/include/SkSGRenderNode.h"
+
+#include <utility>
+
+class SkCanvas;
+class SkMatrix;
+struct SkPoint;
+
+namespace sksg {
+class InvalidationController;
+
+/**
+ * Concrete rendering node.
+ *
+ * Wraps and draws a [geometry, paint] tuple.
+ *
+ * Think Skia SkCanvas::drawFoo(foo, paint) calls.
+ */
+class Draw : public RenderNode {
+public:
+    static sk_sp<Draw> Make(sk_sp<GeometryNode> geo, sk_sp<PaintNode> paint) {
+        return (geo && paint) ? sk_sp<Draw>(new Draw(std::move(geo), std::move(paint))) : nullptr;
+    }
+
+protected:
+    Draw(sk_sp<GeometryNode>, sk_sp<PaintNode> paint);
+    ~Draw() override;
+
+    void onRender(SkCanvas*, const RenderContext*) const override;
+    const RenderNode* onNodeAt(const SkPoint&)     const override;
+
+    SkRect onRevalidate(InvalidationController*, const SkMatrix&) override;
+
+private:
+    sk_sp<GeometryNode> fGeometry;
+    sk_sp<PaintNode>    fPaint;
+
+    using INHERITED = RenderNode;
+};
+
+} // namespace sksg
+
+#endif // SkSGDraw_DEFINED

package/cpp/skia/modules/sksg/include/SkSGEffectNode.h

@@ -0,0 +1,50 @@
+/*
+ * Copyright 2017 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkSGEffectNode_DEFINED
+#define SkSGEffectNode_DEFINED
+
+#include "include/core/SkRect.h"
+#include "include/core/SkRefCnt.h"
+#include "modules/sksg/include/SkSGRenderNode.h"
+
+#include <cstdint>
+
+class SkCanvas;
+class SkMatrix;
+struct SkPoint;
+
+namespace sksg {
+class InvalidationController;
+
+/**
+ * Base class for nodes which apply some transformation when rendering
+ * their descendants.
+ *
+ * This includes transforms, clipping, filters, etc.
+ */
+class EffectNode : public RenderNode {
+protected:
+    explicit EffectNode(sk_sp<RenderNode>, uint32_t inval_traits = 0);
+    ~EffectNode() override;
+
+    void onRender(SkCanvas*, const RenderContext*) const override;
+    const RenderNode* onNodeAt(const SkPoint&)     const override;
+
+    SkRect onRevalidate(InvalidationController*, const SkMatrix&) override;
+
+    const sk_sp<RenderNode>& getChild() const { return fChild; }
+
+private:
+    sk_sp<RenderNode> fChild;
+
+    using INHERITED = RenderNode;
+};
+
+} // namespace sksg
+
+#endif // SkSGEffectNode_DEFINED

package/cpp/skia/modules/sksg/include/SkSGGeometryEffect.h

@@ -0,0 +1,181 @@
+/*
+ * Copyright 2020 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkSGGeometryEffect_DEFINED
+#define SkSGGeometryEffect_DEFINED
+
+#include "include/core/SkPaint.h"
+#include "include/core/SkPath.h"
+#include "include/core/SkRect.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkScalar.h"
+#include "include/effects/SkTrimPathEffect.h"
+#include "modules/sksg/include/SkSGGeometryNode.h"
+#include "modules/sksg/include/SkSGNode.h"
+#include "modules/sksg/include/SkSGTransform.h"
+
+#include <utility>
+#include <vector>
+
+class SkCanvas;
+class SkMatrix;
+struct SkPoint;
+
+namespace sksg {
+class InvalidationController;
+
+/**
+ * Base class for geometry effects.
+ */
+class GeometryEffect : public GeometryNode {
+protected:
+    explicit GeometryEffect(sk_sp<GeometryNode>);
+    ~GeometryEffect() override;
+
+    void onClip(SkCanvas*, bool antiAlias) const final;
+    void onDraw(SkCanvas*, const SkPaint&) const final;
+    bool onContains(const SkPoint&)        const final;
+
+    SkRect onRevalidate(InvalidationController*, const SkMatrix&) final;
+    SkPath onAsPath() const final;
+
+    virtual SkPath onRevalidateEffect(const sk_sp<GeometryNode>&, const SkMatrix&) = 0;
+
+private:
+    const sk_sp<GeometryNode> fChild;
+    SkPath                    fPath; // transformed child cache.
+
+    using INHERITED = GeometryNode;
+};
+
+/**
+ * Apply a trim effect to the child geometry.
+ */
+class TrimEffect final : public GeometryEffect {
+public:
+    static sk_sp<TrimEffect> Make(sk_sp<GeometryNode> child) {
+        return child ? sk_sp<TrimEffect>(new TrimEffect(std::move(child))) : nullptr;
+    }
+
+    SG_ATTRIBUTE(Start , SkScalar              , fStart )
+    SG_ATTRIBUTE(Stop  , SkScalar              , fStop  )
+    SG_ATTRIBUTE(Mode  , SkTrimPathEffect::Mode, fMode  )
+
+private:
+    explicit TrimEffect(sk_sp<GeometryNode> child) : INHERITED(std::move(child)) {}
+
+    SkPath onRevalidateEffect(const sk_sp<GeometryNode>&, const SkMatrix&) override;
+
+    SkScalar               fStart = 0,
+                           fStop  = 1;
+    SkTrimPathEffect::Mode fMode  = SkTrimPathEffect::Mode::kNormal;
+
+    using INHERITED = GeometryEffect;
+};
+
+/**
+ * Apply a transform to a GeometryNode.
+ */
+class GeometryTransform final : public GeometryEffect {
+public:
+    static sk_sp<GeometryTransform> Make(sk_sp<GeometryNode> child, sk_sp<Transform> transform) {
+        return child && transform
+            ? sk_sp<GeometryTransform>(new GeometryTransform(std::move(child),
+                                                             std::move(transform)))
+            : nullptr;
+    }
+
+    ~GeometryTransform() override;
+
+    const sk_sp<Transform>& getTransform() const { return fTransform; }
+
+private:
+    GeometryTransform(sk_sp<GeometryNode>, sk_sp<Transform>);
+
+    SkPath onRevalidateEffect(const sk_sp<GeometryNode>&, const SkMatrix&) override;
+
+    const sk_sp<Transform> fTransform;
+
+    using INHERITED = GeometryEffect;
+};
+
+/**
+ * Apply a dash effect to the child geometry.
+ *
+ * Follows the same semantics as SkDashPathEffect, with one minor tweak: when the number of
+ * intervals is odd, they are repeated once more to attain an even sequence (same as SVG
+ * stroke-dasharray: https://www.w3.org/TR/SVG11/painting.html#StrokeDasharrayProperty).
+ */
+class DashEffect final : public GeometryEffect {
+public:
+    static sk_sp<DashEffect> Make(sk_sp<GeometryNode> child) {
+        return child ? sk_sp<DashEffect>(new DashEffect(std::move(child))) : nullptr;
+    }
+
+    SG_ATTRIBUTE(Intervals, std::vector<float>, fIntervals)
+    SG_ATTRIBUTE(Phase,                 float , fPhase    )
+
+private:
+    explicit DashEffect(sk_sp<GeometryNode> child) : INHERITED(std::move(child)) {}
+
+    SkPath onRevalidateEffect(const sk_sp<GeometryNode>&, const SkMatrix&) override;
+
+    std::vector<float> fIntervals;
+    float              fPhase = 0;
+
+    using INHERITED = GeometryEffect;
+};
+
+/**
+ * Apply a rounded-corner effect to the child geometry.
+ */
+class RoundEffect final : public GeometryEffect {
+public:
+    static sk_sp<RoundEffect> Make(sk_sp<GeometryNode> child) {
+        return child ? sk_sp<RoundEffect>(new RoundEffect(std::move(child))) : nullptr;
+    }
+
+    SG_ATTRIBUTE(Radius, SkScalar, fRadius)
+
+private:
+    explicit RoundEffect(sk_sp<GeometryNode> child) : INHERITED(std::move(child)) {}
+
+    SkPath onRevalidateEffect(const sk_sp<GeometryNode>&, const SkMatrix&) override;
+
+    SkScalar fRadius = 0;
+
+    using INHERITED = GeometryEffect;
+};
+
+/**
+ * Apply an offset effect to the child geometry.
+ */
+class OffsetEffect final : public GeometryEffect {
+public:
+    static sk_sp<OffsetEffect> Make(sk_sp<GeometryNode> child) {
+        return child ? sk_sp<OffsetEffect>(new OffsetEffect(std::move(child))) : nullptr;
+    }
+
+    SG_ATTRIBUTE(Offset     , SkScalar     , fOffset    )
+    SG_ATTRIBUTE(MiterLimit , SkScalar     , fMiterLimit)
+    SG_ATTRIBUTE(Join       , SkPaint::Join, fJoin      )
+
+private:
+    explicit OffsetEffect(sk_sp<GeometryNode> child) : INHERITED(std::move(child)) {}
+
+    SkPath onRevalidateEffect(const sk_sp<GeometryNode>&, const SkMatrix&) override;
+
+    SkScalar fOffset     = 0,
+             fMiterLimit = 4;
+    SkPaint::Join  fJoin = SkPaint::kMiter_Join;
+
+    using INHERITED = GeometryEffect;
+};
+
+} // namespace sksg
+
+#endif // SkSGGeometryEffect_DEFINED

package/cpp/skia/modules/sksg/include/SkSGGeometryNode.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2017 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkSGGeometryNode_DEFINED
+#define SkSGGeometryNode_DEFINED
+
+#include "modules/sksg/include/SkSGNode.h"
+
+class SkCanvas;
+class SkPaint;
+class SkPath;
+struct SkPoint;
+
+namespace sksg {
+
+/**
+ * Base class for nodes which provide 'geometry' (as opposed to paint)
+ * for drawing.
+ *
+ * Think SkRect, SkPath, etc.
+ */
+class GeometryNode : public Node {
+public:
+    void clip(SkCanvas*, bool antiAlias) const;
+    void draw(SkCanvas*, const SkPaint&) const;
+
+    bool contains(const SkPoint&) const;
+
+    SkPath asPath() const;
+
+protected:
+    GeometryNode();
+
+    virtual void onClip(SkCanvas*, bool antiAlias) const = 0;
+
+    virtual void onDraw(SkCanvas*, const SkPaint&) const = 0;
+
+    virtual bool onContains(const SkPoint&) const = 0;
+
+    virtual SkPath onAsPath() const = 0;
+
+private:
+    friend class Draw; // wants to know the cached bounds.
+
+    using INHERITED = Node;
+};
+
+} // namespace sksg
+
+#endif // SkSGGeometryNode_DEFINED

package/cpp/skia/modules/sksg/include/SkSGGradient.h

@@ -0,0 +1,108 @@
+/*
+ * Copyright 2018 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkSGGradient_DEFINED
+#define SkSGGradient_DEFINED
+
+#include "include/core/SkColor.h"
+#include "include/core/SkPoint.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkScalar.h"
+#include "include/core/SkTileMode.h"
+#include "modules/sksg/include/SkSGNode.h"
+#include "modules/sksg/include/SkSGRenderEffect.h"
+
+#include <vector>
+
+class SkShader;
+
+namespace sksg {
+
+/**
+ * Gradient base class.
+ */
+class Gradient : public Shader {
+public:
+    struct ColorStop {
+        SkScalar  fPosition;
+        SkColor4f fColor;
+
+        bool operator==(const ColorStop& other) const {
+            return fPosition == other.fPosition && fColor == other.fColor;
+        }
+    };
+
+    SG_ATTRIBUTE(ColorStops, std::vector<ColorStop>, fColorStops)
+    SG_ATTRIBUTE(TileMode  , SkTileMode            , fTileMode  )
+
+protected:
+    sk_sp<SkShader> onRevalidateShader() final;
+
+    virtual sk_sp<SkShader> onMakeShader(const std::vector<SkColor4f>& colors,
+                                         const std::vector<SkScalar >& positions) const = 0;
+
+protected:
+    Gradient() = default;
+
+private:
+    std::vector<ColorStop> fColorStops;
+    SkTileMode             fTileMode = SkTileMode::kClamp;
+
+    using INHERITED = Shader;
+};
+
+class LinearGradient final : public Gradient {
+public:
+    static sk_sp<LinearGradient> Make() {
+        return sk_sp<LinearGradient>(new LinearGradient());
+    }
+
+    SG_ATTRIBUTE(StartPoint, SkPoint, fStartPoint)
+    SG_ATTRIBUTE(EndPoint  , SkPoint, fEndPoint  )
+
+protected:
+    sk_sp<SkShader> onMakeShader(const std::vector<SkColor4f>&,
+                                 const std::vector<SkScalar >&) const override;
+
+private:
+    LinearGradient() = default;
+
+    SkPoint fStartPoint = SkPoint::Make(0, 0),
+            fEndPoint   = SkPoint::Make(0, 0);
+
+    using INHERITED = Gradient;
+};
+
+class RadialGradient final : public Gradient {
+public:
+    static sk_sp<RadialGradient> Make() {
+        return sk_sp<RadialGradient>(new RadialGradient());
+    }
+
+    SG_ATTRIBUTE(StartCenter, SkPoint , fStartCenter)
+    SG_ATTRIBUTE(EndCenter  , SkPoint , fEndCenter  )
+    SG_ATTRIBUTE(StartRadius, SkScalar, fStartRadius)
+    SG_ATTRIBUTE(EndRadius  , SkScalar, fEndRadius  )
+
+protected:
+    sk_sp<SkShader> onMakeShader(const std::vector<SkColor4f>&,
+                                 const std::vector<SkScalar >&) const override;
+
+private:
+    RadialGradient() = default;
+
+    SkPoint  fStartCenter = SkPoint::Make(0, 0),
+             fEndCenter   = SkPoint::Make(0, 0);
+    SkScalar fStartRadius = 0,
+             fEndRadius   = 0;
+
+    using INHERITED = Gradient;
+};
+
+} // namespace sksg
+
+#endif // SkSGGradient_DEFINED