@shopify/react-native-skia 2.9.1 → 2.10.1

package/cpp/api/JsiSkImage.h

@@ -1,13 +1,16 @@
 #pragma once
 
 #include <memory>
+#include <optional>
 #include <string>
 #include <utility>
+#include <variant>
 
+#include "JsiSkConverters.h"
 #include "JsiSkDispatcher.h"
-#include "JsiSkHostObjects.h"
 #include "JsiSkImageInfo.h"
 #include "JsiSkMatrix.h"
+#include "JsiSkNativeObjects.h"
 #include "JsiSkShader.h"
 #include "api/third_party/base64.h"
 
@@ -15,8 +18,8 @@
 #include "utils/RNSkTypedArray.h"
 
 #if defined(SK_GRAPHITE)
-#include "rnskia/RNDawnContext.h"
 #include "include/gpu/graphite/Context.h"
+#include "rnskia/RNDawnContext.h"
 #else
 #include "include/gpu/ganesh/GrDirectContext.h"
 #endif
@@ -140,63 +143,50 @@ inline SkSamplingOptions SamplingOptionsFromValue(jsi::Runtime &runtime,
   return samplingOptions;
 }
 
-class JsiSkImage : public JsiSkWrappingSkPtrHostObject<SkImage> {
+class JsiSkImage : public JsiSkWrappingSkPtrNativeObject<JsiSkImage, SkImage> {
 private:
   std::shared_ptr<Dispatcher> _dispatcher;
 
 public:
+  static constexpr const char *CLASS_NAME = "Image";
+
   // TODO-API: Properties?
-  JSI_HOST_FUNCTION(width) { return static_cast<double>(getObject()->width()); }
-  JSI_HOST_FUNCTION(height) {
-    return static_cast<double>(getObject()->height());
-  }
+  double width() { return static_cast<double>(getObject()->width()); }
+  double height() { return static_cast<double>(getObject()->height()); }
 
-  JSI_HOST_FUNCTION(getImageInfo) {
-    return JsiSkImageInfo::toValue(runtime, getContext(),
-                                   getObject()->imageInfo());
+  std::shared_ptr<JsiSkImageInfo> getImageInfo() {
+    return std::make_shared<JsiSkImageInfo>(getContext(),
+                                            getObject()->imageInfo());
   }
 
-  JSI_HOST_FUNCTION(makeShaderOptions) {
-    auto tmx = (SkTileMode)arguments[0].asNumber();
-    auto tmy = (SkTileMode)arguments[1].asNumber();
-    auto fm = (SkFilterMode)arguments[2].asNumber();
-    auto mm = (SkMipmapMode)arguments[3].asNumber();
-    auto m = count > 4 && !arguments[4].isUndefined()
-                 ? JsiSkMatrix::fromValue(runtime, arguments[4]).get()
-                 : nullptr;
-    auto shader =
-        getObject()->makeShader(tmx, tmy, SkSamplingOptions(fm, mm), m);
-    auto shaderObj =
-        std::make_shared<JsiSkShader>(getContext(), std::move(shader));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, shaderObj,
-                                                       getContext());
+  std::shared_ptr<JsiSkShader>
+  makeShaderOptions(double tmx, double tmy, double fm, double mm,
+                    std::optional<std::shared_ptr<SkMatrix>> m) {
+    auto shader = getObject()->makeShader(
+        static_cast<SkTileMode>(tmx), static_cast<SkTileMode>(tmy),
+        SkSamplingOptions(static_cast<SkFilterMode>(fm),
+                          static_cast<SkMipmapMode>(mm)),
+        m.has_value() ? m->get() : nullptr);
+    return std::make_shared<JsiSkShader>(getContext(), std::move(shader));
   }
 
-  JSI_HOST_FUNCTION(makeShaderCubic) {
-    auto tmx = (SkTileMode)arguments[0].asNumber();
-    auto tmy = (SkTileMode)arguments[1].asNumber();
-    auto B = SkDoubleToScalar(arguments[2].asNumber());
-    auto C = SkDoubleToScalar(arguments[3].asNumber());
-    auto m = count > 4 && !arguments[4].isUndefined()
-                 ? JsiSkMatrix::fromValue(runtime, arguments[4]).get()
-                 : nullptr;
-    auto shader =
-        getObject()->makeShader(tmx, tmy, SkSamplingOptions({B, C}), m);
-    auto shaderObj =
-        std::make_shared<JsiSkShader>(getContext(), std::move(shader));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, shaderObj,
-                                                       getContext());
+  std::shared_ptr<JsiSkShader>
+  makeShaderCubic(double tmx, double tmy, double B, double C,
+                  std::optional<std::shared_ptr<SkMatrix>> m) {
+    auto shader = getObject()->makeShader(
+        static_cast<SkTileMode>(tmx), static_cast<SkTileMode>(tmy),
+        SkSamplingOptions({SkDoubleToScalar(B), SkDoubleToScalar(C)}),
+        m.has_value() ? m->get() : nullptr);
+    return std::make_shared<JsiSkShader>(getContext(), std::move(shader));
   }
 
-  sk_sp<SkData> encodeImageData(const jsi::Value *arguments, size_t count) {
+  sk_sp<SkData> encodeImageData(JsiOptional<double> formatParam,
+                                JsiOptional<double> qualityParam) {
     // Get optional parameters
-    auto format =
-        count >= 1 ? static_cast<SkEncodedImageFormat>(arguments[0].asNumber())
-                   : SkEncodedImageFormat::kPNG;
-
-    auto quality = (count >= 2 && arguments[1].isNumber())
-                       ? arguments[1].asNumber()
-                       : 100.0;
+    auto format = formatParam.has_value()
+                      ? static_cast<SkEncodedImageFormat>(*formatParam)
+                      : SkEncodedImageFormat::kPNG;
+    auto quality = qualityParam.has_value() ? *qualityParam : 100.0;
     auto image = getObject();
 #if defined(SK_GRAPHITE)
     image = DawnContext::getInstance().MakeRasterImage(image);
@@ -240,8 +230,17 @@ public:
     return data;
   }
 
+  // Stays raw: constructs a Uint8Array result.
   JSI_HOST_FUNCTION(encodeToBytes) {
-    auto data = encodeImageData(arguments, count);
+    JsiOptional<double> format =
+        count >= 1 && !arguments[0].isUndefined() && !arguments[0].isNull()
+            ? JsiOptional<double>(arguments[0].asNumber())
+            : JsiOptional<double>();
+    JsiOptional<double> quality = count >= 2 && arguments[1].isNumber()
+                                      ? JsiOptional<double>(
+                                            arguments[1].asNumber())
+                                      : JsiOptional<double>();
+    auto data = encodeImageData(format, quality);
     if (!data) {
       return jsi::Value::null();
     }
@@ -263,17 +262,18 @@ public:
     return array;
   }
 
-  JSI_HOST_FUNCTION(encodeToBase64) {
-    auto data = encodeImageData(arguments, count);
+  std::variant<std::nullptr_t, std::string>
+  encodeToBase64(JsiOptional<double> format, JsiOptional<double> quality) {
+    auto data = encodeImageData(format, quality);
     if (!data) {
-      return jsi::Value::null();
+      return nullptr;
     }
 
     auto len = Base64::Encode(data->bytes(), data->size(), nullptr);
     auto buffer = std::string(len, 0);
     Base64::Encode(data->bytes(), data->size(),
                    reinterpret_cast<void *>(&buffer[0]));
-    return jsi::String::createFromAscii(runtime, buffer);
+    return buffer;
   }
 
   JSI_HOST_FUNCTION(readPixels) {
@@ -330,24 +330,22 @@ public:
     return dest;
   }
 
-  JSI_HOST_FUNCTION(makeNonTextureImage) {
+  std::variant<std::nullptr_t, std::shared_ptr<JsiSkImage>>
+  makeNonTextureImage() {
 #if defined(SK_GRAPHITE)
     auto rasterImage = DawnContext::getInstance().MakeRasterImage(getObject());
 #else
     auto grContext = getContext()->getDirectContext();
     auto image = getObject();
     if (!grContext) {
-      throw jsi::JSError(runtime, "No GPU context available.");
+      throw std::runtime_error("No GPU context available.");
     }
     auto rasterImage = image->makeRasterImage(grContext);
 #endif
     if (!rasterImage) {
-      return jsi::Value::null();
+      return nullptr;
     }
-    auto hostObjectInstance =
-        std::make_shared<JsiSkImage>(getContext(), std::move(rasterImage));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-        runtime, hostObjectInstance, getContext());
+    return std::make_shared<JsiSkImage>(getContext(), std::move(rasterImage));
   }
 
   JSI_HOST_FUNCTION(getNativeTextureUnstable) {
@@ -359,29 +357,44 @@ public:
     return JsiTextureInfo::toValue(runtime, texInfo);
   }
 
-  JSI_HOST_FUNCTION(isTextureBacked) {
-    return jsi::Value(getObject()->isTextureBacked());
+  bool isTextureBacked() { return getObject()->isTextureBacked(); }
+
+  /**
+    Returns the underlying object from a host object of this type
+   */
+  static sk_sp<SkImage> fromValue(jsi::Runtime &runtime,
+                                  const jsi::Value &obj) {
+    return objectFromValue(runtime, obj);
   }
 
-  EXPORT_JSI_API_TYPENAME(JsiSkImage, Image)
-
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkImage, width),
-                       JSI_EXPORT_FUNC(JsiSkImage, height),
-                       JSI_EXPORT_FUNC(JsiSkImage, getImageInfo),
-                       JSI_EXPORT_FUNC(JsiSkImage, makeShaderOptions),
-                       JSI_EXPORT_FUNC(JsiSkImage, makeShaderCubic),
-                       JSI_EXPORT_FUNC(JsiSkImage, encodeToBytes),
-                       JSI_EXPORT_FUNC(JsiSkImage, encodeToBase64),
-                       JSI_EXPORT_FUNC(JsiSkImage, readPixels),
-                       JSI_EXPORT_FUNC(JsiSkImage, makeNonTextureImage),
-                       JSI_EXPORT_FUNC(JsiSkImage, getNativeTextureUnstable),
-                       JSI_EXPORT_FUNC(JsiSkImage, isTextureBacked),
-                       JSI_EXPORT_FUNC(JsiSkImage, dispose))
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installCommon(runtime, prototype);
+    installMethod(runtime, prototype, "width", &JsiSkImage::width);
+    installMethod(runtime, prototype, "height", &JsiSkImage::height);
+    installMethod(runtime, prototype, "getImageInfo",
+                  &JsiSkImage::getImageInfo);
+    installMethod(runtime, prototype, "makeShaderOptions",
+                  &JsiSkImage::makeShaderOptions);
+    installMethod(runtime, prototype, "makeShaderCubic",
+                  &JsiSkImage::makeShaderCubic);
+    installHostMethod(runtime, prototype, "encodeToBytes",
+                      &JsiSkImage::encodeToBytes);
+    installMethod(runtime, prototype, "encodeToBase64",
+                  &JsiSkImage::encodeToBase64);
+    installHostMethod(runtime, prototype, "readPixels",
+                      &JsiSkImage::readPixels);
+    installMethod(runtime, prototype, "makeNonTextureImage",
+                  &JsiSkImage::makeNonTextureImage);
+    installHostMethod(runtime, prototype, "getNativeTextureUnstable",
+                      &JsiSkImage::getNativeTextureUnstable);
+    installMethod(runtime, prototype, "isTextureBacked",
+                  &JsiSkImage::isTextureBacked);
+  }
 
   JsiSkImage(std::shared_ptr<RNSkPlatformContext> context,
              const sk_sp<SkImage> image)
-      : JsiSkWrappingSkPtrHostObject<SkImage>(std::move(context),
-                                              std::move(image)) {
+      : JsiSkWrappingSkPtrNativeObject<JsiSkImage, SkImage>(std::move(context),
+                                                            std::move(image)) {
     // Get the dispatcher for the current thread
     _dispatcher = Dispatcher::getDispatcher();
     // Process any pending operations (e.g. deletions of previous resources)
@@ -406,7 +419,7 @@ public:
     }
   }
 
-  size_t getMemoryPressure() const override {
+  size_t getMemoryPressure() override {
     if (isDisposed()) {
       return 0;
     }
@@ -420,8 +433,6 @@ public:
     }
     return 0;
   }
-
-  std::string getObjectType() const override { return "JsiSkImage"; }
 };
 
 } // namespace RNSkia

package/cpp/api/JsiSkImageFactory.h

@@ -2,71 +2,58 @@
 
 #include <memory>
 #include <utility>
+#include <variant>
 
 #include <jsi/jsi.h>
 
-#include "jsi/JsiPromises.h"
+#include "JsiSkConverters.h"
 #include "JsiSkData.h"
-#include "JsiSkHostObjects.h"
 #include "JsiSkImage.h"
 #include "JsiSkImageInfo.h"
+#include "JsiSkNativeObjects.h"
+#include "jsi/JsiPromises.h"
 
 #ifdef SK_GRAPHITE
 #include "rnskia/RNDawnContext.h"
-#include "rnwgpu/api/GPUTexture.h"
 #endif
 
 namespace RNSkia {
 
 namespace jsi = facebook::jsi;
 
-class JsiSkImageFactory : public JsiSkHostObject {
+class JsiSkImageFactory : public JsiSkNativeObject<JsiSkImageFactory> {
 public:
-  JSI_HOST_FUNCTION(MakeNull) {
-    auto hostObjectInstance =
-        std::make_shared<JsiSkImage>(getContext(), nullptr);
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-        runtime, hostObjectInstance, getContext());
+  static constexpr const char *CLASS_NAME = "ImageFactory";
+
+  std::shared_ptr<JsiSkImage> MakeNull() {
+    return std::make_shared<JsiSkImage>(getContext(), nullptr);
   }
 
-  JSI_HOST_FUNCTION(MakeImageFromEncoded) {
-    auto data = JsiSkData::fromValue(runtime, arguments[0]);
+  std::variant<std::nullptr_t, std::shared_ptr<JsiSkImage>>
+  MakeImageFromEncoded(sk_sp<SkData> data) {
     auto image = SkImages::DeferredFromEncodedData(data);
     if (image == nullptr) {
-      return jsi::Value::null();
+      return nullptr;
     }
-    auto hostObjectInstance =
-        std::make_shared<JsiSkImage>(getContext(), std::move(image));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-        runtime, hostObjectInstance, getContext());
+    return std::make_shared<JsiSkImage>(getContext(), std::move(image));
   }
 
-  JSI_HOST_FUNCTION(MakeImageFromNativeBuffer) {
-    jsi::BigInt pointer = arguments[0].asBigInt(runtime);
-    const uintptr_t nativeBufferPointer = pointer.asUint64(runtime);
-    void *rawPointer = reinterpret_cast<void *>(nativeBufferPointer);
+  std::shared_ptr<JsiSkImage> MakeImageFromNativeBuffer(void *rawPointer) {
     auto image = getContext()->makeImageFromNativeBuffer(rawPointer);
     if (image == nullptr) {
       throw std::runtime_error("Failed to convert NativeBuffer to SkImage!");
     }
-    auto hostObjectInstance =
-        std::make_shared<JsiSkImage>(getContext(), std::move(image));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-        runtime, hostObjectInstance, getContext());
+    return std::make_shared<JsiSkImage>(getContext(), std::move(image));
   }
 
-  JSI_HOST_FUNCTION(MakeImage) {
-    auto imageInfo = JsiSkImageInfo::fromValue(runtime, arguments[0]);
-    auto pixelData = JsiSkData::fromValue(runtime, arguments[1]);
-    auto bytesPerRow = arguments[2].asNumber();
+  std::variant<std::nullptr_t, std::shared_ptr<JsiSkImage>>
+  MakeImage(std::shared_ptr<SkImageInfo> imageInfo, sk_sp<SkData> pixelData,
+            double bytesPerRow) {
     auto image = SkImages::RasterFromData(*imageInfo, pixelData, bytesPerRow);
     if (image == nullptr) {
-      return jsi::Value::null();
+      return nullptr;
     }
-    auto hostObjectInstance =
-        std::make_shared<JsiSkImage>(getContext(), std::move(image));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-        runtime, hostObjectInstance, getContext());
+    return std::make_shared<JsiSkImage>(getContext(), std::move(image));
   }
 
   JSI_HOST_FUNCTION(MakeImageFromViewTag) {
@@ -88,10 +75,9 @@ public:
                     promise->reject("Failed to create image from view tag");
                     return;
                   }
-                  auto hostObjectInstance =
-                      std::make_shared<JsiSkImage>(context, std::move(result));
-                  promise->resolve(JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-                      runtime, hostObjectInstance, context));
+                  promise->resolve(
+                      makeJsiObject(runtime, std::make_shared<JsiSkImage>(
+                                                 context, std::move(result))));
                 });
               });
         });
