@shopify/react-native-skia 2.4.15 → 2.4.17

package/cpp/rnwgpu/api/GPUSupportedLimits.cpp

@@ -0,0 +1,129 @@
+#include "GPUSupportedLimits.h"
+
+namespace rnwgpu {
+
+double GPUSupportedLimits::getMaxTextureDimension1D() {
+  return _instance.maxTextureDimension1D;
+}
+
+double GPUSupportedLimits::getMaxTextureDimension2D() {
+  return _instance.maxTextureDimension2D;
+}
+
+double GPUSupportedLimits::getMaxTextureDimension3D() {
+  return _instance.maxTextureDimension3D;
+}
+
+double GPUSupportedLimits::getMaxTextureArrayLayers() {
+  return _instance.maxTextureArrayLayers;
+}
+
+double GPUSupportedLimits::getMaxBindGroups() {
+  return _instance.maxBindGroups;
+}
+
+double GPUSupportedLimits::getMaxBindGroupsPlusVertexBuffers() {
+  return _instance.maxBindGroupsPlusVertexBuffers;
+}
+
+double GPUSupportedLimits::getMaxBindingsPerBindGroup() {
+  return _instance.maxBindingsPerBindGroup;
+}
+
+double GPUSupportedLimits::getMaxDynamicUniformBuffersPerPipelineLayout() {
+  return _instance.maxDynamicUniformBuffersPerPipelineLayout;
+}
+
+double GPUSupportedLimits::getMaxDynamicStorageBuffersPerPipelineLayout() {
+  return _instance.maxDynamicStorageBuffersPerPipelineLayout;
+}
+
+double GPUSupportedLimits::getMaxSampledTexturesPerShaderStage() {
+  return _instance.maxSampledTexturesPerShaderStage;
+}
+
+double GPUSupportedLimits::getMaxSamplersPerShaderStage() {
+  return _instance.maxSamplersPerShaderStage;
+}
+
+double GPUSupportedLimits::getMaxStorageBuffersPerShaderStage() {
+  return _instance.maxStorageBuffersPerShaderStage;
+}
+
+double GPUSupportedLimits::getMaxStorageTexturesPerShaderStage() {
+  return _instance.maxStorageTexturesPerShaderStage;
+}
+
+double GPUSupportedLimits::getMaxUniformBuffersPerShaderStage() {
+  return _instance.maxUniformBuffersPerShaderStage;
+}
+
+double GPUSupportedLimits::getMaxUniformBufferBindingSize() {
+  return _instance.maxUniformBufferBindingSize;
+}
+
+double GPUSupportedLimits::getMaxStorageBufferBindingSize() {
+  return _instance.maxStorageBufferBindingSize;
+}
+
+double GPUSupportedLimits::getMinUniformBufferOffsetAlignment() {
+  return _instance.minUniformBufferOffsetAlignment;
+}
+
+double GPUSupportedLimits::getMinStorageBufferOffsetAlignment() {
+  return _instance.minStorageBufferOffsetAlignment;
+}
+
+double GPUSupportedLimits::getMaxVertexBuffers() {
+  return _instance.maxVertexBuffers;
+}
+
+double GPUSupportedLimits::getMaxBufferSize() {
+  return _instance.maxBufferSize;
+}
+
+double GPUSupportedLimits::getMaxVertexAttributes() {
+  return _instance.maxVertexAttributes;
+}
+
+double GPUSupportedLimits::getMaxVertexBufferArrayStride() {
+  return _instance.maxVertexBufferArrayStride;
+}
+
+double GPUSupportedLimits::getMaxInterStageShaderVariables() {
+  return _instance.maxInterStageShaderVariables;
+}
+
+double GPUSupportedLimits::getMaxColorAttachments() {
+  return _instance.maxColorAttachments;
+}
+
+double GPUSupportedLimits::getMaxColorAttachmentBytesPerSample() {
+  return _instance.maxColorAttachmentBytesPerSample;
+}
+
+double GPUSupportedLimits::getMaxComputeWorkgroupStorageSize() {
+  return _instance.maxComputeWorkgroupStorageSize;
+}
+
+double GPUSupportedLimits::getMaxComputeInvocationsPerWorkgroup() {
+  return _instance.maxComputeInvocationsPerWorkgroup;
+}
+
+double GPUSupportedLimits::getMaxComputeWorkgroupSizeX() {
+  return _instance.maxComputeWorkgroupSizeX;
+}
+
+double GPUSupportedLimits::getMaxComputeWorkgroupSizeY() {
+  return _instance.maxComputeWorkgroupSizeY;
+}
+
+double GPUSupportedLimits::getMaxComputeWorkgroupSizeZ() {
+  return _instance.maxComputeWorkgroupSizeZ;
+}
+
+double GPUSupportedLimits::getMaxComputeWorkgroupsPerDimension() {
+  return _instance.maxComputeWorkgroupsPerDimension;
+}
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUSupportedLimits.h

@@ -0,0 +1,131 @@
+#pragma once
+
+#include <string>
+
+#include "descriptors/Unions.h"
+
+#include "jsi2/NativeObject.h"
+
+#include "webgpu/webgpu_cpp.h"
+
+namespace rnwgpu {
+
+namespace jsi = facebook::jsi;
+
+class GPUSupportedLimits : public NativeObject<GPUSupportedLimits> {
+public:
+  static constexpr const char *CLASS_NAME = "GPUSupportedLimits";
+
+  explicit GPUSupportedLimits(wgpu::Limits instance)
+      : NativeObject(CLASS_NAME), _instance(instance) {}
+
+public:
+  std::string getBrand() { return CLASS_NAME; }
+
+  double getMaxTextureDimension1D();
+  double getMaxTextureDimension2D();
+  double getMaxTextureDimension3D();
+  double getMaxTextureArrayLayers();
+  double getMaxBindGroups();
+  double getMaxBindGroupsPlusVertexBuffers();
+  double getMaxBindingsPerBindGroup();
+  double getMaxDynamicUniformBuffersPerPipelineLayout();
+  double getMaxDynamicStorageBuffersPerPipelineLayout();
+  double getMaxSampledTexturesPerShaderStage();
+  double getMaxSamplersPerShaderStage();
+  double getMaxStorageBuffersPerShaderStage();
+  double getMaxStorageTexturesPerShaderStage();
+  double getMaxUniformBuffersPerShaderStage();
+  double getMaxUniformBufferBindingSize();
+  double getMaxStorageBufferBindingSize();
+  double getMinUniformBufferOffsetAlignment();
+  double getMinStorageBufferOffsetAlignment();
+  double getMaxVertexBuffers();
+  double getMaxBufferSize();
+  double getMaxVertexAttributes();
+  double getMaxVertexBufferArrayStride();
+  double getMaxInterStageShaderVariables();
+  double getMaxColorAttachments();
+  double getMaxColorAttachmentBytesPerSample();
+  double getMaxComputeWorkgroupStorageSize();
+  double getMaxComputeInvocationsPerWorkgroup();
+  double getMaxComputeWorkgroupSizeX();
+  double getMaxComputeWorkgroupSizeY();
+  double getMaxComputeWorkgroupSizeZ();
+  double getMaxComputeWorkgroupsPerDimension();
+
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installGetter(runtime, prototype, "__brand", &GPUSupportedLimits::getBrand);
+    installGetter(runtime, prototype, "maxTextureDimension1D",
+                  &GPUSupportedLimits::getMaxTextureDimension1D);
+    installGetter(runtime, prototype, "maxTextureDimension2D",
+                  &GPUSupportedLimits::getMaxTextureDimension2D);
+    installGetter(runtime, prototype, "maxTextureDimension3D",
+                  &GPUSupportedLimits::getMaxTextureDimension3D);
+    installGetter(runtime, prototype, "maxTextureArrayLayers",
+                  &GPUSupportedLimits::getMaxTextureArrayLayers);
+    installGetter(runtime, prototype, "maxBindGroups",
+                  &GPUSupportedLimits::getMaxBindGroups);
+    installGetter(runtime, prototype, "maxBindGroupsPlusVertexBuffers",
+                  &GPUSupportedLimits::getMaxBindGroupsPlusVertexBuffers);
+    installGetter(runtime, prototype, "maxBindingsPerBindGroup",
+                  &GPUSupportedLimits::getMaxBindingsPerBindGroup);
+    installGetter(
+        runtime, prototype, "maxDynamicUniformBuffersPerPipelineLayout",
+        &GPUSupportedLimits::getMaxDynamicUniformBuffersPerPipelineLayout);
+    installGetter(
+        runtime, prototype, "maxDynamicStorageBuffersPerPipelineLayout",
+        &GPUSupportedLimits::getMaxDynamicStorageBuffersPerPipelineLayout);
+    installGetter(runtime, prototype, "maxSampledTexturesPerShaderStage",
+                  &GPUSupportedLimits::getMaxSampledTexturesPerShaderStage);
+    installGetter(runtime, prototype, "maxSamplersPerShaderStage",
+                  &GPUSupportedLimits::getMaxSamplersPerShaderStage);
+    installGetter(runtime, prototype, "maxStorageBuffersPerShaderStage",
+                  &GPUSupportedLimits::getMaxStorageBuffersPerShaderStage);
+    installGetter(runtime, prototype, "maxStorageTexturesPerShaderStage",
+                  &GPUSupportedLimits::getMaxStorageTexturesPerShaderStage);
+    installGetter(runtime, prototype, "maxUniformBuffersPerShaderStage",
+                  &GPUSupportedLimits::getMaxUniformBuffersPerShaderStage);
+    installGetter(runtime, prototype, "maxUniformBufferBindingSize",
+                  &GPUSupportedLimits::getMaxUniformBufferBindingSize);
+    installGetter(runtime, prototype, "maxStorageBufferBindingSize",
+                  &GPUSupportedLimits::getMaxStorageBufferBindingSize);
+    installGetter(runtime, prototype, "minUniformBufferOffsetAlignment",
+                  &GPUSupportedLimits::getMinUniformBufferOffsetAlignment);
+    installGetter(runtime, prototype, "minStorageBufferOffsetAlignment",
+                  &GPUSupportedLimits::getMinStorageBufferOffsetAlignment);
+    installGetter(runtime, prototype, "maxVertexBuffers",
+                  &GPUSupportedLimits::getMaxVertexBuffers);
+    installGetter(runtime, prototype, "maxBufferSize",
+                  &GPUSupportedLimits::getMaxBufferSize);
+    installGetter(runtime, prototype, "maxVertexAttributes",
+                  &GPUSupportedLimits::getMaxVertexAttributes);
+    installGetter(runtime, prototype, "maxVertexBufferArrayStride",
+                  &GPUSupportedLimits::getMaxVertexBufferArrayStride);
+    installGetter(runtime, prototype, "maxInterStageShaderVariables",
+                  &GPUSupportedLimits::getMaxInterStageShaderVariables);
+    installGetter(runtime, prototype, "maxColorAttachments",
+                  &GPUSupportedLimits::getMaxColorAttachments);
+    installGetter(runtime, prototype, "maxColorAttachmentBytesPerSample",
+                  &GPUSupportedLimits::getMaxColorAttachmentBytesPerSample);
+    installGetter(runtime, prototype, "maxComputeWorkgroupStorageSize",
+                  &GPUSupportedLimits::getMaxComputeWorkgroupStorageSize);
+    installGetter(runtime, prototype, "maxComputeInvocationsPerWorkgroup",
+                  &GPUSupportedLimits::getMaxComputeInvocationsPerWorkgroup);
+    installGetter(runtime, prototype, "maxComputeWorkgroupSizeX",
+                  &GPUSupportedLimits::getMaxComputeWorkgroupSizeX);
+    installGetter(runtime, prototype, "maxComputeWorkgroupSizeY",
+                  &GPUSupportedLimits::getMaxComputeWorkgroupSizeY);
+    installGetter(runtime, prototype, "maxComputeWorkgroupSizeZ",
+                  &GPUSupportedLimits::getMaxComputeWorkgroupSizeZ);
+    installGetter(runtime, prototype, "maxComputeWorkgroupsPerDimension",
+                  &GPUSupportedLimits::getMaxComputeWorkgroupsPerDimension);
+  }
+
+  inline const wgpu::Limits get() { return _instance; }
+
+private:
+  wgpu::Limits _instance;
+};
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUTexture.cpp

@@ -0,0 +1,47 @@
+#include "GPUTexture.h"
+
+#include <memory>
+
+#include "Convertors.h"
+
+namespace rnwgpu {
+
+void GPUTexture::destroy() { _instance.Destroy(); }
+
+std::shared_ptr<GPUTextureView> GPUTexture::createView(
+    std::optional<std::shared_ptr<GPUTextureViewDescriptor>> descriptor) {
+  wgpu::TextureViewDescriptor desc;
+  Convertor conv;
+  if (!conv(desc, descriptor)) {
+    throw std::runtime_error("GPUTextureView.createView(): couldn't access "
+                             "GPUTextureViewDescriptor");
+  }
+  auto view = _instance.CreateView(&desc);
+  return std::make_shared<GPUTextureView>(
+      view,
+      descriptor.has_value() ? descriptor.value()->label.value_or("") : "");
+}
+
+uint32_t GPUTexture::getWidth() { return _instance.GetWidth(); }
+
+uint32_t GPUTexture::getHeight() { return _instance.GetHeight(); }
+
+uint32_t GPUTexture::getDepthOrArrayLayers() {
+  return _instance.GetDepthOrArrayLayers();
+}
+
+uint32_t GPUTexture::getMipLevelCount() { return _instance.GetMipLevelCount(); }
+
+uint32_t GPUTexture::getSampleCount() { return _instance.GetSampleCount(); }
+
+wgpu::TextureDimension GPUTexture::getDimension() {
+  return _instance.GetDimension();
+}
+
+wgpu::TextureFormat GPUTexture::getFormat() { return _instance.GetFormat(); }
+
+double GPUTexture::getUsage() {
+  return static_cast<double>(_instance.GetUsage());
+}
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUTexture.h

@@ -0,0 +1,150 @@
+#pragma once
+
+#include <algorithm>
+#include <memory>
+#include <string>
+
+#include "descriptors/Unions.h"
+
+#include "jsi2/NativeObject.h"
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "GPUTextureView.h"
+#include "descriptors/GPUTextureViewDescriptor.h"
+
+namespace rnwgpu {
+
+namespace jsi = facebook::jsi;
+
+class GPUTexture : public NativeObject<GPUTexture> {
+public:
+  static constexpr const char *CLASS_NAME = "GPUTexture";
+
+  explicit GPUTexture(wgpu::Texture instance, std::string label)
+      : NativeObject(CLASS_NAME), _instance(instance), _label(label) {}
+
+public:
+  std::string getBrand() { return CLASS_NAME; }
+
+  std::shared_ptr<GPUTextureView> createView(
+      std::optional<std::shared_ptr<GPUTextureViewDescriptor>> descriptor);
+  void destroy();
+
+  uint32_t getWidth();
+  uint32_t getHeight();
+  uint32_t getDepthOrArrayLayers();
+  uint32_t getMipLevelCount();
+  uint32_t getSampleCount();
+  wgpu::TextureDimension getDimension();
+  wgpu::TextureFormat getFormat();
+  double getUsage();
+
+  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", &GPUTexture::getBrand);
+    installMethod(runtime, prototype, "createView", &GPUTexture::createView);
+    installMethod(runtime, prototype, "destroy", &GPUTexture::destroy);
+    installGetter(runtime, prototype, "width", &GPUTexture::getWidth);
+    installGetter(runtime, prototype, "height", &GPUTexture::getHeight);
+    installGetter(runtime, prototype, "depthOrArrayLayers",
+                  &GPUTexture::getDepthOrArrayLayers);
+    installGetter(runtime, prototype, "mipLevelCount",
+                  &GPUTexture::getMipLevelCount);
+    installGetter(runtime, prototype, "sampleCount",
+                  &GPUTexture::getSampleCount);
+    installGetter(runtime, prototype, "dimension", &GPUTexture::getDimension);
+    installGetter(runtime, prototype, "format", &GPUTexture::getFormat);
+    installGetter(runtime, prototype, "usage", &GPUTexture::getUsage);
+    installGetterSetter(runtime, prototype, "label", &GPUTexture::getLabel,
+                        &GPUTexture::setLabel);
+  }
+
+  inline const wgpu::Texture get() { return _instance; }
+
+  size_t getMemoryPressure() override {
+    // Calculate approximate memory usage based on texture properties
+    uint32_t width = getWidth();
+    uint32_t height = getHeight();
+    uint32_t depthOrArrayLayers = getDepthOrArrayLayers();
+    uint32_t mipLevelCount = getMipLevelCount();
+    uint32_t sampleCount = getSampleCount();
+
+    // Estimate bytes per pixel based on format
+    // This is a simplified estimate - actual values depend on the specific
+    // format
+    size_t bytesPerPixel = 4; // Default to RGBA8 format
+    wgpu::TextureFormat format = getFormat();
+    switch (format) {
+    case wgpu::TextureFormat::R8Unorm:
+    case wgpu::TextureFormat::R8Snorm:
+    case wgpu::TextureFormat::R8Uint:
+    case wgpu::TextureFormat::R8Sint:
+      bytesPerPixel = 1;
+      break;
+    case wgpu::TextureFormat::R16Uint:
+    case wgpu::TextureFormat::R16Sint:
+    case wgpu::TextureFormat::R16Float:
+    case wgpu::TextureFormat::RG8Unorm:
+    case wgpu::TextureFormat::RG8Snorm:
+    case wgpu::TextureFormat::RG8Uint:
+    case wgpu::TextureFormat::RG8Sint:
+      bytesPerPixel = 2;
+      break;
+    case wgpu::TextureFormat::RGBA8Unorm:
+    case wgpu::TextureFormat::RGBA8UnormSrgb:
+    case wgpu::TextureFormat::RGBA8Snorm:
+    case wgpu::TextureFormat::RGBA8Uint:
+    case wgpu::TextureFormat::RGBA8Sint:
+    case wgpu::TextureFormat::BGRA8Unorm:
+    case wgpu::TextureFormat::BGRA8UnormSrgb:
+    case wgpu::TextureFormat::RGB10A2Unorm:
+    case wgpu::TextureFormat::R32Float:
+    case wgpu::TextureFormat::R32Uint:
+    case wgpu::TextureFormat::R32Sint:
+    case wgpu::TextureFormat::RG16Uint:
+    case wgpu::TextureFormat::RG16Sint:
+    case wgpu::TextureFormat::RG16Float:
+      bytesPerPixel = 4;
+      break;
+    case wgpu::TextureFormat::RG32Float:
+    case wgpu::TextureFormat::RG32Uint:
+    case wgpu::TextureFormat::RG32Sint:
+    case wgpu::TextureFormat::RGBA16Uint:
+    case wgpu::TextureFormat::RGBA16Sint:
+    case wgpu::TextureFormat::RGBA16Float:
+      bytesPerPixel = 8;
+      break;
+    case wgpu::TextureFormat::RGBA32Float:
+    case wgpu::TextureFormat::RGBA32Uint:
+    case wgpu::TextureFormat::RGBA32Sint:
+      bytesPerPixel = 16;
+      break;
+    default:
+      bytesPerPixel = 4; // Safe default
+      break;
+    }
+
+    // Calculate total memory for all mip levels
+    size_t totalMemory = 0;
+    for (uint32_t mip = 0; mip < mipLevelCount; ++mip) {
+      uint32_t mipWidth = std::max(1u, width >> mip);
+      uint32_t mipHeight = std::max(1u, height >> mip);
+      totalMemory += static_cast<size_t>(mipWidth) * mipHeight *
+                     depthOrArrayLayers * bytesPerPixel * sampleCount;
+    }
+
+    return totalMemory;
+  }
+
+private:
+  wgpu::Texture _instance;
+  std::string _label;
+};
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUTextureView.h

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

package/cpp/rnwgpu/api/GPUValidationError.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#include <string>
+
+#include "jsi2/NativeObject.h"
+
+namespace rnwgpu {
+
+namespace jsi = facebook::jsi;
+
+class GPUValidationError : public NativeObject<GPUValidationError> {
+public:
+  static constexpr const char *CLASS_NAME = "GPUValidationError";
+
+  explicit GPUValidationError(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", &GPUValidationError::getBrand);
+    installGetter(runtime, prototype, "message",
+                  &GPUValidationError::getMessage);
+  }
+
+private:
+  std::string _message;
+};
+
+} // namespace rnwgpu

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

@@ -0,0 +1,64 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "jsi2/JSIConverter.h"
+
+#include "GPUBindGroupEntry.h"
+#include "rnwgpu/api/GPUBindGroupLayout.h"
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+struct GPUBindGroupDescriptor {
+  std::shared_ptr<GPUBindGroupLayout> layout; // GPUBindGroupLayout
+  std::vector<std::shared_ptr<GPUBindGroupEntry>>
+      entries;                      // Iterable<GPUBindGroupEntry>
+  std::optional<std::string> label; // string
+};
+
+} // namespace rnwgpu
+
+namespace rnwgpu {
+
+template <>
+struct JSIConverter<std::shared_ptr<rnwgpu::GPUBindGroupDescriptor>> {
+  static std::shared_ptr<rnwgpu::GPUBindGroupDescriptor>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUBindGroupDescriptor>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "layout")) {
+        auto prop = value.getProperty(runtime, "layout");
+        result->layout =
+            JSIConverter<std::shared_ptr<GPUBindGroupLayout>>::fromJSI(
+                runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "entries")) {
+        auto prop = value.getProperty(runtime, "entries");
+        result->entries = JSIConverter<
+            std::vector<std::shared_ptr<GPUBindGroupEntry>>>::fromJSI(runtime,
+                                                                      prop,
+                                                                      false);
+      }
+      if (value.hasProperty(runtime, "label")) {
+        auto prop = value.getProperty(runtime, "label");
+        result->label = JSIConverter<std::optional<std::string>>::fromJSI(
+            runtime, prop, false);
+      }
+    }
+
+    return result;
+  }
+  static jsi::Value toJSI(jsi::Runtime &runtime,
+                          std::shared_ptr<rnwgpu::GPUBindGroupDescriptor> arg) {
+    throw std::runtime_error("Invalid GPUBindGroupDescriptor::toJSI()");
+  }
+};
+
+} // namespace rnwgpu

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

