react-native-webgpu 0.5.11

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

@@ -0,0 +1,50 @@
+package com.webgpu;
+
+import android.util.Log;
+
+import androidx.annotation.OptIn;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import com.facebook.proguard.annotations.DoNotStrip;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.JavaScriptContextHolder;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.common.annotations.FrameworkAPI;
+import com.facebook.react.module.annotations.ReactModule;
+import com.facebook.react.modules.blob.BlobModule;
+import com.facebook.react.modules.blob.BlobProvider;
+import com.facebook.react.turbomodule.core.CallInvokerHolderImpl;
+import com.facebook.react.turbomodule.core.interfaces.CallInvokerHolder;
+
+@ReactModule(name = WebGPUModule.NAME)
+public class WebGPUModule extends NativeWebGPUModuleSpec {
+  static {
+      System.loadLibrary("react-native-wgpu"); // Load the C++ library
+  }
+
+  public WebGPUModule(ReactApplicationContext reactContext) {
+    super(reactContext);
+    // Initialize the C++ module
+    initialize();
+  }
+
+  @OptIn(markerClass = FrameworkAPI.class)
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public boolean install() {
+    ReactApplicationContext context = getReactApplicationContext();
+    JavaScriptContextHolder jsContext = context.getJavaScriptContextHolder();
+    CallInvokerHolder callInvokerHolder = context.getCatalystInstance().getJSCallInvokerHolder();
+    BlobModule blobModule = getReactApplicationContext().getNativeModule(BlobModule.class);
+    if (blobModule == null) {
+      throw new RuntimeException("React Native's BlobModule was not found!");
+    }
+    initializeNative(jsContext.get(), (CallInvokerHolderImpl) callInvokerHolder, blobModule);
+    return true;
+  }
+
+  @OptIn(markerClass = FrameworkAPI.class)
+  @DoNotStrip
+  private native void initializeNative(long jsRuntime, CallInvokerHolderImpl jsInvoker, BlobModule blobModule);
+}

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

@@ -0,0 +1,41 @@
+package com.webgpu;
+
+import android.annotation.SuppressLint;
+import android.content.Context;
+import android.view.SurfaceHolder;
+import android.view.SurfaceView;
+
+import androidx.annotation.NonNull;
+
+@SuppressLint("ViewConstructor")
+public class WebGPUSurfaceView extends SurfaceView implements SurfaceHolder.Callback {
+
+  WebGPUAPI mApi;
+
+  public WebGPUSurfaceView(Context context, WebGPUAPI api) {
+    super(context);
+    mApi = api;
+    getHolder().addCallback(this);
+  }
+
+  @Override
+  protected void onDetachedFromWindow() {
+    super.onDetachedFromWindow();
+    mApi.surfaceDestroyed();
+  }
+
+  @Override
+  public void surfaceCreated(@NonNull SurfaceHolder holder) {
+    mApi.surfaceCreated(holder.getSurface());
+  }
+
+  @Override
+  public void surfaceChanged(@NonNull SurfaceHolder holder, int format, int width, int height) {
+    mApi.surfaceChanged(holder.getSurface());
+  }
+
+  @Override
+  public void surfaceDestroyed(@NonNull SurfaceHolder holder) {
+    mApi.surfaceOffscreen();
+  }
+}

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

