react-native-wgpu 0.5.13 → 0.5.14

package/cpp/rnwgpu/api/External.h

@@ -1,12 +0,0 @@
-#pragma once
-
-#include "webgpu/webgpu_cpp.h"
-
-namespace rnwgpu {
-enum class PredefinedColorSpace : uint32_t {
-  DisplayP3 = 0,
-  Srgb = 1,
-};
-
-enum class PremultiplyAlpha : uint32_t { Default = 0, None = 1, Premultiply };
-} // namespace rnwgpu

package/cpp/rnwgpu/api/GPU.cpp

@@ -1,154 +0,0 @@
-#include "GPU.h"
-
-#include <cstdio>
-#include <memory>
-#include <string>
-#include <unordered_set>
-#include <utility>
-#include <vector>
-
-#include "Convertors.h"
-#include "JSIConverter.h"
-#include "rnwgpu/async/JSIMicrotaskDispatcher.h"
-
-namespace rnwgpu {
-
-GPU::GPU(jsi::Runtime &runtime) : NativeObject(CLASS_NAME) {
-  static const auto kTimedWaitAny = wgpu::InstanceFeatureName::TimedWaitAny;
-  wgpu::InstanceDescriptor instanceDesc{.requiredFeatureCount = 1,
-                                        .requiredFeatures = &kTimedWaitAny};
-
-  wgpu::InstanceLimits limits{.timedWaitAnyMaxCount = 64};
-  instanceDesc.requiredLimits = &limits;
-
-  // Expose Dawn's experimental adapter features. Several features needed by
-  // our Android external-texture path (YCbCrVulkanSamplers,
-  // OpaqueYCbCrAndroidForExternalTexture) are tagged Experimental in Dawn's
-  // feature table and are otherwise filtered out of adapter.features by
-  // PhysicalDeviceBase::GetSupportedFeatures. The allow_unsafe_apis toggle
-  // disables that filter so the features become visible;
-  // expose_wgsl_experimental_features is the parallel toggle for WGSL language
-  // features.
-  //
-  // Trade-off: these are instance-level Dawn toggles, so they apply to every
-  // adapter/device created from this instance, not just the external-texture
-  // path. There is no finer-grained, per-feature mechanism to surface these.
-  // The exposure is acceptable because the toggle only *un-hides* experimental
-  // features in adapter.features; it does not enable any of them. Nothing
-  // experimental becomes active unless application code explicitly lists that
-  // feature in requiredFeatures at device creation, so the default behavior of
-  // a device that asks for no experimental features is unchanged.
-  static const char *const kEnabledToggles[] = {
-      "allow_unsafe_apis",
-      "expose_wgsl_experimental_features",
-  };
-  wgpu::DawnTogglesDescriptor toggles;
-  toggles.enabledToggleCount = std::size(kEnabledToggles);
-  toggles.enabledToggles = kEnabledToggles;
-  instanceDesc.nextInChain = &toggles;
-
-  _instance = wgpu::CreateInstance(&instanceDesc);
-
-  auto dispatcher = std::make_shared<async::JSIMicrotaskDispatcher>(runtime);
-  _async = async::AsyncRunner::getOrCreate(runtime, _instance, dispatcher);
-}
-
-async::AsyncTaskHandle GPU::requestAdapter(
-    std::optional<std::shared_ptr<GPURequestAdapterOptions>> options) {
-  wgpu::RequestAdapterOptions aOptions;
-  Convertor conv;
-  if (!conv(aOptions, options)) {
-    throw std::runtime_error("Failed to convert GPUDeviceDescriptor");
-  }
-#ifdef __APPLE__
-  constexpr auto kDefaultBackendType = wgpu::BackendType::Metal;
-#else
-  constexpr auto kDefaultBackendType = wgpu::BackendType::Vulkan;
-#endif
-  aOptions.backendType = kDefaultBackendType;
-  return _async->postTask(
-      [this, aOptions](const async::AsyncTaskHandle::ResolveFunction &resolve,
-                       const async::AsyncTaskHandle::RejectFunction &reject) {
-        _instance.RequestAdapter(
-            &aOptions, wgpu::CallbackMode::AllowProcessEvents,
-            [asyncRunner = _async, resolve,
-             reject](wgpu::RequestAdapterStatus status, wgpu::Adapter adapter,
-                     wgpu::StringView message) {
-              if (message.length) {
-                fprintf(stderr, "%s", message.data);
-              }
-
-              if (status == wgpu::RequestAdapterStatus::Success && adapter) {
-                auto adapterHost = std::make_shared<GPUAdapter>(
-                    std::move(adapter), asyncRunner);
-                auto result =
-                    std::variant<std::nullptr_t, std::shared_ptr<GPUAdapter>>(
-                        adapterHost);
-                resolve([result =
-                             std::move(result)](jsi::Runtime &runtime) mutable {
-                  return JSIConverter<decltype(result)>::toJSI(runtime, result);
-                });
-              } else {
-                auto result =
-                    std::variant<std::nullptr_t, std::shared_ptr<GPUAdapter>>(
-                        nullptr);
-                resolve([result =
-                             std::move(result)](jsi::Runtime &runtime) mutable {
-                  return JSIConverter<decltype(result)>::toJSI(runtime, result);
-                });
-              }
-            });
-      });
-}
-
-std::unordered_set<std::string> GPU::getWgslLanguageFeatures() {
-  wgpu::SupportedWGSLLanguageFeatures supportedFeatures = {};
-  _instance.GetWGSLLanguageFeatures(&supportedFeatures);
-
-  std::unordered_set<std::string> result;
-  for (size_t i = 0; i < supportedFeatures.featureCount; i++) {
-    wgpu::WGSLLanguageFeatureName feature = supportedFeatures.features[i];
-    std::string name;
-    switch (feature) {
-    case wgpu::WGSLLanguageFeatureName::ReadonlyAndReadwriteStorageTextures:
-      name = "readonly_and_readwrite_storage_textures";
-      break;
-    case wgpu::WGSLLanguageFeatureName::Packed4x8IntegerDotProduct:
-      name = "packed_4x8_integer_dot_product";
-      break;
-    case wgpu::WGSLLanguageFeatureName::UnrestrictedPointerParameters:
-      name = "unrestricted_pointer_parameters";
-      break;
-    case wgpu::WGSLLanguageFeatureName::PointerCompositeAccess:
-      name = "pointer_composite_access";
-      break;
-    case wgpu::WGSLLanguageFeatureName::ChromiumTestingUnimplemented:
-      name = "chromium_testing_unimplemented";
-      break;
-    case wgpu::WGSLLanguageFeatureName::ChromiumTestingUnsafeExperimental:
-      name = "chromium_testing_unsafe_experimental";
-      break;
-    case wgpu::WGSLLanguageFeatureName::ChromiumTestingExperimental:
-      name = "chromium_testing_experimental";
-      break;
-    case wgpu::WGSLLanguageFeatureName::ChromiumTestingShippedWithKillswitch:
-      name = "chromium_testing_shipped_with_killswitch";
-      break;
-    case wgpu::WGSLLanguageFeatureName::ChromiumTestingShipped:
-      name = "chromium_testing_shipped";
-      break;
-    }
-    result.insert(name);
-  }
-  return result;
-}
-
-wgpu::TextureFormat GPU::getPreferredCanvasFormat() {
-#if defined(__ANDROID__)
-  return wgpu::TextureFormat::RGBA8Unorm;
-#else
-  return wgpu::TextureFormat::BGRA8Unorm;
-#endif // defined(__ANDROID__)
-}
-
-} // namespace rnwgpu

