@shopify/react-native-skia 0.1.115

package/cpp/api/JsiSkRuntimeEffect.h

@@ -0,0 +1,217 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include <JsiSkHostObjects.h>
+#include <JsiSkShader.h>
+#include <JsiSkMatrix.h>
+
+#include <jsi/jsi.h>
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include <SkRuntimeEffect.h>
+
+#pragma clang diagnostic pop
+
+namespace RNSkia
+{
+
+  using namespace facebook;
+
+  struct RuntimeEffectUniform
+  {
+    int columns;
+    int rows;
+    int slot; // the index into the uniforms array that this uniform begins.
+    bool isInteger;
+  };
+
+  class JsiSkRuntimeEffect
+      : public JsiSkWrappingSkPtrHostObject<SkRuntimeEffect>
+  {
+  public:
+    JSI_HOST_FUNCTION(makeShader)
+    {
+      auto uniforms = castUniforms(runtime, arguments[0]);
+      auto isOpaque = count >= 2 && arguments[1].isBool() ? arguments[1].getBool() : false;
+      auto matrix = count >= 3 && !arguments[2].isUndefined()  && !arguments[2].isNull()  ? JsiSkMatrix::fromValue(runtime, arguments[2]).get() : nullptr;
+
+      // Create and return shader as host object
+      auto shader = getObject()->makeShader(std::move(uniforms), nullptr,
+                                            0, matrix, isOpaque);
+
+      return jsi::Object::createFromHostObject(
+          runtime, std::make_shared<JsiSkShader>(getContext(), std::move(shader)));
+    }
+
+    JSI_HOST_FUNCTION(makeShaderWithChildren)
+    {
+      auto uniforms = castUniforms(runtime, arguments[0]);
+      auto isOpaque = count >= 2 && arguments[1].isBool() ? arguments[1].getBool() : false;
+
+      // Children
+      std::vector<sk_sp<SkShader>> children;
+      auto jsiChildren = arguments[2].asObject(runtime).asArray(runtime);
+      auto jsiChildCount = jsiChildren.size(runtime);
+      children.reserve(jsiChildCount);
+      for (int i = 0; i < jsiChildCount; i++)
+      {
+        auto shader = jsiChildren.getValueAtIndex(runtime, i)
+                          .asObject(runtime)
+                          .asHostObject<JsiSkShader>(runtime)
+                          ->getObject();
+        children.push_back(shader);
+      }
+
+      auto matrix = count >= 4 && !arguments[3].isUndefined()  && !arguments[3].isNull() ? JsiSkMatrix::fromValue(runtime, arguments[3]).get() : nullptr;
+
+      // Create and return shader as host object
+      auto shader = getObject()->makeShader(std::move(uniforms), children.data(),
+                                            children.size(), matrix, isOpaque);
+
+      return jsi::Object::createFromHostObject(
+          runtime, std::make_shared<JsiSkShader>(getContext(), std::move(shader)));
+    }
+
+    JSI_HOST_FUNCTION(getUniformCount)
+    {
+      return static_cast<int>(getObject()->uniforms().size());
+    }
+
+    JSI_HOST_FUNCTION(getUniformFloatCount)
+    {
+      return static_cast<int>(getObject()->uniformSize() / sizeof(float));
+    }
+
+    JSI_HOST_FUNCTION(getUniformName)
+    {
+      auto i = static_cast<int>(arguments[0].asNumber());
+      if (i < 0 || i >= getObject()->uniforms().size()) {
+        jsi::detail::throwJSError(runtime, "invalid uniform index");
+      }
+      auto it = getObject()->uniforms().begin() + i;
+      return jsi::String::createFromAscii(runtime, it->name.c_str());
+    }
+
+    JSI_HOST_FUNCTION(getUniform)
+    {
+      auto i = static_cast<int>(arguments[0].asNumber());
+      if (i < 0 || i >= getObject()->uniforms().size()) {
+        jsi::detail::throwJSError(runtime, "invalid uniform index");
+      }
+      auto it = getObject()->uniforms().begin() + i;
+      auto result = jsi::Object(runtime);
+      RuntimeEffectUniform su = fromUniform(*it);
+      result.setProperty(runtime, "columns", su.columns);
+      result.setProperty(runtime, "rows", su.rows);
+      result.setProperty(runtime, "slot", su.slot);
+      result.setProperty(runtime, "isInteger", su.isInteger);
+      return result;
+    }
+
+    JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkRuntimeEffect, makeShader),
+                         JSI_EXPORT_FUNC(JsiSkRuntimeEffect,
+                                         makeShaderWithChildren),
+                         JSI_EXPORT_FUNC(JsiSkRuntimeEffect, getUniformCount),
+                         JSI_EXPORT_FUNC(JsiSkRuntimeEffect,
+                                         getUniformFloatCount),
+                         JSI_EXPORT_FUNC(JsiSkRuntimeEffect, getUniformName),
+                         JSI_EXPORT_FUNC(JsiSkRuntimeEffect, getUniform))
+
+    JsiSkRuntimeEffect(std::shared_ptr<RNSkPlatformContext> context,
+                       sk_sp<SkRuntimeEffect> rt)
+        : JsiSkWrappingSkPtrHostObject<SkRuntimeEffect>(std::move(context), std::move(rt)){}
+
+  private:
+    sk_sp<SkData> castUniforms(jsi::Runtime &runtime, const jsi::Value &value)
+    {
+      auto jsiUniforms = value.asObject(runtime).asArray(runtime);
+      auto jsiUniformsSize = jsiUniforms.size(runtime);
+
+      // verify size of input uniforms
+      if (jsiUniformsSize * sizeof(float) != getObject()->uniformSize())
+      {
+        std::string msg = "Uniforms size differs from effect's uniform size. Received " +
+                std::to_string(jsiUniformsSize) +
+                " expected " +
+                std::to_string(getObject()->uniformSize() / sizeof(float));
+        jsi::detail::throwJSError(runtime, msg.c_str());
+      }
+
+      auto uniforms = SkData::MakeUninitialized(getObject()->uniformSize());
+
+      // Convert to skia uniforms
+      const auto& u = getObject()->uniforms();
+      for (std::size_t i = 0; i < u.size(); i++)
+      {
+        auto it = getObject()->uniforms().begin() + i;
+        RuntimeEffectUniform reu = fromUniform(*it);
+        for (std::size_t j = 0; j < reu.columns * reu.rows; ++j) {
+          const std::size_t offset = reu.slot + j;
+          float fValue = jsiUniforms.getValueAtIndex(runtime, offset).asNumber();
+          int iValue = static_cast<int>(fValue);
+          auto value = reu.isInteger ? iValue : fValue;
+          memcpy(SkTAddOffset<void>(uniforms->writable_data(), offset * sizeof(value)), &value, sizeof(value));
+        }
+      }
+      return uniforms;
+    }
+
+    RuntimeEffectUniform fromUniform(const SkRuntimeEffect::Uniform &u)
+    {
+      RuntimeEffectUniform su;
+      su.rows = u.count; // arrayLength
+      su.columns = 1;
+      su.isInteger = false;
+      using Type = SkRuntimeEffect::Uniform::Type;
+      switch (u.type)
+      {
+      case Type::kFloat:
+        break;
+      case Type::kFloat2:
+        su.columns = 2;
+        break;
+      case Type::kFloat3:
+        su.columns = 3;
+        break;
+      case Type::kFloat4:
+        su.columns = 4;
+        break;
+      case Type::kFloat2x2:
+        su.columns = 2;
+        su.rows *= 2;
+        break;
+      case Type::kFloat3x3:
+        su.columns = 3;
+        su.rows *= 3;
+        break;
+      case Type::kFloat4x4:
+        su.columns = 4;
+        su.rows *= 4;
+        break;
+      case Type::kInt:
+        su.isInteger = true;
+        break;
+      case Type::kInt2:
+        su.columns = 2;
+        su.isInteger = true;
+        break;
+      case Type::kInt3:
+        su.columns = 3;
+        su.isInteger = true;
+        break;
+      case Type::kInt4:
+        su.columns = 4;
+        su.isInteger = true;
+        break;
+      }
+      su.slot = (int)(u.offset / sizeof(float));
+      return su;
+    }
+  };
+} // namespace RNSkia

