@shopify/react-native-skia 0.1.158 → 0.1.160

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

@@ -0,0 +1,79 @@
+#pragma once
+
+#include "JsiDomDeclarationNode.h"
+#include "PaintProps.h"
+
+#include <memory>
+
+namespace RNSkia {
+
+// TODO: implement feature: A paint node has its own paint not inherited,
+//       and when found the drawing node should render an extra time for
+//       each paint node in its children.
+
+class JsiPaintNode : public JsiBaseDomDeclarationNode,
+                     public JsiDomNodeCtor<JsiPaintNode> {
+public:
+  explicit JsiPaintNode(std::shared_ptr<RNSkPlatformContext> context)
+      : JsiBaseDomDeclarationNode(context, "skPaint") {}
+
+  /**
+   Returns a pointer to the local paint context in the paint node. This is a
+   special case for declaration nodes since the Paint node has a bit different
+   semantic than other declaration nodes.
+   */
+  DrawingContext *getDrawingContext() { return _localContext.get(); }
+
+  /**
+   We need to override the decorate node call to avoid letting children
+   decorate before we have created our child context.
+   */
+  void decorateContext(DrawingContext *context) override {
+    // A paint node should have its own local paint
+    if (_localContext == nullptr) {
+      _localContext = context->inheritContext("PaintNode");
+    }
+
+    // ...and it should be a totally new paint, not inheriting from parent
+    // paint.
+    if (_localContext->isChanged()) {
+      auto paint = std::make_shared<SkPaint>();
+      paint->setAntiAlias(true);
+      _localContext->setMutablePaint(paint);
+    }
+
+    // Let's decorate paint props
+    _paintProps->decorate(_localContext.get());
+
+    // Materialize children who will now only change the paint node's paint
+    for (auto &child : getChildren()) {
+      auto decl = std::dynamic_pointer_cast<JsiBaseDomDeclarationNode>(child);
+      if (decl != nullptr) {
+        decl->decorateContext(_localContext.get());
+      }
+    }
+  }
+
+  std::shared_ptr<const SkPaint> getPaint() {
+    return _localContext->getPaint();
+  }
+
+protected:
+  void decorate(DrawingContext *context) override {}
+
+  void defineProperties(NodePropsContainer *container) override {
+    JsiBaseDomDeclarationNode::defineProperties(container);
+
+    _paintProps = container->defineProperty(std::make_shared<PaintProps>());
+    _opacityProp =
+        container->defineProperty(std::make_shared<NodeProp>(PropNameOpacity));
+  }
+
+private:
+  NodeProp *_opacityProp;
+  PaintProps *_paintProps;
+
+  std::shared_ptr<DrawingContext> _localContext;
+};
+
+} // namespace RNSkia

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

@@ -0,0 +1,54 @@
+#pragma once
+
+#include "BezierProps.h"
+#include "BlendModeProp.h"
+#include "ColorProp.h"
+#include "JsiDomDrawingNode.h"
+#include "PointsProp.h"
+
+#include <memory>
+
+namespace RNSkia {
+
+class JsiPatchNode : public JsiDomDrawingNode,
+                     public JsiDomNodeCtor<JsiPatchNode> {
+public:
+  explicit JsiPatchNode(std::shared_ptr<RNSkPlatformContext> context)
+      : JsiDomDrawingNode(context, "skPatch") {}
+
+protected:
+  void draw(DrawingContext *context) override {
+    SkBlendMode defaultBlendMode =
+        _colorsProp->isSet() ? SkBlendMode::kDstOver : SkBlendMode::kSrcOver;
+    context->getCanvas()->drawPatch(
+        _patchProp->getDerivedValue()->data(),
+        _colorsProp->isSet() ? _colorsProp->getDerivedValue()->data() : nullptr,
+        _textureProp->isSet() ? _textureProp->getDerivedValue()->data()
+                              : nullptr,
+        _blendModeProp->isSet() ? *_blendModeProp->getDerivedValue()
+                                : defaultBlendMode,
+        *context->getPaint());
+  }
+
+  void defineProperties(NodePropsContainer *container) override {
+    JsiDomDrawingNode::defineProperties(container);
+    _colorsProp = container->defineProperty(
+        std::make_shared<ColorsProp>(JsiPropId::get("colors")));
+    _textureProp = container->defineProperty(
+        std::make_shared<PointsProp>(JsiPropId::get("texture")));
+    _blendModeProp = container->defineProperty(
+        std::make_shared<BlendModeProp>(JsiPropId::get("blendMode")));
+    _patchProp = container->defineProperty(
+        std::make_shared<BezierProp>(JsiPropId::get("patch")));
+
+    _patchProp->require();
+  }
+
+private:
+  ColorsProp *_colorsProp;
+  PointsProp *_textureProp;
+  BlendModeProp *_blendModeProp;
+  BezierProp *_patchProp;
+};
+
+} // namespace RNSkia

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

