react-native-webgpu 0.10.5 → 0.11.0

package/apple/WebGPUModule.mm

@@ -1,6 +1,7 @@
 #import "WebGPUModule.h"
 #include "ApplePlatformContext.h"
 #import "GPUCanvasContext.h"
+#import "RNWGUIKit.h"
 
 #import <React/RCTBridge+Private.h>
 #import <React/RCTCallInvoker.h>
@@ -31,6 +32,11 @@ static std::shared_ptr<rnwgpu::RNWebGPUManager> webgpuManager;
 // calls setCallInvoker: during module initialization.
 @synthesize callInvoker = _callInvoker;
 
+// Synthesize the view registry so the TurboModule infra injects it too. It
+// resolves React tags to native views in both Bridge and Bridgeless mode
+// (Fabric component views included), which drawElementImageToTexture needs.
+@synthesize viewRegistry_DEPRECATED = _viewRegistry_DEPRECATED;
+
 + (std::shared_ptr<rnwgpu::RNWebGPUManager>)getManager {
   return webgpuManager;
 }
@@ -74,8 +80,21 @@ RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(install) {
     return [NSNumber numberWithBool:NO];
   }
 
+  // Main-thread only (see ApplePlatformContext::ViewLookup). Weak: the module
+  // is invalidated on reload, after which lookups simply fail.
+  __weak WebGPUModule *weakSelf = self;
+  rnwgpu::ApplePlatformContext::ViewLookup viewLookup =
+      [weakSelf](int tag) -> void * {
+    WebGPUModule *strongSelf = weakSelf;
+    if (strongSelf == nil) {
+      return nullptr;
+    }
+    RNWGPlatformView *view =
+        [strongSelf.viewRegistry_DEPRECATED viewForReactTag:@(tag)];
+    return (__bridge void *)view;
+  };
   std::shared_ptr<rnwgpu::PlatformContext> platformContext =
-      std::make_shared<rnwgpu::ApplePlatformContext>();
+      std::make_shared<rnwgpu::ApplePlatformContext>(std::move(viewLookup));
   webgpuManager = std::make_shared<rnwgpu::RNWebGPUManager>(runtime, jsInvoker,
                                                             platformContext);
   return @true;

package/cpp/rnwgpu/PlatformContext.h

@@ -2,6 +2,7 @@
 
 #include <functional>
 #include <memory>
+#include <mutex>
 #include <span>
 #include <string>
 #include <utility>
@@ -72,11 +73,55 @@ public:
   virtual void pause() = 0;
 };
 
+// A request to rasterize a native React Native view (looked up by its React
+// tag) for GPUQueue.drawElementImageToTexture.
+//
+// The source rectangle is expressed in the view's own coordinate space, in
+// density-independent points (the units of React Native layout). A
+// non-positive sourceWidth/sourceHeight means "the whole view". The
+// destination size is in pixels: the platform rasterizes the source rectangle
+// scaled to exactly width x height.
+struct ViewSnapshotRequest {
+  int viewTag = 0;
+  double sourceX = 0;
+  double sourceY = 0;
+  double sourceWidth = 0;
+  double sourceHeight = 0;
+  uint32_t width = 0;
+  uint32_t height = 0;
+};
+
 class PlatformContext {
 public:
   PlatformContext() = default;
   virtual ~PlatformContext() = default;
 
+  // The platform context of the currently installed RNWebGPUManager, for API
+  // objects (e.g. GPUQueue) that are created without a reference to it. Set on
+  // install, cleared on teardown; a dev reload replaces it.
+  static void setCurrent(std::shared_ptr<PlatformContext> context) {
+    std::lock_guard<std::mutex> lock(currentMutex());
+    currentSlot() = std::move(context);
+  }
+  static std::shared_ptr<PlatformContext> current() {
+    std::lock_guard<std::mutex> lock(currentMutex());
+    return currentSlot();
+  }
+
+  // Rasterize a native view into CPU pixels (see ViewSnapshotRequest). The
+  // implementation hops to the platform UI thread, so this is asynchronous:
+  // exactly one of onSuccess / onError is invoked, from an arbitrary thread
+  // (typically the UI thread). Callers must not touch JSI in the callbacks.
+  //
+  // The returned ImageData is tightly packed (no row padding), 4 bytes per
+  // pixel, `format` is rgba8unorm or bgra8unorm depending on what the platform
+  // rasterizer produces natively, and `premultiplied` reports its alpha
+  // representation.
+  virtual void
+  snapshotView(const ViewSnapshotRequest &request,
+               std::function<void(ImageData)> onSuccess,
+               std::function<void(std::string)> onError) = 0;
+
   virtual wgpu::Surface makeSurface(wgpu::Instance instance, void *surface,
                                     int width, int height) = 0;
   virtual ImageData createImageBitmap(std::string blobId, double offset,
@@ -129,6 +174,16 @@ public:
   // and return its absolute path. Lets the SharedTextureMemory example play
   // a real decoded video without bundling an asset.
   virtual std::string writeTestVideoFile() = 0;
+
+private:
+  static std::mutex &currentMutex() {
+    static std::mutex mutex;
+    return mutex;
+  }
+  static std::shared_ptr<PlatformContext> &currentSlot() {
+    static std::shared_ptr<PlatformContext> slot;
+    return slot;
+  }
 };
 
 } // namespace rnwgpu

