react-native-wgpu 0.5.13 → 0.5.14

package/cpp/rnwgpu/api/VideoFrame.h

@@ -1,76 +0,0 @@
-#pragma once
-
-#include <functional>
-#include <memory>
-#include <string>
-#include <utility>
-
-#include "JSIConverter.h"
-#include "NativeObject.h"
-#include "PlatformContext.h"
-
-namespace rnwgpu {
-
-namespace jsi = facebook::jsi;
-
-// VideoFrame is a small RAII wrapper around a platform-specific native handle
-// (IOSurfaceRef-backed CVPixelBuffer on Apple, AHardwareBuffer on Android).
-// It surfaces the raw handle as a BigInt to JS so callers can hand it to
-// GPUDevice.importSharedTextureMemory, and owns a deleter so the underlying
-// object stays alive until the JS object is GC'd (or release() is called).
-class VideoFrame : public NativeObject<VideoFrame> {
-public:
-  // JS-facing brand. installConstructor() exposes this as globalThis[CLASS_NAME]
-  // and keys the NativeObjectRegistry / worklet serializer off it, so it must
-  // NOT be "VideoFrame": that would install our constructor over the WebCodecs
-  // `VideoFrame` global and shadow it at runtime. "NativeVideoFrame" matches the
-  // public TypeScript type (see src/types.ts) and keeps the two namespaces
-  // distinct. The C++ class stays `VideoFrame` for brevity; only the brand is
-  // namespaced.
-  static constexpr const char *CLASS_NAME = "NativeVideoFrame";
-
-  explicit VideoFrame(VideoFrameHandle handle)
-      : NativeObject(CLASS_NAME), _handle(std::move(handle)) {}
-
-  ~VideoFrame() override { release(); }
-
-  std::string getBrand() { return CLASS_NAME; }
-
-  // The native handle (IOSurfaceRef / AHardwareBuffer*) as a uintptr_t value.
-  // Exposed as a BigInt on the JS side.
-  void *getHandle() { return _handle.handle; }
-  uint32_t getWidth() { return _handle.width; }
-  uint32_t getHeight() { return _handle.height; }
-
-  // Pixel format as a JS-visible string: "bgra8" | "nv12".
-  std::string getPixelFormat() {
-    return _handle.pixelFormat == VideoPixelFormat::NV12 ? "nv12" : "bgra8";
-  }
-
-  // Direct access to the underlying handle, for use by importExternalTexture /
-  // importSharedTextureMemory inside the C++ layer (not exposed to JS).
-  const VideoFrameHandle &handle() const { return _handle; }
-
-  void release() {
-    if (_handle.deleter) {
-      _handle.deleter();
-      _handle.deleter = nullptr;
-    }
-    _handle.handle = nullptr;
-  }
-
-  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
-    installGetter(runtime, prototype, "__brand", &VideoFrame::getBrand);
-    installGetter(runtime, prototype, "handle", &VideoFrame::getHandle);
-    installGetter(runtime, prototype, "width", &VideoFrame::getWidth);
-    installGetter(runtime, prototype, "height", &VideoFrame::getHeight);
-    installGetter(runtime, prototype, "pixelFormat",
-                  &VideoFrame::getPixelFormat);
-    installMethod(runtime, prototype, "release", &VideoFrame::release);
-  }
-
-private:
-  VideoFrameHandle _handle;
-};
-
-} // namespace rnwgpu

package/cpp/rnwgpu/api/VideoPlayer.h

