@shopify/react-native-skia 0.1.158 → 0.1.159

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

@@ -0,0 +1,26 @@
+
+#pragma once
+
+#include "JsiDomRenderNode.h"
+
+#include <memory>
+
+namespace RNSkia {
+
+class JsiGroupNode : public JsiDomRenderNode,
+                     public JsiDomNodeCtor<JsiGroupNode> {
+public:
+  explicit JsiGroupNode(std::shared_ptr<RNSkPlatformContext> context)
+      : JsiDomRenderNode(context, "skGroup") {}
+
+  void renderNode(DrawingContext *context) override {
+    for (auto &child : getChildren()) {
+      auto renderNode = std::dynamic_pointer_cast<JsiDomRenderNode>(child);
+      if (renderNode != nullptr) {
+        renderNode->render(context);
+      }
+    }
+  }
+};
+
+} // namespace RNSkia

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

@@ -0,0 +1,415 @@
+#pragma once
+
+#include "JsiColorFilterNodes.h"
+#include "JsiDomDeclarationNode.h"
+#include "JsiShaderNodes.h"
+#include "JsiSkRuntimeEffect.h"
+
+#include "NodeProp.h"
+#include "RadiusProp.h"
+#include "TileModeProp.h"
+#include "UniformsProp.h"
+
+#include <memory>
+#include <string>
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include <SkImageFilter.h>
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+class JsiBaseImageFilterNode
+    : public JsiDomDeclarationNode<JsiBaseImageFilterNode,
+                                   sk_sp<SkImageFilter>> {
+public:
+  JsiBaseImageFilterNode(std::shared_ptr<RNSkPlatformContext> context,
+                         const char *type)
+      : JsiDomDeclarationNode<JsiBaseImageFilterNode, sk_sp<SkImageFilter>>(
+            context, type) {}
+
+protected:
+  sk_sp<SkImageFilter> resolve(std::shared_ptr<JsiDomNode> child) override {
+    auto imageFilterPtr =
+        std::dynamic_pointer_cast<JsiBaseImageFilterNode>(child);
+    if (imageFilterPtr) {
+      return imageFilterPtr->getCurrent();
+    }
+    auto shaderPtr = std::dynamic_pointer_cast<JsiBaseShaderNode>(child);
+    if (shaderPtr) {
+      return SkImageFilters::Shader(shaderPtr->getCurrent());
+    }
+    auto colorFilterPtr =
+        std::dynamic_pointer_cast<JsiBaseColorFilterNode>(child);
+    if (colorFilterPtr) {
+      return SkImageFilters::ColorFilter(colorFilterPtr->getCurrent(), nullptr);
+    }
+    return nullptr;
+  }
+
+  void setImageFilter(DrawingContext *context, sk_sp<SkImageFilter> f) {
+    set(context, f);
+  }
+
+  void set(DrawingContext *context, sk_sp<SkImageFilter> imageFilter) override {
+    auto paint = context->getMutablePaint();
+    if (paint->getImageFilter() != nullptr &&
+        paint->getImageFilter() != getCurrent().get()) {
+      paint->setImageFilter(
+          SkImageFilters::Compose(paint->refImageFilter(), imageFilter));
+    } else {
+      paint->setImageFilter(imageFilter);
+    }
+
+    setCurrent(imageFilter);
+  }
+};
+
+class JsiBlendImageFilterNode : public JsiBaseImageFilterNode,
+                                public JsiDomNodeCtor<JsiBlendImageFilterNode> {
+public:
+  explicit JsiBlendImageFilterNode(std::shared_ptr<RNSkPlatformContext> context)
+      : JsiBaseImageFilterNode(context, "skBlendImageFilter") {}
+
+protected:
+  void decorate(DrawingContext *context) override {
+
+    if (isChanged(context)) {
+
+      if (getChildren().size() != 2) {
+        throw std::runtime_error("Blend image filter needs two child nodes.");
+      }
+
+      auto background = requireChild(0);
+      auto foreground = requireChild(1);
+
+      SkBlendMode blendMode = *_blendModeProp->getDerivedValue();
+      setImageFilter(context,
+                     SkImageFilters::Blend(blendMode, background, foreground));
+    }
+  }
+
+  void defineProperties(NodePropsContainer *container) override {
+    JsiBaseDomDeclarationNode::defineProperties(container);
+    _blendModeProp = container->defineProperty(
+        std::make_shared<BlendModeProp>(JsiPropId::get("mode")));
+    _blendModeProp->require();
+  }
+
+private:
+  BlendModeProp *_blendModeProp;
+};
+
+class JsiDropShadowImageFilterNode
+    : public JsiBaseImageFilterNode,
+      public JsiDomNodeCtor<JsiDropShadowImageFilterNode> {
+public:
+  explicit JsiDropShadowImageFilterNode(
+      std::shared_ptr<RNSkPlatformContext> context)
+      : JsiBaseImageFilterNode(context, "skDropShadowImageFilter") {}
+
+protected:
+  void decorate(DrawingContext *context) override {
+    if (isChanged(context)) {
+      auto color = _colorProp->getDerivedValue();
+      auto dx = _dxProp->value().getAsNumber();
+      auto dy = _dxProp->value().getAsNumber();
+      auto blur = _blurProp->value().getAsNumber();
+      auto input = optionalChild(0);
+
+      auto inner = _innerProp->isSet() && _innerProp->value().getAsBool();
+      auto shadowOnly =
+          _shadowOnlyProp->isSet() && _shadowOnlyProp->value().getAsBool();
+
+      if (inner) {
+        auto srcGraphic = SkImageFilters::ColorFilter(
+            SkColorFilters::Blend(SK_ColorBLACK, SkBlendMode::kDst), nullptr);
+        auto srcAlpha = SkImageFilters::ColorFilter(
+            SkColorFilters::Blend(SK_ColorBLACK, SkBlendMode::kSrcIn), nullptr);
+        auto f1 = SkImageFilters::ColorFilter(
+            SkColorFilters::Blend(*color, SkBlendMode::kSrcOut), nullptr);
+        auto f2 = SkImageFilters::Offset(dx, dy, f1);
+        auto f3 = SkImageFilters::Blur(blur, blur, SkTileMode::kDecal, f2);
+        auto f4 = SkImageFilters::Blend(SkBlendMode::kSrcIn, srcAlpha, f3);
+
+        setImageFilter(context, SkImageFilters::Compose(
+                                    input ? input : nullptr,
+                                    SkImageFilters::Blend(SkBlendMode::kSrcOver,
+                                                          srcGraphic, f4)));
+
+      } else {
+        setImageFilter(
+            context,
+            shadowOnly
+                ? SkImageFilters::DropShadowOnly(dx, dy, blur, blur, *color,
+                                                 input ? input : nullptr)
+                : SkImageFilters::DropShadow(dx, dy, blur, blur, *color,
+                                             input ? input : nullptr));
+      }
+    }
+  }
+
+  void defineProperties(NodePropsContainer *container) override {
+    JsiBaseDomDeclarationNode::defineProperties(container);
+    _dxProp = container->defineProperty(
+        std::make_shared<NodeProp>(JsiPropId::get("dx")));
+    _dyProp = container->defineProperty(
+        std::make_shared<NodeProp>(JsiPropId::get("dy")));
+    _blurProp = container->defineProperty(
+        std::make_shared<NodeProp>(JsiPropId::get("blur")));
+    _colorProp = container->defineProperty(
+        std::make_shared<ColorProp>(JsiPropId::get("color")));
+
+    _innerProp = container->defineProperty(
+        std::make_shared<NodeProp>(JsiPropId::get("inner")));
+    _shadowOnlyProp = container->defineProperty(
+        std::make_shared<NodeProp>(JsiPropId::get("shadowOnly")));
+
+    _dxProp->require();
+    _dyProp->require();
+    _blurProp->require();
+    _colorProp->require();
+  }
+
+private:
+  NodeProp *_dxProp;
+  NodeProp *_dyProp;
+  NodeProp *_blurProp;
+  ColorProp *_colorProp;
+  NodeProp *_innerProp;
+  NodeProp *_shadowOnlyProp;
+};
+
+class JsiDisplacementMapImageFilterNode
+    : public JsiBaseImageFilterNode,
+      public JsiDomNodeCtor<JsiDisplacementMapImageFilterNode> {
+public:
+  explicit JsiDisplacementMapImageFilterNode(
+      std::shared_ptr<RNSkPlatformContext> context)
+      : JsiBaseImageFilterNode(context, "skDisplacementMapImageFilter") {}
+
+protected:
+  void decorate(DrawingContext *context) override {
+    if (isChanged(context)) {
+
+      auto channelX =
+          getColorChannelFromStringValue(_channelXProp->value().getAsString());
+      auto channelY =
+          getColorChannelFromStringValue(_channelYProp->value().getAsString());
+      auto scale = _scaleProp->value().getAsNumber();
+
+      auto displacement = requireChild(0);
+      auto color = optionalChild(1);
+
+      setImageFilter(context, SkImageFilters::DisplacementMap(
+                                  channelX, channelY, scale, displacement,
+                                  color ? color : nullptr));
+    }
+  }
+
+  void defineProperties(NodePropsContainer *container) override {
+    JsiBaseDomDeclarationNode::defineProperties(container);
+    _channelXProp = container->defineProperty(
+        std::make_shared<NodeProp>(JsiPropId::get("channelX")));
+    _channelYProp = container->defineProperty(
+        std::make_shared<NodeProp>(JsiPropId::get("channelY")));
+    _scaleProp = container->defineProperty(
+        std::make_shared<NodeProp>(JsiPropId::get("scale")));
+
+    _channelXProp->require();
+    _channelYProp->require();
+    _scaleProp->require();
+  }
+
+private:
+  SkColorChannel getColorChannelFromStringValue(const std::string &value) {
+    if (value == "r") {
+      return SkColorChannel::kR;
+    } else if (value == "g") {
+      return SkColorChannel::kG;
+    } else if (value == "b") {
+      return SkColorChannel::kB;
+    } else if (value == "a") {
+      return SkColorChannel::kA;
+    }
+    throw std::runtime_error("Value \"" + value +
+                             "\" is not a valid color channel.");
+  }
+
+  NodeProp *_channelXProp;
+  NodeProp *_channelYProp;
+  NodeProp *_scaleProp;
+};
+
+class JsiBlurImageFilterNode : public JsiBaseImageFilterNode,
+                               public JsiDomNodeCtor<JsiBlurImageFilterNode> {
+public:
+  explicit JsiBlurImageFilterNode(std::shared_ptr<RNSkPlatformContext> context)
+      : JsiBaseImageFilterNode(context, "skBlurImageFilter") {}
+
+protected:
+  void decorate(DrawingContext *context) override {
+    if (isChanged(context)) {
+      auto input = optionalChild(0);
+      setImageFilter(
+          context, SkImageFilters::Blur(_blurProp->getDerivedValue()->x(),
+                                        _blurProp->getDerivedValue()->y(),
+                                        _tileModeProp->isSet()
+                                            ? *_tileModeProp->getDerivedValue()
+                                            : SkTileMode::kDecal,
+                                        input ? input : nullptr));
+    }
+  }
+
+  void defineProperties(NodePropsContainer *container) override {
+    JsiBaseDomDeclarationNode::defineProperties(container);
+    _blurProp = container->defineProperty(
+        std::make_shared<RadiusProp>(JsiPropId::get("blur")));
+    _tileModeProp = container->defineProperty(
+        std::make_shared<TileModeProp>(JsiPropId::get("mode")));
+
+    _blurProp->require();
+  }
+
+private:
+  RadiusProp *_blurProp;
+  TileModeProp *_tileModeProp;
+};
+
+class JsiOffsetImageFilterNode
+    : public JsiBaseImageFilterNode,
+      public JsiDomNodeCtor<JsiOffsetImageFilterNode> {
+public:
+  explicit JsiOffsetImageFilterNode(
+      std::shared_ptr<RNSkPlatformContext> context)
+      : JsiBaseImageFilterNode(context, "skOffsetImageFilter") {}
+
+protected:
+  void decorate(DrawingContext *context) override {
+    if (isChanged(context)) {
+      auto input = optionalChild(0);
+      if (getPropsContainer()->isChanged()) {
+        setImageFilter(context,
+                       SkImageFilters::Offset(_xProp->value().getAsNumber(),
+                                              _yProp->value().getAsNumber(),
+                                              input ? input : nullptr));
+      }
+    }
+  }
+
+  void defineProperties(NodePropsContainer *container) override {
+    JsiBaseDomDeclarationNode::defineProperties(container);
+    _xProp = container->defineProperty(
+        std::make_shared<NodeProp>(JsiPropId::get("x")));
+    _yProp = container->defineProperty(
+        std::make_shared<NodeProp>(JsiPropId::get("y")));
+
+    _xProp->require();
+    _yProp->require();
+  }
+
+private:
+  NodeProp *_xProp;
+  NodeProp *_yProp;
+};
+
+class JsiMorphologyImageFilterNode
+    : public JsiBaseImageFilterNode,
+      public JsiDomNodeCtor<JsiMorphologyImageFilterNode> {
+public:
+  enum Type { Dilate, Erode };
+
+  explicit JsiMorphologyImageFilterNode(
+      std::shared_ptr<RNSkPlatformContext> context)
+      : JsiBaseImageFilterNode(context, "skMorphologyImageFilter") {}
+
+protected:
+  void decorate(DrawingContext *context) override {
+    if (isChanged(context)) {
+      auto op = getTypeFromStringValue(_operatorProp->value().getAsString());
+      auto radius = _radiusProp->getDerivedValue();
+      auto input = optionalChild(0);
+
+      if (op == Type::Dilate) {
+        setImageFilter(context,
+                       SkImageFilters::Dilate(radius->x(), radius->y(),
+                                              input ? input : nullptr));
+      } else {
+        setImageFilter(context, SkImageFilters::Erode(radius->x(), radius->y(),
+                                                      input ? input : nullptr));
+      }
+    }
+  }
+
+  void defineProperties(NodePropsContainer *container) override {
+    JsiBaseDomDeclarationNode::defineProperties(container);
+    _operatorProp = container->defineProperty(
+        std::make_shared<NodeProp>(JsiPropId::get("operator")));
+    _radiusProp = container->defineProperty(
+        std::make_shared<RadiusProp>(JsiPropId::get("radius")));
+
+    _operatorProp->require();
+    _radiusProp->require();
+  }
+
+private:
+  Type getTypeFromStringValue(const std::string &value) {
+    if (value == "erode") {
+      return Type::Erode;
+    } else if (value == "dilate") {
+      return Type::Dilate;
+    }
+    throw std::runtime_error("Value \"" + value +
+                             "\" is not valid for the operator property in the "
+                             "MorphologyImageFilter component.");
+  }
+  NodeProp *_operatorProp;
+  RadiusProp *_radiusProp;
+};
+
+class JsiRuntimeShaderImageFilterNode
+    : public JsiBaseImageFilterNode,
+      public JsiDomNodeCtor<JsiRuntimeShaderImageFilterNode> {
+public:
+  explicit JsiRuntimeShaderImageFilterNode(
+      std::shared_ptr<RNSkPlatformContext> context)
+      : JsiBaseImageFilterNode(context, "skRuntimeShaderImageFilter") {}
+
+protected:
+  void decorate(DrawingContext *context) override {
+    if (isChanged(context)) {
+      auto source = _sourceProp->value().getAs<JsiSkRuntimeEffect>();
+      if (source == nullptr) {
+        throw std::runtime_error("Expected runtime effect when reading source "
+                                 "property of RuntimeEffectImageFilter.");
+      }
+
+      auto builder = SkRuntimeShaderBuilder(source->getObject());
+      auto input = optionalChild(0);
+      _uniformsProp->processUniforms(builder);
+
+      setImageFilter(context,
+                     SkImageFilters::RuntimeShader(builder, "", input));
+    }
+  }
+
+  void defineProperties(NodePropsContainer *container) override {
+    JsiBaseDomDeclarationNode::defineProperties(container);
+    _sourceProp = container->defineProperty(
+        std::make_shared<NodeProp>(JsiPropId::get("source")));
+    _uniformsProp =
+        container->defineProperty(std::make_shared<SimpleUniformsProp>(
+            JsiPropId::get("uniforms"), _sourceProp));
+
+    _sourceProp->require();
+  }
+
+private:
+  NodeProp *_sourceProp;
+  SimpleUniformsProp *_uniformsProp;
+};
+
+} // namespace RNSkia

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

