@shopify/react-native-skia 1.10.2 → 1.11.1

package/cpp/api/recorder/Paint.h

@@ -0,0 +1,191 @@
+#pragma once
+
+#include <optional>
+#include <string>
+#include <variant>
+
+#include "Command.h"
+#include "Convertor.h"
+#include "DrawingCtx.h"
+
+namespace RNSkia {
+
+struct TransformProps {
+  std::optional<SkM44> transform;
+  std::optional<SkPoint> origin;
+  std::optional<SkMatrix> matrix;
+};
+
+// TODO: can we avoid a copy here?
+SkMatrix processTransform(std::optional<SkMatrix> &matrix,
+                          std::optional<SkM44> &transform,
+                          std::optional<SkPoint> &origin) {
+  SkMatrix m3;
+  if (matrix.has_value()) {
+    m3 = matrix.value();
+    if (origin.has_value()) {
+      m3.postTranslate(origin.value().x(), origin.value().y());
+      m3.preTranslate(-origin.value().x(), -origin.value().y());
+    }
+  } else if (transform.has_value()) {
+    auto m4 = transform.value();
+    if (origin.has_value()) {
+      m4.postTranslate(origin.value().x(), origin.value().y());
+      m4.preTranslate(-origin.value().x(), -origin.value().y());
+    }
+    m3 = m4.asM33();
+  }
+  return m3;
+}
+
+struct CTMCmdProps : TransformProps {
+  std::optional<ClipDef> clip;
+  std::optional<bool> invertClip;
+  std::optional<Layer> layer;
+};
+
+class SaveCTMCmd : public Command {
+private:
+  CTMCmdProps props;
+
+public:
+  SaveCTMCmd(jsi::Runtime &runtime, const jsi::Object &object,
+             Variables &variables)
+      : Command(CommandType::SaveCTM) {
+    convertProperty(runtime, object, "transform", props.transform, variables);
+    convertProperty(runtime, object, "origin", props.origin, variables);
+    convertProperty(runtime, object, "matrix", props.matrix, variables);
+    convertProperty(runtime, object, "clip", props.clip, variables);
+    convertProperty(runtime, object, "invertClip", props.invertClip, variables);
+    convertProperty(runtime, object, "layer", props.layer, variables);
+  }
+
+  void saveCTM(DrawingCtx *ctx) {
+    auto clip = props.clip;
+    auto invertClip = props.invertClip;
+    auto layer = props.layer;
+    auto hasTransform = props.matrix.has_value() || props.transform.has_value();
+    auto hasClip = clip.has_value();
+    auto op = invertClip.has_value() && invertClip.value()
+                  ? SkClipOp::kDifference
+                  : SkClipOp::kIntersect;
+    auto shouldSave = hasTransform || hasClip || layer.has_value();
+    SkMatrix m3 = processTransform(props.matrix, props.transform, props.origin);
+    if (shouldSave) {
+      if (layer.has_value()) {
+        if (std::holds_alternative<bool>(layer.value())) {
+          ctx->canvas->saveLayer(nullptr, nullptr);
+        } else {
+          auto paint = std::get<SkPaint>(layer.value());
+          ctx->canvas->saveLayer(nullptr, &paint);
+        }
+      } else {
+        ctx->canvas->save();
+      }
+      ctx->canvas->concat(m3);
+    }
+    if (clip.has_value()) {
+      auto c = clip.value();
+      if (std::holds_alternative<SkPath>(c)) {
+        auto path = std::get<SkPath>(c);
+        ctx->canvas->clipPath(path, op);
+      } else if (std::holds_alternative<std::string>(c)) {
+        auto pathString = std::get<std::string>(c);
+        SkPath result;
+        if (SkParsePath::FromSVGString(pathString.c_str(), &result)) {
+          ctx->canvas->clipPath(result, op);
+        } else {
+          throw std::runtime_error("Could not parse path from string.");
+        }
+      } else if (std::holds_alternative<SkRect>(c)) {
+        auto rect = std::get<SkRect>(c);
+        ctx->canvas->clipRect(rect, op);
+      } else if (std::holds_alternative<SkRRect>(c)) {
+        auto rrect = std::get<SkRRect>(c);
+        ctx->canvas->clipRRect(rrect, op);
+      }
+    }
+  }
+};
+
+struct PaintCmdProps {
+  std::optional<SkColor> color;
+  std::optional<SkBlendMode> blendMode;
+  std::optional<SkPaint::Style> style;
+  std::optional<SkPaint::Join> strokeJoin;
+  std::optional<SkPaint::Cap> strokeCap;
+  std::optional<float> strokeMiter;
+  std::optional<float> strokeWidth;
+  std::optional<float> opacity;
+  std::optional<bool> antiAlias;
+  std::optional<bool> dither;
+  std::optional<SkPaint> paint;
+};
+
+class SavePaintCmd : public Command {
+private:
+  PaintCmdProps props;
+
+public:
+  SavePaintCmd(jsi::Runtime &runtime, const jsi::Object &object,
+               Variables &variables)
+      : Command(CommandType::SavePaint) {
+    convertProperty(runtime, object, "color", props.color, variables);
+    convertProperty(runtime, object, "blendMode", props.blendMode, variables);
+    convertProperty(runtime, object, "style", props.style, variables);
+    convertProperty(runtime, object, "strokeJoin", props.strokeJoin, variables);
+    convertProperty(runtime, object, "strokeCap", props.strokeCap, variables);
+    convertProperty(runtime, object, "strokeMiter", props.strokeMiter,
+                    variables);
+    convertProperty(runtime, object, "strokeWidth", props.strokeWidth,
+                    variables);
+    convertProperty(runtime, object, "opacity", props.opacity, variables);
+    convertProperty(runtime, object, "antiAlias", props.antiAlias, variables);
+    convertProperty(runtime, object, "dither", props.dither, variables);
+    convertProperty(runtime, object, "paint", props.paint, variables);
+  }
+
+  void savePaint(DrawingCtx *ctx) {
+    if (props.paint.has_value()) {
+      ctx->pushPaint(props.paint.value());
+      return;
+    }
+    ctx->savePaint();
+    auto &paint = ctx->getPaint();
+    if (props.opacity.has_value()) {
+      paint.setAlphaf(paint.getAlphaf() * props.opacity.value());
+    }
+    if (props.color.has_value()) {
+      auto currentOpacity = paint.getAlphaf();
+      paint.setShader(nullptr);
+      paint.setColor(props.color.value());
+      paint.setAlphaf(currentOpacity * paint.getAlphaf());
+    }
+    if (props.blendMode.has_value()) {
+      paint.setBlendMode(props.blendMode.value());
+    }
+    if (props.style.has_value()) {
+      paint.setStyle(props.style.value());
+    }
+    if (props.strokeJoin.has_value()) {
+      paint.setStrokeJoin(props.strokeJoin.value());
+    }
+    if (props.strokeCap.has_value()) {
+      paint.setStrokeCap(props.strokeCap.value());
+    }
+    if (props.strokeMiter.has_value()) {
+      paint.setStrokeMiter(props.strokeMiter.value());
+    }
+    if (props.strokeWidth.has_value()) {
+      paint.setStrokeWidth(props.strokeWidth.value());
+    }
+    if (props.antiAlias.has_value()) {
+      paint.setAntiAlias(props.antiAlias.value());
+    }
+    if (props.dither.has_value()) {
+      paint.setDither(props.dither.value());
+    }
+  }
+};
+
+} // namespace RNSkia