package/cpp/rnwgpu/api/GPU.h

@@ -1,58 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <string>
-#include <unordered_set>
-#include <variant>
-
-#include "Unions.h"
-
-#include "NativeObject.h"
-
-#include "rnwgpu/async/AsyncRunner.h"
-#include "rnwgpu/async/AsyncTaskHandle.h"
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "GPUAdapter.h"
-#include "GPURequestAdapterOptions.h"
-
-#include <webgpu/webgpu.h>
-
-namespace rnwgpu {
-
-namespace jsi = facebook::jsi;
-
-class GPU : public NativeObject<GPU> {
-public:
-  static constexpr const char *CLASS_NAME = "GPU";
-
-  explicit GPU(jsi::Runtime &runtime);
-
-public:
-  std::string getBrand() { return CLASS_NAME; }
-
-  async::AsyncTaskHandle requestAdapter(
-      std::optional<std::shared_ptr<GPURequestAdapterOptions>> options);
-  wgpu::TextureFormat getPreferredCanvasFormat();
-
-  std::unordered_set<std::string> getWgslLanguageFeatures();
-
-  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
-    installGetter(runtime, prototype, "__brand", &GPU::getBrand);
-    installMethod(runtime, prototype, "requestAdapter", &GPU::requestAdapter);
-    installMethod(runtime, prototype, "getPreferredCanvasFormat",
-                  &GPU::getPreferredCanvasFormat);
-    installGetter(runtime, prototype, "wgslLanguageFeatures",
-                  &GPU::getWgslLanguageFeatures);
-  }
-
-  inline const wgpu::Instance get() { return _instance; }
-  inline std::shared_ptr<async::AsyncRunner> getAsyncRunner() { return _async; }
-
-private:
-  wgpu::Instance _instance;
-  std::shared_ptr<async::AsyncRunner> _async;
-};
-
-} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUAdapter.cpp

