@shopify/react-native-skia 2.0.7 → 2.1.1

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

@@ -0,0 +1,65 @@
+/*
+ * 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 SkSGGroup_DEFINED
+#define SkSGGroup_DEFINED
+
+#include "include/core/SkRect.h"
+#include "include/core/SkRefCnt.h"
+#include "modules/sksg/include/SkSGRenderNode.h"
+
+#include <cstddef>
+#include <utility>
+#include <vector>
+
+class SkCanvas;
+class SkMatrix;
+struct SkPoint;
+
+namespace sksg {
+class InvalidationController;
+
+/**
+ * Concrete node, grouping together multiple descendants.
+ */
+class Group : public RenderNode {
+public:
+    static sk_sp<Group> Make() {
+        return sk_sp<Group>(new Group(std::vector<sk_sp<RenderNode>>()));
+    }
+
+    static sk_sp<Group> Make(std::vector<sk_sp<RenderNode>> children) {
+        return sk_sp<Group>(new Group(std::move(children)));
+    }
+
+    void addChild(sk_sp<RenderNode>);
+    void removeChild(const sk_sp<RenderNode>&);
+
+    size_t size() const { return fChildren.size(); }
+    bool  empty() const { return fChildren.empty(); }
+    void  clear();
+
+protected:
+    Group();
+    explicit Group(std::vector<sk_sp<RenderNode>>);
+    ~Group() override;
+
+    void onRender(SkCanvas*, const RenderContext*) const override;
+    const RenderNode* onNodeAt(const SkPoint&)     const override;
+
+    SkRect onRevalidate(InvalidationController*, const SkMatrix&) override;
+
+private:
+    std::vector<sk_sp<RenderNode>> fChildren;
+    bool                           fRequiresIsolation = true;
+
+    using INHERITED = RenderNode;
+};
+
+} // namespace sksg
+
+#endif // SkSGGroup_DEFINED

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

@@ -0,0 +1,59 @@
+/*
+ * 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 SkSGImage_DEFINED
+#define SkSGImage_DEFINED
+
+#include "include/core/SkImage.h"
+#include "include/core/SkRect.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkSamplingOptions.h"
+#include "modules/sksg/include/SkSGNode.h"
+#include "modules/sksg/include/SkSGRenderNode.h"
+
+#include <utility>
+
+class SkCanvas;
+class SkMatrix;
+struct SkPoint;
+
+namespace sksg {
+class InvalidationController;
+
+/**
+ * Concrete rendering node, wrapping an SkImage.
+ *
+ */
+class Image final : public RenderNode {
+public:
+    static sk_sp<Image> Make(sk_sp<SkImage> image) {
+        return sk_sp<Image>(new Image(std::move(image)));
+    }
+
+    SG_ATTRIBUTE(Image          , sk_sp<SkImage>   , fImage          )
+    SG_ATTRIBUTE(SamplingOptions, SkSamplingOptions, fSamplingOptions)
+    SG_ATTRIBUTE(AntiAlias      , bool             , fAntiAlias      )
+
+protected:
+    explicit Image(sk_sp<SkImage>);
+
+    void onRender(SkCanvas*, const RenderContext*) const override;
+    const RenderNode* onNodeAt(const SkPoint&)     const override;
+
+    SkRect onRevalidate(InvalidationController*, const SkMatrix&) override;
+
+private:
+    SkSamplingOptions fSamplingOptions;
+    sk_sp<SkImage>    fImage;
+    bool              fAntiAlias = true;
+
+    using INHERITED = RenderNode;
+};
+
+} // namespace sksg
+
+#endif // SkSGImage_DEFINED

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

