react-native-wgpu 0.1.0 → 0.1.2

package/cpp/rnwgpu/ArrayBuffer.h

@@ -0,0 +1,72 @@
+#pragma once
+#include <jsi/jsi.h>
+
+#include <memory>
+
+#include "RNFJSIConverter.h"
+
+namespace rnwgpu {
+
+namespace jsi = facebook::jsi;
+
+struct ArrayBuffer : jsi::MutableBuffer {
+  ArrayBuffer(void *data, size_t size, size_t bytesPerElement)
+      : _data(data), _size(size), _bytesPerElement(bytesPerElement) {}
+
+  ~ArrayBuffer() override {}
+
+  size_t size() const override { return _size; }
+
+  uint8_t *data() override { return static_cast<uint8_t *>(_data); }
+
+  void *_data;
+  size_t _size;
+  size_t _bytesPerElement;
+};
+
+} // namespace rnwgpu
+
+namespace margelo {
+
+static std::shared_ptr<rnwgpu::ArrayBuffer>
+createArrayBufferFromJSI(jsi::Runtime &runtime,
+                         const jsi::ArrayBuffer &arrayBuffer,
+                         size_t bytesPerElement) {
+  auto size = arrayBuffer.size(runtime);
+  return std::make_shared<rnwgpu::ArrayBuffer>(arrayBuffer.data(runtime), size,
+                                               bytesPerElement);
+}
+
+template <> struct JSIConverter<std::shared_ptr<rnwgpu::ArrayBuffer>> {
+  static std::shared_ptr<rnwgpu::ArrayBuffer>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBound) {
+    if (arg.isObject()) {
+      auto obj = arg.getObject(runtime);
+      if (obj.isArrayBuffer(runtime)) {
+        return createArrayBufferFromJSI(runtime, obj.getArrayBuffer(runtime),
+                                        1);
+      }
+      if (obj.hasProperty(runtime, "buffer")) {
+        auto bufferProp = obj.getProperty(runtime, "buffer");
+        if (bufferProp.isObject() &&
+            bufferProp.getObject(runtime).isArrayBuffer(runtime)) {
+          auto buff = bufferProp.getObject(runtime);
+          auto bytesPerElements =
+              obj.getProperty(runtime, "BYTES_PER_ELEMENT").asNumber();
+          return createArrayBufferFromJSI(
+              runtime, buff.getArrayBuffer(runtime),
+              static_cast<size_t>(bytesPerElements));
+        }
+      }
+    }
+    throw std::runtime_error("ArrayBuffer::fromJSI: argument is not an object "
+                             "with an ArrayBuffer 'buffer' property");
+  }
+
+  static jsi::Value toJSI(jsi::Runtime &runtime,
+                          std::shared_ptr<rnwgpu::ArrayBuffer> arg) {
+    return jsi::ArrayBuffer(runtime, arg);
+  }
+};
+
+} // namespace margelo

package/cpp/rnwgpu/PlatformContext.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#include "webgpu/webgpu_cpp.h"
+
+namespace rnwgpu {
+
+class PlatformContext {
+public:
+  PlatformContext() = default;
+  virtual ~PlatformContext() = default;
+
+  virtual wgpu::Surface makeSurface(wgpu::Instance instance, void *surface,
+                                    int width, int height) = 0;
+};
+
+} // namespace rnwgpu

package/cpp/rnwgpu/RNWebGPUManager.cpp

@@ -1,6 +1,8 @@
 #include "RNWebGPUManager.h"
 
 #include "GPU.h"
+#include "Navigator.h"
+
 // Enums
 #include "GPUBufferUsage.h"
 #include "GPUColorWrite.h"
@@ -12,16 +14,16 @@
 #include <utility>
 
 namespace rnwgpu {
+
 RNWebGPUManager::RNWebGPUManager(
     jsi::Runtime *jsRuntime,
-    std::shared_ptr<facebook::react::CallInvoker> jsCallInvoker)
-    : _jsRuntime(jsRuntime), _jsCallInvoker(jsCallInvoker) {
+    std::shared_ptr<facebook::react::CallInvoker> jsCallInvoker,
+    std::shared_ptr<PlatformContext> platformContext)
+    : _jsRuntime(jsRuntime), _jsCallInvoker(jsCallInvoker),
+      _platformContext(platformContext) {
 
-  wgpu::InstanceDescriptor instanceDesc;
-  instanceDesc.features.timedWaitAnyEnable = true;
-  instanceDesc.features.timedWaitAnyMaxCount = 64;
-  auto gpu =
-      std::make_shared<GPU>(std::move(wgpu::CreateInstance(&instanceDesc)));
+  _gpu = std::make_shared<GPU>();
+  auto navigator = std::make_shared<Navigator>(_gpu, _platformContext);
 
   auto bufferUsage = std::make_shared<GPUBufferUsage>();
   _jsRuntime->global().setProperty(
@@ -49,12 +51,15 @@ RNWebGPUManager::RNWebGPUManager(
       jsi::Object::createFromHostObject(*_jsRuntime, std::move(textureUsage)));
 
   _jsRuntime->global().setProperty(
-      *_jsRuntime, "gpu",
-      jsi::Object::createFromHostObject(*_jsRuntime, std::move(gpu)));
+      *_jsRuntime, "navigator",
+      jsi::Object::createFromHostObject(*_jsRuntime, navigator));
 }
 
 RNWebGPUManager::~RNWebGPUManager() {
   _jsRuntime = nullptr;
   _jsCallInvoker = nullptr;
 }
+
+std::shared_ptr<GPU> RNWebGPUManager::getGPU() { return _gpu; }
+
 } // namespace rnwgpu