@@ -0,0 +1,315 @@
+#pragma once
+
+#include "JsiDomDeclarationNode.h"
+
+#include "NodeProp.h"
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include <SkPathEffect.h>
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+class JsiBasePathEffectNode
+    : public JsiDomDeclarationNode<JsiBasePathEffectNode, sk_sp<SkPathEffect>> {
+public:
+  JsiBasePathEffectNode(std::shared_ptr<RNSkPlatformContext> context,
+                        const char *type)
+      : JsiDomDeclarationNode<JsiBasePathEffectNode, sk_sp<SkPathEffect>>(
+            context, type) {}
+
+protected:
+  void setPathEffect(DrawingContext *context, sk_sp<SkPathEffect> f) {
+    set(context, f);
+  }
+
+  sk_sp<SkPathEffect> resolve(std::shared_ptr<JsiDomNode> child) override {
+    auto ptr = std::dynamic_pointer_cast<JsiBasePathEffectNode>(child);
+    if (ptr) {
+      return ptr->getCurrent();
+    }
+    return nullptr;
+  }
+
+  /**
+   Sets or composes the path effect
+   */
+  void set(DrawingContext *context, sk_sp<SkPathEffect> pathEffect) override {
+    auto paint = context->getMutablePaint();
+    if (paint->getPathEffect() != nullptr &&
+        paint->getPathEffect() != getCurrent().get()) {
+      paint->setPathEffect(
+          SkPathEffect::MakeCompose(paint->refPathEffect(), pathEffect));
+    } else {
+      paint->setPathEffect(pathEffect);
+    }
+    setCurrent(pathEffect);
+  }
+};
+
+class JsiDashPathEffectNode : public JsiBasePathEffectNode,
+                              public JsiDomNodeCtor<JsiDashPathEffectNode> {
+public:
+  explicit JsiDashPathEffectNode(std::shared_ptr<RNSkPlatformContext> context)
+      : JsiBasePathEffectNode(context, "skDashPathEffect") {}
+
+protected:
+  void decorate(DrawingContext *context) override {
+    if (isChanged(context)) {
+
+      // Phase
+      auto phase = _phase->isSet() ? _phase->value().getAsNumber() : 0;
+
+      // Copy intervals
+      std::vector<SkScalar> intervals;
+      auto intervalsArray = _intervals->value().getAsArray();
+      for (size_t i = 0; i < intervalsArray.size(); ++i) {
+        intervals.push_back(intervalsArray[i].getAsNumber());
+      }
+
+      // Create effect
+      auto pathEffect = SkDashPathEffect::Make(
+          intervals.data(), static_cast<int>(intervals.size()), phase);
+
+      setPathEffect(context, pathEffect);
+    }
+  }
+
+  void defineProperties(NodePropsContainer *container) override {
+    JsiBaseDomDeclarationNode::defineProperties(container);
+
+    _intervals = container->defineProperty(
+        std::make_shared<NodeProp>(JsiPropId::get("intervals")));
+    _phase = container->defineProperty(
+        std::make_shared<NodeProp>(JsiPropId::get("phase")));
+
+    _intervals->require();
+  }
+
+private:
+  NodeProp *_intervals;
+  NodeProp *_phase;
+};
+
+class JsiDiscretePathEffectNode
+    : public JsiBasePathEffectNode,
+      public JsiDomNodeCtor<JsiDiscretePathEffectNode> {
+public:
+  explicit JsiDiscretePathEffectNode(
+      std::shared_ptr<RNSkPlatformContext> context)
+      : JsiBasePathEffectNode(context, "skDiscretePathEffect") {}
+
+protected:
+  void decorate(DrawingContext *context) override {
+    if (isChanged(context)) {
+
+      // Create effect
+      auto pathEffect =
+          SkDiscretePathEffect::Make(_lengthProp->value().getAsNumber(),
+                                     _deviationProp->value().getAsNumber(),
+                                     _seedProp->value().getAsNumber());
+
+      setPathEffect(context, pathEffect);
+    }
+  }
+
+  void defineProperties(NodePropsContainer *container) override {
+    JsiBaseDomDeclarationNode::defineProperties(container);
+
+    _lengthProp = container->defineProperty(
+        std::make_shared<NodeProp>(JsiPropId::get("length")));
+    _deviationProp = container->defineProperty(
+        std::make_shared<NodeProp>(JsiPropId::get("deviation")));
+    _seedProp = container->defineProperty(
+        std::make_shared<NodeProp>(JsiPropId::get("seed")));
+
+    _lengthProp->require();
+    _deviationProp->require();
+    _seedProp->require();
+  }
+
+private:
+  NodeProp *_lengthProp;
+  NodeProp *_deviationProp;
+  NodeProp *_seedProp;
+};
+
+class JsiCornerPathEffectNode : public JsiBasePathEffectNode,
+                                public JsiDomNodeCtor<JsiCornerPathEffectNode> {
+public:
+  explicit JsiCornerPathEffectNode(std::shared_ptr<RNSkPlatformContext> context)
+      : JsiBasePathEffectNode(context, "skCornerPathEffect") {}
+
+protected:
+  void decorate(DrawingContext *context) override {
+    if (isChanged(context)) {
+
+      // Create effect
+      auto pathEffect = SkCornerPathEffect::Make(_rProp->value().getAsNumber());
+
+      setPathEffect(context, pathEffect);
+    }
+  }
+
+  void defineProperties(NodePropsContainer *container) override {
+    JsiBaseDomDeclarationNode::defineProperties(container);
+
+    _rProp = container->defineProperty(
+        std::make_shared<NodeProp>(JsiPropId::get("r")));
+    _rProp->require();
+  }
+
+private:
+  NodeProp *_rProp;
+};
+
+class JsiPath1DPathEffectNode : public JsiBasePathEffectNode,
+                                public JsiDomNodeCtor<JsiPath1DPathEffectNode> {
+public:
+  explicit JsiPath1DPathEffectNode(std::shared_ptr<RNSkPlatformContext> context)
+      : JsiBasePathEffectNode(context, "skPath1DPathEffect") {}
+
+protected:
+  void decorate(DrawingContext *context) override {
+    if (isChanged(context)) {
+
+      // Create effect
+      auto pathEffect = SkPath1DPathEffect::Make(
+          *_pathProp->getDerivedValue(), _advanceProp->value().getAsNumber(),
+          _phaseProp->value().getAsNumber(),
+          getStyleFromStringValue(_styleProp->value().getAsString()));
+
+      setPathEffect(context, pathEffect);
+    }
+  }
+
+  void defineProperties(NodePropsContainer *container) override {
+    JsiBaseDomDeclarationNode::defineProperties(container);
+
+    _phaseProp = container->defineProperty(
+        std::make_shared<NodeProp>(JsiPropId::get("phase")));
+    _advanceProp = container->defineProperty(
+        std::make_shared<NodeProp>(JsiPropId::get("advance")));
+    _pathProp = container->defineProperty(
+        std::make_shared<PathProp>(JsiPropId::get("path")));
+    _styleProp = container->defineProperty(
+        std::make_shared<NodeProp>(JsiPropId::get("style")));
+
+    _phaseProp->require();
+    _advanceProp->require();
+    _pathProp->require();
+    _styleProp->require();
+  }
+
+private:
+  SkPath1DPathEffect::Style getStyleFromStringValue(const std::string &value) {
+    if (value == "translate") {
+      return SkPath1DPathEffect::kTranslate_Style;
+    } else if (value == "rotate") {
+      return SkPath1DPathEffect::kRotate_Style;
+    } else if (value == "morph") {
+      return SkPath1DPathEffect::kMorph_Style;
+    }
+    throw std::runtime_error("Value \"" + value +
+                             "\" is not a valid Path1D effect style.");
+  }
+
+  NodeProp *_phaseProp;
+  NodeProp *_advanceProp;
+  NodeProp *_styleProp;
+  PathProp *_pathProp;
+};
+
+class JsiPath2DPathEffectNode : public JsiBasePathEffectNode,
+                                public JsiDomNodeCtor<JsiPath2DPathEffectNode> {
+public:
+  explicit JsiPath2DPathEffectNode(std::shared_ptr<RNSkPlatformContext> context)
+      : JsiBasePathEffectNode(context, "skPath2DPathEffect") {}
+
+protected:
+  void decorate(DrawingContext *context) override {
+    if (isChanged(context)) {
+
+      // Create effect
+      auto pathEffect = SkPath2DPathEffect::Make(
+          *_matrixProp->getDerivedValue(), *_pathProp->getDerivedValue());
+
+      setPathEffect(context, pathEffect);
+    }
+  }
+
+  void defineProperties(NodePropsContainer *container) override {
+    JsiBaseDomDeclarationNode::defineProperties(container);
+
+    _matrixProp = container->defineProperty(
+        std::make_shared<MatrixProp>(JsiPropId::get("matrix")));
+    _pathProp = container->defineProperty(
+        std::make_shared<PathProp>(JsiPropId::get("path")));
+
+    _matrixProp->require();
+    _pathProp->require();
+  }
+
+private:
+  MatrixProp *_matrixProp;
+  PathProp *_pathProp;
+};
+
+class JsiLine2DPathEffectNode : public JsiBasePathEffectNode,
+                                public JsiDomNodeCtor<JsiLine2DPathEffectNode> {
+public:
+  explicit JsiLine2DPathEffectNode(std::shared_ptr<RNSkPlatformContext> context)
+      : JsiBasePathEffectNode(context, "skLine2DPathEffect") {}
+
+protected:
+  void decorate(DrawingContext *context) override {
+    if (isChanged(context)) {
+
+      // Create effect
+      auto pathEffect = SkLine2DPathEffect::Make(
+          _widthProp->value().getAsNumber(), *_matrixProp->getDerivedValue());
+
+      setPathEffect(context, pathEffect);
+    }
+  }
+
+  void defineProperties(NodePropsContainer *container) override {
+    JsiBaseDomDeclarationNode::defineProperties(container);
+
+    _matrixProp = container->defineProperty(
+        std::make_shared<MatrixProp>(JsiPropId::get("matrix")));
+    _widthProp = container->defineProperty(
+        std::make_shared<NodeProp>(JsiPropId::get("width")));
+
+    _matrixProp->require();
+    _widthProp->require();
+  }
+
+private:
+  MatrixProp *_matrixProp;
+  NodeProp *_widthProp;
+};
+
+class JsiSumPathEffectNode : public JsiBasePathEffectNode,
+                             public JsiDomNodeCtor<JsiSumPathEffectNode> {
+public:
+  explicit JsiSumPathEffectNode(std::shared_ptr<RNSkPlatformContext> context)
+      : JsiBasePathEffectNode(context, "skSumPathEffect") {}
+
+protected:
+  void decorate(DrawingContext *context) override {
+    if (isChanged(context)) {
+      auto inner = requireChild(0);
+      auto outer = requireChild(1);
+      setPathEffect(context, SkPathEffect::MakeSum(inner, outer));
+    }
+  }
+};
+} // namespace RNSkia

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

