@shopify/react-native-skia 1.11.1 → 1.11.2

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

@@ -1,262 +0,0 @@
-
-#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>
-#include <vector>
-
-namespace RNSkia {
-
-class JsiDomRenderNode : public JsiDomNode {
-public:
-  JsiDomRenderNode(std::shared_ptr<RNSkPlatformContext> context,
-                   const char *type)
-      : JsiDomNode(context, type, NodeClass::RenderNode) {}
-
-  void render(DrawingContext *context) {
-#if SKIA_DOM_DEBUG
-    printDebugInfo("Begin Render");
-#endif
-
-    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 =
-        shouldTransform || _clipProp->isSet() || _layerProp->isSet();
-
-    // Handle matrix/transforms
-    if (shouldSave) {
-      // Save canvas state
-      if (_layerProp->isSet()) {
-        if (_layerProp->isBool()) {
-#if SKIA_DOM_DEBUG_VERBOSE
-          printDebugInfo("canvas->saveLayer()");
-#endif
-          context->getCanvas()->saveLayer(
-              SkCanvas::SaveLayerRec(nullptr, nullptr, nullptr, 0));
-        } else {
-#if SKIA_DOM_DEBUG_VERBOSE
-          printDebugInfo("canvas->saveLayer(paint)");
-#endif
-          context->getCanvas()->saveLayer(SkCanvas::SaveLayerRec(
-              nullptr, _layerProp->getDerivedValue().get(), nullptr, 0));
-        }
-      } else {
-#if SKIA_DOM_DEBUG_VERBOSE
-        printDebugInfo("canvas->save()");
-#endif
-        context->getCanvas()->save();
-      }
-
-      if (_originProp->isSet()) {
-#if SKIA_DOM_DEBUG_VERBOSE
-        printDebugInfo("canvas->translate(origin)");
-#endif
-        // Handle origin
-        context->getCanvas()->translate(_originProp->getDerivedValue()->x(),
-                                        _originProp->getDerivedValue()->y());
-      }
-
-      if (shouldTransform) {
-#if SKIA_DOM_DEBUG_VERBOSE
-        printDebugInfo(
-            "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
-        context->getCanvas()->concat(*matrix);
-      }
-
-      // Clipping
-      if (_clipProp->isSet()) {
-        auto invert = _invertClip->isSet() && _invertClip->value().getAsBool();
-        clip(context, context->getCanvas(), invert);
-      }
-
-      if (_originProp->isSet()) {
-#if SKIA_DOM_DEBUG_VERBOSE
-        printDebugInfo("canvas->translate(-origin)");
-#endif
-        // Handle origin
-        context->getCanvas()->translate(-_originProp->getDerivedValue()->x(),
-                                        -_originProp->getDerivedValue()->y());
-      }
-    }
-
-    // Render the node
-    renderNode(context);
-
-    // Restore if needed
-    if (shouldSave) {
-#if SKIA_DOM_DEBUG_VERBOSE
-      printDebugInfo("canvas->restore()");
-#endif
-      context->getCanvas()->restore();
-    }
-
-    if (shouldRestore) {
-      _paintCache.parent = parentPaint;
-      _paintCache.child = context->getPaint();
-      context->restore();
-    }
-
-#if SKIA_DOM_DEBUG
-    printDebugInfo("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(); }
-
-  /**
-   Overridden dispose to release resources
-   */
-  void dispose(bool immediate) override {
-    JsiDomNode::dispose(immediate);
-    _paintCache.clear();
-  }
-
-protected:
-  /**
-   Invalidates and marks then context as changed.
-   */
-  void invalidateContext() override {
-    enqueAsynOperation([weakSelf = weak_from_this()]() {
-      auto self = weakSelf.lock();
-      if (self) {
-        std::static_pointer_cast<JsiDomRenderNode>(self)->_paintCache.parent =
-            nullptr;
-        std::static_pointer_cast<JsiDomRenderNode>(self)->_paintCache.child =
-            nullptr;
-      }
-    });
-  }
-
-  /**
-   Override to implement rendering where the current state of the drawing
-   context is correctly set.
-   */
-  virtual void renderNode(DrawingContext *context) = 0;
-
-  /**
-   Define common properties for all render nodes
-   */
-  void defineProperties(NodePropsContainer *container) override {
-    JsiDomNode::defineProperties(container);
-
-    _paintProps = container->defineProperty<PaintProps>();
-
-    _matrixProp = container->defineProperty<MatrixProp>("matrix");
-    _transformProp = container->defineProperty<TransformProp>("transform");
-    _originProp = container->defineProperty<PointProp>("origin");
-    _clipProp = container->defineProperty<ClipProp>("clip");
-    _invertClip = container->defineProperty<NodeProp>("invertClip");
-    _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"),    JsiPropId::get("dither")};
-
-    // 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
-   */
-  void clip(DrawingContext *context, SkCanvas *canvas, bool invert) {
-    auto op = invert ? SkClipOp::kDifference : SkClipOp::kIntersect;
-    if (_clipProp->getRect() != nullptr) {
-#if SKIA_DOM_DEBUG
-      printDebugInfo("canvas->clipRect()");
-#endif
-      canvas->clipRect(*_clipProp->getRect(), op, true);
-    } else if (_clipProp->getRRect() != nullptr) {
-#if SKIA_DOM_DEBUG
-      printDebugInfo("canvas->clipRRect()");
-#endif
-      canvas->clipRRect(*_clipProp->getRRect(), op, true);
-    } else if (_clipProp->getPath() != nullptr) {
-#if SKIA_DOM_DEBUG
-      printDebugInfo("canvas->clipPath()");
-#endif
-      canvas->clipPath(*_clipProp->getPath(), op, true);
-    }
-  }
-
-  struct PaintCache {
-    void clear() {
-      parent = nullptr;
-      child = nullptr;
-    }
-    std::shared_ptr<SkPaint> parent;
-    std::shared_ptr<SkPaint> child;
-  };
-
-  PaintCache _paintCache;
-
-  PointProp *_originProp;
-  MatrixProp *_matrixProp;
-  TransformProp *_transformProp;
-  NodeProp *_invertClip;
-  ClipProp *_clipProp;
-  LayerProp *_layerProp;
-  PaintProps *_paintProps;
-};
-
-} // namespace RNSkia

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

@@ -1,139 +0,0 @@
-#pragma once
-
-#include "BaseNodeProp.h"
-#include "JsiValue.h"
-
-#include <chrono>
-#include <memory>
-#include <mutex>
-#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(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
-   */
-  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_unique<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_unique<JsiValue>(runtime, read(runtime, _name, this));
-      } else {
-        _buffer->setCurrent(runtime, read(runtime, _name, this));
-      }
-      _hasNewValue = *_buffer.get() != *_value.get();
-      if (_hasNewValue && _onChange != nullptr) {
-        _onChange(this);
-      }
-    }
-  }
-
-  /**
-   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_unique<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;
-    if (_onChange != nullptr) {
-      _onChange(this);
-    }
-  }
-
-  /**
-   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);
-        _value.swap(_buffer);
-
-        // 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::function<void(BaseNodeProp *)> _onChange;
-
-  std::unique_ptr<JsiValue> _value;
-  std::unique_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

@@ -1,158 +0,0 @@
-#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 for the node prop container
-   */
-  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
-   being/end visit
-   */
-  bool isChanged() {
-    for (auto &prop : _properties) {
-      if (prop->isChanged()) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  /**
-   Enumerate all mapped properties
-   */
-  void enumerateMappedProps(
-      const std::function<void(const PropId name,
-                               const std::vector<NodeProp *>)> &callback) {
-    std::lock_guard<std::mutex> lock(_mappedPropsLock);
-    for (auto &props : _mappedProperties) {
-      callback(props.first, props.second);
-    }
-  }
-
-  /**
-   Enumerates a named property instances from the mapped properties list
-   */
-  void
-  enumerateMappedPropsByName(const std::string &name,
-                             const std::function<void(NodeProp *)> &callback) {
-    std::lock_guard<std::mutex> lock(_mappedPropsLock);
-    auto propMapIt = _mappedProperties.find(JsiPropId::get(name));
-    if (propMapIt != _mappedProperties.end()) {
-      for (auto &prop : propMapIt->second) {
-        callback(prop);
-      }
-    }
-  }
-
-  /**
-   Updates any props that has changes waiting, updates props that have derived
-   values
-   */
-  void updatePendingValues() {
-    for (auto &prop : _properties) {
-      prop->updatePendingChanges();
-      if (prop->isRequired() && !prop->isSet()) {
-        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() {
-    std::lock_guard<std::mutex> lock(_mappedPropsLock);
-    _properties.clear();
-    _mappedProperties.clear();
-  }
-
-  /**
-   Called when the React / JS side sets properties on a node
-   */
-  void setProps(jsi::Runtime &runtime, const jsi::Value &maybePropsObject) {
-    std::lock_guard<std::mutex> lock(_mappedPropsLock);
-
-    // Clear property mapping
-    _mappedProperties.clear();
-
-    if (!maybePropsObject.isObject()) {
-      throw jsi::JSError(runtime, "Expected property object.");
-    }
-
-    auto props = maybePropsObject.asObject(runtime);
-
-    // 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 added to the container
-   */
-  template <class _Tp, class... _Args,
-            class = std::enable_if_t<!std::is_array<_Tp>::value>>
-  _Tp *defineProperty(_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;
-  std::mutex _mappedPropsLock;
-};
-
-} // namespace RNSkia

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

@@ -1,64 +0,0 @@
-#pragma once
-
-#include "JsiDomDrawingNode.h"
-#include "RSXformProp.h"
-#include "RectProp.h"
-#include "SamplingProp.h"
-#include "SkImageProps.h"
-
-#include <memory>
-#include <tuple>
-
-namespace RNSkia {
-
-class JsiAtlasNode : public JsiDomDrawingNode,
-                     public JsiDomNodeCtor<JsiAtlasNode> {
-public:
-  explicit JsiAtlasNode(std::shared_ptr<RNSkPlatformContext> context)
-      : JsiDomDrawingNode(context, "skAtlas") {}
-
-protected:
-  void draw(DrawingContext *context) override {
-    if (_rectsProp->isSet() && _imageProp->isSet() && _rsxFormsProp->isSet()) {
-      const auto image = _imageProp->getDerivedValue();
-      const auto sprites = _rectsProp->getDerivedValue();
-      const auto transforms = _rsxFormsProp->getDerivedValue();
-      const auto colors =
-          _colorsProp->isSet() ? _colorsProp->getDerivedValue() : nullptr;
-      const auto blendMode = _blendModeProp->isSet()
-                                 ? *_blendModeProp->getDerivedValue()
-                                 : SkBlendMode::kDstOver;
-      auto paint = *context->getPaint();
-      auto sampling = _samplingProp->isSet()
-                          ? *_samplingProp->getDerivedValue()
-                          : SkSamplingOptions(SkFilterMode::kLinear);
-      context->getCanvas()->drawAtlas(
-          image.get(), transforms->data(), sprites->data(),
-          colors == nullptr ? nullptr : colors->data(), sprites->size(),
-          blendMode, sampling, nullptr, &paint);
-    }
-  }
-
-  void defineProperties(NodePropsContainer *container) override {
-    JsiDomDrawingNode::defineProperties(container);
-    _rectsProp = container->defineProperty<RectsProp>("sprites");
-    _rsxFormsProp = container->defineProperty<RSXFormsProp>("transforms");
-    _imageProp = container->defineProperty<ImageProp>("image");
-    _colorsProp = container->defineProperty<ColorsProp>("colors");
-    _blendModeProp = container->defineProperty<BlendModeProp>("blendMode");
-    _samplingProp = container->defineProperty<SamplingProp>("sampling");
-
-    _rectsProp->require();
-    _rsxFormsProp->require();
-  }
-
-private:
-  ImageProp *_imageProp;
-  RectsProp *_rectsProp;
-  RSXFormsProp *_rsxFormsProp;
-  ColorsProp *_colorsProp;
-  BlendModeProp *_blendModeProp;
-  SamplingProp *_samplingProp;
-};
-
-} // namespace RNSkia

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

@@ -1,49 +0,0 @@
-#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 {
-    auto children = getChildren();
-
-    if (children.size() == 0) {
-      return;
-    }
-
-    auto canvas = context->getCanvas();
-    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, imageFilter.get(), 0));
-    canvas->restore();
-  }
-};
-
-} // namespace RNSkia