@@ -1,69 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <string>
-#include <utility>
-#include <variant>
-
-#include "NativeObject.h"
-#include "PlatformContext.h"
-#include "VideoFrame.h"
-
-namespace rnwgpu {
-
-namespace jsi = facebook::jsi;
-
-// JSI wrapper around a platform-specific IVideoPlayer. Hands out fresh
-// VideoFrame handles each time the underlying decoder produces a new frame.
-class VideoPlayer : public NativeObject<VideoPlayer> {
-public:
-  static constexpr const char *CLASS_NAME = "VideoPlayer";
-
-  explicit VideoPlayer(std::unique_ptr<IVideoPlayer> impl)
-      : NativeObject(CLASS_NAME), _impl(std::move(impl)) {}
-
-  std::string getBrand() { return CLASS_NAME; }
-
-  // Returns the latest decoded frame, or null if no new frame is ready yet.
-  // Callers should poll this from their render loop and skip rendering (or
-  // reuse the last frame's texture) when null.
-  std::variant<std::nullptr_t, std::shared_ptr<VideoFrame>>
-  copyLatestFrame() {
-    if (!_impl) {
-      return nullptr;
-    }
-    auto handle = _impl->copyLatestFrame();
-    if (handle.handle == nullptr) {
-      return nullptr;
-    }
-    return std::make_shared<VideoFrame>(std::move(handle));
-  }
-
-  void play() {
-    if (_impl) {
-      _impl->play();
-    }
-  }
-
-  void pause() {
-    if (_impl) {
-      _impl->pause();
-    }
-  }
-
-  void release() { _impl.reset(); }
-
-  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
-    installGetter(runtime, prototype, "__brand", &VideoPlayer::getBrand);
-    installMethod(runtime, prototype, "copyLatestFrame",
-                  &VideoPlayer::copyLatestFrame);
-    installMethod(runtime, prototype, "play", &VideoPlayer::play);
-    installMethod(runtime, prototype, "pause", &VideoPlayer::pause);
-    installMethod(runtime, prototype, "release", &VideoPlayer::release);
-  }
-
-private:
-  std::unique_ptr<IVideoPlayer> _impl;
-};
-
-} // namespace rnwgpu

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

@@ -1,65 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "JSIConverter.h"
-#include "WGPULogger.h"
-
-#include "GPUBindGroupEntry.h"
-#include "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

@@ -1,81 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <variant>
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "GPUBufferBinding.h"
-#include "GPUExternalTexture.h"
-#include "GPUSampler.h"
-#include "GPUTextureView.h"
-#include "JSIConverter.h"
-#include "WGPULogger.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;
-  std::shared_ptr<GPUExternalTexture> externalTexture = nullptr;
-};
-
-} // 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 if (obj.hasNativeState<rnwgpu::GPUExternalTexture>(runtime)) {
-            result->externalTexture =
-                obj.getNativeState<rnwgpu::GPUExternalTexture>(runtime);
-          } else if (obj.hasNativeState<rnwgpu::GPUBuffer>(runtime)) {
-            // Support passing GPUBuffer directly as resource (auto-wrap in
-            // GPUBufferBinding)
-            auto binding = std::make_shared<rnwgpu::GPUBufferBinding>();
-            binding->buffer = obj.getNativeState<rnwgpu::GPUBuffer>(runtime);
-            result->buffer = binding;
-          } 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

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