package/cpp/rnwgpu/RNWebGPUManager.cpp

@@ -67,6 +67,10 @@ RNWebGPUManager::RNWebGPUManager(
   // no invoker (best-effort; see README "Threading model").
   async::RuntimeContext::registerMainRuntime(_jsRuntime, _jsCallInvoker);
 
+  // Expose the platform context to API objects created later without a
+  // reference to it (GPUQueue::drawElementImageToTexture).
+  PlatformContext::setCurrent(_platformContext);
+
   auto gpu = std::make_shared<GPU>(*_jsRuntime);
   auto rnWebGPU =
       std::make_shared<RNWebGPU>(gpu, _platformContext, _jsCallInvoker);
@@ -248,6 +252,9 @@ RNWebGPUManager::~RNWebGPUManager() {
   // contextId counter, and stale entries would alias new canvases onto dead
   // surfaces.
   SurfaceRegistry::getInstance().clear();
+  if (PlatformContext::current() == _platformContext) {
+    PlatformContext::setCurrent(nullptr);
+  }
   _jsRuntime = nullptr;
   _jsCallInvoker = nullptr;
 }

package/cpp/rnwgpu/api/GPUQueue.cpp

@@ -1,10 +1,16 @@
 #include "GPUQueue.h"
 
+#include <algorithm>
+#include <cmath>
 #include <limits>
 #include <memory>
+#include <string>
+#include <utility>
 #include <vector>
 
 #include "Convertors.h"
+#include "ImageBitmap.h"
+#include "PlatformContext.h"
 
 namespace rnwgpu {
 
@@ -193,6 +199,187 @@ void GPUQueue::copyExternalImageToTexture(
   }
 }
 
+async::AsyncTaskHandle GPUQueue::drawElementImageToTexture(
+    jsi::Runtime &runtime, std::shared_ptr<GPUDrawElementImageSource> source,
+    std::shared_ptr<GPUDrawElementImageDestination> destination) {
+  auto platform = PlatformContext::current();
+  if (!platform) {
+    throw std::runtime_error(
+        "drawElementImageToTexture: react-native-webgpu is not installed");
+  }
+  if (!destination || !destination->info || !destination->info->texture) {
+    throw std::runtime_error(
+        "drawElementImageToTexture: `destination.texture` is required");
+  }
+  const auto &info = destination->info;
+
+  // Destination texture: only the 8-bit RGBA/BGRA formats the platform
+  // rasterizers produce natively are accepted (with a byte swizzle between
+  // the two); anything else would need a GPU blit.
+  wgpu::TexelCopyTextureInfo dst{};
+  Convertor conv;
+  if (!conv(dst.aspect, info->aspect) || !conv(dst.mipLevel, info->mipLevel) ||
+      !conv(dst.origin, info->origin) || !conv(dst.texture, info->texture)) {
+    throw std::runtime_error(
+        "drawElementImageToTexture: invalid destination");
+  }
+  const wgpu::Texture texture = info->texture->get();
+  bool destinationIsBgra = false;
+  switch (texture.GetFormat()) {
+  case wgpu::TextureFormat::RGBA8Unorm:
+  case wgpu::TextureFormat::RGBA8UnormSrgb:
+    destinationIsBgra = false;
+    break;
+  case wgpu::TextureFormat::BGRA8Unorm:
+  case wgpu::TextureFormat::BGRA8UnormSrgb:
+    destinationIsBgra = true;
+    break;
+  default:
+    throw std::runtime_error(
+        "drawElementImageToTexture: the destination texture must be "
+        "rgba8unorm, rgba8unorm-srgb, bgra8unorm or bgra8unorm-srgb");
+  }
+  if (!(texture.GetUsage() & wgpu::TextureUsage::CopyDst)) {
+    throw std::runtime_error(
+        "drawElementImageToTexture: the destination texture must have "
+        "GPUTextureUsage.COPY_DST");
+  }
+  if (texture.GetDimension() != wgpu::TextureDimension::e2D ||
+      texture.GetSampleCount() != 1) {
+    throw std::runtime_error(
+        "drawElementImageToTexture: the destination must be a single-sampled "
+        "2D texture");
+  }
+  if (dst.mipLevel >= texture.GetMipLevelCount()) {
+    throw std::runtime_error(
+        "drawElementImageToTexture: destination.mipLevel is out of range");
+  }
+  const uint32_t mipWidth =
+      std::max<uint32_t>(1, texture.GetWidth() >> dst.mipLevel);
+  const uint32_t mipHeight =
+      std::max<uint32_t>(1, texture.GetHeight() >> dst.mipLevel);
+  if (dst.origin.z >= texture.GetDepthOrArrayLayers()) {
+    throw std::runtime_error(
+        "drawElementImageToTexture: destination.origin.z is out of range");
+  }
+
+  // Source rectangle (points, view space). Omitted width/height mean "the
+  // whole view", which only the platform knows.
+  ViewSnapshotRequest request{};
+  request.viewTag = source->viewTag;
+  request.sourceX = source->sourceX.value_or(0.0);
+  request.sourceY = source->sourceY.value_or(0.0);
+  request.sourceWidth = source->sourceWidth.value_or(0.0);
+  request.sourceHeight = source->sourceHeight.value_or(0.0);
+  if (!std::isfinite(request.sourceX) || !std::isfinite(request.sourceY) ||
+      !std::isfinite(request.sourceWidth) ||
+      !std::isfinite(request.sourceHeight) ||
+      (source->sourceWidth.has_value() && request.sourceWidth <= 0) ||
+      (source->sourceHeight.has_value() && request.sourceHeight <= 0)) {
+    throw std::runtime_error(
+        "drawElementImageToTexture: the source rectangle must be finite with "
+        "a positive width and height");
+  }
+
+  // Destination size (pixels). Omitted means the source rectangle's natural
+  // pixel size (points times the device pixel ratio), which the platform
+  // computes; the bounds check then happens once the pixels are back.
+  if (destination->size.has_value()) {
+    wgpu::Extent3D size{};
+    if (!conv(size, destination->size.value())) {
+      throw std::runtime_error(
+          "drawElementImageToTexture: invalid destination.size");
+    }
+    if (size.width == 0 || size.height == 0 || size.depthOrArrayLayers != 1) {
+      throw std::runtime_error(
+          "drawElementImageToTexture: destination.size must have a positive "
+          "width and height and a depthOrArrayLayers of 1");
+    }
+    if (size.width > mipWidth - std::min(dst.origin.x, mipWidth) ||
+        size.height > mipHeight - std::min(dst.origin.y, mipHeight)) {
+      throw std::runtime_error(
+          "drawElementImageToTexture: destination.origin + destination.size "
+          "exceeds the texture's extent at destination.mipLevel");
+    }
+    request.width = size.width;
+    request.height = size.height;
+  }
+
+  // premultipliedAlpha defaults to false, like copyExternalImageToTexture.
+  const bool destinationPremultiplied =
+      info->premultipliedAlpha.value_or(false);
+
+  // Settle on the CALLING runtime's context (see GPUBuffer::mapAsync): the
+  // snapshot completes on the UI thread and is deposited into that context's
+  // mailbox; the texture write and the resolve then run on the runtime's own
+  // thread during its next tick.
+  auto context =
+      async::RuntimeContext::getOrCreate(runtime, _async->instance());
+  auto queue = _instance;
+  // Keeps the destination texture alive until the write is issued.
+  auto gpuTexture = info->texture;
+  return context->postTask(
+      [platform, request, dst, mipWidth, mipHeight, destinationIsBgra,
+       destinationPremultiplied, queue,
+       gpuTexture](const async::AsyncTaskHandle::ResolveFunction &resolve,
+                   const async::AsyncTaskHandle::RejectFunction &reject) {
+        platform->snapshotView(
+            request,
+            [resolve, reject, dst, mipWidth, mipHeight, destinationIsBgra,
+             destinationPremultiplied, queue,
+             gpuTexture](ImageData image) mutable {
+              // Arbitrary (UI) thread: validate without touching JSI.
+              if (image.width == 0 || image.height == 0 ||
+                  image.data.size() < image.width * image.height * 4) {
+                reject("drawElementImageToTexture: the view produced no "
+                       "pixels (is it mounted with a non-zero size?)");
+                return;
+              }
+              if (image.width > mipWidth - std::min<uint32_t>(dst.origin.x,
+                                                              mipWidth) ||
+                  image.height > mipHeight - std::min<uint32_t>(dst.origin.y,
+                                                                mipHeight)) {
+                reject("drawElementImageToTexture: the view's natural pixel "
+                       "size (" +
+                       std::to_string(image.width) + "x" +
+                       std::to_string(image.height) +
+                       ") does not fit in the destination texture at "
+                       "destination.origin; pass destination.size to scale "
+                       "it, or create a larger texture");
+                return;
+              }
+              resolve([image = std::move(image), dst, destinationIsBgra,
+                       destinationPremultiplied, queue,
+                       gpuTexture](jsi::Runtime &) mutable -> jsi::Value {
+                // Owning runtime's thread. Bring the pixels into the
+                // destination's channel order and alpha representation, then
+                // issue the write.
+                const bool sourceIsBgra =
+                    image.format == wgpu::TextureFormat::BGRA8Unorm ||
+                    image.format == wgpu::TextureFormat::BGRA8UnormSrgb;
+                uint8_t *pixels = image.data.data();
+                const size_t byteLength = image.width * image.height * 4;
+                if (sourceIsBgra != destinationIsBgra) {
+                  for (size_t i = 0; i + 3 < byteLength; i += 4) {
+                    std::swap(pixels[i], pixels[i + 2]);
+                  }
+                }
+                convertAlpha(pixels, byteLength, image.premultiplied,
+                             destinationPremultiplied);
+                wgpu::TexelCopyBufferLayout layout{};
+                layout.offset = 0;
+                layout.bytesPerRow = static_cast<uint32_t>(image.width * 4);
+                layout.rowsPerImage = static_cast<uint32_t>(image.height);
+                wgpu::Extent3D extent{static_cast<uint32_t>(image.width),
+                                      static_cast<uint32_t>(image.height), 1};
+                queue.WriteTexture(&dst, pixels, byteLength, &layout, &extent);
+                return jsi::Value::undefined();
+              });
+            },
+            [reject](std::string error) { reject(std::move(error)); });
+      });
+}
+
 void GPUQueue::writeTexture(std::shared_ptr<GPUImageCopyTexture> destination,
                             std::shared_ptr<ArrayBuffer> data,
                             std::shared_ptr<GPUImageDataLayout> dataLayout,

package/cpp/rnwgpu/api/GPUQueue.h

@@ -16,6 +16,8 @@
 #include "ArrayBuffer.h"
 #include "GPUBuffer.h"
 #include "GPUCommandBuffer.h"
+#include "GPUDrawElementImageDestination.h"
+#include "GPUDrawElementImageSource.h"
 #include "GPUImageCopyExternalImage.h"
 #include "GPUImageCopyTextureTagged.h"
 
@@ -51,6 +53,18 @@ public:
       std::shared_ptr<GPUImageCopyTextureTagged> destination,
       std::shared_ptr<GPUExtent3D> copySize);
 
+  // Non-spec React Native extension modeled on the html-in-canvas proposal's
+  // GPUQueue.drawElementImageToTexture: rasterizes a native view (the
+  // "element") and writes the pixels into `destination.texture`. Unlike the
+  // web API it returns a Promise, because the view can only be rasterized on
+  // the platform UI thread; the texture write is issued on the calling
+  // runtime's thread right before the promise resolves, so work submitted
+  // after `await` observes the new contents.
+  async::AsyncTaskHandle drawElementImageToTexture(
+      jsi::Runtime &runtime,
+      std::shared_ptr<GPUDrawElementImageSource> source,
+      std::shared_ptr<GPUDrawElementImageDestination> destination);
+
   std::string getLabel() { return _label; }
   void setLabel(const std::string &label) {
     _label = label;
@@ -66,6 +80,8 @@ public:
     installMethod(runtime, prototype, "writeTexture", &GPUQueue::writeTexture);
     installMethod(runtime, prototype, "copyExternalImageToTexture",
                   &GPUQueue::copyExternalImageToTexture);
+    installMethodWithRuntime(runtime, prototype, "drawElementImageToTexture",
+                             &GPUQueue::drawElementImageToTexture);
     installGetterSetter(runtime, prototype, "label", &GPUQueue::getLabel,
                         &GPUQueue::setLabel);
   }

package/cpp/rnwgpu/api/descriptors/GPUDrawElementImageDestination.h

@@ -0,0 +1,60 @@
+#pragma once
+
+#include <memory>
+#include <optional>
+
+#include "JSIConverter.h"
+
+#include "GPUExtent3D.h"
+#include "GPUImageCopyTextureTagged.h"
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+// The `destination` argument of GPUQueue.drawElementImageToTexture:
+//   dictionary GPUDrawElementImageDestination : GPUCopyExternalImageDestInfo {
+//     GPUExtent3D size;
+//   };
+// `size` is the pixel size of the region the view is drawn into. When omitted
+// it is the source rectangle's natural pixel size (points times the device
+// pixel ratio).
+struct GPUDrawElementImageDestination {
+  std::shared_ptr<GPUImageCopyTextureTagged> info;
+  std::optional<std::shared_ptr<GPUExtent3D>> size;
+};
+
+} // namespace rnwgpu
+
+namespace rnwgpu {
+
+template <>
+struct JSIConverter<std::shared_ptr<rnwgpu::GPUDrawElementImageDestination>> {
+  static std::shared_ptr<rnwgpu::GPUDrawElementImageDestination>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUDrawElementImageDestination>();
+    if (outOfBounds || !arg.isObject()) {
+      throw std::runtime_error(
+          "drawElementImageToTexture: expected a destination dictionary");
+    }
+    result->info =
+        JSIConverter<std::shared_ptr<GPUImageCopyTextureTagged>>::fromJSI(
+            runtime, arg, false);
+    auto obj = arg.getObject(runtime);
+    if (obj.hasProperty(runtime, "size")) {
+      result->size =
+          JSIConverter<std::optional<std::shared_ptr<GPUExtent3D>>>::fromJSI(
+              runtime, obj.getProperty(runtime, "size"), false);
+    }
+    return result;
+  }
+
+  static jsi::Value
+  toJSI(jsi::Runtime &runtime,
+        std::shared_ptr<rnwgpu::GPUDrawElementImageDestination> arg) {
+    throw std::runtime_error(
+        "Invalid GPUDrawElementImageDestination::toJSI()");
+  }
+};
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/descriptors/GPUDrawElementImageSource.h