@@ -0,0 +1,79 @@
+package com.webgpu;
+
+import android.annotation.SuppressLint;
+import android.content.Context;
+import android.graphics.PixelFormat;
+import android.os.Build;
+import android.view.Surface;
+import android.view.SurfaceControl;
+import android.view.SurfaceHolder;
+import android.view.SurfaceView;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.RequiresApi;
+
+
+@SuppressLint("ViewConstructor")
+@RequiresApi(api = Build.VERSION_CODES.Q)
+public class WebGPUSurfaceViewWithSC extends SurfaceView implements SurfaceHolder.Callback {
+
+  WebGPUAPI mApi;
+  SurfaceControl mSurfaceControl;
+  Surface mSurface;
+
+  public WebGPUSurfaceViewWithSC(Context context, WebGPUAPI api) {
+    super(context);
+    mApi = api;
+    getHolder().addCallback(this);
+  }
+
+  @Override
+  protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
+    super.onLayout(changed, left, top, right, bottom);
+
+  }
+
+  @Override
+  protected void onDetachedFromWindow() {
+    super.onDetachedFromWindow();
+  }
+
+  @Override
+  public void surfaceCreated(@NonNull SurfaceHolder holder) {
+    if (mSurfaceControl != null) {
+      SurfaceControl.Transaction tr = new SurfaceControl.Transaction();
+      tr.setVisibility(mSurfaceControl, true);
+      tr.reparent(mSurfaceControl, getSurfaceControl());
+      tr.apply();
+    } else {
+      SurfaceControl.Builder scb = new SurfaceControl.Builder();
+      scb.setName("WebGPUView");
+      scb.setOpaque(true);
+      scb.setBufferSize(getWidth(), getHeight());
+      scb.setParent(getSurfaceControl());
+      scb.setFormat(PixelFormat.RGBA_8888);
+      mSurfaceControl = scb.build();
+      mSurface = new Surface(mSurfaceControl);
+      mApi.surfaceCreated(mSurface);
+    }
+    SurfaceControl.Transaction tr = new SurfaceControl.Transaction();
+    tr.setVisibility(mSurfaceControl, true);
+    tr.apply();
+  }
+
+  @Override
+  public void surfaceChanged(@NonNull SurfaceHolder holder, int format, int width, int height) {
+    mApi.surfaceChanged(mSurface);
+    SurfaceControl.Transaction tr = new SurfaceControl.Transaction();
+    tr.setVisibility(mSurfaceControl, true);
+    tr.setBufferSize(mSurfaceControl, getWidth(), getHeight());
+    tr.apply();
+  }
+
+  @Override
+  public void surfaceDestroyed(@NonNull SurfaceHolder holder) {
+    SurfaceControl.Transaction tr = new SurfaceControl.Transaction();
+    tr.reparent(mSurfaceControl, null);
+    tr.apply();
+  }
+}

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

@@ -0,0 +1,46 @@
+package com.webgpu;
+
+import android.annotation.SuppressLint;
+import android.content.Context;
+import android.graphics.SurfaceTexture;
+import android.view.Surface;
+import android.view.TextureView;
+import androidx.annotation.NonNull;
+
+import org.w3c.dom.Text;
+
+@SuppressLint("ViewConstructor")
+public class WebGPUTextureView extends TextureView implements TextureView.SurfaceTextureListener {
+
+  WebGPUAPI mApi;
+
+  public WebGPUTextureView(Context context, WebGPUAPI api) {
+    super(context);
+    mApi = api;
+    setOpaque(false);
+    setSurfaceTextureListener(this);
+  }
+
+  @Override
+  public void onSurfaceTextureAvailable(@NonNull SurfaceTexture surfaceTexture, int width, int height) {
+    Surface surface = new Surface(surfaceTexture);
+    mApi.surfaceCreated(surface);
+  }
+
+  @Override
+  public void onSurfaceTextureSizeChanged(@NonNull SurfaceTexture surfaceTexture, int width, int height) {
+    Surface surface = new Surface(surfaceTexture);
+    mApi.surfaceChanged(surface);
+  }
+
+  @Override
+  public boolean onSurfaceTextureDestroyed(@NonNull SurfaceTexture surfaceTexture) {
+    mApi.surfaceDestroyed();
+    return true;
+  }
+
+  @Override
+  public void onSurfaceTextureUpdated(@NonNull SurfaceTexture surfaceTexture) {
+    // No implementation needed
+  }
+}

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

@@ -0,0 +1,108 @@
+package com.webgpu;
+
+import android.content.Context;
+import android.os.Build;
+import android.view.Surface;
+import android.view.View;
+
+import com.facebook.proguard.annotations.DoNotStrip;
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.facebook.react.views.view.ReactViewGroup;
+
+public class WebGPUView extends ReactViewGroup implements WebGPUAPI {
+
+
+  private int mContextId;
+  private boolean mTransparent = false;
+  private WebGPUModule mModule;
+  private View mView = null;
+
+  WebGPUView(Context context) {
+    super(context);
+  }
+
+  public void setContextId(int contextId) {
+    if (mModule == null) {
+      Context context = getContext();
+      if (context instanceof ThemedReactContext) {
+        mModule = ((ThemedReactContext) context).getReactApplicationContext().getNativeModule(WebGPUModule.class);
+      }
+    }
+    mContextId = contextId;
+  }
+
+  public void setTransparent(boolean value) {
+    Context ctx = getContext();
+    if (value != mTransparent || mView == null) {
+      if (mView != null) {
+        removeView(mView);
+      }
+      mTransparent = value;
+      if (mTransparent) {
+//        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+//          mView = new WebGPUAHBView(ctx, this);
+//        } else {
+          mView = new WebGPUTextureView(ctx, this);
+//        }
+      } else {
+        mView = new WebGPUSurfaceView(ctx, this);
+      }
+      addView(mView);
+    }
+  }
+
+  @Override
+  protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
+    super.onLayout(changed, left, top, right, bottom);
+    mView.layout(0, 0, this.getMeasuredWidth(), this.getMeasuredHeight());
+  }
+
+  @Override
+  public void surfaceCreated(Surface surface) {
+    float density = getResources().getDisplayMetrics().density;
+    float width = getWidth() / density;
+    float height = getHeight() / density;
+    onSurfaceCreate(surface, mContextId, width, height);
+  }
+
+  @Override
+  public void surfaceChanged(Surface surface) {
+    float density = getResources().getDisplayMetrics().density;
+    float width = getWidth() / density;
+    float height = getHeight() / density;
+    onSurfaceChanged(surface, mContextId, width, height);
+  }
+
+  @Override
+  public void surfaceDestroyed() {
+    onSurfaceDestroy(mContextId);
+  }
+
+  @Override
+  public void surfaceOffscreen() {
+    switchToOffscreenSurface(mContextId);
+  }
+
+  @DoNotStrip
+  private native void onSurfaceCreate(
+    Surface surface,
+    int contextId,
+    float width,
+    float height
+  );
+
+  @DoNotStrip
+  private native void onSurfaceChanged(
+    Surface surface,
+    int contextId,
+    float width,
+    float height
+  );
+
+  @DoNotStrip
+  private native void onSurfaceDestroy(int contextId);
+
+  @DoNotStrip
+  private native void switchToOffscreenSurface(int contextId);
+
+}

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