@@ -0,0 +1,71 @@
+#pragma once
+
+#include <memory>
+#include <variant>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "GPUBufferBinding.h"
+#include "rnwgpu/api/GPUExternalTexture.h"
+#include "rnwgpu/api/GPUSampler.h"
+#include "rnwgpu/api/GPUTextureView.h"
+#include "jsi2/JSIConverter.h"
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+struct GPUBindGroupEntry {
+  double binding;
+  std::shared_ptr<GPUSampler> sampler = nullptr;
+  std::shared_ptr<GPUTextureView> textureView = nullptr;
+  std::shared_ptr<GPUBufferBinding> buffer = nullptr;
+  // external textures
+};
+
+} // namespace rnwgpu
+
+namespace rnwgpu {
+
+template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUBindGroupEntry>> {
+  static std::shared_ptr<rnwgpu::GPUBindGroupEntry>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUBindGroupEntry>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "binding")) {
+        result->binding = value.getProperty(runtime, "binding").asNumber();
+      }
+      if (value.hasProperty(runtime, "resource")) {
+        auto prop = value.getProperty(runtime, "resource");
+        if (prop.isObject()) {
+          auto obj = prop.getObject(runtime);
+          if (obj.hasNativeState<rnwgpu::GPUSampler>(runtime)) {
+            result->sampler = obj.getNativeState<rnwgpu::GPUSampler>(runtime);
+          } else if (obj.hasNativeState<rnwgpu::GPUTextureView>(runtime)) {
+            result->textureView =
+                obj.getNativeState<rnwgpu::GPUTextureView>(runtime);
+          } else {
+            result->buffer = JSIConverter<
+                std::shared_ptr<rnwgpu::GPUBufferBinding>>::fromJSI(runtime,
+                                                                    prop,
+                                                                    false);
+          }
+        }
+        // result->resource = JSIConverter<std::variant<
+        //     std::shared_ptr<GPUSampler>, std::shared_ptr<GPUTextureView>,
+        //     std::shared_ptr<GPUBufferBinding>,
+        //     std::shared_ptr<GPUExternalTexture>>>::fromJSI(runtime, prop,
+        //                                                    false);
+      }
+    }
+
+    return result;
+  }
+  static jsi::Value toJSI(jsi::Runtime &runtime,
+                          std::shared_ptr<rnwgpu::GPUBindGroupEntry> arg) {
+    throw std::runtime_error("Invalid GPUBindGroupEntry::toJSI()");
+  }
+};
+
+} // namespace rnwgpu