react-native-webgpu 0.5.11

package/cpp/rnwgpu/api/External.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#include "webgpu/webgpu_cpp.h"
+
+namespace rnwgpu {
+enum class PredefinedColorSpace : uint32_t {
+  DisplayP3 = 0,
+  Srgb = 1,
+};
+
+enum class PremultiplyAlpha : uint32_t { Default = 0, None = 1, Premultiply };
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPU.cpp

@@ -0,0 +1,127 @@
+#include "GPU.h"
+
+#include <cstdio>
+#include <memory>
+#include <string>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+
+#include "Convertors.h"
+#include "JSIConverter.h"
+#include "rnwgpu/async/JSIMicrotaskDispatcher.h"
+
+namespace rnwgpu {
+
+GPU::GPU(jsi::Runtime &runtime) : NativeObject(CLASS_NAME) {
+  static const auto kTimedWaitAny = wgpu::InstanceFeatureName::TimedWaitAny;
+  wgpu::InstanceDescriptor instanceDesc{.requiredFeatureCount = 1,
+                                        .requiredFeatures = &kTimedWaitAny};
+
+  wgpu::InstanceLimits limits{.timedWaitAnyMaxCount = 64};
+  instanceDesc.requiredLimits = &limits;
+  _instance = wgpu::CreateInstance(&instanceDesc);
+
+  auto dispatcher = std::make_shared<async::JSIMicrotaskDispatcher>(runtime);
+  _async = async::AsyncRunner::getOrCreate(runtime, _instance, dispatcher);
+}
+
+async::AsyncTaskHandle GPU::requestAdapter(
+    std::optional<std::shared_ptr<GPURequestAdapterOptions>> options) {
+  wgpu::RequestAdapterOptions aOptions;
+  Convertor conv;
+  if (!conv(aOptions, options)) {
+    throw std::runtime_error("Failed to convert GPUDeviceDescriptor");
+  }
+#ifdef __APPLE__
+  constexpr auto kDefaultBackendType = wgpu::BackendType::Metal;
+#else
+  constexpr auto kDefaultBackendType = wgpu::BackendType::Vulkan;
+#endif
+  aOptions.backendType = kDefaultBackendType;
+  return _async->postTask(
+      [this, aOptions](const async::AsyncTaskHandle::ResolveFunction &resolve,
+                       const async::AsyncTaskHandle::RejectFunction &reject) {
+        _instance.RequestAdapter(
+            &aOptions, wgpu::CallbackMode::AllowProcessEvents,
+            [asyncRunner = _async, resolve,
+             reject](wgpu::RequestAdapterStatus status, wgpu::Adapter adapter,
+                     wgpu::StringView message) {
+              if (message.length) {
+                fprintf(stderr, "%s", message.data);
+              }
+
+              if (status == wgpu::RequestAdapterStatus::Success && adapter) {
+                auto adapterHost = std::make_shared<GPUAdapter>(
+                    std::move(adapter), asyncRunner);
+                auto result =
+                    std::variant<std::nullptr_t, std::shared_ptr<GPUAdapter>>(
+                        adapterHost);
+                resolve([result =
+                             std::move(result)](jsi::Runtime &runtime) mutable {
+                  return JSIConverter<decltype(result)>::toJSI(runtime, result);
+                });
+              } else {
+                auto result =
+                    std::variant<std::nullptr_t, std::shared_ptr<GPUAdapter>>(
+                        nullptr);
+                resolve([result =
+                             std::move(result)](jsi::Runtime &runtime) mutable {
+                  return JSIConverter<decltype(result)>::toJSI(runtime, result);
+                });
+              }
+            });
+      });
+}
+
+std::unordered_set<std::string> GPU::getWgslLanguageFeatures() {
+  wgpu::SupportedWGSLLanguageFeatures supportedFeatures = {};
+  _instance.GetWGSLLanguageFeatures(&supportedFeatures);
+
+  std::unordered_set<std::string> result;
+  for (size_t i = 0; i < supportedFeatures.featureCount; i++) {
+    wgpu::WGSLLanguageFeatureName feature = supportedFeatures.features[i];
+    std::string name;
+    switch (feature) {
+    case wgpu::WGSLLanguageFeatureName::ReadonlyAndReadwriteStorageTextures:
+      name = "readonly_and_readwrite_storage_textures";
+      break;
+    case wgpu::WGSLLanguageFeatureName::Packed4x8IntegerDotProduct:
+      name = "packed_4x8_integer_dot_product";
+      break;
+    case wgpu::WGSLLanguageFeatureName::UnrestrictedPointerParameters:
+      name = "unrestricted_pointer_parameters";
+      break;
+    case wgpu::WGSLLanguageFeatureName::PointerCompositeAccess:
+      name = "pointer_composite_access";
+      break;
+    case wgpu::WGSLLanguageFeatureName::ChromiumTestingUnimplemented:
+      name = "chromium_testing_unimplemented";
+      break;
+    case wgpu::WGSLLanguageFeatureName::ChromiumTestingUnsafeExperimental:
+      name = "chromium_testing_unsafe_experimental";
+      break;
+    case wgpu::WGSLLanguageFeatureName::ChromiumTestingExperimental:
+      name = "chromium_testing_experimental";
+      break;
+    case wgpu::WGSLLanguageFeatureName::ChromiumTestingShippedWithKillswitch:
+      name = "chromium_testing_shipped_with_killswitch";
+      break;
+    case wgpu::WGSLLanguageFeatureName::ChromiumTestingShipped:
+      name = "chromium_testing_shipped";
+      break;
+    }
+    result.insert(name);
+  }
+  return result;
+}
+
+wgpu::TextureFormat GPU::getPreferredCanvasFormat() {
+#if defined(__ANDROID__)
+  return wgpu::TextureFormat::RGBA8Unorm;
+#else
+  return wgpu::TextureFormat::BGRA8Unorm;
+#endif // defined(__ANDROID__)
+}
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPU.h

@@ -0,0 +1,58 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <unordered_set>
+#include <variant>
+
+#include "Unions.h"
+
+#include "NativeObject.h"
+
+#include "rnwgpu/async/AsyncRunner.h"
+#include "rnwgpu/async/AsyncTaskHandle.h"
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "GPUAdapter.h"
+#include "GPURequestAdapterOptions.h"
+
+#include <webgpu/webgpu.h>
+
+namespace rnwgpu {
+
+namespace jsi = facebook::jsi;
+
+class GPU : public NativeObject<GPU> {
+public:
+  static constexpr const char *CLASS_NAME = "GPU";
+
+  explicit GPU(jsi::Runtime &runtime);
+
+public:
+  std::string getBrand() { return CLASS_NAME; }
+
+  async::AsyncTaskHandle requestAdapter(
+      std::optional<std::shared_ptr<GPURequestAdapterOptions>> options);
+  wgpu::TextureFormat getPreferredCanvasFormat();
+
+  std::unordered_set<std::string> getWgslLanguageFeatures();
+
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installGetter(runtime, prototype, "__brand", &GPU::getBrand);
+    installMethod(runtime, prototype, "requestAdapter", &GPU::requestAdapter);
+    installMethod(runtime, prototype, "getPreferredCanvasFormat",
+                  &GPU::getPreferredCanvasFormat);
+    installGetter(runtime, prototype, "wgslLanguageFeatures",
+                  &GPU::getWgslLanguageFeatures);
+  }
+
+  inline const wgpu::Instance get() { return _instance; }
+  inline std::shared_ptr<async::AsyncRunner> getAsyncRunner() { return _async; }
+
+private:
+  wgpu::Instance _instance;
+  std::shared_ptr<async::AsyncRunner> _async;
+};
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUAdapter.cpp

@@ -0,0 +1,191 @@
+#include "GPUAdapter.h"
+
+#include <cstdio>
+#include <memory>
+#include <string>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+
+#include "Convertors.h"
+
+#include "GPUFeatures.h"
+#include "JSIConverter.h"
+#include "WGPULogger.h"
+
+namespace rnwgpu {
+
+async::AsyncTaskHandle GPUAdapter::requestDevice(
+    std::optional<std::shared_ptr<GPUDeviceDescriptor>> descriptor) {
+  wgpu::DeviceDescriptor aDescriptor;
+  Convertor conv;
+  if (!conv(aDescriptor, descriptor)) {
+    throw std::runtime_error("Failed to convert GPUDeviceDescriptor");
+  }
+  auto deviceLostBinding = std::make_shared<std::weak_ptr<GPUDevice>>();
+  // Set device lost callback using new template API
+  aDescriptor.SetDeviceLostCallback(
+      wgpu::CallbackMode::AllowSpontaneous,
+      [deviceLostBinding](const wgpu::Device & /*device*/,
+                          wgpu::DeviceLostReason reason,
+                          wgpu::StringView message) {
+        const char *lostReason = "";
+        switch (reason) {
+        case wgpu::DeviceLostReason::Destroyed:
+          lostReason = "Destroyed";
+          break;
+        case wgpu::DeviceLostReason::Unknown:
+          lostReason = "Unknown";
+          break;
+        default:
+          lostReason = "Unknown";
+        }
+        std::string msg =
+            message.length ? std::string(message.data, message.length) : "";
+        Logger::logToConsole("GPU Device Lost (%s): %s", lostReason,
+                             msg.c_str());
+        if (auto deviceHost = deviceLostBinding->lock()) {
+          deviceHost->notifyDeviceLost(reason, std::move(msg));
+        }
+      });
+
+  // Set uncaptured error callback using new template API
+  // Note: This callback cannot capture variables, so we use a static registry
+  // to look up the GPUDevice from the wgpu::Device handle.
+  aDescriptor.SetUncapturedErrorCallback([](const wgpu::Device &device,
+                                            wgpu::ErrorType type,
+                                            wgpu::StringView message) {
+    const char *errorType = "";
+    switch (type) {
+    case wgpu::ErrorType::Validation:
+      errorType = "Validation";
+      break;
+    case wgpu::ErrorType::OutOfMemory:
+      errorType = "Out of Memory";
+      break;
+    case wgpu::ErrorType::Internal:
+      errorType = "Internal";
+      break;
+    case wgpu::ErrorType::Unknown:
+      errorType = "Unknown";
+      break;
+    default:
+      errorType = "Unknown";
+    }
+    std::string msg =
+        message.length > 0 ? std::string(message.data, message.length) : "";
+    std::string fullMessage =
+        msg.length() > 0 ? std::string(errorType) + ": " + msg : "no message";
+    fprintf(stderr, "%s\n", fullMessage.c_str());
+
+    // Look up the GPUDevice from the registry and notify it
+    if (auto gpuDevice = GPUDevice::lookupDevice(device.Get())) {
+      gpuDevice->notifyUncapturedError(type, std::move(msg));
+    }
+  });
+  std::string label =
+      descriptor.has_value() ? descriptor.value()->label.value_or("") : "";
+
+  auto creationRuntime = getCreationRuntime();
+  return _async->postTask(
+      [this, aDescriptor, descriptor, label = std::move(label),
+       deviceLostBinding,
+       creationRuntime](const async::AsyncTaskHandle::ResolveFunction &resolve,
+                        const async::AsyncTaskHandle::RejectFunction &reject) {
+        (void)descriptor;
+        _instance.RequestDevice(
+            &aDescriptor, wgpu::CallbackMode::AllowProcessEvents,
+            [asyncRunner = _async, resolve, reject, label, creationRuntime,
+             deviceLostBinding](wgpu::RequestDeviceStatus status,
+                                wgpu::Device device,
+                                wgpu::StringView message) mutable {
+              if (message.length) {
+                fprintf(stderr, "%s", message.data);
+              }
+
+              if (status != wgpu::RequestDeviceStatus::Success || !device) {
+                std::string error =
+                    message.length ? std::string(message.data, message.length)
+                                   : "Failed to request device";
+                reject(std::move(error));
+                return;
+              }
+
+              device.SetLoggingCallback([creationRuntime](
+                                            wgpu::LoggingType type,
+                                            wgpu::StringView msg) {
+                if (creationRuntime == nullptr) {
+                  return;
+                }
+                const char *logLevel = "";
+                switch (type) {
+                case wgpu::LoggingType::Warning:
+                  logLevel = "Warning";
+                  Logger::warnToJavascriptConsole(
+                      *creationRuntime, std::string(msg.data, msg.length));
+                  break;
+                case wgpu::LoggingType::Error:
+                  logLevel = "Error";
+                  Logger::errorToJavascriptConsole(
+                      *creationRuntime, std::string(msg.data, msg.length));
+                  break;
+                case wgpu::LoggingType::Verbose:
+                  logLevel = "Verbose";
+                  break;
+                case wgpu::LoggingType::Info:
+                  logLevel = "Info";
+                  break;
+                default:
+                  logLevel = "Unknown";
+                  Logger::logToConsole("%s: %.*s", logLevel,
+                                       static_cast<int>(msg.length), msg.data);
+                }
+              });
+
+              auto deviceHost = std::make_shared<GPUDevice>(std::move(device),
+                                                            asyncRunner, label);
+              *deviceLostBinding = deviceHost;
+
+              // Register the device in the static registry so the uncaptured
+              // error callback can find it
+              GPUDevice::registerDevice(deviceHost->get().Get(), deviceHost);
+
+              resolve([deviceHost = std::move(deviceHost)](
+                          jsi::Runtime &runtime) mutable {
+                return JSIConverter<std::shared_ptr<GPUDevice>>::toJSI(
+                    runtime, deviceHost);
+              });
+            });
+      });
+}
+
+std::unordered_set<std::string> GPUAdapter::getFeatures() {
+  wgpu::SupportedFeatures supportedFeatures;
+  _instance.GetFeatures(&supportedFeatures);
+  std::unordered_set<std::string> result;
+  for (size_t i = 0; i < supportedFeatures.featureCount; ++i) {
+    auto feature = supportedFeatures.features[i];
+    std::string name;
+    convertEnumToJSUnion(feature, &name);
+    if (name != "") {
+      result.insert(name);
+    }
+  }
+  return result;
+}
+
+std::shared_ptr<GPUSupportedLimits> GPUAdapter::getLimits() {
+  wgpu::Limits limits{};
+  if (!_instance.GetLimits(&limits)) {
+    throw std::runtime_error("Failed to get limits");
+  }
+  return std::make_shared<GPUSupportedLimits>(limits);
+}
+
+std::shared_ptr<GPUAdapterInfo> GPUAdapter::getInfo() {
+  wgpu::AdapterInfo info = {};
+  _instance.GetInfo(&info);
+  return std::make_shared<GPUAdapterInfo>(info);
+}
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUAdapter.h

@@ -0,0 +1,59 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <unordered_set>
+
+#include "Unions.h"
+
+#include "NativeObject.h"
+
+#include "rnwgpu/async/AsyncRunner.h"
+#include "rnwgpu/async/AsyncTaskHandle.h"
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "GPUAdapterInfo.h"
+#include "GPUDevice.h"
+#include "GPUDeviceDescriptor.h"
+#include "GPUSupportedLimits.h"
+
+namespace rnwgpu {
+
+namespace jsi = facebook::jsi;
+
+class GPUAdapter : public NativeObject<GPUAdapter> {
+public:
+  static constexpr const char *CLASS_NAME = "GPUAdapter";
+
+  explicit GPUAdapter(wgpu::Adapter instance,
+                      std::shared_ptr<async::AsyncRunner> async)
+      : NativeObject(CLASS_NAME), _instance(instance), _async(async) {}
+
+public:
+  std::string getBrand() { return CLASS_NAME; }
+
+  async::AsyncTaskHandle
+  requestDevice(std::optional<std::shared_ptr<GPUDeviceDescriptor>> descriptor);
+
+  std::unordered_set<std::string> getFeatures();
+  std::shared_ptr<GPUSupportedLimits> getLimits();
+  std::shared_ptr<GPUAdapterInfo> getInfo();
+
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installGetter(runtime, prototype, "__brand", &GPUAdapter::getBrand);
+    installMethod(runtime, prototype, "requestDevice",
+                  &GPUAdapter::requestDevice);
+    installGetter(runtime, prototype, "features", &GPUAdapter::getFeatures);
+    installGetter(runtime, prototype, "limits", &GPUAdapter::getLimits);
+    installGetter(runtime, prototype, "info", &GPUAdapter::getInfo);
+  }
+
+  inline const wgpu::Adapter get() { return _instance; }
+
+private:
+  wgpu::Adapter _instance;
+  std::shared_ptr<async::AsyncRunner> _async;
+};
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUAdapterInfo.h

@@ -0,0 +1,57 @@
+#pragma once
+
+#include <string>
+#include <utility>
+
+#include "Unions.h"
+
+#include "NativeObject.h"
+
+#include "Convertors.h"
+
+#include "webgpu/webgpu_cpp.h"
+
+namespace rnwgpu {
+
+namespace jsi = facebook::jsi;
+
+class GPUAdapterInfo : public NativeObject<GPUAdapterInfo> {
+public:
+  static constexpr const char *CLASS_NAME = "GPUAdapterInfo";
+
+  explicit GPUAdapterInfo(wgpu::AdapterInfo &info)
+      : NativeObject(CLASS_NAME), _vendor(info.vendor),
+        _architecture(info.architecture), _device(info.device),
+        _description(info.description),
+        _isFallbackAdapter(info.adapterType == wgpu::AdapterType::CPU) {}
+
+public:
+  std::string getBrand() { return CLASS_NAME; }
+
+  std::string getVendor() { return _vendor; }
+  std::string getArchitecture() { return _architecture; }
+  std::string getDevice() { return _device; }
+  std::string getDescription() { return _description; }
+  bool getIsFallbackAdapter() { return _isFallbackAdapter; }
+
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installGetter(runtime, prototype, "__brand", &GPUAdapterInfo::getBrand);
+    installGetter(runtime, prototype, "vendor", &GPUAdapterInfo::getVendor);
+    installGetter(runtime, prototype, "architecture",
+                  &GPUAdapterInfo::getArchitecture);
+    installGetter(runtime, prototype, "device", &GPUAdapterInfo::getDevice);
+    installGetter(runtime, prototype, "description",
+                  &GPUAdapterInfo::getDescription);
+    installGetter(runtime, prototype, "isFallbackAdapter",
+                  &GPUAdapterInfo::getIsFallbackAdapter);
+  }
+
+private:
+  std::string _vendor;
+  std::string _architecture;
+  std::string _device;
+  std::string _description;
+  bool _isFallbackAdapter;
+};
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUBindGroup.cpp

@@ -0,0 +1,3 @@
+#include "GPUBindGroup.h"
+
+namespace rnwgpu {} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUBindGroup.h

@@ -0,0 +1,51 @@
+#pragma once
+
+#include <string>
+
+#include "Unions.h"
+
+#include "NativeObject.h"
+
+#include "webgpu/webgpu_cpp.h"
+
+namespace rnwgpu {
+
+namespace jsi = facebook::jsi;
+
+class GPUBindGroup : public NativeObject<GPUBindGroup> {
+public:
+  static constexpr const char *CLASS_NAME = "GPUBindGroup";
+
+  explicit GPUBindGroup(wgpu::BindGroup instance, std::string label)
+      : NativeObject(CLASS_NAME), _instance(instance), _label(label) {}
+
+public:
+  std::string getBrand() { return CLASS_NAME; }
+
+  std::string getLabel() { return _label; }
+  void setLabel(const std::string &label) {
+    _label = label;
+    _instance.SetLabel(_label.c_str());
+  }
+
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installGetter(runtime, prototype, "__brand", &GPUBindGroup::getBrand);
+    installGetterSetter(runtime, prototype, "label", &GPUBindGroup::getLabel,
+                        &GPUBindGroup::setLabel);
+  }
+
+  inline const wgpu::BindGroup get() { return _instance; }
+
+  size_t getMemoryPressure() override {
+    // Bind groups store resource bindings and descriptor state
+    // They reference buffers, textures, samplers, etc.
+    // Estimate: 1KB per bind group (descriptor tables and binding state)
+    return 1024;
+  }
+
+private:
+  wgpu::BindGroup _instance;
+  std::string _label;
+};
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUBindGroupLayout.h

@@ -0,0 +1,52 @@
+#pragma once
+
+#include <string>
+
+#include "Unions.h"
+
+#include "NativeObject.h"
+
+#include "webgpu/webgpu_cpp.h"
+
+namespace rnwgpu {
+
+namespace jsi = facebook::jsi;
+
+class GPUBindGroupLayout : public NativeObject<GPUBindGroupLayout> {
+public:
+  static constexpr const char *CLASS_NAME = "GPUBindGroupLayout";
+
+  explicit GPUBindGroupLayout(wgpu::BindGroupLayout instance, std::string label)
+      : NativeObject(CLASS_NAME), _instance(instance), _label(label) {}
+
+public:
+  std::string getBrand() { return CLASS_NAME; }
+
+  std::string getLabel() { return _label; }
+  void setLabel(const std::string &label) {
+    _label = label;
+    _instance.SetLabel(_label.c_str());
+  }
+
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installGetter(runtime, prototype, "__brand", &GPUBindGroupLayout::getBrand);
+    installGetterSetter(runtime, prototype, "label",
+                        &GPUBindGroupLayout::getLabel,
+                        &GPUBindGroupLayout::setLabel);
+  }
+
+  inline const wgpu::BindGroupLayout get() { return _instance; }
+
+  size_t getMemoryPressure() override {
+    // Bind group layouts define the structure/schema for bind groups
+    // They store binding descriptors, types, and validation info
+    // Estimate: 512 bytes per layout (smaller than actual bind groups)
+    return 512;
+  }
+
+private:
+  wgpu::BindGroupLayout _instance;
+  std::string _label;
+};
+
+} // namespace rnwgpu