@@ -105,97 +91,109 @@ public:
     if (image == nullptr) {
       throw std::runtime_error("Failed to convert native texture to SkImage!");
     }
-    if (count > 4 && arguments[4].isObject() &&
-        arguments[4].asObject(runtime).isHostObject(runtime)) {
-      auto jsiImage =
-          arguments[4].asObject(runtime).asHostObject<JsiSkImage>(runtime);
-      jsiImage->setObject(image);
-      return jsi::Value(runtime, arguments[4]);
+    if (count > 4) {
+      auto jsiImage = tryGetJsiObject<JsiSkImage>(runtime, arguments[4]);
+      if (jsiImage) {
+        jsiImage->setObject(image);
+        return jsi::Value(runtime, arguments[4]);
+      }
     }
-    auto hostObjectInstance =
-        std::make_shared<JsiSkImage>(getContext(), std::move(image));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-        runtime, hostObjectInstance, getContext());
+    return makeJsiObject(
+        runtime, std::make_shared<JsiSkImage>(getContext(), std::move(image)));
   }
 
-  JSI_HOST_FUNCTION(MakeImageFromTexture) {
+  // Pointer-based texture interop with react-native-webgpu. The GPUTexture
+  // JS objects live in react-native-webgpu, so textures cross the package
+  // boundary as raw WGPUTexture pointers (BigInt), exactly like the device
+  // handoff (Skia.getNativeDevice / importDevice). Only sound on the shared
+  // device: both packages link one Dawn and share one wgpu::Instance.
+
+  JSI_HOST_FUNCTION(MakeImageFromNativeTexture) {
 #ifdef SK_GRAPHITE
-    if (count < 1 || !arguments[0].isObject()) {
-      throw std::runtime_error(
-          "MakeImageFromTexture requires a GPUTexture argument");
+    if (count < 1 || !arguments[0].isBigInt()) {
+      throw std::runtime_error("MakeImageFromNativeTexture requires a "
+                               "WGPUTexture pointer (BigInt), e.g. "
+                               "texture.nativePointer");
     }
-    auto obj = arguments[0].asObject(runtime);
-    auto gpuTexture = obj.getNativeState<rnwgpu::GPUTexture>(runtime);
-    if (!gpuTexture) {
-      throw std::runtime_error("Invalid GPUTexture object");
+    auto raw = reinterpret_cast<WGPUTexture>(
+        arguments[0].asBigInt(runtime).asUint64(runtime));
+    if (raw == nullptr) {
+      throw std::runtime_error(
+          "MakeImageFromNativeTexture: pointer must be non-null");
     }
-
-    wgpu::Texture texture = gpuTexture->get();
-    int width = static_cast<int>(gpuTexture->getWidth());
-    int height = static_cast<int>(gpuTexture->getHeight());
-    wgpu::TextureFormat format = gpuTexture->getFormat();
-
+    // Borrow: AddRef so our wgpu::Texture holds its own reference; the
+    // wrapped SkImage retains the texture for its lifetime (see
+    // DawnContext::MakeImageFromTexture) and the caller keeps ownership of
+    // the JS GPUTexture.
+    wgpuTextureAddRef(raw);
+    wgpu::Texture texture = wgpu::Texture::Acquire(raw);
     auto &dawnContext = DawnContext::getInstance();
-    auto image =
-        dawnContext.MakeImageFromTexture(texture, width, height, format);
+    auto image = dawnContext.MakeImageFromTexture(
+        texture, static_cast<int>(texture.GetWidth()),
+        static_cast<int>(texture.GetHeight()), texture.GetFormat());
     if (image == nullptr) {
-      throw std::runtime_error("Failed to create SkImage from GPUTexture!");
+      throw std::runtime_error(
+          "MakeImageFromNativeTexture: failed to wrap the texture");
     }
-    auto hostObjectInstance =
-        std::make_shared<JsiSkImage>(getContext(), std::move(image));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-        runtime, hostObjectInstance, getContext());
+    return makeJsiObject(
+        runtime, std::make_shared<JsiSkImage>(getContext(), std::move(image)));
 #else
     throw std::runtime_error(
-        "MakeImageFromTexture is only available with the Graphite backend. "
-        "Rebuild with SK_GRAPHITE enabled.");
+        "MakeImageFromNativeTexture is only available with the Graphite "
+        "backend. Rebuild with SK_GRAPHITE enabled.");
 #endif
   }
 
-  JSI_HOST_FUNCTION(MakeTextureFromImage) {
+  JSI_HOST_FUNCTION(MakeNativeTextureFromImage) {
 #ifdef SK_GRAPHITE
     if (count < 1) {
       throw std::runtime_error(
-          "MakeTextureFromImage requires an SkImage argument");
+          "MakeNativeTextureFromImage requires an SkImage argument");
     }
     auto image = JsiSkImage::fromValue(runtime, arguments[0]);
     if (!image) {
       throw std::runtime_error("Invalid SkImage object");
     }
-
     auto &dawnContext = DawnContext::getInstance();
     wgpu::Texture texture = dawnContext.MakeTextureFromImage(image);
     if (!texture) {
-      throw std::runtime_error("Failed to create GPUTexture from SkImage!");
+      throw std::runtime_error(
+          "MakeNativeTextureFromImage: failed to create the texture");
     }
-
-    auto gpuTexture =
-        std::make_shared<rnwgpu::GPUTexture>(texture, "SkImage Texture");
-    return rnwgpu::GPUTexture::create(runtime, gpuTexture);
+    // Transfer ownership: the returned pointer carries one reference and must
+    // be adopted exactly once (react-native-webgpu's adoptTexture()), which
+    // releases it when the JS GPUTexture is destroyed.
+    return jsi::BigInt::fromUint64(
+        runtime, reinterpret_cast<uint64_t>(texture.MoveToCHandle()));
 #else
     throw std::runtime_error(
-        "MakeTextureFromImage is only available with the Graphite backend. "
-        "Rebuild with SK_GRAPHITE enabled.");
+        "MakeNativeTextureFromImage is only available with the Graphite "
+        "backend. Rebuild with SK_GRAPHITE enabled.");
 #endif
   }
 
