react-native-wgpu 0.5.11 → 0.5.14

package/cpp/rnwgpu/api/GPUDevice.h

@@ -1,259 +0,0 @@
-#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

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

package/cpp/rnwgpu/api/GPUDeviceLostInfo.h

@@ -1,40 +0,0 @@
-#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

@@ -1,35 +0,0 @@
-#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

@@ -1,66 +0,0 @@
-#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

@@ -1,45 +0,0 @@
-#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

@@ -1,203 +0,0 @@
-#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

@@ -1,31 +0,0 @@
-#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