react-native-webgpu 0.5.14 → 0.5.15

package/src/install.ts

@@ -0,0 +1,61 @@
+import {
+  GPUBufferUsage,
+  GPUColorWrite,
+  GPUMapMode,
+  GPUShaderStage,
+  GPUTextureUsage,
+} from "./constants";
+
+// Globals that this function installs on the calling runtime. These are the
+// native-derived flag constants re-exported from `./constants` (a single source
+// of truth, matching the native `wgpu::*Usage` enums), so they are safe to set
+// on any runtime.
+const constants = {
+  GPUBufferUsage,
+  GPUTextureUsage,
+  GPUShaderStage,
+  GPUColorWrite,
+  GPUMapMode,
+};
+
+/**
+ * Install WebGPU on the runtime that calls it.
+ *
+ * The native module installs the WebGPU flag constants (`GPUBufferUsage`,
+ * `GPUTextureUsage`, `GPUShaderStage`, `GPUColorWrite`, `GPUMapMode`) as globals
+ * on the main JS runtime, but worklet runtimes (Reanimated UI, dedicated worklet
+ * runtimes, Vision Camera frame processors) start without them, so referencing
+ * the bare global inside a worklet yields `undefined`.
+ *
+ * Call `installWebGPU()` once at the top of a worklet to make those globals
+ * available there, instead of importing each constant by hand:
+ *
+ * ```tsx
+ * import { installWebGPU } from "react-native-webgpu";
+ *
+ * const work = (device: GPUDevice) => {
+ *   "worklet";
+ *   installWebGPU();
+ *   device.createBuffer({
+ *     usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
+ *   });
+ * };
+ * ```
+ *
+ * The constants are captured into the worklet by closure (the same way a shader
+ * string is), so they work on every runtime. Calling it on a runtime that
+ * already has the globals (e.g. the main JS runtime) is a safe no-op.
+ *
+ * This is the explicit entry point for runtime setup; for now it only installs
+ * the flag constants, but it is the place where other per-runtime WebGPU setup
+ * (e.g. `navigator.gpu`) can be wired in later.
+ */
+export const installWebGPU = () => {
+  "worklet";
+  const g = globalThis as unknown as Record<string, unknown>;
+  for (const [key, value] of Object.entries(constants)) {
+    if (g[key] === undefined) {
+      g[key] = value;
+    }
+  }
+};

package/src/types.ts

@@ -9,6 +9,15 @@ export interface NativeCanvas {
 }
 
 export type RNCanvasContext = GPUCanvasContext & {
+  /**
+   * Present the current frame.
+   *
+   * Call this after `queue.submit()` on every runtime: the main JS runtime, the
+   * Reanimated UI runtime, and dedicated worklet runtimes (e.g.
+   * `createWorkletRuntime` / `runOnRuntime`, or a Vision Camera frame
+   * processor). It runs synchronously on the calling thread, so the frame is
+   * presented from whichever thread did the rendering.
+   */
   present: () => void;
 };
 
@@ -75,6 +84,55 @@ export interface GPUSharedTextureMemoryDescriptor {
   label?: string;
 }
 