@@ -1,57 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "JSIConverter.h"
-#include "WGPULogger.h"
-
-#include "GPUBindGroupLayoutEntry.h"
-
-namespace jsi = facebook::jsi;
-
-namespace rnwgpu {
-
-struct GPUBindGroupLayoutDescriptor {
-  std::vector<std::shared_ptr<GPUBindGroupLayoutEntry>>
-      entries;                      // Iterable<GPUBindGroupLayoutEntry>
-  std::optional<std::string> label; // string
-};
-
-} // namespace rnwgpu
-
-namespace rnwgpu {
-
-template <>
-struct JSIConverter<std::shared_ptr<rnwgpu::GPUBindGroupLayoutDescriptor>> {
-  static std::shared_ptr<rnwgpu::GPUBindGroupLayoutDescriptor>
-  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
-    auto result = std::make_unique<rnwgpu::GPUBindGroupLayoutDescriptor>();
-    if (!outOfBounds && arg.isObject()) {
-      auto value = arg.getObject(runtime);
-      if (value.hasProperty(runtime, "entries")) {
-        auto prop = value.getProperty(runtime, "entries");
-        result->entries = JSIConverter<std::vector<
-            std::shared_ptr<GPUBindGroupLayoutEntry>>>::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::GPUBindGroupLayoutDescriptor> arg) {
-    throw std::runtime_error("Invalid GPUBindGroupLayoutDescriptor::toJSI()");
-  }
-};
-
-} // namespace rnwgpu

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

@@ -1,98 +0,0 @@
-#pragma once
-
-#include <memory>
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "JSIConverter.h"
-#include "WGPULogger.h"
-
-#include "GPUBufferBindingLayout.h"
-#include "GPUExternalTextureBindingLayout.h"
-#include "GPUSamplerBindingLayout.h"
-#include "GPUStorageTextureBindingLayout.h"
-#include "GPUTextureBindingLayout.h"
-
-namespace jsi = facebook::jsi;
-
-namespace rnwgpu {
-
-struct GPUBindGroupLayoutEntry {
-  double binding;    // GPUIndex32
-  double visibility; // GPUShaderStageFlags
-  std::optional<std::shared_ptr<GPUBufferBindingLayout>>
-      buffer; // GPUBufferBindingLayout
-  std::optional<std::shared_ptr<GPUSamplerBindingLayout>>
-      sampler; // GPUSamplerBindingLayout
-  std::optional<std::shared_ptr<GPUTextureBindingLayout>>
-      texture; // GPUTextureBindingLayout
-  std::optional<std::shared_ptr<GPUStorageTextureBindingLayout>>
-      storageTexture; // GPUStorageTextureBindingLayout
-  std::optional<std::shared_ptr<GPUExternalTextureBindingLayout>>
-      externalTexture; // GPUExternalTextureBindingLayout
-};
-
-} // namespace rnwgpu
-
-namespace rnwgpu {
-
-template <>
-struct JSIConverter<std::shared_ptr<rnwgpu::GPUBindGroupLayoutEntry>> {
-  static std::shared_ptr<rnwgpu::GPUBindGroupLayoutEntry>
-  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
-    auto result = std::make_unique<rnwgpu::GPUBindGroupLayoutEntry>();
-    if (!outOfBounds && arg.isObject()) {
-      auto value = arg.getObject(runtime);
-      if (value.hasProperty(runtime, "binding")) {
-        auto prop = value.getProperty(runtime, "binding");
-        result->binding = JSIConverter<double>::fromJSI(runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "visibility")) {
-        auto prop = value.getProperty(runtime, "visibility");
-        result->visibility =
-            JSIConverter<double>::fromJSI(runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "buffer")) {
-        auto prop = value.getProperty(runtime, "buffer");
-        result->buffer = JSIConverter<std::optional<
-            std::shared_ptr<GPUBufferBindingLayout>>>::fromJSI(runtime, prop,
-                                                               false);
-      }
-      if (value.hasProperty(runtime, "sampler")) {
-        auto prop = value.getProperty(runtime, "sampler");
-        result->sampler = JSIConverter<std::optional<
-            std::shared_ptr<GPUSamplerBindingLayout>>>::fromJSI(runtime, prop,
-                                                                false);
-      }
-      if (value.hasProperty(runtime, "texture")) {
-        auto prop = value.getProperty(runtime, "texture");
-        result->texture = JSIConverter<std::optional<
-            std::shared_ptr<GPUTextureBindingLayout>>>::fromJSI(runtime, prop,
-                                                                false);
-      }
-      if (value.hasProperty(runtime, "storageTexture")) {
-        auto prop = value.getProperty(runtime, "storageTexture");
-        result->storageTexture = JSIConverter<std::optional<
-            std::shared_ptr<GPUStorageTextureBindingLayout>>>::fromJSI(runtime,
-                                                                       prop,
-                                                                       false);
-      }
-      if (value.hasProperty(runtime, "externalTexture")) {
-        auto prop = value.getProperty(runtime, "externalTexture");
-        result->externalTexture = JSIConverter<std::optional<
-            std::shared_ptr<GPUExternalTextureBindingLayout>>>::fromJSI(runtime,
-                                                                        prop,
-                                                                        false);
-      }
-    }
-
-    return result;
-  }
-  static jsi::Value
-  toJSI(jsi::Runtime &runtime,
-        std::shared_ptr<rnwgpu::GPUBindGroupLayoutEntry> arg) {
-    throw std::runtime_error("Invalid GPUBindGroupLayoutEntry::toJSI()");
-  }
-};
-
-} // namespace rnwgpu

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