@@ -0,0 +1,46 @@
+/*
+ * 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 SkSGInvalidationController_DEFINED
+#define SkSGInvalidationController_DEFINED
+
+#include "include/core/SkMatrix.h"
+#include "include/core/SkRect.h"
+#include "include/core/SkTypes.h"
+
+#include <vector>
+
+namespace sksg {
+
+/**
+ * Receiver for invalidation events.
+ *
+ * Tracks dirty regions for repaint.
+ */
+class InvalidationController {
+public:
+    InvalidationController();
+    InvalidationController(const InvalidationController&) = delete;
+    InvalidationController& operator=(const InvalidationController&) = delete;
+
+    void inval(const SkRect&, const SkMatrix& ctm = SkMatrix::I());
+
+    const SkRect& bounds() const { return fBounds; }
+
+    auto begin() const { return fRects.cbegin(); }
+    auto   end() const { return fRects.cend();   }
+
+    void reset();
+
+private:
+    std::vector<SkRect> fRects;
+    SkRect              fBounds;
+};
+
+} // namespace sksg
+
+#endif // SkSGInvalidationController_DEFINED

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

@@ -0,0 +1,65 @@
+/*
+ * 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 SkSGMaskEffect_DEFINED
+#define SkSGMaskEffect_DEFINED
+
+#include "include/core/SkRect.h"
+#include "include/core/SkRefCnt.h"
+#include "modules/sksg/include/SkSGEffectNode.h"
+#include "modules/sksg/include/SkSGRenderNode.h"
+
+#include <cstdint>
+#include <utility>
+
+class SkCanvas;
+class SkMatrix;
+struct SkPoint;
+
+namespace sksg {
+class InvalidationController;
+
+/**
+ * Concrete Effect node, applying a mask to its descendants.
+ *
+ */
+class MaskEffect final : public EffectNode {
+public:
+    enum class Mode : uint32_t {
+        kAlphaNormal,
+        kAlphaInvert,
+        kLumaNormal,
+        kLumaInvert,
+    };
+
+    static sk_sp<MaskEffect> Make(sk_sp<RenderNode> child, sk_sp<RenderNode> mask,
+                                  Mode mode = Mode::kAlphaNormal) {
+        return (child && mask)
+            ? sk_sp<MaskEffect>(new MaskEffect(std::move(child), std::move(mask), mode))
+            : nullptr;
+    }
+
+    ~MaskEffect() override;
+
+protected:
+    MaskEffect(sk_sp<RenderNode>, sk_sp<RenderNode> mask, Mode);
+
+    void onRender(SkCanvas*, const RenderContext*) const override;
+    const RenderNode* onNodeAt(const SkPoint&)     const override;
+
+    SkRect onRevalidate(InvalidationController*, const SkMatrix&) override;
+
+private:
+    const sk_sp<RenderNode> fMaskNode;
+    const Mode              fMaskMode;
+
+    using INHERITED = EffectNode;
+};
+
+} // namespace sksg
+
+#endif // SkSGMaskEffect_DEFINED

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

@@ -0,0 +1,74 @@
+/*
+ * 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 SkSGMerge_DEFINED
+#define SkSGMerge_DEFINED
+
+#include "include/core/SkPath.h"
+#include "include/core/SkRect.h"
+#include "include/core/SkRefCnt.h"
+#include "modules/sksg/include/SkSGGeometryNode.h"
+
+#include <utility>
+#include <vector>
+
+class SkCanvas;
+class SkMatrix;
+class SkPaint;
+struct SkPoint;
+
+namespace sksg {
+class InvalidationController;
+
+/**
+ * Concrete Geometry node, combining other geometries based on Mode.
+ */
+class Merge final : public GeometryNode {
+public:
+    enum class Mode {
+        // Append path mode.
+        kMerge,
+
+        // SkPathOp ops.
+        kUnion,
+        kIntersect,
+        kDifference,
+        kReverseDifference,
+        kXOR,
+    };
+
+    struct Rec {
+        sk_sp<GeometryNode> fGeo;
+        Mode                fMode;
+    };
+
+    static sk_sp<Merge> Make(std::vector<Rec>&& recs) {
+        return sk_sp<Merge>(new Merge(std::move(recs)));
+    }
+
+    ~Merge() override;
+
+protected:
+    void onClip(SkCanvas*, bool antiAlias) const override;
+    void onDraw(SkCanvas*, const SkPaint&) const override;
+    bool onContains(const SkPoint&)        const override;
+
+    SkRect onRevalidate(InvalidationController*, const SkMatrix&) override;
+    SkPath onAsPath() const override;
+
+private:
+    Merge(std::vector<Rec>&& recs);
+
+    const std::vector<Rec> fRecs;
+    SkPath                 fMerged;
+
+    using INHERITED = GeometryNode;
+};
+
+} // namespace sksg
+
+#endif // SkSGMerge_DEFINED

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