package/cpp/api/JsiSkRuntimeEffectFactory.h

@@ -0,0 +1,41 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <utility>
+
+#include <jsi/jsi.h>
+
+#include "JsiSkRuntimeEffect.h"
+#include "JsiSkColorFilter.h"
+#include "JsiSkHostObjects.h"
+
+namespace RNSkia {
+
+using namespace facebook;
+
+class JsiSkRuntimeEffectFactory : public JsiSkHostObject {
+public:
+  JSI_HOST_FUNCTION(Make) {
+    auto sksl = arguments[0].asString(runtime).utf8(runtime);
+    auto result = SkRuntimeEffect::MakeForShader(SkString(sksl));
+    auto effect = result.effect;
+    auto errorText = result.errorText;
+    if (!effect) {
+      jsi::detail::throwJSError(
+          runtime,
+          std::string("Error in sksl:\n" + std::string(errorText.c_str()))
+              .c_str());
+      return jsi::Value::null();
+    }
+    return jsi::Object::createFromHostObject(
+        runtime, std::make_shared<JsiSkRuntimeEffect>(getContext(), std::move(effect)));
+  }
+
+  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkRuntimeEffectFactory, Make))
+
+  JsiSkRuntimeEffectFactory(std::shared_ptr<RNSkPlatformContext> context)
+      : JsiSkHostObject(std::move(context)) {}
+};
+
+} // namespace RNSkia