@@ -0,0 +1,181 @@
+#pragma once
+
+#include "JsiDomDrawingNode.h"
+#include "PathProp.h"
+
+#include <memory>
+#include <string>
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include <SkTrimPathEffect.h>
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+static PropId PropNamePath = JsiPropId::get("path");
+static PropId PropNameStart = JsiPropId::get("start");
+static PropId PropNameEnd = JsiPropId::get("end");
+static PropId PropNameFillType = JsiPropId::get("fillType");
+static PropId PropNameMiterLimit = JsiPropId::get("miter_limit");
+static PropId PropNameStroke = JsiPropId::get("stroke");
+static PropId PropNamePrecision = JsiPropId::get("precision");
+
+class JsiPathNode : public JsiDomDrawingNode,
+                    public JsiDomNodeCtor<JsiPathNode> {
+public:
+  explicit JsiPathNode(std::shared_ptr<RNSkPlatformContext> context)
+      : JsiDomDrawingNode(context, "skPath") {}
+
+protected:
+  void draw(DrawingContext *context) override {
+    if (getPropsContainer()->isChanged()) {
+      // Can we use the path directly, or do we need to copy to
+      // mutate / modify the path?
+      auto hasStartOffset =
+          _startProp->isSet() && _startProp->value().getAsNumber() != 0.0;
+      auto hasEndOffset =
+          _endProp->isSet() && _endProp->value().getAsNumber() != 1.0;
+      auto hasFillStyle = _fillTypeProp->isSet();
+      auto hasStrokeOptions =
+          _strokeOptsProp->isSet() &&
+          _strokeOptsProp->value().getType() == PropType::Object;
+
+      auto willMutatePath =
+          hasStartOffset || hasEndOffset || hasFillStyle || hasStrokeOptions;
+
+      if (willMutatePath) {
+        // We'll trim the path
+        SkPath filteredPath(*_pathProp->getDerivedValue());
+        auto pe = SkTrimPathEffect::Make(_startProp->value().getAsNumber(),
+                                         _endProp->value().getAsNumber(),
+                                         SkTrimPathEffect::Mode::kNormal);
+
+        if (pe != nullptr) {
+          SkStrokeRec rec(SkStrokeRec::InitStyle::kHairline_InitStyle);
+          if (!pe->filterPath(_pathProp->getDerivedValue().get(), filteredPath,
+                              &rec, nullptr)) {
+            throw std::runtime_error(
+                "Failed trimming path with parameters start: " +
+                std::to_string(_startProp->value().getAsNumber()) +
+                ", end: " + std::to_string(_endProp->value().getAsNumber()));
+          }
+          _path = std::make_shared<SkPath>(filteredPath);
+        } else if (hasStartOffset || hasEndOffset) {
+          throw std::runtime_error(
+              "Failed trimming path with parameters start: " +
+              std::to_string(_startProp->value().getAsNumber()) +
+              ", end: " + std::to_string(_endProp->value().getAsNumber()));
+        } else {
+          _path = std::make_shared<SkPath>(*_pathProp->getDerivedValue());
+        }
+
+        // Set fill style
+        if (_fillTypeProp->isSet()) {
+          auto fillType = _fillTypeProp->value().getAsString();
+          _path->setFillType(getFillTypeFromStringValue(fillType));
+        }
+
+        // do we have a special paint here?
+        if (_strokeOptsProp->isSet()) {
+          auto opts = _strokeOptsProp->value();
+          SkPaint strokePaint;
+
+          if (opts.hasValue(JsiPropId::get("strokeCap"))) {
+            strokePaint.setStrokeCap(StrokeCapProp::getCapFromString(
+                opts.getValue(JsiPropId::get("strokeCap")).getAsString()));
+          }
+
+          if (opts.hasValue(JsiPropId::get("strokeJoin"))) {
+            strokePaint.setStrokeJoin(StrokeJoinProp::getJoinFromString(
+                opts.getValue(JsiPropId::get("strokeJoin")).getAsString()));
+          }
+
+          if (opts.hasValue(PropNameWidth)) {
+            strokePaint.setStrokeWidth(
+                opts.getValue(PropNameWidth).getAsNumber());
+          }
+
+          if (opts.hasValue(PropNameMiterLimit)) {
+            strokePaint.setStrokeMiter(
+                opts.getValue(PropNameMiterLimit).getAsNumber());
+          }
+
+          double precision = 1.0;
+          if (opts.hasValue(PropNamePrecision)) {
+            precision = opts.getValue(PropNamePrecision).getAsNumber();
+          }
+
+          if (!strokePaint.getFillPath(*_path.get(), _path.get(), nullptr,
+                                       precision)) {
+            _path = nullptr;
+          }
+        }
+
+      } else {
+        // We'll just draw the pure path
+        _path = _pathProp->getDerivedValue();
+      }
+    }
+
+    if (_path == nullptr) {
+      throw std::runtime_error(
+          "Path node could not resolve path props correctly.");
+    }
+
+    context->getCanvas()->drawPath(*_path, *context->getPaint());
+  }
+
+  void defineProperties(NodePropsContainer *container) override {
+    JsiDomDrawingNode::defineProperties(container);
+    _pathProp =
+        container->defineProperty(std::make_shared<PathProp>(PropNamePath));
+    _startProp =
+        container->defineProperty(std::make_shared<NodeProp>(PropNameStart));
+    _endProp =
+        container->defineProperty(std::make_shared<NodeProp>(PropNameEnd));
+    _fillTypeProp =
+        container->defineProperty(std::make_shared<NodeProp>(PropNameFillType));
+    _strokeOptsProp =
+        container->defineProperty(std::make_shared<NodeProp>(PropNameStroke));
+
+    _pathProp->require();
+  }
+
+private:
+  SkPathFillType getFillTypeFromStringValue(const std::string &value) {
+    if (value == "winding") {
+      return SkPathFillType::kWinding;
+    } else if (value == "evenOdd") {
+      return SkPathFillType::kEvenOdd;
+    } else if (value == "inverseWinding") {
+      return SkPathFillType::kInverseWinding;
+    } else if (value == "inverseEvenOdd") {
+      return SkPathFillType::kInverseEvenOdd;
+    }
+    throw std::runtime_error("Could not convert value \"" + value +
+                             "\" to path fill type.");
+  }
+
+  PathProp *_pathProp;
+  NodeProp *_startProp;
+  NodeProp *_endProp;
+  NodeProp *_fillTypeProp;
+  NodeProp *_strokeOptsProp;
+
+  std::shared_ptr<SkPath> _path;
+};
+
+class StrokeOptsProps : public BaseDerivedProp {
+public:
+  StrokeOptsProps() : BaseDerivedProp() {
+    _strokeProp = addProperty(std::make_shared<NodeProp>(PropNameStroke));
+  }
+
+private:
+  NodeProp *_strokeProp;
+};
+
+} // namespace RNSkia

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

@@ -0,0 +1,32 @@
+#pragma once
+
+#include "JsiDomDrawingNode.h"
+#include "PictureProp.h"
+
+#include <memory>
+
+namespace RNSkia {
+
+class JsiPictureNode : public JsiDomDrawingNode,
+                       public JsiDomNodeCtor<JsiPictureNode> {
+public:
+  explicit JsiPictureNode(std::shared_ptr<RNSkPlatformContext> context)
+      : JsiDomDrawingNode(context, "skPicture") {}
+
+protected:
+  void draw(DrawingContext *context) override {
+    context->getCanvas()->drawPicture(_pictureProp->getDerivedValue());
+  }
+
+  void defineProperties(NodePropsContainer *container) override {
+    JsiDomDrawingNode::defineProperties(container);
+    _pictureProp = container->defineProperty(
+        std::make_shared<PictureProp>(JsiPropId::get("picture")));
+    _pictureProp->require();
+  }
+
+private:
+  PictureProp *_pictureProp;
+};
+
+} // namespace RNSkia