@@ -0,0 +1,128 @@
+/*
+ * 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 SkSGNode_DEFINED
+#define SkSGNode_DEFINED
+
+#include "include/core/SkRect.h"
+#include "include/core/SkRefCnt.h"
+#include "include/private/base/SkAssert.h"
+
+#include <cstdint>
+#include <vector>
+
+class SkMatrix;
+
+namespace sksg {
+
+class InvalidationController;
+
+/**
+ * Base class for all scene graph nodes.
+ *
+ * Handles ingress edge management for the DAG (i.e. node -> "parent" node mapping),
+ * and invalidation.
+ *
+ * Note: egress edges are only implemented/supported in container subclasses
+ * (e.g. Group, Effect, Draw).
+ */
+class Node : public SkRefCnt {
+public:
+    // Traverse the DAG and revalidate any dependant/invalidated nodes.
+    // Returns the bounding box for the DAG fragment.
+    const SkRect& revalidate(InvalidationController*, const SkMatrix&);
+
+    // Tag this node for invalidation and optional damage.
+    void invalidate(bool damage = true);
+
+protected:
+    enum InvalTraits {
+        // Nodes with this trait never generate direct damage -- instead,
+        // the damage bubbles up to ancestors.
+        kBubbleDamage_Trait   = 1 << 0,
+
+        // Nodes with this trait obscure the descendants' damage and always override it.
+        kOverrideDamage_Trait = 1 << 1,
+    };
+
+    explicit Node(uint32_t invalTraits);
+    ~Node() override;
+
+    const SkRect& bounds() const {
+        SkASSERT(!this->hasInval());
+        return fBounds;
+    }
+
+    bool hasInval() const { return fFlags & kInvalidated_Flag; }
+
+    // Dispatched on revalidation.  Subclasses are expected to recompute/cache their properties
+    // and return their bounding box in local coordinates.
+    virtual SkRect onRevalidate(InvalidationController*, const SkMatrix& ctm) = 0;
+
+    // Register/unregister |this| to receive invalidation events from a descendant.
+    void observeInval(const sk_sp<Node>&);
+    void unobserveInval(const sk_sp<Node>&);
+
+private:
+    enum Flags {
+        kInvalidated_Flag   = 1 << 0, // the node or its descendants require revalidation
+        kDamage_Flag        = 1 << 1, // the node contributes damage during revalidation
+        kObserverArray_Flag = 1 << 2, // the node has more than one inval observer
+        kInTraversal_Flag   = 1 << 3, // the node is part of a traversal (cycle detection)
+    };
+
+    template <typename Func>
+    void forEachInvalObserver(Func&&) const;
+
+    class ScopedFlag;
+
+    union {
+        Node*               fInvalObserver;
+        std::vector<Node*>* fInvalObserverArray;
+    };
+    SkRect                  fBounds;
+    const uint32_t          fInvalTraits :  2;
+    uint32_t                fFlags       :  4; // Internal flags.
+    uint32_t                fNodeFlags   :  8; // Accessible from select subclasses.
+    // Free bits                         : 18;
+
+    friend class NodePriv;
+    friend class RenderNode; // node flags access
+
+    using INHERITED = SkRefCnt;
+};
+
+// Helper for defining attribute getters/setters in subclasses.
+#define SG_ATTRIBUTE(attr_name, attr_type, attr_container)             \
+    const attr_type& get##attr_name() const { return attr_container; } \
+    void set##attr_name(const attr_type& v) {                          \
+        if (attr_container == v) return;                               \
+        attr_container = v;                                            \
+        this->invalidate();                                            \
+    }                                                                  \
+    void set##attr_name(attr_type&& v) {                               \
+        if (attr_container == v) return;                               \
+        attr_container = std::move(v);                                 \
+        this->invalidate();                                            \
+    }
+
+#define SG_MAPPED_ATTRIBUTE(attr_name, attr_type, attr_container)                \
+    attr_type get##attr_name() const { return attr_container.get##attr_name(); } \
+    void set##attr_name(const attr_type& v) {                                    \
+        if (attr_container.get##attr_name() == v) return;                        \
+        attr_container.set##attr_name(v);                                        \
+        this->invalidate();                                                      \
+    }                                                                            \
+    void set##attr_name(attr_type&& v) {                                         \
+        if (attr_container.get##attr_name() == v) return;                        \
+        attr_container.set##attr_name(std::move(v));                             \
+        this->invalidate();                                                      \
+    }
+
+} // namespace sksg
+
+#endif // SkSGNode_DEFINED

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