+// The kind of native synchronization primitive a GPUSharedFence wraps, matching
+// the shared-fence-* device feature names. Limited to the kinds react-native-webgpu
+// targets (iOS/Metal and Android/Vulkan); importSharedFence accepts these and
+// export() reports them.
+export type GPUSharedFenceType =
+  | "mtl-shared-event"
+  | "sync-fd"
+  | "vk-semaphore-opaque-fd";
+
+export interface GPUSharedFenceDescriptor {
+  // The fence kind to import. Must match a shared-fence-* feature enabled on
+  // the device.
+  type: GPUSharedFenceType;
+  // The raw native handle as a BigInt: an id<MTLSharedEvent> pointer for
+  // "mtl-shared-event", or an OS file descriptor for the *-fd kinds.
+  handle: bigint;
+  label?: string;
+}
+
+export interface GPUSharedFenceExportInfo {
+  type: GPUSharedFenceType;
+  // An id<MTLSharedEvent> pointer (Apple) or file descriptor (Android), as a
+  // BigInt. The caller takes ownership; e.g. an exported sync-fd must be
+  // closed once consumed.
+  handle: bigint;
+}
+
+// A native GPU synchronization primitive shared across queues/APIs. Produced by
+// GPUSharedTextureMemory.endAccess(), consumed by beginAccess(), or imported
+// from a consumer's fence with GPUDevice.importSharedFence().
+export interface GPUSharedFence {
+  readonly __brand: "GPUSharedFence";
+  label: string;
+  export(): GPUSharedFenceExportInfo;
+}
+
+// A fence and the timeline value to wait for (0n for binary sync-fd fences).
+export interface GPUSharedFenceState {
+  fence: GPUSharedFence;
+  signaledValue: bigint;
+}
+
+// The result of GPUSharedTextureMemory.endAccess(): each fence is signaled at
+// its signaledValue once Dawn's GPU work for the access completes.
+export interface GPUSharedTextureMemoryEndAccessState {
+  initialized: boolean;
+  fences: GPUSharedFenceState[];
+}
+
 // Non-standard, Dawn-only device toggles. Mirrors Dawn's DawnTogglesDescriptor
 // and is chained onto the native device descriptor at requestDevice time.
 // Pass it via the (augmented) GPUDeviceDescriptor: adapter.requestDevice({
@@ -96,7 +154,15 @@ export interface GPUSharedTextureMemory {
   createTexture(descriptor?: GPUTextureDescriptor): GPUTexture;
   // `initialized` declares whether the surface already holds meaningful pixels
   // (true for an incoming video/camera frame, false if the next pass will fully
-  // overwrite it).
-  beginAccess(texture: GPUTexture, initialized: boolean): boolean;
-  endAccess(texture: GPUTexture): boolean;
+  // overwrite it). Optional `fences` are wait fences: Dawn waits for each to
+  // reach its signaledValue before writing the surface. Throws if the access
+  // could not begin.
+  beginAccess(
+    texture: GPUTexture,
+    initialized: boolean,
+    fences?: GPUSharedFenceState[],
+  ): void;
+  // Ends the access and returns the fences Dawn produced for it. Throws if the
+  // access could not be ended.
+  endAccess(texture: GPUTexture): GPUSharedTextureMemoryEndAccessState;
 }

package/cpp/rnwgpu/async/AsyncDispatcher.h

@@ -1,28 +0,0 @@
-#pragma once
-
-#include <functional>
-#include <memory>
-
-#include <jsi/jsi.h>
-
-namespace rnwgpu::async {
-
-namespace jsi = facebook::jsi;
-
-/**
- * Abstract dispatcher used by the AsyncRunner to enqueue work back onto the
- * JavaScript thread.
- */
-class AsyncDispatcher {
-public:
-  using Work = std::function<void(jsi::Runtime &)>;
-
-  virtual ~AsyncDispatcher() = default;
-
-  /**
-   * Enqueue a unit of work that will be executed on the JavaScript thread.
-   */
-  virtual void post(Work work) = 0;
-};
-
-} // namespace rnwgpu::async

package/cpp/rnwgpu/async/AsyncRunner.cpp

