@shopify/react-native-skia 0.1.158 → 0.1.160

package/cpp/rnskia/dom/props/ImageProps.h

@@ -0,0 +1,173 @@
+#pragma once
+
+#include "DerivedNodeProp.h"
+
+#include "JsiSkImage.h"
+
+#include <algorithm>
+#include <memory>
+#include <string>
+
+namespace RNSkia {
+
+struct FitSizes {
+  SkSize src;
+  SkSize dst;
+};
+
+struct FitRects {
+  SkRect src;
+  SkRect dst;
+};
+
+static PropId PropNameImage = JsiPropId::get("image");
+static PropId PropNameFit = JsiPropId::get("fit");
+
+class ImageProp : public DerivedSkProp<SkImage> {
+public:
+  explicit ImageProp(PropId name) : DerivedSkProp<SkImage>() {
+    _imageProp = addProperty(std::make_shared<NodeProp>(name));
+  }
+
+  void updateDerivedValue() override {
+    if (_imageProp->value().getType() != PropType::HostObject) {
+      throw std::runtime_error("Expected SkImage object for the " +
+                               std::string(getName()) + " property.");
+    }
+
+    auto ptr = std::dynamic_pointer_cast<JsiSkImage>(
+        _imageProp->value().getAsHostObject());
+    if (ptr == nullptr) {
+      throw std::runtime_error("Expected SkImage object for the " +
+                               std::string(getName()) + " property.");
+    }
+
+    setDerivedValue(ptr->getObject());
+  }
+
+private:
+  NodeProp *_imageProp;
+};
+
+class ImageProps : public DerivedProp<FitRects> {
+public:
+  ImageProps() : DerivedProp<FitRects>() {
+    _fitProp = addProperty(std::make_shared<NodeProp>(PropNameFit));
+    _imageProp = addProperty(std::make_shared<ImageProp>(PropNameImage));
+    _rectProp = addProperty(std::make_shared<RectProps>(PropNameRect));
+  }
+
+  void updateDerivedValue() override {
+    if (!_imageProp->isSet()) {
+      throw std::runtime_error("Image property is not set on the Image node.");
+    }
+
+    auto image = _imageProp->getDerivedValue();
+    auto imageRect = SkRect::MakeXYWH(0, 0, image->width(), image->height());
+
+    auto rect = _rectProp->getDerivedValue() ? *_rectProp->getDerivedValue()
+                                             : imageRect;
+    auto fit = _fitProp->isSet() ? _fitProp->value().getAsString() : "none";
+
+    setDerivedValue(fitRects(fit, imageRect, rect));
+  }
+
+  sk_sp<SkImage> getImage() { return _imageProp->getDerivedValue(); }
+  std::shared_ptr<SkRect> getRect() { return _rectProp->getDerivedValue(); }
+
+  SkRect rect2rect(SkRect src, SkRect dst) {
+    auto scaleX = dst.width() / src.width();
+    auto scaleY = dst.height() / src.height();
+    auto translateX = dst.x() - src.x() * scaleX;
+    auto translateY = dst.y() - src.y() * scaleY;
+    return SkRect::MakeXYWH(translateX, translateY, scaleX, scaleY);
+  }
+
+private:
+  SkSize size(double width, double height) {
+    return SkSize::Make(width, height);
+  }
+
+  FitRects fitRects(const std::string &fit, SkRect rect, SkRect rect2) {
+    auto sizes = applyBoxFit(fit, size(rect.width(), rect.height()),
+                             size(rect2.width(), rect2.height()));
+
+    auto src = inscribe(sizes.src, rect);
+    auto dst = inscribe(sizes.dst, rect2);
+
+    return {.src = src, .dst = dst};
+  }
+
+  SkRect inscribe(SkSize size, SkRect rect) {
+    auto halfWidthDelta = (rect.width() - size.width()) / 2.0;
+    auto halfHeightDelta = (rect.height() - size.height()) / 2.0;
+    return SkRect::MakeXYWH(rect.x() + halfWidthDelta,
+                            rect.y() + halfHeightDelta, size.width(),
+                            size.height());
+  }
+
+  FitSizes applyBoxFit(const std::string fit, SkSize input, SkSize output) {
+    SkSize src = size(0, 0);
+    SkSize dst = size(0, 0);
+
+    if (input.height() <= 0.0 || input.width() <= 0.0 ||
+        output.height() <= 0.0 || output.width() <= 0.0) {
+      return {.src = src, .dst = dst};
+    }
+
+    if (fit == "fill") {
+      src = input;
+      dst = output;
+    } else if (fit == "contain") {
+      src = input;
+      if (output.width() / output.height() > src.width() / src.height()) {
+        dst = size((src.width() * output.height()) / src.height(),
+                   output.height());
+      } else {
+        dst =
+            size(output.width(), (src.height() * output.width()) / src.width());
+      }
+    } else if (fit == "cover") {
+      if (output.width() / output.height() > input.width() / input.height()) {
+        src = size(input.width(),
+                   (input.width() * output.height()) / output.width());
+      } else {
+        src = size((input.height() * output.width()) / output.height(),
+                   input.height());
+      }
+      dst = output;
+    } else if (fit == "fitWidth") {
+      src = size(input.width(),
+                 (input.width() * output.height()) / output.width());
+      dst = size(output.width(), (src.height() * output.width()) / src.width());
+    } else if (fit == "fitHeight") {
+      src = size((input.height() * output.width()) / output.height(),
+                 input.height());
+      dst =
+          size((src.width() * output.height()) / src.height(), output.height());
+    } else if (fit == "none") {
+      src = size(std::min(input.width(), output.width()),
+                 std::min(input.height(), output.height()));
+      dst = src;
+    } else if (fit == "scaleDown") {
+      src = input;
+      dst = input;
+      auto aspectRatio = input.width() / input.height();
+      if (dst.height() > output.height()) {
+        dst = size(output.height() * aspectRatio, output.height());
+      }
+      if (dst.width() > output.width()) {
+        dst = size(output.width(), output.width() / aspectRatio);
+      }
+    } else {
+      throw std::runtime_error("The value \"" + fit +
+                               "\" is not a valid fit value.");
+    }
+    return {.src = src, .dst = dst};
+  }
+
+  NodeProp *_fitProp;
+  ImageProp *_imageProp;
+  RectProps *_rectProp;
+};
+} // namespace RNSkia

