react-native-wgpu 0.1.0

package/cpp/jsi/RNFEnumMapper.h

@@ -0,0 +1,49 @@
+//
+// Created by Marc Rousavy on 22.02.24.
+//
+
+#pragma once
+
+#include <stdexcept>
+#include <string>
+
+namespace margelo {
+
+namespace EnumMapper {
+  // Add these two methods in namespace "EnumMapper" to allow parsing a custom enum:
+  // 1. `static void convertJSUnionToEnum(const std::string& inUnion, Enum* outEnum)`
+  // 2. `static void convertEnumToJSUnion(Enum inEnum, std::string* outUnion)`
+
+  static std::runtime_error invalidUnion(const std::string& passedUnion) {
+    return std::runtime_error("Cannot convert JS Value to Enum: Invalid Union value passed! (\"" + std::string(passedUnion) + "\")");
+  }
+
+  template <typename T> static std::runtime_error invalidEnum(T passedEnum) {
+    return std::runtime_error("Cannot convert Enum to JS Value: Invalid Enum passed! (Value #" +
+                              std::to_string(static_cast<int>(passedEnum)) + ")");
+  }
+
+  // Trait to check if a convertJSUnionToEnum function for enum type T exists
+  template <typename T, typename = void> struct has_js_union_to_enum : std::false_type {};
+  template <typename T>
+  struct has_js_union_to_enum<T, std::void_t<decltype(convertJSUnionToEnum(std::declval<std::string>(), std::declval<T*>()))>>
+      : std::true_type {};
+
+  // Trait to check if a convertEnumToJSUnion function for enum type T exists
+  template <typename T, typename = void> struct has_enum_to_js_union : std::false_type {};
+  template <typename T>
+  struct has_enum_to_js_union<T, std::void_t<decltype(convertEnumToJSUnion(std::declval<T>(), std::declval<std::string*>()))>>
+      : std::true_type {};
+
+  template <typename TEnum> static void convertJSUnionToEnum(const std::string&, TEnum*) {
+    static_assert(has_js_union_to_enum<TEnum>::value,
+                  "Cannot convert a JS union to this enum type. Did you implement EnumMapper::convertJSUnionToEnum(...)?");
+  }
+
+  template <typename TEnum> static void convertEnumToJSUnion(TEnum, std::string*) {
+    static_assert(has_enum_to_js_union<TEnum>::value,
+                  "Cannot convert this enum type to a JS union. Did you implement EnumMapper::convertEnumToJSUnion(...)?");
+  }
+} // namespace EnumMapper
+
+} // namespace margelo

package/cpp/jsi/RNFHybridObject.cpp