package/cpp/api/recorder/PathEffects.h

@@ -0,0 +1,194 @@
+#pragma once
+
+#include <optional>
+#include <string>
+#include <variant>
+
+#include "Command.h"
+#include "Convertor.h"
+#include "DrawingCtx.h"
+
+namespace RNSkia {
+
+struct DiscretePathEffectProps {
+  float length;
+  float deviation;
+  uint32_t seed;
+};
+
+class DiscretePathEffectCmd : public Command {
+private:
+  DiscretePathEffectProps props;
+
+public:
+  DiscretePathEffectCmd(jsi::Runtime &runtime, const jsi::Object &object,
+                        Variables &variables)
+      : Command(CommandType::PushPathEffect, "skDiscretePathEffect") {
+    convertProperty(runtime, object, "length", props.length, variables);
+    convertProperty(runtime, object, "deviation", props.deviation, variables);
+    convertProperty(runtime, object, "seed", props.seed, variables);
+  }
+
+  void pushPathEffect(DrawingCtx *ctx) {
+    auto pe =
+        SkDiscretePathEffect::Make(props.length, props.deviation, props.seed);
+    ctx->pathEffects.push_back(pe);
+  }
+};
+
+struct DashPathEffectProps {
+  std::vector<float> intervals;
+  float phase = 0;
+};
+
+class DashPathEffectCmd : public Command {
+private:
+  DashPathEffectProps props;
+
+public:
+  DashPathEffectCmd(jsi::Runtime &runtime, const jsi::Object &object,
+                    Variables &variables)
+      : Command(CommandType::PushPathEffect, "skDashPathEffect") {
+    convertProperty(runtime, object, "intervals", props.intervals, variables);
+    convertProperty(runtime, object, "phase", props.phase, variables);
+  }
+
+  void pushPathEffect(DrawingCtx *ctx) {
+    auto pe = SkDashPathEffect::Make(props.intervals.data(),
+                                     props.intervals.size(), props.phase);
+    ctx->pathEffects.push_back(pe);
+  }
+};
+
+struct Path1DPathEffectProps {
+  SkPath path;
+  float advance;
+  float phase;
+  SkPath1DPathEffect::Style style;
+};
+
+class Path1DPathEffectCmd : public Command {
+private:
+  Path1DPathEffectProps props;
+
+public:
+  Path1DPathEffectCmd(jsi::Runtime &runtime, const jsi::Object &object,
+                      Variables &variables)
+      : Command(CommandType::PushPathEffect, "skPath1DPathEffect") {
+    convertProperty(runtime, object, "path", props.path, variables);
+    convertProperty(runtime, object, "advance", props.advance, variables);
+    convertProperty(runtime, object, "phase", props.phase, variables);
+    convertProperty(runtime, object, "style", props.style, variables);
+  }
+
+  void pushPathEffect(DrawingCtx *ctx) {
+    auto pe = SkPath1DPathEffect::Make(props.path, props.advance, props.phase,
+                                       props.style);
+    if (pe) {
+      ctx->pathEffects.push_back(pe);
+    }
+  }
+};
+
+struct Path2DPathEffectProps {
+  SkMatrix matrix;
+  SkPath path;
+};
+
+class Path2DPathEffectCmd : public Command {
+private:
+  Path2DPathEffectProps props;
+
+public:
+  Path2DPathEffectCmd(jsi::Runtime &runtime, const jsi::Object &object,
+                      Variables &variables)
+      : Command(CommandType::PushPathEffect, "skPath2DPathEffect") {
+    convertProperty(runtime, object, "matrix", props.matrix, variables);
+    convertProperty(runtime, object, "path", props.path, variables);
+  }
+
+  void pushPathEffect(DrawingCtx *ctx) {
+    auto pe = SkPath2DPathEffect::Make(props.matrix, props.path);
+    if (pe) {
+      ctx->pathEffects.push_back(pe);
+    }
+  }
+};
+
+struct CornerPathEffectProps {
+  float r;
+};
+
+class CornerPathEffectCmd : public Command {
+private:
+  CornerPathEffectProps props;
+
+public:
+  CornerPathEffectCmd(jsi::Runtime &runtime, const jsi::Object &object,
+                      Variables &variables)
+      : Command(CommandType::PushPathEffect, "skCornerPathEffect") {
+    convertProperty(runtime, object, "r", props.r, variables);
+  }
+
+  void pushPathEffect(DrawingCtx *ctx) {
+    auto pe = SkCornerPathEffect::Make(props.r);
+    if (pe) {
+      ctx->pathEffects.push_back(pe);
+    }
+  }
+};
+
+class SumPathEffectCmd : public Command {
+public:
+  SumPathEffectCmd(jsi::Runtime &runtime, const jsi::Object &object,
+                   Variables &variables)
+      : Command(CommandType::PushPathEffect, "skSumPathEffect") {}
+
+  void pushPathEffect(DrawingCtx *ctx) {
+    // Get all path effects
+    auto effects = std::move(ctx->pathEffects);
+    ctx->pathEffects.clear(); // Clear the vector since we moved from it
+
+    // Create composer function for path effects
+    Composer<SkPathEffect> pathEffectComposer = [](sk_sp<SkPathEffect> outer,
+                                                   sk_sp<SkPathEffect> inner) {
+      return SkPathEffect::MakeSum(outer, inner);
+    };
+
+    // Compose all effects
+    auto composedEffect =
+        composeEffects<SkPathEffect>(effects, pathEffectComposer);
+
+    // If we got a valid composed effect, push it back
+    if (composedEffect) {
+      ctx->pathEffects.push_back(std::move(composedEffect));
+    }
+  }
+};
+
+struct Line2DPathEffectProps {
+  float width;
+  SkMatrix matrix;
+};
+
+class Line2DPathEffectCmd : public Command {
+private:
+  Line2DPathEffectProps props;
+
+public:
+  Line2DPathEffectCmd(jsi::Runtime &runtime, const jsi::Object &object,
+                      Variables &variables)
+      : Command(CommandType::PushPathEffect, "skLine2DPathEffect") {
+    convertProperty(runtime, object, "width", props.width, variables);
+    convertProperty(runtime, object, "matrix", props.matrix, variables);
+  }
+
+  void pushPathEffect(DrawingCtx *ctx) {
+    auto pe = SkLine2DPathEffect::Make(props.width, props.matrix);
+    if (pe) {
+      ctx->pathEffects.push_back(pe);
+    }
+  }
+};
+
+} // namespace RNSkia