react-native-skia 0.0.1 → 2.15.0

package/cpp/skia/modules/skottie/include/Skottie.h

@@ -0,0 +1,324 @@
+/*
+ * Copyright 2017 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef Skottie_DEFINED
+#define Skottie_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkScalar.h"
+#include "include/core/SkSize.h"
+#include "include/core/SkSpan.h"
+#include "include/core/SkString.h"
+#include "include/core/SkTypes.h"
+#include "modules/skresources/include/SkResources.h"
+
+// TODO(kjlubick) update clients and then remove the following:
+#include "include/core/SkFontMgr.h"  // IWYU pragma: keep
+#include "modules/skottie/include/ExternalLayer.h"  // IWYU pragma: keep
+#include "modules/skottie/include/SkottieProperty.h"  // IWYU pragma: keep
+#include "modules/skottie/include/SlotManager.h"  // IWYU pragma: keep
+
+#include <cstddef>
+#include <cstdint>
+#include <vector>
+
+class SkCanvas;
+class SkStream;
+struct SkRect;
+
+namespace sksg {
+
+class InvalidationController;
+class RenderNode;
+
+} // namespace sksg
+
+namespace SkShapers { class Factory; }
+
+namespace skottie {
+
+namespace internal { class Animator; }
+
+using ImageAsset = skresources::ImageAsset;
+using ResourceProvider = skresources::ResourceProvider;
+
+struct LayerInfo {
+    SkString    fName;
+    SkSize      fSize;
+    const float fInPoint,
+                fOutPoint;
+};
+
+/**
+ * A Logger subclass can be used to receive Animation::Builder parsing errors and warnings.
+ */
+class SK_API Logger : public SkRefCnt {
+public:
+    enum class Level {
+        kWarning,
+        kError,
+    };
+
+    virtual void log(Level, const char message[], const char* json = nullptr) = 0;
+};
+
+// Evaluates AE expressions.
+template <class T>
+class SK_API ExpressionEvaluator : public SkRefCnt {
+public:
+    // Evaluate the expression at the current time.
+    virtual T evaluate(float t) = 0;
+};
+
+/**
+ * Creates ExpressionEvaluators to evaluate AE expressions and return the results.
+ */
+class SK_API ExpressionManager : public SkRefCnt {
+public:
+    virtual sk_sp<ExpressionEvaluator<float>> createNumberExpressionEvaluator(
+        const char expression[]) = 0;
+
+    virtual sk_sp<ExpressionEvaluator<SkString>> createStringExpressionEvaluator(
+        const char expression[]) = 0;
+
+    virtual sk_sp<ExpressionEvaluator<std::vector<float>>> createArrayExpressionEvaluator(
+        const char expression[]) = 0;
+};
+
+/**
+ * Interface for receiving AE composition markers at Animation build time.
+ */
+class SK_API MarkerObserver : public SkRefCnt {
+public:
+    // t0,t1 are in the Animation::seek() domain.
+    virtual void onMarker(const char name[], float t0, float t1) = 0;
+};
+
+class SK_API Animation : public SkNVRefCnt<Animation> {
+public:
+    class SK_API Builder final {
+    public:
+        enum Flags : uint32_t {
+            kDeferImageLoading   = 0x01, // Normally, all static image frames are resolved at
+                                         // load time via ImageAsset::getFrame(0).  With this flag,
+                                         // frames are only resolved when needed, at seek() time.
+            kPreferEmbeddedFonts = 0x02, // Attempt to use the embedded fonts (glyph paths,
+                                         // normally used as fallback) over native Skia typefaces.
+        };
+
+        explicit Builder(uint32_t flags = 0);
+        Builder(const Builder&);
+        Builder(Builder&&);
+        ~Builder();
+
+        struct Stats {
+            float  fTotalLoadTimeMS  = 0, // Total animation instantiation time.
+                   fJsonParseTimeMS  = 0, // Time spent building a JSON DOM.
+                   fSceneParseTimeMS = 0; // Time spent constructing the animation scene graph.
+            size_t fJsonSize         = 0, // Input JSON size.
+                   fAnimatorCount    = 0; // Number of dynamically animated properties.
+        };
+
+        /**
+         * Returns various animation build stats.
+         *
+         * @return Stats (see above).
+         */
+        const Stats& getStats() const { return fStats; }
+
+        /**
+         * Specify a loader for external resources (images, etc.).
+         */
+        Builder& setResourceProvider(sk_sp<ResourceProvider>);
+
+        /**
+         * Specify a font manager for loading animation fonts.
+         */
+        Builder& setFontManager(sk_sp<SkFontMgr>);
+
+        /**
+         * Specify a PropertyObserver to receive callbacks during parsing.
+         *
+         * See SkottieProperty.h for more details.
+         *
+         */
+        Builder& setPropertyObserver(sk_sp<PropertyObserver>);
+
+        /**
+         * Register a Logger with this builder.
+         */
+        Builder& setLogger(sk_sp<Logger>);
+
+        /**
+         * Register a MarkerObserver with this builder.
+         */
+        Builder& setMarkerObserver(sk_sp<MarkerObserver>);
+
+        /**
+         * Register a precomp layer interceptor.
+         * This allows substituting precomp layers with custom/externally managed content.
+         */
+        Builder& setPrecompInterceptor(sk_sp<PrecompInterceptor>);
+
+        /**
+         * Registers an ExpressionManager to evaluate AE expressions.
+         * If unspecified, expressions in the animation JSON will be ignored.
+         */
+        Builder& setExpressionManager(sk_sp<ExpressionManager>);
+
+        /**
+         * Registers a factory to be used when shaping text.
+         * If unspecified, text will be shaped with primitive shaping.
+         * See //modules/skshaper/utils/FactoryHelpers.h
+         */
+        Builder& setTextShapingFactory(sk_sp<SkShapers::Factory>);
+
+        /**
+         * Animation factories.
+         */
+        sk_sp<Animation> make(SkStream*);
+        sk_sp<Animation> make(const char* data, size_t length);
+        sk_sp<Animation> makeFromFile(const char path[]);
+
+        /**
+         * Get handle for SlotManager after animation is built.
+         */
+        const sk_sp<SlotManager>& getSlotManager() const {return fSlotManager;}
+
+        SkSpan<const LayerInfo> getLayerInfo() const {return SkSpan(fLayerInfo);}
+
+    private:
+        const uint32_t          fFlags;
+
+        sk_sp<ResourceProvider>   fResourceProvider;
+        sk_sp<SkFontMgr>          fFontMgr;
+        sk_sp<PropertyObserver>   fPropertyObserver;
+        sk_sp<Logger>             fLogger;
+        sk_sp<MarkerObserver  >   fMarkerObserver;
+        sk_sp<PrecompInterceptor> fPrecompInterceptor;
+        sk_sp<ExpressionManager>  fExpressionManager;
+        sk_sp<SkShapers::Factory> fShapingFactory;
+        sk_sp<SlotManager>        fSlotManager;
+        Stats                     fStats;
+        std::vector<LayerInfo>    fLayerInfo;
+    };
+
+    /**
+     * Animation factories.
+     *
+     * Use the Builder helper above for more options/control.
+     */
+    static sk_sp<Animation> Make(const char* data, size_t length);
+    static sk_sp<Animation> Make(SkStream*);
+    static sk_sp<Animation> MakeFromFile(const char path[]);
+
+    ~Animation();
+
+    enum RenderFlag : uint32_t {
+        // When rendering into a known transparent buffer, clients can pass
+        // this flag to avoid some unnecessary compositing overhead for
+        // animations using layer blend modes.
+        kSkipTopLevelIsolation   = 0x01,
+        // By default, content is clipped to the intrinsic animation
+        // bounds (as determined by its size).  If this flag is set,
+        // then the animation can draw outside of the bounds.
+        kDisableTopLevelClipping = 0x02,
+    };
+    using RenderFlags = uint32_t;
+
+    /**
+     * Draws the current animation frame.
+     *
+     * It is undefined behavior to call render() on a newly created Animation
+     * before specifying an initial frame via one of the seek() variants.
+     *
+     * @param canvas   destination canvas
+     * @param dst      optional destination rect
+     * @param flags    optional RenderFlags
+     */
+    void render(SkCanvas* canvas, const SkRect* dst = nullptr) const;
+    void render(SkCanvas* canvas, const SkRect* dst, RenderFlags) const;
+
+    /**
+     * [Deprecated: use one of the other versions.]
+     *
+     * Updates the animation state for |t|.
+     *
+     * @param t   normalized [0..1] frame selector (0 -> first frame, 1 -> final frame)
+     * @param ic  optional invalidation controller (dirty region tracking)
+     *
+     */
+    void seek(SkScalar t, sksg::InvalidationController* ic = nullptr) {
+        this->seekFrameTime(t * this->duration(), ic);
+    }
+
+    /**
+     * Update the animation state to match |t|, specified as a frame index
+     * i.e. relative to duration() * fps().
+     *
+     * Fractional values are allowed and meaningful - e.g.
+     *
+     *   0.0 -> first frame
+     *   1.0 -> second frame
+     *   0.5 -> halfway between first and second frame
+     */
+    void seekFrame(double t, sksg::InvalidationController* ic = nullptr);
+
+    /** Update the animation state to match t, specifed in frame time
+     *  i.e. relative to duration().
+     */
+    void seekFrameTime(double t, sksg::InvalidationController* = nullptr);
+
+    /**
+     * Returns the animation duration in seconds.
+     */
+    double duration() const { return fDuration; }
+
+    /**
+     * Returns the animation frame rate (frames / second).
+     */
+    double fps() const { return fFPS; }
+
+    /**
+     * Animation in point, in frame index units.
+     */
+    double inPoint()  const { return fInPoint;  }
+
+    /**
+     * Animation out point, in frame index units.
+     */
+    double outPoint() const { return fOutPoint; }
+
+    const SkString& version() const { return fVersion; }
+    const SkSize&      size() const { return fSize;    }
+
+private:
+    enum Flags : uint32_t {
+        kRequiresTopLevelIsolation = 1 << 0, // Needs to draw into a layer due to layer blending.
+    };
+
+    Animation(sk_sp<sksg::RenderNode>,
+              std::vector<sk_sp<internal::Animator>>&&,
+              SkString ver, const SkSize& size,
+              double inPoint, double outPoint, double duration, double fps, uint32_t flags);
+
+    const sk_sp<sksg::RenderNode>                fSceneRoot;
+    const std::vector<sk_sp<internal::Animator>> fAnimators;
+    const SkString                               fVersion;
+    const SkSize                                 fSize;
+    const double                                 fInPoint,
+                                                 fOutPoint,
+                                                 fDuration,
+                                                 fFPS;
+    const uint32_t                               fFlags;
+
+    using INHERITED = SkNVRefCnt<Animation>;
+};
+
+} // namespace skottie
+
+#endif // Skottie_DEFINED