@@ -0,0 +1,54 @@
+/*
+ * 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 SkSGOpacityEffect_DEFINED
+#define SkSGOpacityEffect_DEFINED
+
+#include "include/core/SkRect.h"
+#include "include/core/SkRefCnt.h"
+#include "modules/sksg/include/SkSGEffectNode.h"
+#include "modules/sksg/include/SkSGNode.h"
+#include "modules/sksg/include/SkSGRenderNode.h"
+
+#include <utility>
+
+class SkCanvas;
+class SkMatrix;
+struct SkPoint;
+
+namespace sksg {
+class InvalidationController;
+
+/**
+ * Concrete Effect node, applying opacity to its descendants.
+ *
+ */
+class OpacityEffect final : public EffectNode {
+public:
+    static sk_sp<OpacityEffect> Make(sk_sp<RenderNode> child, float opacity = 1) {
+        return child ? sk_sp<OpacityEffect>(new OpacityEffect(std::move(child), opacity)) : nullptr;
+    }
+
+    SG_ATTRIBUTE(Opacity, float, fOpacity)
+
+protected:
+    OpacityEffect(sk_sp<RenderNode>, float);
+
+    void onRender(SkCanvas*, const RenderContext*) const override;
+    const RenderNode* onNodeAt(const SkPoint&)     const override;
+
+    SkRect onRevalidate(InvalidationController*, const SkMatrix&) override;
+
+private:
+    float fOpacity;
+
+    using INHERITED = EffectNode;
+};
+
+} // namespace sksg
+
+#endif // SkSGOpacityEffect_DEFINED

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