@@ -1,215 +0,0 @@
-#include "AsyncRunner.h"
-
-#include <chrono>
-#include <stdexcept>
-#include <utility>
-
-#include "AsyncTaskHandle.h"
-#include "WGPULogger.h"
-
-namespace rnwgpu::async {
-
-namespace {
-struct RuntimeData {
-  std::shared_ptr<AsyncRunner> runner;
-};
-constexpr const char *TAG = "AsyncRunner";
-} // namespace
-
-AsyncRunner::AsyncRunner(wgpu::Instance instance,
-                         std::shared_ptr<AsyncDispatcher> dispatcher)
-    : _instance(std::move(instance)), _dispatcher(std::move(dispatcher)),
-      _pendingTasks(0), _pumpTasks(0), _tickScheduled(false),
-      _lastTickTimeNs(0) {
-  if (!_dispatcher) {
-    throw std::runtime_error("AsyncRunner requires a valid dispatcher.");
-  }
-  Logger::logToConsole("[%s] Created runner (dispatcher=%p)", TAG,
-                       _dispatcher.get());
-}
-
-std::shared_ptr<AsyncRunner> AsyncRunner::get(jsi::Runtime &runtime) {
-  auto data = runtime.getRuntimeData(runtimeDataUUID());
-  if (!data) {
-    return nullptr;
-  }
-  auto stored = std::static_pointer_cast<RuntimeData>(data);
-  return stored->runner;
-}
-
-std::shared_ptr<AsyncRunner>
-AsyncRunner::getOrCreate(jsi::Runtime &runtime, wgpu::Instance instance,
-                         std::shared_ptr<AsyncDispatcher> dispatcher) {
-  auto existing = get(runtime);
-  if (existing) {
-    return existing;
-  }
-
-  auto runner =
-      std::make_shared<AsyncRunner>(std::move(instance), std::move(dispatcher));
-  auto data = std::make_shared<RuntimeData>();
-  data->runner = runner;
-  runtime.setRuntimeData(runtimeDataUUID(), data);
-  return runner;
-}
-
-AsyncTaskHandle AsyncRunner::postTask(const TaskCallback &callback,
-                                      bool keepPumping) {
-  auto handle = AsyncTaskHandle::create(shared_from_this(), keepPumping);
-  if (!handle.valid()) {
-    throw std::runtime_error("Failed to create AsyncTaskHandle.");
-  }
-
-  _pendingTasks.fetch_add(1, std::memory_order_acq_rel);
-  if (keepPumping) {
-    _pumpTasks.fetch_add(1, std::memory_order_acq_rel);
-  }
-  requestTick();
-
-  Logger::logToConsole(
-      "[%s] postTask (keepPumping=%s, pending=%zu, pumping=%zu)", TAG,
-      keepPumping ? "true" : "false",
-      _pendingTasks.load(std::memory_order_acquire),
-      _pumpTasks.load(std::memory_order_acquire));
-
-  auto resolve = handle.createResolveFunction();
-  auto reject = handle.createRejectFunction();
-
-  try {
-    callback(resolve, reject);
-  } catch (const std::exception &exception) {
-    reject(exception.what());
-  } catch (...) {
-    reject("Unknown native error in AsyncRunner::postTask.");
-  }
-
-  return handle;
-}
-
-void AsyncRunner::requestTick() {
-  bool expected = false;
-  if (!_tickScheduled.compare_exchange_strong(expected, true,
-                                              std::memory_order_acq_rel)) {
-    return;
-  }
-
-  auto self = shared_from_this();
-  _dispatcher->post([self](jsi::Runtime &runtime) {
-    auto tickCallback = jsi::Function::createFromHostFunction(
-        runtime, jsi::PropNameID::forAscii(runtime, "AsyncRunnerTick"), 0,
-        [self](jsi::Runtime &runtime, const jsi::Value & /*thisValue*/,
-               const jsi::Value * /*args*/, size_t /*count*/) -> jsi::Value {
-          self->tick(runtime);
-          return jsi::Value::undefined();
-        });
-
-#if defined(ANDROID) || defined(__ANDROID__)
-    auto global = runtime.global();
-    auto setImmediateValue = global.getProperty(runtime, "setImmediate");
-    constexpr auto kMinTickInterval = std::chrono::milliseconds(4);
-    const int64_t nowNs =
-        std::chrono::duration_cast<std::chrono::nanoseconds>(
-            std::chrono::steady_clock::now().time_since_epoch())
-            .count();
-    const int64_t lastNs =
-        self->_lastTickTimeNs.load(std::memory_order_acquire);
-    int delayMs = 0;
-    if (lastNs > 0) {
-      const int64_t elapsedNs = nowNs - lastNs;
-      const int64_t minIntervalNs = kMinTickInterval.count() * 1000000LL;
-      if (elapsedNs < minIntervalNs) {
-        const int64_t remainingNs = minIntervalNs - elapsedNs;
-        delayMs = static_cast<int>((remainingNs + 999999) / 1000000);
-      }
-    }
-
-    auto tryScheduleTimeout = [&](int ms) {
-      auto setTimeoutValue = global.getProperty(runtime, "setTimeout");
-      if (!setTimeoutValue.isObject()) {
-        return false;
-      }
-      auto setTimeoutObj = setTimeoutValue.asObject(runtime);
-      if (!setTimeoutObj.isFunction(runtime)) {
-        return false;
-      }
-      Logger::logToConsole("[%s] requestTick scheduled via setTimeout(%d)", TAG,
-                           ms);
-      auto setTimeoutFn = setTimeoutObj.asFunction(runtime);
-      jsi::Value callbackArg(runtime, tickCallback);
-      jsi::Value delayArg(static_cast<double>(ms));
-      setTimeoutFn.call(runtime, callbackArg, delayArg);
-      return true;
-    };
-
-    if (delayMs > 0) {
-      if (tryScheduleTimeout(delayMs)) {
-        return;
-      }
-      // If setTimeout unavailable fall through to immediate scheduling.
-    }
-
-    if (setImmediateValue.isObject()) {
-      auto setImmediateObj = setImmediateValue.asObject(runtime);
-      if (setImmediateObj.isFunction(runtime)) {
-        Logger::logToConsole("[%s] requestTick scheduled via setImmediate",
-                             TAG);
-        auto setImmediateFn = setImmediateObj.asFunction(runtime);
-        jsi::Value callbackArg(runtime, tickCallback);
-        setImmediateFn.call(runtime, callbackArg);
-        return;
-      }
-    }
-
-    int timeoutDelayMs = delayMs > 0 ? delayMs : 0;
-    if (tryScheduleTimeout(timeoutDelayMs)) {
-      return;
-    }
-
-    Logger::logToConsole("[%s] requestTick scheduled via microtask fallback",
-                         TAG);
-    runtime.queueMicrotask(std::move(tickCallback));
-#else
-    Logger::logToConsole("[%s] requestTick scheduled microtask (non-Android)",
-                         TAG);
-    runtime.queueMicrotask(std::move(tickCallback));
-#endif
-  });
-}
-
-void AsyncRunner::tick(jsi::Runtime & /*runtime*/) {
-  _tickScheduled.store(false, std::memory_order_release);
-  _instance.ProcessEvents();
-  const auto nowNs = std::chrono::duration_cast<std::chrono::nanoseconds>(
-                         std::chrono::steady_clock::now().time_since_epoch())
-                         .count();
-  _lastTickTimeNs.store(nowNs, std::memory_order_release);
-  Logger::logToConsole("[%s] tick processed events (pending=%zu, pumping=%zu)",
-                       TAG, _pendingTasks.load(std::memory_order_acquire),
-                       _pumpTasks.load(std::memory_order_acquire));
-  if (_pumpTasks.load(std::memory_order_acquire) > 0) {
-    requestTick();
-  }
-}
-
-void AsyncRunner::onTaskSettled(bool keepPumping) {
-  _pendingTasks.fetch_sub(1, std::memory_order_acq_rel);
-  if (keepPumping) {
-    _pumpTasks.fetch_sub(1, std::memory_order_acq_rel);
-  }
-  Logger::logToConsole(
-      "[%s] onTaskSettled (keepPumping=%s, pending=%zu, pumping=%zu)", TAG,
-      keepPumping ? "true" : "false",
-      _pendingTasks.load(std::memory_order_acquire),
-      _pumpTasks.load(std::memory_order_acquire));
-}
-
-std::shared_ptr<AsyncDispatcher> AsyncRunner::dispatcher() const {
-  return _dispatcher;
-}
-
-jsi::UUID AsyncRunner::runtimeDataUUID() {
-  static const auto uuid = jsi::UUID();
-  return uuid;
-}
-
-} // namespace rnwgpu::async

