react-native-webgpu 0.5.11

package/cpp/rnwgpu/api/GPUDevice.h

@@ -0,0 +1,259 @@
+#pragma once
+
+#include <functional>
+#include <memory>
+#include <mutex>
+#include <optional>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+#include <variant>
+#include <vector>
+
+#include "Unions.h"
+
+#include "NativeObject.h"
+
+#include "rnwgpu/async/AsyncRunner.h"
+#include "rnwgpu/async/AsyncTaskHandle.h"
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "GPUBindGroup.h"
+#include "GPUBindGroupDescriptor.h"
+#include "GPUBindGroupLayout.h"
+#include "GPUBindGroupLayoutDescriptor.h"
+#include "GPUBuffer.h"
+#include "GPUBufferDescriptor.h"
+#include "GPUCommandEncoder.h"
+#include "GPUCommandEncoderDescriptor.h"
+#include "GPUComputePipeline.h"
+#include "GPUComputePipelineDescriptor.h"
+#include "GPUDeviceLostInfo.h"
+#include "GPUError.h"
+#include "GPUExternalTexture.h"
+#include "GPUExternalTextureDescriptor.h"
+#include "GPUPipelineLayout.h"
+#include "GPUPipelineLayoutDescriptor.h"
+#include "GPUQuerySet.h"
+#include "GPUQuerySetDescriptor.h"
+#include "GPUQueue.h"
+#include "GPURenderBundleEncoder.h"
+#include "GPURenderBundleEncoderDescriptor.h"
+#include "GPURenderPipeline.h"
+#include "GPURenderPipelineDescriptor.h"
+#include "GPUSampler.h"
+#include "GPUSamplerDescriptor.h"
+#include "GPUShaderModule.h"
+#include "GPUShaderModuleDescriptor.h"
+#include "GPUSupportedLimits.h"
+#include "GPUTexture.h"
+#include "GPUTextureDescriptor.h"
+#include "GPUUncapturedErrorEvent.h"
+
+namespace rnwgpu {
+
+namespace jsi = facebook::jsi;
+
+class GPUDevice : public NativeObject<GPUDevice> {
+public:
+  static constexpr const char *CLASS_NAME = "GPUDevice";
+
+  explicit GPUDevice(wgpu::Device instance,
+                     std::shared_ptr<async::AsyncRunner> async,
+                     std::string label)
+      : NativeObject(CLASS_NAME), _instance(instance), _async(async),
+        _label(label) {}
+
+  ~GPUDevice() override {
+    // Unregister from the static registry
+    unregisterDevice(_instance.Get());
+  }
+
+  // Static registry for looking up GPUDevice from wgpu::Device in callbacks
+  static void registerDevice(WGPUDevice handle,
+                             std::weak_ptr<GPUDevice> device) {
+    std::lock_guard<std::mutex> lock(getRegistryMutex());
+    getRegistry()[handle] = device;
+  }
+
+  static void unregisterDevice(WGPUDevice handle) {
+    std::lock_guard<std::mutex> lock(getRegistryMutex());
+    getRegistry().erase(handle);
+  }
+
+  static std::shared_ptr<GPUDevice> lookupDevice(WGPUDevice handle) {
+    std::lock_guard<std::mutex> lock(getRegistryMutex());
+    auto it = getRegistry().find(handle);
+    if (it != getRegistry().end()) {
+      return it->second.lock();
+    }
+    return nullptr;
+  }
+
+private:
+  static std::unordered_map<WGPUDevice, std::weak_ptr<GPUDevice>> &
+  getRegistry() {
+    static std::unordered_map<WGPUDevice, std::weak_ptr<GPUDevice>> registry;
+    return registry;
+  }
+
+  static std::mutex &getRegistryMutex() {
+    static std::mutex mutex;
+    return mutex;
+  }
+
+public:
+  std::string getBrand() { return CLASS_NAME; }
+
+  void destroy();
+  std::shared_ptr<GPUBuffer>
+  createBuffer(std::shared_ptr<GPUBufferDescriptor> descriptor);
+  std::shared_ptr<GPUTexture>
+  createTexture(std::shared_ptr<GPUTextureDescriptor> descriptor);
+  std::shared_ptr<GPUSampler> createSampler(
+      std::optional<std::shared_ptr<GPUSamplerDescriptor>> descriptor);
+  std::shared_ptr<GPUExternalTexture> importExternalTexture(
+      std::shared_ptr<GPUExternalTextureDescriptor> descriptor);
+  std::shared_ptr<GPUBindGroupLayout> createBindGroupLayout(
+      std::shared_ptr<GPUBindGroupLayoutDescriptor> descriptor);
+  std::shared_ptr<GPUPipelineLayout>
+  createPipelineLayout(std::shared_ptr<GPUPipelineLayoutDescriptor> descriptor);
+  std::shared_ptr<GPUBindGroup>
+  createBindGroup(std::shared_ptr<GPUBindGroupDescriptor> descriptor);
+  std::shared_ptr<GPUShaderModule>
+  createShaderModule(std::shared_ptr<GPUShaderModuleDescriptor> descriptor);
+  std::shared_ptr<GPUComputePipeline> createComputePipeline(
+      std::shared_ptr<GPUComputePipelineDescriptor> descriptor);
+  std::shared_ptr<GPURenderPipeline>
+  createRenderPipeline(std::shared_ptr<GPURenderPipelineDescriptor> descriptor);
+  async::AsyncTaskHandle createComputePipelineAsync(
+      std::shared_ptr<GPUComputePipelineDescriptor> descriptor);
+  async::AsyncTaskHandle createRenderPipelineAsync(
+      std::shared_ptr<GPURenderPipelineDescriptor> descriptor);
+  std::shared_ptr<GPUCommandEncoder> createCommandEncoder(
+      std::optional<std::shared_ptr<GPUCommandEncoderDescriptor>> descriptor);
+  std::shared_ptr<GPURenderBundleEncoder> createRenderBundleEncoder(
+      std::shared_ptr<GPURenderBundleEncoderDescriptor> descriptor);
+  std::shared_ptr<GPUQuerySet>
+  createQuerySet(std::shared_ptr<GPUQuerySetDescriptor> descriptor);
+  void pushErrorScope(wgpu::ErrorFilter filter);
+  async::AsyncTaskHandle popErrorScope();
+
+  std::unordered_set<std::string> getFeatures();
+  std::shared_ptr<GPUSupportedLimits> getLimits();
+  std::shared_ptr<GPUQueue> getQueue();
+  async::AsyncTaskHandle getLost();
+  void notifyDeviceLost(wgpu::DeviceLostReason reason, std::string message);
+  void notifyUncapturedError(wgpu::ErrorType type, std::string message);
+  void forceLossForTesting();
+
+  // EventTarget methods
+  void addEventListener(std::string type, jsi::Function callback);
+  void removeEventListener(std::string type, jsi::Function callback);
+
+  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", &GPUDevice::getBrand);
+    installMethod(runtime, prototype, "destroy", &GPUDevice::destroy);
+    installMethod(runtime, prototype, "createBuffer", &GPUDevice::createBuffer);
+    installMethod(runtime, prototype, "createTexture",
+                  &GPUDevice::createTexture);
+    installMethod(runtime, prototype, "createSampler",
+                  &GPUDevice::createSampler);
+    installMethod(runtime, prototype, "importExternalTexture",
+                  &GPUDevice::importExternalTexture);
+    installMethod(runtime, prototype, "createBindGroupLayout",
+                  &GPUDevice::createBindGroupLayout);
+    installMethod(runtime, prototype, "createPipelineLayout",
+                  &GPUDevice::createPipelineLayout);
+    installMethod(runtime, prototype, "createBindGroup",
+                  &GPUDevice::createBindGroup);
+    installMethod(runtime, prototype, "createShaderModule",
+                  &GPUDevice::createShaderModule);
+    installMethod(runtime, prototype, "createComputePipeline",
+                  &GPUDevice::createComputePipeline);
+    installMethod(runtime, prototype, "createRenderPipeline",
+                  &GPUDevice::createRenderPipeline);
+    installMethod(runtime, prototype, "createComputePipelineAsync",
+                  &GPUDevice::createComputePipelineAsync);
+    installMethod(runtime, prototype, "createRenderPipelineAsync",
+                  &GPUDevice::createRenderPipelineAsync);
+    installMethod(runtime, prototype, "createCommandEncoder",
+                  &GPUDevice::createCommandEncoder);
+    installMethod(runtime, prototype, "createRenderBundleEncoder",
+                  &GPUDevice::createRenderBundleEncoder);
+    installMethod(runtime, prototype, "createQuerySet",
+                  &GPUDevice::createQuerySet);
+    installMethod(runtime, prototype, "pushErrorScope",
+                  &GPUDevice::pushErrorScope);
+    installMethod(runtime, prototype, "popErrorScope",
+                  &GPUDevice::popErrorScope);
+    installGetter(runtime, prototype, "features", &GPUDevice::getFeatures);
+    installGetter(runtime, prototype, "limits", &GPUDevice::getLimits);
+    installGetter(runtime, prototype, "queue", &GPUDevice::getQueue);
+    installGetter(runtime, prototype, "lost", &GPUDevice::getLost);
+    installGetterSetter(runtime, prototype, "label", &GPUDevice::getLabel,
+                        &GPUDevice::setLabel);
+    installMethod(runtime, prototype, "forceLossForTesting",
+                  &GPUDevice::forceLossForTesting);
+
+    // EventTarget methods - installed manually since they take jsi::Function
+    auto addEventListenerFunc = jsi::Function::createFromHostFunction(
+        runtime, jsi::PropNameID::forUtf8(runtime, "addEventListener"), 2,
+        [](jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+           size_t count) -> jsi::Value {
+          if (count < 2 || !args[0].isString() || !args[1].isObject() ||
+              !args[1].getObject(rt).isFunction(rt)) {
+            return jsi::Value::undefined();
+          }
+          auto native = GPUDevice::fromValue(rt, thisVal);
+          native->addEventListener(args[0].getString(rt).utf8(rt),
+                                   args[1].getObject(rt).getFunction(rt));
+          return jsi::Value::undefined();
+        });
+    prototype.setProperty(runtime, "addEventListener", addEventListenerFunc);
+
+    auto removeEventListenerFunc = jsi::Function::createFromHostFunction(
+        runtime, jsi::PropNameID::forUtf8(runtime, "removeEventListener"), 2,
+        [](jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+           size_t count) -> jsi::Value {
+          if (count < 2 || !args[0].isString() || !args[1].isObject() ||
+              !args[1].getObject(rt).isFunction(rt)) {
+            return jsi::Value::undefined();
+          }
+          auto native = GPUDevice::fromValue(rt, thisVal);
+          native->removeEventListener(args[0].getString(rt).utf8(rt),
+                                      args[1].getObject(rt).getFunction(rt));
+          return jsi::Value::undefined();
+        });
+    prototype.setProperty(runtime, "removeEventListener",
+                          removeEventListenerFunc);
+  }
+
+  inline const wgpu::Device get() { return _instance; }
+
+private:
+  friend class GPUAdapter;
+
+  wgpu::Device _instance;
+  std::shared_ptr<async::AsyncRunner> _async;
+  std::string _label;
+  std::optional<async::AsyncTaskHandle> _lostHandle;
+  std::shared_ptr<GPUDeviceLostInfo> _lostInfo;
+  bool _lostSettled = false;
+  std::optional<async::AsyncTaskHandle::ResolveFunction> _lostResolve;
+
+  // Event listeners storage - keyed by event type
+  // Each entry contains a vector of shared_ptr to functions
+  std::unordered_map<std::string, std::vector<std::shared_ptr<jsi::Function>>>
+      _eventListeners;
+};
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUDeviceLostInfo.cpp

