react-native-webgpu 0.5.17 → 0.6.0

package/README.md

@@ -8,6 +8,20 @@ WebGPU for React Native, powered by Dawn.
 
 [Installation instructions](https://wcandillon.github.io/react-native-webgpu/docs/getting-started/installation)
 
+## Expo config plugin
+
+The package ships with an Expo config plugin that disables Metal API validation in the iOS Xcode scheme, which is required to run WebGPU on the iOS Simulator (Metal API validation reports false positives for Dawn that do not occur on device). Because the plugin is part of the package, plugin and package versions are always aligned.
+
+```json
+{
+  "expo": {
+    "plugins": ["react-native-webgpu"]
+  }
+}
+```
+
+See the [Expo guide](https://wcandillon.github.io/react-native-webgpu/docs/getting-started/expo#config-plugin) for details.
+
 ## Contributing
 
 For detailed information on library development, building, testing, and contributing guidelines, please see [CONTRIBUTING.md](packages/webgpu/CONTRIBUTING.md).

package/android/cpp/AndroidPlatformContext.h

@@ -241,8 +241,8 @@ public:
     const uint32_t stridePixels = actualDesc.stride;
 
     void *vaddr = nullptr;
-    int rc = AHardwareBuffer_lock(buffer, AHARDWAREBUFFER_USAGE_CPU_WRITE_RARELY,
-                                  -1, nullptr, &vaddr);
+    int rc = AHardwareBuffer_lock(
+        buffer, AHARDWAREBUFFER_USAGE_CPU_WRITE_RARELY, -1, nullptr, &vaddr);
     if (rc != 0 || !vaddr) {
       AHardwareBuffer_release(buffer);
       throw std::runtime_error(
@@ -302,6 +302,21 @@ public:
     AHardwareBuffer_Desc desc = {};
     AHardwareBuffer_describe(buffer, &desc);
 
+    // Dawn derives the importable WebGPU usages from the AHB's usage bits;
+    // without GPU_SAMPLED_IMAGE the imported texture never gets
+    // TextureBinding and import fails deep inside Dawn with an opaque
+    // validation error. Surface the real cause here instead. (CameraX's
+    // default ImageReaders allocate CPU-only buffers; with
+    // react-native-vision-camera, use pixelFormat: 'native' which allocates
+    // GPU-sampleable buffers.)
+    if ((desc.usage & AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE) == 0) {
+      throw std::runtime_error(
+          "wrapNativeBuffer: this AHardwareBuffer was allocated without "
+          "AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE, so the GPU cannot sample "
+          "it. Camera/CPU pipelines must allocate frames with GPU usage (for "
+          "react-native-vision-camera, use pixelFormat: 'native').");
+    }
+
     AHardwareBuffer_acquire(buffer);
 
     VideoFrameHandle handle;
@@ -312,13 +327,13 @@ public:
     // Dawn's OpaqueYCbCrAndroidForExternalTexture path. Single-plane RGBA AHBs
     // take the plain BGRA8 path (sampled as a regular 2D texture).
     switch (desc.format) {
-      case AHARDWAREBUFFER_FORMAT_Y8Cb8Cr8_420:
-      case AHARDWAREBUFFER_FORMAT_YCbCr_P010:
-        handle.pixelFormat = VideoPixelFormat::NV12;
-        break;
-      default:
-        handle.pixelFormat = VideoPixelFormat::BGRA8;
-        break;
+    case AHARDWAREBUFFER_FORMAT_Y8Cb8Cr8_420:
+    case AHARDWAREBUFFER_FORMAT_YCbCr_P010:
+      handle.pixelFormat = VideoPixelFormat::NV12;
+      break;
+    default:
+      handle.pixelFormat = VideoPixelFormat::BGRA8;
+      break;
     }
     handle.deleter = [buffer]() { AHardwareBuffer_release(buffer); };
     return handle;

package/app.plugin.js

@@ -0,0 +1 @@
+module.exports = require("./plugin/build").default;

package/cpp/rnwgpu/api/GPUAdapter.cpp

@@ -2,12 +2,17 @@
 
 #include <algorithm>
 #include <cstdio>
+#include <cstring>
 #include <memory>
 #include <string>
 #include <unordered_set>
 #include <utility>
 #include <vector>
 
+#ifdef __APPLE__
+#include <TargetConditionals.h>
+#endif
+
 #include "Convertors.h"
 
 #include "GPUFeatures.h"
@@ -150,16 +155,40 @@ async::AsyncTaskHandle GPUAdapter::requestDevice(
             for (const auto &t : dawnToggles->enabledToggles.value()) {
               enabledToggles.push_back(t.c_str());
             }
-            toggles.enabledToggleCount = enabledToggles.size();
-            toggles.enabledToggles = enabledToggles.data();
           }
           if (dawnToggles->disabledToggles) {
             for (const auto &t : dawnToggles->disabledToggles.value()) {
               disabledToggles.push_back(t.c_str());
             }
-            toggles.disabledToggleCount = disabledToggles.size();
-            toggles.disabledToggles = disabledToggles.data();
           }
+        }
+// TODO: in the latest version of Dawn, this won't be needed (https://issues.chromium.org/issues/42241591)
+#if defined(TARGET_OS_SIMULATOR) && TARGET_OS_SIMULATOR
+        // The iOS Simulator only advertises MTLFeatureSet_iOS_GPUFamily2, so
+        // Dawn defaults disable_base_instance/disable_base_vertex on and then
+        // rejects every draw with a non-zero firstInstance or baseVertex,
+        // both core WebGPU. The simulator forwards Metal calls to the host
+        // GPU, which does support base vertex/instance drawing, so force the
+        // toggles off. Device builds are unaffected: WebGPU-capable iPhones
+        // and iPads are all GPUFamily3+. These are device-stage toggles, so
+        // they must be chained here rather than on the instance descriptor
+        // (instance-stage toggle parsing silently drops them).
+        static const char *const kSimulatorDisabledToggles[] = {
+            "disable_base_instance", "disable_base_vertex"};
+        for (const char *name : kSimulatorDisabledToggles) {
+          const bool explicitlyEnabled = std::any_of(
+              enabledToggles.begin(), enabledToggles.end(),
+              [name](const char *t) { return std::strcmp(t, name) == 0; });
+          if (!explicitlyEnabled) {
+            disabledToggles.push_back(name);
+          }
+        }
+#endif
+        if (!enabledToggles.empty() || !disabledToggles.empty()) {
+          toggles.enabledToggleCount = enabledToggles.size();
+          toggles.enabledToggles = enabledToggles.data();
+          toggles.disabledToggleCount = disabledToggles.size();
+          toggles.disabledToggles = disabledToggles.data();
           deviceDesc.nextInChain = &toggles;
         }
         _instance.RequestDevice(

package/cpp/rnwgpu/api/GPUExternalTexture.cpp

@@ -1,5 +1,6 @@
 #include "GPUExternalTexture.h"
 
+#include <array>
 #include <cmath>
 #include <memory>
 #include <string>
@@ -56,44 +57,76 @@ static const float kIdentityTransferParams[7] = {
     0.0f, // F
 };
 
-// BT.709 limited-range YUV -> R'G'B' as a 3x4 row-major matrix mapping
-// [Y, Cb, Cr, 1] to gamma-encoded R'G'B' (NOT linear; the sRGB decode in
-// srcTransferFunctionParameters linearizes afterwards). Same values the Apple
-// NV12 path computes from the CVPixelBuffer; used for Android buffers that
-// arrive as a *defined* biplanar format (where we split the planes and convert
-// ourselves) rather than an opaque external-format AHB. Camera streams are
-// limited-range BT.709 in the overwhelming majority of cases; full-range /
-// BT.601 would need different coefficients (refine from the buffer's suggested
-// range if it matters).
-[[maybe_unused]] static const float kBT709LimitedToRgb[12] = {
-    1.164383f, 0.000000f, 1.792741f, -0.972945f,  //
-    1.164383f, -0.213249f, -0.532909f, 0.301517f, //
-    1.164383f, 2.112402f, 0.000000f, -1.133402f,  //
+// Identity passthrough for GPUExternalTexture.yuvToRgbMatrix: the sampled
+// texel is already RGB (Apple's biplanar path where Dawn converts in the
+// sampler transform, RGBA surfaces, or an Android AHB whose driver reports
+// RGB_IDENTITY). A 3x4 row-major matrix mapping [c.r, c.g, c.b, 1] to itself.
+static constexpr std::array<float, 12> kYuvPassthroughMatrix = {
+    1.0f, 0.0f, 0.0f, 0.0f, //
+    0.0f, 1.0f, 0.0f, 0.0f, //
+    0.0f, 0.0f, 1.0f, 0.0f, //
 };
 
-// True for the multi-planar Y + CbCr formats whose planes we can view as
-// Plane0Only (luma) / Plane1Only (chroma) and convert with an explicit matrix.
-// Excludes OpaqueYCbCrAndroid (external format, no plane views) and triplanar
-// formats (would need a third plane). Only referenced on Android.
-[[maybe_unused]] static bool isBiplanarYuvFormat(wgpu::TextureFormat format) {
-  switch (format) {
-  case wgpu::TextureFormat::R8BG8Biplanar420Unorm:
-  case wgpu::TextureFormat::R8BG8Biplanar422Unorm:
-  case wgpu::TextureFormat::R8BG8Biplanar444Unorm:
-  case wgpu::TextureFormat::R10X6BG10X6Biplanar420Unorm:
-  case wgpu::TextureFormat::R10X6BG10X6Biplanar422Unorm:
-  case wgpu::TextureFormat::R10X6BG10X6Biplanar444Unorm:
-    return true;
+// Build a 3x4 row-major matrix mapping the *sampled* gamma-encoded
+// [Y, Cb, Cr, 1] (each normalized to [0,1]) to gamma-encoded R'G'B', from the
+// Vulkan-suggested YCbCr model + range of an Android external-format buffer.
+// Needed because Dawn's opaque-YCbCr sampling path hard-codes an RGB_IDENTITY
+// conversion (SamplerVk.cpp::GetYCbCrForTextureView, crbug.com/497675620), so
+// the shader receives raw Y/Cb/Cr and must convert itself.
+// The VkSamplerYcbcrModelConversion / VkSamplerYcbcrRange values are inlined
+// to avoid a Vulkan header dependency in this cross-platform file.
+[[maybe_unused]] static std::array<float, 12>
+makeYuvToRgbMatrix(uint32_t vkModel, uint32_t vkRange) {
+  constexpr uint32_t kModelRgbIdentity = 0; // VK_..._RGB_IDENTITY
+  constexpr uint32_t kModel709 = 2;         // VK_..._YCBCR_709
+  constexpr uint32_t kModel601 = 3;         // VK_..._YCBCR_601
+  constexpr uint32_t kModel2020 = 4;        // VK_..._YCBCR_2020
+  constexpr uint32_t kRangeItuNarrow = 1;   // VK_SAMPLER_YCBCR_RANGE_ITU_NARROW
+
+  if (vkModel == kModelRgbIdentity) {
+    // The buffer content is RGB; nothing to convert.
+    return kYuvPassthroughMatrix;
+  }
+  float kr;
+  float kb;
+  switch (vkModel) {
+  case kModel709:
+    kr = 0.2126f;
+    kb = 0.0722f;
+    break;
+  case kModel2020:
+    kr = 0.2627f;
+    kb = 0.0593f;
+    break;
+  case kModel601:
   default:
-    return false;
+    // YCBCR_IDENTITY and unknown models: Android camera streams are BT.601 in
+    // practice, so that is the sane default.
+    kr = 0.299f;
+    kb = 0.114f;
+    break;
   }
+  const float kg = 1.0f - kr - kb;
+  const bool narrow = vkRange == kRangeItuNarrow;
+  const float yScale = narrow ? 255.0f / 219.0f : 1.0f;
+  const float cScale = narrow ? 255.0f / 224.0f : 1.0f;
+  const float yOffset = narrow ? 16.0f / 255.0f : 0.0f;
+  const float cOffset = 128.0f / 255.0f;
+  const float crR = 2.0f * (1.0f - kr) * cScale;
+  const float cbG = -2.0f * kb * (1.0f - kb) / kg * cScale;
+  const float crG = -2.0f * kr * (1.0f - kr) / kg * cScale;
+  const float cbB = 2.0f * (1.0f - kb) * cScale;
+  return {
+      yScale, 0.0f, crR,  -yScale * yOffset - crR * cOffset,         //
+      yScale, cbG,  crG,  -yScale * yOffset - (cbG + crG) * cOffset, //
+      yScale, cbB,  0.0f, -yScale * yOffset - cbB * cOffset,         //
+  };
 }
 
 // Map a rotation in degrees (0 / 90 / 180 / 270) to Dawn's enum. Anything that
 // isn't a clean multiple of 90 snaps to the nearest quadrant; Dawn only
 // supports those four steps for external textures.
-static wgpu::ExternalTextureRotation
-toExternalTextureRotation(double degrees) {
+static wgpu::ExternalTextureRotation toExternalTextureRotation(double degrees) {
   int quadrant = static_cast<int>(std::lround(degrees / 90.0)) & 3;
   switch (quadrant) {
   case 1:
@@ -216,7 +249,11 @@ std::shared_ptr<GPUExternalTexture> GPUExternalTexture::Create(
 
   return std::make_shared<GPUExternalTexture>(
       std::move(external), std::move(memory), std::move(texture),
-      std::move(descriptor->source), std::move(label));
+      std::move(descriptor->source), std::move(label),
+      // Dawn's Metal path applies the YUV->RGB conversion (from
+      // frame.yuvToRgbMatrix above) inside the sampling transform, so the
+      // sampled texel is already RGB.
+      kYuvPassthroughMatrix);
 #elif defined(__ANDROID__)
   // 1. Import the AHardwareBuffer as SharedTextureMemory. For YUV AHBs this
   //    yields a Dawn texture in the implementation-defined OpaqueYCbCrAndroid
@@ -257,32 +294,39 @@ std::shared_ptr<GPUExternalTexture> GPUExternalTexture::Create(
         "GPUExternalTexture::Create(): BeginAccess failed");
   }
 
-  // 4. Build the ExternalTextureDescriptor. There are two cases depending on
-  //    how Dawn imported the AHB (see SharedTextureMemoryVk.cpp):
-  //
-  //    a. *External* format (camera buffers whose layout has no Vulkan
-  //       equivalent) -> OpaqueYCbCrAndroid, a single opaque plane. Sampling
-  //       routes through a Vulkan SamplerYcbcrConversion whose model Dawn
-  //       copies verbatim from the AHB's suggestedYcbcrModel. We pass a single
-  //       plane + identity transfer and let that conversion (if any) run. NOTE:
-  //       when the driver reports RGB_IDENTITY the sample comes back as raw
-  //       Y/Cb/Cr; there is no public hook to override the model on this path.
-  //
-  //    b. *Defined* biplanar format (e.g. R8BG8Biplanar420Unorm, exposed by the
-  //       dawn-multi-planar-formats feature) -> we split Plane0Only (luma) /
-  //       Plane1Only (chroma) and hand Dawn an explicit BT.709 matrix + sRGB
-  //       transfer, exactly like the iOS NV12 path. This makes numPlanes == 2
-  //       so the matrix is actually applied (the single-plane branch in Dawn's
-  //       Tint transform ignores yuvToRgbConversionMatrix).
-  //
-  //    Either way we must pass non-null gamut/transfer arrays:
-  //    ComputeExternalTextureParams dereferences them unconditionally
-  //    (kIdentityTransferParams is defined at file scope).
-  const bool isBiplanar = frame.pixelFormat == VideoPixelFormat::NV12 &&
-                          isBiplanarYuvFormat(texture.GetFormat());
+  // 4. Resolve the YUV->RGB conversion the *shader* must apply. Dawn imports
+  //    every YUV / implementation-defined AHB format as OpaqueYCbCrAndroid
+  //    (AHBFunctions.cpp::FormatFromAHardwareBufferFormat) and samples it
+  //    through a Vulkan SamplerYcbcrConversion that is hard-coded to
+  //    RGB_IDENTITY (SamplerVk.cpp::GetYCbCrForTextureView,
+  //    crbug.com/497675620), so the sample always comes back as raw
+  //    [Y, Cb, Cr]. The driver's *suggested* model + range are captured at
+  //    import time though; read them back from the shared memory's properties
+  //    and derive the correct conversion matrix, exposed to JS as
+  //    GPUExternalTexture.yuvToRgbMatrix. Defined color formats (e.g. an RGBA
+  //    AHB -> RGBA8Unorm) sample as RGB directly and get the passthrough.
+  std::array<float, 12> yuvToRgbMatrix = kYuvPassthroughMatrix;
+  if (texture.GetFormat() == wgpu::TextureFormat::OpaqueYCbCrAndroid) {
+    wgpu::SharedTextureMemoryAHardwareBufferProperties ahbProps{};
+    wgpu::SharedTextureMemoryProperties props{};
+    props.nextInChain = &ahbProps;
+    if (memory.GetProperties(&props)) {
+      yuvToRgbMatrix = makeYuvToRgbMatrix(ahbProps.yCbCrInfo.vkYCbCrModel,
+                                          ahbProps.yCbCrInfo.vkYCbCrRange);
+    } else {
+      // Fall back to the Android camera norm rather than passthrough.
+      yuvToRgbMatrix = makeYuvToRgbMatrix(/* YCBCR_601 */ 3,
+                                          /* ITU_NARROW */ 1);
+    }
+  }
 
-  wgpu::TextureView plane0;
-  wgpu::TextureView plane1;
+  // 5. Build the ExternalTextureDescriptor: a single (opaque or RGB) plane
+  //    with identity transfer. The YUV->RGB conversion cannot run inside
+  //    Dawn's external-texture transform here: the single-plane branch of the
+  //    Tint transform ignores yuvToRgbConversionMatrix, which is why the
+  //    matrix is surfaced to the shader instead. The gamut/transfer arrays
+  //    must still be non-null: ComputeExternalTextureParams dereferences them
+  //    unconditionally.
   wgpu::ExternalTextureDescriptor extDesc{};
   if (!label.empty()) {
     extDesc.label = wgpu::StringView(label.c_str(), label.size());
@@ -291,24 +335,10 @@ std::shared_ptr<GPUExternalTexture> GPUExternalTexture::Create(
   extDesc.cropSize = {frame.width, frame.height};
   extDesc.apparentSize = {frame.width, frame.height};
   extDesc.gamutConversionMatrix = kIdentityGamutMatrix;
-  if (isBiplanar) {
-    wgpu::TextureViewDescriptor v0{};
-    v0.aspect = wgpu::TextureAspect::Plane0Only;
-    plane0 = texture.CreateView(&v0);
-    wgpu::TextureViewDescriptor v1{};
-    v1.aspect = wgpu::TextureAspect::Plane1Only;
-    plane1 = texture.CreateView(&v1);
-    extDesc.plane0 = plane0;
-    extDesc.plane1 = plane1;
-    extDesc.yuvToRgbConversionMatrix = kBT709LimitedToRgb;
-    extDesc.srcTransferFunctionParameters = kSrgbDecodeParams;
-    extDesc.dstTransferFunctionParameters = kSrgbEncodeParams;
-  } else {
-    plane0 = texture.CreateView();
-    extDesc.plane0 = plane0;
-    extDesc.srcTransferFunctionParameters = kIdentityTransferParams;
-    extDesc.dstTransferFunctionParameters = kIdentityTransferParams;
-  }
+  wgpu::TextureView plane0 = texture.CreateView();
+  extDesc.plane0 = plane0;
+  extDesc.srcTransferFunctionParameters = kIdentityTransferParams;
+  extDesc.dstTransferFunctionParameters = kIdentityTransferParams;
   extDesc.mirrored = descriptor->mirrored.value_or(false);
   extDesc.rotation =
       toExternalTextureRotation(descriptor->rotation.value_or(0));
@@ -324,7 +354,8 @@ std::shared_ptr<GPUExternalTexture> GPUExternalTexture::Create(
 
   return std::make_shared<GPUExternalTexture>(
       std::move(external), std::move(memory), std::move(texture),
-      std::move(descriptor->source), std::move(label));
+      std::move(descriptor->source), std::move(label),
+      std::move(yuvToRgbMatrix));
 #else
   throw std::runtime_error(
       "GPUExternalTexture::Create(): not yet implemented on this "

package/cpp/rnwgpu/api/GPUExternalTexture.h

@@ -1,8 +1,10 @@
 #pragma once
 
+#include <array>
 #include <memory>
 #include <string>
 #include <utility>
+#include <vector>
 
 #include "Unions.h"
 
@@ -36,10 +38,12 @@ public:
   // the producer (e.g. AVPlayer) can reclaim the IOSurface.
   GPUExternalTexture(wgpu::ExternalTexture instance,
                      wgpu::SharedTextureMemory memory, wgpu::Texture texture,
-                     std::shared_ptr<VideoFrame> source, std::string label)
+                     std::shared_ptr<VideoFrame> source, std::string label,
+                     std::array<float, 12> yuvToRgbMatrix)
       : NativeObject(CLASS_NAME), _instance(std::move(instance)),
         _memory(std::move(memory)), _texture(std::move(texture)),
-        _source(std::move(source)), _label(std::move(label)) {}
+        _source(std::move(source)), _label(std::move(label)),
+        _yuvToRgbMatrix(yuvToRgbMatrix) {}
 
   ~GPUExternalTexture() override { destroy(); }
 
@@ -69,11 +73,25 @@ public:
     _instance.SetLabel(_label.c_str());
   }
 
+  // Non-spec extension. A 3x4 row-major matrix mapping the *sampled* texel
+  // [c.r, c.g, c.b, 1] to gamma-encoded R'G'B'. When Dawn's sampler already
+  // produces RGB (Apple's biplanar path, RGBA surfaces), this is the identity
+  // passthrough; on the Android opaque-YCbCr path the sample comes back as raw
+  // [Y, Cb, Cr] (Dawn hard-codes an RGB_IDENTITY Vulkan conversion, see
+  // crbug.com/497675620) and this matrix is derived from the driver's
+  // suggested YCbCr model + range for the buffer. Shaders can therefore apply
+  // it unconditionally after textureSampleBaseClampToEdge.
+  std::vector<double> getYuvToRgbMatrix() {
+    return std::vector<double>(_yuvToRgbMatrix.begin(), _yuvToRgbMatrix.end());
+  }
+
   static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
     installGetter(runtime, prototype, "__brand", &GPUExternalTexture::getBrand);
     installGetterSetter(runtime, prototype, "label",
                         &GPUExternalTexture::getLabel,
                         &GPUExternalTexture::setLabel);
+    installGetter(runtime, prototype, "yuvToRgbMatrix",
+                  &GPUExternalTexture::getYuvToRgbMatrix);
     installMethod(runtime, prototype, "destroy", &GPUExternalTexture::destroy);
   }
 
@@ -85,6 +103,7 @@ private:
   wgpu::Texture _texture;
   std::shared_ptr<VideoFrame> _source;
   std::string _label;
+  std::array<float, 12> _yuvToRgbMatrix;
 };
 
 } // namespace rnwgpu

package/cpp/rnwgpu/async/RuntimeContext.cpp

@@ -186,7 +186,14 @@ void RuntimeContext::tick() {
 }
 
 jsi::UUID RuntimeContext::runtimeDataUUID() {
-  static const auto uuid = jsi::UUID();
+  // Fixed random UUID identifying react-native-webgpu's runtimeData slot.
+  // Never use the default-constructed all-zero UUID here: Hermes backs
+  // runtimeData with a DenseMap that reserves the all-zero UUID as its
+  // empty-bucket marker (and the all-0xff UUID as its tombstone), so using
+  // either as a key is undefined behavior. It crashes on worklet runtimes,
+  // where react-native-worklets seeds runtimeData before we do.
+  static constexpr jsi::UUID uuid(0xC06D5D2D, 0xB19B, 0x431B, 0xA89E,
+                                  0x20F8A0B6E31BULL);
   return uuid;
 }
 

package/lib/typescript/app.plugin.d.ts

@@ -0,0 +1,3 @@
+declare const _exports: any;
+export = _exports;
+//# sourceMappingURL=app.plugin.d.ts.map

package/lib/typescript/app.plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"app.plugin.d.ts","sourceRoot":"","sources":["../../app.plugin.js"],"names":[],"mappings":""}

package/lib/typescript/src/index.d.ts

@@ -34,6 +34,7 @@ declare global {
     }
     interface GPUExternalTexture {
         destroy(): void;
+        readonly yuvToRgbMatrix: number[];
     }
     function createImageBitmap(image: ArrayBuffer | ArrayBufferView): Promise<ImageBitmap>;
 }

package/lib/typescript/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,cAAc,EACd,wBAAwB,EACxB,wBAAwB,EACxB,sBAAsB,EACtB,gCAAgC,EAChC,YAAY,EACZ,eAAe,EACf,WAAW,EACX,gBAAgB,EAChB,sBAAsB,EACvB,MAAM,SAAS,CAAC;AAEjB,cAAc,QAAQ,CAAC;AACvB,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC;AAC1B,YAAY,EACV,gBAAgB,EAChB,WAAW,EACX,cAAc,EACd,wBAAwB,EACxB,wBAAwB,EACxB,mBAAmB,EACnB,kBAAkB,EAClB,sBAAsB,EACtB,gCAAgC,EAChC,oCAAoC,EACpC,sBAAsB,EACtB,wBAAwB,EACxB,wBAAwB,GACzB,MAAM,SAAS,CAAC;AAEjB,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,SAAS;QACjB,GAAG,EAAE,GAAG,CAAC;KACV;IAED,IAAI,SAAS,EAAE,SAAS,CAAC;IAEzB,IAAI,QAAQ,EAAE;QACZ,GAAG,EAAE,GAAG,CAAC;QACT,MAAM,EAAE,OAAO,CAAC;QAChB,gBAAgB,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,YAAY,CAAC;QACtD,uBAAuB,EAAE,CACvB,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,KACX,eAAe,CAAC;QACrB,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,eAAe,GAAG,WAAW,KAAK,MAAM,CAAC;QACvE,iBAAiB,EAAE,OAAO,iBAAiB,CAAC;QAC5C,cAAc,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,gBAAgB,CAAC;QACnD,oBAAoB,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,gBAAgB,CAAC;QAI1E,gCAAgC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,gBAAgB,CAAC;QACxE,iBAAiB,EAAE,CACjB,IAAI,EAAE,MAAM,EACZ,WAAW,CAAC,EAAE,sBAAsB,KACjC,WAAW,CAAC;QACjB,kBAAkB,EAAE,MAAM,MAAM,CAAC;KAClC,CAAC;IAEF,UAAU,SAAS;QACjB,yBAAyB,CACvB,UAAU,EAAE,gCAAgC,GAC3C,sBAAsB,CAAC;QAC1B,iBAAiB,CAAC,UAAU,EAAE,wBAAwB,GAAG,cAAc,CAAC;KACzE;IAID,UAAU,mBAAmB;QAC3B,WAAW,CAAC,EAAE,wBAAwB,CAAC;KACxC;IAMD,UAAU,4BAA4B;QACpC,QAAQ,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,GAAG,GAAG,GAAG,CAAC;QAC9B,QAAQ,CAAC,EAAE,OAAO,CAAC;KACpB;IASD,UAAU,kBAAkB;QAC1B,OAAO,IAAI,IAAI,CAAC;KACjB;IAGD,SAAS,iBAAiB,CACxB,KAAK,EAAE,WAAW,GAAG,eAAe,GACnC,OAAO,CAAC,WAAW,CAAC,CAAC;CACzB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,cAAc,EACd,wBAAwB,EACxB,wBAAwB,EACxB,sBAAsB,EACtB,gCAAgC,EAChC,YAAY,EACZ,eAAe,EACf,WAAW,EACX,gBAAgB,EAChB,sBAAsB,EACvB,MAAM,SAAS,CAAC;AAEjB,cAAc,QAAQ,CAAC;AACvB,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC;AAC1B,YAAY,EACV,gBAAgB,EAChB,WAAW,EACX,cAAc,EACd,wBAAwB,EACxB,wBAAwB,EACxB,mBAAmB,EACnB,kBAAkB,EAClB,sBAAsB,EACtB,gCAAgC,EAChC,oCAAoC,EACpC,sBAAsB,EACtB,wBAAwB,EACxB,wBAAwB,GACzB,MAAM,SAAS,CAAC;AAEjB,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,SAAS;QACjB,GAAG,EAAE,GAAG,CAAC;KACV;IAED,IAAI,SAAS,EAAE,SAAS,CAAC;IAEzB,IAAI,QAAQ,EAAE;QACZ,GAAG,EAAE,GAAG,CAAC;QACT,MAAM,EAAE,OAAO,CAAC;QAChB,gBAAgB,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,YAAY,CAAC;QACtD,uBAAuB,EAAE,CACvB,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,KACX,eAAe,CAAC;QACrB,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,eAAe,GAAG,WAAW,KAAK,MAAM,CAAC;QACvE,iBAAiB,EAAE,OAAO,iBAAiB,CAAC;QAC5C,cAAc,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,gBAAgB,CAAC;QACnD,oBAAoB,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,gBAAgB,CAAC;QAI1E,gCAAgC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,gBAAgB,CAAC;QACxE,iBAAiB,EAAE,CACjB,IAAI,EAAE,MAAM,EACZ,WAAW,CAAC,EAAE,sBAAsB,KACjC,WAAW,CAAC;QACjB,kBAAkB,EAAE,MAAM,MAAM,CAAC;KAClC,CAAC;IAEF,UAAU,SAAS;QACjB,yBAAyB,CACvB,UAAU,EAAE,gCAAgC,GAC3C,sBAAsB,CAAC;QAC1B,iBAAiB,CAAC,UAAU,EAAE,wBAAwB,GAAG,cAAc,CAAC;KACzE;IAID,UAAU,mBAAmB;QAC3B,WAAW,CAAC,EAAE,wBAAwB,CAAC;KACxC;IAMD,UAAU,4BAA4B;QACpC,QAAQ,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,GAAG,GAAG,GAAG,CAAC;QAC9B,QAAQ,CAAC,EAAE,OAAO,CAAC;KACpB;IASD,UAAU,kBAAkB;QAC1B,OAAO,IAAI,IAAI,CAAC;QAShB,QAAQ,CAAC,cAAc,EAAE,MAAM,EAAE,CAAC;KACnC;IAGD,SAAS,iBAAiB,CACxB,KAAK,EAAE,WAAW,GAAG,eAAe,GACnC,OAAO,CAAC,WAAW,CAAC,CAAC;CACzB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-webgpu",
-  "version": "0.5.17",
+  "version": "0.6.0",
   "description": "React Native WebGPU",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",
@@ -18,15 +18,20 @@
     "cpp/**/*.{h,cpp}",
     "apple/**",
     "libs/**",
-    "*.podspec"
+    "*.podspec",
+    "app.plugin.js",
+    "plugin/build/**"
   ],
   "dawn": "chromium/7849",
   "scripts": {
     "test": "NODE_OPTIONS='--experimental-require-module' jest -i",
     "test:ref": "REFERENCE=true NODE_OPTIONS='--experimental-require-module' jest -i",
+    "test:node": "NODE_WEBGPU=true NODE_OPTIONS='--experimental-require-module' jest -i",
+    "test:plugin": "jest -c plugin/jest.config.js",
     "lint": "eslint . --ext .ts,.tsx  --max-warnings 0 --cache --fix",
     "tsc": "tsc --noEmit",
-    "build": "bob build",
+    "build": "bob build && yarn build:plugin",
+    "build:plugin": "tsc -p plugin/tsconfig.build.json",
     "release": "semantic-release",
     "build-dawn": "tsx scripts/build/dawn.ts",
     "clean-dawn": "rimraf ./libs && rimraf ../../externals/dawn/out",
@@ -41,7 +46,9 @@
   "keywords": [
     "react-native",
     "ios",
-    "android"
+    "android",
+    "expo",
+    "expo-config-plugin"
   ],
   "repository": {
     "type": "git",
@@ -59,6 +66,7 @@
     "provenance": true
   },
   "devDependencies": {
+    "@expo/config-plugins": "^57.0.3",
     "@semantic-release/commit-analyzer": "^13.0.0",
     "@semantic-release/exec": "^7.0.3",
     "@semantic-release/github": "^10.3.3",
@@ -100,6 +108,7 @@
     "ts-morph": "^22.0.0",
     "tsx": "^4.20.5",
     "typescript": "^5.2.2",
+    "webgpu": "0.4.0",
     "wgpu-matrix": "^3.0.2",
     "ws": "^8.18.0",
     "yargs": "^17.7.2"

package/plugin/build/index.d.ts

@@ -0,0 +1,3 @@
+import type { ConfigPlugin } from "@expo/config-plugins";
+declare const _default: ConfigPlugin<void>;
+export default _default;

package/plugin/build/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_plugins_1 = require("@expo/config-plugins");
+const withMetalApiValidation_1 = require("./withMetalApiValidation");
+const pkg = require("../../package.json");
+const withWebGPU = (config) => (0, withMetalApiValidation_1.withMetalApiValidationDisabled)(config);
+// Expo resolves config plugins through their default export (re-exported by
+// app.plugin.js at the package root).
+// eslint-disable-next-line import/no-default-export
+exports.default = (0, config_plugins_1.createRunOncePlugin)(withWebGPU, pkg.name, pkg.version);

package/plugin/build/setMetalApiValidation.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Rewrites an Xcode scheme (.xcscheme XML) so that Metal API validation is
+ * disabled for the Run action — the same effect as unchecking
+ * Product → Scheme → Edit Scheme → Run → Diagnostics → Metal API Validation.
+ *
+ * Xcode encodes the setting as the `enableGPUValidationMode` attribute on the
+ * <LaunchAction> element: the attribute is absent when validation is enabled
+ * (the default) and set to "1" when disabled. This mirrors how Flutter
+ * disables Metal API validation in its templates
+ * (https://github.com/flutter/flutter/pull/159228).
+ */
+export declare const setMetalApiValidationDisabled: (xcscheme: string) => string;

package/plugin/build/setMetalApiValidation.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setMetalApiValidationDisabled = void 0;
+/**
+ * Rewrites an Xcode scheme (.xcscheme XML) so that Metal API validation is
+ * disabled for the Run action — the same effect as unchecking
+ * Product → Scheme → Edit Scheme → Run → Diagnostics → Metal API Validation.
+ *
+ * Xcode encodes the setting as the `enableGPUValidationMode` attribute on the
+ * <LaunchAction> element: the attribute is absent when validation is enabled
+ * (the default) and set to "1" when disabled. This mirrors how Flutter
+ * disables Metal API validation in its templates
+ * (https://github.com/flutter/flutter/pull/159228).
+ */
+const setMetalApiValidationDisabled = (xcscheme) => xcscheme.replace(/<LaunchAction([^>]*)>/, (launchAction, attributes) => {
+    if (attributes.includes("enableGPUValidationMode")) {
+        return launchAction.replace(/enableGPUValidationMode\s*=\s*"[^"]*"/, 'enableGPUValidationMode = "1"');
+    }
+    return `<LaunchAction${attributes}\n      enableGPUValidationMode = "1">`;
+});
+exports.setMetalApiValidationDisabled = setMetalApiValidationDisabled;

package/plugin/build/withMetalApiValidation.d.ts

@@ -0,0 +1,9 @@
+import type { ConfigPlugin } from "@expo/config-plugins";
+/**
+ * Disables Metal API validation in every shared Xcode scheme of the iOS
+ * project. Dawn (the WebGPU implementation) triggers false-positive
+ * validation errors on the iOS Simulator that do not occur on device.
+ * Manually unchecking the setting in Xcode does not survive
+ * `npx expo prebuild --clean`, which is why this is a config plugin.
+ */
+export declare const withMetalApiValidationDisabled: ConfigPlugin;

package/plugin/build/withMetalApiValidation.js

@@ -0,0 +1,73 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withMetalApiValidationDisabled = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const config_plugins_1 = require("@expo/config-plugins");
+const setMetalApiValidation_1 = require("./setMetalApiValidation");
+const getSharedSchemes = (platformProjectRoot) => {
+    if (!fs.existsSync(platformProjectRoot)) {
+        return [];
+    }
+    return fs
+        .readdirSync(platformProjectRoot)
+        .filter((entry) => entry.endsWith(".xcodeproj"))
+        .map((entry) => path.join(platformProjectRoot, entry, "xcshareddata", "xcschemes"))
+        .filter((schemesDir) => fs.existsSync(schemesDir))
+        .flatMap((schemesDir) => fs
+        .readdirSync(schemesDir)
+        .filter((file) => file.endsWith(".xcscheme"))
+        .map((file) => path.join(schemesDir, file)));
+};
+/**
+ * Disables Metal API validation in every shared Xcode scheme of the iOS
+ * project. Dawn (the WebGPU implementation) triggers false-positive
+ * validation errors on the iOS Simulator that do not occur on device.
+ * Manually unchecking the setting in Xcode does not survive
+ * `npx expo prebuild --clean`, which is why this is a config plugin.
+ */
+const withMetalApiValidationDisabled = (config) => (0, config_plugins_1.withDangerousMod)(config, [
+    "ios",
+    async (cfg) => {
+        const schemes = getSharedSchemes(cfg.modRequest.platformProjectRoot);
+        for (const scheme of schemes) {
+            const contents = fs.readFileSync(scheme, "utf8");
+            fs.writeFileSync(scheme, (0, setMetalApiValidation_1.setMetalApiValidationDisabled)(contents));
+        }
+        return cfg;
+    },
+]);
+exports.withMetalApiValidationDisabled = withMetalApiValidationDisabled;

package/src/index.tsx

@@ -93,6 +93,15 @@ declare global {
   // pool (e.g. a camera/video player) and pile up GPU resources.
   interface GPUExternalTexture {
     destroy(): void;
+    // Non-spec extension: a 3x4 row-major matrix (12 numbers) mapping the
+    // sampled texel [r, g, b, 1] to gamma-encoded R'G'B'. On the Android
+    // opaque-YCbCr camera path, textureSampleBaseClampToEdge returns raw
+    // [Y, Cb, Cr] (Dawn hard-codes an RGB_IDENTITY Vulkan conversion); this
+    // matrix is derived per-buffer from the driver's suggested YCbCr model and
+    // range (BT.601/709/2020, full/narrow). Everywhere else (iOS, RGBA
+    // surfaces) it is the identity passthrough, so shaders can apply it
+    // unconditionally. Upload it as a uniform and multiply after sampling.
+    readonly yuvToRgbMatrix: number[];
   }
 
   // Extend createImageBitmap to accept ArrayBuffer/TypedArray (encoded image bytes)