@@ -1,58 +0,0 @@
-#pragma once
-
-#include <memory>
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "JSIConverter.h"
-#include "WGPULogger.h"
-
-namespace jsi = facebook::jsi;
-
-namespace rnwgpu {
-
-struct GPUBlendComponent {
-  std::optional<wgpu::BlendOperation> operation; // GPUBlendOperation
-  std::optional<wgpu::BlendFactor> srcFactor;    // GPUBlendFactor
-  std::optional<wgpu::BlendFactor> dstFactor;    // GPUBlendFactor
-};
-
-} // namespace rnwgpu
-
-namespace rnwgpu {
-
-template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUBlendComponent>> {
-  static std::shared_ptr<rnwgpu::GPUBlendComponent>
-  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
-    auto result = std::make_unique<rnwgpu::GPUBlendComponent>();
-    if (!outOfBounds && arg.isObject()) {
-      auto value = arg.getObject(runtime);
-      if (value.hasProperty(runtime, "operation")) {
-        auto prop = value.getProperty(runtime, "operation");
-        result->operation =
-            JSIConverter<std::optional<wgpu::BlendOperation>>::fromJSI(
-                runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "srcFactor")) {
-        auto prop = value.getProperty(runtime, "srcFactor");
-        result->srcFactor =
-            JSIConverter<std::optional<wgpu::BlendFactor>>::fromJSI(
-                runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "dstFactor")) {
-        auto prop = value.getProperty(runtime, "dstFactor");
-        result->dstFactor =
-            JSIConverter<std::optional<wgpu::BlendFactor>>::fromJSI(
-                runtime, prop, false);
-      }
-    }
-
-    return result;
-  }
-  static jsi::Value toJSI(jsi::Runtime &runtime,
-                          std::shared_ptr<rnwgpu::GPUBlendComponent> arg) {
-    throw std::runtime_error("Invalid GPUBlendComponent::toJSI()");
-  }
-};
-
-} // namespace rnwgpu

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

@@ -1,53 +0,0 @@
-#pragma once
-
-#include <memory>
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "JSIConverter.h"
-#include "WGPULogger.h"
-
-#include "GPUBlendComponent.h"
-
-namespace jsi = facebook::jsi;
-
-namespace rnwgpu {
-
-struct GPUBlendState {
-  std::shared_ptr<GPUBlendComponent> color; // GPUBlendComponent
-  std::shared_ptr<GPUBlendComponent> alpha; // GPUBlendComponent
-};
-
-} // namespace rnwgpu
-
-namespace rnwgpu {
-
-template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUBlendState>> {
-  static std::shared_ptr<rnwgpu::GPUBlendState>
-  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
-    auto result = std::make_unique<rnwgpu::GPUBlendState>();
-    if (!outOfBounds && arg.isObject()) {
-      auto value = arg.getObject(runtime);
-      if (value.hasProperty(runtime, "color")) {
-        auto prop = value.getProperty(runtime, "color");
-        result->color =
-            JSIConverter<std::shared_ptr<GPUBlendComponent>>::fromJSI(
-                runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "alpha")) {
-        auto prop = value.getProperty(runtime, "alpha");
-        result->alpha =
-            JSIConverter<std::shared_ptr<GPUBlendComponent>>::fromJSI(
-                runtime, prop, false);
-      }
-    }
-
-    return result;
-  }
-  static jsi::Value toJSI(jsi::Runtime &runtime,
-                          std::shared_ptr<rnwgpu::GPUBlendState> arg) {
-    throw std::runtime_error("Invalid GPUBlendState::toJSI()");
-  }
-};
-
-} // namespace rnwgpu

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