package/cpp/skia/modules/skottie/include/SkottieProperty.h

@@ -0,0 +1,192 @@
+/*
+ * Copyright 2018 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkottieProperty_DEFINED
+#define SkottieProperty_DEFINED
+
+#include "include/core/SkColor.h"
+#include "include/core/SkMatrix.h"
+#include "include/core/SkPaint.h"
+#include "include/core/SkPoint.h"
+#include "include/core/SkRect.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkScalar.h"
+#include "include/core/SkSpan.h"
+#include "include/core/SkString.h"
+#include "include/core/SkTypeface.h"
+#include "include/private/SkAPI.h"
+#include "include/utils/SkTextUtils.h"
+#include "modules/skottie/include/TextShaper.h"
+
+#include <cstddef>
+#include <cstdint>
+#include <functional>
+#include <limits>
+#include <memory>
+#include <utility>
+
+class SkCanvas;
+
+namespace sksg {
+
+class Color;
+class OpacityEffect;
+
+} // namespace sksg
+
+namespace skottie {
+
+using ColorPropertyValue   = SkColor;
+using OpacityPropertyValue = float;
+
+enum class TextPaintOrder : uint8_t {
+    kFillStroke,
+    kStrokeFill,
+};
+
+// Optional callback invoked when drawing text layers.
+// Allows clients to render custom text decorations.
+class GlyphDecorator : public SkRefCnt {
+public:
+    struct GlyphInfo {
+        SkRect   fBounds;  // visual glyph bounds
+        SkMatrix fMatrix;  // glyph matrix
+        size_t   fCluster; // cluster index in the original text string
+        float    fAdvance; // horizontal glyph advance
+    };
+
+    struct TextInfo {
+        SkSpan<const GlyphInfo> fGlyphs;
+        float                   fScale;  // Additional font scale applied by auto-sizing.
+    };
+
+    virtual void onDecorate(SkCanvas*, const TextInfo&) = 0;
+};
+
+struct TextPropertyValue {
+    sk_sp<SkTypeface>       fTypeface;
+    SkString                fText;
+    float                   fTextSize       = 0,
+                            fMinTextSize    = 0,                                 // when auto-sizing
+                            fMaxTextSize    = std::numeric_limits<float>::max(), // when auto-sizing
+                            fStrokeWidth    = 0,
+                            fLineHeight     = 0,
+                            fLineShift      = 0,
+                            fAscent         = 0;
+    size_t                  fMaxLines       = 0;                                 // when auto-sizing
+    SkTextUtils::Align      fHAlign         = SkTextUtils::kLeft_Align;
+    Shaper::VAlign          fVAlign         = Shaper::VAlign::kTop;
+    Shaper::ResizePolicy    fResize         = Shaper::ResizePolicy::kNone;
+    Shaper::LinebreakPolicy fLineBreak      = Shaper::LinebreakPolicy::kExplicit;
+    Shaper::Direction       fDirection      = Shaper::Direction::kLTR;
+    Shaper::Capitalization  fCapitalization = Shaper::Capitalization::kNone;
+    SkRect                  fBox            = SkRect::MakeEmpty();
+    SkColor                 fFillColor      = SK_ColorTRANSPARENT,
+                            fStrokeColor    = SK_ColorTRANSPARENT;
+    TextPaintOrder          fPaintOrder     = TextPaintOrder::kFillStroke;
+    SkPaint::Join           fStrokeJoin     = SkPaint::Join::kMiter_Join;
+    bool                    fHasFill        = false,
+                            fHasStroke      = false;
+    sk_sp<GlyphDecorator>   fDecorator;
+                            // The locale to be used for text shaping, in BCP47 form.  This includes
+                            // support for RFC6067 extensions, so one can e.g. select strict line
+                            // breaking rules for certain scripts: ja-u-lb-strict.
+                            // Pass an empty string to use the system locale.
+    SkString                fLocale;
+                            // Optional font family name, to be passed to the font manager for
+                            // fallback.
+    SkString                fFontFamily;
+                            // Extra spacing between glyphs (letter tracking), in 1/1000 em units.
+    float                   fTextTracking   = 0;
+
+    bool operator==(const TextPropertyValue& other) const;
+    bool operator!=(const TextPropertyValue& other) const;
+};
+
+struct TransformPropertyValue {
+    SkPoint  fAnchorPoint,
+             fPosition;
+    SkVector fScale;
+    SkScalar fRotation,
+             fSkew,
+             fSkewAxis;
+
+    bool operator==(const TransformPropertyValue& other) const;
+    bool operator!=(const TransformPropertyValue& other) const;
+};
+
+namespace internal { class SceneGraphRevalidator; }
+
+/**
+ * Property handles are adapters between user-facing AE model/values
+ * and the internal scene-graph representation.
+ */
+template <typename ValueT, typename NodeT>
+class SK_API PropertyHandle final {
+public:
+    explicit PropertyHandle(sk_sp<NodeT>);
+    PropertyHandle(sk_sp<NodeT> node, sk_sp<internal::SceneGraphRevalidator> revalidator)
+        : fNode(std::move(node))
+        , fRevalidator(std::move(revalidator)) {}
+    ~PropertyHandle();
+
+    PropertyHandle(const PropertyHandle&);
+
+    ValueT get() const;
+    void set(const ValueT&);
+
+private:
+    const sk_sp<NodeT>                           fNode;
+    const sk_sp<internal::SceneGraphRevalidator> fRevalidator;
+};
+
+namespace internal {
+
+class TextAdapter;
+class TransformAdapter2D;
+
+} // namespace internal
+
+using ColorPropertyHandle     = PropertyHandle<ColorPropertyValue,
+                                               sksg::Color>;
+using OpacityPropertyHandle   = PropertyHandle<OpacityPropertyValue,
+                                               sksg::OpacityEffect>;
+using TextPropertyHandle      = PropertyHandle<TextPropertyValue,
+                                               internal::TextAdapter>;
+using TransformPropertyHandle = PropertyHandle<TransformPropertyValue,
+                                               internal::TransformAdapter2D>;
+
+/**
+ * A PropertyObserver can be used to track and manipulate certain properties of "interesting"
+ * Lottie nodes.
+ *
+ * When registered with an animation builder, PropertyObserver receives notifications for
+ * various properties of layer and shape nodes.  The |node_name| argument corresponds to the
+ * name ("nm") node property.
+ */
+class SK_API PropertyObserver : public SkRefCnt {
+public:
+    enum class NodeType {COMPOSITION, LAYER, EFFECT, OTHER};
+
+    template <typename T>
+    using LazyHandle = std::function<std::unique_ptr<T>()>;
+
+    virtual void onColorProperty    (const char node_name[],
+                                     const LazyHandle<ColorPropertyHandle>&);
+    virtual void onOpacityProperty  (const char node_name[],
+                                     const LazyHandle<OpacityPropertyHandle>&);
+    virtual void onTextProperty     (const char node_name[],
+                                     const LazyHandle<TextPropertyHandle>&);
+    virtual void onTransformProperty(const char node_name[],
+                                     const LazyHandle<TransformPropertyHandle>&);
+    virtual void onEnterNode(const char node_name[], NodeType node_type);
+    virtual void onLeavingNode(const char node_name[], NodeType node_type);
+};
+
+} // namespace skottie
+
+#endif // SkottieProperty_DEFINED