package/cpp/rnskia/dom/props/LayerProp.h

@@ -0,0 +1,50 @@
+#pragma once
+
+#include "DerivedNodeProp.h"
+
+#include "PaintProps.h"
+
+#include <memory>
+
+namespace RNSkia {
+
+class LayerProp : public DerivedProp<SkPaint> {
+public:
+  explicit LayerProp(PropId name) : DerivedProp<SkPaint>() {
+    _layerPaintProp = addProperty(std::make_shared<PaintProp>(name));
+    _layerBoolProp = addProperty(std::make_shared<NodeProp>(name));
+  }
+
+  /**
+   Returns true if is optional and one of the child props has a value, or all
+   props if optional is false.
+   */
+  bool isSet() override { return DerivedProp<SkPaint>::isSet() || _isBool; };
+
+  void updateDerivedValue() override {
+    if (_layerBoolProp->isSet() &&
+        _layerBoolProp->value().getType() == PropType::Bool) {
+      _isBool = true;
+      setDerivedValue(nullptr);
+      return;
+    }
+
+    if (_layerPaintProp->isSet()) {
+      // We have a paint object for the layer property
+      setDerivedValue(_layerPaintProp->getDerivedValue());
+      _isBool = false;
+    } else {
+      _isBool = false;
+      setDerivedValue(nullptr);
+    }
+  }
+
+  bool isBool() { return _isBool; }
+
+private:
+  PaintProp *_layerPaintProp;
+  NodeProp *_layerBoolProp;
+  std::atomic<bool> _isBool;
+};
+
+} // namespace RNSkia

package/cpp/rnskia/dom/props/MatrixProp.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include "DerivedNodeProp.h"
+#include "JsiSkMatrix.h"
+
+#include <memory>
+
+namespace RNSkia {
+
+static PropId PropNameMatrix = JsiPropId::get("matrix");
+
+class MatrixProp : public DerivedProp<SkMatrix> {
+public:
+  explicit MatrixProp(PropId name) : DerivedProp<SkMatrix>() {
+    _matrixProp = addProperty(std::make_shared<NodeProp>(name));
+  }
+
+  void updateDerivedValue() override {
+    if (_matrixProp->isSet() &&
+        _matrixProp->value().getType() == PropType::HostObject) {
+      // Try reading as SkMatrix
+      auto matrix = _matrixProp->value().getAs<JsiSkMatrix>();
+      if (matrix != nullptr) {
+        setDerivedValue(matrix->getObject());
+      }
+    }
+  }
+
+private:
+  NodeProp *_matrixProp;
+};
+
+} // namespace RNSkia