@@ -0,0 +1,145 @@
+//
+// Created by Marc Rousavy on 21.02.24.
+//
+#include "RNFHybridObject.h"
+#include "RNFJSIConverter.h"
+#include "Logger.h"
+
+#include <vector>
+#include <utility>
+#include <string>
+
+namespace margelo {
+
+#if DEBUG && RNF_ENABLE_LOGS
+static std::unordered_map<const char*, int> _instanceIds;
+static std::mutex _mutex;
+
+static int getId(const char* name) {
+  std::unique_lock lock(_mutex);
+  if (_instanceIds.find(name) == _instanceIds.end()) {
+    _instanceIds.insert({name, 1});
+  }
+  auto iterator = _instanceIds.find(name);
+  return iterator->second++;
+}
+#endif
+
+HybridObject::HybridObject(const char* name) : _name(name) {
+#if DEBUG && RNF_ENABLE_LOGS
+  _instanceId = getId(name);
+  Logger::logToConsole(TAG, "(MEMORY) Creating %s (#%i)... ✅", _name, _instanceId);
+#endif
+}
+
+HybridObject::~HybridObject() {
+#if DEBUG && RNF_ENABLE_LOGS
+  Logger::log(TAG, "(MEMORY) Deleting %s (#%i)... ❌", _name, _instanceId);
+#endif
+  _functionCache.clear();
+}
+
+std::string HybridObject::toString(jsi::Runtime& runtime) {
+  std::string result = std::string(_name) + " { ";
+  std::vector<jsi::PropNameID> props = getPropertyNames(runtime);
+  for (size_t i = 0; i < props.size(); i++) {
+    auto suffix = i < props.size() - 1 ? ", " : " ";
+    result += "\"" + props[i].utf8(runtime) + "\"" + suffix;
+  }
+  return result + "}";
+}
+
+std::vector<jsi::PropNameID> HybridObject::getPropertyNames(facebook::jsi::Runtime& runtime) {
+  std::unique_lock lock(_mutex);
+  ensureInitialized(runtime);
+
+  std::vector<jsi::PropNameID> result;
+  size_t totalSize = _methods.size() + _getters.size() + _setters.size();
+  result.reserve(totalSize);
+
+  for (const auto& item : _methods) {
+    result.push_back(jsi::PropNameID::forUtf8(runtime, item.first));
+  }
+  for (const auto& item : _getters) {
+    result.push_back(jsi::PropNameID::forUtf8(runtime, item.first));
+  }
+  for (const auto& item : _setters) {
+    result.push_back(jsi::PropNameID::forUtf8(runtime, item.first));
+  }
+  return result;
+}
+
+jsi::Value HybridObject::get(facebook::jsi::Runtime& runtime, const facebook::jsi::PropNameID& propName) {
+  std::unique_lock lock(_mutex);
+  ensureInitialized(runtime);
+
+  std::string name = propName.utf8(runtime);
+  auto& functionCache = _functionCache[&runtime];
+
+  if (_getters.count(name) > 0) {
+    // it's a property getter
+    return _getters[name](runtime, jsi::Value::undefined(), nullptr, 0);
+  }
+
+  if (functionCache.count(name) > 0) {
+    [[likely]];
+    // cache hit
+    return jsi::Value(runtime, *functionCache[name]);
+  }
+
+  if (_methods.count(name) > 0) {
+    // cache miss - create jsi::Function and cache it.
+    HybridFunction& hybridFunction = _methods.at(name);
+    jsi::Function function = jsi::Function::createFromHostFunction(runtime, jsi::PropNameID::forUtf8(runtime, name),
+                                                                   hybridFunction.parameterCount, hybridFunction.function);
+
+    functionCache[name] = JSIHelper::createSharedJsiFunction(runtime, std::move(function));
+    return jsi::Value(runtime, *functionCache[name]);
+  }
+
+  if (name == "toString") {
+    return jsi::Function::createFromHostFunction(
+        runtime, jsi::PropNameID::forUtf8(runtime, "toString"), 0,
+        [=](jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* args, size_t count) -> jsi::Value {
+          std::string stringRepresentation = this->toString(runtime);
+          return jsi::String::createFromUtf8(runtime, stringRepresentation);
+        });
+  }
+
+  return jsi::HostObject::get(runtime, propName);
+}
+
+void HybridObject::set(facebook::jsi::Runtime& runtime, const facebook::jsi::PropNameID& propName, const facebook::jsi::Value& value) {
+  std::unique_lock lock(_mutex);
+  ensureInitialized(runtime);
+
+  std::string name = propName.utf8(runtime);
+
+  if (_setters.count(name) > 0) {
+    // Call setter
+    _setters[name](runtime, jsi::Value::undefined(), &value, 1);
+    return;
+  }
+
+  HostObject::set(runtime, propName, value);
+}
+
+void HybridObject::ensureInitialized(facebook::jsi::Runtime& runtime) {
+  if (!_didLoadMethods) {
+    [[unlikely]];
+    _creationRuntime = &runtime;
+    // lazy-load all exposed methods
+    loadHybridMethods();
+    _didLoadMethods = true;
+  }
+}
+
+bool HybridObject::isRuntimeAlive() {
+  if (_creationRuntime == nullptr) {
+    [[unlikely]];
+    return false;
+  }
+  return RNFWorkletRuntimeRegistry::isRuntimeAlive(_creationRuntime);
+}
+
+} // namespace margelo

package/cpp/jsi/RNFHybridObject.h

