@shopify/react-native-skia 2.0.7 → 2.1.1

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

@@ -0,0 +1,200 @@
+/*
+ * 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 SkottieTextShaper_DEFINED
+#define SkottieTextShaper_DEFINED
+
+#include "include/core/SkFont.h"
+#include "include/core/SkPoint.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkScalar.h"
+#include "include/core/SkTypes.h"
+#include "include/private/base/SkTypeTraits.h"
+#include "include/utils/SkTextUtils.h"
+
+#include <cstddef>
+#include <cstdint>
+#include <type_traits>
+#include <vector>
+
+class SkCanvas;
+class SkFontMgr;
+class SkPaint;
+class SkString;
+class SkTypeface;
+struct SkRect;
+
+namespace SkShapers { class Factory; }
+
+namespace skottie {
+
+// Helper implementing After Effects text shaping semantics on top of SkShaper.
+
+class Shaper final {
+public:
+    struct RunRec {
+        SkFont fFont;
+        size_t fSize;
+
+        static_assert(::sk_is_trivially_relocatable<decltype(fFont)>::value);
+
+        using sk_is_trivially_relocatable = std::true_type;
+    };
+
+    struct ShapedGlyphs {
+        std::vector<RunRec>    fRuns;
+
+        // Consolidated storage for all runs.
+        std::vector<SkGlyphID> fGlyphIDs;
+        std::vector<SkPoint>   fGlyphPos;
+
+        // fClusters[i] is an input string index, pointing to the start of the UTF sequence
+        // associated with fGlyphs[i].  The number of entries matches the number of glyphs.
+        // Only available with Flags::kClusters.
+        std::vector<size_t>    fClusters;
+
+        enum class BoundsType { kConservative, kTight };
+        SkRect computeBounds(BoundsType) const;
+
+        void draw(SkCanvas*, const SkPoint& origin, const SkPaint&) const;
+    };
+
+    struct Fragment {
+        ShapedGlyphs fGlyphs;
+        SkPoint      fOrigin;
+
+        // Only valid for kFragmentGlyphs
+        float        fAdvance,
+                     fAscent;
+        uint32_t     fLineIndex;    // 0-based index for the line this fragment belongs to.
+        bool         fIsWhitespace; // True if the first code point in the corresponding
+                                    // cluster is whitespace.
+    };
+
+    struct Result {
+        std::vector<Fragment> fFragments;
+        size_t                fMissingGlyphCount = 0;
+        // Relative text size scale, when using an auto-scaling ResizePolicy
+        // (otherwise 1.0).  This is informative of the final text size, and is
+        // not required to render the Result.
+        float                 fScale = 1.0f;
+
+        SkRect computeVisualBounds() const;
+    };
+
+    enum class VAlign : uint8_t {
+        // Align the first line typographical top with the text box top (AE box text).
+        kTop,
+        // Align the first line typographical baseline with the text box top (AE point text).
+        kTopBaseline,
+
+        // Skottie vertical alignment extensions
+
+        // These are based on a hybrid extent box defined (in Y) as
+        //
+        //   ------------------------------------------------------
+        //   MIN(visual_top_extent   , typographical_top_extent   )
+        //
+        //                         ...
+        //
+        //   MAX(visual_bottom_extent, typographical_bottom_extent)
+        //   ------------------------------------------------------
+        kHybridTop,     // extent box top    -> text box top
+        kHybridCenter,  // extent box center -> text box center
+        kHybridBottom,  // extent box bottom -> text box bottom
+
+        // Visual alignement modes -- these are using tight visual bounds for the paragraph.
+        kVisualTop,     // visual top    -> text box top
+        kVisualCenter,  // visual center -> text box center
+        kVisualBottom,  // visual bottom -> text box bottom
+    };
+
+    enum class ResizePolicy : uint8_t {
+        // Use the specified text size.
+        kNone,
+        // Resize the text such that the extent box fits (snuggly) in the text box,
+        // both horizontally and vertically.
+        kScaleToFit,
+        // Same kScaleToFit if the text doesn't fit at the specified font size.
+        // Otherwise, same as kNone.
+        kDownscaleToFit,
+    };
+
+    enum class LinebreakPolicy : uint8_t {
+        // Break lines such that they fit in a non-empty paragraph box, horizontally.
+        kParagraph,
+        // Only break lines when requested explicitly (\r), regardless of paragraph box dimensions.
+        kExplicit,
+    };
+
+    // Initial text direction.
+    enum class Direction : uint8_t { kLTR, kRTL };
+
+    enum class Capitalization {
+        kNone,
+        kUpperCase,
+    };
+
+    enum Flags : uint32_t {
+        kNone                       = 0x00,
+
+        // Split out individual glyphs into separate Fragments
+        // (useful when the caller intends to manipulate glyphs independently).
+        kFragmentGlyphs             = 0x01,
+
+        // Compute the advance and ascent for each fragment.
+        kTrackFragmentAdvanceAscent = 0x02,
+
+        // Return cluster information.
+        kClusters                   = 0x04,
+    };
+
+    struct TextDesc {
+        const sk_sp<SkTypeface>&  fTypeface;
+        SkScalar                  fTextSize       = 0,
+                                  fMinTextSize    = 0,  // when auto-sizing
+                                  fMaxTextSize    = 0,  // when auto-sizing
+                                  fLineHeight     = 0,
+                                  fLineShift      = 0,
+                                  fAscent         = 0;
+        SkTextUtils::Align        fHAlign         = SkTextUtils::kLeft_Align;
+        VAlign                    fVAlign         = Shaper::VAlign::kTop;
+        ResizePolicy              fResize         = Shaper::ResizePolicy::kNone;
+        LinebreakPolicy           fLinebreak      = Shaper::LinebreakPolicy::kExplicit;
+        Direction                 fDirection      = Shaper::Direction::kLTR ;
+        Capitalization            fCapitalization = Shaper::Capitalization::kNone;
+        size_t                    fMaxLines       = 0;  // when auto-sizing, 0 -> no max
+        uint32_t                  fFlags          = 0;
+        const char*               fLocale         = nullptr;
+        const char*               fFontFamily     = nullptr;
+    };
+
+    // Performs text layout along an infinite horizontal line, starting at |point|.
+    // Only explicit line breaks (\r) are observed.
+    static Result Shape(const SkString& text, const TextDesc& desc, const SkPoint& point,
+                        const sk_sp<SkFontMgr>&, const sk_sp<SkShapers::Factory>&);
+
+    // Performs text layout within |box|, injecting line breaks as needed to ensure
+    // horizontal fitting.  The result is *not* guaranteed to fit vertically (it may extend
+    // below the box bottom).
+    static Result Shape(const SkString& text, const TextDesc& desc, const SkRect& box,
+                        const sk_sp<SkFontMgr>&, const sk_sp<SkShapers::Factory>&);
+
+#if !defined(SK_DISABLE_LEGACY_SHAPER_FACTORY)
+    static Result Shape(const SkString& text, const TextDesc& desc, const SkPoint& point,
+                        const sk_sp<SkFontMgr>&);
+    static Result Shape(const SkString& text, const TextDesc& desc, const SkRect& box,
+                        const sk_sp<SkFontMgr>&);
+#endif
+
+private:
+    Shaper() = delete;
+};
+
+} // namespace skottie
+
+#endif // SkottieTextShaper_DEFINED

package/cpp/skia/modules/skottie/src/SkottieValue.h

@@ -0,0 +1,56 @@
+/*
+ * 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 SkottieValue_DEFINED
+#define SkottieValue_DEFINED
+
+#include "include/core/SkColor.h"
+#include "include/core/SkM44.h"
+#include "include/core/SkPath.h"
+
+#include <initializer_list>
+#include <vector>
+
+namespace skjson { class Value; }
+
+namespace skottie {
+
+using ScalarValue = SkScalar;
+using   Vec2Value = SkV2;
+
+class VectorValue : public std::vector<float> {
+public:
+    VectorValue() = default;
+
+    VectorValue(std::initializer_list<float> l) : INHERITED(l) {}
+
+    operator SkV3()      const;
+private:
+    using INHERITED = std::vector<float>;
+};
+
+class ColorValue final : public VectorValue {
+public:
+    ColorValue() = default;
+
+    ColorValue(std::initializer_list<float> l) : INHERITED(l) {}
+
+    operator SkColor()   const;
+    operator SkColor4f() const;
+
+private:
+    using INHERITED = VectorValue;
+};
+
+class ShapeValue final : public std::vector<float> {
+public:
+    operator SkPath() const;
+};
+
+} // namespace skottie
+
+#endif // SkottieValue_DEFINED

package/cpp/skia/modules/skottie/src/animator/Animator.h

@@ -0,0 +1,89 @@
+/*
+ * 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 SkottieAnimator_DEFINED
+#define SkottieAnimator_DEFINED
+
+#include "include/core/SkRefCnt.h"
+
+#include <vector>
+
+struct SkV2;
+
+namespace skjson {
+
+class ObjectValue;
+
+} // namespace skjson
+
+namespace skottie {
+
+class SlotManager;
+
+namespace internal {
+
+class AnimationBuilder;
+class AnimatorBuilder;
+
+class Animator : public SkRefCnt {
+public:
+    using StateChanged = bool;
+    StateChanged seek(float t) { return this->onSeek(t); }
+
+protected:
+    Animator() = default;
+
+    virtual StateChanged onSeek(float t) = 0;
+
+private:
+    Animator(const Animator&) = delete;
+    Animator& operator=(const Animator&) = delete;
+};
+
+class AnimatablePropertyContainer : public Animator {
+public:
+    // This is the workhorse for property binding: depending on whether the property is animated,
+    // it will either apply immediately or instantiate and attach a keyframe animator, scoped to
+    // this container.
+    template <typename T>
+    bool bind(const AnimationBuilder&, const skjson::ObjectValue*, T*);
+
+    template <typename T>
+    bool bind(const AnimationBuilder& abuilder, const skjson::ObjectValue* jobject, T& v) {
+        return this->bind<T>(abuilder, jobject, &v);
+    }
+
+    // A flavor of bind<Vec2Value> which drives an additional/optional orientation target
+    // (rotation in degrees), when bound to a motion path property.
+    bool bindAutoOrientable(const AnimationBuilder& abuilder,
+                            const skjson::ObjectValue* jobject,
+                            SkV2* v, float* orientation);
+
+    bool isStatic() const { return fAnimators.empty() && !fHasSlotID; }
+
+protected:
+    friend class skottie::SlotManager;
+    virtual void onSync() = 0;
+
+    void shrink_to_fit();
+
+    void attachDiscardableAdapter(sk_sp<AnimatablePropertyContainer>);
+
+private:
+    StateChanged onSeek(float) final;
+
+    bool bindImpl(const AnimationBuilder&, const skjson::ObjectValue*, AnimatorBuilder&);
+
+    std::vector<sk_sp<Animator>> fAnimators;
+    bool                         fHasSynced = false;
+    bool                         fHasSlotID = false;
+};
+
+} // namespace internal
+} // namespace skottie
+
+#endif // SkottieAnimator_DEFINED

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

@@ -0,0 +1,82 @@
+/*
+ * Copyright 2022 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkottieFont_DEFINED
+#define SkottieFont_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkTypes.h"
+#include "include/private/base/SkNoncopyable.h"
+#include "include/utils/SkCustomTypeface.h"
+#include "modules/sksg/include/SkSGRenderNode.h"
+#include "src/core/SkTHash.h"
+
+#include <memory>
+#include <utility>
+#include <vector>
+
+class SkPath;
+class SkTypeface;
+struct SkSize;
+
+namespace skjson { class ObjectValue; }
+
+namespace skottie::internal {
+
+class AnimationBuilder;
+
+// Font backed by Lottie character data (glyph paths and glyph compositions).
+class CustomFont final : SkNoncopyable {
+public:
+    ~CustomFont();
+
+    using GlyphCompMap = skia_private::THashMap<SkGlyphID, sk_sp<sksg::RenderNode>>;
+
+    class Builder final : SkNoncopyable {
+    public:
+        bool parseGlyph(const AnimationBuilder*, const skjson::ObjectValue&);
+        std::unique_ptr<CustomFont> detach();
+
+    private:
+        static bool ParseGlyphPath(const AnimationBuilder*, const skjson::ObjectValue&, SkPath*);
+        static sk_sp<sksg::RenderNode> ParseGlyphComp(const AnimationBuilder*,
+                                                      const skjson::ObjectValue&,
+                                                      SkSize*);
+
+        GlyphCompMap            fGlyphComps;
+        SkCustomTypefaceBuilder fCustomBuilder;
+    };
+
+    // Helper for resolving (SkTypeface, SkGlyphID) tuples to a composition root.
+    // Used post-shaping, to substitute composition glyphs in the rendering tree.
+    class GlyphCompMapper final : public SkRefCnt {
+    public:
+        explicit GlyphCompMapper(std::vector<std::unique_ptr<CustomFont>>&& fonts)
+            : fFonts(std::move(fonts)) {}
+
+        ~GlyphCompMapper() override = default;
+
+        sk_sp<sksg::RenderNode> getGlyphComp(const SkTypeface*, SkGlyphID) const;
+
+    private:
+        const std::vector<std::unique_ptr<CustomFont>> fFonts;
+    };
+
+    const sk_sp<SkTypeface>& typeface() const { return fTypeface; }
+
+    int glyphCompCount() const { return fGlyphComps.count(); }
+
+private:
+    CustomFont(GlyphCompMap&&, sk_sp<SkTypeface> tf);
+
+    const GlyphCompMap      fGlyphComps;
+    const sk_sp<SkTypeface> fTypeface;
+};
+
+}  // namespace skottie::internal
+
+#endif  // SkottieFont_DEFINED

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

@@ -0,0 +1,155 @@
+/*
+ * 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 SkottieTextAdapter_DEFINED
+#define SkottieTextAdapter_DEFINED
+
+#include "include/core/SkM44.h"
+#include "include/core/SkPoint.h"
+#include "include/core/SkRefCnt.h"
+#include "modules/skottie/include/TextShaper.h"
+#include "modules/skottie/src/SkottieValue.h"
+#include "modules/skottie/src/animator/Animator.h"
+#include "modules/skottie/src/text/Font.h"
+#include "modules/skottie/src/text/TextAnimator.h"
+#include "modules/skottie/src/text/TextValue.h"
+#include "modules/sksg/include/SkSGPaint.h"
+#include "modules/sksg/include/SkSGRenderEffect.h"
+#include "modules/sksg/include/SkSGTransform.h"
+
+#include <cstdint>
+#include <memory>
+#include <vector>
+
+class SkFontMgr;
+
+namespace skjson {
+class ObjectValue;
+}
+namespace skottie {
+class Logger;
+}
+namespace sksg {
+class Group;
+class RenderNode;
+}  // namespace sksg
+
+namespace SkShapers { class Factory; }
+
+namespace skottie {
+namespace internal {
+class AnimationBuilder;
+
+class TextAdapter final : public AnimatablePropertyContainer {
+public:
+    static sk_sp<TextAdapter> Make(const skjson::ObjectValue&,
+                                   const AnimationBuilder*,
+                                   sk_sp<SkFontMgr>,
+                                   sk_sp<CustomFont::GlyphCompMapper>,
+                                   sk_sp<Logger>,
+                                   sk_sp<::SkShapers::Factory>);
+
+    ~TextAdapter() override;
+
+    const sk_sp<sksg::Group>& node() const { return fRoot; }
+
+    const TextValue& getText() const { return fText.fCurrentValue; }
+    void setText(const TextValue&);
+
+protected:
+    void onSync() override;
+
+private:
+    class GlyphDecoratorNode;
+
+    enum class AnchorPointGrouping : uint8_t {
+        kCharacter,
+        kWord,
+        kLine,
+        kAll,
+    };
+
+    TextAdapter(sk_sp<SkFontMgr>,
+                sk_sp<CustomFont::GlyphCompMapper>,
+                sk_sp<Logger>,
+                sk_sp<SkShapers::Factory>,
+                AnchorPointGrouping);
+
+    struct FragmentRec {
+        SkPoint                      fOrigin; // fragment position
+
+        const Shaper::ShapedGlyphs*  fGlyphs = nullptr;
+        sk_sp<sksg::Matrix<SkM44>>   fMatrixNode;
+        sk_sp<sksg::Color>           fFillColorNode,
+                                     fStrokeColorNode;
+        sk_sp<sksg::BlurImageFilter> fBlur;
+
+        float                        fAdvance, // used for transform anchor point calculations
+                                     fAscent;  // ^
+    };
+
+    void reshape();
+    void addFragment(Shaper::Fragment&, sksg::Group* container);
+    void buildDomainMaps(const Shaper::Result&);
+    std::vector<sk_sp<sksg::RenderNode>> buildGlyphCompNodes(Shaper::ShapedGlyphs&) const;
+
+    void pushPropsToFragment(const TextAnimator::ResolvedProps&, const FragmentRec&,
+                             const SkV2& frag_offset, const SkV2& grouping_alignment,
+                             const TextAnimator::DomainSpan*) const;
+
+    SkV2 fragmentAnchorPoint(const FragmentRec&, const SkV2&,
+                             const TextAnimator::DomainSpan*) const;
+    uint32_t shaperFlags() const;
+
+    SkM44 fragmentMatrix(const TextAnimator::ResolvedProps&, const FragmentRec&, const SkV2&) const;
+
+    const sk_sp<sksg::Group>                 fRoot;
+    const sk_sp<SkFontMgr>                   fFontMgr;
+    const sk_sp<CustomFont::GlyphCompMapper> fCustomGlyphMapper;
+    sk_sp<Logger>                            fLogger;
+    sk_sp<SkShapers::Factory>                fShapingFactory;
+    const AnchorPointGrouping                fAnchorPointGrouping;
+
+    std::vector<sk_sp<TextAnimator>>         fAnimators;
+    std::vector<FragmentRec>                 fFragments;
+    TextAnimator::DomainMaps                 fMaps;
+
+    // Helps detect external value changes.
+    struct TextValueTracker {
+        TextValue fCurrentValue;
+
+        bool hasChanged() const {
+            if (fCurrentValue != fPrevValue) {
+                fPrevValue = fCurrentValue;
+                return true;
+            }
+            return false;
+        }
+
+        const TextValue* operator->() const { return &fCurrentValue; }
+
+    private:
+        mutable TextValue fPrevValue;
+    };
+
+    TextValueTracker          fText;
+    Vec2Value                 fGroupingAlignment = {0,0};
+    float                     fTextShapingScale  = 1;     // size adjustment from auto-scaling
+
+    // Optional text path.
+    struct PathInfo;
+    std::unique_ptr<PathInfo> fPathInfo;
+
+    bool                      fHasBlurAnimator         : 1,
+                              fRequiresAnchorPoint     : 1,
+                              fRequiresLineAdjustments : 1;
+};
+
+} // namespace internal
+} // namespace skottie
+
+#endif // SkottieTextAdapter_DEFINED

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

@@ -0,0 +1,121 @@
+/*
+ * 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 SkottieTextAnimator_DEFINED
+#define SkottieTextAnimator_DEFINED
+
+#include "include/core/SkColor.h"
+#include "include/core/SkM44.h"
+#include "include/core/SkRefCnt.h"
+#include "modules/skottie/src/SkottieValue.h"
+
+#include <cstddef>
+#include <vector>
+
+namespace skjson {
+class ObjectValue;
+}
+
+namespace skottie {
+namespace internal {
+class AnimatablePropertyContainer;
+class AnimationBuilder;
+class RangeSelector;
+
+class TextAnimator final : public SkNVRefCnt<TextAnimator> {
+public:
+    static sk_sp<TextAnimator> Make(const skjson::ObjectValue*,
+                                    const AnimationBuilder*,
+                                    AnimatablePropertyContainer* acontainer);
+
+    // Direct mapping of AE properties.
+    struct AnimatedProps {
+        VectorValue position,
+                    scale          = { 100, 100, 100 };
+        ColorValue  fill_color,
+                    stroke_color;
+        // unlike pos/scale which are animated vectors, rotation is separated in each dimension.
+        SkV3        rotation       = { 0, 0, 0 };
+        Vec2Value   blur           = { 0, 0 },
+                line_spacing       = { 0, 0 };
+        ScalarValue opacity        = 100,
+                    fill_opacity   = 100,
+                    stroke_opacity = 100,
+                    tracking       = 0,
+                    stroke_width   = 0;
+    };
+
+    struct ResolvedProps {
+        SkV3      position = { 0, 0, 0 },
+                     scale = { 1, 1, 1 },
+                  rotation = { 0, 0, 0 };
+        float      opacity = 1,
+                  tracking = 0,
+              stroke_width = 0;
+        SkColor fill_color = SK_ColorTRANSPARENT,
+              stroke_color = SK_ColorTRANSPARENT;
+        SkV2          blur = { 0, 0 },
+              line_spacing = { 0, 0 };
+    };
+
+    struct AnimatedPropsModulator {
+        ResolvedProps props;     // accumulates properties across *all* animators
+        float         coverage;  // accumulates range selector coverage for a given animator
+    };
+    using ModulatorBuffer = std::vector<AnimatedPropsModulator>;
+
+    // Domain maps describe how a given index domain (words, lines, etc) relates
+    // to the full fragment index range.
+    //
+    // Each domain[i] represents a [domain[i].fOffset.. domain[i].fOffset+domain[i].fCount-1]
+    // fragment subset.
+    struct DomainSpan {
+        size_t fOffset,
+               fCount;
+        float  fAdvance, // cumulative advance for all fragments in span
+               fAscent;  // max ascent for all fragments in span
+    };
+    using DomainMap = std::vector<DomainSpan>;
+
+    struct DomainMaps {
+        DomainMap fNonWhitespaceMap,
+                  fWordsMap,
+                  fLinesMap;
+    };
+
+    void modulateProps(const DomainMaps&, ModulatorBuffer&) const;
+
+    bool hasBlur() const { return fHasBlur; }
+
+    bool requiresAnchorPoint()     const { return fRequiresAnchorPoint;     }
+    bool requiresLineAdjustments() const { return fRequiresLineAdjustments; }
+
+private:
+    TextAnimator(std::vector<sk_sp<RangeSelector>>&&,
+                 const skjson::ObjectValue&,
+                 const AnimationBuilder*,
+                 AnimatablePropertyContainer*);
+
+    ResolvedProps modulateProps(const ResolvedProps&, float amount) const;
+
+    const std::vector<sk_sp<RangeSelector>> fSelectors;
+
+    AnimatedProps fTextProps;
+    bool          fHasFillColor            : 1,
+                  fHasStrokeColor          : 1,
+                  fHasFillOpacity          : 1,
+                  fHasStrokeOpacity        : 1,
+                  fHasOpacity              : 1,
+                  fHasBlur                 : 1,
+                  fRequiresAnchorPoint     : 1, // animator sensitive to transform origin?
+                  fRequiresLineAdjustments : 1; // animator effects line-wide fragment adjustments
+};
+
+} // namespace internal
+} // namespace skottie
+
+#endif // SkottieTextAnimator_DEFINED