react-native-wgpu 0.1.12 → 0.1.14

package/cpp/platform/ThreadUtils.h

@@ -0,0 +1,30 @@
+//
+//  ThreadUtils.hpp
+//  react-native-nitro
+//
+//  Created by Marc Rousavy on 14.07.24.
+//
+#pragma once
+
+#include <string>
+
+namespace margelo {
+
+class ThreadUtils final {
+public:
+  ThreadUtils() = delete;
+
+  /**
+   * Get the current Thread's name.
+   * This is implemented differently on iOS and Android.
+   */
+  static std::string getThreadName();
+
+  /**
+   * Set the current Thread's name.
+   * This is implemented differently on iOS and Android.
+   */
+  static void setThreadName(const std::string &name);
+};
+
+} // namespace margelo

package/cpp/rnwgpu/RNWebGPUManager.cpp

@@ -1,5 +1,7 @@
 #include "RNWebGPUManager.h"
 
+#include "CallInvokerDispatcher.h"
+#include "Dispatcher.h"
 #include "GPU.h"
 #include "RNWebGPU.h"
 
@@ -22,6 +24,12 @@ RNWebGPUManager::RNWebGPUManager(
     : _jsRuntime(jsRuntime), _jsCallInvoker(jsCallInvoker),
       _platformContext(platformContext) {
 
+  // Installs the global Dispatcher mechanism into this Runtime.
+  // This allows creating Promises and calling back to JS.
+  auto dispatcher =
+      std::make_shared<margelo::CallInvokerDispatcher>(_jsCallInvoker);
+  margelo::Dispatcher::installRuntimeGlobalDispatcher(*_jsRuntime, dispatcher);
+
   auto gpu = std::make_shared<GPU>();
   auto rnWebGPU = std::make_shared<RNWebGPU>(gpu, _platformContext);
   _gpu = gpu->get();

package/cpp/rnwgpu/api/Convertors.h

@@ -175,6 +175,17 @@ public:
     return true;
   }
 
+  [[nodiscard]] bool Convert(wgpu::OptionalBool &out,
+                             const std::optional<bool> &in) {
+    out = in;
+    return true;
+  }
+
+  [[nodiscard]] bool Convert(wgpu::StringView &out, const std::string &in) {
+    out = {in.data(), in.size()};
+    return true;
+  }
+
   [[nodiscard]] bool Convert(const char *&out, const std::string &in) {
     out = in.c_str();
     return true;
@@ -280,15 +291,6 @@ public:
            Convert(out.label, in.label);
   }
 
-  // [[nodiscard]] bool Convert(wgpu::CanvasConfiguration &out,
-  //                            const GPUCanvasConfiguration &in) {
-  //   return Convert(out.device, in.device) && Convert(out.format, in.format)
-  //   &&
-  //          Convert(out.usage, in.usage) && Convert(out.viewFormats,
-  //          in.viewFormats) && Convert(out.colorSpace, in.colorSpace) &&
-  //          Convert(out.alphaMode, in.alphaMode);
-  // }
-
   [[nodiscard]] bool Convert(wgpu::Color &out, const GPUColor &in) {
     return Convert(out.r, in.r) && Convert(out.g, in.g) &&
            Convert(out.b, in.b) && Convert(out.a, in.a);
@@ -490,11 +492,8 @@ public:
                              const GPUPrimitiveState &in) {
     out = {};
 
-    if (in.unclippedDepth) {
-      wgpu::PrimitiveDepthClipControl *depthClip =
-          Allocate<wgpu::PrimitiveDepthClipControl>();
-      depthClip->unclippedDepth = true;
-      out.nextInChain = depthClip;
+    if (in.unclippedDepth.has_value()) {
+      out.unclippedDepth = in.unclippedDepth.value();
     }
 
     return Convert(out.topology, in.topology) &&

package/cpp/rnwgpu/api/GPU.cpp

@@ -28,10 +28,10 @@ GPU::requestAdapter(
   wgpu::Adapter adapter = nullptr;
   _instance.RequestAdapter(
       &aOptions,
-      [](WGPURequestAdapterStatus, WGPUAdapter cAdapter, const char *message,
-         void *userdata) {
-        if (message != nullptr) {
-          fprintf(stderr, "%s", message);
+      [](WGPURequestAdapterStatus, WGPUAdapter cAdapter,
+         const WGPUStringView message, void *userdata) {
+        if (message.length) {
+          fprintf(stderr, "%s", message.data);
           return;
         }
         *static_cast<wgpu::Adapter *>(userdata) =

package/cpp/rnwgpu/api/GPUAdapter.cpp

@@ -23,7 +23,7 @@ std::future<std::shared_ptr<GPUDevice>> GPUAdapter::requestDevice(
   }
   wgpu::DeviceLostCallbackInfo info = {
       .callback = [](WGPUDevice const *device, WGPUDeviceLostReason reason,
-                     char const *message, void *userdata) {
+                     const WGPUStringView message, void *userdata) {
         const char *lostReason = "";
         switch (reason) {
         case WGPUDeviceLostReason_Destroyed:
@@ -35,12 +35,13 @@ std::future<std::shared_ptr<GPUDevice>> GPUAdapter::requestDevice(
         default:
           lostReason = "Unknown";
         }
-        Logger::logToConsole("GPU Device Lost (%s): %s", lostReason, message);
+        Logger::logToConsole("GPU Device Lost (%s): %s", lostReason,
+                             message.data);
       }};
   aDescriptor.deviceLostCallbackInfo = info;
   wgpu::UncapturedErrorCallbackInfo errorInfo;
   errorInfo.userdata = static_cast<void *>(_creationRuntime);
-  errorInfo.callback = [](WGPUErrorType type, const char *message,
+  errorInfo.callback = [](WGPUErrorType type, const WGPUStringView message,
                           void *userdata) {
     auto creationRuntime = static_cast<jsi::Runtime *>(userdata);
     const char *errorType = "";
@@ -60,16 +61,16 @@ std::future<std::shared_ptr<GPUDevice>> GPUAdapter::requestDevice(
     default:
       errorType = "Unknown";
     }
-    std::string fullMessage = std::string(errorType) + ": " + message;
-    Logger::errorToJavascriptConsole(*creationRuntime, fullMessage.c_str());
+    std::string fullMessage = std::string(errorType) + ": " + message.data;
+    Logger::errorToJavascriptConsole(*creationRuntime, fullMessage);
   };
   aDescriptor.uncapturedErrorCallbackInfo = errorInfo;
   _instance.RequestDevice(
       &aDescriptor,
       [](WGPURequestDeviceStatus status, WGPUDevice cDevice,
-         const char *message, void *userdata) {
-        if (message != nullptr) {
-          fprintf(stderr, "%s", message);
+         const WGPUStringView message, void *userdata) {
+        if (message.length) {
+          fprintf(stderr, "%s", message.data);
           return;
         }
         *static_cast<wgpu::Device *>(userdata) = wgpu::Device::Acquire(cDevice);
@@ -80,17 +81,17 @@ std::future<std::shared_ptr<GPUDevice>> GPUAdapter::requestDevice(
     throw std::runtime_error("Failed to request device");
   }
   device.SetLoggingCallback(
-      [](WGPULoggingType type, const char *message, void *userdata) {
+      [](WGPULoggingType type, const WGPUStringView message, void *userdata) {
         auto creationRuntime = static_cast<jsi::Runtime *>(userdata);
         const char *logLevel = "";
         switch (type) {
         case WGPULoggingType_Warning:
           logLevel = "Warning";
-          Logger::warnToJavascriptConsole(*creationRuntime, message);
+          Logger::warnToJavascriptConsole(*creationRuntime, message.data);
           break;
         case WGPULoggingType_Error:
           logLevel = "Error";
-          Logger::errorToJavascriptConsole(*creationRuntime, message);
+          Logger::errorToJavascriptConsole(*creationRuntime, message.data);
           break;
         case WGPULoggingType_Verbose:
           logLevel = "Verbose";
@@ -139,9 +140,9 @@ std::shared_ptr<GPUAdapterInfo> GPUAdapter::getInfo() {
 }
 
 bool GPUAdapter::getIsFallbackAdapter() {
-  wgpu::AdapterProperties adapterProperties = {};
-  _instance.GetProperties(&adapterProperties);
-  return adapterProperties.adapterType == wgpu::AdapterType::DiscreteGPU;
+  wgpu::AdapterInfo adapterInfo = {};
+  _instance.GetInfo(&adapterInfo);
+  return adapterInfo.adapterType == wgpu::AdapterType::CPU;
 }
 
 } // namespace rnwgpu

package/cpp/rnwgpu/api/GPUAdapterInfo.h

@@ -8,6 +8,7 @@
 #include "RNFHybridObject.h"
 
 #include "AsyncRunner.h"
+#include "Convertors.h"
 
 #include "webgpu/webgpu_cpp.h"
 
@@ -23,10 +24,30 @@ public:
 public:
   std::string getBrand() { return _name; }
 
-  std::string getVendor() { return _instance.vendor; }
-  std::string getArchitecture() { return _instance.architecture; }
-  std::string getDevice() { return _instance.device; }
-  std::string getDescription() { return _instance.description; }
+  std::string getVendor() {
+    if (_instance.vendor.length) {
+      return _instance.vendor.data;
+    }
+    return "";
+  }
+  std::string getArchitecture() {
+    if (_instance.architecture.length) {
+      return _instance.architecture.data;
+    }
+    return "";
+  }
+  std::string getDevice() {
+    if (_instance.device.length) {
+      return _instance.device.data;
+    }
+    return "";
+  }
+  std::string getDescription() {
+    if (_instance.device.length) {
+      return _instance.device.data;
+    }
+    return "";
+  }
 
   void loadHybridMethods() override {
     registerHybridGetter("__brand", &GPUAdapterInfo::getBrand, this);

package/cpp/rnwgpu/api/GPUCanvasContext.cpp

@@ -16,12 +16,14 @@ void GPUCanvasContext::configure(
       throw std::runtime_error("Error with SurfaceConfiguration");
     }
   }
-  if (!conv(surfaceConfiguration.format, configuration->format)) {
-    throw std::runtime_error("Error with SurfaceConfiguration");
-  }
-  if (!conv(surfaceConfiguration.usage, configuration->usage)) {
+  if (!conv(surfaceConfiguration.usage, configuration->usage) ||
+      !conv(surfaceConfiguration.format, configuration->format)) {
     throw std::runtime_error("Error with SurfaceConfiguration");
   }
+
+#ifdef __APPLE__
+  surfaceConfiguration.alphaMode = configuration->alphaMode;
+#endif
   _surfaceInfo->configure(surfaceConfiguration);
 }
 

package/cpp/rnwgpu/api/GPUDevice.cpp

@@ -76,10 +76,9 @@ std::shared_ptr<GPUShaderModule> GPUDevice::createShaderModule(
   }
   sm_desc.nextInChain = &wgsl_desc;
   if (descriptor->code.find('\0') != std::string::npos) {
-    return std::make_shared<GPUShaderModule>(
-        _instance.CreateErrorShaderModule(
-            &sm_desc, "The WGSL shader contains an illegal character '\\0'"),
-        _async, sm_desc.label);
+    auto mod = _instance.CreateErrorShaderModule(
+        &sm_desc, "The WGSL shader contains an illegal character '\\0'");
+    return std::make_shared<GPUShaderModule>(mod, _async, sm_desc.label.data);
   }
   auto module = _instance.CreateShaderModule(&sm_desc);
   return std::make_shared<GPUShaderModule>(module, _async,
@@ -337,6 +336,7 @@ std::unordered_set<std::string> GPUDevice::getFeatures() {
 }
 
 std::future<std::shared_ptr<GPUDeviceLostInfo>> GPUDevice::getLost() {
-  return m_lostPromise->get_future();
+  return std::async(std::launch::async,
+                    [=]() { return m_lostSharedFuture->get(); });
 }
 } // namespace rnwgpu

package/cpp/rnwgpu/api/GPUDevice.h

@@ -57,6 +57,10 @@ public:
         _label(label) {
     m_lostPromise =
         std::make_shared<std::promise<std::shared_ptr<GPUDeviceLostInfo>>>();
+
+    auto sharedFuture = m_lostPromise->get_future().share();
+    m_lostSharedFuture = std::make_shared<
+        std::shared_future<std::shared_ptr<GPUDeviceLostInfo>>>(sharedFuture);
   }
 
 public:
@@ -154,6 +158,8 @@ private:
   std::string _label;
   std::shared_ptr<std::promise<std::shared_ptr<GPUDeviceLostInfo>>>
       m_lostPromise;
+  std::shared_ptr<std::shared_future<std::shared_ptr<GPUDeviceLostInfo>>>
+      m_lostSharedFuture;
 };
 
-} // namespace rnwgpu
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUFeatures.h

@@ -65,9 +65,9 @@ static void convertEnumToJSUnion(wgpu::FeatureName inEnum,
   case wgpu::FeatureName::ImplicitDeviceSynchronization:
     *outUnion = "implicit-device-synchronization";
     break;
-  case wgpu::FeatureName::SurfaceCapabilities:
-    *outUnion = "surface-capabilities";
-    break;
+    //  case wgpu::FeatureName::SurfaceCapabilities:
+    //    *outUnion = "surface-capabilities";
+    //    break;
   case wgpu::FeatureName::TransientAttachments:
     *outUnion = "transient-attachments";
     break;
@@ -218,4 +218,4 @@ static void convertEnumToJSUnion(wgpu::FeatureName inEnum,
   }
 }
 
-} // namespace rnwgpu
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUShaderModule.cpp

@@ -18,7 +18,8 @@ GPUShaderModule::getCompilationInfo() {
             for (size_t i = 0; i < compilationInfo->messageCount; ++i) {
               const auto &wgpuMessage = compilationInfo->messages[i];
               GPUCompilationMessage message;
-              message.message = wgpuMessage.message ? wgpuMessage.message : "";
+              message.message =
+                  wgpuMessage.message.length ? wgpuMessage.message.data : "";
               message.type = wgpuMessage.type;
               message.lineNum = wgpuMessage.lineNum;
               message.linePos = wgpuMessage.linePos;

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

@@ -21,6 +21,7 @@ struct GPUCanvasConfiguration {
   std::optional<double> usage;       // GPUTextureUsageFlags
   std::optional<std::vector<wgpu::TextureFormat>>
       viewFormats; // Iterable<GPUTextureFormat>
+  wgpu::CompositeAlphaMode alphaMode = wgpu::CompositeAlphaMode::Opaque;
 };
 
 } // namespace rnwgpu
@@ -58,6 +59,14 @@ struct JSIConverter<std::shared_ptr<rnwgpu::GPUCanvasConfiguration>> {
                                                                       prop,
                                                                       false);
       }
+      if (value.hasProperty(runtime, "alphaMode")) {
+        auto prop = value.getProperty(runtime, "alphaMode")
+                        .asString(runtime)
+                        .utf8(runtime);
+        if (prop == "premultiplied") {
+          result->alphaMode = wgpu::CompositeAlphaMode::Premultiplied;
+        }
+      }
     }
 
     return result;

package/cpp/threading/CallInvokerDispatcher.h

@@ -0,0 +1,37 @@
+
+//
+// Created by Marc Rousavy on 27.03.24.
+//
+
+#pragma once
+
+#include "Dispatcher.h"
+
+#include <utility>
+#include <memory>
+#include <ReactCommon/CallInvoker.h>
+
+namespace margelo {
+
+/**
+ * A Dispatcher that uses react::CallInvoker for it's implementation
+ */
+class CallInvokerDispatcher final : public Dispatcher {
+public:
+  explicit CallInvokerDispatcher(
+      std::shared_ptr<react::CallInvoker> callInvoker)
+      : _callInvoker(callInvoker) {}
+
+  void runAsync(std::function<void()> &&function) override {
+    _callInvoker->invokeAsync(std::move(function));
+  }
+
+  void runSync(std::function<void()> &&function) override {
+    _callInvoker->invokeSync(std::move(function));
+  }
+
+private:
+  std::shared_ptr<react::CallInvoker> _callInvoker;
+};
+
+} // namespace margelo

package/cpp/threading/Dispatcher.cpp

@@ -0,0 +1,54 @@
+//
+// Created by Marc Rousavy on 12.03.24.
+//
+
+#include "Dispatcher.h"
+
+#include <memory>
+#include "RNFJSIHelper.h"
+
+namespace margelo {
+
+namespace jsi = facebook::jsi;
+
+static constexpr auto GLOBAL_DISPATCHER_HOLDER_NAME = "__nitroDispatcher";
+
+std::unordered_map<jsi::Runtime *, std::weak_ptr<Dispatcher>>
+    Dispatcher::_globalCache;
+
+void Dispatcher::installRuntimeGlobalDispatcher(
+    jsi::Runtime &runtime, std::shared_ptr<Dispatcher> dispatcher) {
+
+  // Store a weak reference in global cache
+  _globalCache[&runtime] = std::weak_ptr<Dispatcher>(dispatcher);
+
+  // Inject the dispatcher into Runtime global (runtime will hold a strong
+  // reference)
+  jsi::Object dispatcherHolder(runtime);
+  dispatcherHolder.setNativeState(runtime, dispatcher);
+  runtime.global().setProperty(runtime, GLOBAL_DISPATCHER_HOLDER_NAME,
+                               dispatcherHolder);
+}
+
+std::shared_ptr<Dispatcher>
+Dispatcher::getRuntimeGlobalDispatcher(jsi::Runtime &runtime) {
+  if (auto search = _globalCache.find(&runtime); search != _globalCache.end()) {
+    // the runtime is known - we have something in cache
+    std::weak_ptr<Dispatcher> weakDispatcher = _globalCache[&runtime];
+    std::shared_ptr<Dispatcher> strongDispatcher = weakDispatcher.lock();
+    if (strongDispatcher) {
+      // the weak reference we cached is still valid - return it!
+      return strongDispatcher;
+    }
+  }
+
+  jsi::Value dispatcherHolderValue = getRuntimeGlobalDispatcherHolder(runtime);
+  jsi::Object dispatcherHolder = dispatcherHolderValue.getObject(runtime);
+  return dispatcherHolder.getNativeState<Dispatcher>(runtime);
+}
+
+jsi::Value Dispatcher::getRuntimeGlobalDispatcherHolder(jsi::Runtime &runtime) {
+  return runtime.global().getProperty(runtime, GLOBAL_DISPATCHER_HOLDER_NAME);
+}
+
+} // namespace margelo

package/cpp/threading/Dispatcher.h

@@ -0,0 +1,93 @@
+//
+// Created by Marc Rousavy on 12.03.24.
+//
+
+#pragma once
+
+#include <functional>
+#include <future>
+#include <jsi/jsi.h>
+#include <queue>
+#include <unordered_map>
+#include <utility>
+#include <memory>
+
+namespace margelo {
+
+namespace jsi = facebook::jsi;
+
+class Dispatcher : public jsi::NativeState {
+public:
+  /**
+   Installs the Dispatcher into the given Runtime.
+   It can be accessed using `getRuntimeGlobalDispatcher` later.
+   */
+  static void
+  installRuntimeGlobalDispatcher(jsi::Runtime &runtime,
+                                 std::shared_ptr<Dispatcher> dispatcher);
+  /**
+   Gets the global Dispatcher in the given Runtime, or throws an error if not
+   found.
+  */
+  static std::shared_ptr<Dispatcher>
+  getRuntimeGlobalDispatcher(jsi::Runtime &runtime);
+
+private:
+  static jsi::Value getRuntimeGlobalDispatcherHolder(jsi::Runtime &runtime);
+
+public:
+  /**
+   * Run the given void function synchronously on the Thread this Dispatcher is
+   * managing.
+   */
+  virtual void runSync(std::function<void()> &&function) = 0;
+
+  /**
+   * Run the given void function asynchronously on the Thread this Dispatcher is
+   * managing.
+   */
+  virtual void runAsync(std::function<void()> &&function) = 0;
+
+  /**
+   * Run the given function asynchronously on the Thread this Dispatcher is
+   * managing, and return a future that will hold the result of the function.
+   */
+  template <typename T>
+  std::future<T> runAsyncAwaitable(std::function<T()> &&function) {
+    // 1. Create Promise that can be shared between this and dispatcher thread
+    auto promise = std::make_shared<std::promise<T>>();
+    std::future<T> future = promise->get_future();
+
+    runAsync([function = std::move(function), promise]() {
+      try {
+        if constexpr (std::is_void_v<T>) {
+          // 4. Call the actual function on the new Thread
+          function();
+          // 5.a. Resolve the Promise if we succeeded
+          promise->set_value();
+        } else {
+          // 4. Call the actual function on the new Thread
+          T result = function();
+          // 5.a. Resolve the Promise if we succeeded
+          promise->set_value(std::move(result));
+        }
+      } catch (...) {
+        // 5.b. Reject the Promise if the call failed
+        promise->set_exception(std::current_exception());
+      }
+    });
+
+    // 3. Return an open future that gets resolved later by the dispatcher
+    // Thread
+    return future;
+  }
+
+private:
+  static std::unordered_map<jsi::Runtime *, std::weak_ptr<Dispatcher>>
+      _globalCache;
+
+private:
+  static constexpr auto TAG = "Dispatcher";
+};
+
+} // namespace margelo

package/cpp/threading/ThreadPool.cpp

@@ -0,0 +1,86 @@
+//
+//  ThreadPool.cpp
+//  NitroModules
+//
+//  Created by Marc Rousavy on 21.06.24.
+//
+
+#include "ThreadPool.h"
+#include "ThreadUtils.h"
+
+#include <utility>
+#include <algorithm>
+
+namespace margelo {
+
+ThreadPool::ThreadPool(const char *name, size_t numThreads)
+    : _isAlive(true), _name(name) {
+  for (size_t i = 0; i < numThreads; ++i) {
+    std::string threadName = std::string(name) + "-" + std::to_string(i + 1);
+    _workers.emplace_back([this, threadName] {
+      // Set the Thread's name
+      ThreadUtils::setThreadName(threadName);
+
+      // Start the run-loop
+      while (true) {
+        std::function<void()> task;
+        {
+          // Lock on the mutex so only one Worker receives the condition signal
+          // at a time
+          std::unique_lock<std::mutex> lock(_queueMutex);
+          this->_condition.wait(
+              lock, [this] { return !_isAlive || !_tasks.empty(); });
+          if (!_isAlive && _tasks.empty()) {
+            // ThreadPool is dead - stop run-loop.
+            return;
+          }
+          // Schedule the oldest task
+          task = std::move(_tasks.front());
+          _tasks.pop();
+        }
+        // Run it (outside of the mutex so others can run in parallel)
+        task();
+      }
+    });
+  }
+}
+
+void ThreadPool::run(std::function<void()> &&task) {
+  {
+    // lock on the mutex - we want to emplace the task back in the queue
+    std::unique_lock<std::mutex> lock(_queueMutex);
+    if (!_isAlive) {
+      throw std::runtime_error("Cannot queue the given task - the ThreadPool "
+                               "has already been stopped!");
+    }
+    _tasks.emplace(std::move(task));
+  }
+  // Notify about a new task - one of the workers will pick it up
+  _condition.notify_one();
+}
+
+ThreadPool::~ThreadPool() {
+  {
+    // Lock and set `_isAlive` to false.
+    std::unique_lock<std::mutex> lock(_queueMutex);
+    _isAlive = false;
+  }
+  // Notify all workers - they will stop the work since `_isAlive` is false.
+  _condition.notify_all();
+  for (std::thread &worker : _workers) {
+    // Wait for each worker to exit.
+    worker.join();
+  }
+}
+
+std::shared_ptr<ThreadPool> ThreadPool::getSharedPool() {
+  static std::shared_ptr<ThreadPool> shared;
+  if (shared == nullptr) {
+    int availableThreads = std::thread::hardware_concurrency();
+    auto numThreads = std::min(availableThreads, 3);
+    shared = std::make_shared<ThreadPool>("nitro-thread", numThreads);
+  }
+  return shared;
+}
+
+} // namespace margelo