react-native-wgpu 0.1.13 → 0.1.15

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

@@ -67,6 +67,14 @@ static void convertJSUnionToEnum(const std::string &inUnion,
     *outEnum = wgpu::BlendFactor::Constant;
   } else if (inUnion == "one-minus-constant") {
     *outEnum = wgpu::BlendFactor::OneMinusConstant;
+  } else if (inUnion == "src1") {
+    *outEnum = wgpu::BlendFactor::Src1;
+  } else if (inUnion == "one-minus-src1") {
+    *outEnum = wgpu::BlendFactor::OneMinusSrc1;
+  } else if (inUnion == "src1-alpha") {
+    *outEnum = wgpu::BlendFactor::Src1Alpha;
+  } else if (inUnion == "one-minus-src1-alpha") {
+    *outEnum = wgpu::BlendFactor::OneMinusSrc1Alpha;
   } else {
     throw invalidUnion(inUnion);
   }
@@ -114,6 +122,18 @@ static void convertEnumToJSUnion(wgpu::BlendFactor inEnum,
   case wgpu::BlendFactor::OneMinusConstant:
     *outUnion = "one-minus-constant";
     break;
+  case wgpu::BlendFactor::Src1:
+    *outUnion = "src1";
+    break;
+  case wgpu::BlendFactor::OneMinusSrc1:
+    *outUnion = "one-minus-src1";
+    break;
+  case wgpu::BlendFactor::Src1Alpha:
+    *outUnion = "src1-alpha";
+    break;
+  case wgpu::BlendFactor::OneMinusSrc1Alpha:
+    *outUnion = "one-minus-src1-alpha";
+    break;
   default:
     throw invalidEnum(inEnum);
   }
@@ -412,6 +432,10 @@ static void convertJSUnionToEnum(const std::string &inUnion,
     *outEnum = wgpu::FeatureName::BGRA8UnormStorage;
   } else if (inUnion == "float32-filterable") {
     *outEnum = wgpu::FeatureName::Float32Filterable;
+  } else if (inUnion == "clip-distances") {
+    *outEnum = wgpu::FeatureName::ClipDistances;
+  } else if (inUnion == "dual-source-blending") {
+    *outEnum = wgpu::FeatureName::DualSourceBlending;
   } else {
     throw invalidUnion(inUnion);
   }
@@ -453,6 +477,12 @@ static void convertEnumToJSUnion(wgpu::FeatureName inEnum,
   case wgpu::FeatureName::Float32Filterable:
     *outUnion = "float32-filterable";
     break;
+  case wgpu::FeatureName::ClipDistances:
+    *outUnion = "clip-distances";
+    break;
+  case wgpu::FeatureName::DualSourceBlending:
+    *outUnion = "dual-source-blending";
+    break;
   default:
     throw invalidEnum(inEnum);
   }

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

package/cpp/threading/ThreadPool.h

@@ -0,0 +1,53 @@
+//
+//  ThreadPool.hpp
+//  NitroModules
+//
+//  Created by Marc Rousavy on 21.06.24.
+//
+
+#pragma once
+
+#include <atomic>
+#include <condition_variable>
+#include <functional>
+#include <memory>
+#include <mutex>
+#include <queue>
+#include <string>
+#include <thread>
+#include <vector>
+
+namespace margelo {
+
+class ThreadPool final {
+public:
+  /**
+   * Create a new ThreadPool with the given number of fixed workers/threads.
+   */
+  explicit ThreadPool(const char *const name, size_t numThreads);
+  ~ThreadPool();
+
+  /**
+   * Schedules the given task asynchronously on the ThreadPool.
+   * It will run once a worker is available.
+   */
+  void run(std::function<void()> &&task);
+
+public:
+  /**
+   * Get a static singleton instance - a shared ThreadPool.
+   * The shared ThreadPool has 3 threads.
+   */
+  static std::shared_ptr<ThreadPool> getSharedPool();
+
+private:
+  std::vector<std::thread> _workers;
+  std::queue<std::function<void()>> _tasks;
+  std::mutex _queueMutex;
+  std::condition_variable _condition;
+  std::atomic<bool> _isAlive;
+  const char *_name;
+  static constexpr auto TAG = "ThreadPool";
+};
+
+} // namespace margelo