package/cpp/rnwgpu/RNWebGPUManager.h

@@ -2,6 +2,10 @@
 
 #include <memory>
 
+#include "GPU.h"
+#include "PlatformContext.h"
+#include "SurfaceRegistry.h"
+
 namespace facebook {
 namespace jsi {
 class Runtime;
@@ -19,12 +23,19 @@ namespace react = facebook::react;
 class RNWebGPUManager {
 public:
   RNWebGPUManager(jsi::Runtime *jsRuntime,
-                  std::shared_ptr<facebook::react::CallInvoker> jsCallInvoker);
+                  std::shared_ptr<facebook::react::CallInvoker> jsCallInvoker,
+                  std::shared_ptr<PlatformContext> platformContext);
   ~RNWebGPUManager();
 
+  SurfaceRegistry surfacesRegistry;
+
+  std::shared_ptr<GPU> getGPU();
+
 private:
   jsi::Runtime *_jsRuntime;
   std::shared_ptr<facebook::react::CallInvoker> _jsCallInvoker;
+  std::shared_ptr<PlatformContext> _platformContext;
+  std::shared_ptr<GPU> _gpu;
 };
 
 } // namespace rnwgpu

package/cpp/rnwgpu/SurfaceRegistry.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <memory>
+#include <unordered_map>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "Canvas.h"
+
+namespace rnwgpu {
+
+class SurfaceRegistry {
+  std::unordered_map<int, std::shared_ptr<Canvas>> _registry;
+
+public:
+  void addSurface(const int contextId, void *surface, float width,
+                  float height) {
+    _registry[contextId] = std::make_shared<Canvas>(
+        reinterpret_cast<uint64_t>(surface), width, height);
+  }
+
+  std::shared_ptr<Canvas> getSurface(const int contextId) {
+    return _registry[contextId];
+  }
+
+  void removeSurface(const int contextId) { _registry.erase(contextId); }
+
+  void updateSurface(const int contextId, float width, float height) {
+    if (_registry.find(contextId) != _registry.end()) {
+      _registry[contextId]->setClientWidth(width);
+      _registry[contextId]->setClientHeight(height);
+    }
+  }
+};
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/AsyncRunner.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include "webgpu/webgpu_cpp.h"
+
+#include <future>
+#include <utility>
+
+namespace rnwgpu {
+
+class AsyncRunner {
+public:
+  explicit AsyncRunner(wgpu::Instance *instance) : instance(instance) {}
+
+  template <typename F> auto runAsync(F &&func) {
+    return std::async(
+        std::launch::async, [this, func = std::forward<F>(func)]() {
+          if constexpr (std::is_invocable_v<F, wgpu::Instance *>) {
+            return func(instance);
+          } else {
+            auto future = func();
+            instance->WaitAny(future, UINT64_MAX);
+          }
+        });
+  }
+
+private:
+  wgpu::Instance *instance;
+};
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/Canvas.h

@@ -0,0 +1,55 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "Unions.h"
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "RNFHybridObject.h"
+
+namespace rnwgpu {
+
+namespace m = margelo;
+
+class Canvas : public m::HybridObject {
+public:
+  explicit Canvas(uint64_t surface, const float width, const float height)
+      : HybridObject("Canvas"), _surface(surface), _width(width),
+        _height(height), _clientWidth(width), _clientHeight(height) {}
+
+  float getWidth() { return _width; }
+  float getHeight() { return _height; }
+
+  void setWidth(const float width) { _width = width; }
+  void setHeight(const float height) { _height = height; }
+
+  float getClientWidth() { return _clientWidth; }
+  float getClientHeight() { return _clientHeight; }
+
+  void setClientWidth(const float width) { _clientWidth = width; }
+
+  void setClientHeight(const float height) { _clientHeight = height; }
+
+  uint64_t getSurface() { return _surface; }
+
+  void loadHybridMethods() override {
+    registerHybridGetter("surface", &Canvas::getSurface, this);
+    registerHybridGetter("width", &Canvas::getWidth, this);
+    registerHybridGetter("height", &Canvas::getHeight, this);
+    registerHybridGetter("clientWidth", &Canvas::getClientWidth, this);
+    registerHybridGetter("clientHeight", &Canvas::getClientHeight, this);
+    registerHybridSetter("width", &Canvas::setWidth, this);
+    registerHybridSetter("height", &Canvas::setHeight, this);
+  }
+
+private:
+  uint64_t _surface;
+  float _width;
+  float _height;
+  float _clientWidth;
+  float _clientHeight;
+};
+
+} // namespace rnwgpu