@@ -1,267 +0,0 @@
-#include "GPUAdapter.h"
-
-#include <algorithm>
-#include <cstdio>
-#include <memory>
-#include <string>
-#include <unordered_set>
-#include <utility>
-#include <vector>
-
-#include "Convertors.h"
-
-#include "GPUFeatures.h"
-#include "JSIConverter.h"
-#include "RnFeatures.h"
-#include "WGPULogger.h"
-
-namespace rnwgpu {
-
-async::AsyncTaskHandle GPUAdapter::requestDevice(
-    std::optional<std::shared_ptr<GPUDeviceDescriptor>> descriptor) {
-  // Enable the react-native-wgpu "native-texture" umbrella by default, mirroring
-  // the web where importExternalTexture is core and needs no feature request.
-  // We append the umbrella's backing Dawn features to requiredFeatures so the
-  // capability is on without the caller listing it. Two rules keep this safe:
-  //   - All-or-nothing: only inject when the adapter supports *every* backing
-  //     feature (same semantics as maybeSynthesizeRnNativeTextureFeature). On a
-  //     web/fallback adapter the backing set is empty or unsupported, so this is
-  //     a no-op and device creation is unaffected.
-  //   - Requesting a feature the adapter doesn't support makes RequestDevice
-  //     fail, hence the support check below.
-  // Callers can still pass "rnwebgpu/native-texture" explicitly; the dedupe
-  // keeps that idempotent.
-  {
-    auto backing = rnNativeTextureBackingFeatures();
-    if (!backing.empty()) {
-      wgpu::SupportedFeatures supported;
-      _instance.GetFeatures(&supported);
-      std::unordered_set<wgpu::FeatureName> supportedSet(
-          supported.features, supported.features + supported.featureCount);
-      bool allSupported = std::all_of(
-          backing.begin(), backing.end(),
-          [&](wgpu::FeatureName f) { return supportedSet.count(f) > 0; });
-      if (allSupported) {
-        if (!descriptor.has_value()) {
-          descriptor = std::make_shared<GPUDeviceDescriptor>();
-        }
-        auto &desc = descriptor.value();
-        if (!desc->requiredFeatures.has_value()) {
-          desc->requiredFeatures = std::vector<wgpu::FeatureName>{};
-        }
-        auto &features = desc->requiredFeatures.value();
-        for (auto f : backing) {
-          if (std::find(features.begin(), features.end(), f) ==
-              features.end()) {
-            features.push_back(f);
-          }
-        }
-      }
-    }
-  }
-
-  wgpu::DeviceDescriptor aDescriptor;
-  Convertor conv;
-  if (!conv(aDescriptor, descriptor)) {
-    throw std::runtime_error("Failed to convert GPUDeviceDescriptor");
-  }
-  auto deviceLostBinding = std::make_shared<std::weak_ptr<GPUDevice>>();
-  // Set device lost callback using new template API
-  aDescriptor.SetDeviceLostCallback(
-      wgpu::CallbackMode::AllowSpontaneous,
-      [deviceLostBinding](const wgpu::Device & /*device*/,
-                          wgpu::DeviceLostReason reason,
-                          wgpu::StringView message) {
-        const char *lostReason = "";
-        switch (reason) {
-        case wgpu::DeviceLostReason::Destroyed:
-          lostReason = "Destroyed";
-          break;
-        case wgpu::DeviceLostReason::Unknown:
-          lostReason = "Unknown";
-          break;
-        default:
-          lostReason = "Unknown";
-        }
-        std::string msg =
-            message.length ? std::string(message.data, message.length) : "";
-        Logger::logToConsole("GPU Device Lost (%s): %s", lostReason,
-                             msg.c_str());
-        if (auto deviceHost = deviceLostBinding->lock()) {
-          deviceHost->notifyDeviceLost(reason, std::move(msg));
-        }
-      });
-
-  // Set uncaptured error callback using new template API
-  // Note: This callback cannot capture variables, so we use a static registry
-  // to look up the GPUDevice from the wgpu::Device handle.
-  aDescriptor.SetUncapturedErrorCallback([](const wgpu::Device &device,
-                                            wgpu::ErrorType type,
-                                            wgpu::StringView message) {
-    const char *errorType = "";
-    switch (type) {
-    case wgpu::ErrorType::Validation:
-      errorType = "Validation";
-      break;
-    case wgpu::ErrorType::OutOfMemory:
-      errorType = "Out of Memory";
-      break;
-    case wgpu::ErrorType::Internal:
-      errorType = "Internal";
-      break;
-    case wgpu::ErrorType::Unknown:
-      errorType = "Unknown";
-      break;
-    default:
-      errorType = "Unknown";
-    }
-    std::string msg =
-        message.length > 0 ? std::string(message.data, message.length) : "";
-    std::string fullMessage =
-        msg.length() > 0 ? std::string(errorType) + ": " + msg : "no message";
-    fprintf(stderr, "%s\n", fullMessage.c_str());
-
-    // Look up the GPUDevice from the registry and notify it
-    if (auto gpuDevice = GPUDevice::lookupDevice(device.Get())) {
-      gpuDevice->notifyUncapturedError(type, std::move(msg));
-    }
-  });
-  std::string label =
-      descriptor.has_value() ? descriptor.value()->label.value_or("") : "";
-
-  auto creationRuntime = getCreationRuntime();
-  return _async->postTask(
-      [this, aDescriptor, descriptor, label = std::move(label),
-       deviceLostBinding,
-       creationRuntime](const async::AsyncTaskHandle::ResolveFunction &resolve,
-                        const async::AsyncTaskHandle::RejectFunction &reject) {
-        // Build a local mutable copy so we can chain Dawn's device toggles.
-        // The toggle name strings are owned by `descriptor` (captured above),
-        // and the const char* / DawnTogglesDescriptor locals live for the
-        // whole synchronous RequestDevice call below, which is when Dawn reads
-        // the chained struct.
-        wgpu::DeviceDescriptor deviceDesc = aDescriptor;
-        wgpu::DawnTogglesDescriptor toggles{};
-        std::vector<const char *> enabledToggles;
-        std::vector<const char *> disabledToggles;
-        if (descriptor.has_value() && descriptor.value()->dawnToggles) {
-          const auto &dawnToggles = descriptor.value()->dawnToggles.value();
-          if (dawnToggles->enabledToggles) {
-            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();
-          }
-          deviceDesc.nextInChain = &toggles;
-        }
-        _instance.RequestDevice(
-            &deviceDesc, wgpu::CallbackMode::AllowProcessEvents,
-            [asyncRunner = _async, resolve, reject, label, creationRuntime,
-             deviceLostBinding](wgpu::RequestDeviceStatus status,
-                                wgpu::Device device,
-                                wgpu::StringView message) {
-              if (message.length) {
-                fprintf(stderr, "%s", message.data);
-              }
-
-              if (status != wgpu::RequestDeviceStatus::Success || !device) {
-                std::string error =
-                    message.length ? std::string(message.data, message.length)
-                                   : "Failed to request device";
-                reject(std::move(error));
-                return;
-              }
-
-              device.SetLoggingCallback(
-                  [](wgpu::LoggingType type, wgpu::StringView msg,
-                     jsi::Runtime *creationRuntime) {
-                    if (creationRuntime == nullptr) {
-                      return;
-                    }
-                    const char *logLevel = "";
-                    switch (type) {
-                    case wgpu::LoggingType::Warning:
-                      logLevel = "Warning";
-                      Logger::warnToJavascriptConsole(
-                          *creationRuntime,
-                          std::string(msg.data, msg.length));
-                      break;
-                    case wgpu::LoggingType::Error:
-                      logLevel = "Error";
-                      Logger::errorToJavascriptConsole(
-                          *creationRuntime,
-                          std::string(msg.data, msg.length));
-                      break;
-                    case wgpu::LoggingType::Verbose:
-                      logLevel = "Verbose";
-                      break;
-                    case wgpu::LoggingType::Info:
-                      logLevel = "Info";
-                      break;
-                    default:
-                      logLevel = "Unknown";
-                      Logger::logToConsole("%s: %.*s", logLevel,
-                                           static_cast<int>(msg.length),
-                                           msg.data);
-                    }
-                  },
-                  creationRuntime);
-
-              auto deviceHost = std::make_shared<GPUDevice>(std::move(device),
-                                                            asyncRunner, label);
-              *deviceLostBinding = deviceHost;
-
-              // Register the device in the static registry so the uncaptured
-              // error callback can find it
-              GPUDevice::registerDevice(deviceHost->get().Get(), deviceHost);
-
-              resolve([deviceHost = std::move(deviceHost)](
-                          jsi::Runtime &runtime) mutable {
-                return JSIConverter<std::shared_ptr<GPUDevice>>::toJSI(
-                    runtime, deviceHost);
-              });
-            });
-      });
-}
-
-std::unordered_set<std::string> GPUAdapter::getFeatures() {
-  wgpu::SupportedFeatures supportedFeatures;
-  _instance.GetFeatures(&supportedFeatures);
-  std::unordered_set<std::string> result;
-  std::unordered_set<wgpu::FeatureName> enabled;
-  for (size_t i = 0; i < supportedFeatures.featureCount; ++i) {
-    auto feature = supportedFeatures.features[i];
-    enabled.insert(feature);
-    std::string name;
-    convertEnumToJSUnion(feature, &name);
-    if (name != "") {
-      result.insert(name);
-    }
-  }
-  maybeSynthesizeRnNativeTextureFeature(enabled, result);
-  return result;
-}
-
-std::shared_ptr<GPUSupportedLimits> GPUAdapter::getLimits() {
-  wgpu::Limits limits{};
-  if (!_instance.GetLimits(&limits)) {
-    throw std::runtime_error("Failed to get limits");
-  }
-  return std::make_shared<GPUSupportedLimits>(limits);
-}
-
-std::shared_ptr<GPUAdapterInfo> GPUAdapter::getInfo() {
-  wgpu::AdapterInfo info = {};
-  _instance.GetInfo(&info);
-  return std::make_shared<GPUAdapterInfo>(info);
-}
-
-} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUAdapter.h

