react-native-wgpu 0.1.0 → 0.1.2

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

@@ -1,32 +1,109 @@
 #include "GPU.h"
+
 #include <utility>
+#include <vector>
+
+#include "Convertors.h"
 
 namespace rnwgpu {
 
-std::future<std::shared_ptr<GPUAdapter>>
-GPU::requestAdapter(std::shared_ptr<GPURequestAdapterOptions> options) {
-  return std::async(std::launch::async, [this, options]() {
-    auto aOptions = options->getInstance();
-    wgpu::Adapter adapter = nullptr;
-    _instance.RequestAdapter(
-        aOptions,
-        [](WGPURequestAdapterStatus, WGPUAdapter cAdapter, const char *message,
-           void *userdata) {
-          if (message != nullptr) {
-            fprintf(stderr, "%s", message);
-            return;
-          }
-          *static_cast<wgpu::Adapter *>(userdata) =
-              wgpu::Adapter::Acquire(cAdapter);
-        },
-        &adapter);
-    // TODO: implement returning null jsi value
-    if (!adapter) {
-      throw std::runtime_error("Failed to request adapter");
-    }
+std::future<std::variant<std::nullptr_t, std::shared_ptr<GPUAdapter>>>
+GPU::requestAdapter(
+    std::optional<std::shared_ptr<GPURequestAdapterOptions>> options) {
+  return std::async(
+      std::launch::async,
+      [this,
+       options]() -> std::variant<std::nullptr_t, std::shared_ptr<GPUAdapter>> {
+        wgpu::RequestAdapterOptions aOptions;
+        Convertor conv;
+        if (!conv(aOptions, options)) {
+          throw std::runtime_error("Failed to convert GPUDeviceDescriptor");
+        }
+        wgpu::Adapter adapter = nullptr;
+        _instance.RequestAdapter(
+            &aOptions,
+            [](WGPURequestAdapterStatus, WGPUAdapter cAdapter,
+               const char *message, void *userdata) {
+              if (message != nullptr) {
+                fprintf(stderr, "%s", message);
+                return;
+              }
+              *static_cast<wgpu::Adapter *>(userdata) =
+                  wgpu::Adapter::Acquire(cAdapter);
+            },
+            &adapter);
+        if (!adapter) {
+          return nullptr;
+        }
 
-    return std::make_shared<GPUAdapter>(std::move(adapter));
-  });
+        return std::make_shared<GPUAdapter>(std::move(adapter), _async);
+      });
+}
+
+// Async impl keeping here as a reference
+// std::future<std::shared_ptr<GPUAdapter>>
+// GPU::requestAdapter(std::shared_ptr<GPURequestAdapterOptions> options) {
+//   return _async->runAsync([=](wgpu::Instance *instance) {
+//     auto aOptions = options->getInstance();
+//     wgpu::Adapter adapter = nullptr;
+//     auto result = std::make_shared<GPUAdapter>(adapter, _async);
+//     wgpu::RequestAdapterCallbackInfo callback;
+//     callback.callback = [](WGPURequestAdapterStatus, WGPUAdapter cAdapter,
+//                            const char *message, void *userdata) {
+//       if (message != nullptr) {
+//         fprintf(stderr, "%s", message);
+//         return;
+//       }
+//       *static_cast<wgpu::Adapter *>(userdata) =
+//           wgpu::Adapter::Acquire(cAdapter);
+//     };
+//     callback.mode = wgpu::CallbackMode::WaitAnyOnly;
+//     callback.userdata = &(result->_instance);
+//     auto future = _instance.RequestAdapter(aOptions, callback);
+//     instance->WaitAny(future, UINT64_MAX);
+//     return result;
+//   });
+// }
+
+std::unordered_set<std::string> GPU::getWgslLanguageFeatures() {
+  auto count = _instance.EnumerateWGSLLanguageFeatures(nullptr);
+  std::vector<wgpu::WGSLFeatureName> features(count);
+  _instance.EnumerateWGSLLanguageFeatures(features.data());
+  std::unordered_set<std::string> result;
+  for (auto feature : features) {
+    std::string name;
+    switch (feature) {
+    case wgpu::WGSLFeatureName::ReadonlyAndReadwriteStorageTextures:
+      name = "readonly_and_readwrite_storage_textures";
+      break;
+    case wgpu::WGSLFeatureName::Packed4x8IntegerDotProduct:
+      name = "packed_4x8_integer_dot_product";
+      break;
+    case wgpu::WGSLFeatureName::UnrestrictedPointerParameters:
+      name = "unrestricted_pointer_parameters";
+      break;
+    case wgpu::WGSLFeatureName::PointerCompositeAccess:
+      name = "pointer_composite_access";
+      break;
+    case wgpu::WGSLFeatureName::ChromiumTestingUnimplemented:
+      name = "chromium_testing_unimplemented";
+      break;
+    case wgpu::WGSLFeatureName::ChromiumTestingUnsafeExperimental:
+      name = "chromium_testing_unsafe_experimental";
+      break;
+    case wgpu::WGSLFeatureName::ChromiumTestingExperimental:
+      name = "chromium_testing_experimental";
+      break;
+    case wgpu::WGSLFeatureName::ChromiumTestingShippedWithKillswitch:
+      name = "chromium_testing_shipped_with_killswitch";
+      break;
+    case wgpu::WGSLFeatureName::ChromiumTestingShipped:
+      name = "chromium_testing_shipped";
+      break;
+    }
+    result.insert(name);
+  }
+  return result;
 }
 
 wgpu::TextureFormat GPU::getPreferredCanvasFormat() {

package/cpp/rnwgpu/api/GPU.h

@@ -3,11 +3,14 @@
 #include <future>
 #include <memory>
 #include <string>
+#include <unordered_set>
+#include <variant>
 
 #include "Unions.h"
-#include <RNFHybridObject.h>
 
-#include "MutableBuffer.h"
+#include "RNFHybridObject.h"
+
+#include "AsyncRunner.h"
 
 #include "webgpu/webgpu_cpp.h"
 
@@ -20,24 +23,39 @@ namespace m = margelo;
 
 class GPU : public m::HybridObject {
 public:
-  explicit GPU(wgpu::Instance instance)
-      : HybridObject("GPU"), _instance(instance) {}
+  GPU() : HybridObject("GPU") {
+    wgpu::InstanceDescriptor instanceDesc;
+    instanceDesc.features.timedWaitAnyEnable = true;
+    instanceDesc.features.timedWaitAnyMaxCount = 64;
+    _instance = wgpu::CreateInstance(&instanceDesc);
+    auto instance = &_instance;
+    _async = std::make_shared<AsyncRunner>(instance);
+  }
 
 public:
   std::string getBrand() { return _name; }
 
-  std::future<std::shared_ptr<GPUAdapter>>
-  requestAdapter(std::shared_ptr<GPURequestAdapterOptions> options);
+  std::future<std::variant<std::nullptr_t, std::shared_ptr<GPUAdapter>>>
+  requestAdapter(
+      std::optional<std::shared_ptr<GPURequestAdapterOptions>> options);
   wgpu::TextureFormat getPreferredCanvasFormat();
 
+  std::unordered_set<std::string> getWgslLanguageFeatures();
+
   void loadHybridMethods() override {
     registerHybridGetter("__brand", &GPU::getBrand, this);
     registerHybridMethod("requestAdapter", &GPU::requestAdapter, this);
     registerHybridMethod("getPreferredCanvasFormat",
                          &GPU::getPreferredCanvasFormat, this);
+    registerHybridGetter("wgslLanguageFeatures", &GPU::getWgslLanguageFeatures,
+                         this);
   }
 
+  inline const wgpu::Instance get() { return _instance; }
+
 private:
   wgpu::Instance _instance;
+  std::shared_ptr<AsyncRunner> _async;
 };
+
 } // namespace rnwgpu

package/cpp/rnwgpu/api/GPUAdapter.cpp

@@ -1,17 +1,71 @@
-// GPUAdapter.cpp
-
 #include "GPUAdapter.h"
+
+#include <string>
 #include <utility>
+#include <vector>
+
+#include "Convertors.h"
+
+#include "GPUFeatures.h"
+#include "WGPULogger.h"
 
 namespace rnwgpu {
 
-std::future<std::shared_ptr<GPUDevice>>
-GPUAdapter::requestDevice(std::shared_ptr<GPUDeviceDescriptor> descriptor) {
-  return std::async(std::launch::async, [this, descriptor]() {
+std::future<std::shared_ptr<GPUDevice>> GPUAdapter::requestDevice(
+    std::optional<std::shared_ptr<GPUDeviceDescriptor>> descriptor) {
+  return std::async(std::launch::async, [this,
+                                         descriptor = std::move(descriptor)]() {
     wgpu::Device device = nullptr;
-    auto aDescriptor = descriptor->getInstance();
+    wgpu::DeviceDescriptor aDescriptor;
+    Convertor conv;
+    if (!conv(aDescriptor, descriptor)) {
+      throw std::runtime_error("Failed to convert GPUDeviceDescriptor");
+    }
+    wgpu::DeviceLostCallbackInfo info = {
+        .callback = [](WGPUDevice const *device, WGPUDeviceLostReason reason,
+                       char const *message, void *userdata) {
+          const char *lostReason = "";
+          switch (reason) {
+          case WGPUDeviceLostReason_Destroyed:
+            lostReason = "Destroyed";
+            break;
+          case WGPUDeviceLostReason_Unknown:
+            lostReason = "Unknown";
+            break;
+          default:
+            lostReason = "Unknown";
+          }
+          Logger::logToConsole("GPU Device Lost (%s): %s", lostReason, message);
+        }};
+    aDescriptor.deviceLostCallbackInfo = info;
+    wgpu::UncapturedErrorCallbackInfo errorInfo;
+    errorInfo.userdata = static_cast<void *>(_creationRuntime);
+    errorInfo.callback = [](WGPUErrorType type, const char *message,
+                            void *userdata) {
+      auto creationRuntime = static_cast<jsi::Runtime *>(userdata);
+      const char *errorType = "";
+      switch (type) {
+      case WGPUErrorType_Validation:
+        errorType = "Validation";
+        break;
+      case WGPUErrorType_OutOfMemory:
+        errorType = "Out of Memory";
+        break;
+      case WGPUErrorType_Internal:
+        errorType = "Internal";
+        break;
+      case WGPUErrorType_Unknown:
+        errorType = "Unknown";
+        break;
+      default:
+        errorType = "Unknown";
+      }
+      std::string fullMessage = std::string(errorType) + ": " + message;
+      Logger::errorToJavascriptConsole(*creationRuntime, fullMessage.c_str());
+    };
+    aDescriptor.uncapturedErrorCallbackInfo = errorInfo;
     _instance.RequestDevice(
-        aDescriptor,
+        &aDescriptor,
         [](WGPURequestDeviceStatus status, WGPUDevice cDevice,
            const char *message, void *userdata) {
           if (message != nullptr) {
@@ -26,8 +80,68 @@ GPUAdapter::requestDevice(std::shared_ptr<GPUDeviceDescriptor> descriptor) {
     if (!device) {
       throw std::runtime_error("Failed to request device");
     }
-    return std::make_shared<GPUDevice>(std::move(device), descriptor->label);
+    device.SetLoggingCallback(
+        [](WGPULoggingType type, const char *message, void *userdata) {
+          auto creationRuntime = static_cast<jsi::Runtime *>(userdata);
+          const char *logLevel = "";
+          switch (type) {
+          case WGPULoggingType_Warning:
+            logLevel = "Warning";
+            Logger::warnToJavascriptConsole(*creationRuntime, message);
+            break;
+          case WGPULoggingType_Error:
+            logLevel = "Error";
+            Logger::errorToJavascriptConsole(*creationRuntime, message);
+            break;
+          case WGPULoggingType_Verbose:
+            logLevel = "Verbose";
+          case WGPULoggingType_Info:
+            logLevel = "Info";
+          default:
+            logLevel = "Unknown";
+            Logger::logToConsole("%s: %s", logLevel, message);
+          }
+        },
+        _creationRuntime);
+    std::string label =
+        descriptor.has_value() ? descriptor.value()->label.value_or("") : "";
+    return std::make_shared<GPUDevice>(std::move(device), _async, label);
   });
 }
 
+std::unordered_set<std::string> GPUAdapter::getFeatures() {
+  size_t count = _instance.EnumerateFeatures(nullptr);
+  std::vector<wgpu::FeatureName> features(count);
+  _instance.EnumerateFeatures(features.data());
+  std::unordered_set<std::string> result;
+  for (auto feature : features) {
+    std::string name;
+    convertEnumToJSUnion(feature, &name);
+    if (name != "") {
+      result.insert(name);
+    }
+  }
+  return result;
+}
+
+std::shared_ptr<GPUSupportedLimits> GPUAdapter::getLimits() {
+  wgpu::SupportedLimits 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);
+}
+
+bool GPUAdapter::getIsFallbackAdapter() {
+  wgpu::AdapterProperties adapterProperties = {};
+  _instance.GetProperties(&adapterProperties);
+  return adapterProperties.adapterType == wgpu::AdapterType::DiscreteGPU;
+}
+
 } // namespace rnwgpu

package/cpp/rnwgpu/api/GPUAdapter.h

@@ -3,16 +3,20 @@
 #include <future>
 #include <memory>
 #include <string>
+#include <unordered_set>
 
 #include "Unions.h"
-#include <RNFHybridObject.h>
 
-#include "MutableBuffer.h"
+#include "RNFHybridObject.h"
+
+#include "AsyncRunner.h"
 
 #include "webgpu/webgpu_cpp.h"
 
+#include "GPUAdapterInfo.h"
 #include "GPUDevice.h"
 #include "GPUDeviceDescriptor.h"
+#include "GPUSupportedLimits.h"
 
 namespace rnwgpu {
 
@@ -20,21 +24,36 @@ namespace m = margelo;
 
 class GPUAdapter : public m::HybridObject {
 public:
-  explicit GPUAdapter(wgpu::Adapter instance)
-      : HybridObject("GPUAdapter"), _instance(instance) {}
+  explicit GPUAdapter(wgpu::Adapter instance,
+                      std::shared_ptr<AsyncRunner> async)
+      : HybridObject("GPUAdapter"), _instance(instance), _async(async) {}
 
 public:
   std::string getBrand() { return _name; }
 
   std::future<std::shared_ptr<GPUDevice>>
-  requestDevice(std::shared_ptr<GPUDeviceDescriptor> options);
+  requestDevice(std::optional<std::shared_ptr<GPUDeviceDescriptor>> descriptor);
+
+  std::unordered_set<std::string> getFeatures();
+  std::shared_ptr<GPUSupportedLimits> getLimits();
+  std::shared_ptr<GPUAdapterInfo> getInfo();
+  bool getIsFallbackAdapter();
 
   void loadHybridMethods() override {
     registerHybridGetter("__brand", &GPUAdapter::getBrand, this);
     registerHybridMethod("requestDevice", &GPUAdapter::requestDevice, this);
+    registerHybridGetter("features", &GPUAdapter::getFeatures, this);
+    registerHybridGetter("limits", &GPUAdapter::getLimits, this);
+    registerHybridGetter("info", &GPUAdapter::getInfo, this);
+    registerHybridGetter("isFallbackAdapter", &GPUAdapter::getIsFallbackAdapter,
+                         this);
   }
 
+  inline const wgpu::Adapter get() { return _instance; }
+
 private:
   wgpu::Adapter _instance;
+  std::shared_ptr<AsyncRunner> _async;
 };
+
 } // namespace rnwgpu

package/cpp/rnwgpu/api/GPUAdapterInfo.h

@@ -1,13 +1,13 @@
 #pragma once
 
-#include <future>
-#include <memory>
 #include <string>
+#include <utility>
 
 #include "Unions.h"
-#include <RNFHybridObject.h>
 
-#include "MutableBuffer.h"
+#include "RNFHybridObject.h"
+
+#include "AsyncRunner.h"
 
 #include "webgpu/webgpu_cpp.h"
 
@@ -17,17 +17,29 @@ namespace m = margelo;
 
 class GPUAdapterInfo : public m::HybridObject {
 public:
-  explicit GPUAdapterInfo(wgpu::AdapterInfo instance)
-      : HybridObject("GPUAdapterInfo"), _instance(instance) {}
+  explicit GPUAdapterInfo(wgpu::AdapterInfo &instance)
+      : HybridObject("GPUAdapterInfo"), _instance(std::move(instance)) {}
 
 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; }
+
   void loadHybridMethods() override {
     registerHybridGetter("__brand", &GPUAdapterInfo::getBrand, this);
+
+    registerHybridGetter("vendor", &GPUAdapterInfo::getVendor, this);
+    registerHybridGetter("architecture", &GPUAdapterInfo::getArchitecture,
+                         this);
+    registerHybridGetter("device", &GPUAdapterInfo::getDevice, this);
+    registerHybridGetter("description", &GPUAdapterInfo::getDescription, this);
   }
 
 private:
   wgpu::AdapterInfo _instance;
 };
-} // namespace rnwgpu
+
+} // 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

@@ -1,13 +1,12 @@
 #pragma once
 
-#include <future>
-#include <memory>
 #include <string>
 
 #include "Unions.h"
-#include <RNFHybridObject.h>
 
-#include "MutableBuffer.h"
+#include "RNFHybridObject.h"
+
+#include "AsyncRunner.h"
 
 #include "webgpu/webgpu_cpp.h"
 
@@ -24,15 +23,23 @@ public:
   std::string getBrand() { return _name; }
 
   std::string getLabel() { return _label; }
+  void setLabel(const std::string &label) {
+    _label = label;
+    _instance.SetLabel(_label.c_str());
+  }
 
   void loadHybridMethods() override {
     registerHybridGetter("__brand", &GPUBindGroup::getBrand, this);
 
     registerHybridGetter("label", &GPUBindGroup::getLabel, this);
+    registerHybridSetter("label", &GPUBindGroup::setLabel, this);
   }
 
+  inline const wgpu::BindGroup get() { return _instance; }
+
 private:
   wgpu::BindGroup _instance;
   std::string _label;
 };
+
 } // namespace rnwgpu

package/cpp/rnwgpu/api/GPUBindGroupLayout.h

@@ -1,13 +1,12 @@
 #pragma once
 
-#include <future>
-#include <memory>
 #include <string>
 
 #include "Unions.h"
-#include <RNFHybridObject.h>
 
-#include "MutableBuffer.h"
+#include "RNFHybridObject.h"
+
+#include "AsyncRunner.h"
 
 #include "webgpu/webgpu_cpp.h"
 
@@ -25,15 +24,23 @@ public:
   std::string getBrand() { return _name; }
 
   std::string getLabel() { return _label; }
+  void setLabel(const std::string &label) {
+    _label = label;
+    _instance.SetLabel(_label.c_str());
+  }
 
   void loadHybridMethods() override {
     registerHybridGetter("__brand", &GPUBindGroupLayout::getBrand, this);
 
     registerHybridGetter("label", &GPUBindGroupLayout::getLabel, this);
+    registerHybridSetter("label", &GPUBindGroupLayout::setLabel, this);
   }
 
+  inline const wgpu::BindGroupLayout get() { return _instance; }
+
 private:
   wgpu::BindGroupLayout _instance;
   std::string _label;
 };
+
 } // namespace rnwgpu

package/cpp/rnwgpu/api/GPUBuffer.cpp

@@ -1,16 +1,91 @@
 #include "GPUBuffer.h"
 
+#include <utility>
+
+#include "Convertors.h"
+
 namespace rnwgpu {
 
-std::shared_ptr<MutableJSIBuffer>
-GPUBuffer::getMappedRange(std::optional<size_t> offset,
-                          std::optional<size_t> size) {
-  auto aOffset = offset.value_or(0);
-  auto aSize = size.value_or(WGPU_WHOLE_MAP_SIZE);
-  auto result = _instance.GetMappedRange(aOffset, aSize);
-  return std::make_shared<MutableJSIBuffer>(result, _instance.GetSize());
+std::shared_ptr<ArrayBuffer>
+GPUBuffer::getMappedRange(std::optional<size_t> o, std::optional<size_t> size) {
+  auto offset = o.value_or(0);
+  uint64_t s = size.has_value() ? size.value() : (_instance.GetSize() - offset);
+
+  uint64_t start = offset;
+  uint64_t end = offset + s;
+  // for (auto& mapping : mappings_) {
+  //     if (mapping.Intersects(start, end)) {
+  //         Errors::OperationError(env).ThrowAsJavaScriptException();
+  //         return {};
+  //     }
+  // }
+
+  auto *ptr =
+      (_instance.GetUsage() & wgpu::BufferUsage::MapWrite)
+          ? _instance.GetMappedRange(offset, s)
+          : const_cast<void *>(_instance.GetConstMappedRange(offset, s));
+  if (!ptr) {
+    throw std::runtime_error("Failed to get getMappedRange");
+  }
+  auto array_buffer = std::make_shared<ArrayBuffer>(ptr, s, 1);
+  // TODO(crbug.com/dawn/1135): Ownership here is the wrong way around.
+  // mappings_.emplace_back(Mapping{start, end,
+  // Napi::Persistent(array_buffer)});
+  return array_buffer;
+}
+
+void GPUBuffer::destroy() { _instance.Destroy(); }
+
+std::future<void> GPUBuffer::mapAsync(uint64_t modeIn,
+                                      std::optional<uint64_t> offset,
+                                      std::optional<uint64_t> size) {
+  Convertor conv;
+  wgpu::MapMode mode;
+  if (!conv(mode, modeIn)) {
+    throw std::runtime_error("Couldn't get MapMode");
+  }
+  uint64_t rangeSize = size.has_value()
+                           ? size.value()
+                           : (_instance.GetSize() - offset.value_or(0));
+  return _async->runAsync([=] {
+    // for (auto& mapping : mappings) {
+    //   if (mapping.Intersects(start, end)) {
+    //     promise.set_exception(std::make_exception_ptr(std::runtime_error("Buffer
+    //     is already mapped"))); return future;
+    //   }
+    // }
+    wgpu::BufferMapCallbackInfo callback;
+    callback.mode = wgpu::CallbackMode::WaitAnyOnly;
+    callback.callback = [](WGPUBufferMapAsyncStatus status, void *userdata) {
+      switch (status) {
+      case WGPUBufferMapAsyncStatus_Success:
+        break;
+      case WGPUBufferMapAsyncStatus_InstanceDropped:
+        throw std::runtime_error("WGPUBufferMapAsyncStatus_InstanceDropped");
+        break;
+      case WGPUBufferMapAsyncStatus_ValidationError:
+        throw std::runtime_error("WGPUBufferMapAsyncStatus_ValidationError");
+        break;
+      default:
+        throw std::runtime_error("WGPUBufferMapAsyncStatus: " +
+                                 std::to_string(status));
+        break;
+      }
+    };
+    return _instance.MapAsync(mode, offset.value_or(0), rangeSize, callback);
+  });
 }
 
 void GPUBuffer::unmap() { _instance.Unmap(); }
 
+uint64_t GPUBuffer::getSize() { return _instance.GetSize(); }
+
+double GPUBuffer::getUsage() {
+  return static_cast<double>(_instance.GetUsage());
+}
+
+wgpu::BufferMapState GPUBuffer::getMapState() {
+  return _instance.GetMapState();
+}
+
 } // namespace rnwgpu