@@ -0,0 +1,7 @@
+#include "GPUDeviceLostInfo.h"
+#include <string>
+
+namespace rnwgpu {
+wgpu::DeviceLostReason getReason();
+std::string getMessage();
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUDeviceLostInfo.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <string>
+
+#include "Unions.h"
+
+#include "NativeObject.h"
+
+#include "webgpu/webgpu_cpp.h"
+
+namespace rnwgpu {
+
+namespace jsi = facebook::jsi;
+
+class GPUDeviceLostInfo : public NativeObject<GPUDeviceLostInfo> {
+public:
+  static constexpr const char *CLASS_NAME = "GPUDeviceLostInfo";
+
+  explicit GPUDeviceLostInfo(wgpu::DeviceLostReason reason, std::string message)
+      : NativeObject(CLASS_NAME), _reason(reason), _message(message) {}
+
+public:
+  std::string getBrand() { return CLASS_NAME; }
+
+  wgpu::DeviceLostReason getReason() { return _reason; }
+  std::string getMessage() { return _message; }
+
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installGetter(runtime, prototype, "__brand", &GPUDeviceLostInfo::getBrand);
+    installGetter(runtime, prototype, "reason", &GPUDeviceLostInfo::getReason);
+    installGetter(runtime, prototype, "message",
+                  &GPUDeviceLostInfo::getMessage);
+  }
+
+private:
+  wgpu::DeviceLostReason _reason;
+  std::string _message;
+};
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUError.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#include <string>
+
+#include "NativeObject.h"
+
+namespace rnwgpu {
+
+namespace jsi = facebook::jsi;
+
+class GPUError : public NativeObject<GPUError> {
+public:
+  static constexpr const char *CLASS_NAME = "GPUError";
+
+  explicit GPUError(std::string message)
+      : NativeObject(CLASS_NAME), _message(std::move(message)) {}
+
+public:
+  std::string getBrand() { return CLASS_NAME; }
+  std::string getMessage() { return _message; }
+
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installGetter(runtime, prototype, "__brand", &GPUError::getBrand);
+    installGetter(runtime, prototype, "message", &GPUError::getMessage);
+  }
+
+protected:
+  // Protected constructor for subclasses
+  GPUError(const char *className, std::string message)
+      : NativeObject(className), _message(std::move(message)) {}
+
+  std::string _message;
+};
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUExtent3D.h

@@ -0,0 +1,66 @@
+#pragma once
+
+#include <memory>
+
+#include "JSIConverter.h"
+
+#include "webgpu/webgpu_cpp.h"
+
+namespace rnwgpu {
+
+struct GPUExtent3D {
+  double width;
+  double height = 1;
+  double depthOrArrayLayers = 1;
+};
+
+template <> struct JSIConverter<std::shared_ptr<GPUExtent3D>> {
+  static std::shared_ptr<GPUExtent3D>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<GPUExtent3D>();
+    if (!outOfBounds && arg.isObject()) {
+      if (arg.getObject(runtime).isArray(runtime)) {
+        auto array = arg.getObject(runtime).asArray(runtime);
+        auto size = array.size(runtime);
+        if (size == 0) {
+          throw std::runtime_error(
+              "Expected an array of size >1 for GPUTExtent3D");
+        }
+        if (size > 0) {
+          result->width = array.getValueAtIndex(runtime, 0).asNumber();
+        }
+        if (size > 1) {
+          result->height = array.getValueAtIndex(runtime, 1).asNumber();
+        }
+        if (size > 2) {
+          result->depthOrArrayLayers =
+              array.getValueAtIndex(runtime, 2).asNumber();
+        }
+      } else {
+        auto object = arg.getObject(runtime);
+        if (object.hasProperty(runtime, "width")) {
+          result->width = object.getProperty(runtime, "width").asNumber();
+        } else {
+          throw std::runtime_error("Property GPUTExtent3D::width is required");
+        }
+        if (object.hasProperty(runtime, "height")) {
+          result->height = object.getProperty(runtime, "height").asNumber();
+        }
+        if (object.hasProperty(runtime, "depthOrArrayLayers")) {
+          result->depthOrArrayLayers =
+              object.getProperty(runtime, "depthOrArrayLayers").asNumber();
+        }
+      }
+    } else {
+      throw std::runtime_error("Expected an object for GPUTExtent3D");
+    }
+    return result;
+  }
+  static jsi::Value toJSI(jsi::Runtime &runtime,
+                          std::shared_ptr<GPUExtent3D> arg) {
+    // No conversions here
+    return jsi::Value::null();
+  }
+};
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUExternalTexture.h

@@ -0,0 +1,45 @@
+#pragma once
+
+#include <string>
+
+#include "Unions.h"
+
+#include "NativeObject.h"
+
+#include "webgpu/webgpu_cpp.h"
+
+namespace rnwgpu {
+
+namespace jsi = facebook::jsi;
+
+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) {}
+
+public:
+  std::string getBrand() { return CLASS_NAME; }
+
+  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", &GPUExternalTexture::getBrand);
+    installGetterSetter(runtime, prototype, "label",
+                        &GPUExternalTexture::getLabel,
+                        &GPUExternalTexture::setLabel);
+  }
+
+  inline const wgpu::ExternalTexture get() { return _instance; }
+
+private:
+  wgpu::ExternalTexture _instance;
+  std::string _label;
+};
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUFeatures.h