@@ -1,59 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <string>
-#include <unordered_set>
-
-#include "Unions.h"
-
-#include "NativeObject.h"
-
-#include "rnwgpu/async/AsyncRunner.h"
-#include "rnwgpu/async/AsyncTaskHandle.h"
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "GPUAdapterInfo.h"
-#include "GPUDevice.h"
-#include "GPUDeviceDescriptor.h"
-#include "GPUSupportedLimits.h"
-
-namespace rnwgpu {
-
-namespace jsi = facebook::jsi;
-
-class GPUAdapter : public NativeObject<GPUAdapter> {
-public:
-  static constexpr const char *CLASS_NAME = "GPUAdapter";
-
-  explicit GPUAdapter(wgpu::Adapter instance,
-                      std::shared_ptr<async::AsyncRunner> async)
-      : NativeObject(CLASS_NAME), _instance(instance), _async(async) {}
-
-public:
-  std::string getBrand() { return CLASS_NAME; }
-
-  async::AsyncTaskHandle
-  requestDevice(std::optional<std::shared_ptr<GPUDeviceDescriptor>> descriptor);
-
-  std::unordered_set<std::string> getFeatures();
-  std::shared_ptr<GPUSupportedLimits> getLimits();
-  std::shared_ptr<GPUAdapterInfo> getInfo();
-
-  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
-    installGetter(runtime, prototype, "__brand", &GPUAdapter::getBrand);
-    installMethod(runtime, prototype, "requestDevice",
-                  &GPUAdapter::requestDevice);
-    installGetter(runtime, prototype, "features", &GPUAdapter::getFeatures);
-    installGetter(runtime, prototype, "limits", &GPUAdapter::getLimits);
-    installGetter(runtime, prototype, "info", &GPUAdapter::getInfo);
-  }
-
-  inline const wgpu::Adapter get() { return _instance; }
-
-private:
-  wgpu::Adapter _instance;
-  std::shared_ptr<async::AsyncRunner> _async;
-};
-
-} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUAdapterInfo.h

