react-native-wgpu 0.1.11 → 0.1.13

package/{ios/IOSPlatformContext.h → apple/ApplePlatformContext.h}

@@ -4,10 +4,10 @@
 
 namespace rnwgpu {
 
-class IOSPlatformContext : public PlatformContext {
+class ApplePlatformContext : public PlatformContext {
 public:
-  IOSPlatformContext() = default;
-  ~IOSPlatformContext() = default;
+  ApplePlatformContext();
+  ~ApplePlatformContext() = default;
 
   wgpu::Surface makeSurface(wgpu::Instance instance, void *surface, int width,
                             int height) override;
@@ -16,4 +16,4 @@ public:
                               double size) override;
 };
 
-} // namespace rnwgpu
+} // namespace rnwgpu

package/{ios/IOSPlatformContext.mm → apple/ApplePlatformContext.mm}

@@ -1,4 +1,6 @@
-#include "IOSPlatformContext.h"
+#include "ApplePlatformContext.h"
+
+#include <TargetConditionals.h>
 
 #import <React/RCTBlobManager.h>
 #import <React/RCTBridge+Private.h>
@@ -9,9 +11,25 @@
 
 namespace rnwgpu {
 
-wgpu::Surface IOSPlatformContext::makeSurface(wgpu::Instance instance,
-                                              void *surface, int width,
-                                              int height) {
+void isSimulatorWithAPIValidation() {
+#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() { isSimulatorWithAPIValidation(); }
+
+wgpu::Surface ApplePlatformContext::makeSurface(wgpu::Instance instance,
+                                                void *surface, int width,
+                                                int height) {
   wgpu::SurfaceDescriptorFromMetalLayer metalSurfaceDesc;
   metalSurfaceDesc.layer = surface;
   wgpu::SurfaceDescriptor surfaceDescriptor;
@@ -19,8 +37,8 @@ wgpu::Surface IOSPlatformContext::makeSurface(wgpu::Instance instance,
   return instance.CreateSurface(&surfaceDescriptor);
 }
 
-ImageData IOSPlatformContext::createImageBitmap(std::string blobId,
-                                                double offset, double size) {
+ImageData ApplePlatformContext::createImageBitmap(std::string blobId,
+                                                  double offset, double size) {
   RCTBlobManager *blobManager =
       [[RCTBridge currentBridge] moduleForClass:RCTBlobManager.class];
   NSData *blobData =

package/{ios → apple}/MetalView.h

@@ -7,4 +7,7 @@
 
 @property NSNumber *contextId;
 
+- (void)configure;
+- (void)update;
+
 @end

package/apple/MetalView.mm

@@ -0,0 +1,58 @@
+#import "MetalView.h"
+#import "webgpu_cpp.h"
+
+#ifndef RCT_NEW_ARCH_ENABLED
+#import <React/RCTViewManager.h>
+#endif // RCT_NEW_ARCH_ENABLED
+
+@implementation MetalView {
+  BOOL _isConfigured;
+}
+
++ (Class)layerClass {
+  return [CAMetalLayer class];
+}
+
+- (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]);
+}
+
+#ifndef RCT_NEW_ARCH_ENABLED
+// Paper only method
+// TODO: this method is wrong, it appears to call configureSurface instead of
+// updateSurface sometimes
+- (void)reactSetFrame:(CGRect)frame {
+  [super reactSetFrame:frame];
+  if (!_isConfigured) {
+    [self configure];
+    _isConfigured = YES;
+  } else {
+    [self update];
+  }
+}
+#endif // RCT_NEW_ARCH_ENABLED
+
+@end

package/{ios → apple}/WebGPUModule.mm

@@ -1,6 +1,6 @@
 #import "WebGPUModule.h"
+#include "ApplePlatformContext.h"
 #import "GPUCanvasContext.h"
-#include "IOSPlatformContext.h"
 
 #import <React/RCTBridge+Private.h>
 #import <React/RCTLog.h>
@@ -67,7 +67,7 @@ RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(install) {
     jsInvoker = cxxBridge.jsCallInvoker;
   }
   std::shared_ptr<rnwgpu::PlatformContext> platformContext =
-      std::make_shared<rnwgpu::IOSPlatformContext>();
+      std::make_shared<rnwgpu::ApplePlatformContext>();
   // TODO: remove allocation here
   webgpuManager = std::make_shared<rnwgpu::RNWebGPUManager>(runtime, jsInvoker,
                                                             platformContext);

package/{ios → apple}/WebGPUView.h

@@ -8,9 +8,6 @@
 NS_ASSUME_NONNULL_BEGIN
 
 @interface WebGPUView : RCTViewComponentView
-+ (void)registerMetalView:(MetalView *)metalView
-            withContextId:(NSNumber *)contextId;
-+ (bool)isContextRegisterd:(NSNumber *)contextId;
 @end
 
 NS_ASSUME_NONNULL_END

package/apple/WebGPUView.mm

@@ -0,0 +1,68 @@
+#ifdef RCT_NEW_ARCH_ENABLED
+#import "WebGPUView.h"
+
+#import <react/renderer/components/RNWgpuViewSpec/ComponentDescriptors.h>
+#import <react/renderer/components/RNWgpuViewSpec/EventEmitters.h>
+#import <react/renderer/components/RNWgpuViewSpec/Props.h>
+#import <react/renderer/components/RNWgpuViewSpec/RCTComponentViewHelpers.h>
+
+#import "MetalView.h"
+#import "RCTFabricComponentsPlugins.h"
+#import "Utils.h"
+
+using namespace facebook::react;
+
+@implementation WebGPUView
+
++ (ComponentDescriptorProvider)componentDescriptorProvider {
+  return concreteComponentDescriptorProvider<WebGPUViewComponentDescriptor>();
+}
+
+- (void)prepareForRecycle {
+  [super prepareForRecycle];
+  /*
+    It's important to destroy the Metal Layer before releasing a view
+    to the recycled pool to prevent displaying outdated content from
+    the last usage in the new context.
+  */
+  self.contentView = nil;
+}
+
+- (MetalView *)getContentView {
+  if (!self.contentView) {
+    self.contentView = [MetalView new];
+  }
+  return (MetalView *)self.contentView;
+}
+
+- (void)updateProps:(const Props::Shared &)props
+           oldProps:(const Props::Shared &)oldProps {
+  const auto &oldViewProps =
+      *std::static_pointer_cast<const WebGPUViewProps>(_props);
+  const auto &newViewProps =
+      *std::static_pointer_cast<const WebGPUViewProps>(props);
+
+  if (newViewProps.contextId != oldViewProps.contextId) {
+    /*
+      The context is set only once during mounting the component
+      and never changes because it isn't available for users to modify.
+    */
+    MetalView *metalView = [MetalView new];
+    self.contentView = metalView;
+    [metalView setContextId:@(newViewProps.contextId)];
+    [metalView configure];
+  }
+
+  [super updateProps:props oldProps:oldProps];
+}
+
+- (void)updateLayoutMetrics:(const LayoutMetrics &)layoutMetrics
+           oldLayoutMetrics:(const LayoutMetrics &)oldLayoutMetrics {
+  [super updateLayoutMetrics:layoutMetrics oldLayoutMetrics:oldLayoutMetrics];
+  [(MetalView *)self.contentView update];
+}
+
+Class<RCTComponentViewProtocol> WebGPUViewCls(void) { return WebGPUView.class; }
+
+@end
+#endif

package/cpp/rnwgpu/api/Convertors.h

@@ -280,15 +280,6 @@ public:
            Convert(out.label, in.label);
   }
 
-  // [[nodiscard]] bool Convert(wgpu::CanvasConfiguration &out,
-  //                            const GPUCanvasConfiguration &in) {
-  //   return Convert(out.device, in.device) && Convert(out.format, in.format)
-  //   &&
-  //          Convert(out.usage, in.usage) && Convert(out.viewFormats,
-  //          in.viewFormats) && Convert(out.colorSpace, in.colorSpace) &&
-  //          Convert(out.alphaMode, in.alphaMode);
-  // }
-
   [[nodiscard]] bool Convert(wgpu::Color &out, const GPUColor &in) {
     return Convert(out.r, in.r) && Convert(out.g, in.g) &&
            Convert(out.b, in.b) && Convert(out.a, in.a);

package/cpp/rnwgpu/api/GPUCanvasContext.cpp

@@ -16,12 +16,13 @@ void GPUCanvasContext::configure(
       throw std::runtime_error("Error with SurfaceConfiguration");
     }
   }
-  if (!conv(surfaceConfiguration.format, configuration->format)) {
-    throw std::runtime_error("Error with SurfaceConfiguration");
-  }
-  if (!conv(surfaceConfiguration.usage, configuration->usage)) {
-    throw std::runtime_error("Error with SurfaceConfiguration");
+  if (!conv(surfaceConfiguration.usage, configuration->usage) || !conv(surfaceConfiguration.format, configuration->format)) {
+        throw std::runtime_error("Error with SurfaceConfiguration");
   }
+
+#ifdef __APPLE__
+  surfaceConfiguration.alphaMode = configuration->alphaMode;
+#endif
   _surfaceInfo->configure(surfaceConfiguration);
 }
 

package/cpp/rnwgpu/api/descriptors/GPUCanvasConfiguration.h

@@ -21,6 +21,7 @@ struct GPUCanvasConfiguration {
   std::optional<double> usage;       // GPUTextureUsageFlags
   std::optional<std::vector<wgpu::TextureFormat>>
       viewFormats; // Iterable<GPUTextureFormat>
+  wgpu::CompositeAlphaMode alphaMode = wgpu::CompositeAlphaMode::Opaque;
 };
 
 } // namespace rnwgpu
@@ -58,6 +59,12 @@ struct JSIConverter<std::shared_ptr<rnwgpu::GPUCanvasConfiguration>> {
                                                                       prop,
                                                                       false);
       }
+      if (value.hasProperty(runtime, "alphaMode")) {
+        auto prop = value.getProperty(runtime, "alphaMode").asString(runtime).utf8(runtime);
+        if (prop == "premultiplied") {
+          result->alphaMode = wgpu::CompositeAlphaMode::Premultiplied;
+        }
+      }
     }
 
     return result;