react-native-wgpu 0.1.7 → 0.1.9

package/android/cpp/cpp-adapter.cpp

@@ -27,52 +27,30 @@ extern "C" JNIEXPORT void JNICALL Java_com_webgpu_WebGPUModule_initializeNative(
                                                       platformContext);
 }
 
-extern "C" JNIEXPORT void JNICALL
-Java_com_webgpu_WebGPUModule_createSurfaceContext(JNIEnv *env, jobject thiz,
-                                                  jlong jsRuntime,
-                                                  jint contextId) {
-  auto canvas = manager->surfacesRegistry.getSurface(contextId);
-  if (canvas == nullptr) {
-    throw std::runtime_error("Surface haven't configured yet");
-  }
-
-  auto runtime = reinterpret_cast<facebook::jsi::Runtime *>(jsRuntime);
-  auto webGPUContextRegistry = runtime->global().getPropertyAsObject(
-      *runtime, "__WebGPUContextRegistry");
-  if (webGPUContextRegistry.hasProperty(*runtime,
-                                        std::to_string(contextId).c_str())) {
-    // Context already exists, just update width/height
-    auto prop =
-        webGPUContextRegistry
-            .getPropertyAsObject(*runtime, std::to_string(contextId).c_str())
-            .asHostObject<rnwgpu::Canvas>(*runtime);
-    prop->setWidth(canvas->getWidth());
-    prop->setHeight(canvas->getHeight());
-    return;
-  }
-  webGPUContextRegistry.setProperty(
-      *runtime, std::to_string(contextId).c_str(),
-      facebook::jsi::Object::createFromHostObject(*runtime, canvas));
-}
-
 extern "C" JNIEXPORT void JNICALL Java_com_webgpu_WebGPUView_onSurfaceChanged(
     JNIEnv *env, jobject thiz, jobject surface, jint contextId, jfloat width,
     jfloat height) {
-  manager->surfacesRegistry.updateSurface(contextId, width, height);
+  auto &registry = rnwgpu::SurfaceRegistry::getInstance();
+  auto info = registry.getSurface(contextId);
+  registry.setSize(contextId, static_cast<int>(width),
+                   static_cast<int>(height));
 }
 
 extern "C" JNIEXPORT void JNICALL Java_com_webgpu_WebGPUView_onSurfaceCreate(
-    JNIEnv *env, jobject thiz, jobject surface, jint contextId, jfloat width,
+    JNIEnv *env, jobject thiz, jobject jSurface, jint contextId, jfloat width,
     jfloat height) {
-  auto window = ANativeWindow_fromSurface(env, surface);
+  auto window = ANativeWindow_fromSurface(env, jSurface);
   // ANativeWindow_acquire(window);
-  manager->surfacesRegistry.addSurface(contextId, window, width, height);
+  auto &registry = rnwgpu::SurfaceRegistry::getInstance();
+  registry.createSurface(contextId, window, static_cast<int>(width),
+                         static_cast<int>(height), manager->_platformContext);
 }
 
 extern "C" JNIEXPORT void JNICALL Java_com_webgpu_WebGPUView_onSurfaceDestroy(
     JNIEnv *env, jobject thiz, jint contextId) {
-  auto canvas = manager->surfacesRegistry.getSurface(contextId);
+  auto &registry = rnwgpu::SurfaceRegistry::getInstance();
+  auto canvas = registry.getSurface(contextId);
   ANativeWindow_release(
-      reinterpret_cast<ANativeWindow *>(canvas->getSurface()));
-  manager->surfacesRegistry.removeSurface(contextId);
+      reinterpret_cast<ANativeWindow *>(canvas.nativeSurface));
+  registry.removeSurface(contextId);
 }

package/android/src/main/java/com/webgpu/WebGPUModule.java

@@ -24,9 +24,6 @@ public class WebGPUModule extends NativeWebGPUModuleSpec {
       System.loadLibrary("react-native-wgpu"); // Load the C++ library
   }
 