@@ -0,0 +1,38 @@
+package com.webgpu;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.facebook.react.module.annotations.ReactModule;
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.facebook.react.uimanager.annotations.ReactProp;
+
+@ReactModule(name = WebGPUViewManager.NAME)
+public class WebGPUViewManager extends WebGPUViewManagerSpec<WebGPUView> {
+
+  public static final String NAME = "WebGPUView";
+
+  @NonNull
+  @Override
+  public String getName() {
+    return NAME;
+  }
+
+  @NonNull
+  @Override
+  public WebGPUView createViewInstance(@NonNull ThemedReactContext context) {
+    return new WebGPUView(context);
+  }
+
+  @Override
+  @ReactProp(name = "transparent")
+  public void setTransparent(WebGPUView view, boolean value) {
+    view.setTransparent(value);
+  }
+
+  @Override
+  @ReactProp(name = "contextId")
+  public void setContextId(WebGPUView view, int value) {
+    view.setContextId(value);
+  }
+}

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

@@ -0,0 +1,50 @@
+
+package com.webgpu;
+
+import com.facebook.react.TurboReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.module.annotations.ReactModule;
+import com.facebook.react.module.model.ReactModuleInfo;
+import com.facebook.react.module.model.ReactModuleInfoProvider;
+import com.facebook.react.uimanager.ViewManager;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class WebGPUViewPackage extends TurboReactPackage {
+  @Override
+  public NativeModule getModule(String name, ReactApplicationContext reactContext) {
+    if (name.equals(WebGPUModule.NAME)) {
+      return new WebGPUModule(reactContext);
+    }
+    return null;
+  }
+
+  @Override
+  public ReactModuleInfoProvider getReactModuleInfoProvider() {
+    return () -> {
+      Map<String, ReactModuleInfo> map = new HashMap<>();
+      map.put(
+        WebGPUModule.NAME,
+        new ReactModuleInfo(
+          WebGPUModule.NAME,
+          WebGPUModule.class.getName(),
+          false,
+          false,
+          false,
+          false,
+          true // isTurboModule
+        )
+      );
+      return map;
+    };
+  }
+
+  @Override
+  public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
+    return Collections.singletonList(new WebGPUViewManager());
+  }
+}

package/android/src/newarch/com/webgpu/WebGPUViewManagerSpec.java

@@ -0,0 +1,24 @@
+package com.webgpu;
+
+import android.view.View;
+
+import androidx.annotation.Nullable;
+
+import com.facebook.react.uimanager.SimpleViewManager;
+import com.facebook.react.uimanager.ViewManagerDelegate;
+import com.facebook.react.viewmanagers.WebGPUViewManagerDelegate;
+import com.facebook.react.viewmanagers.WebGPUViewManagerInterface;
+
+public abstract class WebGPUViewManagerSpec<T extends View> extends SimpleViewManager<T> implements WebGPUViewManagerInterface<T> {
+  private final ViewManagerDelegate<T> mDelegate;
+
+  public WebGPUViewManagerSpec() {
+    mDelegate = new WebGPUViewManagerDelegate(this);
+  }
+
+  @Nullable
+  @Override
+  protected ViewManagerDelegate<T> getDelegate() {
+    return mDelegate;
+  }
+}

