@shopify/react-native-skia 1.10.2 → 1.11.1

package/cpp/api/recorder/DataTypes.h

@@ -0,0 +1,232 @@
+#pragma once
+
+#include <jsi/jsi.h>
+
+namespace RNSkia {
+
+using Uniforms = std::map<std::string, std::vector<float>>;
+
+std::vector<float> processArray(jsi::Runtime &runtime,
+                                const jsi::Array &array) {
+  std::vector<float> result;
+  size_t length = array.length(runtime);
+  result.reserve(length);
+
+  for (size_t i = 0; i < length; i++) {
+    jsi::Value element = array.getValueAtIndex(runtime, i);
+    if (element.isNumber()) {
+      result.push_back(static_cast<float>(element.asNumber()));
+    } else if (element.isObject() &&
+               element.asObject(runtime).isArray(runtime)) {
+      auto subArray =
+          processArray(runtime, element.asObject(runtime).asArray(runtime));
+      result.insert(result.end(), subArray.begin(), subArray.end());
+    } else if (element.isObject()) {
+      auto indexableObj = element.asObject(runtime);
+      std::vector<float> values;
+      values.reserve(4);
+      for (int i = 0; i < 4; i++) {
+        if (indexableObj.hasProperty(runtime, std::to_string(i).c_str())) {
+          result.push_back(static_cast<float>(
+              indexableObj.getProperty(runtime, std::to_string(i).c_str())
+                  .asNumber()));
+        }
+      }
+    }
+  }
+  return result;
+}
+
+bool isJSPoint(jsi::Runtime &runtime, const jsi::Value &value) {
+  return value.isObject() &&
+         value.asObject(runtime).hasProperty(runtime, "x") &&
+         value.asObject(runtime).hasProperty(runtime, "y");
+}
+
+bool isIndexable(jsi::Runtime &runtime, const jsi::Value &value) {
+  return value.isObject() && value.asObject(runtime).hasProperty(runtime, "0");
+}
+
+std::shared_ptr<SkRect> processRect(jsi::Runtime &runtime,
+                                    const jsi::Value &value) {
+  if (value.isObject()) {
+    auto object = value.asObject(runtime);
+    if (object.isHostObject(runtime)) {
+      auto ptr = std::dynamic_pointer_cast<JsiSkRect>(
+          value.asObject(runtime).asHostObject(runtime));
+      if (ptr != nullptr) {
+        return ptr->getObject();
+      }
+    } else if (object.hasProperty(runtime, "x") &&
+               object.hasProperty(runtime, "y") &&
+               object.hasProperty(runtime, "width") &&
+               object.hasProperty(runtime, "height")) {
+      auto x = object.getProperty(runtime, "x").getNumber();
+      auto y = object.getProperty(runtime, "y").getNumber();
+      auto width = object.getProperty(runtime, "width").getNumber();
+      auto height = object.getProperty(runtime, "height").getNumber();
+      return std::make_shared<SkRect>(SkRect::MakeXYWH(x, y, width, height));
+    }
+  }
+  return nullptr;
+}
+
+SkPoint processPoint(jsi::Runtime &runtime, const jsi::Value &value) {
+  if (value.isObject()) {
+    auto object = value.asObject(runtime);
+    if (object.hasProperty(runtime, "x") && object.hasProperty(runtime, "y")) {
+      auto x = static_cast<float>(object.getProperty(runtime, "x").getNumber());
+      auto y = static_cast<float>(object.getProperty(runtime, "y").getNumber());
+      return SkPoint::Make(x, y);
+    }
+  }
+  throw std::runtime_error("Couldn't read point value");
+};
+
+// TODO: return the SkRRect directly
+std::shared_ptr<SkRRect> processRRect(jsi::Runtime &runtime,
+                                      const jsi::Value &value) {
+  if (value.isObject()) {
+    auto object = value.asObject(runtime);
+    if (object.isHostObject(runtime)) {
+      auto ptr = std::dynamic_pointer_cast<JsiSkRRect>(
+          value.asObject(runtime).asHostObject(runtime));
+      if (ptr != nullptr) {
+        return ptr->getObject();
+      }
+    } else if (object.hasProperty(runtime, "rect") &&
+               object.hasProperty(runtime, "rx") &&
+               object.hasProperty(runtime, "ry")) {
+      auto rect = processRect(runtime, object.getProperty(runtime, "rect"));
+      auto rx = object.getProperty(runtime, "rx").getNumber();
+      auto ry = object.getProperty(runtime, "ry").getNumber();
+      return std::make_shared<SkRRect>(SkRRect::MakeRectXY(*rect, rx, ry));
+    } else if (object.hasProperty(runtime, "rect") &&
+               object.hasProperty(runtime, "topLeft") &&
+               object.hasProperty(runtime, "topRight") &&
+               object.hasProperty(runtime, "bottomRight") &&
+               object.hasProperty(runtime, "bottomLeft")) {
+      auto rect = processRect(runtime, object.getProperty(runtime, "rect"));
+      auto topLeft =
+          processPoint(runtime, object.getProperty(runtime, "topLeft"));
+      auto topRight =
+          processPoint(runtime, object.getProperty(runtime, "topRight"));
+      auto bottomRight =
+          processPoint(runtime, object.getProperty(runtime, "bottomRight"));
+      auto bottomLeft =
+          processPoint(runtime, object.getProperty(runtime, "bottomLeft"));
+      auto result = std::make_shared<SkRRect>(SkRRect::MakeRectXY(*rect, 0, 0));
+      const SkVector corners[4] = {topLeft, topRight, bottomRight, bottomLeft};
+      result->setRectRadii(*rect, corners);
+      return result;
+    }
+  }
+  return nullptr;
+}
+
+// Return SkPath instead of shared_ptr<SkPath>
+std::shared_ptr<SkPath> processPath(jsi::Runtime &runtime,
+                                    const jsi::Value &value) {
+  if (value.isString()) {
+    auto pathString = value.getString(runtime).utf8(runtime);
+    SkPath result;
+
+    if (SkParsePath::FromSVGString(pathString.c_str(), &result)) {
+      return std::make_shared<SkPath>(result);
+    } else {
+      throw std::runtime_error("Could not parse path from string.");
+    }
+  } else if (value.isObject() &&
+             value.asObject(runtime).isHostObject(runtime)) {
+    auto ptr = std::dynamic_pointer_cast<JsiSkPath>(
+        value.asObject(runtime).asHostObject(runtime));
+    if (ptr != nullptr) {
+      return ptr->getObject();
+    }
+  }
+  return nullptr;
+}
+
+// Function to process uniforms and return SkData for PushShaderCmd
+inline sk_sp<SkData> processUniforms(const sk_sp<SkRuntimeEffect> &effect,
+                                     const Uniforms &uniforms) {
+
+  size_t uniformSize = effect->uniformSize();
+  auto uniformsData = SkData::MakeUninitialized(uniformSize);
+  auto uniformDataPtr = static_cast<float *>(uniformsData->writable_data());
+
+  const auto &sourceUniforms = effect->uniforms();
+  for (const auto &uniform : sourceUniforms) {
+    auto it = uniforms.find(std::string(uniform.name));
+    if (it == uniforms.end()) {
+      throw std::runtime_error("Missing uniform value for: " +
+                               std::string(uniform.name));
+    }
+
+    const auto &uniformValues = it->second;
+    RuntimeEffectUniform reu = JsiSkRuntimeEffect::fromUniform(uniform);
+    size_t expectedSize = reu.columns * reu.rows;
+
+    if (uniformValues.size() != expectedSize) {
+      throw std::runtime_error(
+          "Incorrect uniform size for: " + std::string(uniform.name) +
+          ". Expected " + std::to_string(expectedSize) + " got " +
+          std::to_string(uniformValues.size()));
+    }
+
+    // Process each element in the uniform
+    for (std::size_t j = 0; j < expectedSize; ++j) {
+      const std::size_t offset = reu.slot + j;
+      float fValue = uniformValues[j];
+
+      if (reu.isInteger) {
+        int iValue = static_cast<int>(fValue);
+        uniformDataPtr[offset] = SkBits2Float(iValue);
+      } else {
+        uniformDataPtr[offset] = fValue;
+      }
+    }
+  }
+
+  return uniformsData;
+}
+
+inline void processUniforms(SkRuntimeShaderBuilder &builder,
+                            const sk_sp<SkRuntimeEffect> &effect,
+                            const Uniforms &uniforms) {
+
+  const auto &sourceUniforms = effect->uniforms();
+  for (const auto &uniform : sourceUniforms) {
+    auto it = uniforms.find(std::string(uniform.name));
+    if (it == uniforms.end()) {
+      throw std::runtime_error("Missing uniform value for: " +
+                               std::string(uniform.name));
+    }
+
+    const auto &uniformValues = it->second;
+    RuntimeEffectUniform reu = JsiSkRuntimeEffect::fromUniform(uniform);
+    size_t expectedSize = reu.columns * reu.rows;
+
+    if (uniformValues.size() != expectedSize) {
+      throw std::runtime_error(
+          "Incorrect uniform size for: " + std::string(uniform.name) +
+          ". Expected " + std::to_string(expectedSize) + " got " +
+          std::to_string(uniformValues.size()));
+    }
+
+    auto builderUniform = builder.uniform(uniform.name);
+
+    if (reu.isInteger) {
+      std::vector<float> convertedValues(uniformValues.size());
+      for (size_t i = 0; i < uniformValues.size(); ++i) {
+        int iValue = static_cast<int>(uniformValues[i]);
+        convertedValues[i] = SkBits2Float(iValue);
+      }
+      builderUniform.set(convertedValues.data(), convertedValues.size());
+    } else {
+      builderUniform.set(uniformValues.data(), uniformValues.size());
+    }
+  }
+}
+
+} // namespace RNSkia