-  private final Object mContextLock = new Object();
-  private final Set<Integer> mSurfaceContextsIds = new HashSet<>();
-
   public WebGPUModule(ReactApplicationContext reactContext) {
     super(reactContext);
     // Initialize the C++ module
@@ -50,38 +47,4 @@ public class WebGPUModule extends NativeWebGPUModuleSpec {
   @OptIn(markerClass = FrameworkAPI.class)
   @DoNotStrip
   private native void initializeNative(long jsRuntime, CallInvokerHolderImpl jsInvoker, BlobModule blobModule);
-
-  @ReactMethod(isBlockingSynchronousMethod = true)
-  public boolean createSurfaceContext(double contextId) {
-    waitForNativeSurface((int)contextId);
-
-    ReactApplicationContext context = getReactApplicationContext();
-    JavaScriptContextHolder jsContext = context.getJavaScriptContextHolder();
-    createSurfaceContext(jsContext.get(), (int)contextId);
-    return true;
-  }
-
-  @DoNotStrip
-  private native void createSurfaceContext(long jsRuntime, int contextId);
-
-  private void waitForNativeSurface(Integer contextId) {
-    synchronized (mContextLock) {
-      while (!mSurfaceContextsIds.contains(contextId)) {
-        try {
-          mContextLock.wait();
-        } catch (InterruptedException e) {
-          Log.e("RNWebGPU", "Unable to create a context");
-          return;
-        }
-      }
-    }
-  }
-
-  protected void onSurfaceCreated(Integer contextId) {
-    synchronized (mContextLock) {
-      mSurfaceContextsIds.add(contextId);
-      mContextLock.notifyAll();
-    }
-  }
-
 }

package/android/src/main/java/com/webgpu/WebGPUView.java

@@ -41,7 +41,6 @@ public class WebGPUView extends SurfaceView implements SurfaceHolder.Callback {
     float width = getWidth() / density;
     float height = getHeight() / density;
     onSurfaceCreate(holder.getSurface(), mContextId, width, height);
-    mModule.onSurfaceCreated(mContextId);
   }
 
   @Override

package/android/src/main/java/com/webgpu/WebGPUViewPackage.java

@@ -21,6 +21,6 @@ public class WebGPUViewPackage implements ReactPackage {
 
   @Override
   public List<NativeModule> createNativeModules(ReactApplicationContext reactContext) {
-      return Arrays.asList(new WebGPUModule(reactContext));
+      return List.of(new WebGPUModule(reactContext));
   }
 }

package/cpp/rnwgpu/RNWebGPUManager.h

@@ -27,11 +27,11 @@ public:
                   std::shared_ptr<PlatformContext> platformContext);
   ~RNWebGPUManager();
 
-  SurfaceRegistry surfacesRegistry;
-
 private:
   jsi::Runtime *_jsRuntime;
   std::shared_ptr<facebook::react::CallInvoker> _jsCallInvoker;
+
+public:
   std::shared_ptr<PlatformContext> _platformContext;
 };
 

package/cpp/rnwgpu/SurfaceRegistry.h

@@ -1,33 +1,168 @@
 #pragma once
 
 #include <memory>
+#include <shared_mutex>
 #include <unordered_map>
 
 #include "webgpu/webgpu_cpp.h"
 