@@ -0,0 +1,34 @@
+#pragma once
+
+#include "ImageProps.h"
+#include "JsiDomDrawingNode.h"
+
+#include <memory>
+
+namespace RNSkia {
+
+class JsiImageNode : public JsiDomDrawingNode,
+                     public JsiDomNodeCtor<JsiImageNode> {
+public:
+  explicit JsiImageNode(std::shared_ptr<RNSkPlatformContext> context)
+      : JsiDomDrawingNode(context, "skImage") {}
+
+protected:
+  void draw(DrawingContext *context) override {
+    auto rects = _imageProps->getDerivedValue();
+    context->getCanvas()->drawImageRect(
+        _imageProps->getImage(), rects->src, rects->dst, SkSamplingOptions(),
+        context->getPaint().get(), SkCanvas::kStrict_SrcRectConstraint);
+  }
+
+  void defineProperties(NodePropsContainer *container) override {
+    JsiDomDrawingNode::defineProperties(container);
+    _imageProps = container->defineProperty(std::make_shared<ImageProps>());
+    _imageProps->require();
+  }
+
+private:
+  ImageProps *_imageProps;
+};
+
+} // namespace RNSkia

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

@@ -0,0 +1,44 @@
+#pragma once
+
+#include "JsiDomDrawingNode.h"
+#include "RectProp.h"
+#include "SvgProp.h"
+
+#include <memory>
+
+namespace RNSkia {
+
+class JsiImageSvgNode : public JsiDomDrawingNode,
+                        public JsiDomNodeCtor<JsiImageSvgNode> {
+public:
+  explicit JsiImageSvgNode(std::shared_ptr<RNSkPlatformContext> context)
+      : JsiDomDrawingNode(context, "skImageSvg") {}
+
+protected:
+  void draw(DrawingContext *context) override {
+    auto svgDom = _svgDomProp->getDerivedValue();
+    auto rect = _rectProp->getDerivedValue();
+
+    context->getCanvas()->save();
+    context->getCanvas()->translate(rect->x(), rect->y());
+    svgDom->setContainerSize(SkSize::Make(rect->width(), rect->height()));
+    svgDom->render(context->getCanvas());
+    context->getCanvas()->restore();
+  }
+
+  void defineProperties(NodePropsContainer *container) override {
+    JsiDomDrawingNode::defineProperties(container);
+    _svgDomProp = container->defineProperty(
+        std::make_shared<SvgProp>(JsiPropId::get("svg")));
+    _rectProp = container->defineProperty(
+        std::make_shared<RectProps>(JsiPropId::get("rect")));
+
+    _svgDomProp->require();
+  }
+
+private:
+  SvgProp *_svgDomProp;
+  RectProps *_rectProp;
+};
+
+} // namespace RNSkia

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

