react-native-webgpu 0.19.2 → 0.20.0

package/cpp/rnwgpu/api/RNWebGPU.h

@@ -14,12 +14,12 @@
 #include "GPUCanvasContext.h"
 #include "GPUDevice.h"
 #include "GPUTexture.h"
-#include "rnwgpu/async/RuntimeContext.h"
 #include "ImageBitmap.h"
 #include "PlatformContext.h"
 #include "VideoFrame.h"
 #include "VideoPlayer.h"
 #include "WebGPURuntime.h"
+#include "rnwgpu/async/RuntimeContext.h"
 
 #include <ReactCommon/CallInvoker.h>
 
@@ -132,8 +132,8 @@ public:
   // Skia's Graphite device from Skia.getNativeDevice()) in a GPUDevice.
   // AddRefs the handle, so the original owner keeps its reference. Only sound
   // because the process links a single Dawn copy. The device's async
-  // callbacks are pumped on the instance that owns it (RuntimeContext is per
-  // runtime and per instance), which is not necessarily the shared one:
+  // callbacks are waited for on the instance that owns it (RuntimeContext is
+  // per runtime and per instance), which is not necessarily the shared one:
   // WebGPURuntime adopts Skia's instance only when Skia's getter is reachable
   // as the instance is first used (on Android, only once librnskia.so is
   // loaded), and other exporters have their own.