@@ -0,0 +1,112 @@
+/*
+ * 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 SkSGPaint_DEFINED
+#define SkSGPaint_DEFINED
+
+#include "include/core/SkBlendMode.h"
+#include "include/core/SkColor.h"
+#include "include/core/SkPaint.h"
+#include "include/core/SkRect.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkScalar.h"
+#include "modules/sksg/include/SkSGNode.h"
+
+class SkMatrix;
+
+namespace skottie::internal {
+class AnimationBuilder;
+} // namespace skottie::internal
+
+namespace sksg {
+class InvalidationController;
+class Shader;
+
+/**
+ * Base class for nodes which provide a 'paint' (as opposed to geometry) for
+ * drawing (e.g. colors, gradients, patterns).
+ *
+ * Roughly equivalent to Skia's SkPaint.
+ */
+class PaintNode : public Node {
+public:
+    SkPaint makePaint() const;
+
+    SG_ATTRIBUTE(AntiAlias  , bool          , fAntiAlias  )
+    SG_ATTRIBUTE(Opacity    , SkScalar      , fOpacity    )
+    SG_ATTRIBUTE(BlendMode  , SkBlendMode   , fBlendMode  )
+    SG_ATTRIBUTE(StrokeWidth, SkScalar      , fStrokeWidth)
+    SG_ATTRIBUTE(StrokeMiter, SkScalar      , fStrokeMiter)
+    SG_ATTRIBUTE(Style      , SkPaint::Style, fStyle      )
+    SG_ATTRIBUTE(StrokeJoin , SkPaint::Join , fStrokeJoin )
+    SG_ATTRIBUTE(StrokeCap  , SkPaint::Cap  , fStrokeCap  )
+
+protected:
+    PaintNode();
+
+    virtual void onApplyToPaint(SkPaint*) const = 0;
+
+private:
+    SkScalar       fOpacity     = 1,
+                   fStrokeWidth = 1,
+                   fStrokeMiter = 4;
+    bool           fAntiAlias   = false;
+    SkBlendMode    fBlendMode   = SkBlendMode::kSrcOver;
+    SkPaint::Style fStyle       = SkPaint::kFill_Style;
+    SkPaint::Join  fStrokeJoin  = SkPaint::kMiter_Join;
+    SkPaint::Cap   fStrokeCap   = SkPaint::kButt_Cap;
+
+    using INHERITED = Node;
+};
+
+/**
+ * Concrete Paint node, wrapping an SkColor.
+ */
+class Color : public PaintNode {
+public:
+    static sk_sp<Color> Make(SkColor c);
+
+    SG_ATTRIBUTE(Color, SkColor, fColor)
+
+protected:
+    SkRect onRevalidate(InvalidationController*, const SkMatrix&) override;
+
+    void onApplyToPaint(SkPaint*) const override;
+
+private:
+    explicit Color(SkColor);
+
+    SkColor fColor;
+
+    friend class skottie::internal::AnimationBuilder;
+};
+
+/**
+ * Shader-based paint.
+ */
+class ShaderPaint final : public PaintNode {
+public:
+    ~ShaderPaint() override;
+
+    static sk_sp<ShaderPaint> Make(sk_sp<Shader>);
+
+protected:
+    SkRect onRevalidate(InvalidationController*, const SkMatrix&) override;
+
+    void onApplyToPaint(SkPaint*) const override;
+
+private:
+    explicit ShaderPaint(sk_sp<Shader>);
+
+    const sk_sp<Shader> fShader;
+
+    using INHERITED = PaintNode;
+};
+
+}  // namespace sksg
+
+#endif // SkSGPaint_DEFINED

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

@@ -0,0 +1,68 @@
+/*
+ * 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 SkSGPath_DEFINED
+#define SkSGPath_DEFINED
+
+#include "include/core/SkPath.h"
+#include "include/core/SkRect.h"
+#include "include/core/SkRefCnt.h"
+#include "modules/sksg/include/SkSGGeometryNode.h"
+#include "modules/sksg/include/SkSGNode.h"
+
+class SkCanvas;
+class SkMatrix;
+class SkPaint;
+enum class SkPathFillType;
+struct SkPoint;
+
+namespace sksg {
+class InvalidationController;
+
+/**
+ * Concrete Geometry node, wrapping an SkPath.
+ */
+class Path : public GeometryNode {
+public:
+    static sk_sp<Path> Make()                { return sk_sp<Path>(new Path(SkPath())); }
+    static sk_sp<Path> Make(const SkPath& r) { return sk_sp<Path>(new Path(r)); }
+
+    SG_ATTRIBUTE(Path, SkPath, fPath)
+
+    // Temporarily inlined for SkPathFillType staging
+    // SG_MAPPED_ATTRIBUTE(FillType, SkPathFillType, fPath)
+
+    SkPathFillType getFillType() const {
+        return fPath.getFillType();
+    }
+
+    void setFillType(SkPathFillType fillType) {
+        if (fillType != fPath.getFillType()) {
+            fPath.setFillType(fillType);
+            this->invalidate();
+        }
+    }
+
+protected:
+    void onClip(SkCanvas*, bool antiAlias) const override;
+    void onDraw(SkCanvas*, const SkPaint&) const override;
+    bool onContains(const SkPoint&)        const override;
+
+    SkRect onRevalidate(InvalidationController*, const SkMatrix&) override;
+    SkPath onAsPath() const override;
+
+private:
+    explicit Path(const SkPath&);
+
+    SkPath fPath;
+
+    using INHERITED = GeometryNode;
+};
+
+} // namespace sksg
+
+#endif // SkSGPath_DEFINED