@shopify/react-native-skia 2.6.4 → 2.6.5

package/cpp/rnwgpu/api/GPUExternalTexture.h

@@ -1,6 +1,8 @@
 #pragma once
 
+#include <memory>
 #include <string>
+#include <utility>
 
 #include "descriptors/Unions.h"
 
@@ -12,16 +14,61 @@ namespace rnwgpu {
 
 namespace jsi = facebook::jsi;
 
+struct GPUExternalTextureDescriptor;
+
 class GPUExternalTexture : public NativeObject<GPUExternalTexture> {
 public:
   static constexpr const char *CLASS_NAME = "GPUExternalTexture";
 
-  explicit GPUExternalTexture(wgpu::ExternalTexture instance, std::string label)
-      : NativeObject(CLASS_NAME), _instance(instance), _label(label) {}
+  // Import a native buffer (via descriptor.source, a CVPixelBufferRef /
+  // AHardwareBuffer* from Skia's NativeBuffer API) as a GPUExternalTexture on
+  // `device`: imports the native surface as SharedTextureMemory, begins access,
+  // and wraps the resulting wgpu::ExternalTexture together with the resources
+  // whose lifetime it owns. The matching EndAccess runs in destroy() / the
+  // destructor. Defined in GPUExternalTexture.cpp.
+  static std::shared_ptr<GPUExternalTexture>
+  Create(wgpu::Device device,
+         std::shared_ptr<GPUExternalTextureDescriptor> descriptor);
+
+  // Construct from an already-built wgpu::ExternalTexture plus the underlying
+  // shared-memory resources we need to keep alive. The wrapper takes ownership
+  // of the SharedTextureMemory + Texture and calls EndAccess on destruction so
+  // the producer (the native buffer's surface) can reclaim it.
+  GPUExternalTexture(wgpu::ExternalTexture instance,
+                     wgpu::SharedTextureMemory memory, wgpu::Texture texture,
+                     std::string label)
+      : NativeObject(CLASS_NAME), _instance(std::move(instance)),
+        _memory(std::move(memory)), _texture(std::move(texture)),
+        _label(std::move(label)) {}
+
+  ~GPUExternalTexture() override { destroy(); }
 
 public:
   std::string getBrand() { return CLASS_NAME; }
 
+  // End the shared-memory access window and release the underlying resources.
+  // Idempotent: safe to call more than once, and the destructor calls it as a
+  // garbage-collection fallback. Call it right after the queue.submit() that
+  // sampled this texture (never before): a GPUExternalTexture's access window
+  // is owned by this wrapper's lifetime, not by submit, so without an explicit
+  // destroy() the producer's surface stays claimed until GC runs. EndAccess is
+  // the designed post-submit call: Dawn keeps the texture alive for in-flight
+  // GPU work via the fences it returns.
+  void destroy() {
+    if (_memory && _texture) {
+      wgpu::SharedTextureMemoryEndAccessState state{};
+#if defined(__ANDROID__)
+      // Dawn's Vulkan backend requires the released VkImageLayout to be chained
+      // (matches BeginAccess in GPUExternalTexture::Create).
+      wgpu::SharedTextureMemoryVkImageLayoutEndState vkEnd{};
+      state.nextInChain = &vkEnd;
+#endif
+      (void)_memory.EndAccess(_texture, &state);
+    }
+    _texture = nullptr;
+    _memory = nullptr;
+  }
+
   std::string getLabel() { return _label; }
   void setLabel(const std::string &label) {
     _label = label;
@@ -33,12 +80,15 @@ public:
     installGetterSetter(runtime, prototype, "label",
                         &GPUExternalTexture::getLabel,
                         &GPUExternalTexture::setLabel);
+    installMethod(runtime, prototype, "destroy", &GPUExternalTexture::destroy);
   }
 
   inline const wgpu::ExternalTexture get() { return _instance; }
 
 private:
   wgpu::ExternalTexture _instance;
+  wgpu::SharedTextureMemory _memory;
+  wgpu::Texture _texture;
   std::string _label;
 };
 

package/cpp/rnwgpu/api/GPUQueue.cpp

@@ -1,5 +1,6 @@
 #include "GPUQueue.h"
 
+#include <cstring>
 #include <limits>
 #include <memory>
 #include <vector>
@@ -103,51 +104,55 @@ void GPUQueue::copyExternalImageToTexture(
     std::shared_ptr<GPUImageCopyExternalImage> source,
     std::shared_ptr<GPUImageCopyTextureTagged> destination,
     std::shared_ptr<GPUExtent3D> size) {
-  //  wgpu::TexelCopyTextureInfo dst{};
-  //  wgpu::TexelCopyBufferLayout layout{};
-  //  wgpu::Extent3D sz{};
-  //  Convertor conv;
-  //  uint32_t bytesPerPixel =
-  //      source->source->getSize() /
-  //      (source->source->getWidth() * source->source->getHeight());
-  //  auto dataLayout = std::make_shared<GPUImageDataLayout>(GPUImageDataLayout{
-  //      std::optional<double>{0.0},
-  //      std::optional<double>{
-  //          static_cast<double>(bytesPerPixel * source->source->getWidth())},
-  //      std::optional<double>{static_cast<double>(source->source->getHeight())}});
-  //  if (!conv(dst.aspect, destination->aspect) ||
-  //      !conv(dst.mipLevel, destination->mipLevel) ||
-  //      !conv(dst.origin, destination->origin) ||
-  //      !conv(dst.texture, destination->texture) ||
-  //      !conv(layout, dataLayout) || //
-  //      !conv(sz, size)) {
-  //    throw std::runtime_error("Invalid input for GPUQueue::writeTexture()");
-  //  }
-  //
-  //  if (source->flipY.value_or(false)) {
-  //    // Calculate the row size and total size
-  //    uint32_t rowSize = bytesPerPixel * source->source->getWidth();
-  //    uint32_t totalSize = source->source->getSize();
-  //
-  //    // Create a new buffer for the flipped data
-  //    std::vector<uint8_t> flippedData(totalSize);
-  //
-  //    // Flip the data vertically
-  //    for (uint32_t row = 0; row < source->source->getHeight(); ++row) {
-  //      std::memcpy(flippedData.data() +
-  //                      (source->source->getHeight() - 1 - row) * rowSize,
-  //                  static_cast<const uint8_t *>(source->source->getData()) +
-  //                      row * rowSize,
-  //                  rowSize);
-  //    }
-  //    // Use the flipped data for writing to texture
-  //    _instance.WriteTexture(&dst, flippedData.data(), totalSize, &layout,
-  //    &sz);
-  //  } else {
-  //
-  //    _instance.WriteTexture(&dst, source->source->getData(),
-  //                           source->source->getSize(), &layout, &sz);
-  //  }
+  if (!source || source->source == nullptr) {
+    throw std::runtime_error("GPUQueue::copyExternalImageToTexture(): "
+                             "source.source (ImageBitmap) is required");
+  }
+  // ImageBitmap holds decoded, row-major RGBA8 pixels. We upload them with
+  // WriteTexture (a CPU staging copy) rather than a GPU blit; that is enough
+  // for the common "decode an image, sample it" path and avoids needing a
+  // source GPUTexture.
+  const auto &pixels = source->source->data();
+  auto width = static_cast<uint32_t>(source->source->getWidth());
+  auto height = static_cast<uint32_t>(source->source->getHeight());
+  if (pixels.empty() || width == 0 || height == 0) {
+    throw std::runtime_error("GPUQueue::copyExternalImageToTexture(): "
+                             "ImageBitmap has no pixels (was it closed?)");
+  }
+  auto bytesPerPixel = static_cast<uint32_t>(
+      pixels.size() / (static_cast<size_t>(width) * height));
+  uint32_t rowSize = bytesPerPixel * width;
+
+  wgpu::TexelCopyTextureInfo dst{};
+  wgpu::TexelCopyBufferLayout layout{};
+  wgpu::Extent3D sz{};
+  Convertor conv;
+  auto dataLayout = std::make_shared<GPUImageDataLayout>(
+      GPUImageDataLayout{std::optional<double>{0.0},
+                         std::optional<double>{static_cast<double>(rowSize)},
+                         std::optional<double>{static_cast<double>(height)}});
+  if (!conv(dst.aspect, destination->aspect) ||
+      !conv(dst.mipLevel, destination->mipLevel) ||
+      !conv(dst.origin, destination->origin) ||
+      !conv(dst.texture, destination->texture) || !conv(layout, dataLayout) ||
+      !conv(sz, size)) {
+    throw std::runtime_error(
+        "Invalid input for GPUQueue::copyExternalImageToTexture()");
+  }
+
+  if (source->flipY.value_or(false)) {
+    // Flip rows so the image is uploaded bottom-up (matches the WebGPU
+    // copyExternalImageToTexture flipY semantics).
+    std::vector<uint8_t> flippedData(pixels.size());
+    for (uint32_t row = 0; row < height; ++row) {
+      std::memcpy(flippedData.data() + (height - 1 - row) * rowSize,
+                  pixels.data() + row * rowSize, rowSize);
+    }
+    _instance.WriteTexture(&dst, flippedData.data(), flippedData.size(),
+                           &layout, &sz);
+  } else {
+    _instance.WriteTexture(&dst, pixels.data(), pixels.size(), &layout, &sz);
+  }
 }
 
 void GPUQueue::writeTexture(std::shared_ptr<GPUImageCopyTexture> destination,

package/cpp/rnwgpu/api/GPUSharedTextureMemory.cpp

@@ -0,0 +1,82 @@
+#include "GPUSharedTextureMemory.h"
+
+#include <memory>
+#include <stdexcept>
+#include <string>
+
+#include "Convertors.h"
+
+namespace rnwgpu {
+
+std::shared_ptr<GPUTexture> GPUSharedTextureMemory::createTexture(
+    std::optional<std::shared_ptr<GPUTextureDescriptor>> descriptor) {
+  if (!descriptor.has_value() || descriptor.value() == nullptr) {
+    auto texture = _instance.CreateTexture();
+    // The texture aliases the shared memory; it doesn't own GPU allocation, so
+    // it doesn't report memory pressure.
+    return std::make_shared<GPUTexture>(texture, "", false);
+  }
+
+  wgpu::TextureDescriptor desc{};
+  Convertor conv;
+  if (!conv(desc, descriptor.value())) {
+    throw std::runtime_error(
+        "GPUSharedTextureMemory::createTexture(): Error with "
+        "GPUTextureDescriptor");
+  }
+  auto texture = _instance.CreateTexture(&desc);
+  return std::make_shared<GPUTexture>(
+      texture, descriptor.value()->label.value_or(""), false);
+}
+
+bool GPUSharedTextureMemory::beginAccess(std::shared_ptr<GPUTexture> texture,
+                                         bool initialized) {
+  if (!texture) {
+    throw std::runtime_error(
+        "GPUSharedTextureMemory::beginAccess(): texture is null");
+  }
+  wgpu::SharedTextureMemoryBeginAccessDescriptor desc{};
+  desc.initialized = initialized;
+  desc.concurrentRead = false;
+  desc.fenceCount = 0;
+  desc.fences = nullptr;
+  desc.signaledValues = nullptr;
+
+#if defined(__ANDROID__)
+  // Dawn's Vulkan backend (AHardwareBuffer) validates that the begin-access
+  // descriptor chains a SharedTextureMemoryVkImageLayoutBeginState specifying
+  // the VkImageLayout to acquire the image into. UNDEFINED (= 0) on both ends
+  // is the canonical "no prior GPU producer" pattern: Dawn performs an
+  // external-queue acquire from VK_QUEUE_FAMILY_EXTERNAL which preserves the
+  // AHB contents, then transitions to whatever layout the texture's actual
+  // usage requires.
+  wgpu::SharedTextureMemoryVkImageLayoutBeginState vkLayout{};
+  vkLayout.oldLayout = 0;
+  vkLayout.newLayout = 0;
+  desc.nextInChain = &vkLayout;
+#endif
+
+  auto status = _instance.BeginAccess(texture->get(), &desc);
+  return static_cast<bool>(status);
+}
+
+bool GPUSharedTextureMemory::endAccess(std::shared_ptr<GPUTexture> texture) {
+  if (!texture) {
+    throw std::runtime_error(
+        "GPUSharedTextureMemory::endAccess(): texture is null");
+  }
+  wgpu::SharedTextureMemoryEndAccessState state{};
+
+#if defined(__ANDROID__)
+  // Dawn's Vulkan backend writes the released old/new VkImageLayouts back into
+  // a chained SharedTextureMemoryVkImageLayoutEndState; validation requires
+  // the chain even when the caller doesn't read the values.
+  wgpu::SharedTextureMemoryVkImageLayoutEndState vkLayout{};
+  state.nextInChain = &vkLayout;
+#endif
+
+  auto status = _instance.EndAccess(texture->get(), &state);
+  return static_cast<bool>(status);
+}
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUSharedTextureMemory.h

@@ -0,0 +1,70 @@
+#pragma once
+
+#include <memory>
+#include <optional>
+#include <string>
+
+#include "jsi2/NativeObject.h"
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "GPUTexture.h"
+#include "descriptors/GPUTextureDescriptor.h"
+
+namespace rnwgpu {
+
+namespace jsi = facebook::jsi;
+
+class GPUSharedTextureMemory : public NativeObject<GPUSharedTextureMemory> {
+public:
+  static constexpr const char *CLASS_NAME = "GPUSharedTextureMemory";
+
+  explicit GPUSharedTextureMemory(wgpu::SharedTextureMemory instance,
+                                  std::string label)
+      : NativeObject(CLASS_NAME), _instance(std::move(instance)),
+        _label(std::move(label)) {}
+
+public:
+  std::string getBrand() { return CLASS_NAME; }
+
+  std::shared_ptr<GPUTexture> createTexture(
+      std::optional<std::shared_ptr<GPUTextureDescriptor>> descriptor);
+
+  // Returns true on success. `initialized` marks whether the shared memory's
+  // content should be preserved. Fence-based synchronization isn't exposed yet;
+  // we take the implicit/no-fence path that matches the common RN use cases
+  // (still images, single-producer frames).
+  bool beginAccess(std::shared_ptr<GPUTexture> texture, bool initialized);
+
+  // Returns true on success. Drops any fences produced by end-access (we do
+  // not yet surface them to JS).
+  bool endAccess(std::shared_ptr<GPUTexture> texture);
+
+  std::string getLabel() { return _label; }
+  void setLabel(const std::string &label) {
+    _label = label;
+    _instance.SetLabel(_label.c_str());
+  }
+
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installGetter(runtime, prototype, "__brand",
+                  &GPUSharedTextureMemory::getBrand);
+    installMethod(runtime, prototype, "createTexture",
+                  &GPUSharedTextureMemory::createTexture);
+    installMethod(runtime, prototype, "beginAccess",
+                  &GPUSharedTextureMemory::beginAccess);
+    installMethod(runtime, prototype, "endAccess",
+                  &GPUSharedTextureMemory::endAccess);
+    installGetterSetter(runtime, prototype, "label",
+                        &GPUSharedTextureMemory::getLabel,
+                        &GPUSharedTextureMemory::setLabel);
+  }
+
+  inline const wgpu::SharedTextureMemory get() { return _instance; }
+
+private:
+  wgpu::SharedTextureMemory _instance;
+  std::string _label;
+};
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/ImageBitmap.h

@@ -0,0 +1,62 @@
+#pragma once
+
+#include <cstdint>
+#include <memory>
+#include <utility>
+#include <vector>
+
+#include "jsi2/NativeObject.h"
+
+namespace rnwgpu {
+
+namespace jsi = facebook::jsi;
+
+// DRAFT — compile-unverified. Minimal ImageBitmap holding decoded, unpremul
+// RGBA8 pixels plus its dimensions. Produced by the global createImageBitmap()
+// binding (see RNSkManager.cpp). Decoding is done with Skia's own codec, so no
+// platform-specific image decoder is required.
+//
+// FOLLOW-UP: to make an ImageBitmap usable as a copyExternalImageToTexture
+// source, uncomment the `source` field + ImageBitmap converter in
+// rnwgpu/api/descriptors/GPUImageCopyExternalImage.h and upload `data()` in
+// GPUQueue::copyExternalImageToTexture. That GPU wiring is intentionally out of
+// scope for this draft.
+class ImageBitmap : public NativeObject<ImageBitmap> {
+public:
+  static constexpr const char *CLASS_NAME = "ImageBitmap";
+
+  ImageBitmap(std::vector<uint8_t> data, size_t width, size_t height)
+      : NativeObject(CLASS_NAME), _data(std::move(data)), _width(width),
+        _height(height) {}
+
+  size_t getWidth() { return _width; }
+
+  size_t getHeight() { return _height; }
+
+  // Per the spec, close() releases the bitmap's underlying pixels and zeroes
+  // its dimensions. Idempotent.
+  void close() {
+    _data.clear();
+    _data.shrink_to_fit();
+    _width = 0;
+    _height = 0;
+  }
+
+  // Decoded, unpremultiplied RGBA8 pixels (row-major, width*height*4 bytes).
+  const std::vector<uint8_t> &data() const { return _data; }
+
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installGetter(runtime, prototype, "width", &ImageBitmap::getWidth);
+    installGetter(runtime, prototype, "height", &ImageBitmap::getHeight);
+    installMethod(runtime, prototype, "close", &ImageBitmap::close);
+  }
+
+  size_t getMemoryPressure() override { return _data.size(); }
+
+private:
+  std::vector<uint8_t> _data;
+  size_t _width;
+  size_t _height;
+};
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/NativeBufferUtils.h

@@ -0,0 +1,87 @@
+#pragma once
+
+#include <cstdint>
+#include <stdexcept>
+#include <string>
+
+#include "webgpu/webgpu_cpp.h"
+
+#if defined(__APPLE__)
+#include "AppleNativeBuffer.h"
+#elif defined(__ANDROID__)
+#include <android/hardware_buffer.h>
+#endif
+
+namespace rnwgpu {
+
+// Import a Skia NativeBuffer pointer (a CVPixelBufferRef on Apple, an
+// AHardwareBuffer* on Android, as returned by Skia.NativeBuffer.MakeFromImage /
+// MakeTestBuffer) as a wgpu::SharedTextureMemory on `device`. When non-null,
+// outWidth/outHeight receive the surface dimensions. Returns a null
+// SharedTextureMemory if the import itself fails (the caller decides how to
+// report that); throws std::runtime_error for pre-import failures (a buffer
+// with no IOSurface, or an unsupported platform).
+//
+// The platform-specific chained descriptor only needs to outlive the
+// ImportSharedTextureMemory call, so it lives entirely within this function.
+// Shared by GPUDevice::importSharedTextureMemory and
+// GPUExternalTexture::Create.
+inline wgpu::SharedTextureMemory importNativeBufferAsSharedTextureMemory(
+    const wgpu::Device &device, void *bufferPtr, const std::string &label,
+    uint32_t *outWidth, uint32_t *outHeight) {
+  wgpu::SharedTextureMemoryDescriptor memDesc{};
+  if (!label.empty()) {
+    memDesc.label = wgpu::StringView(label.c_str(), label.size());
+  }
+
+  uint32_t width = 0;
+  uint32_t height = 0;
+  wgpu::SharedTextureMemory memory;
+
+#if defined(__APPLE__)
+  // Skia's NativeBuffer is a CVPixelBufferRef; extract its backing IOSurface
+  // (and dimensions) in Objective-C++ since CoreVideo isn't available here.
+  void *ioSurface = GetIOSurfaceFromNativeBuffer(bufferPtr, &width, &height);
+  if (ioSurface == nullptr) {
+    throw std::runtime_error(
+        "importNativeBufferAsSharedTextureMemory(): native "
+        "buffer has no IOSurface");
+  }
+  wgpu::SharedTextureMemoryIOSurfaceDescriptor platformDesc{};
+  platformDesc.ioSurface = ioSurface;
+  // Default off: enabling it propagates StorageBinding into properties.usage,
+  // which then forces memory.createTexture() (no-descriptor form) to validate
+  // the format against storage capabilities. bgra8unorm (the standard
+  // CVPixelBuffer format) only supports storage when the device opts into the
+  // bgra8unorm-storage feature, so unconditionally setting this here breaks the
+  // common sample-only case.
+  platformDesc.allowStorageBinding = false;
+  memDesc.nextInChain = &platformDesc;
+  memory = device.ImportSharedTextureMemory(&memDesc);
+#elif defined(__ANDROID__)
+  auto *ahb = reinterpret_cast<AHardwareBuffer *>(bufferPtr);
+  AHardwareBuffer_Desc ahbDesc = {};
+  AHardwareBuffer_describe(ahb, &ahbDesc);
+  width = ahbDesc.width;
+  height = ahbDesc.height;
+  wgpu::SharedTextureMemoryAHardwareBufferDescriptor platformDesc{};
+  platformDesc.handle = ahb;
+  memDesc.nextInChain = &platformDesc;
+  memory = device.ImportSharedTextureMemory(&memDesc);
+#else
+  (void)device;
+  (void)bufferPtr;
+  throw std::runtime_error(
+      "importNativeBufferAsSharedTextureMemory(): unsupported platform");
+#endif
+
+  if (outWidth != nullptr) {
+    *outWidth = width;
+  }
+  if (outHeight != nullptr) {
+    *outHeight = height;
+  }
+  return memory;
+}
+
+} // namespace rnwgpu

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

@@ -20,7 +20,7 @@ struct GPUBindGroupEntry {
   std::shared_ptr<GPUSampler> sampler = nullptr;
   std::shared_ptr<GPUTextureView> textureView = nullptr;
   std::shared_ptr<GPUBufferBinding> buffer = nullptr;
-  // external textures
+  std::shared_ptr<GPUExternalTexture> externalTexture = nullptr;
 };
 
 } // namespace rnwgpu
@@ -45,6 +45,9 @@ template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUBindGroupEntry>> {
           } else if (obj.hasNativeState<rnwgpu::GPUTextureView>(runtime)) {
             result->textureView =
                 obj.getNativeState<rnwgpu::GPUTextureView>(runtime);
+          } else if (obj.hasNativeState<rnwgpu::GPUExternalTexture>(runtime)) {
+            result->externalTexture =
+                obj.getNativeState<rnwgpu::GPUExternalTexture>(runtime);
           } else if (obj.hasNativeState<rnwgpu::GPUBuffer>(runtime)) {
             auto binding = std::make_shared<rnwgpu::GPUBufferBinding>();
             binding->buffer = obj.getNativeState<rnwgpu::GPUBuffer>(runtime);

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

@@ -7,7 +7,7 @@
 
 #include "jsi2/JSIConverter.h"
 
-#include "GPUDevice.h"
+#include "rnwgpu/api/GPUDevice.h"
 
 namespace jsi = facebook::jsi;
 

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

@@ -0,0 +1,56 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "jsi2/JSIConverter.h"
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+// Non-standard, Dawn-only. Mirrors wgpu::DawnTogglesDescriptor field-for-field
+// so the mapping to the native chained struct is 1:1. Chained onto the
+// wgpu::DeviceDescriptor in GPUAdapter::requestDevice.
+struct GPUDawnTogglesDescriptor {
+  std::optional<std::vector<std::string>> enabledToggles;  // Iterable<string>
+  std::optional<std::vector<std::string>> disabledToggles; // Iterable<string>
+};
+
+} // namespace rnwgpu
+
+namespace rnwgpu {
+
+template <>
+struct JSIConverter<std::shared_ptr<rnwgpu::GPUDawnTogglesDescriptor>> {
+  static std::shared_ptr<rnwgpu::GPUDawnTogglesDescriptor>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUDawnTogglesDescriptor>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "enabledToggles")) {
+        auto prop = value.getProperty(runtime, "enabledToggles");
+        result->enabledToggles =
+            JSIConverter<std::optional<std::vector<std::string>>>::fromJSI(
+                runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "disabledToggles")) {
+        auto prop = value.getProperty(runtime, "disabledToggles");
+        result->disabledToggles =
+            JSIConverter<std::optional<std::vector<std::string>>>::fromJSI(
+                runtime, prop, false);
+      }
+    }
+    return result;
+  }
+  static jsi::Value
+  toJSI(jsi::Runtime &runtime,
+        std::shared_ptr<rnwgpu::GPUDawnTogglesDescriptor> arg) {
+    throw std::runtime_error("Invalid GPUDawnTogglesDescriptor::toJSI()");
+  }
+};
+
+} // namespace rnwgpu

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

