react-native-webgpu 0.5.18 → 0.6.0

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/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/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.18",
+  "version": "0.6.0",
   "description": "React Native WebGPU",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",
@@ -26,6 +26,7 @@
   "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",
@@ -107,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/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)