@shopify/react-native-skia 2.10.0 → 2.11.0-next.1

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,162 +0,0 @@
-#include "GPU.h"
-
-#include <cstdio>
-#include <memory>
-#include <string>
-#include <unordered_set>
-#include <utility>
-#include <vector>
-
-#include "Convertors.h"
-#include "jsi/JSIConverter.h"
-#include "rnwgpu/async/RuntimeContext.h"
-
-namespace rnwgpu {
-
-GPU::GPU(jsi::Runtime & /*runtime*/, wgpu::Instance instance)
-    : NativeObject(CLASS_NAME), _instance(instance) {}
-
-async::AsyncTaskHandle GPU::requestAdapter(
-    jsi::Runtime &runtime,
-    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;
-
-  // Per-runtime context: async ops requested on this runtime resolve on this
-  // runtime's own thread (via its ProcessEvents pump).
-  auto context = async::RuntimeContext::getOrCreate(runtime, _instance);
-  return context->postTask(
-      [this, aOptions,
-       context](const async::AsyncTaskHandle::ResolveFunction &resolve,
-                const async::AsyncTaskHandle::RejectFunction &reject) {
-        _instance.RequestAdapter(
-            &aOptions, wgpu::CallbackMode::AllowProcessEvents,
-            [context, 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), context);
-                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::UniformBufferStandardLayout:
-      name = "uniform_buffer_standard_layout";
-      break;
-    case wgpu::WGSLLanguageFeatureName::SubgroupId:
-      name = "subgroup_id";
-      break;
-    case wgpu::WGSLLanguageFeatureName::FragmentDepth:
-      name = "fragment_depth";
-      break;
-    case wgpu::WGSLLanguageFeatureName::ImmediateAddressSpace:
-      name = "immediate_address_space";
-      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;
-    case wgpu::WGSLLanguageFeatureName::SizedBindingArray:
-      name = "sized_binding_array";
-      break;
-    case wgpu::WGSLLanguageFeatureName::TexelBuffers:
-      name = "texel_buffers";
-      break;
-    case wgpu::WGSLLanguageFeatureName::ChromiumPrint:
-      name = "chromium_print";
-      break;
-    case wgpu::WGSLLanguageFeatureName::TextureAndSamplerLet:
-      name = "texture_and_sampler_let";
-      break;
-    case wgpu::WGSLLanguageFeatureName::SubgroupUniformity:
-      name = "subgroup_uniformity";
-      break;
-    case wgpu::WGSLLanguageFeatureName::TextureFormatsTier1:
-      name = "texture_formats_tier1";
-      break;
-    case wgpu::WGSLLanguageFeatureName::BufferView:
-      name = "buffer_view";
-      break;
-    case wgpu::WGSLLanguageFeatureName::SwizzleAssignment:
-      name = "swizzle_assignment";
-      break;
-    case wgpu::WGSLLanguageFeatureName::LinearIndexing:
-      name = "linear_indexing";
-      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,60 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <string>
-#include <unordered_set>
-#include <variant>
-
-#include "descriptors/Unions.h"
-
-#include "jsi/NativeObject.h"
-
-#include "rnwgpu/async/AsyncTaskHandle.h"
-#include "rnwgpu/async/RuntimeContext.h"
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "GPUAdapter.h"
-#include "descriptors/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, wgpu::Instance instance);
-
-public:
-  std::string getBrand() { return CLASS_NAME; }
-
-  // requestAdapter needs the calling runtime so each runtime gets its own
-  // RuntimeContext (and ProcessEvents pump on its own thread).
-  async::AsyncTaskHandle requestAdapter(
-      jsi::Runtime &runtime,
-      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);
-    installMethodWithRuntime(runtime, prototype, "requestAdapter",
-                             &GPU::requestAdapter);
-    installMethod(runtime, prototype, "getPreferredCanvasFormat",
-                  &GPU::getPreferredCanvasFormat);
-    installGetter(runtime, prototype, "wgslLanguageFeatures",
-                  &GPU::getWgslLanguageFeatures);
-  }
-
-  inline const wgpu::Instance get() { return _instance; }
-
-private:
-  wgpu::Instance _instance;
-};
-
-} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUAdapter.cpp

@@ -1,239 +0,0 @@
-#include "GPUAdapter.h"
-
-#include <cstdio>
-#include <memory>
-#include <string>
-#include <unordered_set>
-#include <utility>
-#include <vector>
-
-#include "Convertors.h"
-
-#include "GPUFeatures.h"
-#include "GPUInternalError.h"
-#include "GPUOutOfMemoryError.h"
-#include "GPUValidationError.h"
-#include "jsi/JSIConverter.h"
-
-namespace rnwgpu {
-
-async::AsyncTaskHandle GPUAdapter::requestDevice(
-    jsi::Runtime &runtime,
-    std::optional<std::shared_ptr<GPUDeviceDescriptor>> descriptor) {
-  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) : "";
-        fprintf(stderr, "GPU Device Lost (%s): %s\n", lostReason, msg.c_str());
-        if (auto deviceHost = deviceLostBinding->lock()) {
-          deviceHost->notifyDeviceLost(reason, std::move(msg));
-        }
-      });
-
-  // Set uncaptured error callback using new template API
-  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 fullMessage =
-        message.length > 0 ? std::string(errorType) + ": " +
-                                 std::string(message.data, message.length)
-                           : "no message";
-    fprintf(stderr, "%s", fullMessage.c_str());
-
-    // Look up the GPUDevice from the registry and notify it
-    auto *gpuDevice = GPUDeviceRegistry::getInstance().getDevice(device.Get());
-    if (gpuDevice != nullptr) {
-      std::string messageStr =
-          message.length > 0 ? std::string(message.data, message.length) : "";
-
-      GPUErrorVariant error;
-      switch (type) {
-      case wgpu::ErrorType::Validation:
-        error = std::make_shared<GPUValidationError>(messageStr);
-        break;
-      case wgpu::ErrorType::OutOfMemory:
-        error = std::make_shared<GPUOutOfMemoryError>(messageStr);
-        break;
-      case wgpu::ErrorType::Internal:
-      case wgpu::ErrorType::Unknown:
-      default:
-        error = std::make_shared<GPUInternalError>(messageStr);
-        break;
-      }
-      gpuDevice->notifyUncapturedError(std::move(error));
-    }
-  });
-  std::string label =
-      descriptor.has_value() ? descriptor.value()->label.value_or("") : "";
-
-  auto creationRuntime = getCreationRuntime();
-  // Post to the CALLING runtime's context so the promise settles on the
-  // thread that requested it (see GPUBuffer::mapAsync). The GPUDevice is also
-  // bound to this context, honoring the contract that a device belongs to the
-  // runtime that requested it.
-  auto context =
-      async::RuntimeContext::getOrCreate(runtime, _async->instance());
-  return context->postTask(
-      [this, aDescriptor, descriptor, label = std::move(label),
-       deviceLostBinding, context,
-       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,
-            [context, 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;
-              }
-
-              // SetLoggingCallback is a repeatable callback (no callback mode),
-              // which rejects capturing lambdas. Pass the runtime pointer
-              // through Dawn's userdata argument instead of capturing it.
-              device.SetLoggingCallback(
-                  [](wgpu::LoggingType type, wgpu::StringView msg,
-                     jsi::Runtime *runtime) {
-                    if (runtime == nullptr) {
-                      return;
-                    }
-                    const char *logLevel = "";
-                    switch (type) {
-                    case wgpu::LoggingType::Warning:
-                      logLevel = "Warning";
-                      fprintf(stderr, "WebGPU Warning: %.*s\n",
-                              static_cast<int>(msg.length), msg.data);
-                      break;
-                    case wgpu::LoggingType::Error:
-                      logLevel = "Error";
-                      fprintf(stderr, "WebGPU Error: %.*s\n",
-                              static_cast<int>(msg.length), msg.data);
-                      break;
-                    case wgpu::LoggingType::Verbose:
-                      logLevel = "Verbose";
-                      break;
-                    case wgpu::LoggingType::Info:
-                      logLevel = "Info";
-                      break;
-                    default:
-                      logLevel = "Unknown";
-                      fprintf(stderr, "%s: %.*s\n", logLevel,
-                              static_cast<int>(msg.length), msg.data);
-                    }
-                  },
-                  creationRuntime);
-
-              auto deviceHost = std::make_shared<GPUDevice>(std::move(device),
-                                                            context, label);
-              *deviceLostBinding = 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;
-  for (size_t i = 0; i < supportedFeatures.featureCount; ++i) {
-    auto feature = supportedFeatures.features[i];
-    std::string name;
-    convertEnumToJSUnion(feature, &name);
-    if (name != "") {
-      result.insert(name);
-    }
-  }
-  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,60 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <string>
-#include <unordered_set>
-
-#include "descriptors/Unions.h"
-
-#include "jsi/NativeObject.h"
-
-#include "rnwgpu/async/AsyncTaskHandle.h"
-#include "rnwgpu/async/RuntimeContext.h"
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "GPUAdapterInfo.h"
-#include "GPUDevice.h"
-#include "GPUSupportedLimits.h"
-#include "descriptors/GPUDeviceDescriptor.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::RuntimeContext> async)
-      : NativeObject(CLASS_NAME), _instance(instance), _async(async) {}
-
-public:
-  std::string getBrand() { return CLASS_NAME; }
-
-  async::AsyncTaskHandle
-  requestDevice(jsi::Runtime &runtime,
-                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);
-    installMethodWithRuntime(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::RuntimeContext> _async;
-};
-
-} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUAdapterInfo.h

@@ -1,57 +0,0 @@
-#pragma once
-
-#include <string>
-#include <utility>
-
-#include "descriptors/Unions.h"
-
-#include "jsi/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 "descriptors/Unions.h"
-
-#include "jsi/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