package/cpp/api/recorder/DrawingCtx.h

@@ -0,0 +1,187 @@
+#pragma once
+
+#include <memory>
+#include <vector>
+
+namespace RNSkia {
+
+// Generic composer type using std::function
+template <typename T>
+using Composer = std::function<sk_sp<T>(sk_sp<T>, sk_sp<T>)>;
+
+// Generic composition function
+template <typename T>
+using Composer = std::function<sk_sp<T>(sk_sp<T>, sk_sp<T>)>;
+// Generic composition function
+template <typename T>
+sk_sp<T> composeEffects(const std::vector<sk_sp<T>> &effects,
+                        const Composer<T> &composer) {
+  if (effects.empty()) {
+    return nullptr;
+  }
+  if (effects.size() == 1) {
+    return effects[0];
+  }
+  // Use std::accumulate with reverse iterators to mimic JavaScript's
+  // reduceRight
+  return std::accumulate(
+      std::next(effects.rbegin()), // Start from second-to-last
+      effects.rend(),              // End at first
+      effects.back(),              // Initial value is last element
+      [&composer](const sk_sp<T> &inner, const sk_sp<T> &outer) {
+        return inner ? composer(outer, inner) : outer;
+      });
+}
+
+struct Composers {
+  static sk_sp<SkColorFilter> colorFilter(const sk_sp<SkColorFilter> &outer,
+                                          const sk_sp<SkColorFilter> &inner) {
+    return SkColorFilters::Compose(outer, inner);
+  }
+
+  static sk_sp<SkImageFilter> imageFilter(const sk_sp<SkImageFilter> &outer,
+                                          const sk_sp<SkImageFilter> &inner) {
+    return SkImageFilters::Compose(outer, inner);
+  }
+
+  static sk_sp<SkPathEffect> pathEffect(const sk_sp<SkPathEffect> &outer,
+                                        const sk_sp<SkPathEffect> &inner) {
+    return SkPathEffect::MakeCompose(outer, inner);
+  }
+};
+
+class DrawingCtx {
+public:
+  DrawingCtx(SkCanvas *canvas) : canvas(canvas) {
+    SkPaint paint;
+    paint.setAntiAlias(true);
+    paints.push_back(paint);
+  }
+
+  void pushPaint(SkPaint &paint) { paints.push_back(paint); }
+
+  void savePaint() { paints.push_back(SkPaint(getPaint())); }
+
+  void saveBackdropFilter() {
+    // Initialize image filter as nullptr
+    sk_sp<SkImageFilter> imageFilter = nullptr;
+
+    // Try to get image filter first
+    if (!imageFilters.empty()) {
+      imageFilter = imageFilters.back();
+      imageFilters.pop_back();
+    } else if (!colorFilters.empty()) {
+      // If no image filter, try to create one from color filter
+      auto colorFilter = colorFilters.back();
+      colorFilters.pop_back();
+      imageFilter = SkImageFilters::ColorFilter(colorFilter, nullptr);
+    }
+
+    // Save layer with the image filter
+    SkPaint layerPaint;
+    if (imageFilter) {
+      layerPaint.setImageFilter(imageFilter);
+    }
+    canvas->saveLayer(
+        SkCanvas::SaveLayerRec(nullptr, nullptr, imageFilter.get(), 0));
+    canvas->restore();
+  }
+
+  SkPaint &getPaint() { return paints.back(); }
+  const SkPaint &getPaint() const { return paints.back(); }
+
+  SkPaint restorePaint() {
+    if (paints.empty()) {
+      throw std::runtime_error("No paint available");
+    }
+    auto paint = paints.back();
+    paints.pop_back();
+    return paint;
+  }
+
+  std::vector<sk_sp<SkShader>> popAllShaders() {
+    auto result = std::move(shaders);
+    shaders.clear();
+    return result;
+  }
+
+  void composeImageFilter() {
+    if (imageFilters.size() >= 2) {
+      auto outer = imageFilters.back();
+      imageFilters.pop_back();
+      auto inner = imageFilters.back();
+      imageFilters.pop_back();
+
+      auto imgf = SkImageFilters::Compose(outer, inner);
+      imageFilters.push_back(imgf);
+    }
+  }
+
+  void composePathEffect() {
+    if (pathEffects.size() >= 2) {
+      auto outer = pathEffects.back();
+      pathEffects.pop_back();
+      auto inner = pathEffects.back();
+      pathEffects.pop_back();
+
+      auto pe = SkPathEffect::MakeCompose(outer, inner);
+      pathEffects.push_back(pe);
+    }
+  }
+
+  void composeColorFilter() {
+    if (colorFilters.size() >= 2) {
+      auto outer = colorFilters.back();
+      colorFilters.pop_back();
+      auto inner = colorFilters.back();
+      colorFilters.pop_back();
+
+      auto cf = SkColorFilters::Compose(outer, inner);
+      colorFilters.push_back(cf);
+    }
+  }
+
+  void materializePaint() {
+    if (!colorFilters.empty()) {
+      getPaint().setColorFilter(
+          composeEffects<SkColorFilter>(colorFilters, Composers::colorFilter));
+    }
+
+    if (!shaders.empty()) {
+      getPaint().setShader(shaders.back());
+    }
+
+    if (!maskFilters.empty()) {
+      getPaint().setMaskFilter(maskFilters.back());
+    }
+
+    if (!imageFilters.empty()) {
+      getPaint().setImageFilter(
+          composeEffects<SkImageFilter>(imageFilters, Composers::imageFilter));
+    }
+
+    // Handle path effects
+    if (!pathEffects.empty()) {
+      getPaint().setPathEffect(
+          composeEffects<SkPathEffect>(pathEffects, Composers::pathEffect));
+    }
+
+    // Clear all vectors
+    colorFilters.clear();
+    shaders.clear();
+    imageFilters.clear();
+    pathEffects.clear();
+    maskFilters.clear();
+  }
+
+  SkCanvas *canvas;
+  std::vector<SkPaint> paints;
+  std::vector<sk_sp<SkMaskFilter>> maskFilters;
+  std::vector<sk_sp<SkColorFilter>> colorFilters;
+  std::vector<sk_sp<SkShader>> shaders;
+  std::vector<sk_sp<SkImageFilter>> imageFilters;
+  std::vector<sk_sp<SkPathEffect>> pathEffects;
+  std::vector<SkPaint> paintDeclarations;
+};
+
+} // namespace RNSkia