@@ -0,0 +1,64 @@
+#pragma once
+
+#include "JsiBoxShadowNode.h"
+#include "JsiDomRenderNode.h"
+#include "JsiPaintNode.h"
+
+#include <memory>
+#include <vector>
+
+namespace RNSkia {
+
+class JsiLayerNode : public JsiDomRenderNode,
+                     public JsiDomNodeCtor<JsiLayerNode> {
+public:
+  explicit JsiLayerNode(std::shared_ptr<RNSkPlatformContext> context)
+      : JsiDomRenderNode(context, "skLayer") {}
+
+protected:
+  void renderNode(DrawingContext *context) override {
+
+    bool isLayer = false;
+    auto children = getChildren();
+    auto size = children.size();
+
+    // Is the first children a layer?
+    for (size_t i = 0; i < size; ++i) {
+      if (i == 0) {
+        // Check for paint node as layer
+        auto paintNode =
+            std::dynamic_pointer_cast<JsiPaintNode>(children.at(i));
+
+        if (paintNode != nullptr) {
+          // Yes, it is a paint node - which we can use as a layer.
+          isLayer = true;
+          // Save canvas with the paint node's paint!
+          context->getCanvas()->saveLayer(SkCanvas::SaveLayerRec(
+              nullptr, paintNode->getPaint().get(), nullptr, 0));
+
+          continue;
+        }
+      }
+
+      // Render rest of the children
+      auto renderNode =
+          std::dynamic_pointer_cast<JsiDomRenderNode>(children.at(i));
+
+      if (renderNode != nullptr) {
+        renderNode->render(context);
+      }
+    }
+
+    if (isLayer) {
+      context->getCanvas()->restore();
+    }
+  }
+
+  void defineProperties(NodePropsContainer *container) override {
+    JsiDomRenderNode::defineProperties(container);
+  }
+
+private:
+};
+
+} // namespace RNSkia

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