package/cpp/rnwgpu/async/AsyncRunner.h

@@ -1,53 +0,0 @@
-#pragma once
-
-#include <atomic>
-#include <cstdint>
-#include <functional>
-#include <memory>
-
-#include <jsi/jsi.h>
-
-#include "AsyncDispatcher.h"
-#include "AsyncTaskHandle.h"
-
-#include "webgpu/webgpu_cpp.h"
-
-namespace jsi = facebook::jsi;
-
-namespace rnwgpu::async {
-
-class AsyncRunner : public std::enable_shared_from_this<AsyncRunner> {
-public:
-  using TaskCallback =
-      std::function<void(const AsyncTaskHandle::ResolveFunction &,
-                         const AsyncTaskHandle::RejectFunction &)>;
-
-  AsyncRunner(wgpu::Instance instance,
-              std::shared_ptr<AsyncDispatcher> dispatcher);
-
-  static std::shared_ptr<AsyncRunner> get(jsi::Runtime &runtime);
-  static std::shared_ptr<AsyncRunner>
-  getOrCreate(jsi::Runtime &runtime, wgpu::Instance instance,
-              std::shared_ptr<AsyncDispatcher> dispatcher);
-
-  AsyncTaskHandle postTask(const TaskCallback &callback,
-                           bool keepPumping = true);
-
-  void requestTick();
-  void tick(jsi::Runtime &runtime);
-  void onTaskSettled(bool keepPumping);
-
-  std::shared_ptr<AsyncDispatcher> dispatcher() const;
-
-private:
-  static jsi::UUID runtimeDataUUID();
-
-  wgpu::Instance _instance;
-  std::shared_ptr<AsyncDispatcher> _dispatcher;
-  std::atomic<size_t> _pendingTasks;
-  std::atomic<size_t> _pumpTasks;
-  std::atomic<bool> _tickScheduled;
-  std::atomic<int64_t> _lastTickTimeNs;
-};
-
-} // namespace rnwgpu::async