package/apple/ApplePlatformContext.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include "PlatformContext.h"
+#include <string>
+
+namespace rnwgpu {
+
+class ApplePlatformContext : public PlatformContext {
+public:
+  ApplePlatformContext();
+  ~ApplePlatformContext() = default;
+
+  wgpu::Surface makeSurface(wgpu::Instance instance, void *surface, int width,
+                            int height) override;
+
+  ImageData createImageBitmap(std::string blobId, double offset,
+                              double size) override;
+
+  void
+  createImageBitmapAsync(std::string blobId, double offset, double size,
+                         std::function<void(ImageData)> onSuccess,
+                         std::function<void(std::string)> onError) override;
+
+  ImageData createImageBitmapFromData(std::span<const uint8_t> data) override;
+
+  void createImageBitmapFromDataAsync(
+      std::span<const uint8_t> data, std::function<void(ImageData)> onSuccess,
+      std::function<void(std::string)> onError) override;
+};
+
+} // namespace rnwgpu

package/apple/ApplePlatformContext.mm

@@ -0,0 +1,157 @@
+#include "ApplePlatformContext.h"
+
+#include <TargetConditionals.h>
+
+#import <React/RCTBlobManager.h>
+#import <React/RCTBridge+Private.h>
+#import <ReactCommon/RCTTurboModule.h>
+
+#include "RNWebGPUManager.h"
+#include "WebGPUModule.h"
+
+namespace rnwgpu {
+
+void checkIfUsingSimulatorWithAPIValidation() {
+#if TARGET_OS_SIMULATOR
+  NSDictionary *environment = [[NSProcessInfo processInfo] environment];
+  NSString *metalDeviceWrapperType = environment[@"METAL_DEVICE_WRAPPER_TYPE"];
+
+  if ([metalDeviceWrapperType isEqualToString:@"1"]) {
+    throw std::runtime_error(
+        "To use React Native WebGPU project on the iOS simulator, you need to "
+        "disable the Metal validation API. In 'Edit Scheme,' uncheck 'Metal "
+        "Validation.'");
+  }
+#endif
+}
+
+ApplePlatformContext::ApplePlatformContext() {
+  checkIfUsingSimulatorWithAPIValidation();
+}
+
+wgpu::Surface ApplePlatformContext::makeSurface(wgpu::Instance instance,
+                                                void *surface, int width,
+                                                int height) {
+  wgpu::SurfaceSourceMetalLayer metalSurfaceDesc;
+  metalSurfaceDesc.layer = surface;
+  wgpu::SurfaceDescriptor surfaceDescriptor;
+  surfaceDescriptor.nextInChain = &metalSurfaceDesc;
+  return instance.CreateSurface(&surfaceDescriptor);
+}
+
+static std::span<const uint8_t> nsDataToSpan(NSData *data) {
+  return {static_cast<const uint8_t *>(data.bytes), data.length};
+}
+
+ImageData ApplePlatformContext::createImageBitmap(std::string blobId,
+                                                  double offset, double size) {
+  RCTBlobManager *blobManager =
+      [[RCTBridge currentBridge] moduleForClass:RCTBlobManager.class];
+  NSData *blobData =
+      [blobManager resolve:[NSString stringWithUTF8String:blobId.c_str()]
+                    offset:(long)offset
+                      size:(long)size];
+
+  if (!blobData) {
+    throw std::runtime_error("Couldn't retrieve blob data");
+  }
+
+  return createImageBitmapFromData(nsDataToSpan(blobData));
+}
+
+void ApplePlatformContext::createImageBitmapAsync(
+    std::string blobId, double offset, double size,
+    std::function<void(ImageData)> onSuccess,
+    std::function<void(std::string)> onError) {
+  // Resolve blob on current thread (requires RCTBridge access)
+  RCTBlobManager *blobManager =
+      [[RCTBridge currentBridge] moduleForClass:RCTBlobManager.class];
+  NSData *blobData =
+      [blobManager resolve:[NSString stringWithUTF8String:blobId.c_str()]
+                    offset:(long)offset
+                      size:(long)size];
+
+  if (!blobData) {
+    onError("Couldn't retrieve blob data");
+    return;
+  }
+
+  // blobData is alive during this synchronous call;
+  // createImageBitmapFromDataAsync copies the span before dispatching
+  createImageBitmapFromDataAsync(nsDataToSpan(blobData), std::move(onSuccess),
+                                 std::move(onError));
+}
+
+ImageData
+ApplePlatformContext::createImageBitmapFromData(std::span<const uint8_t> data) {
+  // This avoids a copy by assuming the UIImage/NSImage constructors
+  // decode `nsData` eagerly before the memory for the wrapped `data`
+  // is freed.
+  //
+  // Since we get the `CGImageRef` from `image` and then throw
+  // it away, that's a fairly safe assumption.
+  NSData *nsData =
+      [NSData dataWithBytesNoCopy:const_cast<uint8_t *>(data.data())
+                           length:data.size()
+                     freeWhenDone:NO];
+
+#if !TARGET_OS_OSX
+  UIImage *image = [UIImage imageWithData:nsData];
+#else
+  NSImage *image = [[NSImage alloc] initWithData:nsData];
+#endif
+  if (!image) {
+    throw std::runtime_error("Couldn't decode image");
+  }
+
+#if !TARGET_OS_OSX
+  CGImageRef cgImage = image.CGImage;
+#else
+  CGImageRef cgImage = [image CGImageForProposedRect:NULL
+                                             context:NULL
+                                               hints:NULL];
+#endif
+  size_t width = CGImageGetWidth(cgImage);
+  size_t height = CGImageGetHeight(cgImage);
+  size_t bitsPerComponent = 8;
+  size_t bytesPerRow = width * 4;
+
+  ImageData result;
+  result.width = static_cast<int>(width);
+  result.height = static_cast<int>(height);
+  result.data.resize(height * bytesPerRow);
+  result.format = wgpu::TextureFormat::RGBA8Unorm;
+
+  CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
+  CGContextRef context = CGBitmapContextCreate(
+      result.data.data(), width, height, bitsPerComponent, bytesPerRow,
+      colorSpace, kCGImageAlphaPremultipliedLast | kCGBitmapByteOrder32Big);
+
+  CGContextDrawImage(context, CGRectMake(0, 0, width, height), cgImage);
+
+  CGContextRelease(context);
+  CGColorSpaceRelease(colorSpace);
+
+  return result;
+}
+
+void ApplePlatformContext::createImageBitmapFromDataAsync(
+    std::span<const uint8_t> data, std::function<void(ImageData)> onSuccess,
+    std::function<void(std::string)> onError) {
+  // Copy span data into shared_ptr so the dispatch_async block owns the memory
+  auto ownedData =
+      std::make_shared<std::vector<uint8_t>>(data.begin(), data.end());
+
+  dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0), ^{
+    @autoreleasepool {
+      try {
+        auto result = createImageBitmapFromData(*ownedData);
+        onSuccess(std::move(result));
+      } catch (const std::exception &e) {
+        onError(e.what());
+      }
+    }
+  });
+}
+
+} // namespace rnwgpu

