react-native-webgpu 0.11.2 → 0.12.1

package/Package.swift

@@ -29,7 +29,7 @@ let sibling = { (relative: String) -> String in
 // check runs here, at manifest evaluation. SwiftPM caches evaluations, so
 // after changing either package's Dawn version reset the package caches
 // (File > Packages > Reset Package Caches) if this does not re-run.
-let dawnReleaseTag = "dawn-chrome-m154"
+let dawnReleaseTag = "dawn-chrome-m154a"
 // Only Graphite builds of react-native-skia carry this marker (Ganesh builds
 // do not link Dawn and impose no constraint). From v3 the Skia binaries ship
 // in react-native-skia-graphite-apple-ios, which records the tag at
@@ -109,8 +109,8 @@ let package = Package(
     // build-dawn.yml), so SPM exposes them to dependents automatically.
     .binaryTarget(
       name: "WebGPUDawn",
-      url: "https://github.com/wcandillon/react-native-webgpu/releases/download/dawn-chrome-m154/dawn-apple-dawn-chrome-m154.xcframework.zip",
-      checksum: "896575ffbc99610198a83d061f8c5a2789139b7f16c669fbf3a9f7a7ac9be123"
+      url: "https://github.com/wcandillon/react-native-webgpu/releases/download/dawn-chrome-m154a/dawn-apple-dawn-chrome-m154a.xcframework.zip",
+      checksum: "ec06936cca08bca5177e41d78a1b190a22d62980e11df8a4c4ca5868de17c36c"
     ),
     .target(
       name: "ReactNativeWebGPU",

package/cpp/rnwgpu/api/GPUAdapter.cpp

@@ -17,7 +17,7 @@
 
 #include "GPUFeatures.h"
 #include "JSIConverter.h"
-#include "RnFeatures.h"
+#include "NativeFrameFeatures.h"
 #include "WGPULogger.h"
 
 namespace rnwgpu {
@@ -25,36 +25,24 @@ namespace rnwgpu {
 async::AsyncTaskHandle GPUAdapter::requestDevice(
     jsi::Runtime &runtime,
     std::optional<std::shared_ptr<GPUDeviceDescriptor>> descriptor) {
-  // Enable the react-native-wgpu "native-texture" umbrella by default,
-  // mirroring the web where importExternalTexture is core and needs no feature
-  // request. We append the umbrella's backing Dawn features to requiredFeatures
-  // so the capability is on without the caller listing it. Two rules keep this
-  // safe:
-  //   - All-or-nothing: only inject when the adapter supports *every* backing
-  //     feature (same semantics as maybeSynthesizeRnNativeTextureFeature). On a
-  //     web/fallback adapter the backing set is empty or unsupported, so this
-  //     is a no-op and device creation is unaffected.
-  //   - Requesting a feature the adapter doesn't support makes RequestDevice
-  //     fail, hence the support check below.
-  // Callers can still pass "rnwebgpu/native-texture" explicitly; the dedupe
-  // keeps that idempotent.
-  // The optional features (rnNativeTextureOptionalFeatures) ride along one by
-  // one, each only when the adapter supports it: on Android the YUV frames of
-  // the decoder and of the camera cannot be imported without
-  // OpaqueYCbCrAndroidForExternalTexture, while RGBA buffers need nothing
-  // beyond the backing set.
+  // Native frame import (importSharedTextureMemory, importExternalTexture,
+  // copyExternalImageToTexture with a NativeVideoFrame) needs no feature
+  // request, like importExternalTexture on the web: the Dawn features behind
+  // it are added to requiredFeatures here, each one when the adapter supports
+  // it. Requesting a feature the adapter lacks would make RequestDevice fail,
+  // so a fallback adapter (emulators, the web) still gets a device, without
+  // the capability; the first import then reports what is missing.
   {
-    auto backing = rnNativeTextureBackingFeatures();
-    if (!backing.empty()) {
+    auto native = nativeFrameImportFeatures();
+    if (!native.empty()) {
       wgpu::SupportedFeatures supported;
       _instance.GetFeatures(&supported);
       std::unordered_set<wgpu::FeatureName> supportedSet(
           supported.features, supported.features + supported.featureCount);
-      bool allSupported =
-          std::all_of(backing.begin(), backing.end(), [&](wgpu::FeatureName f) {
-            return supportedSet.count(f) > 0;
-          });
-      if (allSupported) {
+      for (auto f : native) {
+        if (supportedSet.count(f) == 0) {
+          continue;
+        }
         if (!descriptor.has_value()) {
           descriptor = std::make_shared<GPUDeviceDescriptor>();
         }
@@ -63,18 +51,8 @@ async::AsyncTaskHandle GPUAdapter::requestDevice(
           desc->requiredFeatures = std::vector<wgpu::FeatureName>{};
         }
         auto &features = desc->requiredFeatures.value();
-        for (auto f : backing) {
-          if (std::find(features.begin(), features.end(), f) ==
-              features.end()) {
-            features.push_back(f);
-          }
-        }
-        for (auto f : rnNativeTextureOptionalFeatures()) {
-          if (supportedSet.count(f) > 0 &&
-              std::find(features.begin(), features.end(), f) ==
-                  features.end()) {
-            features.push_back(f);
-          }
+        if (std::find(features.begin(), features.end(), f) == features.end()) {
+          features.push_back(f);
         }
       }
     }
@@ -325,17 +303,13 @@ std::unordered_set<std::string> GPUAdapter::getFeatures() {
   wgpu::SupportedFeatures supportedFeatures;
   _instance.GetFeatures(&supportedFeatures);
   std::unordered_set<std::string> result;
-  std::unordered_set<wgpu::FeatureName> enabled;
   for (size_t i = 0; i < supportedFeatures.featureCount; ++i) {
-    auto feature = supportedFeatures.features[i];
-    enabled.insert(feature);
     std::string name;
-    convertEnumToJSUnion(feature, &name);
+    convertEnumToJSUnion(supportedFeatures.features[i], &name);
     if (name != "") {
       result.insert(name);
     }
   }
-  maybeSynthesizeRnNativeTextureFeature(enabled, result);
   return result;
 }
 

package/cpp/rnwgpu/api/GPUDevice.cpp

@@ -15,7 +15,6 @@
 #include "GPUInternalError.h"
 #include "GPUOutOfMemoryError.h"
 #include "GPUValidationError.h"
-#include "RnFeatures.h"
 #include "SurfaceRegistry.h"
 
 namespace rnwgpu {
@@ -570,15 +569,11 @@ std::unordered_set<std::string> GPUDevice::getFeatures() {
   wgpu::SupportedFeatures supportedFeatures;
   _instance.GetFeatures(&supportedFeatures);
   std::unordered_set<std::string> result;
-  std::unordered_set<wgpu::FeatureName> enabled;
   for (size_t i = 0; i < supportedFeatures.featureCount; ++i) {
-    auto feature = supportedFeatures.features[i];
-    enabled.insert(feature);
     std::string name;
-    convertEnumToJSUnion(feature, &name);
+    convertEnumToJSUnion(supportedFeatures.features[i], &name);
     result.insert(name);
   }
-  maybeSynthesizeRnNativeTextureFeature(enabled, result);
   return result;
 }
 

package/cpp/rnwgpu/api/NativeFrameFeatures.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <vector>
+
+#include "webgpu/webgpu_cpp.h"
+
+namespace rnwgpu {
+
+// The Dawn features behind native frame import on the current platform:
+// importSharedTextureMemory, importExternalTexture and
+// copyExternalImageToTexture with a NativeVideoFrame. Like
+// importExternalTexture on the web, the capability needs no feature request:
+// requestDevice() enables each of these the adapter supports (see
+// GPUAdapter::requestDevice). A device created by another library and wrapped
+// with importDevice() has to request them itself for its frames to import.
+inline std::vector<wgpu::FeatureName> nativeFrameImportFeatures() {
+#if defined(__APPLE__)
+  return {
+      // IOSurface import, and the MTLSharedEvent fence that EndAccess exports
+      wgpu::FeatureName::SharedTextureMemoryIOSurface,
+      wgpu::FeatureName::SharedFenceMTLSharedEvent,
+      // The biplanar NV12 layout of camera frames
+      wgpu::FeatureName::DawnMultiPlanarFormats,
+  };
+#elif defined(__ANDROID__)
+  return {
+      // AHardwareBuffer import, and the sync-fd fence that EndAccess exports
+      wgpu::FeatureName::SharedTextureMemoryAHardwareBuffer,
+      wgpu::FeatureName::SharedFenceSyncFD,
+      // The YUV buffers of the video decoder and of the camera: Dawn imports
+      // them as OpaqueYCbCrAndroid textures, a format it only accepts, and
+      // only samples as an external texture, with this feature
+      wgpu::FeatureName::OpaqueYCbCrAndroidForExternalTexture,
+  };
+#else
+  return {};
+#endif
+}
+
+} // namespace rnwgpu

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

@@ -2,13 +2,13 @@
 
 #include <map>
 #include <memory>
+#include <stdexcept>
 #include <string>
 #include <vector>
 
 #include "webgpu/webgpu_cpp.h"
 
 #include "JSIConverter.h"
-#include "RnFeatures.h"
 #include "WGPULogger.h"
 
 #include "GPUDawnTogglesDescriptor.h"
@@ -57,13 +57,14 @@ template <> struct JSIConverter<std::vector<wgpu::FeatureName>> {
         continue;
       }
       auto str = elementValue.asString(runtime).utf8(runtime);
-      // Expand react-native-wgpu's umbrella feature into the platform's
-      // backing Dawn features before they reach RequestDevice.
-      if (str == kRnNativeTextureFeature) {
-        for (auto f : rnNativeTextureBackingFeatures()) {
-          vector.emplace_back(f);
-        }
-        continue;
+      // The umbrella feature of earlier versions. Native frame import is on
+      // by default now and the name is gone; say so rather than reject it as
+      // an unknown feature.
+      if (str == "rnwebgpu/native-texture") {
+        throw std::runtime_error(
+            "requestDevice: the 'rnwebgpu/native-texture' feature has been "
+            "removed. Native frame import is enabled by default whenever the "
+            "adapter supports it; drop the name from requiredFeatures.");
       }
       vector.emplace_back(JSIConverter<wgpu::FeatureName>::fromJSI(
           runtime, elementValue, outOfBounds));
@@ -109,13 +110,12 @@ template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUDeviceDescriptor>> {
       }
       if (value.hasProperty(runtime, "dawnToggles")) {
         auto prop = value.getProperty(runtime, "dawnToggles");
-        result->dawnToggles = JSIConverter<
-            std::optional<std::shared_ptr<GPUDawnTogglesDescriptor>>>::fromJSI(
-            runtime, prop, false);
+        result->dawnToggles = JSIConverter<std::optional<
+            std::shared_ptr<GPUDawnTogglesDescriptor>>>::fromJSI(runtime, prop,
+                                                                 false);
       }
       if (value.hasProperty(runtime, "implicitDeviceSynchronization")) {
-        auto prop =
-            value.getProperty(runtime, "implicitDeviceSynchronization");
+        auto prop = value.getProperty(runtime, "implicitDeviceSynchronization");
         result->implicitDeviceSynchronization =
             JSIConverter<std::optional<bool>>::fromJSI(runtime, prop, false);
       }

package/libs/apple/libwebgpu_dawn.xcframework/Info.plist

@@ -10,7 +10,7 @@
 			<key>HeadersPath</key>
 			<string>Headers</string>
 			<key>LibraryIdentifier</key>
-			<string>ios-arm64_x86_64-simulator</string>
+			<string>macos-arm64_x86_64</string>
 			<key>LibraryPath</key>
 			<string>libwebgpu_dawn.a</string>
 			<key>SupportedArchitectures</key>
@@ -19,9 +19,7 @@
 				<string>x86_64</string>
 			</array>
 			<key>SupportedPlatform</key>
-			<string>ios</string>
-			<key>SupportedPlatformVariant</key>
-			<string>simulator</string>
+			<string>macos</string>
 		</dict>
 		<dict>
 			<key>BinaryPath</key>
@@ -45,7 +43,7 @@
 			<key>HeadersPath</key>
 			<string>Headers</string>
 			<key>LibraryIdentifier</key>
-			<string>macos-arm64_x86_64</string>
+			<string>ios-arm64_x86_64-simulator</string>
 			<key>LibraryPath</key>
 			<string>libwebgpu_dawn.a</string>
 			<key>SupportedArchitectures</key>
@@ -54,7 +52,9 @@
 				<string>x86_64</string>
 			</array>
 			<key>SupportedPlatform</key>
-			<string>macos</string>
+			<string>ios</string>
+			<key>SupportedPlatformVariant</key>
+			<string>simulator</string>
 		</dict>
 	</array>
 	<key>CFBundlePackageType</key>

package/libs/apple/libwebgpu_dawn.xcframework/ios-arm64_x86_64-simulator/libwebgpu_dawn.a

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: package/libs/apple/libwebgpu_dawn.xcframework/ios-arm64_x86_64-simulator/libwebgpu_dawn.a
-size: 42656720 bytes
-sha256: 95078993275bccc969b1dfa1ad0934cbacc05ae59e8aa2a6cc46ce93e97d4f69
+size: 42690144 bytes
+sha256: 62ee6161dc9938a0241df7aabb437cc5c012b16c271eb1b9e795c46825b46bbc

package/libs/apple/libwebgpu_dawn.xcframework/macos-arm64_x86_64/libwebgpu_dawn.a

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: package/libs/apple/libwebgpu_dawn.xcframework/macos-arm64_x86_64/libwebgpu_dawn.a
-size: 44192496 bytes
-sha256: 65261557e7fc6c1816c098ee6302a8c01fcb947693ee0ee2a9fb513cb3796e4e
+size: 44227600 bytes
+sha256: 838e315fa20bb88ede8442ae144fba1d4085b8587512466a8fb6ce2efbab7af1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-webgpu",
-  "version": "0.11.2",
+  "version": "0.12.1",
   "description": "React Native WebGPU",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",
@@ -25,7 +25,7 @@
     "app.plugin.js",
     "plugin/build/**"
   ],
-  "dawn": "chrome-m154",
+  "dawn": "chrome-m154a",
   "dawnCommit": "3d786993a7ded64c4ebb4884b9b079db9ad0e580",
   "scripts": {
     "test": "NODE_OPTIONS='--experimental-require-module' jest -i",

package/cpp/rnwgpu/api/RnFeatures.h

@@ -1,66 +0,0 @@
-#pragma once
-
-#include <string>
-#include <unordered_set>
-#include <vector>
-
-#include "webgpu/webgpu_cpp.h"
-
-namespace rnwgpu {
-
-// Umbrella feature name owned by react-native-wgpu. Backed by a
-// platform-specific pair of Dawn features. The prefix is intentional: this
-// string is not part of the WebGPU spec, it is our API surface for the
-// "import a native surface as a sampleable texture" capability.
-inline constexpr const char *kRnNativeTextureFeature =
-    "rnwebgpu/native-texture";
-
-// Dawn features that back the umbrella on the current platform. Empty on
-// platforms where the capability is not available, in which case the umbrella
-// behaves as a no-op (it won't appear in adapter.features and asking for it
-// in requiredFeatures expands to nothing).
-inline std::vector<wgpu::FeatureName> rnNativeTextureBackingFeatures() {
-#if defined(__APPLE__)
-  return {wgpu::FeatureName::SharedTextureMemoryIOSurface,
-          wgpu::FeatureName::SharedFenceMTLSharedEvent};
-#elif defined(__ANDROID__)
-  return {wgpu::FeatureName::SharedTextureMemoryAHardwareBuffer,
-          wgpu::FeatureName::SharedFenceSyncFD};
-#else
-  return {};
-#endif
-}
-
-// Dawn features that complete the umbrella on the current platform. They are
-// requested by default when the adapter supports them, but they are not part
-// of the all-or-nothing backing set: on Android, Dawn imports the YUV buffers
-// of the video decoder and of the camera as OpaqueYCbCrAndroid textures, a
-// format it only accepts, and only samples as an external texture, with
-// OpaqueYCbCrAndroidForExternalTexture; RGBA buffers import without it.
-inline std::vector<wgpu::FeatureName> rnNativeTextureOptionalFeatures() {
-#if defined(__ANDROID__)
-  return {wgpu::FeatureName::OpaqueYCbCrAndroidForExternalTexture};
-#else
-  return {};
-#endif
-}
-
-// If every Dawn feature backing the umbrella is in `enabled`, add the
-// umbrella name to `out`. Used by adapter.features / device.features so JS
-// callers can see (and call .has on) the same name they pass in.
-inline void maybeSynthesizeRnNativeTextureFeature(
-    const std::unordered_set<wgpu::FeatureName> &enabled,
-    std::unordered_set<std::string> &out) {
-  auto backing = rnNativeTextureBackingFeatures();
-  if (backing.empty()) {
-    return;
-  }
-  for (auto f : backing) {
-    if (enabled.find(f) == enabled.end()) {
-      return;
-    }
-  }
-  out.insert(kRnNativeTextureFeature);
-}
-
-} // namespace rnwgpu