@@ -1,57 +0,0 @@
-#pragma once
-
-#include <string>
-#include <utility>
-
-#include "Unions.h"
-
-#include "NativeObject.h"
-
-#include "Convertors.h"
-
-#include "webgpu/webgpu_cpp.h"
-
-namespace rnwgpu {
-
-namespace jsi = facebook::jsi;
-
-class GPUAdapterInfo : public NativeObject<GPUAdapterInfo> {
-public:
-  static constexpr const char *CLASS_NAME = "GPUAdapterInfo";
-
-  explicit GPUAdapterInfo(wgpu::AdapterInfo &info)
-      : NativeObject(CLASS_NAME), _vendor(info.vendor),
-        _architecture(info.architecture), _device(info.device),
-        _description(info.description),
-        _isFallbackAdapter(info.adapterType == wgpu::AdapterType::CPU) {}
-
-public:
-  std::string getBrand() { return CLASS_NAME; }
-
-  std::string getVendor() { return _vendor; }
-  std::string getArchitecture() { return _architecture; }
-  std::string getDevice() { return _device; }
-  std::string getDescription() { return _description; }
-  bool getIsFallbackAdapter() { return _isFallbackAdapter; }
-
-  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
-    installGetter(runtime, prototype, "__brand", &GPUAdapterInfo::getBrand);
-    installGetter(runtime, prototype, "vendor", &GPUAdapterInfo::getVendor);
-    installGetter(runtime, prototype, "architecture",
-                  &GPUAdapterInfo::getArchitecture);
-    installGetter(runtime, prototype, "device", &GPUAdapterInfo::getDevice);
-    installGetter(runtime, prototype, "description",
-                  &GPUAdapterInfo::getDescription);
-    installGetter(runtime, prototype, "isFallbackAdapter",
-                  &GPUAdapterInfo::getIsFallbackAdapter);
-  }
-
-private:
-  std::string _vendor;
-  std::string _architecture;
-  std::string _device;
-  std::string _description;
-  bool _isFallbackAdapter;
-};
-
-} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUBindGroup.cpp