-  size_t getMemoryPressure() const override { return 1024; }
-
-  std::string getObjectType() const override { return "JsiSkImageFactory"; }
-
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkImageFactory, MakeImageFromEncoded),
-                       JSI_EXPORT_FUNC(JsiSkImageFactory, MakeImageFromViewTag),
-                       JSI_EXPORT_FUNC(JsiSkImageFactory,
-                                       MakeImageFromNativeBuffer),
-                       JSI_EXPORT_FUNC(JsiSkImageFactory,
-                                       MakeImageFromNativeTextureUnstable),
-                       JSI_EXPORT_FUNC(JsiSkImageFactory, MakeImage),
-                       JSI_EXPORT_FUNC(JsiSkImageFactory, MakeNull),
-                       JSI_EXPORT_FUNC(JsiSkImageFactory, MakeImageFromTexture),
-                       JSI_EXPORT_FUNC(JsiSkImageFactory, MakeTextureFromImage))
+  size_t getMemoryPressure() override { return 1024; }
+
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installMethod(runtime, prototype, "MakeImageFromEncoded",
+                  &JsiSkImageFactory::MakeImageFromEncoded);
+    installHostMethod(runtime, prototype, "MakeImageFromViewTag",
+                      &JsiSkImageFactory::MakeImageFromViewTag);
+    installMethod(runtime, prototype, "MakeImageFromNativeBuffer",
+                  &JsiSkImageFactory::MakeImageFromNativeBuffer);
+    installHostMethod(runtime, prototype, "MakeImageFromNativeTextureUnstable",
+                      &JsiSkImageFactory::MakeImageFromNativeTextureUnstable);
+    installMethod(runtime, prototype, "MakeImage",
+                  &JsiSkImageFactory::MakeImage);
+    installMethod(runtime, prototype, "MakeNull", &JsiSkImageFactory::MakeNull);
+    installHostMethod(runtime, prototype, "MakeImageFromNativeTexture",
+                      &JsiSkImageFactory::MakeImageFromNativeTexture);
+    installHostMethod(runtime, prototype, "MakeNativeTextureFromImage",
+                      &JsiSkImageFactory::MakeNativeTextureFromImage);
+  }
 
   explicit JsiSkImageFactory(std::shared_ptr<RNSkPlatformContext> context)
