@shopify/react-native-skia 0.1.171 → 0.1.173

package/cpp/rnskia/dom/base/JsiDomDrawingNode.h

@@ -16,7 +16,7 @@ public:
 protected:
   void defineProperties(NodePropsContainer *container) override {
     JsiDomRenderNode::defineProperties(container);
-    container->defineProperty<PaintProp>();
+    _paintProp = container->defineProperty<PaintDrawingContextProp>();
   }
 
   /**
@@ -28,23 +28,42 @@ protected:
 #if SKIA_DOM_DEBUG
     printDebugInfo("Begin Draw", 1);
 #endif
-
-#if SKIA_DOM_DEBUG
-    printDebugInfo(context->getDebugDescription(), 2);
-#endif
-    draw(context);
+    // Save paint if the paint property is set
+    if (_paintProp->isSet()) {
+      draw(_paintProp->getUnsafeDerivedValue().get());
+    } else {
+      // Call abstract draw method
+      draw(context);
+    }
 
     // Draw once more for each child paint node
+    auto declarationCtx = context->getDeclarationContext();
     for (auto &child : getChildren()) {
-      auto ptr = std::dynamic_pointer_cast<JsiPaintNode>(child);
-      if (ptr != nullptr) {
-        draw(ptr->getDrawingContext());
+      if (child->getNodeClass() == NodeClass::DeclarationNode &&
+          std::static_pointer_cast<JsiDomDeclarationNode>(child)
+                  ->getDeclarationType() == DeclarationType::Paint) {
+        auto paintNode = std::static_pointer_cast<JsiPaintNode>(child);
+        // Draw once again with the paint
+        declarationCtx->save();
+        paintNode->decorate(declarationCtx);
+        auto paint = declarationCtx->getPaints()->pop();
+        declarationCtx->restore();
+
+        // FIXME: Can we avoid creating a new drawing context here each time?
+        auto localContext =
+            std::make_shared<DrawingContext>(std::shared_ptr<SkPaint>(paint));
+        localContext->setCanvas(context->getCanvas());
+        draw(localContext.get());
       }
     }
+
 #if SKIA_DOM_DEBUG
     printDebugInfo("End Draw", 1);
 #endif
   }
+
+private:
+  PaintDrawingContextProp *_paintProp;
 };
 
 } // namespace RNSkia

package/cpp/rnskia/dom/base/JsiDomNode.h

@@ -33,7 +33,7 @@ static std::atomic<size_t> NodeIdent = 1000;
 typedef enum {
   RenderNode = 1,
   DeclarationNode = 2,
-} JsiDomNodeClass;
+} NodeClass;
 
 /**
  Implements an abstract base class for nodes in the Skia Reconciler. This node
@@ -46,8 +46,10 @@ public:
    Contructor. Takes as parameters the values comming from the JS world that
    initialized the class.
    */
-  JsiDomNode(std::shared_ptr<RNSkPlatformContext> context, const char *type)
-      : _type(type), _context(context), _nodeId(NodeIdent++), JsiHostObject() {}
+  JsiDomNode(std::shared_ptr<RNSkPlatformContext> context, const char *type,
+             NodeClass nodeClass)
+      : _type(type), _context(context), _nodeClass(nodeClass),
+        _nodeId(NodeIdent++), JsiHostObject() {}
 
   /**
    Called when creating the node, resolves properties from the node constructor.
@@ -183,7 +185,7 @@ public:
    Returns the class of node so that we can do loops faster without
    having to check using runtime type information
    */
-  virtual JsiDomNodeClass getNodeClass() = 0;
+  NodeClass getNodeClass() { return _nodeClass; }
 
   /**
    Updates any pending property changes in all nodes and child nodes. This
@@ -205,11 +207,6 @@ public:
         op();
       }
 
-      // If there are any ops here we should invalidate the cached context
-      if (_queuedNodeOps.size() > 0) {
-        invalidateContext();
-      }
-
       _queuedNodeOps.clear();
     }
 
@@ -268,7 +265,21 @@ public:
     }
   }
 
+  /**
+  Empty implementation of the decorate context method
+  */
+  virtual void decorateContext(DeclarationContext *context) {
+    // Empty implementation
+  }
+
 protected:
+  /**
+   Adds an operation that will be executed when the render cycle is finished.
+   */
+  void enqueAsynOperation(std::function<void()> &&fp) {
+    std::lock_guard<std::mutex> lock(_childrenLock);
+    _queuedNodeOps.push_back(std::move(fp));
+  }
   /**
    Override to define properties in node implementations
    */