package/cpp/api/JsiSkSVG.h

@@ -0,0 +1,43 @@
+#pragma once
+
+#include <memory>
+#include <utility>
+
+#include <jsi/jsi.h>
+
+#include <JsiSkHostObjects.h>
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include <modules/svg/include/SkSVGDOM.h>
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+using namespace facebook;
+
+class JsiSkSVG : public JsiSkWrappingSkPtrHostObject<SkSVGDOM> {
+public:
+  JsiSkSVG(std::shared_ptr<RNSkPlatformContext> context, sk_sp<SkSVGDOM> svgdom)
+      : JsiSkWrappingSkPtrHostObject<SkSVGDOM>(std::move(context), std::move(svgdom)){}
+
+  JSI_PROPERTY_GET(__typename__) {
+    return jsi::String::createFromUtf8(runtime, "SVG");
+  }
+
+  JSI_EXPORT_PROPERTY_GETTERS(JSI_EXPORT_PROP_GET(JsiSkSVG, __typename__))
+
+  /**
+    Returns the underlying object from a host object of this type
+   */
+  static sk_sp<SkSVGDOM> fromValue(jsi::Runtime &runtime,
+                                   const jsi::Value &obj) {
+    return obj.asObject(runtime)
+        .asHostObject<JsiSkSVG>(runtime)
+        ->getObject();
+  }
+};
+
+} // namespace RNSkia

package/cpp/api/JsiSkSVGFactory.h

@@ -0,0 +1,48 @@
+#pragma once
+
+#include <memory>
+#include <utility>
+
+#include <jsi/jsi.h>
+
+#include "JsiSkTypeface.h"
+#include "JsiSkHostObjects.h"
+#include "JsiSkData.h"
+#include "JsiSkSVG.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include <SkStream.h>
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+    using namespace facebook;
+
+    class JsiSkSVGFactory : public JsiSkHostObject {
+    public:
+        JSI_HOST_FUNCTION(MakeFromData) {
+            auto data = JsiSkData::fromValue(runtime, arguments[0]);
+            auto stream = SkMemoryStream::Make(data);
+            auto svg_dom = SkSVGDOM::Builder().make(*stream);
+            return jsi::Object::createFromHostObject(
+                    runtime, std::make_shared<JsiSkSVG>(getContext(), std::move(svg_dom)));
+        }
+
+        JSI_HOST_FUNCTION(MakeFromString) {
+            auto svgText = arguments[0].asString(runtime).utf8(runtime);
+            auto stream = SkMemoryStream::MakeDirect(svgText.c_str(), svgText.size());
+            auto svg_dom = SkSVGDOM::Builder().make(*stream);
+            return jsi::Object::createFromHostObject(
+                    runtime, std::make_shared<JsiSkSVG>(getContext(), std::move(svg_dom)));
+        }
+
+        JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkSVGFactory, MakeFromData), JSI_EXPORT_FUNC(JsiSkSVGFactory, MakeFromString))
+
+        JsiSkSVGFactory(std::shared_ptr<RNSkPlatformContext> context)
+                : JsiSkHostObject(std::move(context)) {}
+    };
+
+} // namespace RNSkia

package/cpp/api/JsiSkShader.h

@@ -0,0 +1,45 @@
+#pragma once
+
+#include <memory>
+#include <utility>
+
+#include <jsi/jsi.h>
+
+#include <JsiSkHostObjects.h>
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include <SkGradientShader.h>
+#include <SkShader.h>
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+using namespace facebook;
+
+class JsiSkShader : public JsiSkWrappingSkPtrHostObject<SkShader> {
+public:
+  JsiSkShader(std::shared_ptr<RNSkPlatformContext> context,
+              sk_sp<SkShader> shader)
+      : JsiSkWrappingSkPtrHostObject<SkShader>(std::move(context), std::move(shader)) {}
+
+  // TODO: declare in JsiSkWrappingSkPtrHostObject via extra template parameter?
+  JSI_PROPERTY_GET(__typename__) {
+    return jsi::String::createFromUtf8(runtime, "Shader");
+  }
+
+  JSI_EXPORT_PROPERTY_GETTERS(JSI_EXPORT_PROP_GET(JsiSkShader, __typename__))
+
+  /**
+    Returns the underlying object from a host object of this type
+   */
+  static sk_sp<SkShader> fromValue(jsi::Runtime &runtime,
+                                   const jsi::Value &obj) {
+    return obj.asObject(runtime)
+        .asHostObject<JsiSkShader>(runtime)
+        ->getObject();
+  }
+};
+} // namespace RNSkia