@@ -9,6 +9,7 @@
 
 #include "jsi2/JSIConverter.h"
 
+#include "GPUDawnTogglesDescriptor.h"
 #include "GPUQueueDescriptor.h"
 
 namespace jsi = facebook::jsi;
@@ -23,6 +24,9 @@ struct GPUDeviceDescriptor {
   std::optional<std::shared_ptr<GPUQueueDescriptor>>
       defaultQueue;                 // GPUQueueDescriptor
   std::optional<std::string> label; // string
+  // Non-standard Dawn-only device toggles, chained onto the wgpu::Device
+  // descriptor in GPUAdapter::requestDevice.
+  std::optional<std::shared_ptr<GPUDawnTogglesDescriptor>> dawnToggles;
 };
 
 } // namespace rnwgpu
@@ -86,6 +90,12 @@ template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUDeviceDescriptor>> {
         result->label = JSIConverter<std::optional<std::string>>::fromJSI(
             runtime, prop, false);
       }
+      if (value.hasProperty(runtime, "dawnToggles")) {
+        auto prop = value.getProperty(runtime, "dawnToggles");
+        result->dawnToggles = JSIConverter<std::optional<
+            std::shared_ptr<GPUDawnTogglesDescriptor>>>::fromJSI(runtime, prop,
+                                                                 false);
+      }
     }
 
     return result;