@@ -1,3 +0,0 @@
-#include "GPUBindGroup.h"
-
-namespace rnwgpu {} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUBindGroup.h

@@ -1,51 +0,0 @@
-#pragma once
-
-#include <string>
-
-#include "Unions.h"
-
-#include "NativeObject.h"
-
-#include "webgpu/webgpu_cpp.h"
-
-namespace rnwgpu {
-
-namespace jsi = facebook::jsi;
-
-class GPUBindGroup : public NativeObject<GPUBindGroup> {
-public:
-  static constexpr const char *CLASS_NAME = "GPUBindGroup";
-
-  explicit GPUBindGroup(wgpu::BindGroup 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", &GPUBindGroup::getBrand);
-    installGetterSetter(runtime, prototype, "label", &GPUBindGroup::getLabel,
-                        &GPUBindGroup::setLabel);
-  }
-
-  inline const wgpu::BindGroup get() { return _instance; }
-
-  size_t getMemoryPressure() override {
-    // Bind groups store resource bindings and descriptor state
-    // They reference buffers, textures, samplers, etc.
-    // Estimate: 1KB per bind group (descriptor tables and binding state)
-    return 1024;
-  }
-
-private:
-  wgpu::BindGroup _instance;
-  std::string _label;
-};
-
-} // namespace rnwgpu