@@ -298,7 +309,8 @@ protected:
     if (_propsContainer == nullptr) {
 
       // Initialize properties container
-      _propsContainer = std::make_shared<NodePropsContainer>(getType());
+      _propsContainer = std::make_shared<NodePropsContainer>(
+          getType(), [=](BaseNodeProp *p) { onPropertyChanged(p); });
 
       // Ask sub classes to define their properties
       defineProperties(_propsContainer.get());
@@ -320,7 +332,8 @@ protected:
     if (_propsContainer == nullptr) {
 
       // Initialize properties container
-      _propsContainer = std::make_shared<NodePropsContainer>(getType());
+      _propsContainer = std::make_shared<NodePropsContainer>(
+          getType(), [=](BaseNodeProp *p) { onPropertyChanged(p); });
 
       // Ask sub classes to define their properties
       defineProperties(_propsContainer.get());
@@ -335,6 +348,11 @@ protected:
     return _children;
   }
 
+  /**
+   Override to be notified when a node property has changed
+   */
+  virtual void onPropertyChanged(BaseNodeProp *prop) {}
+
   /**
    Adds a child node to the array of children for this node
    */
@@ -343,8 +361,7 @@ protected:
     printDebugInfo("JS:addChild(childId: " + std::to_string(child->_nodeId) +
                    ")");
 #endif
-    std::lock_guard<std::mutex> lock(_childrenLock);
-    _queuedNodeOps.push_back([child, this]() {
+    enqueAsynOperation([child, this]() {
       _children.push_back(child);
       child->setParent(this);
     });
@@ -361,8 +378,7 @@ protected:
         "JS:insertChildBefore(childId: " + std::to_string(child->_nodeId) +
         ", beforeId: " + std::to_string(before->_nodeId) + ")");
 #endif
-    std::lock_guard<std::mutex> lock(_childrenLock);
-    _queuedNodeOps.push_back([child, before, this]() {
+    enqueAsynOperation([child, before, this]() {
       auto position = std::find(_children.begin(), _children.end(), before);
       _children.insert(position, child);
       child->setParent(this);
@@ -378,8 +394,7 @@ protected:
     printDebugInfo("JS:removeChild(childId: " + std::to_string(child->_nodeId) +
                    ")");
 #endif
-    std::lock_guard<std::mutex> lock(_childrenLock);
-    _queuedNodeOps.push_back([child, this]() {
+    enqueAsynOperation([child, this]() {
       // Delete child itself
       _children.erase(
           std::remove_if(_children.begin(), _children.end(),
@@ -429,6 +444,18 @@ protected:
   */
   JsiDomNode *getParent() { return _parent; }
 
+  /**
+  Loops through all declaration nodes and gives each one of them the
+  opportunity to decorate the context.
+  */
+  void decorateChildren(DeclarationContext *context) {
+    for (auto &child : getChildren()) {
+      // All JsiDomNodes has the decorateContext method - but only the
+      // JsiDomDeclarationNode is actually doing stuff inside this method.
+      child->decorateContext(context);
+    }
+  }
+
 private:
   const char *_type;
   std::shared_ptr<RNSkPlatformContext> _context;
@@ -448,6 +475,8 @@ private:
   std::vector<std::function<void()>> _queuedNodeOps;
 
   JsiDomNode *_parent = nullptr;
+
+  NodeClass _nodeClass;
 };
 
 } // namespace RNSkia

package/cpp/rnskia/dom/base/JsiDomRenderNode.h

@@ -15,6 +15,7 @@
 
 #include <memory>
 #include <string>
+#include <vector>
 
 namespace RNSkia {
 
@@ -22,17 +23,19 @@ class JsiDomRenderNode : public JsiDomNode {
 public:
   JsiDomRenderNode(std::shared_ptr<RNSkPlatformContext> context,
                    const char *type)
-      : JsiDomNode(context, type) {}
+      : JsiDomNode(context, type, NodeClass::RenderNode) {}
 
   void render(DrawingContext *context) {
 #if SKIA_DOM_DEBUG
     printDebugInfo("Begin Render");
 #endif
 
-    // Ensure we have a local drawing context inheriting from the parent context
-    if (_localContext == nullptr) {
-      _localContext = context->inheritContext(getType());
-    }
+    auto parentPaint = context->getPaint();
+    auto cache =
+        _paintCache.parent == parentPaint ? _paintCache.child : nullptr;
+
+    auto shouldRestore =
+        context->saveAndConcat(_paintProps, getChildren(), cache);
 
     auto shouldTransform = _matrixProp->isSet() || _transformProp->isSet();
     auto shouldSave =
@@ -43,37 +46,36 @@ public:
       // Save canvas state
       if (_layerProp->isSet()) {
         if (_layerProp->isBool()) {
-#if SKIA_DOM_DEBUG
+#if SKIA_DOM_DEBUG_VERBOSE
           printDebugInfo("canvas->saveLayer()");
 #endif
-          _localContext->getCanvas()->saveLayer(
+          context->getCanvas()->saveLayer(
               SkCanvas::SaveLayerRec(nullptr, nullptr, nullptr, 0));
         } else {
-#if SKIA_DOM_DEBUG
+#if SKIA_DOM_DEBUG_VERBOSE
           printDebugInfo("canvas->saveLayer(paint)");
 #endif
-          _localContext->getCanvas()->saveLayer(SkCanvas::SaveLayerRec(
+          context->getCanvas()->saveLayer(SkCanvas::SaveLayerRec(
               nullptr, _layerProp->getDerivedValue().get(), nullptr, 0));
         }
       } else {
-#if SKIA_DOM_DEBUG
+#if SKIA_DOM_DEBUG_VERBOSE
         printDebugInfo("canvas->save()");
 #endif
-        _localContext->getCanvas()->save();
+        context->getCanvas()->save();
       }
 
       if (_originProp->isSet()) {
-#if SKIA_DOM_DEBUG
+#if SKIA_DOM_DEBUG_VERBOSE
         printDebugInfo("canvas->translate(origin)");
 #endif
         // Handle origin
-        _localContext->getCanvas()->translate(
-            _originProp->getDerivedValue()->x(),
-            _originProp->getDerivedValue()->y());
+        context->getCanvas()->translate(_originProp->getDerivedValue()->x(),
+                                        _originProp->getDerivedValue()->y());
       }
 
       if (shouldTransform) {
-#if SKIA_DOM_DEBUG
+#if SKIA_DOM_DEBUG_VERBOSE
         printDebugInfo(
             "canvas->concat(" +
             std::string(_matrixProp->isSet() ? "matrix" : "transform") +
@@ -83,43 +85,40 @@ public:
                                            : _transformProp->getDerivedValue();
 
         // Concat canvas' matrix with our matrix
-        _localContext->getCanvas()->concat(*matrix);
+        context->getCanvas()->concat(*matrix);
       }
 
       // Clipping
       if (_clipProp->isSet()) {
         auto invert = _invertClip->isSet() && _invertClip->value().getAsBool();
-        clip(context, _localContext->getCanvas(), invert);
+        clip(context, context->getCanvas(), invert);
       }
 
       if (_originProp->isSet()) {
-#if SKIA_DOM_DEBUG
+#if SKIA_DOM_DEBUG_VERBOSE
         printDebugInfo("canvas->translate(-origin)");
 #endif
         // Handle origin
-        _localContext->getCanvas()->translate(
-            -_originProp->getDerivedValue()->x(),
-            -_originProp->getDerivedValue()->y());
+        context->getCanvas()->translate(-_originProp->getDerivedValue()->x(),
+                                        -_originProp->getDerivedValue()->y());
       }
     }
 
-    // Let any local paint props decorate the context
-    _paintProps->decorate(_localContext.get());
-
-    // Now let's make sure the local context is resolved correctly - ie. that
-    // all children of type declaration (except paint) is given the opportunity
-    // to decorate the context.
-    materializeDeclarations();
-
     // Render the node
-    renderNode(_localContext.get());
+    renderNode(context);
 
     // Restore if needed
     if (shouldSave) {
-#if SKIA_DOM_DEBUG
+#if SKIA_DOM_DEBUG_VERBOSE
       printDebugInfo("canvas->restore()");
 #endif
-      _localContext->getCanvas()->restore();
+      context->getCanvas()->restore();
+    }
+
+    if (shouldRestore) {
+      _paintCache.parent = parentPaint;
+      _paintCache.child = context->getPaint();
+      context->restore();
     }
 
 #if SKIA_DOM_DEBUG
@@ -131,36 +130,22 @@ public:
    Override reset (last thing that happens in the render cycle) to also reset
    the changed flag on the local drawing context if necessary.
    */
-  void resetPendingChanges() override {
-    JsiDomNode::resetPendingChanges();
-    _localContext->resetChangedFlag();
-  }
+  void resetPendingChanges() override { JsiDomNode::resetPendingChanges(); }
 
   /**
    Signal from the JS side that the node is removed from the dom.
    */
-  void dispose() override {
-    JsiDomNode::dispose();
-
-    // Clear local drawing context
-    if (_localContext != nullptr) {
-      _localContext->dispose();
-      _localContext = nullptr;
-    }
-  }
-
-  JsiDomNodeClass getNodeClass() override {
-    return JsiDomNodeClass::RenderNode;
-  }
+  void dispose() override { JsiDomNode::dispose(); }
 
 protected:
   /**
    Invalidates and marks then context as changed.
    */
   void invalidateContext() override {
-    if (_localContext != nullptr) {
-      _localContext->markAsChanged();
-    }
+    enqueAsynOperation([=]() {
+      _paintCache.parent = nullptr;
+      _paintCache.child = nullptr;
+    });
   }
 
   /**
@@ -185,6 +170,43 @@ protected:
     _layerProp = container->defineProperty<LayerProp>("layer");
   }
 
+  /**
+   Validates that only declaration nodes can be children
+   */
+  void addChild(std::shared_ptr<JsiDomNode> child) override {
+    JsiDomNode::addChild(child);
+    _paintCache.parent = nullptr;
+    _paintCache.child = nullptr;
+  }
+
+  /**
+   Validates that only declaration nodes can be children
+   */
+  void insertChildBefore(std::shared_ptr<JsiDomNode> child,
+                         std::shared_ptr<JsiDomNode> before) override {
+    JsiDomNode::insertChildBefore(child, before);
+    _paintCache.parent = nullptr;
+    _paintCache.child = nullptr;
+  }
+
+  /**
+   A property changed
+   */
+  void onPropertyChanged(BaseNodeProp *prop) override {
+    static std::vector<const char *> paintProps = {
+        JsiPropId::get("color"),      JsiPropId::get("strokeWidth"),
+        JsiPropId::get("blendMode"),  JsiPropId::get("strokeCap"),
+        JsiPropId::get("strokeJoin"), JsiPropId::get("strokeMiter"),
+        JsiPropId::get("style"),      JsiPropId::get("antiAlias"),
+        JsiPropId::get("opacity")};
+
+    // We'll invalidate paint if a prop change happened in a paint property
+    if (std::find(paintProps.begin(), paintProps.end(), prop->getName()) !=
+        paintProps.end()) {
+      invalidateContext();
+    }
+  }
+
 private:
   /**
    Clips the canvas depending on the clip property
@@ -209,18 +231,12 @@ private:
     }
   }
 
-  /**
-   Loops through all declaration nodes and gives each one of them the
-   opportunity to decorate the context
-   */
-  void materializeDeclarations() {
-    for (auto &child : getChildren()) {
-      if (child->getNodeClass() == JsiDomNodeClass::DeclarationNode) {
-        std::static_pointer_cast<JsiBaseDomDeclarationNode>(child)
-            ->decorateContext(_localContext.get());
-      }
-    }
-  }
+  struct PaintCache {
+    std::shared_ptr<SkPaint> parent;
+    std::shared_ptr<SkPaint> child;
+  };
+
+  PaintCache _paintCache;
 
   PointProp *_originProp;
   MatrixProp *_matrixProp;
@@ -229,8 +245,6 @@ private:
   ClipProp *_clipProp;
   LayerProp *_layerProp;
   PaintProps *_paintProps;
-
-  std::shared_ptr<DrawingContext> _localContext;
 };
 
 } // namespace RNSkia

package/cpp/rnskia/dom/base/NodeProp.h

@@ -5,6 +5,7 @@
 
 #include <chrono>
 #include <memory>
+#include <mutex>
 #include <string>
 
 namespace RNSkia {
@@ -19,8 +20,9 @@ public:
   /**
    Constructs a new optional dom node properrty
    */
-  explicit NodeProp(const std::string &name)
-      : _name(JsiPropId::get(name)), BaseNodeProp() {}
+  explicit NodeProp(const std::string &name,
+                    const std::function<void(BaseNodeProp *)> &onChange)
+      : _name(JsiPropId::get(name)), _onChange(onChange), BaseNodeProp() {}
 
   /**
    Reads JS value and swaps out with a new value
@@ -44,6 +46,9 @@ public:
         _buffer->setCurrent(runtime, read(runtime, _name, this));
       }
       _hasNewValue = *_buffer.get() != *_value.get();
+      if (_hasNewValue && _onChange != nullptr) {
+        _onChange(this);
+      }
     }
   }
 
@@ -62,6 +67,9 @@ public:
     // This is almost always a change - meaning a swap is
     // cheaper than comparing for equality.
     _hasNewValue = true;
+    if (_onChange != nullptr) {
+      _onChange(this);
+    }
   }
 
   /**
@@ -119,6 +127,8 @@ public:
 private:
   PropId _name;
 
+  std::function<void(BaseNodeProp *)> _onChange;
+
   std::shared_ptr<JsiValue> _value;
   std::shared_ptr<JsiValue> _buffer;
   std::atomic<bool> _isChanged = {false};

package/cpp/rnskia/dom/base/NodePropsContainer.h

@@ -20,11 +20,12 @@ namespace RNSkia {
 class NodePropsContainer {
 public:
   /**
-   Constructor. Pass the runtime and the JS object representing the properties,
-   and a function that will be called when any property was changed from within
-   this class as a result of a Skia value change.
+   Constructor for the node prop container
    */
-  explicit NodePropsContainer(PropId componentType) : _type(componentType) {}
+  explicit NodePropsContainer(
+      PropId componentType,
+      const std::function<void(BaseNodeProp *)> &onPropChanged)
+      : _onPropChanged(onPropChanged), _type(componentType) {}
 
   /**
    Returns true if there are any changes in the props container in the current
@@ -102,25 +103,23 @@ public:
   }
 
   /**
-   Defines a property that will be updated with the container changes.
-   */
-  template <typename T = BaseNodeProp>
-  T *defineProperty(std::shared_ptr<T> prop) {
-    _properties.push_back(prop);
-    return prop.get();
-  }
-
-  /**
-   Defines a property that will be updated with the container changes.
+   Defines a property that will be added to the container
    */
   template <class _Tp, class... _Args,
             class = std::_EnableIf<!std::is_array<_Tp>::value>>
   _Tp *defineProperty(_Args &&...__args) {
-    return defineProperty(
-        std::make_shared<_Tp>(std::forward<_Args>(__args)...));
+    // Create property and set onChange callback
+    auto prop =
+        std::make_shared<_Tp>(std::forward<_Args>(__args)..., _onPropChanged);
+
+    // Add to props list
+    _properties.push_back(prop);
+
+    return prop.get();
   }
 
 private:
+  std::function<void(BaseNodeProp *)> _onPropChanged;
   std::vector<std::shared_ptr<BaseNodeProp>> _properties;
   std::map<PropId, std::vector<NodeProp *>> _mappedProperties;
   PropId _type;

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

@@ -15,22 +15,33 @@ public:
 
 protected:
   void draw(DrawingContext *context) override {
-    if (getChildren().size() == 0) {
-      throw std::runtime_error(
-          "Expected at least one child in the BackdropFilter node.");
+    auto children = getChildren();
+
+    if (children.size() == 0) {
+      return;
     }
-    auto child = getChildren()[0];
-    auto colorFilter = std::dynamic_pointer_cast<JsiBaseColorFilterNode>(child);
-    auto imageFilter = std::dynamic_pointer_cast<JsiBaseImageFilterNode>(child);
 
     auto canvas = context->getCanvas();
-    auto filter =
-        colorFilter != nullptr
-            ? SkImageFilters::ColorFilter(colorFilter->getCurrent(), nullptr)
-            : imageFilter->getCurrent();
+    auto firstChild = children[0];
+    sk_sp<SkImageFilter> imageFilter;
+
+    if (firstChild->getNodeClass() == NodeClass::DeclarationNode) {
+      context->getDeclarationContext()->save();
+      firstChild->decorateContext(context->getDeclarationContext());
+      auto imgF = context->getDeclarationContext()->getImageFilters()->pop();
+      if (imgF) {
+        imageFilter = imgF;
+      } else {
+        auto cf = context->getDeclarationContext()->getColorFilters()->pop();
+        if (cf) {
+          imageFilter = SkImageFilters::ColorFilter(cf, nullptr);
+        }
+      }
+      context->getDeclarationContext()->restore();
+    }
 
     canvas->saveLayer(
-        SkCanvas::SaveLayerRec(nullptr, nullptr, filter.get(), 0));
+        SkCanvas::SaveLayerRec(nullptr, nullptr, imageFilter.get(), 0));
     canvas->restore();
   }
 };