@@ -0,0 +1,43 @@
+#pragma once
+
+#include "JsiDomDrawingNode.h"
+#include "PointProp.h"
+
+#include <memory>
+
+namespace RNSkia {
+
+static PropId PropNamePoint1 = JsiPropId::get("p1");
+static PropId PropNamePoint2 = JsiPropId::get("p2");
+
+class JsiLineNode : public JsiDomDrawingNode,
+                    public JsiDomNodeCtor<JsiLineNode> {
+public:
+  explicit JsiLineNode(std::shared_ptr<RNSkPlatformContext> context)
+      : JsiDomDrawingNode(context, "skLine") {}
+
+protected:
+  void draw(DrawingContext *context) override {
+    context->getCanvas()->drawLine(
+        _p1Prop->getDerivedValue()->x(), _p1Prop->getDerivedValue()->y(),
+        _p2Prop->getDerivedValue()->x(), _p2Prop->getDerivedValue()->y(),
+        *context->getPaint());
+  }
+
+  void defineProperties(NodePropsContainer *container) override {
+    JsiDomDrawingNode::defineProperties(container);
+    _p1Prop =
+        container->defineProperty(std::make_shared<PointProp>(PropNamePoint1));
+    _p2Prop =
+        container->defineProperty(std::make_shared<PointProp>(PropNamePoint2));
+
+    _p1Prop->require();
+    _p2Prop->require();
+  }
+
+private:
+  PointProp *_p1Prop;
+  PointProp *_p2Prop;
+};
+
+} // namespace RNSkia

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

@@ -0,0 +1,34 @@
+#pragma once
+
+#include "JsiDomDrawingNode.h"
+#include "RectProp.h"
+
+#include <memory>
+
+namespace RNSkia {
+
+class JsiOvalNode : public JsiDomDrawingNode,
+                    public JsiDomNodeCtor<JsiOvalNode> {
+public:
+  explicit JsiOvalNode(std::shared_ptr<RNSkPlatformContext> context)
+      : JsiDomDrawingNode(context, "skOval") {}
+
+protected:
+  void draw(DrawingContext *context) override {
+    RNSkLogger::logToConsole(context->getDebugDescription());
+    context->getCanvas()->drawOval(*_rectProp->getDerivedValue(),
+                                   *context->getPaint());
+  }
+
+  void defineProperties(NodePropsContainer *container) override {
+    JsiDomDrawingNode::defineProperties(container);
+    _rectProp =
+        container->defineProperty(std::make_shared<RectProps>(PropNameRect));
+    _rectProp->require();
+  }
+
+private:
+  RectProps *_rectProp;
+};
+
+} // namespace RNSkia