@@ -0,0 +1,203 @@
+#pragma once
+
+#include <string>
+
+#include <cstdio>
+
+#include "webgpu/webgpu_cpp.h"
+
+namespace rnwgpu {
+
+static void convertEnumToJSUnion(wgpu::FeatureName inEnum,
+                                 std::string *outUnion) {
+  switch (inEnum) {
+  case wgpu::FeatureName::DepthClipControl:
+    *outUnion = "depth-clip-control";
+    break;
+  case wgpu::FeatureName::Depth32FloatStencil8:
+    *outUnion = "depth32float-stencil8";
+    break;
+  case wgpu::FeatureName::TimestampQuery:
+    *outUnion = "timestamp-query";
+    break;
+  case wgpu::FeatureName::TextureCompressionBC:
+    *outUnion = "texture-compression-bc";
+    break;
+  case wgpu::FeatureName::TextureCompressionETC2:
+    *outUnion = "texture-compression-etc2";
+    break;
+  case wgpu::FeatureName::TextureCompressionASTC:
+    *outUnion = "texture-compression-astc";
+    break;
+  case wgpu::FeatureName::IndirectFirstInstance:
+    *outUnion = "indirect-first-instance";
+    break;
+  case wgpu::FeatureName::ShaderF16:
+    *outUnion = "shader-f16";
+    break;
+  case wgpu::FeatureName::RG11B10UfloatRenderable:
+    *outUnion = "rg11b10ufloat-renderable";
+    break;
+  case wgpu::FeatureName::BGRA8UnormStorage:
+    *outUnion = "bgra8unorm-storage";
+    break;
+  case wgpu::FeatureName::Float32Filterable:
+    *outUnion = "float32-filterable";
+    break;
+  case wgpu::FeatureName::Subgroups:
+    *outUnion = "subgroups";
+    break;
+  case wgpu::FeatureName::DawnInternalUsages:
+    *outUnion = "dawn-internal-usages";
+    break;
+  case wgpu::FeatureName::DawnMultiPlanarFormats:
+    *outUnion = "dawn-multi-planar-formats";
+    break;
+  case wgpu::FeatureName::DawnNative:
+    *outUnion = "dawn-native";
+    break;
+  case wgpu::FeatureName::ChromiumExperimentalTimestampQueryInsidePasses:
+    *outUnion = "chromium-experimental-timestamp-query-inside-passes";
+    break;
+  case wgpu::FeatureName::ImplicitDeviceSynchronization:
+    *outUnion = "implicit-device-synchronization";
+    break;
+  case wgpu::FeatureName::TransientAttachments:
+    *outUnion = "transient-attachments";
+    break;
+  case wgpu::FeatureName::MSAARenderToSingleSampled:
+    *outUnion = "msaa-render-to-single-sampled";
+    break;
+  case wgpu::FeatureName::DualSourceBlending:
+    *outUnion = "dual-source-blending";
+    break;
+  case wgpu::FeatureName::D3D11MultithreadProtected:
+    *outUnion = "d3d11-multithread-protected";
+    break;
+  case wgpu::FeatureName::ANGLETextureSharing:
+    *outUnion = "angle-texture-sharing";
+    break;
+  case wgpu::FeatureName::ChromiumExperimentalSubgroupMatrix:
+    *outUnion = "chromium-experimental-subgroups-matrix";
+    break;
+  case wgpu::FeatureName::PixelLocalStorageCoherent:
+    *outUnion = "pixel-local-storage-coherent";
+    break;
+  case wgpu::FeatureName::PixelLocalStorageNonCoherent:
+    *outUnion = "pixel-local-storage-non-coherent";
+    break;
+  case wgpu::FeatureName::Unorm16TextureFormats:
+    *outUnion = "unorm16-texture-formats";
+    break;
+  case wgpu::FeatureName::MultiPlanarFormatExtendedUsages:
+    *outUnion = "multi-planar-format-extended-usages";
+    break;
+  case wgpu::FeatureName::MultiPlanarFormatP010:
+    *outUnion = "multi-planar-format-p010";
+    break;
+  case wgpu::FeatureName::HostMappedPointer:
+    *outUnion = "host-mapped-pointer";
+    break;
+  case wgpu::FeatureName::MultiPlanarRenderTargets:
+    *outUnion = "multi-planar-render-targets";
+    break;
+  case wgpu::FeatureName::MultiPlanarFormatNv12a:
+    *outUnion = "multi-planar-format-nv12a";
+    break;
+  case wgpu::FeatureName::FramebufferFetch:
+    *outUnion = "framebuffer-fetch";
+    break;
+  case wgpu::FeatureName::BufferMapExtendedUsages:
+    *outUnion = "buffer-map-extended-usages";
+    break;
+  case wgpu::FeatureName::AdapterPropertiesMemoryHeaps:
+    *outUnion = "adapter-properties-memory-heaps";
+    break;
+  case wgpu::FeatureName::AdapterPropertiesD3D:
+    *outUnion = "adapter-properties-d3d";
+    break;
+  case wgpu::FeatureName::AdapterPropertiesVk:
+    *outUnion = "adapter-properties-vk";
+    break;
+  case wgpu::FeatureName::DawnFormatCapabilities:
+    *outUnion = "format-capabilities";
+    break;
+  case wgpu::FeatureName::DawnDrmFormatCapabilities:
+    *outUnion = "drm-format-capabilities";
+    break;
+  case wgpu::FeatureName::MultiPlanarFormatNv16:
+    *outUnion = "multi-planar-format-nv16";
+    break;
+  case wgpu::FeatureName::MultiPlanarFormatNv24:
+    *outUnion = "multi-planar-format-nv24";
+    break;
+  case wgpu::FeatureName::MultiPlanarFormatP210:
+    *outUnion = "multi-planar-format-p210";
+    break;
+  case wgpu::FeatureName::MultiPlanarFormatP410:
+    *outUnion = "multi-planar-format-p410";
+    break;
+  case wgpu::FeatureName::SharedTextureMemoryVkDedicatedAllocation:
+    *outUnion = "shared-texture-memory-vk-dedicated-allocation";
+    break;
+  case wgpu::FeatureName::SharedTextureMemoryAHardwareBuffer:
+    *outUnion = "shared-texture-memory-ahardware-buffer";
+    break;
+  case wgpu::FeatureName::SharedTextureMemoryDmaBuf:
+    *outUnion = "shared-texture-memory-dma-buf";
+    break;
+  case wgpu::FeatureName::SharedTextureMemoryOpaqueFD:
+    *outUnion = "shared-texture-memory-opaque-fd";
+    break;
+  case wgpu::FeatureName::SharedTextureMemoryZirconHandle:
+    *outUnion = "shared-texture-memory-zircon-handle";
+    break;
+  case wgpu::FeatureName::SharedTextureMemoryDXGISharedHandle:
+    *outUnion = "shared-texture-memory-dxgi-shared-handle";
+    break;
+  case wgpu::FeatureName::SharedTextureMemoryD3D11Texture2D:
+    *outUnion = "shared-texture-memory-d3d11-texture2d";
+    break;
+  case wgpu::FeatureName::SharedTextureMemoryIOSurface:
+    *outUnion = "shared-texture-memory-iosurface";
+    break;
+  case wgpu::FeatureName::SharedTextureMemoryEGLImage:
+    *outUnion = "shared-texture-memory-egl-image";
+    break;
+  case wgpu::FeatureName::SharedFenceVkSemaphoreOpaqueFD:
+    *outUnion = "shared-fence-vk-semaphore-opaque-fd";
+    break;
+  case wgpu::FeatureName::SharedFenceSyncFD:
+    *outUnion = "shared-fence-vk-semaphore-sync-fd";
+    break;
+  case wgpu::FeatureName::SharedFenceVkSemaphoreZirconHandle:
+    *outUnion = "shared-fence-vk-semaphore-zircon-handle";
+    break;
+  case wgpu::FeatureName::SharedFenceDXGISharedHandle:
+    *outUnion = "shared-fence-dxgi-shared-handle";
+    break;
+  case wgpu::FeatureName::SharedFenceMTLSharedEvent:
+    *outUnion = "shared-fence-mtl-shared-event";
+    break;
+  case wgpu::FeatureName::SharedBufferMemoryD3D12Resource:
+    *outUnion = "shared-buffer-memory-d3d12-resource";
+    break;
+  case wgpu::FeatureName::StaticSamplers:
+    *outUnion = "static-samplers";
+    break;
+  case wgpu::FeatureName::YCbCrVulkanSamplers:
+    *outUnion = "ycbcr-vulkan-samplers";
+    break;
+  case wgpu::FeatureName::ShaderModuleCompilationOptions:
+    *outUnion = "shader-module-compilation-options";
+    break;
+  case wgpu::FeatureName::DawnLoadResolveTexture:
+    *outUnion = "dawn-load-resolve-texture";
+    break;
+  default:
+    fprintf(stderr, "Unknown feature name %d\n", static_cast<int>(inEnum));
+    *outUnion = "";
+  }
+}
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUInternalError.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <string>
+
+#include "NativeObject.h"
+
+namespace rnwgpu {
+
+namespace jsi = facebook::jsi;
+
+class GPUInternalError : public NativeObject<GPUInternalError> {
+public:
+  static constexpr const char *CLASS_NAME = "GPUInternalError";
+
+  explicit GPUInternalError(std::string message)
+      : NativeObject(CLASS_NAME), _message(std::move(message)) {}
+
+public:
+  std::string getBrand() { return CLASS_NAME; }
+  std::string getMessage() { return _message; }
+
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installGetter(runtime, prototype, "__brand", &GPUInternalError::getBrand);
+    installGetter(runtime, prototype, "message", &GPUInternalError::getMessage);
+  }
+
+private:
+  std::string _message;
+};
+
+} // namespace rnwgpu