@shopify/react-native-skia 0.1.171 → 0.1.173

package/cpp/rnskia/dom/nodes/JsiBlendNode.h

@@ -2,74 +2,55 @@
 
 #include "JsiDomDeclarationNode.h"
 
+#include <algorithm>
 #include <memory>
 #include <string>
 
 namespace RNSkia {
 
-class JsiBlendNode : public JsiBaseDomDeclarationNode,
+class JsiBlendNode : public JsiDomDeclarationNode,
                      public JsiDomNodeCtor<JsiBlendNode> {
 public:
   explicit JsiBlendNode(std::shared_ptr<RNSkPlatformContext> context)
-      : JsiBaseDomDeclarationNode(context, "skBlend") {}
+      : JsiDomDeclarationNode(context, "skBlend",
+                              DeclarationType::ImageFilter) {}
 
-protected:
-  void decorate(DrawingContext *context) override {
-    if (context->isChanged() || getPropsContainer()->isChanged()) {
-      auto children = getChildren();
-      auto childSize = children.size();
-
-      // No need to do anything if there are no children here
-      if (childSize == 0) {
-        return;
-      }
-
-      // Blend mode
-      auto blendMode = *_blendProp->getDerivedValue();
-
-      // Find the latest child and check if it is a shader or image filter
-      bool asShader = std::dynamic_pointer_cast<JsiBaseShaderNode>(
-                          children.at(childSize - 1)) != nullptr;
-
-      // Traverse children in reverse
-      sk_sp<SkShader> innerShader;
-      sk_sp<SkImageFilter> innerImageFilter;
-
-      for (size_t i = childSize - 1; i != (std::size_t)-1; i--) {
-        auto child = children.at(i);
-        auto maybeShader = std::dynamic_pointer_cast<JsiBaseShaderNode>(child);
-        auto maybeImageFilter =
-            std::dynamic_pointer_cast<JsiBaseImageFilterNode>(child);
-
-        if (maybeShader) {
-          sk_sp<SkShader> outer = maybeShader->getCurrent();
-          if (innerShader != nullptr) {
-            innerShader = SkShaders::Blend(blendMode, outer, innerShader);
-          } else {
-            innerShader = outer;
-          }
-        } else if (maybeImageFilter) {
-          sk_sp<SkImageFilter> outer = maybeImageFilter->getCurrent();
-          if (outer != nullptr) {
-            innerImageFilter = SkImageFilters::Blend(blendMode, outer,
-                                                     innerImageFilter, nullptr);
-          } else {
-            innerImageFilter = outer;
-          }
-        }
-      }
-
-      // Materialize
-      if (asShader) {
-        context->getMutablePaint()->setShader(innerShader);
-      } else {
-        context->getMutablePaint()->setImageFilter(innerImageFilter);
-      }
+  void decorate(DeclarationContext *context) override {
+
+    // No need to do anything if there are no children here
+    if (getChildren().size() == 0) {
+      return;
+    }
+
+    decorateChildren(context);
+
+    // Blend mode
+    auto blendMode = *_blendProp->getDerivedValue();
+
+    // Shader
+    auto shader = context->getShaders()->popAsOne(
+        [blendMode](sk_sp<SkShader> inner, sk_sp<SkShader> outer) {
+          return SkShaders::Blend(blendMode, outer, inner);
+        });
+
+    if (shader != nullptr) {
+      context->getShaders()->push(shader);
+    }
+
+    auto imageFilter =
+        context->getImageFilters()->Declaration<sk_sp<SkImageFilter>>::popAsOne(
+            [blendMode](sk_sp<SkImageFilter> inner,
+                        sk_sp<SkImageFilter> outer) {
+              return SkImageFilters::Blend(blendMode, outer, inner);
+            });
+    if (imageFilter != nullptr) {
+      context->getImageFilters()->push(imageFilter);
     }
   }
 
+protected:
   void defineProperties(NodePropsContainer *container) override {
-    JsiBaseDomDeclarationNode::defineProperties(container);
+    JsiDomDeclarationNode::defineProperties(container);
     _blendProp = container->defineProperty<BlendModeProp>("mode");
     _blendProp->require();
   }
@@ -78,7 +59,7 @@ protected:
    Validates that only declaration nodes can be children
    */
   void addChild(std::shared_ptr<JsiDomNode> child) override {
-    JsiBaseDomDeclarationNode::addChild(child);
+    JsiDomDeclarationNode::addChild(child);
     // Verify declaration of either shader or image filter
     verifyChild(child);
   }
@@ -88,15 +69,18 @@ protected:
    */
   void insertChildBefore(std::shared_ptr<JsiDomNode> child,
                          std::shared_ptr<JsiDomNode> before) override {
-    JsiBaseDomDeclarationNode::insertChildBefore(child, before);
+    JsiDomDeclarationNode::insertChildBefore(child, before);
     // Verify declaration of either shader or image filter
     verifyChild(child);
   }
 
 private:
   void verifyChild(std::shared_ptr<JsiDomNode> child) {
-    if (std::dynamic_pointer_cast<JsiBaseShaderNode>(child) == nullptr &&
-        std::dynamic_pointer_cast<JsiBaseImageFilterNode>(child) == nullptr) {
+    if (child->getNodeClass() != NodeClass::DeclarationNode ||
+        (std::static_pointer_cast<JsiDomDeclarationNode>(child)
+                 ->getDeclarationType() != DeclarationType::Shader &&
+         std::static_pointer_cast<JsiDomDeclarationNode>(child)
+                 ->getDeclarationType() != DeclarationType::ImageFilter)) {
       // We'll raise an error when other children are added.
       std::runtime_error("Blend nodes only supports either shaders or image "
                          "filters as children, got " +

package/cpp/rnskia/dom/nodes/JsiBlurMaskNode.h

@@ -16,33 +16,32 @@
 
 namespace RNSkia {
 
-class JsiBlurMaskNode : public JsiBaseDomDeclarationNode,
+class JsiBlurMaskNode : public JsiDomDeclarationNode,
                         public JsiDomNodeCtor<JsiBlurMaskNode> {
 public:
   explicit JsiBlurMaskNode(std::shared_ptr<RNSkPlatformContext> context)
-      : JsiBaseDomDeclarationNode(context, "skBlurMaskFilter") {}
+      : JsiDomDeclarationNode(context, "skBlurMaskFilter",
+                              DeclarationType::MaskFilter) {}
 
-protected:
-  void decorate(DrawingContext *context) override {
-    if (context->isChanged() || getPropsContainer()->isChanged()) {
+  void decorate(DeclarationContext *context) override {
 
-      bool respectCTM =
-          _respectCTM->isSet() ? _respectCTM->value().getAsBool() : true;
-      SkBlurStyle style = SkBlurStyle::kNormal_SkBlurStyle;
-      if (_style->isSet()) {
-        style = getBlurStyleFromString(_style->value().getAsString());
-      }
+    bool respectCTM =
+        _respectCTM->isSet() ? _respectCTM->value().getAsBool() : true;
+    SkBlurStyle style = SkBlurStyle::kNormal_SkBlurStyle;
+    if (_style->isSet()) {
+      style = getBlurStyleFromString(_style->value().getAsString());
+    }
 
-      auto filter = SkMaskFilter::MakeBlur(style, _blur->value().getAsNumber(),
-                                           respectCTM);
+    auto filter =
+        SkMaskFilter::MakeBlur(style, _blur->value().getAsNumber(), respectCTM);
 
-      // Set the mask filter
-      context->getMutablePaint()->setMaskFilter(filter);
-    }
+    // Set the mask filter
+    context->getMaskFilters()->push(filter);
   }
 
+protected:
   void defineProperties(NodePropsContainer *container) override {
-    JsiBaseDomDeclarationNode::defineProperties(container);
+    JsiDomDeclarationNode::defineProperties(container);
 
     _style = container->defineProperty<NodeProp>("style");
     _respectCTM = container->defineProperty<NodeProp>("respectCTM");

package/cpp/rnskia/dom/nodes/JsiBoxShadowNode.h

@@ -7,21 +7,22 @@
 
 namespace RNSkia {
 
-class JsiBoxShadowNode : public JsiBaseDomDeclarationNode,
+class JsiBoxShadowNode : public JsiDomDeclarationNode,
                          public JsiDomNodeCtor<JsiBoxShadowNode> {
 public:
   explicit JsiBoxShadowNode(std::shared_ptr<RNSkPlatformContext> context)
-      : JsiBaseDomDeclarationNode(context, "skBoxShadow") {}
+      : JsiDomDeclarationNode(context, "skBoxShadow",
+                              DeclarationType::Unknown) {}
 
   BoxShadowProps *getBoxShadowProps() { return _boxShadowProps; }
 
-protected:
-  void decorate(DrawingContext *context) override {
+  void decorate(DeclarationContext *context) override {
     // Do nothing, we are just a container for properties
   }
 
+protected:
   void defineProperties(NodePropsContainer *container) override {
-    JsiBaseDomDeclarationNode::defineProperties(container);
+    JsiDomDeclarationNode::defineProperties(container);
     _boxShadowProps = container->defineProperty<BoxShadowProps>();
   }
 

package/cpp/rnskia/dom/nodes/JsiColorFilterNodes.h

@@ -17,39 +17,20 @@
 
 namespace RNSkia {
 
-class JsiBaseColorFilterNode
-    : public JsiDomDeclarationNode<JsiBaseColorFilterNode,
-                                   sk_sp<SkColorFilter>> {
+class JsiBaseColorFilterNode : public JsiDomDeclarationNode {
 public:
   JsiBaseColorFilterNode(std::shared_ptr<RNSkPlatformContext> context,
                          const char *type)
-      : JsiDomDeclarationNode<JsiBaseColorFilterNode, sk_sp<SkColorFilter>>(
-            context, type) {}
+      : JsiDomDeclarationNode(context, type, DeclarationType::ColorFilter) {}
 
 protected:
-  sk_sp<SkColorFilter> resolve(std::shared_ptr<JsiDomNode> child) override {
-    auto ptr = std::dynamic_pointer_cast<JsiBaseColorFilterNode>(child);
-    if (ptr) {
-      return ptr->getCurrent();
-    }
-    return nullptr;
-  }
-
-  void setColorFilter(DrawingContext *context, sk_sp<SkColorFilter> f) {
-    set(context, f);
-  }
-
-  void set(DrawingContext *context, sk_sp<SkColorFilter> ColorFilter) override {
-    auto paint = context->getMutablePaint();
-    if (paint->getColorFilter() != nullptr &&
-        paint->getColorFilter() != getCurrent().get()) {
-      paint->setColorFilter(
-          SkColorFilters::Compose(ColorFilter, paint->refColorFilter()));
-    } else {
-      paint->setColorFilter(ColorFilter);
-    }
-
-    setCurrent(ColorFilter);
+  void composeAndPush(DeclarationContext *context, sk_sp<SkColorFilter> cf1) {
+    context->save();
+    decorateChildren(context);
+    auto cf2 = context->getColorFilters()->popAsOne();
+    context->restore();
+    auto cf = cf2 ? SkColorFilters::Compose(cf1, cf2) : cf1;
+    context->getColorFilters()->push(cf);
   }
 };
 
@@ -61,22 +42,20 @@ public:
       std::shared_ptr<RNSkPlatformContext> context)
       : JsiBaseColorFilterNode(context, "skMatrixColorFilter") {}
 
-protected:
-  void decorate(DrawingContext *context) override {
-    if (isChanged(context)) {
-      auto array = _matrixProp->value().getAsArray();
-      float matrix[20];
-      for (int i = 0; i < 20; i++) {
-        if (array.size() > i) {
-          matrix[i] = array[i].getAsNumber();
-        }
+  void decorate(DeclarationContext *context) override {
+    auto array = _matrixProp->value().getAsArray();
+    float matrix[20];
+    for (int i = 0; i < 20; i++) {
+      if (array.size() > i) {
+        matrix[i] = array[i].getAsNumber();
       }
-      setColorFilter(context, SkColorFilters::Matrix(matrix));
     }
+    composeAndPush(context, SkColorFilters::Matrix(matrix));
   }
 
+protected:
   void defineProperties(NodePropsContainer *container) override {
-    JsiBaseDomDeclarationNode::defineProperties(container);
+    JsiDomDeclarationNode::defineProperties(container);
     _matrixProp = container->defineProperty<NodeProp>("matrix");
     _matrixProp->require();
   }
@@ -91,17 +70,15 @@ public:
   explicit JsiBlendColorFilterNode(std::shared_ptr<RNSkPlatformContext> context)
       : JsiBaseColorFilterNode(context, "skBlendColorFilter") {}
 
-protected:
-  void decorate(DrawingContext *context) override {
-    if (isChanged(context)) {
-      setColorFilter(context,
-                     SkColorFilters::Blend(*_colorProp->getDerivedValue(),
-                                           *_blendModeProp->getDerivedValue()));
-    }
+  void decorate(DeclarationContext *context) override {
+    auto color = _colorProp->getDerivedValue();
+    auto mode = _blendModeProp->getDerivedValue();
+    composeAndPush(context, SkColorFilters::Blend(*color, *mode));
   }
 
+protected:
   void defineProperties(NodePropsContainer *container) override {
-    JsiBaseDomDeclarationNode::defineProperties(container);
+    JsiDomDeclarationNode::defineProperties(container);
     _blendModeProp = container->defineProperty<BlendModeProp>("mode");
     _colorProp = container->defineProperty<ColorProp>("color");
 
@@ -122,11 +99,8 @@ public:
       std::shared_ptr<RNSkPlatformContext> context)
       : JsiBaseColorFilterNode(context, "skLinearToSRGBGammaColorFilter") {}
 
-protected:
-  void decorate(DrawingContext *context) override {
-    if (isChanged(context)) {
-      setColorFilter(context, SkColorFilters::LinearToSRGBGamma());
-    }
+  void decorate(DeclarationContext *context) override {
+    composeAndPush(context, SkColorFilters::LinearToSRGBGamma());
   }
 };
 
@@ -138,11 +112,8 @@ public:
       std::shared_ptr<RNSkPlatformContext> context)
       : JsiBaseColorFilterNode(context, "skSRGBToLinearGammaColorFilter") {}
 
-protected:
-  void decorate(DrawingContext *context) override {
-    if (isChanged(context)) {
-      setColorFilter(context, SkColorFilters::SRGBToLinearGamma());
-    }
+  void decorate(DeclarationContext *context) override {
+    composeAndPush(context, SkColorFilters::SRGBToLinearGamma());
   }
 };
 
@@ -152,11 +123,8 @@ public:
   explicit JsiLumaColorFilterNode(std::shared_ptr<RNSkPlatformContext> context)
       : JsiBaseColorFilterNode(context, "skLumaColorFilter") {}
 
-protected:
-  void decorate(DrawingContext *context) override {
-    if (isChanged(context)) {
-      setColorFilter(context, SkLumaColorFilter::Make());
-    }
+  void decorate(DeclarationContext *context) override {
+    composeAndPush(context, SkLumaColorFilter::Make());
   }
 };
 
@@ -166,17 +134,25 @@ public:
   explicit JsiLerpColorFilterNode(std::shared_ptr<RNSkPlatformContext> context)
       : JsiBaseColorFilterNode(context, "skLerpColorFilter") {}
 
-protected:
-  void decorate(DrawingContext *context) override {
-    if (isChanged(context)) {
-      setColorFilter(context,
-                     SkColorFilters::Lerp(_tProp->value().getAsNumber(),
-                                          requireChild(0), requireChild(1)));
+  void decorate(DeclarationContext *context) override {
+    context->save();
+    decorateChildren(context);
+    auto second = context->getColorFilters()->pop();
+    auto first = context->getColorFilters()->pop();
+    context->restore();
+
+    if (first == nullptr || second == nullptr) {
+      throw std::runtime_error(
+          "LerpColorFilterNode: missing two color filters as children");
     }
+
+    auto t = _tProp->value().getAsNumber();
+    context->getColorFilters()->push(SkColorFilters::Lerp(t, first, second));
   }
 
+protected:
   void defineProperties(NodePropsContainer *container) override {
-    JsiBaseDomDeclarationNode::defineProperties(container);
+    JsiDomDeclarationNode::defineProperties(container);
     _tProp = container->defineProperty<NodeProp>("t");
     _tProp->require();
   }

package/cpp/rnskia/dom/nodes/JsiCustomDrawingNode.h

@@ -7,6 +7,7 @@
 #include "JsiSkPaint.h"
 
 #include <memory>
+#include <mutex>
 #include <utility>
 
 namespace RNSkia {
@@ -76,7 +77,11 @@ protected:
                    static_cast<const jsi::Value *>(args.data()), 1);
 
           auto picture = recorder.finishRecordingAsPicture();
-          this->_drawingProp->setPicture(picture);
+          {
+            // Lock access to the picture property's setter
+            std::lock_guard<std::mutex> lock(_pictureLock);
+            this->_drawingProp->setPicture(picture);
+          }
 
           // Ask view to redraw itself
           _inRedrawCycle = true;
@@ -86,6 +91,7 @@ protected:
     }
 
     if (_drawingProp->isSet()) {
+      std::lock_guard<std::mutex> lock(_pictureLock);
       context->getCanvas()->drawPicture(_drawingProp->getDerivedValue());
       _inRedrawCycle = false;
     }
@@ -115,6 +121,7 @@ private:
   std::shared_ptr<JsiSkCanvas> _jsiCanvas;
 
   std::atomic<bool> _inRedrawCycle = {false};
+  std::mutex _pictureLock;
 };
 
 } // namespace RNSkia

package/cpp/rnskia/dom/nodes/JsiGroupNode.h

@@ -15,7 +15,7 @@ public:
 
   void renderNode(DrawingContext *context) override {
     for (auto &child : getChildren()) {
-      if (child->getNodeClass() == JsiDomNodeClass::RenderNode) {
+      if (child->getNodeClass() == NodeClass::RenderNode) {
         std::static_pointer_cast<JsiDomRenderNode>(child)->render(context);
       }
     }