@@ -240,14 +240,14 @@ public:
         std::vector<uint8_t> dataCopy(data.begin(), data.end());
 
         return Promise::createPromise(
-            runtime,
-            [platformContext, callInvoker, toRequestedAlpha,
-             dataCopy = std::move(dataCopy)](
-                jsi::Runtime & /*runtime*/,
-                std::shared_ptr<Promise> promise) mutable {
+            runtime, [platformContext, callInvoker, toRequestedAlpha,
+                      dataCopy = std::move(dataCopy)](
+                         jsi::Runtime & /*runtime*/,
+                         std::shared_ptr<Promise> promise) mutable {
               platformContext->createImageBitmapFromDataAsync(
                   dataCopy,
-                  [callInvoker, promise, toRequestedAlpha](ImageData imageData) {
+                  [callInvoker, promise,
+                   toRequestedAlpha](ImageData imageData) {
                     toRequestedAlpha(imageData);
                     auto imageBitmap = std::make_shared<ImageBitmap>(imageData);
                     callInvoker->invokeAsync([promise, imageBitmap]() {

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

@@ -22,6 +22,7 @@ struct GPUCanvasConfiguration {
       viewFormats; // Iterable<GPUTextureFormat>
   wgpu::CompositeAlphaMode alphaMode = wgpu::CompositeAlphaMode::Opaque;
   CanvasColorSpace colorSpace = CanvasColorSpace::SRGB;
+  CanvasToneMappingMode toneMappingMode = CanvasToneMappingMode::Standard;
 };
 
 } // namespace rnwgpu
@@ -81,6 +82,29 @@ struct JSIConverter<std::shared_ptr<rnwgpu::GPUCanvasConfiguration>> {
           }
         }
       }
+      if (value.hasProperty(runtime, "toneMapping")) {
+        auto prop = value.getProperty(runtime, "toneMapping");
+        if (prop.isObject()) {
+          auto toneMapping = prop.getObject(runtime);
+          if (toneMapping.hasProperty(runtime, "mode")) {
+            auto mode = toneMapping.getProperty(runtime, "mode");
+            if (!mode.isUndefined()) {
+              auto name = mode.asString(runtime).utf8(runtime);
+              if (name == "extended") {
+                result->toneMappingMode = CanvasToneMappingMode::Extended;
+              } else if (name != "standard") {
+                throw jsi::JSError(
+                    runtime,
+                    "Failed to execute 'configure' on 'GPUCanvasContext': "
+                    "The provided value '" +
+                        name +
+                        "' is not a valid enum value of type "
+                        "GPUCanvasToneMappingMode.");
+              }
+            }
+          }
+        }
+      }
     }
 
     return result;

package/cpp/rnwgpu/async/AsyncTaskHandle.cpp

@@ -15,8 +15,8 @@ using Action = std::function<void(jsi::Runtime &, rnwgpu::Promise &)>;
 
 struct AsyncTaskHandle::State
     : public std::enable_shared_from_this<AsyncTaskHandle::State> {
-  State(std::shared_ptr<RuntimeContext> context, bool keepPumping)
-      : context(std::move(context)), keepPumping(keepPumping) {}
+  explicit State(std::shared_ptr<RuntimeContext> context)
+      : context(std::move(context)) {}
 
   void settle(Action action);
   void attachPromise(const std::shared_ptr<rnwgpu::Promise> &promise);
@@ -29,7 +29,6 @@ struct AsyncTaskHandle::State
 
   std::mutex mutex;
   std::shared_ptr<RuntimeContext> context;
-  bool keepPumping;
   std::shared_ptr<rnwgpu::Promise> promise;
   std::optional<Action> pendingAction;
   bool settled = false;
@@ -92,47 +91,37 @@ void AsyncTaskHandle::State::schedule(Action action) {
     return;
   }
 
+  // Any thread here: the settle (the only JSI-touching work) runs on the
+  // owning runtime's thread, however the context reaches it. A settle that
+  // throws (a value factory that cannot make its value, say) rejects the
+  // promise rather than leaving it pending, and ends the operation all the
+  // same, so that a runtime polling its mailbox stops.
   auto self = shared_from_this();
-
-  if (!keepPumping) {
-    // Spontaneous task (e.g. device.lost): not driven by the ProcessEvents pump.
-    // Settle on the owning runtime's JS thread via its CallInvoker, which is
-    // wired only for the main JS runtime. A device created on a worklet runtime
-    // has no invoker, so its device.lost is dropped (best-effort; see the README
-    // "Threading model"). invokeAsync runs the closure on the main JS thread,
-    // where promiseRef->runtime lives for a main-runtime device.
-    auto invoker = context->callInvoker();
-    if (invoker) {
-      invoker->invokeAsync(
-          [self, action = std::move(action), promiseRef]() mutable {
-            action(promiseRef->runtime, *promiseRef);
-            std::lock_guard<std::mutex> lock(self->mutex);
-            self->keepAlive.reset();
-          });
-    } else {
-      std::lock_guard<std::mutex> lock(mutex);
-      keepAlive.reset();
+  context->post([self, action = std::move(action),
+                 promiseRef](jsi::Runtime &runtime) mutable {
+    try {
+      action(runtime, *promiseRef);
+    } catch (const jsi::JSError &error) {
+      try {
+        // The JS error itself (a RangeError for a typed array too large,
+        // say), name and stack kept.
+        promiseRef->reject(error);
+      } catch (...) {
+        // Rejected already, or the runtime refused: nothing more to do.
+      }
+    } catch (const std::exception &error) {
+      try {
+        promiseRef->reject(error.what());
+      } catch (...) {
+        // Rejected already, or the runtime refused: nothing more to do.
+      }
     }
-    return;
-  }
-
-  // Pumping task (request/response op). The resolve/reject callback may fire on
-  // a thread that is NOT the owning runtime's thread: with a shared
-  // wgpu::Instance, another runtime's ProcessEvents() pump can consume this Dawn
-  // event. Touching the Promise's runtime off-thread would corrupt Hermes. So we
-  // deposit the actual settle (the only JSI-touching work) into the owning
-  // context's mailbox; the context drains it on its own thread during its next
-  // tick. The deposited closure captures only C++ state and runs no JSI until
-  // drained, so depositing from any thread is safe.
-  context->postSettle(
-      [self, action = std::move(action), promiseRef]() mutable {
-        action(promiseRef->runtime, *promiseRef);
-        if (self->context) {
-          self->context->onTaskSettled(/*keepPumping=*/true);
-        }
-        std::lock_guard<std::mutex> lock(self->mutex);
-        self->keepAlive.reset();
-      });
+    if (self->context) {
+      self->context->onTaskSettled();
+    }
+    std::lock_guard<std::mutex> lock(self->mutex);
+    self->keepAlive.reset();
+  });
 }
 
 AsyncTaskHandle::ResolveFunction
@@ -181,9 +170,8 @@ AsyncTaskHandle::AsyncTaskHandle(std::shared_ptr<State> state)
 bool AsyncTaskHandle::valid() const { return _state != nullptr; }
 
 AsyncTaskHandle
-AsyncTaskHandle::create(const std::shared_ptr<RuntimeContext> &context,
-                        bool keepPumping) {
-  auto state = std::make_shared<State>(context, keepPumping);
+AsyncTaskHandle::create(const std::shared_ptr<RuntimeContext> &context) {
+  auto state = std::make_shared<State>(context);
   state->keepAlive = state;
   return AsyncTaskHandle(std::move(state));
 }

package/cpp/rnwgpu/async/AsyncTaskHandle.h

@@ -20,10 +20,10 @@ class RuntimeContext;
  * Represents a pending asynchronous WebGPU operation that can be converted into
  * a JavaScript Promise.
  *
- * In the ProcessEvents model the resolve/reject callbacks are invoked on the
- * owning runtime's own thread (synchronously from instance.ProcessEvents()
- * during the RuntimeContext tick, or synchronously from postTask), so the
- * Promise is settled directly without any thread marshalling.
+ * The resolve and reject functions run on any thread (the instance's waiter
+ * thread, usually) and never touch JSI: they hand the settling to the owning
+ * RuntimeContext, which runs it on its runtime's own thread (see
+ * RuntimeContext::post).
  */
 class AsyncTaskHandle {
 public:
@@ -48,8 +48,7 @@ public:
 
   void attachPromise(const std::shared_ptr<rnwgpu::Promise> &promise) const;
 
-  static AsyncTaskHandle create(const std::shared_ptr<RuntimeContext> &context,
-                                bool keepPumping);
+  static AsyncTaskHandle create(const std::shared_ptr<RuntimeContext> &context);
 
 private:
   std::shared_ptr<State> _state;