@shopify/react-native-skia 2.10.0 → 2.11.0-next.1

package/cpp/api/JsiSkShaderFactory.h

@@ -6,8 +6,13 @@
 
 #include <jsi/jsi.h>
 
+#include "JsiSkColor.h"
 #include "JsiSkColorFilter.h"
+#include "JsiSkConverters.h"
+#include "JsiSkMatrix.h"
 #include "JsiSkNativeObjects.h"
+#include "JsiSkPoint.h"
+#include "JsiSkShader.h"
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
@@ -22,269 +27,192 @@ namespace RNSkia {
 
 namespace jsi = facebook::jsi;
 
-int getFlag(const jsi::Value *values, int i, size_t size) {
-  if (i >= size || values[i].isUndefined()) {
-    return 0;
-  }
-  return values[i].asNumber();
-}
-
-SkMatrix *getLocalMatrix(jsi::Runtime &runtime, const jsi::Value *values, int i,
-                         size_t size) {
-  if (i >= size || values[i].isUndefined()) {
-    return nullptr;
-  }
-  return JsiSkMatrix::fromValue(runtime, values[i]).get();
-}
-
-SkTileMode getTileMode(const jsi::Value *values, int i, size_t size) {
-  if (i >= size || values[i].isUndefined()) {
-    return SkTileMode::kClamp;
-  }
-  return static_cast<SkTileMode>(values[i].asNumber());
-}
-
-std::vector<SkColor4f> getColors(jsi::Runtime &runtime,
-                                 const jsi::Value &value) {
-  std::vector<SkColor4f> colors;
-  if (!value.isNull()) {
-    auto jsiColors = value.asObject(runtime).asArray(runtime);
-    auto size = jsiColors.size(runtime);
-    colors.reserve(size);
-    for (int i = 0; i < size; i++) {
-      SkColor color =
-          JsiSkColor::fromValue(runtime, jsiColors.getValueAtIndex(runtime, i));
-      colors.push_back(SkColor4f::FromColor(color));
-    }
-  }
-  return colors;
-}
-
-std::vector<SkScalar> getPositions(jsi::Runtime &runtime,
-                                   const jsi::Value &value) {
-  std::vector<SkScalar> positions;
-  if (!value.isNull()) {
-    auto jsiPositions = value.asObject(runtime).asArray(runtime);
-    auto size = jsiPositions.size(runtime);
-    positions.reserve(size);
-    for (int i = 0; i < size; i++) {
-      SkScalar position = jsiPositions.getValueAtIndex(runtime, i).asNumber();
-      positions.push_back(position);
-    }
-  }
-  return positions;
-}
-
 class JsiSkShaderFactory : public JsiSkNativeObject<JsiSkShaderFactory> {
 public:
   static constexpr const char *CLASS_NAME = "ShaderFactory";
 
-  JSI_HOST_FUNCTION(MakeLinearGradient) {
-    auto p1 =
-        *JsiSkPoint::fromValue(runtime, arguments[0].asObject(runtime)).get();
-    auto p2 =
-        *JsiSkPoint::fromValue(runtime, arguments[1].asObject(runtime)).get();
+  std::shared_ptr<JsiSkShader>
+  MakeLinearGradient(SkPoint p1, SkPoint p2,
+                     JsiOptional<std::vector<JsiColor>> jsiColors,
+                     JsiOptional<std::vector<float>> jsiPositions,
+                     JsiOptional<double> tileMode,
+                     JsiOptional<std::shared_ptr<SkMatrix>> matrix,
+                     JsiOptional<double> flag) {
     SkPoint pts[] = {p1, p2};
-
-    std::vector<SkColor4f> colors = getColors(runtime, arguments[2]);
-    auto colorsSize = colors.size();
-    if (colorsSize < 2) {
-      throw std::invalid_argument("colors must have at least 2 colors");
-    }
-    std::vector<SkScalar> positions = getPositions(runtime, arguments[3]);
-    if (!positions.empty() && positions.size() != colorsSize) {
-      throw std::invalid_argument(
-          "positions must be empty or have the same size as colors");
-    }
-    auto tileMode = getTileMode(arguments, 4, count);
-    auto flag = getFlag(arguments, 6, count);
-    auto localMatrix = getLocalMatrix(runtime, arguments, 5, count);
-
-    SkGradient::Colors gradColors(
-        SkSpan(colors),
-        !positions.empty()
-            ? SkSpan<const float>(positions.data(), positions.size())
-            : SkSpan<const float>(),
-        tileMode);
-    SkGradient grad(gradColors, SkGradient::Interpolation::FromFlags(flag));
+    auto colors = toColors(jsiColors);
+    auto positions = toPositions(jsiPositions, colors.size());
+    SkGradient::Colors gradColors(SkSpan(colors), toSpan(positions),
+                                  toTileMode(tileMode));
+    SkGradient grad(gradColors,
+                    SkGradient::Interpolation::FromFlags(toFlag(flag)));
     sk_sp<SkShader> gradient =
-        SkShaders::LinearGradient(pts, grad, localMatrix);
-    return makeJsiObject(runtime, std::make_shared<JsiSkShader>(
-                                      getContext(), std::move(gradient)));
+        SkShaders::LinearGradient(pts, grad, toLocalMatrix(matrix));
+    return std::make_shared<JsiSkShader>(getContext(), std::move(gradient));
   }
 
-  JSI_HOST_FUNCTION(MakeRadialGradient) {
-    auto center =
-        *JsiSkPoint::fromValue(runtime, arguments[0].asObject(runtime)).get();
-    auto r = arguments[1].asNumber();
-
-    std::vector<SkColor4f> colors = getColors(runtime, arguments[2]);
-    auto colorsSize = colors.size();
-    if (colorsSize < 2) {
-      throw std::invalid_argument("colors must have at least 2 colors");
-    }
-    std::vector<SkScalar> positions = getPositions(runtime, arguments[3]);
-    if (!positions.empty() && positions.size() != colorsSize) {
-      throw std::invalid_argument(
-          "positions must be empty or the same size as colors");
-    }
-    auto tileMode = getTileMode(arguments, 4, count);
-    auto flag = getFlag(arguments, 6, count);
-    auto localMatrix = getLocalMatrix(runtime, arguments, 5, count);
-
-    SkGradient::Colors gradColors(
-        SkSpan(colors),
-        !positions.empty()
-            ? SkSpan<const float>(positions.data(), positions.size())
-            : SkSpan<const float>(),
-        tileMode);
-    SkGradient grad(gradColors, SkGradient::Interpolation::FromFlags(flag));
+  std::shared_ptr<JsiSkShader>
+  MakeRadialGradient(SkPoint center, double r,
+                     JsiOptional<std::vector<JsiColor>> jsiColors,
+                     JsiOptional<std::vector<float>> jsiPositions,
+                     JsiOptional<double> tileMode,
+                     JsiOptional<std::shared_ptr<SkMatrix>> matrix,
+                     JsiOptional<double> flag) {
+    auto colors = toColors(jsiColors);
+    auto positions = toPositions(jsiPositions, colors.size());
+    SkGradient::Colors gradColors(SkSpan(colors), toSpan(positions),
+                                  toTileMode(tileMode));
+    SkGradient grad(gradColors,
+                    SkGradient::Interpolation::FromFlags(toFlag(flag)));
     sk_sp<SkShader> gradient =
-        SkShaders::RadialGradient(center, r, grad, localMatrix);
-    return makeJsiObject(runtime, std::make_shared<JsiSkShader>(
-                                      getContext(), std::move(gradient)));
+        SkShaders::RadialGradient(center, r, grad, toLocalMatrix(matrix));
+    return std::make_shared<JsiSkShader>(getContext(), std::move(gradient));
   }
 
-  JSI_HOST_FUNCTION(MakeSweepGradient) {
-    auto x = arguments[0].asNumber();
-    auto y = arguments[1].asNumber();
-    std::vector<SkColor4f> colors = getColors(runtime, arguments[2]);
-    auto colorsSize = colors.size();
-    if (colorsSize < 2) {
-      throw std::invalid_argument("colors must have at least 2 colors");
-    }
-    std::vector<SkScalar> positions = getPositions(runtime, arguments[3]);
-    if (!positions.empty() && positions.size() != colorsSize) {
-      throw std::invalid_argument(
-          "positions must be empty or the same size as colors");
-    }
-    auto tileMode = getTileMode(arguments, 4, count);
-    auto localMatrix = getLocalMatrix(runtime, arguments, 5, count);
-    auto flag = getFlag(arguments, 6, count);
-    auto startAngle = (count < 8 || arguments[7].isUndefined())
-                          ? 0.0f
-                          : static_cast<float>(arguments[7].asNumber());
-    auto endAngle = (count < 9 || arguments[8].isUndefined())
-                        ? 360.0f
-                        : static_cast<float>(arguments[8].asNumber());
-
-    SkGradient::Colors gradColors(
-        SkSpan(colors),
-        !positions.empty()
-            ? SkSpan<const float>(positions.data(), positions.size())
-            : SkSpan<const float>(),
-        tileMode);
-    SkGradient grad(gradColors, SkGradient::Interpolation::FromFlags(flag));
-    sk_sp<SkShader> gradient = SkShaders::SweepGradient(
-        SkPoint::Make(x, y), startAngle, endAngle, grad, localMatrix);
-    return makeJsiObject(runtime, std::make_shared<JsiSkShader>(
-                                      getContext(), std::move(gradient)));
+  std::shared_ptr<JsiSkShader>
+  MakeSweepGradient(double x, double y,
+                    JsiOptional<std::vector<JsiColor>> jsiColors,
+                    JsiOptional<std::vector<float>> jsiPositions,
+                    JsiOptional<double> tileMode,
+                    JsiOptional<std::shared_ptr<SkMatrix>> matrix,
+                    JsiOptional<double> flag, JsiOptional<double> start,
+                    JsiOptional<double> end) {
+    auto colors = toColors(jsiColors);
+    auto positions = toPositions(jsiPositions, colors.size());
+    auto startAngle =
+        start.has_value() ? static_cast<float>(*start) : 0.0f;
+    auto endAngle = end.has_value() ? static_cast<float>(*end) : 360.0f;
+    SkGradient::Colors gradColors(SkSpan(colors), toSpan(positions),
+                                  toTileMode(tileMode));
+    SkGradient grad(gradColors,
+                    SkGradient::Interpolation::FromFlags(toFlag(flag)));
+    sk_sp<SkShader> gradient =
+        SkShaders::SweepGradient(SkPoint::Make(x, y), startAngle, endAngle,
+                                 grad, toLocalMatrix(matrix));
+    return std::make_shared<JsiSkShader>(getContext(), std::move(gradient));
   }
 
-  JSI_HOST_FUNCTION(MakeTwoPointConicalGradient) {
-    auto start =
-        *JsiSkPoint::fromValue(runtime, arguments[0].asObject(runtime)).get();
-    auto startRadius = arguments[1].asNumber();
-
-    auto end =
-        *JsiSkPoint::fromValue(runtime, arguments[2].asObject(runtime)).get();
-    auto endRadius = arguments[3].asNumber();
-
-    std::vector<SkColor4f> colors = getColors(runtime, arguments[4]);
-    auto colorsSize = colors.size();
-    if (colorsSize < 2) {
-      throw std::invalid_argument("colors must have at least 2 colors");
-    }
-    std::vector<SkScalar> positions = getPositions(runtime, arguments[5]);
-    if (!positions.empty() && positions.size() != colorsSize) {
-      throw std::invalid_argument(
-          "positions must be empty or the same size as colors");
-    }
-    auto tileMode = getTileMode(arguments, 6, count);
-    auto localMatrix = getLocalMatrix(runtime, arguments, 7, count);
-    auto flag = getFlag(arguments, 8, count);
-
-    SkGradient::Colors gradColors(
-        SkSpan(colors),
-        !positions.empty()
-            ? SkSpan<const float>(positions.data(), positions.size())
-            : SkSpan<const float>(),
-        tileMode);
-    SkGradient grad(gradColors, SkGradient::Interpolation::FromFlags(flag));
+  std::shared_ptr<JsiSkShader>
+  MakeTwoPointConicalGradient(SkPoint start, double startRadius, SkPoint end,
+                              double endRadius,
+                              JsiOptional<std::vector<JsiColor>> jsiColors,
+                              JsiOptional<std::vector<float>> jsiPositions,
+                              JsiOptional<double> tileMode,
+                              JsiOptional<std::shared_ptr<SkMatrix>> matrix,
+                              JsiOptional<double> flag) {
+    auto colors = toColors(jsiColors);
+    auto positions = toPositions(jsiPositions, colors.size());
+    SkGradient::Colors gradColors(SkSpan(colors), toSpan(positions),
+                                  toTileMode(tileMode));
+    SkGradient grad(gradColors,
+                    SkGradient::Interpolation::FromFlags(toFlag(flag)));
     sk_sp<SkShader> gradient = SkShaders::TwoPointConicalGradient(
-        start, startRadius, end, endRadius, grad, localMatrix);
-
-    return makeJsiObject(runtime, std::make_shared<JsiSkShader>(
-                                      getContext(), std::move(gradient)));
+        start, startRadius, end, endRadius, grad, toLocalMatrix(matrix));
+    return std::make_shared<JsiSkShader>(getContext(), std::move(gradient));
   }
 
-  JSI_HOST_FUNCTION(MakeTurbulence) {
-    auto baseFreqX = arguments[0].asNumber();
-    auto baseFreqY = arguments[1].asNumber();
-    auto octaves = arguments[2].asNumber();
-    auto seed = arguments[3].asNumber();
-    auto tileW = arguments[4].asNumber();
-    auto tileH = arguments[5].asNumber();
+  std::shared_ptr<JsiSkShader> MakeTurbulence(double baseFreqX,
+                                              double baseFreqY, double octaves,
+                                              double seed, double tileW,
+                                              double tileH) {
     SkISize size = SkISize::Make(tileW, tileH);
     sk_sp<SkShader> gradient =
         SkShaders::MakeTurbulence(baseFreqX, baseFreqY, octaves, seed, &size);
-    return makeJsiObject(runtime, std::make_shared<JsiSkShader>(
-                                      getContext(), std::move(gradient)));
+    return std::make_shared<JsiSkShader>(getContext(), std::move(gradient));
   }
 
-  JSI_HOST_FUNCTION(MakeFractalNoise) {
-    auto baseFreqX = arguments[0].asNumber();
-    auto baseFreqY = arguments[1].asNumber();
-    auto octaves = arguments[2].asNumber();
-    auto seed = arguments[3].asNumber();
-    auto tileW = arguments[4].asNumber();
-    auto tileH = arguments[5].asNumber();
+  std::shared_ptr<JsiSkShader> MakeFractalNoise(double baseFreqX,
+                                                double baseFreqY,
+                                                double octaves, double seed,
+                                                double tileW, double tileH) {
     SkISize size = SkISize::Make(tileW, tileH);
     sk_sp<SkShader> gradient =
         SkShaders::MakeFractalNoise(baseFreqX, baseFreqY, octaves, seed, &size);
-    return makeJsiObject(runtime, std::make_shared<JsiSkShader>(
-                                      getContext(), std::move(gradient)));
+    return std::make_shared<JsiSkShader>(getContext(), std::move(gradient));
   }
 
-  JSI_HOST_FUNCTION(MakeBlend) {
-    auto blendMode = (SkBlendMode)arguments[0].asNumber();
-    auto one = JsiSkShader::fromValue(runtime, arguments[1]);
-    auto two = JsiSkShader::fromValue(runtime, arguments[2]);
-    sk_sp<SkShader> gradient = SkShaders::Blend(blendMode, one, two);
-    return makeJsiObject(runtime, std::make_shared<JsiSkShader>(
-                                      getContext(), std::move(gradient)));
+  std::shared_ptr<JsiSkShader> MakeBlend(double blendMode, sk_sp<SkShader> one,
+                                         sk_sp<SkShader> two) {
+    sk_sp<SkShader> gradient =
+        SkShaders::Blend(static_cast<SkBlendMode>(blendMode), one, two);
+    return std::make_shared<JsiSkShader>(getContext(), std::move(gradient));
   }
 
-  JSI_HOST_FUNCTION(MakeColor) {
-    auto color = JsiSkColor::fromValue(runtime, arguments[0]);
+  std::shared_ptr<JsiSkShader> MakeColor(JsiColor color) {
     sk_sp<SkShader> gradient = SkShaders::Color(color);
-    return makeJsiObject(runtime, std::make_shared<JsiSkShader>(
-                                      getContext(), std::move(gradient)));
+    return std::make_shared<JsiSkShader>(getContext(), std::move(gradient));
   }
 
   size_t getMemoryPressure() override { return 1024; }
 
   static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
-    installHostMethod(runtime, prototype, "MakeLinearGradient",
-                      &JsiSkShaderFactory::MakeLinearGradient);
-    installHostMethod(runtime, prototype, "MakeRadialGradient",
-                      &JsiSkShaderFactory::MakeRadialGradient);
-    installHostMethod(runtime, prototype, "MakeSweepGradient",
-                      &JsiSkShaderFactory::MakeSweepGradient);
-    installHostMethod(runtime, prototype, "MakeTwoPointConicalGradient",
-                      &JsiSkShaderFactory::MakeTwoPointConicalGradient);
-    installHostMethod(runtime, prototype, "MakeTurbulence",
-                      &JsiSkShaderFactory::MakeTurbulence);
-    installHostMethod(runtime, prototype, "MakeFractalNoise",
-                      &JsiSkShaderFactory::MakeFractalNoise);
-    installHostMethod(runtime, prototype, "MakeBlend",
-                      &JsiSkShaderFactory::MakeBlend);
-    installHostMethod(runtime, prototype, "MakeColor",
-                      &JsiSkShaderFactory::MakeColor);
+    installMethod(runtime, prototype, "MakeLinearGradient",
+                  &JsiSkShaderFactory::MakeLinearGradient);
+    installMethod(runtime, prototype, "MakeRadialGradient",
+                  &JsiSkShaderFactory::MakeRadialGradient);
+    installMethod(runtime, prototype, "MakeSweepGradient",
+                  &JsiSkShaderFactory::MakeSweepGradient);
+    installMethod(runtime, prototype, "MakeTwoPointConicalGradient",
+                  &JsiSkShaderFactory::MakeTwoPointConicalGradient);
+    installMethod(runtime, prototype, "MakeTurbulence",
+                  &JsiSkShaderFactory::MakeTurbulence);
+    installMethod(runtime, prototype, "MakeFractalNoise",
+                  &JsiSkShaderFactory::MakeFractalNoise);
+    installMethod(runtime, prototype, "MakeBlend",
+                  &JsiSkShaderFactory::MakeBlend);
+    installMethod(runtime, prototype, "MakeColor",
+                  &JsiSkShaderFactory::MakeColor);
   }
 
   explicit JsiSkShaderFactory(std::shared_ptr<RNSkPlatformContext> context)
       : JsiSkNativeObject<JsiSkShaderFactory>(std::move(context)) {}
+
+private:
+  static std::vector<SkColor4f>
+  toColors(const JsiOptional<std::vector<JsiColor>> &jsiColors) {
+    std::vector<SkColor4f> colors;
+    if (jsiColors.has_value()) {
+      colors.reserve(jsiColors->size());
+      for (const auto &color : *jsiColors) {
+        colors.push_back(SkColor4f::FromColor(color));
+      }
+    }
+    if (colors.size() < 2) {
+      throw std::invalid_argument("colors must have at least 2 colors");
+    }
+    return colors;
+  }
+
+  static std::vector<float>
+  toPositions(const JsiOptional<std::vector<float>> &jsiPositions,
+              size_t colorsSize) {
+    std::vector<float> positions =
+        jsiPositions.has_value() ? *jsiPositions : std::vector<float>{};
+    if (!positions.empty() && positions.size() != colorsSize) {
+      throw std::invalid_argument(
+          "positions must be empty or have the same size as colors");
+    }
+    return positions;
+  }
+
+  static SkSpan<const float> toSpan(const std::vector<float> &positions) {
+    return !positions.empty()
+               ? SkSpan<const float>(positions.data(), positions.size())
+               : SkSpan<const float>();
+  }
+
+  static SkTileMode toTileMode(const JsiOptional<double> &tileMode) {
+    return tileMode.has_value() ? static_cast<SkTileMode>(*tileMode)
+                                : SkTileMode::kClamp;
+  }
+
+  static int toFlag(const JsiOptional<double> &flag) {
+    return flag.has_value() ? static_cast<int>(*flag) : 0;
+  }
+
+  static SkMatrix *
+  toLocalMatrix(const JsiOptional<std::shared_ptr<SkMatrix>> &matrix) {
+    return matrix.has_value() ? matrix->get() : nullptr;
+  }
 };
 
 } // namespace RNSkia