package/cpp/rnskia/dom/props/NumbersProp.h

@@ -0,0 +1,63 @@
+#pragma once
+
+#include "DerivedNodeProp.h"
+
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace RNSkia {
+
+class NumbersProp : public DerivedProp<std::vector<SkScalar>> {
+public:
+  explicit NumbersProp(PropId name) : DerivedProp<std::vector<SkScalar>>() {
+    _positionProp = addProperty(std::make_shared<NodeProp>(name));
+  }
+
+  void updateDerivedValue() override {
+    if (_positionProp->isSet()) {
+      auto positions = _positionProp->value().getAsArray();
+      std::vector<SkScalar> derivedPositions;
+      derivedPositions.reserve(positions.size());
+
+      for (size_t i = 0; i < positions.size(); ++i) {
+        derivedPositions.push_back(positions[i].getAsNumber());
+      }
+      setDerivedValue(std::move(derivedPositions));
+    } else {
+      setDerivedValue(nullptr);
+    }
+  }
+
+private:
+  NodeProp *_positionProp;
+};
+
+class Numbers16Prop : public DerivedProp<std::vector<u_int16_t>> {
+public:
+  explicit Numbers16Prop(PropId name) : DerivedProp<std::vector<u_int16_t>>() {
+    _prop = addProperty(std::make_shared<NodeProp>(name));
+  }
+
+  void updateDerivedValue() override {
+    if (_prop->isSet()) {
+      auto positions = _prop->value().getAsArray();
+      std::vector<u_int16_t> derivedPositions;
+      derivedPositions.reserve(positions.size());
+
+      for (size_t i = 0; i < positions.size(); ++i) {
+        derivedPositions.push_back(
+            static_cast<u_int16_t>(positions[i].getAsNumber()));
+      }
+      setDerivedValue(std::move(derivedPositions));
+    } else {
+      setDerivedValue(nullptr);
+    }
+  }
+
+private:
+  NodeProp *_prop;
+};
+
+} // namespace RNSkia

package/cpp/rnskia/dom/props/PaintProps.h

