@shopify/react-native-skia 0.1.158 → 0.1.159

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

@@ -0,0 +1,267 @@
+
+#pragma once
+
+#include "ClipProp.h"
+#include "DrawingContext.h"
+#include "JsiDomDeclarationNode.h"
+#include "JsiDomNode.h"
+#include "LayerProp.h"
+#include "MatrixProp.h"
+#include "PaintProps.h"
+#include "PointProp.h"
+#include "RRectProp.h"
+#include "RectProp.h"
+#include "TransformProp.h"
+
+#include <memory>
+#include <string>
+
+namespace RNSkia {
+
+static PropId PropNameOrigin = JsiPropId::get("origin");
+static PropId PropNameOpacity = JsiPropId::get("opacity");
+static PropId PropNameClip = JsiPropId::get("clip");
+static PropId PropNameInvertClip = JsiPropId::get("invertClip");
+static PropId PropNameLayer = JsiPropId::get("layer");
+
+class JsiDomRenderNode : public JsiDomNode {
+public:
+  JsiDomRenderNode(std::shared_ptr<RNSkPlatformContext> context,
+                   const char *type)
+      : JsiDomNode(context, type) {}
+
+  void render(DrawingContext *context) {
+#if SKIA_DOM_DEBUG
+    printDebugInfo(context, "Begin Render");
+#endif
+
+    // Ensure we have a local drawing context inheriting from the parent context
+    if (_localContext == nullptr) {
+      _localContext = context->inheritContext(getType());
+    }
+
+    auto shouldTransform = _matrixProp->isSet() || _transformProp->isSet();
+    auto shouldSave =
+        shouldTransform || _clipProp->isSet() || _layerProp->isSet();
+
+    // Handle matrix/transforms
+    if (shouldSave) {
+      // Save canvas state
+      if (_layerProp->isSet()) {
+        if (_layerProp->isBool()) {
+#if SKIA_DOM_DEBUG
+          printDebugInfo(context, "canvas->saveLayer()");
+#endif
+          _localContext->getCanvas()->saveLayer(
+              SkCanvas::SaveLayerRec(nullptr, nullptr, nullptr, 0));
+        } else {
+#if SKIA_DOM_DEBUG
+          printDebugInfo(context, "canvas->saveLayer(paint)");
+#endif
+          _localContext->getCanvas()->saveLayer(SkCanvas::SaveLayerRec(
+              nullptr, _layerProp->getDerivedValue().get(), nullptr, 0));
+        }
+      } else {
+#if SKIA_DOM_DEBUG
+        printDebugInfo(context, "canvas->save()");
+#endif
+        _localContext->getCanvas()->save();
+      }
+
+      if (_originProp->isSet()) {
+#if SKIA_DOM_DEBUG
+        printDebugInfo(context, "canvas->translate(origin)");
+#endif
+        // Handle origin
+        _localContext->getCanvas()->translate(
+            _originProp->getDerivedValue()->x(),
+            _originProp->getDerivedValue()->y());
+      }
+
+      if (shouldTransform) {
+#if SKIA_DOM_DEBUG
+        printDebugInfo(
+            context,
+            "canvas->concat(" +
+                std::string(_matrixProp->isSet() ? "matrix" : "transform") +
+                std::string(")"));
+#endif
+        auto matrix = _matrixProp->isSet() ? _matrixProp->getDerivedValue()
+                                           : _transformProp->getDerivedValue();
+
+        // Concat canvas' matrix with our matrix
+        _localContext->getCanvas()->concat(*matrix);
+      }
+
+      // Clipping
+      if (_clipProp->isSet()) {
+        auto invert = _invertClip->isSet() && _invertClip->value().getAsBool();
+        clip(context, _localContext->getCanvas(), invert);
+      }
+
+      if (_originProp->isSet()) {
+#if SKIA_DOM_DEBUG
+        printDebugInfo(context, "canvas->translate(-origin)");
+#endif
+        // Handle origin
+        _localContext->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());
+
+    // Restore if needed
+    if (shouldSave) {
+#if SKIA_DOM_DEBUG
+      printDebugInfo(context, "canvas->restore()");
+#endif
+      _localContext->getCanvas()->restore();
+    }
+
+#if SKIA_DOM_DEBUG
+    printDebugInfo(context, "End Render");
+#endif
+  }
+
+  /**
+   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();
+  }
+
+  /**
+   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;
+    }
+  }
+
+protected:
+  /**
+   Override to implement rendering where the current state of the drawing
+   context is correctly set.
+   */
+  virtual void renderNode(DrawingContext *context) = 0;
+
+  /**
+   Removes a child
+   */
+  void removeChild(std::shared_ptr<JsiDomNode> child) override {
+    JsiDomNode::removeChild(child);
+    if (_localContext != nullptr) {
+      _localContext->markAsChanged();
+    }
+  }
+
+  /**
+   Validates that only declaration nodes can be children
+   */
+  void addChild(std::shared_ptr<JsiDomNode> child) override {
+    JsiDomNode::addChild(child);
+    if (_localContext != nullptr) {
+      _localContext->markAsChanged();
+    }
+  }
+
+  /**
+   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);
+    if (_localContext != nullptr) {
+      _localContext->markAsChanged();
+    }
+  }
+
+  /**
+   Define common properties for all render nodes
+   */
+  void defineProperties(NodePropsContainer *container) override {
+    JsiDomNode::defineProperties(container);
+
+    _paintProps = container->defineProperty(std::make_shared<PaintProps>());
+
+    _matrixProp =
+        container->defineProperty(std::make_shared<MatrixProp>(PropNameMatrix));
+    _transformProp = container->defineProperty(
+        std::make_shared<TransformProp>(PropNameTransform));
+    _originProp =
+        container->defineProperty(std::make_shared<PointProp>(PropNameOrigin));
+    _clipProp =
+        container->defineProperty(std::make_shared<ClipProp>(PropNameClip));
+    _invertClip = container->defineProperty(
+        std::make_shared<NodeProp>(PropNameInvertClip));
+    _layerProp =
+        container->defineProperty(std::make_shared<LayerProp>(PropNameLayer));
+  }
+
+private:
+  /**
+   Clips the canvas depending on the clip property
+   */
+  void clip(DrawingContext *context, SkCanvas *canvas, bool invert) {
+    auto op = invert ? SkClipOp::kDifference : SkClipOp::kIntersect;
+    if (_clipProp->getRect() != nullptr) {
+#if SKIA_DOM_DEBUG
+      printDebugInfo(context, "canvas->clipRect()");
+#endif
+      canvas->clipRect(*_clipProp->getRect(), op, true);
+    } else if (_clipProp->getRRect() != nullptr) {
+#if SKIA_DOM_DEBUG
+      printDebugInfo(context, "canvas->clipRRect()");
+#endif
+      canvas->clipRRect(*_clipProp->getRRect(), op, true);
+    } else if (_clipProp->getPath() != nullptr) {
+#if SKIA_DOM_DEBUG
+      printDebugInfo(context, "canvas->clipPath()");
+#endif
+      canvas->clipPath(*_clipProp->getPath(), op, true);
+    }
+  }
+
+  /**
+   Loops through all declaration nodes and gives each one of them the
+   opportunity to decorate the context
+   */
+  void materializeDeclarations() {
+    for (auto &child : getChildren()) {
+      auto ptr = std::dynamic_pointer_cast<JsiBaseDomDeclarationNode>(child);
+      if (ptr != nullptr) {
+        ptr->decorateContext(_localContext.get());
+      }
+    }
+  }
+
+  PointProp *_originProp;
+  MatrixProp *_matrixProp;
+  TransformProp *_transformProp;
+  NodeProp *_invertClip;
+  ClipProp *_clipProp;
+  LayerProp *_layerProp;
+  PaintProps *_paintProps;
+
+  std::shared_ptr<DrawingContext> _localContext;
+};
+
+} // namespace RNSkia

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

@@ -0,0 +1,130 @@
+#pragma once
+
+#include "BaseNodeProp.h"
+#include "JsiValue.h"
+
+#include <chrono>
+#include <memory>
+#include <string>
+
+namespace RNSkia {
+
+/**
+ Simple class for reading a property by name from the Dom Node properties
+ object.
+ */
+class NodeProp : public BaseNodeProp,
+                 public std::enable_shared_from_this<NodeProp> {
+public:
+  /**
+   Constructs a new optional dom node properrty
+   */
+  explicit NodeProp(PropId name) : _name(name), BaseNodeProp() {}
+
+  /**
+   Reads JS value and swaps out with a new value
+   */
+  void readValueFromJs(jsi::Runtime &runtime,
+                       const ReadPropFunc &read) override {
+    // If the value is a nullptr this is the first call to the
+    // readValueFromJS Function (which comes from the reconciler
+    // setting a new property value on the property
+    if (_value == nullptr) {
+      _value = std::make_shared<JsiValue>(runtime, read(runtime, _name, this));
+      _isChanged = true;
+      _hasNewValue = false;
+    } else {
+      // Otherwise we'll just update the buffer and commit it later.
+      std::lock_guard<std::mutex> lock(_swapMutex);
+      if (_buffer == nullptr) {
+        _buffer =
+            std::make_shared<JsiValue>(runtime, read(runtime, _name, this));
+      } else {
+        _buffer->setCurrent(runtime, read(runtime, _name, this));
+      }
+      _hasNewValue = *_buffer.get() != *_value.get();
+    }
+  }
+
+  /**
+   Property value has changed - let's save this as a change to be commited later
+   */
+  void updateValue(jsi::Runtime &runtime, const jsi::Value &value) {
+    // Always use the next field since this method is called on the JS thread
+    // and we don't want to rip out the underlying value object.
+    std::lock_guard<std::mutex> lock(_swapMutex);
+    if (_buffer == nullptr) {
+      _buffer = std::make_shared<JsiValue>(runtime, value);
+    } else {
+      _buffer->setCurrent(runtime, value);
+    }
+    // This is almost always a change - meaning a swap is
+    // cheaper than comparing for equality.
+    _hasNewValue = true;
+  }
+
+  /**
+   Returns true if the property is set and is not undefined or null
+   */
+  bool isSet() override {
+    return _value != nullptr && !_value->isUndefinedOrNull();
+  }
+
+  /**
+   True if the property has changed since we last visited it
+   */
+  bool isChanged() override { return _isChanged; }
+
+  /**
+   Starts the process of updating and reading props
+   */
+  void updatePendingChanges() override {
+    // If the value has changed we should swap the
+    // buffers
+    if (_hasNewValue && _buffer != nullptr) {
+      {
+        // Swap buffers
+        std::lock_guard<std::mutex> lock(_swapMutex);
+        auto tmp = _value;
+        _value = _buffer;
+        _buffer = tmp;
+
+        // turn off pending changes flag
+        _hasNewValue = false;
+      }
+
+      // Mark as changed.
+      _isChanged = true;
+    }
+  }
+
+  /*
+   Ends the visit cycle
+   */
+  void markAsResolved() override { _isChanged = false; }
+
+  /**
+   Returns pointer to the value contained by the property if the property is
+   set.
+   */
+  const JsiValue &value() {
+    assert(isSet());
+    return *_value;
+  }
+
+  /**
+   Returns the name of the property
+   */
+  std::string getName() override { return std::string(_name); }
+
+private:
+  PropId _name;
+
+  std::shared_ptr<JsiValue> _value;
+  std::shared_ptr<JsiValue> _buffer;
+  std::atomic<bool> _isChanged = {false};
+  std::atomic<bool> _hasNewValue = {false};
+  std::mutex _swapMutex;
+};
+
+} // namespace RNSkia

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

@@ -0,0 +1,119 @@
+#pragma once
+
+#include "DrawingContext.h"
+#include "JsiValue.h"
+#include "NodeProp.h"
+
+#include <map>
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace RNSkia {
+
+/**
+ This class manages marshalling from JS values over JSI to C++ values and is
+ typically called when a new node is created or an existing node is updated from
+ the reconciler.
+ */
+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.
+   */
+  explicit NodePropsContainer(PropId componentType) : _type(componentType) {}
+
+  /**
+   Returns true if there are any changes in the props container in the current
+   being/end visit
+   */
+  bool isChanged() {
+    for (auto &prop : _properties) {
+      if (prop->isChanged()) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   Returns a list of mappings betwen property names and property objects
+   */
+  const std::map<PropId, std::vector<NodeProp *>> &getMappedProperties() {
+    return _mappedProperties;
+  }
+
+  /**
+   Updates any props that has changes waiting, updates props that have derived
+   values
+   */
+  void updatePendingValues() {
+    for (auto &prop : _properties) {
+      prop->updatePendingChanges();
+      if (!prop->isSet() && prop->isRequired()) {
+        throw std::runtime_error("Missing one or more required properties " +
+                                 std::string(prop->getName()) + " in the " +
+                                 _type + " component.");
+      }
+    }
+  }
+
+  /**
+   We're done, mark any changes as committed in all props
+   */
+  void markAsResolved() {
+    for (auto &prop : _properties) {
+      prop->markAsResolved();
+    }
+  }
+
+  /**
+   Clears all props and data from the container
+   */
+  void dispose() {
+    _properties.clear();
+    _mappedProperties.clear();
+  }
+
+  /**
+   Called when the React / JS side sets properties on a node
+   */
+  void setProps(jsi::Runtime &runtime, jsi::Object &&props) {
+    // Clear property mapping
+    _mappedProperties.clear();
+
+    // Use specialized reader function to be able to intercept calls that
+    // reads specific named values from the js property object.
+    auto read = [&](jsi::Runtime &runtime, PropId name, NodeProp *prop) {
+      if (_mappedProperties.count(name) == 0) {
+        std::vector<NodeProp *> tmp;
+        _mappedProperties[name] = std::move(tmp);
+      }
+      _mappedProperties.at(name).push_back(prop);
+      return props.getProperty(runtime, name);
+    };
+
+    for (auto &prop : _properties) {
+      prop->readValueFromJs(runtime, read);
+    }
+  }
+
+  /**
+   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();
+  }
+
+private:
+  std::vector<std::shared_ptr<BaseNodeProp>> _properties;
+  std::map<PropId, std::vector<NodeProp *>> _mappedProperties;
+  PropId _type;
+};
+
+} // namespace RNSkia

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

@@ -0,0 +1,38 @@
+#pragma once
+
+#include "CircleProp.h"
+#include "JsiDomDrawingNode.h"
+
+#include <memory>
+
+namespace RNSkia {
+
+class JsiBackdropFilterNode : public JsiDomDrawingNode,
+                              public JsiDomNodeCtor<JsiBackdropFilterNode> {
+public:
+  explicit JsiBackdropFilterNode(std::shared_ptr<RNSkPlatformContext> context)
+      : JsiDomDrawingNode(context, "skBackdropFilter") {}
+
+protected:
+  void draw(DrawingContext *context) override {
+    if (getChildren().size() == 0) {
+      throw std::runtime_error(
+          "Expected at least one child in the BackdropFilter node.");
+    }
+    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();
+
+    canvas->saveLayer(
+        SkCanvas::SaveLayerRec(nullptr, nullptr, filter.get(), 0));
+    canvas->restore();
+  }
+};
+
+} // namespace RNSkia

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

@@ -0,0 +1,112 @@
+#pragma once
+
+#include "JsiDomDeclarationNode.h"
+
+#include <memory>
+#include <string>
+
+namespace RNSkia {
+
+class JsiBlendNode : public JsiBaseDomDeclarationNode,
+                     public JsiDomNodeCtor<JsiBlendNode> {
+public:
+  explicit JsiBlendNode(std::shared_ptr<RNSkPlatformContext> context)
+      : JsiBaseDomDeclarationNode(context, "skBlend") {}
+
+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 (asShader) {
+          sk_sp<SkShader> outer = maybeShader->getCurrent();
+          if (innerShader != nullptr) {
+            innerShader = SkShaders::Blend(blendMode, innerShader, outer);
+          } else {
+            innerShader = outer;
+          }
+
+        } else {
+          sk_sp<SkImageFilter> outer = maybeImageFilter->getCurrent();
+          if (innerImageFilter != nullptr) {
+            innerImageFilter = SkImageFilters::Blend(
+                blendMode, innerImageFilter, outer, nullptr);
+          } else {
+            innerImageFilter = outer;
+          }
+        }
+      }
+
+      // Materialize
+      if (asShader) {
+        context->getMutablePaint()->setShader(innerShader);
+      } else {
+        context->getMutablePaint()->setImageFilter(innerImageFilter);
+      }
+    }
+  }
+
+  void defineProperties(NodePropsContainer *container) override {
+    JsiBaseDomDeclarationNode::defineProperties(container);
+    _blendProp = container->defineProperty(
+        std::make_shared<BlendModeProp>(JsiPropId::get("mode")));
+    _blendProp->require();
+  }
+
+  /**
+   Validates that only declaration nodes can be children
+   */
+  void addChild(std::shared_ptr<JsiDomNode> child) override {
+    JsiBaseDomDeclarationNode::addChild(child);
+    // Verify declaration of either shader or image filter
+    verifyChild(child);
+  }
+
+  /**
+   Validates that only declaration nodes can be children
+   */
+  void insertChildBefore(std::shared_ptr<JsiDomNode> child,
+                         std::shared_ptr<JsiDomNode> before) override {
+    JsiBaseDomDeclarationNode::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) {
+      // 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 " +
+                         std::string(child->getType()) + ".");
+    }
+  }
+
+  BlendModeProp *_blendProp;
+};
+
+} // namespace RNSkia