react-native-wgpu 0.1.8 → 0.1.10

package/android/cpp/cpp-adapter.cpp

@@ -27,52 +27,39 @@ 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();
+  registry.getSurfaceInfo(contextId)->resize(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();
+  auto gpu = manager->_gpu;
+  auto surface = manager->_platformContext->makeSurface(
+      gpu, window, static_cast<int>(width), static_cast<int>(height));
+  registry
+      .getSurfaceInfoOrCreate(contextId, gpu, static_cast<int>(width),
+                              static_cast<int>(height))
+      ->switchToOnscreen(window, surface);
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_webgpu_WebGPUView_switchToOffscreenSurface(JNIEnv *env, jobject thiz,
+                                                    jint contextId) {
+  auto &registry = rnwgpu::SurfaceRegistry::getInstance();
+  auto nativeSurface = registry.getSurfaceInfo(contextId)->switchToOffscreen();
+  ANativeWindow_release(reinterpret_cast<ANativeWindow *>(nativeSurface));
 }
 
 extern "C" JNIEXPORT void JNICALL Java_com_webgpu_WebGPUView_onSurfaceDestroy(
     JNIEnv *env, jobject thiz, jint contextId) {
-  auto canvas = manager->surfacesRegistry.getSurface(contextId);
-  ANativeWindow_release(
-      reinterpret_cast<ANativeWindow *>(canvas->getSurface()));
-  manager->surfacesRegistry.removeSurface(contextId);
+  auto &registry = rnwgpu::SurfaceRegistry::getInstance();
+  registry.removeSurfaceInfo(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
@@ -53,10 +52,16 @@ public class WebGPUView extends SurfaceView implements SurfaceHolder.Callback {
   }
 
   @Override
-  public void surfaceDestroyed(@NonNull SurfaceHolder holder) {
+  protected void onDetachedFromWindow() {
+    super.onDetachedFromWindow();
     onSurfaceDestroy(mContextId);
   }
 
+  @Override
+  public void surfaceDestroyed(@NonNull SurfaceHolder holder) {
+    switchToOffscreenSurface(mContextId);
+  }
+
   @DoNotStrip
   private native void onSurfaceCreate(
     Surface surface,
@@ -76,4 +81,7 @@ public class WebGPUView extends SurfaceView implements SurfaceHolder.Callback {
 
   @DoNotStrip
   private native void onSurfaceDestroy(int contextId);
+
+  @DoNotStrip
+  private native void switchToOffscreenSurface(int contextId);
 }

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.cpp

@@ -24,6 +24,7 @@ RNWebGPUManager::RNWebGPUManager(
 
   auto gpu = std::make_shared<GPU>();
   auto rnWebGPU = std::make_shared<RNWebGPU>(gpu, _platformContext);
+  _gpu = gpu->get();
   _jsRuntime->global().setProperty(
       *_jsRuntime, "RNWebGPU",
       jsi::Object::createFromHostObject(*_jsRuntime, rnWebGPU));

package/cpp/rnwgpu/RNWebGPUManager.h

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

package/cpp/rnwgpu/SurfaceRegistry.h

@@ -1,35 +1,217 @@
 #pragma once
 
 #include <memory>
+#include <shared_mutex>
 #include <unordered_map>
 
 #include "webgpu/webgpu_cpp.h"
 
-#include "Canvas.h"
-
 namespace rnwgpu {
 
-class SurfaceRegistry {
-  std::unordered_map<int, std::shared_ptr<Canvas>> _registry;
+struct NativeInfo {
+  void *nativeSurface;
+  int width;
+  int height;
+};
+
+struct Size {
+  int width;
+  int height;
+};
+
+class SurfaceInfo {
+public:
+  SurfaceInfo(wgpu::Instance gpu, int width, int height)
+      : gpu(gpu), width(width), height(height) {}
+
+  void reconfigure(int newWidth, int newHeight) {
+    std::unique_lock<std::shared_mutex> lock(_mutex);
+    config.width = newWidth;
+    config.height = newHeight;
+    _configure();
+  }
+
+  void configure(wgpu::SurfaceConfiguration &newConfig) {
+    std::unique_lock<std::shared_mutex> lock(_mutex);
+    config = newConfig;
+    config.width = width;
+    config.height = height;
+    _configure();
+  }
+
+  void unconfigure() {
+    std::unique_lock<std::shared_mutex> lock(_mutex);
+    if (surface) {
+      surface.Unconfigure();
+    } else {
+      texture = nullptr;
+    }
+  }
+
+  void *switchToOffscreen() {
+    std::unique_lock<std::shared_mutex> lock(_mutex);
+    wgpu::TextureDescriptor textureDesc;
+    textureDesc.usage = wgpu::TextureUsage::RenderAttachment |
+                        wgpu::TextureUsage::CopySrc |
+                        wgpu::TextureUsage::TextureBinding;
+    textureDesc.format = config.format;
+    textureDesc.size.width = config.width;
+    textureDesc.size.height = config.height;
+    texture = config.device.CreateTexture(&textureDesc);
+    surface = nullptr;
+    return nativeSurface;
+  }
+
+  void switchToOnscreen(void *newNativeSurface, wgpu::Surface newSurface) {
+    std::unique_lock<std::shared_mutex> lock(_mutex);
+    nativeSurface = newNativeSurface;
+    surface = std::move(newSurface);
+    // If we are comming from an offscreen context, we need to configure the new
+    // surface
+    if (texture != nullptr) {
+      config.usage = config.usage | wgpu::TextureUsage::CopyDst;
+      _configure();
+      // We flush the offscreen texture to the onscreen one
+      // TODO: there is a faster way to do this without validation?
+      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);
+      surface.Present();
+      texture = nullptr;
+    }
+  }
+
+  void resize(int newWidth, int newHeight) {
+    std::unique_lock<std::shared_mutex> lock(_mutex);
+    width = newWidth;
+    height = newHeight;
+  }
+
+  void present() {
+    std::unique_lock<std::shared_mutex> lock(_mutex);
+    if (surface) {
+      surface.Present();
+    }
+  }
+
+  wgpu::Texture getCurrentTexture() {
+    std::shared_lock<std::shared_mutex> lock(_mutex);
+    if (surface) {
+      wgpu::SurfaceTexture surfaceTexture;
+      surface.GetCurrentTexture(&surfaceTexture);
+      return surfaceTexture.texture;
+    } else {
+      return texture;
+    }
+  }
+
+  NativeInfo getNativeInfo() {
+    std::shared_lock<std::shared_mutex> lock(_mutex);
+    return {.nativeSurface = nativeSurface, .width = width, .height = height};
+  }
+
+  Size getSize() {
+    std::shared_lock<std::shared_mutex> lock(_mutex);
+    return {.width = width, .height = height};
+  }
+
+  wgpu::Device getDevice() {
+    std::shared_lock<std::shared_mutex> lock(_mutex);
+    return config.device;
+  }
 
+private:
+  void _configure() {
+    if (surface) {
+      surface.Configure(&config);
+    } else {
+      wgpu::TextureDescriptor textureDesc;
+      textureDesc.format = config.format;
+      textureDesc.size.width = config.width;
+      textureDesc.size.height = config.height;
+      textureDesc.usage = wgpu::TextureUsage::RenderAttachment |
+                          wgpu::TextureUsage::CopySrc |
+                          wgpu::TextureUsage::TextureBinding;
+      texture = config.device.CreateTexture(&textureDesc);
+    }
+  }
+
+  mutable std::shared_mutex _mutex;
+  void *nativeSurface = nullptr;
+  wgpu::Surface surface = nullptr;
+  wgpu::Texture texture = nullptr;
+  wgpu::Instance gpu;
+  wgpu::SurfaceConfiguration config;
+  int width;
+  int height;
+};
+
+class SurfaceRegistry {
 public:
-  void addSurface(const int contextId, void *surface, float width,
-                  float height) {
-    _registry[contextId] = std::make_shared<Canvas>(surface, width, height);
+  static SurfaceRegistry &getInstance() {
+    static SurfaceRegistry instance;
+    return instance;
   }
 
-  std::shared_ptr<Canvas> getSurface(const int contextId) {
-    return _registry[contextId];
+  SurfaceRegistry(const SurfaceRegistry &) = delete;
+  SurfaceRegistry &operator=(const SurfaceRegistry &) = delete;
+
+  std::shared_ptr<SurfaceInfo> getSurfaceInfo(int id) {
+    std::shared_lock<std::shared_mutex> lock(_mutex);
+    auto it = _registry.find(id);
+    if (it != _registry.end()) {
+      return it->second;
+    }
+    return nullptr;
+  }
+
+  void removeSurfaceInfo(int id) {
+    std::unique_lock<std::shared_mutex> lock(_mutex);
+    _registry.erase(id);
   }
 
-  void removeSurface(const int contextId) { _registry.erase(contextId); }
+  std::shared_ptr<SurfaceInfo> addSurfaceInfo(int id, wgpu::Instance gpu,
+                                              int width, int height) {
+    std::unique_lock<std::shared_mutex> lock(_mutex);
+    auto info = std::make_shared<SurfaceInfo>(gpu, width, height);
+    _registry[id] = info;
+    return info;
+  }
 
-  void updateSurface(const int contextId, float width, float height) {
-    if (_registry.find(contextId) != _registry.end()) {
-      _registry[contextId]->setClientWidth(width);
-      _registry[contextId]->setClientHeight(height);
+  std::shared_ptr<SurfaceInfo>
+  getSurfaceInfoOrCreate(int id, wgpu::Instance gpu, int width, int height) {
+    std::unique_lock<std::shared_mutex> lock(_mutex);
+    auto it = _registry.find(id);
+    if (it != _registry.end()) {
+      return it->second;
     }
+    auto info = std::make_shared<SurfaceInfo>(gpu, width, height);
+    _registry[id] = info;
+    return info;
   }
+
+private:
+  SurfaceRegistry() = default;
+  mutable std::shared_mutex _mutex;
+  std::unordered_map<int, std::shared_ptr<SurfaceInfo>> _registry;
 };
 
 } // namespace rnwgpu

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

@@ -9,7 +9,6 @@ void GPUCanvasContext::configure(
   Convertor conv;
   wgpu::SurfaceConfiguration surfaceConfiguration;
   surfaceConfiguration.device = configuration->device->get();
-  _device = configuration->device->get();
   if (configuration->viewFormats.has_value()) {
     if (!conv(surfaceConfiguration.viewFormats,
               surfaceConfiguration.viewFormatCount,
@@ -23,41 +22,32 @@ 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();
+  _surfaceInfo->configure(surfaceConfiguration);
 }
 
-void GPUCanvasContext::unconfigure() {
-  _lastConfig = nullptr;
-  _width = _canvas->getWidth();
-  _height = _canvas->getHeight();
-  _instance.Unconfigure();
-}
+void GPUCanvasContext::unconfigure() {}
 
 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");
+  auto prevSize = _surfaceInfo->getSize();
+  auto width = _canvas->getWidth();
+  auto height = _canvas->getHeight();
+  auto sizeHasChanged = prevSize.width != width || prevSize.height != height;
+  if (sizeHasChanged) {
+    _surfaceInfo->reconfigure(width, height);
   }
-  // Default canvas texture label is ""
+  auto texture = _surfaceInfo->getCurrentTexture();
   return std::make_shared<GPUTexture>(texture, "");
 }
 
 void GPUCanvasContext::present() {
 #ifdef __APPLE__
-  dawn::native::metal::WaitForCommandsToBeScheduled(_device.Get());
+  dawn::native::metal::WaitForCommandsToBeScheduled(
+      _surfaceInfo->getDevice().Get());
 #endif
-  _instance.Present();
+  auto size = _surfaceInfo->getSize();
+  _canvas->setClientWidth(size.width);
+  _canvas->setClientHeight(size.height);
+  _surfaceInfo->present();
 }
 
 } // namespace rnwgpu

package/cpp/rnwgpu/api/GPUCanvasContext.h

@@ -12,6 +12,7 @@
 #include "AsyncRunner.h"
 
 #include "Canvas.h"
+#include "GPU.h"
 #include "GPUCanvasConfiguration.h"
 #include "GPUTexture.h"
 #include "SurfaceRegistry.h"
@@ -38,9 +39,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) {
+  GPUCanvasContext(std::shared_ptr<GPU> gpu, int contextId, int width,
+                   int height)
+      : HybridObject("GPUCanvasContext"), _gpu(std::move(gpu)) {
+    _canvas = std::make_shared<Canvas>(nullptr, width, height);
+    auto &registry = rnwgpu::SurfaceRegistry::getInstance();
+    _surfaceInfo =
+        registry.getSurfaceInfoOrCreate(contextId, _gpu->get(), width, height);
   }
 
 public:
@@ -58,19 +63,17 @@ public:
     registerHybridMethod("present", &GPUCanvasContext::present, this);
   }
 
-  inline const wgpu::Surface get() { return _instance; }
+  // TODO: is this ok?
+  inline const wgpu::Surface get() { return nullptr; }
   void configure(std::shared_ptr<GPUCanvasConfiguration> configuration);
   void unconfigure();
   std::shared_ptr<GPUTexture> getCurrentTexture();
   void present();
 
 private:
-  wgpu::Surface _instance;
-  wgpu::Device _device;
   std::shared_ptr<Canvas> _canvas;
-  std::shared_ptr<GPUCanvasConfiguration> _lastConfig;
-  float _width;
-  float _height;
+  std::shared_ptr<SurfaceInfo> _surfaceInfo;
+  std::shared_ptr<GPU> _gpu;
 };
 
 } // namespace rnwgpu

package/cpp/rnwgpu/api/GPUDevice.cpp

@@ -70,8 +70,9 @@ std::shared_ptr<GPUShaderModule> GPUDevice::createShaderModule(
   wgpu::ShaderModuleWGSLDescriptor wgsl_desc{};
   wgpu::ShaderModuleDescriptor sm_desc{};
   Convertor conv;
-  if (!conv(wgsl_desc.code, descriptor->code) || !conv(sm_desc.label, descriptor->label)) {
-      return {};
+  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) {

package/cpp/rnwgpu/api/RNWebGPU.h

@@ -3,6 +3,7 @@
 #include <memory>
 #include <string>
 
+#include "Canvas.h"
 #include "GPU.h"
 #include "GPUCanvasContext.h"
 #include "ImageBitmap.h"
@@ -29,17 +30,18 @@ public:
 
   std::shared_ptr<GPU> getGPU() { return _gpu; }
 
+  bool getFabric() {
+#ifdef RCT_NEW_ARCH_ENABLED
+    return true;
+#else
+    return false;
+#endif
+  }
+
   std::shared_ptr<GPUCanvasContext>
-  MakeWebGPUCanvasContext(std::shared_ptr<Canvas> canvas) {
-    auto nativeSurface = canvas->getSurface();
-    auto width = canvas->getWidth();
-    auto height = canvas->getHeight();
-    auto surface = _platformContext->makeSurface(
-        _gpu->get(), reinterpret_cast<void *>(nativeSurface), width, height);
-    if (surface == nullptr) {
-      throw std::runtime_error("null surface");
-    }
-    auto ctx = std::make_shared<GPUCanvasContext>(surface, canvas);
+  MakeWebGPUCanvasContext(int contextId, float width, float height) {
+    auto ctx =
+        std::make_shared<GPUCanvasContext>(_gpu, contextId, width, height);
     return ctx;
   }
 
@@ -50,10 +52,23 @@ public:
     return imageBitmap;
   }
 
+  std::shared_ptr<Canvas> getNativeSurface(int contextId) {
+    auto &registry = rnwgpu::SurfaceRegistry::getInstance();
+    auto info = registry.getSurfaceInfo(contextId);
+    if (info == nullptr) {
+      return std::make_shared<Canvas>(nullptr, 0, 0);
+    }
+    auto nativeInfo = info->getNativeInfo();
+    return std::make_shared<Canvas>(nativeInfo.nativeSurface, nativeInfo.width,
+                                    nativeInfo.height);
+  }
+
   void loadHybridMethods() override {
+    registerHybridGetter("fabric", &RNWebGPU::getFabric, this);
     registerHybridGetter("gpu", &RNWebGPU::getGPU, this);
     registerHybridMethod("createImageBitmap", &RNWebGPU::createImageBitmap,
                          this);
+    registerHybridMethod("getNativeSurface", &RNWebGPU::getNativeSurface, this);
     registerHybridMethod("MakeWebGPUCanvasContext",
                          &RNWebGPU::MakeWebGPUCanvasContext, this);
   }