@@ -0,0 +1,106 @@
+#pragma once
+
+#include <memory>
+#include <optional>
+#include <string>
+
+#include "JSIConverter.h"
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+// The `source` argument of GPUQueue.drawElementImageToTexture, modeled on the
+// html-in-canvas proposal's GPUDrawElementImageSource. On the web `source` is
+// an Element; here it is a native React Native view, identified by its React
+// tag. The optional rectangle selects the part of the view to draw, in the
+// view's own coordinate space and in density-independent points (React Native
+// layout units); it defaults to the whole view.
+struct GPUDrawElementImageSource {
+  int viewTag = 0;                    // resolved from `source`
+  std::optional<double> sourceX;      // float
+  std::optional<double> sourceY;      // float
+  std::optional<double> sourceWidth;  // float
+  std::optional<double> sourceHeight; // float
+};
+
+} // namespace rnwgpu
+
+namespace rnwgpu {
+
+template <>
+struct JSIConverter<std::shared_ptr<rnwgpu::GPUDrawElementImageSource>> {
+  // Resolve `source` to a React tag. Accepted shapes:
+  //   - a number: the tag itself (what findNodeHandle returns)
+  //   - a React Native host component instance: on the New Architecture these
+  //     carry the tag as `__nativeTag` (ReactFabricHostComponent /
+  //     ReactNativeElement), which is also what findNodeHandle reads
+  //   - a ref object (`{ current }`) wrapping either of the above
+  // The JS wrapper on the main runtime additionally runs findNodeHandle so
+  // class components and legacy instances resolve too; this native fallback is
+  // what worklet runtimes (no findNodeHandle) get.
+  static int resolveViewTag(jsi::Runtime &runtime, const jsi::Value &value,
+                            int depth = 0) {
+    if (value.isNumber()) {
+      return static_cast<int>(value.getNumber());
+    }
+    if (value.isObject() && depth < 2) {
+      auto obj = value.getObject(runtime);
+      if (obj.hasProperty(runtime, "__nativeTag")) {
+        auto tag = obj.getProperty(runtime, "__nativeTag");
+        if (tag.isNumber()) {
+          return static_cast<int>(tag.getNumber());
+        }
+      }
+      if (obj.hasProperty(runtime, "current")) {
+        return resolveViewTag(runtime, obj.getProperty(runtime, "current"),
+                              depth + 1);
+      }
+    }
+    throw std::runtime_error(
+        "drawElementImageToTexture: `source` must be a React Native view "
+        "(a host component ref, its instance, or the tag returned by "
+        "findNodeHandle)");
+  }
+
+  static std::shared_ptr<rnwgpu::GPUDrawElementImageSource>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUDrawElementImageSource>();
+    if (outOfBounds || !arg.isObject()) {
+      throw std::runtime_error(
+          "drawElementImageToTexture: expected a source dictionary");
+    }
+    auto obj = arg.getObject(runtime);
+    if (!obj.hasProperty(runtime, "source")) {
+      throw std::runtime_error(
+          "drawElementImageToTexture: `source.source` is required");
+    }
+    result->viewTag =
+        resolveViewTag(runtime, obj.getProperty(runtime, "source"));
+    if (obj.hasProperty(runtime, "sourceX")) {
+      result->sourceX = JSIConverter<std::optional<double>>::fromJSI(
+          runtime, obj.getProperty(runtime, "sourceX"), false);
+    }
+    if (obj.hasProperty(runtime, "sourceY")) {
+      result->sourceY = JSIConverter<std::optional<double>>::fromJSI(
+          runtime, obj.getProperty(runtime, "sourceY"), false);
+    }
+    if (obj.hasProperty(runtime, "sourceWidth")) {
+      result->sourceWidth = JSIConverter<std::optional<double>>::fromJSI(
+          runtime, obj.getProperty(runtime, "sourceWidth"), false);
+    }
+    if (obj.hasProperty(runtime, "sourceHeight")) {
+      result->sourceHeight = JSIConverter<std::optional<double>>::fromJSI(
+          runtime, obj.getProperty(runtime, "sourceHeight"), false);
+    }
+    return result;
+  }
+
+  static jsi::Value
+  toJSI(jsi::Runtime &runtime,
+        std::shared_ptr<rnwgpu::GPUDrawElementImageSource> arg) {
+    throw std::runtime_error("Invalid GPUDrawElementImageSource::toJSI()");
+  }
+};
+
+} // namespace rnwgpu