@@ -0,0 +1,171 @@
+#pragma once
+
+#include "BlendModeProp.h"
+#include "ColorProp.h"
+#include "NodeProp.h"
+#include "StrokeProps.h"
+
+#include "JsiSkPaint.h"
+#include "third_party/CSSColorParser.h"
+
+#include <memory>
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include <SkPaint.h>
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+static PropId PropNameCurrent = JsiPropId::get("current");
+
+class PaintProp : public DerivedProp<SkPaint> {
+public:
+  explicit PaintProp(PropId name) : DerivedProp<SkPaint>() {
+    _paintProp = addProperty(std::make_shared<NodeProp>(name));
+  }
+
+  PaintProp() : PaintProp(JsiPropId::get("paint")) {}
+
+  void updateDerivedValue() override {
+    if (_paintProp->isSet()) {
+      if (_paintProp->value().getType() == PropType::HostObject) {
+        // Read paint property as Host Object - JsiSkPaint
+        auto ptr = _paintProp->value().getAs<JsiSkPaint>();
+        if (ptr != nullptr) {
+          setDerivedValue(ptr->getObject());
+        } else {
+          throw std::runtime_error("Expected SkPaint object, got unknown "
+                                   "object when reading paint property.");
+        }
+      } else if (_paintProp->value().getType() == PropType::Object) {
+        // We have a JS object - is it a ref?
+        auto ref = _paintProp->value().getValue(PropNameCurrent);
+        if (ref.getType() == PropType::HostObject) {
+          auto ptr = ref.getAs<JsiSkPaint>();
+          if (ptr != nullptr) {
+            // Update the local paint for the current context
+            setDerivedValue(ptr->getObject());
+          } else {
+            throw std::runtime_error(
+                "Expected reference to a SkPaint object, got unknown object "
+                "when reading paint property.");
+          }
+        }
+      } else {
+        setDerivedValue(nullptr);
+      }
+    } else {
+      setDerivedValue(nullptr);
+    }
+  }
+
+private:
+  NodeProp *_paintProp;
+};
+
+class PaintProps : public BaseDerivedProp {
+public:
+  PaintProps() : BaseDerivedProp() {
+    _color = addProperty(std::make_shared<ColorProp>(JsiPropId::get("color")));
+    _style = addProperty(std::make_shared<NodeProp>(JsiPropId::get("style")));
+    _strokeWidth =
+        addProperty(std::make_shared<NodeProp>(JsiPropId::get("strokeWidth")));
+    _blendMode = addProperty(
+        std::make_shared<BlendModeProp>(JsiPropId::get("blendMode")));
+    _strokeJoin = addProperty(
+        std::make_shared<StrokeJoinProp>(JsiPropId::get("strokeJoin")));
+    _strokeCap = addProperty(
+        std::make_shared<StrokeCapProp>(JsiPropId::get("strokeCap")));
+    _strokeMiter =
+        addProperty(std::make_shared<NodeProp>(JsiPropId::get("strokeMiter")));
+    _antiAlias =
+        addProperty(std::make_shared<NodeProp>(JsiPropId::get("antiAlias")));
+    _opacity =
+        addProperty(std::make_shared<NodeProp>(JsiPropId::get("opacity")));
+  }
+
+  void decorate(DrawingContext *context) {
+    // Now we can start updating the context
+
+    // Opacity
+    if (_opacity->isChanged() || context->isChanged()) {
+      if (_opacity->isSet()) {
+        context->setOpacity(_opacity->value().getAsNumber());
+      } else {
+        context->clearOpacity();
+      }
+    }
+
+    // COLOR
+    if (_color->isSet() && (_color->isChanged() || context->isChanged())) {
+      auto paint = context->getMutablePaint();
+      paint->setShader(nullptr);
+      paint->setColor(*_color->getDerivedValue());
+      paint->setAlphaf(context->getOpacity() * paint->getColor4f().fA);
+    }
+
+    // Style
+    if (_style->isSet() && (_style->isChanged() || context->isChanged())) {
+      auto styleValue = _style->value().getAsString();
+      if (styleValue == "stroke") {
+        context->getMutablePaint()->setStyle(SkPaint::Style::kStroke_Style);
+      } else if (styleValue == "fill") {
+        context->getMutablePaint()->setStyle(SkPaint::Style::kFill_Style);
+      } else {
+        throw std::runtime_error(
+            styleValue + " is not a valud value for the style property.");
+      }
+    }
+    // Stroke Width
+    if (_strokeWidth->isSet() &&
+        (_strokeWidth->isChanged() || context->isChanged())) {
+      context->getMutablePaint()->setStrokeWidth(
+          _strokeWidth->value().getAsNumber());
+    }
+    // Blend mode
+    if (_blendMode->isSet() &&
+        (_blendMode->isChanged() || context->isChanged())) {
+      context->getMutablePaint()->setBlendMode(*_blendMode->getDerivedValue());
+    }
+    // Stroke Join
+    if (_strokeJoin->isSet() &&
+        (_strokeJoin->isChanged() || context->isChanged())) {
+      context->getMutablePaint()->setStrokeJoin(
+          *_strokeJoin->getDerivedValue());
+    }
+    // Stroke Cap
+    if (_strokeCap->isSet() &&
+        (_strokeCap->isChanged() || context->isChanged())) {
+      context->getMutablePaint()->setStrokeCap(*_strokeCap->getDerivedValue());
+    }
+    // Stroke Miter
+    if (_strokeMiter->isSet() &&
+        (_strokeMiter->isChanged() || context->isChanged())) {
+      context->getMutablePaint()->setStrokeMiter(
+          _strokeMiter->value().getAsNumber());
+    }
+    // AntiAlias
+    if (_antiAlias->isSet() &&
+        (_antiAlias->isChanged() || context->isChanged())) {
+      context->getMutablePaint()->setAntiAlias(_antiAlias->value().getAsBool());
+    }
+  }
+
+  void updateDerivedValue() override {}
+
+private:
+  ColorProp *_color;
+  NodeProp *_style;
+  NodeProp *_strokeWidth;
+  BlendModeProp *_blendMode;
+  StrokeJoinProp *_strokeJoin;
+  StrokeCapProp *_strokeCap;
+  NodeProp *_strokeMiter;
+  NodeProp *_antiAlias;
+  NodeProp *_opacity;
+};
+
+} // namespace RNSkia

package/cpp/rnskia/dom/props/PathProp.h