@@ -0,0 +1,162 @@
+//
+// Created by Marc Rousavy on 21.02.24.
+//
+
+#pragma once
+
+#include "RNFJSIConverter.h"
+#include "Logger.h"
+#include "RNFWorkletRuntimeRegistry.h"
+#include <functional>
+#include <jsi/jsi.h>
+#include <memory>
+#include <mutex>
+#include <type_traits>
+#include <unordered_map>
+#include <vector>
+#include <utility>
+#include <string>
+
+namespace margelo {
+
+namespace jsi = facebook::jsi;
+
+class HybridObject : public jsi::HostObject, public std::enable_shared_from_this<HybridObject> {
+public:
+  struct HybridFunction {
+    jsi::HostFunctionType function;
+    size_t parameterCount;
+  };
+
+public:
+  explicit HybridObject(const char* name);
+  ~HybridObject();
+
+  void set(jsi::Runtime&, const jsi::PropNameID& name, const jsi::Value& value) override;
+  jsi::Value get(jsi::Runtime& runtime, const jsi::PropNameID& propName) override;
+  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime& runtime) override;
+
+  /**
+   * Get the `std::shared_ptr` instance of this HybridObject.
+   * The HybridObject must be managed inside a `shared_ptr` already, otherwise this will fail.
+   */
+  template <typename Derived> std::shared_ptr<Derived> shared() {
+    return std::static_pointer_cast<Derived>(shared_from_this());
+  }
+
+  /**
+   * Loads all native methods of this `HybridObject` to be exposed to JavaScript.
+   * Example:
+   *
+   * ```cpp
+   * int User::getAge() {
+   *   return 23;
+   * }
+   *
+   * void User::loadHybridMethods() {
+   *   registerHybridMethod("getAge", &User::getAge, this);
+   * }
+   * ```
+   */
+  virtual void loadHybridMethods() = 0;
+
+  /**
+   * Get a string representation of this HostObject, useful for logging or debugging.
+   */
+  virtual std::string toString(jsi::Runtime& runtime);
+
+private:
+  static constexpr auto TAG = "HybridObject";
+  int _instanceId = 1;
+  bool _didLoadMethods = false;
+  std::mutex _mutex;
+  std::unordered_map<std::string, HybridFunction> _methods;
+  std::unordered_map<std::string, jsi::HostFunctionType> _getters;
+  std::unordered_map<std::string, jsi::HostFunctionType> _setters;
+  std::unordered_map<jsi::Runtime*, std::unordered_map<std::string, std::shared_ptr<jsi::Function>>> _functionCache;
+  // Store a pointer to the runtime. Needed for checking if the runtime is still active, see WorkletRuntimeRegistry.
+  jsi::Runtime* _creationRuntime = nullptr;
+
+protected:
+  const char* _name = TAG;
+
+private:
+  inline void ensureInitialized(facebook::jsi::Runtime& runtime);
+
+private:
+  template <typename Derived, typename ReturnType, typename... Args, size_t... Is>
+  static inline jsi::Value callMethod(Derived* obj, ReturnType (Derived::*method)(Args...), jsi::Runtime& runtime, const jsi::Value* args,
+                                      std::index_sequence<Is...>, size_t count) {
+    if constexpr (std::is_same_v<ReturnType, void>) {
+      // It's a void method.
+      (obj->*method)(JSIConverter<std::decay_t<Args>>::fromJSI(runtime, args[Is])...);
+      return jsi::Value::undefined();
+    } else {
+      // It's returning some C++ type, we need to convert that to a JSI value now.
+      ReturnType result = (obj->*method)(JSIConverter<std::decay_t<Args>>::fromJSI(runtime, args[Is], Is >= count)...);
+      return JSIConverter<std::decay_t<ReturnType>>::toJSI(runtime, std::move(result));
+    }
+  }
+
+  template <typename Derived, typename ReturnType, typename... Args>
+  static jsi::HostFunctionType createHybridMethod(ReturnType (Derived::*method)(Args...), Derived* derivedInstance) {
+
+    return [derivedInstance, method](jsi::Runtime& runtime, const jsi::Value& thisVal, const jsi::Value* args, size_t count) -> jsi::Value {
+      if constexpr (std::is_same_v<ReturnType, jsi::Value>) {
+        // If the return type is a jsi::Value, we assume the user wants full JSI code control.
+        // The signature must be identical to jsi::HostFunction (jsi::Runtime&, jsi::Value& this, ...)
+        return (derivedInstance->*method)(runtime, thisVal, args, count);
+      } else {
+        // Call the actual method with JSI values as arguments and return a JSI value again.
+        // Internally, this method converts the JSI values to C++ values.
+        return callMethod(derivedInstance, method, runtime, args, std::index_sequence_for<Args...>{}, count);
+      }
+    };
+  }
+
+protected:
+  template <typename Derived, typename ReturnType, typename... Args>
+  void registerHybridMethod(std::string name, ReturnType (Derived::*method)(Args...), Derived* derivedInstance, bool override = false) {
+    if (!override && (_getters.count(name) > 0 || _setters.count(name) > 0)) {
+      [[unlikely]];
+      throw std::runtime_error("Cannot add Hybrid Method \"" + name + "\" - a property with that name already exists!");
+    }
+    if (!override && (_methods.count(name) > 0)) {
+      throw std::runtime_error("Cannot add Hybrid Method \"" + name + "\" - a method with that name already exists!");
+    }
+
+    _methods[name] = HybridFunction{.function = createHybridMethod(method, derivedInstance), .parameterCount = sizeof...(Args)};
+  }
+
+  template <typename Derived, typename ReturnType>
+  void registerHybridGetter(std::string name, ReturnType (Derived::*method)(), Derived* derivedInstance) {
+    if (_getters.count(name) > 0) {
+      [[unlikely]];
+      throw std::runtime_error("Cannot add Hybrid Property Getter \"" + name + "\" - a getter with that name already exists!");
+    }
+    if (_methods.count(name) > 0) {
+      [[unlikely]];
+      throw std::runtime_error("Cannot add Hybrid Property Getter \"" + name + "\" - a method with that name already exists!");
+    }
+
+    _getters[name] = createHybridMethod(method, derivedInstance);
+  }
+
+  template <typename Derived, typename ValueType>
+  void registerHybridSetter(std::string name, void (Derived::*method)(ValueType), Derived* derivedInstance) {
+    if (_setters.count(name) > 0) {
+      [[unlikely]];
+      throw std::runtime_error("Cannot add Hybrid Property Setter \"" + name + "\" - a setter with that name already exists!");
+    }
+    if (_methods.count(name) > 0) {
+      [[unlikely]];
+      throw std::runtime_error("Cannot add Hybrid Property Setter \"" + name + "\" - a method with that name already exists!");
+    }
+
+    _setters[name] = createHybridMethod(method, derivedInstance);
+  }
+
+  bool isRuntimeAlive();
+};
+
+} // namespace margelo