package/cpp/rnwgpu/async/JSIMicrotaskDispatcher.cpp

@@ -1,23 +0,0 @@
-#include "JSIMicrotaskDispatcher.h"
-
-#include <utility>
-
-namespace rnwgpu::async {
-
-JSIMicrotaskDispatcher::JSIMicrotaskDispatcher(jsi::Runtime &runtime)
-    : _runtime(runtime) {}
-
-void JSIMicrotaskDispatcher::post(Work work) {
-  auto microtask = jsi::Function::createFromHostFunction(
-      _runtime, jsi::PropNameID::forAscii(_runtime, "AsyncMicrotask"), 0,
-      [work = std::move(work)](
-          jsi::Runtime &runtime, const jsi::Value & /*thisValue*/,
-          const jsi::Value * /*args*/, size_t /*count*/) -> jsi::Value {
-        work(runtime);
-        return jsi::Value::undefined();
-      });
-
-  _runtime.queueMicrotask(std::move(microtask));
-}
-
-} // namespace rnwgpu::async

package/cpp/rnwgpu/async/JSIMicrotaskDispatcher.h

@@ -1,22 +0,0 @@
-#pragma once
-
-#include "AsyncDispatcher.h"
-
-namespace rnwgpu::async {
-
-/**
- * Dispatcher implementation backed by `jsi::Runtime::queueMicrotask`.
- */
-class JSIMicrotaskDispatcher final
-    : public AsyncDispatcher,
-      public std::enable_shared_from_this<JSIMicrotaskDispatcher> {
-public:
-  explicit JSIMicrotaskDispatcher(jsi::Runtime &runtime);
-
-  void post(Work work) override;
-
-private:
-  jsi::Runtime &_runtime;
-};
-
-} // namespace rnwgpu::async