package/lib/commonjs/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["_main","require","Object","keys","forEach","key","prototype","hasOwnProperty","call","_exportNames","exports","defineProperty","enumerable","get","_constants","_install"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;;;;;;;;;;;;;AAcA,IAAAA,KAAA,GAAAC,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAH,KAAA,EAAAI,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAH,MAAA,CAAAI,SAAA,CAAAC,cAAA,CAAAC,IAAA,CAAAC,YAAA,EAAAJ,GAAA;EAAA,IAAAA,GAAA,IAAAK,OAAA,IAAAA,OAAA,CAAAL,GAAA,MAAAL,KAAA,CAAAK,GAAA;EAAAH,MAAA,CAAAS,cAAA,CAAAD,OAAA,EAAAL,GAAA;IAAAO,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAb,KAAA,CAAAK,GAAA;IAAA;EAAA;AAAA;AACA,IAAAS,UAAA,GAAAb,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAW,UAAA,EAAAV,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAH,MAAA,CAAAI,SAAA,CAAAC,cAAA,CAAAC,IAAA,CAAAC,YAAA,EAAAJ,GAAA;EAAA,IAAAA,GAAA,IAAAK,OAAA,IAAAA,OAAA,CAAAL,GAAA,MAAAS,UAAA,CAAAT,GAAA;EAAAH,MAAA,CAAAS,cAAA,CAAAD,OAAA,EAAAL,GAAA;IAAAO,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAC,UAAA,CAAAT,GAAA;IAAA;EAAA;AAAA;AACA,IAAAU,QAAA,GAAAd,OAAA","ignoreList":[]}
+{"version":3,"names":["_main","require","Object","keys","forEach","key","prototype","hasOwnProperty","call","_exportNames","exports","defineProperty","enumerable","get","_constants","_install"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;;;;;;;;;;;;;AAgBA,IAAAA,KAAA,GAAAC,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAH,KAAA,EAAAI,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAH,MAAA,CAAAI,SAAA,CAAAC,cAAA,CAAAC,IAAA,CAAAC,YAAA,EAAAJ,GAAA;EAAA,IAAAA,GAAA,IAAAK,OAAA,IAAAA,OAAA,CAAAL,GAAA,MAAAL,KAAA,CAAAK,GAAA;EAAAH,MAAA,CAAAS,cAAA,CAAAD,OAAA,EAAAL,GAAA;IAAAO,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAb,KAAA,CAAAK,GAAA;IAAA;EAAA;AAAA;AACA,IAAAS,UAAA,GAAAb,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAW,UAAA,EAAAV,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAH,MAAA,CAAAI,SAAA,CAAAC,cAAA,CAAAC,IAAA,CAAAC,YAAA,EAAAJ,GAAA;EAAA,IAAAA,GAAA,IAAAK,OAAA,IAAAA,OAAA,CAAAL,GAAA,MAAAS,UAAA,CAAAT,GAAA;EAAAH,MAAA,CAAAS,cAAA,CAAAD,OAAA,EAAAL,GAAA;IAAAO,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAC,UAAA,CAAAT,GAAA;IAAA;EAAA;AAAA;AACA,IAAAU,QAAA,GAAAd,OAAA","ignoreList":[]}

package/lib/commonjs/main/index.js

@@ -12,6 +12,7 @@ Object.defineProperty(exports, "WebGPUModule", {
     return _NativeWebGPUModule.default;
   }
 });
+var _reactNative = require("react-native");
 var _external = require("../external");
 var _install = require("../install");
 var _NativeWebGPUModule = _interopRequireDefault(require("../NativeWebGPUModule"));
@@ -100,6 +101,37 @@ Object.keys(_formats).forEach(function (key) {
   });
 });
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+// Resolve the `source` of drawElementImageToTexture to a React tag on the
+// main JS runtime, where findNodeHandle is available: it handles class
+// components and legacy host instances that the native fallback (a number or
+// an instance carrying `__nativeTag`) does not.
+const resolveElementSource = source => {
+  if (typeof source === "number") {
+    return source;
+  }
+  const instance = source !== null && typeof source === "object" && "current" in source ? source.current : source;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const tag = instance == null ? null : (0, _reactNative.findNodeHandle)(instance);
+  if (tag === null || tag === undefined) {
+    throw new Error("[WebGPU] drawElementImageToTexture: `source` does not resolve to a " + "mounted native view (pass a host component ref rendered with " + "collapsable={false})");
+  }
+  return tag;
+};
+const installDrawElementImageToTexture = () => {
+  if (typeof GPUQueue === "undefined") {
+    return;
+  }
+  const native = GPUQueue.prototype.drawElementImageToTexture;
+  if (typeof native !== "function") {
+    return;
+  }
+  GPUQueue.prototype.drawElementImageToTexture = function (source, destination) {
+    return native.call(this, {
+      ...source,
+      source: resolveElementSource(source.source)
+    }, destination);
+  };
+};
 const _installOk = _NativeWebGPUModule.default.install();
 (0, _external.registerWebGPUForReanimated)();
 if (typeof RNWebGPU !== "undefined") {
@@ -122,6 +154,7 @@ if (typeof RNWebGPU !== "undefined") {
     }
   }
   global.createImageBitmap = global.createImageBitmap ?? RNWebGPU.createImageBitmap.bind(RNWebGPU);
