react-native-webgpu 0.5.11

package/apple/RNWGUIKit.h

@@ -0,0 +1,16 @@
+#ifndef PACKAGES_WEBGPU_APPLE_RNWGUIKIT_H_
+#define PACKAGES_WEBGPU_APPLE_RNWGUIKIT_H_
+
+#if !TARGET_OS_OSX
+#import <UIKit/UIKit.h>
+#else
+#import <Appkit/Appkit.h>
+#endif
+
+#if !TARGET_OS_OSX
+typedef UIView RNWGPlatformView;
+#else
+typedef NSView RNWGPlatformView;
+#endif
+
+#endif // PACKAGES_WEBGPU_APPLE_RNWGUIKIT_H_

package/apple/WebGPUModule.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#import "RNWebGPUManager.h"
+#import <RNWgpuViewSpec/RNWgpuViewSpec.h>
+#import <React/RCTCallInvokerModule.h>
+#import <React/RCTEventEmitter.h>
+
+@interface WebGPUModule
+    : RCTEventEmitter <NativeWebGPUModuleSpec, RCTCallInvokerModule>
+
++ (std::shared_ptr<rnwgpu::RNWebGPUManager>)getManager;
+
+@end

package/apple/WebGPUModule.mm

@@ -0,0 +1,89 @@
+#import "WebGPUModule.h"
+#include "ApplePlatformContext.h"
+#import "GPUCanvasContext.h"
+
+#import <React/RCTBridge+Private.h>
+#import <React/RCTCallInvoker.h>
+#import <React/RCTLog.h>
+#import <ReactCommon/RCTTurboModule.h>
+#import <jsi/jsi.h>
+#import <memory>
+
+namespace jsi = facebook::jsi;
+namespace react = facebook::react;
+
+// Category to declare the runtime property on RCTBridge/RCTBridgeProxy.
+// In Bridgeless mode, self.bridge is an RCTBridgeProxy which implements
+// -(void *)runtime. In Legacy mode, self.bridge is the real RCTBridge
+// (backed by RCTCxxBridge) which also implements it.
+@interface RCTBridge (JSIRuntime)
+- (void *)runtime;
+@end
+
+@implementation WebGPUModule
+
+RCT_EXPORT_MODULE(WebGPUModule)
+
+static std::shared_ptr<rnwgpu::RNWebGPUManager> webgpuManager;
+
+// Synthesize callInvoker so RCTTurboModuleManager injects the JS CallInvoker.
+// When the module conforms to RCTCallInvokerModule, the TurboModule infra
+// calls setCallInvoker: during module initialization.
+@synthesize callInvoker = _callInvoker;
+
++ (std::shared_ptr<rnwgpu::RNWebGPUManager>)getManager {
+  return webgpuManager;
+}
+
+#pragma Setup and invalidation
+
++ (BOOL)requiresMainQueueSetup {
+  return YES;
+}
+
+- (void)invalidate {
+  webgpuManager = nil;
+}
+
+- (std::shared_ptr<rnwgpu::RNWebGPUManager>)getManager {
+  return webgpuManager;
+}
+
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(install) {
+  if (webgpuManager != nil) {
+    // Already initialized, ignore call.
+    return @true;
+  }
+
+  // self.bridge works in both Legacy (RCTBridge) and Bridgeless
+  // (RCTBridgeProxy).
+  jsi::Runtime *runtime = (jsi::Runtime *)self.bridge.runtime;
+  if (!runtime) {
+    NSLog(@"Failed to install react-native-wgpu: jsi::Runtime* was null! "
+          @"(self.bridge=%@)",
+          self.bridge);
+    return [NSNumber numberWithBool:NO];
+  }
+
+  // _callInvoker is injected by RCTTurboModuleManager because we conform to
+  // RCTCallInvokerModule. Works in both Legacy and Bridgeless.
+  std::shared_ptr<react::CallInvoker> jsInvoker = _callInvoker.callInvoker;
+  if (!jsInvoker) {
+    NSLog(@"Failed to install react-native-wgpu: react::CallInvoker was "
+          @"null!");
+    return [NSNumber numberWithBool:NO];
+  }
+
+  std::shared_ptr<rnwgpu::PlatformContext> platformContext =
+      std::make_shared<rnwgpu::ApplePlatformContext>();
+  webgpuManager = std::make_shared<rnwgpu::RNWebGPUManager>(runtime, jsInvoker,
+                                                            platformContext);
+  return @true;
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params {
+  return std::make_shared<facebook::react::NativeWebGPUModuleSpecJSI>(params);
+}
+
+@end

package/apple/WebGPUView.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#import "MetalView.h"
+#import <React/RCTViewComponentView.h>
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface WebGPUView : RCTViewComponentView
+@end
+
+NS_ASSUME_NONNULL_END

package/apple/WebGPUView.mm

@@ -0,0 +1,66 @@
+#import "WebGPUView.h"
+
+#import <react/renderer/components/RNWgpuViewSpec/ComponentDescriptors.h>
+#import <react/renderer/components/RNWgpuViewSpec/EventEmitters.h>
+#import <react/renderer/components/RNWgpuViewSpec/Props.h>
+#import <react/renderer/components/RNWgpuViewSpec/RCTComponentViewHelpers.h>
+
+#import "MetalView.h"
+#import "RCTFabricComponentsPlugins.h"
+#import "Utils.h"
+
+using namespace facebook::react;
+
+@implementation WebGPUView
+
++ (ComponentDescriptorProvider)componentDescriptorProvider {
+  return concreteComponentDescriptorProvider<WebGPUViewComponentDescriptor>();
+}
+
+- (void)prepareForRecycle {
+  [super prepareForRecycle];
+  /*
+    It's important to destroy the Metal Layer before releasing a view
+    to the recycled pool to prevent displaying outdated content from
+    the last usage in the new context.
+  */
+  self.contentView = nil;
+}
+
+- (MetalView *)getContentView {
+  if (!self.contentView) {
+    self.contentView = [MetalView new];
+  }
+  return (MetalView *)self.contentView;
+}
+
+- (void)updateProps:(const Props::Shared &)props
+           oldProps:(const Props::Shared &)oldProps {
+  const auto &oldViewProps =
+      *std::static_pointer_cast<const WebGPUViewProps>(_props);
+  const auto &newViewProps =
+      *std::static_pointer_cast<const WebGPUViewProps>(props);
+
+  if (newViewProps.contextId != oldViewProps.contextId) {
+    /*
+      The context is set only once during mounting the component
+      and never changes because it isn't available for users to modify.
+    */
+    MetalView *metalView = [MetalView new];
+    self.contentView = metalView;
+    [metalView setContextId:@(newViewProps.contextId)];
+    [metalView configure];
+  }
+
+  [super updateProps:props oldProps:oldProps];
+}
+
+- (void)updateLayoutMetrics:(const LayoutMetrics &)layoutMetrics
+           oldLayoutMetrics:(const LayoutMetrics &)oldLayoutMetrics {
+  [super updateLayoutMetrics:layoutMetrics oldLayoutMetrics:oldLayoutMetrics];
+  [(MetalView *)self.contentView update];
+}
+
+Class<RCTComponentViewProtocol> WebGPUViewCls(void) { return WebGPUView.class; }
+
+@end

package/cpp/WGPULogger.h

@@ -0,0 +1,100 @@
+//
+// Created by Christian Falch on 26/08/2021.
+//
+
+#pragma once
+
+#include <cstdio>
+#include <jsi/jsi.h>
+#include <string>
+
+#if defined(ANDROID) || defined(__ANDROID__)
+#include <android/log.h>
+#endif
+
+#ifdef __APPLE__
+#include <syslog.h>
+#endif
+
+namespace rnwgpu {
+
+namespace jsi = facebook::jsi;
+
+class Logger {
+public:
+  /**
+   * Logs message to console
+   * @param message Message to be written out
+   */
+  static void logToConsole(std::string message) {
+#ifdef DEBUG
+#if defined(ANDROID) || defined(__ANDROID__)
+    __android_log_write(ANDROID_LOG_INFO, "WebGPU", message.c_str());
+#endif
+
+#ifdef __APPLE__
+    syslog(LOG_ERR, "%s\n", message.c_str());
+#endif
+#else
+    // In release mode, do nothing
+    (void)message;
+#endif
+  }
+
+  /**
+   * Logs to console
+   * @param fmt Format string
+   * @param ... Arguments to format string
+   */
+  static void logToConsole(const char *fmt, ...) {
+#ifdef DEBUG
+    va_list args;
+    va_start(args, fmt);
+
+    static char buffer[512];
+    vsnprintf(buffer, sizeof(buffer), fmt, args);
+#if defined(ANDROID) || defined(__ANDROID__)
+    __android_log_write(ANDROID_LOG_INFO, "WebGPU", buffer);
+#endif
+#ifdef __APPLE__
+    syslog(LOG_ERR, "WebGPU: %s\n", buffer);
+#endif
+    va_end(args);
+#else
+    // In release mode, do nothing
+    (void)fmt;
+#endif
+  }
+
+  static void logToJavascriptConsole(jsi::Runtime &runtime,
+                                     const std::string &message) {
+    auto console = Logger::getJavascriptConsole(runtime).asObject(runtime);
+    auto log = console.getPropertyAsFunction(runtime, "log");
+    log.call(runtime, jsi::String::createFromUtf8(runtime, message));
+  }
+
+  static void warnToJavascriptConsole(jsi::Runtime &runtime,
+                                      const std::string &message) {
+    auto console = Logger::getJavascriptConsole(runtime).asObject(runtime);
+    auto warn = console.getPropertyAsFunction(runtime, "warn");
+    warn.call(runtime, jsi::String::createFromUtf8(runtime, message));
+  }
+
+  static void errorToJavascriptConsole(jsi::Runtime &runtime,
+                                      const std::string &message) {
+    auto console = Logger::getJavascriptConsole(runtime).asObject(runtime);
+    auto warn = console.getPropertyAsFunction(runtime, "error");
+    warn.call(runtime, jsi::String::createFromUtf8(runtime, message));
+  }
+
+private:
+  static jsi::Value getJavascriptConsole(jsi::Runtime &runtime) {
+    auto console = runtime.global().getProperty(runtime, "console");
+    if (console.isUndefined() || console.isNull()) {
+      throw jsi::JSError(runtime, "Could not find console object.");
+      return jsi::Value::undefined();
+    }
+    return console;
+  }
+};
+} // namespace rnwgpu

package/cpp/dawn_logging.cpp

@@ -0,0 +1,119 @@
+#include <cstdio>
+#include <sstream>
+#include <string>
+#include <utility>
+
+#ifdef __ANDROID__
+#include <android/log.h>
+#elif defined(__APPLE__)
+#include <os/log.h>
+#endif
+
+namespace dawn {
+
+enum class LogSeverity {
+    Debug,
+    Info,
+    Warning,
+    Error,
+};
+
+// Forward declare to match Dawn's exact interface
+class LogMessage {
+public:
+    explicit LogMessage(LogSeverity severity);
+    ~LogMessage();
+    LogMessage(LogMessage&& other);
+    LogMessage& operator=(LogMessage&& other);
+    template <typename T>
+    LogMessage& operator<<(T&& value) {
+        mStream << value;
+        return *this;
+    }
+
+private:
+    LogMessage(const LogMessage& other) = delete;
+    LogMessage& operator=(const LogMessage& other) = delete;
+    LogSeverity mSeverity;
+    std::ostringstream mStream;
+};
+
+// Implementation of LogMessage methods
+LogMessage::LogMessage(LogSeverity severity) : mSeverity(severity) {}
+
+LogMessage::LogMessage(LogMessage&& other)
+    : mSeverity(other.mSeverity), mStream(std::move(other.mStream)) {}
+
+LogMessage& LogMessage::operator=(LogMessage&& other) {
+    if (this != &other) {
+        mSeverity = other.mSeverity;
+        mStream = std::move(other.mStream);
+    }
+    return *this;
+}
+
+LogMessage::~LogMessage() {
+    std::string fullMessage = mStream.str();
+    if (fullMessage.empty()) {
+        return;
+    }
+    const char* severityName;
+    switch (mSeverity) {
+        case LogSeverity::Debug: severityName = "Debug"; break;
+        case LogSeverity::Info: severityName = "Info"; break;
+        case LogSeverity::Warning: severityName = "Warning"; break;
+        case LogSeverity::Error: severityName = "Error"; break;
+        default: severityName = "Unknown"; break;
+    }
+
+#ifdef __ANDROID__
+    int androidPriority;
+    switch (mSeverity) {
+        case LogSeverity::Debug: androidPriority = ANDROID_LOG_DEBUG; break;
+        case LogSeverity::Info: androidPriority = ANDROID_LOG_INFO; break;
+        case LogSeverity::Warning: androidPriority = ANDROID_LOG_WARN; break;
+        case LogSeverity::Error: androidPriority = ANDROID_LOG_ERROR; break;
+        default: androidPriority = ANDROID_LOG_ERROR; break;
+    }
+    __android_log_print(androidPriority, "ReactNativeWebGPU", "%s: %s", severityName, fullMessage.c_str());
+#elif defined(__APPLE__)
+    os_log_type_t logType;
+    switch (mSeverity) {
+        case LogSeverity::Debug: logType = OS_LOG_TYPE_DEBUG; break;
+        case LogSeverity::Info: logType = OS_LOG_TYPE_INFO; break;
+        case LogSeverity::Warning: logType = OS_LOG_TYPE_DEFAULT; break;
+        case LogSeverity::Error: logType = OS_LOG_TYPE_ERROR; break;
+        default: logType = OS_LOG_TYPE_ERROR; break;
+    }
+    os_log_with_type(OS_LOG_DEFAULT, logType, "[ReactNativeWebGPU] %s: %s", severityName, fullMessage.c_str());
+#else
+    FILE* outputStream = (mSeverity == LogSeverity::Warning || mSeverity == LogSeverity::Error) ? stderr : stdout;
+    fprintf(outputStream, "[ReactNativeWebGPU] %s: %s\n", severityName, fullMessage.c_str());
+    fflush(outputStream);
+#endif
+}
+
+// Factory functions
+LogMessage DebugLog() {
+    return LogMessage(LogSeverity::Debug);
+}
+
+LogMessage InfoLog() {
+    return LogMessage(LogSeverity::Info);
+}
+
+LogMessage WarningLog() {
+    return LogMessage(LogSeverity::Warning);
+}
+
+LogMessage ErrorLog() {
+    return LogMessage(LogSeverity::Error);
+}
+
+LogMessage DebugLog(const char* file, const char* function, int line) {
+    LogMessage message = DebugLog();
+    message << file << ":" << line << "(" << function << ")";
+    return message;
+}
+
+} // namespace dawn

package/cpp/jsi/EnumMapper.h

@@ -0,0 +1,45 @@
+#pragma once
+
+#include <stdexcept>
+#include <string>
+
+namespace rnwgpu {
+
+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 rnwgpu