@@ -0,0 +1,55 @@
+#pragma once
+
+#include "DerivedNodeProp.h"
+#include "JsiSkPath.h"
+
+#include <memory>
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include <SkPath.h>
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+class PathProp : public DerivedProp<SkPath> {
+public:
+  explicit PathProp(PropId name) : DerivedProp<SkPath>() {
+    _pathProp = addProperty(std::make_shared<NodeProp>(name));
+  }
+
+  void updateDerivedValue() override {
+    if (!_pathProp->isSet()) {
+      setDerivedValue(nullptr);
+      return;
+    }
+
+    if (_pathProp->value().getType() == PropType::HostObject) {
+      // Try reading as Path
+      auto ptr = std::dynamic_pointer_cast<JsiSkPath>(
+          _pathProp->value().getAsHostObject());
+      if (ptr != nullptr) {
+        setDerivedValue(ptr->getObject());
+      }
+    } else if (_pathProp->value().getType() == PropType::String) {
+      // Read as string
+      auto pathString = _pathProp->value().getAsString();
+      SkPath result;
+
+      if (SkParsePath::FromSVGString(pathString.c_str(), &result)) {
+        setDerivedValue(std::make_shared<SkPath>(result));
+      } else {
+        throw std::runtime_error("Could not parse path from string.");
+      }
+    } else {
+      setDerivedValue(nullptr);
+    }
+  }
+
+private:
+  NodeProp *_pathProp;
+};
+
+} // namespace RNSkia

package/cpp/rnskia/dom/props/PictureProp.h

@@ -0,0 +1,38 @@
+#pragma once
+
+#include "DerivedNodeProp.h"
+
+#include "JsiSkPicture.h"
+
+#include <memory>
+#include <string>
+
+namespace RNSkia {
+
+class PictureProp : public DerivedSkProp<SkPicture> {
+public:
+  explicit PictureProp(PropId name) : DerivedSkProp<SkPicture>() {
+    _pictureProp = addProperty(std::make_shared<NodeProp>(name));
+  }
+
+  void updateDerivedValue() override {
+    if (_pictureProp->value().getType() != PropType::HostObject) {
+      throw std::runtime_error("Expected SkPicture object for the " +
+                               std::string(getName()) + " property.");
+    }
+
+    auto ptr = std::dynamic_pointer_cast<JsiSkPicture>(
+        _pictureProp->value().getAsHostObject());
+    if (ptr == nullptr) {
+      throw std::runtime_error("Expected SkPicture object for the " +
+                               std::string(getName()) + " property.");
+    }
+
+    setDerivedValue(ptr->getObject());
+  }
+
+private:
+  NodeProp *_pictureProp;
+};
+
+} // namespace RNSkia

package/cpp/rnskia/dom/props/PointProp.h

@@ -0,0 +1,72 @@
+#pragma once
+
+#include "DerivedNodeProp.h"
+#include "JsiSkPoint.h"
+
+#include <memory>
+#include <utility>
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include <SkPoint.h>
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+static PropId PropNameX = JsiPropId::get("x");
+static PropId PropNameY = JsiPropId::get("y");
+static SkPoint EmptyPoint = SkPoint::Make(-1, -1);
+
+class PointProp : public DerivedProp<SkPoint> {
+public:
+  explicit PointProp(PropId name) : DerivedProp<SkPoint>() {
+    _pointProp = addProperty(std::make_shared<NodeProp>(name));
+  }
+
+  void updateDerivedValue() override {
+    auto point = processProperty(_pointProp);
+    if (EmptyPoint != point) {
+      setDerivedValue(std::move(point));
+    } else {
+      setDerivedValue(nullptr);
+    }
+  }
+
+  static SkPoint processValue(const JsiValue &value) {
+    if (value.getType() == PropType::HostObject) {
+      // Try reading as point
+      auto ptr = std::dynamic_pointer_cast<JsiSkPoint>(value.getAsHostObject());
+      if (ptr != nullptr) {
+        return SkPoint::Make(ptr->getObject()->x(), ptr->getObject()->y());
+      } else {
+        // Try reading as rect
+        auto ptr =
+            std::dynamic_pointer_cast<JsiSkRect>(value.getAsHostObject());
+        if (ptr != nullptr) {
+          return SkPoint::Make(ptr->getObject()->x(), ptr->getObject()->y());
+        }
+      }
+    } else if (value.getType() == PropType::Object &&
+               value.hasValue(PropNameX) && value.hasValue(PropNameY)) {
+      auto x = value.getValue(PropNameX);
+      auto y = value.getValue(PropNameY);
+      return SkPoint::Make(x.getAsNumber(), y.getAsNumber());
+    }
+    return EmptyPoint;
+  }
+
+  static SkPoint processProperty(NodeProp *prop) {
+    if (prop->isSet()) {
+      // Check for JsiSkRect and JsiSkPoint
+      return processValue(prop->value());
+    }
+    return EmptyPoint;
+  }
+
+private:
+  NodeProp *_pointProp;
+};
+
+} // namespace RNSkia