package/apple/MetalView.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#import "RNWGUIKit.h"
+#import "WebGPUModule.h"
+
+@interface MetalView : RNWGPlatformView
+
+@property NSNumber *contextId;
+
+- (void)configure;
+- (void)update;
+
+@end

package/apple/MetalView.mm

@@ -0,0 +1,50 @@
+#import "MetalView.h"
+#import "webgpu/webgpu_cpp.h"
+
+@implementation MetalView {
+  BOOL _isConfigured;
+}
+
+#if !TARGET_OS_OSX
++ (Class)layerClass {
+  return [CAMetalLayer class];
+}
+#else  // !TARGET_OS_OSX
+- (instancetype)init {
+  self = [super init];
+  if (self) {
+    self.wantsLayer = true;
+    self.layer = [CAMetalLayer layer];
+  }
+  return self;
+}
+#endif // !TARGET_OS_OSX
+
+- (void)configure {
+  auto size = self.frame.size;
+  std::shared_ptr<rnwgpu::RNWebGPUManager> manager = [WebGPUModule getManager];
+  void *nativeSurface = (__bridge void *)self.layer;
+  auto &registry = rnwgpu::SurfaceRegistry::getInstance();
+  auto gpu = manager->_gpu;
+  auto surface = manager->_platformContext->makeSurface(
+      gpu, nativeSurface, size.width, size.height);
+  registry
+      .getSurfaceInfoOrCreate([_contextId intValue], gpu, size.width,
+                              size.height)
+      ->switchToOnscreen(nativeSurface, surface);
+}
+
+- (void)update {
+  auto size = self.frame.size;
+  auto &registry = rnwgpu::SurfaceRegistry::getInstance();
+  registry.getSurfaceInfo([_contextId intValue])
+      ->resize(size.width, size.height);
+}
+
+- (void)dealloc {
+  auto &registry = rnwgpu::SurfaceRegistry::getInstance();
+  // Remove the surface info from the registry
+  registry.removeSurfaceInfo([_contextId intValue]);
+}
+
+@end