@@ -1,57 +0,0 @@
-#pragma once
-
-#include <memory>
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "JSIConverter.h"
-#include "WGPULogger.h"
-
-#include "GPUBuffer.h"
-
-namespace jsi = facebook::jsi;
-
-namespace rnwgpu {
-
-struct GPUBufferBinding {
-  std::shared_ptr<GPUBuffer> buffer; // GPUBuffer
-  std::optional<double> offset;      // GPUSize64
-  std::optional<double> size;        // GPUSize64
-};
-
-} // namespace rnwgpu
-
-namespace rnwgpu {
-
-template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUBufferBinding>> {
-  static std::shared_ptr<rnwgpu::GPUBufferBinding>
-  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
-    auto result = std::make_unique<rnwgpu::GPUBufferBinding>();
-    if (!outOfBounds && arg.isObject()) {
-      auto value = arg.getObject(runtime);
-      if (value.hasProperty(runtime, "buffer")) {
-        auto prop = value.getProperty(runtime, "buffer");
-        result->buffer = JSIConverter<std::shared_ptr<GPUBuffer>>::fromJSI(
-            runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "offset")) {
-        auto prop = value.getProperty(runtime, "offset");
-        result->offset =
-            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "size")) {
-        auto prop = value.getProperty(runtime, "size");
-        result->size =
-            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
-      }
-    }
-
-    return result;
-  }
-  static jsi::Value toJSI(jsi::Runtime &runtime,
-                          std::shared_ptr<rnwgpu::GPUBufferBinding> arg) {
-    throw std::runtime_error("Invalid GPUBufferBinding::toJSI()");
-  }
-};
-
-} // namespace rnwgpu

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

@@ -1,57 +0,0 @@
-#pragma once
-
-#include <memory>
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "JSIConverter.h"
-#include "WGPULogger.h"
-
-namespace jsi = facebook::jsi;
-
-namespace rnwgpu {
-
-struct GPUBufferBindingLayout {
-  std::optional<wgpu::BufferBindingType> type; // GPUBufferBindingType
-  std::optional<bool> hasDynamicOffset;        // boolean
-  std::optional<double> minBindingSize;        // GPUSize64
-};
-
-} // namespace rnwgpu
-
-namespace rnwgpu {
-
-template <>
-struct JSIConverter<std::shared_ptr<rnwgpu::GPUBufferBindingLayout>> {
-  static std::shared_ptr<rnwgpu::GPUBufferBindingLayout>
-  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
-    auto result = std::make_unique<rnwgpu::GPUBufferBindingLayout>();
-    if (!outOfBounds && arg.isObject()) {
-      auto value = arg.getObject(runtime);
-      if (value.hasProperty(runtime, "type")) {
-        auto prop = value.getProperty(runtime, "type");
-        result->type =
-            JSIConverter<std::optional<wgpu::BufferBindingType>>::fromJSI(
-                runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "hasDynamicOffset")) {
-        auto prop = value.getProperty(runtime, "hasDynamicOffset");
-        result->hasDynamicOffset =
-            JSIConverter<std::optional<bool>>::fromJSI(runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "minBindingSize")) {
-        auto prop = value.getProperty(runtime, "minBindingSize");
-        result->minBindingSize =
-            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
-      }
-    }
-
-    return result;
-  }
-  static jsi::Value toJSI(jsi::Runtime &runtime,
-                          std::shared_ptr<rnwgpu::GPUBufferBindingLayout> arg) {
-    throw std::runtime_error("Invalid GPUBufferBindingLayout::toJSI()");
-  }
-};
-
-} // namespace rnwgpu