+  installDrawElementImageToTexture();
   // Let installWebGPU() put navigator.gpu on other runtimes (see install.ts).
   (0, _install.provideGPUForInstall)(RNWebGPU.gpu);
 } else {

package/lib/commonjs/main/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["_external","require","_install","_NativeWebGPUModule","_interopRequireDefault","_Canvas","Object","keys","forEach","key","prototype","hasOwnProperty","call","_exportNames","exports","defineProperty","enumerable","get","_Offscreen","_WebGPUViewNativeComponent","_hooks","_GPUDeviceProvider","_importDevice","_formats","e","__esModule","default","_installOk","WebGPUModule","install","registerWebGPUForReanimated","RNWebGPU","navigator","gpu","userAgent","global","createImageBitmap","bind","provideGPUForInstall","console","warn"],"sourceRoot":"../../../src","sources":["main/index.tsx"],"mappings":"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","ignoreList":[]}
+{"version":3,"names":["_reactNative","require","_external","_install","_NativeWebGPUModule","_interopRequireDefault","_Canvas","Object","keys","forEach","key","prototype","hasOwnProperty","call","_exportNames","exports","defineProperty","enumerable","get","_Offscreen","_WebGPUViewNativeComponent","_hooks","_GPUDeviceProvider","_importDevice","_formats","e","__esModule","default","resolveElementSource","source","instance","current","tag","findNodeHandle","undefined","Error","installDrawElementImageToTexture","GPUQueue","native","drawElementImageToTexture","destination","_installOk","WebGPUModule","install","registerWebGPUForReanimated","RNWebGPU","navigator","gpu","userAgent","global","createImageBitmap","bind","provideGPUForInstall","console","warn"],"sourceRoot":"../../../src","sources":["main/index.tsx"],"mappings":"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","ignoreList":[]}

package/lib/module/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["installWebGPU"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":"AAAA;;AAcA,cAAc,QAAQ;AACtB,cAAc,aAAa;AAC3B,SAASA,aAAa,QAAQ,WAAW","ignoreList":[]}
+{"version":3,"names":["installWebGPU"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":"AAAA;;AAgBA,cAAc,QAAQ;AACtB,cAAc,aAAa;AAC3B,SAASA,aAAa,QAAQ,WAAW","ignoreList":[]}