package/cpp/api/JsiSkShaderFactory.h

@@ -0,0 +1,214 @@
+#pragma once
+
+#include <memory>
+#include <utility>
+#include <vector>
+
+#include <jsi/jsi.h>
+
+#include "JsiSkColorFilter.h"
+#include "JsiSkHostObjects.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include <SkColorFilter.h>
+#include <SkImageFilters.h>
+#include <SkPerlinNoiseShader.h>
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+using namespace facebook;
+
+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<SkColor> getColors(jsi::Runtime &runtime, const jsi::Value& value) {
+  std::vector<SkColor> 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 = jsiColors.getValueAtIndex(runtime, i).asNumber();
+      colors.push_back(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 JsiSkHostObject {
+public:
+  JSI_HOST_FUNCTION(MakeLinearGradient) {
+    auto p1 =
+        *JsiSkPoint::fromValue(runtime, arguments[0].asObject(runtime)).get();
+    auto p2 =
+        *JsiSkPoint::fromValue(runtime, arguments[1].asObject(runtime)).get();
+    SkPoint pts[] = {p1, p2};
+
+    std::vector<SkColor> colors = getColors(runtime, arguments[2]);
+    std::vector<SkScalar> positions = getPositions(runtime, arguments[3]);
+    auto tileMode = getTileMode(arguments, 4, count);
+    auto flag = getFlag(arguments, 6, count);
+    auto localMatrix = getLocalMatrix(runtime, arguments, 5, count);
+
+    sk_sp<SkShader> gradient = SkGradientShader::MakeLinear(pts, colors.data(), positions.data(),
+                                                  static_cast<int>(colors.size()), tileMode, flag, localMatrix);
+    return jsi::Object::createFromHostObject(
+        runtime, 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<SkColor> colors = getColors(runtime, arguments[2]);
+    std::vector<SkScalar> positions = getPositions(runtime, arguments[3]);
+    auto tileMode = getTileMode(arguments, 4, count);
+    auto flag = getFlag(arguments, 6, count);
+    auto localMatrix = getLocalMatrix(runtime, arguments, 5, count);
+
+    sk_sp<SkShader> gradient = SkGradientShader::MakeRadial(center, r, colors.data(),
+                                              positions.data(), static_cast<int>(colors.size()), tileMode,
+                                              flag, localMatrix);
+    return jsi::Object::createFromHostObject(
+        runtime, std::make_shared<JsiSkShader>(getContext(), std::move(gradient)));
+  }
+
+  JSI_HOST_FUNCTION(MakeSweepGradient) {
+    auto x = arguments[0].asNumber();
+    auto y = arguments[1].asNumber();
+    std::vector<SkColor> colors = getColors(runtime, arguments[2]);
+    std::vector<SkScalar> positions = getPositions(runtime, arguments[3]);
+    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 : arguments[7].asNumber();
+    auto endAngle = (count < 9 || arguments[8].isUndefined())
+                        ? 360
+                        : arguments[8].asNumber();
+    sk_sp<SkShader> gradient = SkGradientShader::MakeSweep(
+        x, y, colors.data(), positions.data(), static_cast<int>(colors.size()), tileMode, startAngle,
+        endAngle, flag, localMatrix);
+    return jsi::Object::createFromHostObject(
+        runtime, 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<SkColor> colors = getColors(runtime, arguments[4]);
+    std::vector<SkScalar> positions = getPositions(runtime, arguments[5]);
+    auto tileMode = getTileMode(arguments, 6, count);
+    auto localMatrix = getLocalMatrix(runtime, arguments, 7, count);
+    auto flag = getFlag(arguments, 8, count);
+
+    sk_sp<SkShader> gradient = SkGradientShader::MakeTwoPointConical(
+            start, startRadius, end, endRadius, colors.data(), positions.data(),
+            static_cast<int>(colors.size()), tileMode, flag, localMatrix);
+
+    return jsi::Object::createFromHostObject(
+        runtime, 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();
+    SkISize size = SkISize::Make(tileW, tileH);
+    sk_sp<SkShader> gradient = SkPerlinNoiseShader::MakeTurbulence(
+        baseFreqX, baseFreqY, octaves, seed, &size);
+    return jsi::Object::createFromHostObject(
+        runtime, 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();
+    SkISize size = SkISize::Make(tileW, tileH);
+    sk_sp<SkShader> gradient = SkPerlinNoiseShader::MakeFractalNoise(
+        baseFreqX, baseFreqY, octaves, seed, &size);
+    return jsi::Object::createFromHostObject(
+        runtime, 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 jsi::Object::createFromHostObject(
+        runtime, std::make_shared<JsiSkShader>(getContext(), std::move(gradient)));
+  }
+
+  JSI_HOST_FUNCTION(MakeColor) {
+    auto color = arguments[0].asNumber();
+    sk_sp<SkShader> gradient = SkShaders::Color(color);
+    return jsi::Object::createFromHostObject(
+        runtime, std::make_shared<JsiSkShader>(getContext(), std::move(gradient)));
+  }
+
+  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkShaderFactory, MakeLinearGradient),
+                       JSI_EXPORT_FUNC(JsiSkShaderFactory, MakeRadialGradient),
+                       JSI_EXPORT_FUNC(JsiSkShaderFactory, MakeSweepGradient),
+                       JSI_EXPORT_FUNC(JsiSkShaderFactory,
+                                       MakeTwoPointConicalGradient),
+                       JSI_EXPORT_FUNC(JsiSkShaderFactory, MakeTurbulence),
+                       JSI_EXPORT_FUNC(JsiSkShaderFactory, MakeFractalNoise),
+                       JSI_EXPORT_FUNC(JsiSkShaderFactory, MakeBlend),
+                       JSI_EXPORT_FUNC(JsiSkShaderFactory, MakeColor))
+
+  JsiSkShaderFactory(std::shared_ptr<RNSkPlatformContext> context)
+      : JsiSkHostObject(std::move(context)) {}
+};
+
+} // namespace RNSkia

package/cpp/api/JsiSkSurface.h

@@ -0,0 +1,67 @@
+#pragma once
+
+#include <memory>
+#include <utility>
+
+#include <jsi/jsi.h>
+
+#include "JsiSkHostObjects.h"
+
+#include <JsiSkSurfaceFactory.h>
+#include <JsiSkImage.h>
+#include <JsiSkCanvas.h>
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include <SkSurface.h>
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+using namespace facebook;
+
+class JsiSkSurface : public JsiSkWrappingSkPtrHostObject<SkSurface> {
+public:
+    JsiSkSurface(std::shared_ptr<RNSkPlatformContext> context,
+                 sk_sp<SkSurface> surface)
+            : JsiSkWrappingSkPtrHostObject<SkSurface>(std::move(context), std::move(surface)) {}
+
+    // TODO: declare in JsiSkWrappingSkPtrHostObject via extra template parameter?
+    JSI_PROPERTY_GET(__typename__) {
+            return jsi::String::createFromUtf8(runtime, "Surface");
+    }
+
+    JSI_HOST_FUNCTION(getCanvas) {
+        return jsi::Object::createFromHostObject(runtime,
+        std::make_shared<JsiSkCanvas>(getContext(),
+                                      getObject()->getCanvas()));
+    }
+
+    JSI_HOST_FUNCTION(makeImageSnapshot) {
+      sk_sp<SkImage> image;
+      if(count == 1) {
+        auto rect = JsiSkRect::fromValue(runtime, arguments[0]);
+        image = getObject()->makeImageSnapshot(SkIRect::MakeXYWH(rect->x(), rect->y(), rect->width(), rect->height()));
+      } else {
+        image = getObject()->makeImageSnapshot();
+      }
+      return jsi::Object::createFromHostObject(runtime, std::make_shared<JsiSkImage>(getContext(), std::move(image)));
+    }
+
+    JSI_EXPORT_PROPERTY_GETTERS(JSI_EXPORT_PROP_GET(JsiSkSurface, __typename__))
+    JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkSurface, getCanvas),
+                         JSI_EXPORT_FUNC(JsiSkSurface, makeImageSnapshot))
+
+    /**
+      Returns the underlying object from a host object of this type
+     */
+    static sk_sp<SkSurface> fromValue(jsi::Runtime &runtime, const jsi::Value &obj) {
+        return obj.asObject(runtime)
+                .asHostObject<JsiSkSurface>(runtime)
+                ->getObject();
+    }
+};
+
+} // namespace RNSkia