-#include "Canvas.h"
-
 namespace rnwgpu {
 
+struct ISize {
+  int width;
+  int height;
+};
+
+struct SurfaceInfo {
+  void *nativeSurface = nullptr;
+  wgpu::Surface surface;
+  int width;
+  int height;
+  wgpu::Texture texture;
+  wgpu::Instance gpu;
+  wgpu::SurfaceConfiguration config;
+
+  void flushTextureToSurface() {
+    // 1.a flush texture to the onscreen surface
+    if (texture) {
+      wgpu::CommandEncoderDescriptor encoderDesc;
+      auto device = config.device;
+      wgpu::CommandEncoder encoder = device.CreateCommandEncoder(&encoderDesc);
+
+      wgpu::ImageCopyTexture sourceTexture = {};
+      sourceTexture.texture = texture;
+
+      wgpu::ImageCopyTexture destinationTexture = {};
+      wgpu::SurfaceTexture surfaceTexture;
+      surface.GetCurrentTexture(&surfaceTexture);
+      destinationTexture.texture = surfaceTexture.texture;
+
+      wgpu::Extent3D size = {sourceTexture.texture.GetWidth(),
+                             sourceTexture.texture.GetHeight(),
+                             sourceTexture.texture.GetDepthOrArrayLayers()};
+
+      encoder.CopyTextureToTexture(&sourceTexture, &destinationTexture, &size);
+
+      wgpu::CommandBuffer commands = encoder.Finish();
+      wgpu::Queue queue = device.GetQueue();
+      queue.Submit(1, &commands);
+      texture = nullptr;
+    }
+  }
+};
+
 class SurfaceRegistry {
-  std::unordered_map<int, std::shared_ptr<Canvas>> _registry;
+private:
+  std::unordered_map<int, SurfaceInfo> _registry;
+  mutable std::shared_mutex _mutex;
+
+  // Private constructor to prevent instantiation
+  SurfaceRegistry() {}
+
+  void updateSurface(const int contextId, SurfaceInfo &info) {
+    auto it = _registry.find(contextId);
+    if (it != _registry.end()) {
+      it->second = info;
+    }
+  }
+
+  // bool hasOnScreenSurface(const int contextId) const {
+  //   std::shared_lock<std::shared_mutex> lock(_mutex);
+  //   auto it = _registry.find(contextId);
+  //   if (it != _registry.end()) {
+  //     return it->second.nativeSurface != nullptr;
+  //   }
+  //   return false;
+  // }
+
+  bool hasSurfaceInfo(const int contextId) const {
+    return _registry.find(contextId) != _registry.end();
+  }
 
 public:
-  void addSurface(const int contextId, void *surface, float width,
-                  float height) {
-    _registry[contextId] = std::make_shared<Canvas>(surface, width, height);
+  // Delete copy constructor and assignment operator
+  SurfaceRegistry(const SurfaceRegistry &) = delete;
+  SurfaceRegistry &operator=(const SurfaceRegistry &) = delete;
+
+  // Static method to get the singleton instance
+  static SurfaceRegistry &getInstance() {
+    static SurfaceRegistry instance;
+    return instance;
+  }
+
+  void removeSurface(const int contextId) {
+    std::unique_lock<std::shared_mutex> lock(_mutex);
+    _registry.erase(contextId);
   }
 
-  std::shared_ptr<Canvas> getSurface(const int contextId) {
-    return _registry[contextId];
+  std::optional<SurfaceInfo> getSurfaceMaybe(const int contextId) {
+    std::unique_lock<std::shared_mutex> lock(_mutex);
+    auto it = _registry.find(contextId);
+    if (it != _registry.end()) {
+      return it->second;
+    }
+    return std::nullopt;
   }
 
-  void removeSurface(const int contextId) { _registry.erase(contextId); }
+  SurfaceInfo getSurface(const int contextId) const {
+    auto it = _registry.find(contextId);
+    if (it != _registry.end()) {
+      return it->second;
+    }
+    throw std::out_of_range("Surface not found");
+  }
+
+  void setSize(const int contextId, int width, int height) {
+    std::unique_lock<std::shared_mutex> lock(_mutex);
+    auto it = _registry.find(contextId);
+    if (it != _registry.end()) {
+      it->second.width = width;
+      it->second.height = height;
+    }
+  }
+
+  void
+  configureOffscreenSurface(const int contextId, wgpu::Instance gpu,
+                            wgpu::Texture texture,
+                            wgpu::SurfaceConfiguration surfaceConfiguration) {
+    SurfaceInfo info;
+    info.width = surfaceConfiguration.width;
+    info.height = surfaceConfiguration.height;
+    info.texture = texture;
+    info.gpu = gpu;
+    info.config = surfaceConfiguration;
+    std::unique_lock<std::shared_mutex> lock(_mutex);
+    _registry[contextId] = info;
+  }
 
-  void updateSurface(const int contextId, float width, float height) {
-    if (_registry.find(contextId) != _registry.end()) {
-      _registry[contextId]->setClientWidth(width);
-      _registry[contextId]->setClientHeight(height);
+  void createSurface(const int contextId, void *nativeSurface, int width,
+                     int height,
+                     std::shared_ptr<PlatformContext> platformContext) {
+    std::unique_lock<std::shared_mutex> lock(_mutex);
+    // 1. The scene has already be drawn offscreen
+    if (hasSurfaceInfo(contextId)) {
+      auto info = getSurface(contextId);
+      auto surface =
+          platformContext->makeSurface(info.gpu, nativeSurface, width, height);
+      info.config.usage = info.config.usage | wgpu::TextureUsage::CopyDst;
+      surface.Configure(&info.config);
+      info.nativeSurface = nativeSurface;
+      info.surface = surface;
+      info.width = width;
+      info.height = height;
+      info.flushTextureToSurface();
+      surface.Present();
+      updateSurface(contextId, info);
+    } else {
+      // 2. The scene has not been drawn offscreen yet, we will draw onscreen
+      // directly
+      rnwgpu::SurfaceInfo info;
+      info.nativeSurface = nativeSurface;
+      info.surface =
+          platformContext->makeSurface(info.gpu, nativeSurface, width, height);
+      info.width = width;
+      info.height = height;
+      _registry[contextId] = info;
     }
   }
 };

package/cpp/rnwgpu/api/Canvas.h

@@ -15,24 +15,24 @@ namespace m = margelo;
 
 class Canvas : public m::HybridObject {
 public:
-  explicit Canvas(void* surface, const float width, const float height)
+  explicit Canvas(void *surface, const int width, const int height)
       : HybridObject("Canvas"), _surface(surface), _width(width),
         _height(height), _clientWidth(width), _clientHeight(height) {}
 
-  float getWidth() { return _width; }
-  float getHeight() { return _height; }
+  int getWidth() { return _width; }
+  int getHeight() { return _height; }
 
-  void setWidth(const float width) { _width = width; }
-  void setHeight(const float height) { _height = height; }
+  void setWidth(const int width) { _width = width; }
+  void setHeight(const int height) { _height = height; }
 
-  float getClientWidth() { return _clientWidth; }
-  float getClientHeight() { return _clientHeight; }
+  int getClientWidth() { return _clientWidth; }
+  int getClientHeight() { return _clientHeight; }
 
-  void setClientWidth(const float width) { _clientWidth = width; }
+  void setClientWidth(const int width) { _clientWidth = width; }
 
-  void setClientHeight(const float height) { _clientHeight = height; }
+  void setClientHeight(const int height) { _clientHeight = height; }
 
-  void* getSurface() { return _surface; }
+  void *getSurface() { return _surface; }
 
   void loadHybridMethods() override {
     registerHybridGetter("surface", &Canvas::getSurface, this);
@@ -45,11 +45,11 @@ public:
   }
 
 private:
-  void* _surface;
-  float _width;
-  float _height;
-  float _clientWidth;
-  float _clientHeight;
+  void *_surface;
+  int _width;
+  int _height;
+  int _clientWidth;
+  int _clientHeight;
 };
 
 } // namespace rnwgpu

package/cpp/rnwgpu/api/GPUCanvasContext.cpp

@@ -23,41 +23,99 @@ void GPUCanvasContext::configure(
   if (!conv(surfaceConfiguration.usage, configuration->usage)) {
     throw std::runtime_error("Error with SurfaceConfiguration");
   }
-  surfaceConfiguration.width = _canvas->getWidth();
-  surfaceConfiguration.height = _canvas->getHeight();
-  _instance.Configure(&surfaceConfiguration);
-  _lastConfig = configuration;
-  _width = _canvas->getWidth();
-  _height = _canvas->getHeight();
+  auto width = _canvas->getWidth();
+  auto height = _canvas->getHeight();
+  surfaceConfiguration.width = width;
+  surfaceConfiguration.height = height;
+  _surfaceConfiguration = surfaceConfiguration;
+  // Are we onscreen now?
+  auto &registry = rnwgpu::SurfaceRegistry::getInstance();
+  auto infoVal = registry.getSurfaceMaybe(_contextId);
+  if (infoVal.has_value()) {
+    auto info = infoVal.value();
+    if (info.surface) {
+      _instance = info.surface;
+      _offscreenSurface = nullptr;
+    }
+  }
+
+  if (_instance) {
+    _instance.Configure(&surfaceConfiguration);
+  } else {
+    _offscreenSurface->configure(_surfaceConfiguration);
+    // Add texture to the surface registry, when the native surface is
+    // available, we will copy its content there This only makes sense if the on
+    // screen native surface is not available yet
+    registry.configureOffscreenSurface(_contextId, _gpu->get(),
+                                       _offscreenSurface->getCurrentTexture(),
+                                       _surfaceConfiguration);
+  }
 }
 
 void GPUCanvasContext::unconfigure() {
-  _lastConfig = nullptr;
-  _width = _canvas->getWidth();
-  _height = _canvas->getHeight();
-  _instance.Unconfigure();
+  if (_instance) {
+    _instance.Unconfigure();
+  } else if (_offscreenSurface) {
+    _offscreenSurface = nullptr;
+  }
 }
 
 std::shared_ptr<GPUTexture> GPUCanvasContext::getCurrentTexture() {
-  // we need to reconfigure if the size of the canvas has changed
-  if (_width != _canvas->getWidth() || _height != _canvas->getHeight()) {
-    configure(_lastConfig);
-  }
-  wgpu::SurfaceTexture surfaceTexture;
-  _instance.GetCurrentTexture(&surfaceTexture);
-  auto texture = surfaceTexture.texture;
-  if (texture == nullptr) {
-    throw std::runtime_error("Couldn't get current texture");
-  }
-  // Default canvas texture label is ""
-  return std::make_shared<GPUTexture>(texture, "");
+  auto width = _canvas->getWidth();
+  auto height = _canvas->getHeight();
+
+  auto prevWidth = _surfaceConfiguration.width;
+  auto prevHeight = _surfaceConfiguration.height;
+  auto sizeHasChanged = prevWidth != width || prevHeight != height;
+  _surfaceConfiguration.width = width;
+  _surfaceConfiguration.height = height;
+  // Get onscreen texture
+  if (_instance) {
+    // Did the surface resize?
+    if (sizeHasChanged) {
+      _instance.Configure(&_surfaceConfiguration);
+    }
+    // Get onscreen texture
+    wgpu::SurfaceTexture surfaceTexture;
+    _instance.GetCurrentTexture(&surfaceTexture);
+    auto texture = surfaceTexture.texture;
+    if (texture == nullptr) {
+      throw std::runtime_error("Couldn't get current texture");
+    }
+    return std::make_shared<GPUTexture>(texture, "");
+  } else {
+    // Did the surface resize?
+    if (sizeHasChanged) {
+      _offscreenSurface->configure(_surfaceConfiguration);
+    }
+    // Get offscreen texture
+    auto tex = _offscreenSurface->getCurrentTexture();
+    return std::make_shared<GPUTexture>(tex, "");
+  }
 }
 
 void GPUCanvasContext::present() {
 #ifdef __APPLE__
   dawn::native::metal::WaitForCommandsToBeScheduled(_device.Get());
 #endif
-  _instance.Present();
+  auto &registry = rnwgpu::SurfaceRegistry::getInstance();
+  auto infoVal = registry.getSurfaceMaybe(_contextId);
+  if (infoVal.has_value()) {
+    auto info = infoVal.value();
+    // We are starting a new frame, this is a good time to update the client
+    _canvas->setClientWidth(info.width);
+    _canvas->setClientHeight(info.height);
+    if (_offscreenSurface) {
+      // Are we onscreen now?
+      if (info.surface) {
+        _instance = info.surface;
+        _offscreenSurface = nullptr;
+      }
+    }
+  }
+  if (_instance) {
+    _instance.Present();
+  }
 }
 
 } // namespace rnwgpu

package/cpp/rnwgpu/api/GPUCanvasContext.h

@@ -12,8 +12,10 @@
 #include "AsyncRunner.h"
 
 #include "Canvas.h"
+#include "GPU.h"
 #include "GPUCanvasConfiguration.h"
 #include "GPUTexture.h"
+#include "OffscreenSurface.h"
 #include "SurfaceRegistry.h"
 
 #ifdef __APPLE__
@@ -38,9 +40,13 @@ namespace m = margelo;
 
 class GPUCanvasContext : public m::HybridObject {
 public:
-  explicit GPUCanvasContext(wgpu::Surface instance,
-                            std::shared_ptr<Canvas> canvas)
-      : HybridObject("GPUCanvasContext"), _instance(instance), _canvas(canvas) {
+  // TODO: platformContext no necessary here
+  GPUCanvasContext(std::shared_ptr<GPU> gpu, int contextId, int width,
+                   int height)
+      : HybridObject("GPUCanvasContext"), _contextId(contextId),
+        _gpu(std::move(gpu)) {
+    _canvas = std::make_shared<Canvas>(nullptr, width, height);
+    _offscreenSurface = std::make_shared<OffscreenSurface>(_canvas);
   }
 
 public:
@@ -65,12 +71,15 @@ public:
   void present();
 
 private:
-  wgpu::Surface _instance;
+  std::shared_ptr<OffscreenSurface> _offscreenSurface;
+  wgpu::Surface _instance = nullptr;
   wgpu::Device _device;
   std::shared_ptr<Canvas> _canvas;
-  std::shared_ptr<GPUCanvasConfiguration> _lastConfig;
-  float _width;
-  float _height;
+  int _contextId;
+
+  std::shared_ptr<GPU> _gpu;
+  // TODO: do we need this or can it be stored in the surface registry?
+  wgpu::SurfaceConfiguration _surfaceConfiguration;
 };
 
 } // namespace rnwgpu

package/cpp/rnwgpu/api/GPUDevice.cpp

@@ -69,14 +69,17 @@ std::shared_ptr<GPUShaderModule> GPUDevice::createShaderModule(
     std::shared_ptr<GPUShaderModuleDescriptor> descriptor) {
   wgpu::ShaderModuleWGSLDescriptor wgsl_desc{};
   wgpu::ShaderModuleDescriptor sm_desc{};
-  wgsl_desc.code = descriptor->code.c_str();
-  sm_desc.label = descriptor->label.value_or("").c_str();
+  Convertor conv;
+  if (!conv(wgsl_desc.code, descriptor->code) ||
+      !conv(sm_desc.label, descriptor->label)) {
+    return {};
+  }
   sm_desc.nextInChain = &wgsl_desc;
   if (descriptor->code.find('\0') != std::string::npos) {
     return std::make_shared<GPUShaderModule>(
         _instance.CreateErrorShaderModule(
             &sm_desc, "The WGSL shader contains an illegal character '\\0'"),
-        _async, descriptor->label.value_or(""));
+        _async, sm_desc.label);
   }
   auto module = _instance.CreateShaderModule(&sm_desc);
   return std::make_shared<GPUShaderModule>(module, _async,

package/cpp/rnwgpu/api/OffscreenSurface.h

@@ -0,0 +1,49 @@
+#pragma once
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "Canvas.h"
+
+namespace rnwgpu {
+
+class OffscreenSurface {
+public:
+  explicit OffscreenSurface(std::shared_ptr<Canvas> canvas)
+      : _canvas(std::move(canvas)) {
+#if defined(__ANDROID__)
+    _textureFormat = wgpu::TextureFormat::RGBA8Unorm;
+#else
+    _textureFormat = wgpu::TextureFormat::BGRA8Unorm;
+#endif // defined(__ANDROID__)
+  }
+
+  void configure(const wgpu::SurfaceConfiguration &config) {
+    // Configure the canvas context with the device and format
+    _device = config.device;
+
+    wgpu::TextureDescriptor textureDesc;
+    textureDesc.size.width = _canvas->getWidth();
+    textureDesc.size.height = _canvas->getHeight();
+    textureDesc.format = _textureFormat;
+    textureDesc.usage = wgpu::TextureUsage::RenderAttachment |
+                        wgpu::TextureUsage::CopySrc |
+                        wgpu::TextureUsage::TextureBinding;
+
+    _texture = _device.CreateTexture(&textureDesc);
+  }
+
+  wgpu::Texture getCurrentTexture() {
+    if (!_texture) {
+      throw std::runtime_error("Texture is not configured");
+    }
+    return _texture;
+  }
+
+private:
+  wgpu::TextureFormat _textureFormat;
+  wgpu::Texture _texture = nullptr;
+  wgpu::Device _device;
+  std::shared_ptr<Canvas> _canvas;
+};
+
+} // namespace rnwgpu