-      : JsiSkHostObject(std::move(context)) {}
+      : JsiSkNativeObject<JsiSkImageFactory>(std::move(context)) {}
 };
 
 } // namespace RNSkia

package/cpp/api/JsiSkImageFilter.h

@@ -5,7 +5,7 @@
 
 #include <jsi/jsi.h>
 
-#include "JsiSkHostObjects.h"
+#include "JsiSkNativeObjects.h"
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
@@ -18,19 +18,29 @@ namespace RNSkia {
 
 namespace jsi = facebook::jsi;
 
-class JsiSkImageFilter : public JsiSkWrappingSkPtrHostObject<SkImageFilter> {
+class JsiSkImageFilter
+    : public JsiSkWrappingSkPtrNativeObject<JsiSkImageFilter, SkImageFilter> {
 public:
+  static constexpr const char *CLASS_NAME = "ImageFilter";
+
   JsiSkImageFilter(std::shared_ptr<RNSkPlatformContext> context,
                    sk_sp<SkImageFilter> imageFilter)
-      : JsiSkWrappingSkPtrHostObject<SkImageFilter>(std::move(context),
-                                                    std::move(imageFilter)) {}
-
-  size_t getMemoryPressure() const override { return 1024 * 1024; }
-
-  std::string getObjectType() const override { return "JsiSkImageFilter"; }
-
-  EXPORT_JSI_API_TYPENAME(JsiSkImageFilter, ImageFilter)
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkImageFilter, dispose))
+      : JsiSkWrappingSkPtrNativeObject<JsiSkImageFilter, SkImageFilter>(
+            std::move(context), std::move(imageFilter)) {}
+
+  size_t getMemoryPressure() override { return 1024 * 1024; }
+
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installCommon(runtime, prototype);
+  }
+
+  /**
+    Returns the underlying object from a host object of this type
+   */
+  static sk_sp<SkImageFilter> fromValue(jsi::Runtime &runtime,
+                                        const jsi::Value &obj) {
+    return objectFromValue(runtime, obj);
+  }
 };
 
 } // namespace RNSkia