package/cpp/skia/modules/skottie/include/SlotManager.h

@@ -0,0 +1,113 @@
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SlotManager_DEFINED
+#define SlotManager_DEFINED
+
+#include "include/core/SkColor.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkString.h"
+#include "include/private/SkAPI.h"
+#include "include/private/SkTArray.h"
+#include "modules/skottie/src/SkottieValue.h"
+#include "modules/skottie/src/text/TextAdapter.h"
+#include "src/core/SkTHash.h"
+
+#include <optional>
+
+struct SkV2;
+
+namespace skresources {
+class ImageAsset;
+}
+
+namespace skottie {
+
+struct TextPropertyValue;
+
+namespace internal {
+class AnimationBuilder;
+class SceneGraphRevalidator;
+class AnimatablePropertyContainer;
+} // namespace internal
+
+using namespace skia_private;
+
+class SK_API SlotManager final : public SkRefCnt {
+
+public:
+    using SlotID = SkString;
+
+    explicit SlotManager(sk_sp<skottie::internal::SceneGraphRevalidator>);
+    ~SlotManager() override;
+
+    bool setColorSlot(const SlotID&, SkColor);
+    bool setImageSlot(const SlotID&, const sk_sp<skresources::ImageAsset>&);
+    bool setScalarSlot(const SlotID&, float);
+    bool setVec2Slot(const SlotID&, SkV2);
+    bool setTextSlot(const SlotID&, const TextPropertyValue&);
+
+    std::optional<SkColor>               getColorSlot(const SlotID&) const;
+    sk_sp<const skresources::ImageAsset> getImageSlot(const SlotID&) const;
+    std::optional<float>                 getScalarSlot(const SlotID&) const;
+    std::optional<SkV2>                  getVec2Slot(const SlotID&) const;
+    std::optional<TextPropertyValue>     getTextSlot(const SlotID&) const;
+
+    struct SlotInfo {
+        TArray<SlotID> fColorSlotIDs;
+        TArray<SlotID> fScalarSlotIDs;
+        TArray<SlotID> fVec2SlotIDs;
+        TArray<SlotID> fImageSlotIDs;
+        TArray<SlotID> fTextSlotIDs;
+    };
+
+    // Helper function to get all slot IDs and their value types
+    SlotInfo getSlotInfo() const;
+
+private:
+
+    // pass value to the SlotManager for manipulation and node for invalidation
+    void trackColorValue(const SlotID&, ColorValue*,
+                         sk_sp<skottie::internal::AnimatablePropertyContainer>);
+    sk_sp<skresources::ImageAsset> trackImageValue(const SlotID&, sk_sp<skresources::ImageAsset>);
+    void trackScalarValue(const SlotID&, ScalarValue*,
+                          sk_sp<skottie::internal::AnimatablePropertyContainer>);
+    void trackVec2Value(const SlotID&, Vec2Value*,
+                        sk_sp<skottie::internal::AnimatablePropertyContainer>);
+    void trackTextValue(const SlotID&, sk_sp<skottie::internal::TextAdapter>);
+
+    // ValuePair tracks a pointer to a value to change, and a means to invalidate the render tree.
+    // For the latter, we can take either a node in the scene graph that directly the scene graph,
+    // or an adapter which takes the value passed and interprets it before pushing to the scene
+    // (clamping, normalizing, etc.)
+    // Only one should be set, it is UB to create a ValuePair with both a node and an adapter.
+    template <typename T>
+    struct ValuePair
+    {
+        T value;
+        sk_sp<skottie::internal::AnimatablePropertyContainer> adapter;
+    };
+
+    class ImageAssetProxy;
+    template <typename T>
+    using SlotMap = THashMap<SlotID, TArray<T>>;
+
+    SlotMap<ValuePair<ColorValue*>>                fColorMap;
+    SlotMap<ValuePair<ScalarValue*>>               fScalarMap;
+    SlotMap<ValuePair<Vec2Value*>>                 fVec2Map;
+    SlotMap<sk_sp<ImageAssetProxy>>                fImageMap;
+    SlotMap<sk_sp<skottie::internal::TextAdapter>> fTextMap;
+
+    const sk_sp<skottie::internal::SceneGraphRevalidator> fRevalidator;
+
+    friend class skottie::internal::AnimationBuilder;
+    friend class skottie::internal::AnimatablePropertyContainer;
+};
+
+} // namespace skottie
+
+#endif // SlotManager_DEFINED