react-native-webgpu 0.5.11

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

@@ -0,0 +1,81 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "JSIConverter.h"
+#include "WGPULogger.h"
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+struct GPURenderBundleEncoderDescriptor {
+  std::optional<bool> depthReadOnly;   // boolean
+  std::optional<bool> stencilReadOnly; // boolean
+  std::vector<std::variant<std::nullptr_t, wgpu::TextureFormat>>
+      colorFormats; // Iterable<GPUTextureFormat | null>
+  std::optional<wgpu::TextureFormat> depthStencilFormat; // GPUTextureFormat
+  std::optional<double> sampleCount;                     // GPUSize32
+  std::optional<std::string> label;                      // string
+};
+
+} // namespace rnwgpu
+
+namespace rnwgpu {
+
+template <>
+struct JSIConverter<std::shared_ptr<rnwgpu::GPURenderBundleEncoderDescriptor>> {
+  static std::shared_ptr<rnwgpu::GPURenderBundleEncoderDescriptor>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPURenderBundleEncoderDescriptor>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "depthReadOnly")) {
+        auto prop = value.getProperty(runtime, "depthReadOnly");
+        result->depthReadOnly =
+            JSIConverter<std::optional<bool>>::fromJSI(runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "stencilReadOnly")) {
+        auto prop = value.getProperty(runtime, "stencilReadOnly");
+        result->stencilReadOnly =
+            JSIConverter<std::optional<bool>>::fromJSI(runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "colorFormats")) {
+        auto prop = value.getProperty(runtime, "colorFormats");
+        result->colorFormats = JSIConverter<
+            std::vector<std::variant<std::nullptr_t, wgpu::TextureFormat>>>::
+            fromJSI(runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "depthStencilFormat")) {
+        auto prop = value.getProperty(runtime, "depthStencilFormat");
+        result->depthStencilFormat =
+            JSIConverter<std::optional<wgpu::TextureFormat>>::fromJSI(
+                runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "sampleCount")) {
+        auto prop = value.getProperty(runtime, "sampleCount");
+        result->sampleCount =
+            JSIConverter<std::optional<double>>::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::GPURenderBundleEncoderDescriptor> arg) {
+    throw std::runtime_error(
+        "Invalid GPURenderBundleEncoderDescriptor::toJSI()");
+  }
+};
+
+} // namespace rnwgpu

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

@@ -0,0 +1,82 @@
+#pragma once
+
+#include <memory>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "JSIConverter.h"
+#include "WGPULogger.h"
+
+#include "GPUColor.h"
+#include "GPUTextureView.h"
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+struct GPURenderPassColorAttachment {
+  std::shared_ptr<GPUTextureView> view; // GPUTextureView
+  std::optional<double> depthSlice;     // GPUIntegerCoordinate
+  std::optional<std::shared_ptr<GPUTextureView>>
+      resolveTarget;                                   // GPUTextureView
+  std::optional<std::shared_ptr<GPUColor>> clearValue; // GPUColor
+  wgpu::LoadOp loadOp;                                 // GPULoadOp
+  wgpu::StoreOp storeOp;                               // GPUStoreOp
+};
+
+} // namespace rnwgpu
+
+namespace rnwgpu {
+
+template <>
+struct JSIConverter<std::shared_ptr<rnwgpu::GPURenderPassColorAttachment>> {
+  static std::shared_ptr<rnwgpu::GPURenderPassColorAttachment>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPURenderPassColorAttachment>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "view")) {
+        auto prop = value.getProperty(runtime, "view");
+        result->view = JSIConverter<std::shared_ptr<GPUTextureView>>::fromJSI(
+            runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "depthSlice")) {
+        auto prop = value.getProperty(runtime, "depthSlice");
+        result->depthSlice =
+            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "resolveTarget")) {
+        auto prop = value.getProperty(runtime, "resolveTarget");
+        result->resolveTarget = JSIConverter<
+            std::optional<std::shared_ptr<GPUTextureView>>>::fromJSI(runtime,
+                                                                     prop,
+                                                                     false);
+      }
+      if (value.hasProperty(runtime, "clearValue")) {
+        auto prop = value.getProperty(runtime, "clearValue");
+        result->clearValue =
+            JSIConverter<std::optional<std::shared_ptr<GPUColor>>>::fromJSI(
+                runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "loadOp")) {
+        auto prop = value.getProperty(runtime, "loadOp");
+        result->loadOp =
+            JSIConverter<wgpu::LoadOp>::fromJSI(runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "storeOp")) {
+        auto prop = value.getProperty(runtime, "storeOp");
+        result->storeOp =
+            JSIConverter<wgpu::StoreOp>::fromJSI(runtime, prop, false);
+      }
+    }
+
+    return result;
+  }
+  static jsi::Value
+  toJSI(jsi::Runtime &runtime,
+        std::shared_ptr<rnwgpu::GPURenderPassColorAttachment> arg) {
+    throw std::runtime_error("Invalid GPURenderPassColorAttachment::toJSI()");
+  }
+};
+
+} // namespace rnwgpu

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

@@ -0,0 +1,102 @@
+#pragma once
+
+#include <memory>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "JSIConverter.h"
+#include "WGPULogger.h"
+
+#include "GPUTextureView.h"
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+struct GPURenderPassDepthStencilAttachment {
+  std::shared_ptr<GPUTextureView> view;        // GPUTextureView
+  std::optional<double> depthClearValue;       // number
+  std::optional<wgpu::LoadOp> depthLoadOp;     // GPULoadOp
+  std::optional<wgpu::StoreOp> depthStoreOp;   // GPUStoreOp
+  std::optional<bool> depthReadOnly;           // boolean
+  std::optional<double> stencilClearValue;     // GPUStencilValue
+  std::optional<wgpu::LoadOp> stencilLoadOp;   // GPULoadOp
+  std::optional<wgpu::StoreOp> stencilStoreOp; // GPUStoreOp
+  std::optional<bool> stencilReadOnly;         // boolean
+};
+
+} // namespace rnwgpu
+
+namespace rnwgpu {
+
+template <>
+struct JSIConverter<
+    std::shared_ptr<rnwgpu::GPURenderPassDepthStencilAttachment>> {
+  static std::shared_ptr<rnwgpu::GPURenderPassDepthStencilAttachment>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result =
+        std::make_unique<rnwgpu::GPURenderPassDepthStencilAttachment>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "view")) {
+        auto prop = value.getProperty(runtime, "view");
+        result->view = JSIConverter<std::shared_ptr<GPUTextureView>>::fromJSI(
+            runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "depthClearValue")) {
+        auto prop = value.getProperty(runtime, "depthClearValue");
+        result->depthClearValue =
+            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "depthLoadOp")) {
+        auto prop = value.getProperty(runtime, "depthLoadOp");
+        result->depthLoadOp =
+            JSIConverter<std::optional<wgpu::LoadOp>>::fromJSI(runtime, prop,
+                                                               false);
+      }
+      if (value.hasProperty(runtime, "depthStoreOp")) {
+        auto prop = value.getProperty(runtime, "depthStoreOp");
+        result->depthStoreOp =
+            JSIConverter<std::optional<wgpu::StoreOp>>::fromJSI(runtime, prop,
+                                                                false);
+      }
+      if (value.hasProperty(runtime, "depthReadOnly")) {
+        auto prop = value.getProperty(runtime, "depthReadOnly");
+        result->depthReadOnly =
+            JSIConverter<std::optional<bool>>::fromJSI(runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "stencilClearValue")) {
+        auto prop = value.getProperty(runtime, "stencilClearValue");
+        result->stencilClearValue =
+            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "stencilLoadOp")) {
+        auto prop = value.getProperty(runtime, "stencilLoadOp");
+        result->stencilLoadOp =
+            JSIConverter<std::optional<wgpu::LoadOp>>::fromJSI(runtime, prop,
+                                                               false);
+      }
+      if (value.hasProperty(runtime, "stencilStoreOp")) {
+        auto prop = value.getProperty(runtime, "stencilStoreOp");
+        result->stencilStoreOp =
+            JSIConverter<std::optional<wgpu::StoreOp>>::fromJSI(runtime, prop,
+                                                                false);
+      }
+      if (value.hasProperty(runtime, "stencilReadOnly")) {
+        auto prop = value.getProperty(runtime, "stencilReadOnly");
+        result->stencilReadOnly =
+            JSIConverter<std::optional<bool>>::fromJSI(runtime, prop, false);
+      }
+    }
+
+    return result;
+  }
+  static jsi::Value
+  toJSI(jsi::Runtime &runtime,
+        std::shared_ptr<rnwgpu::GPURenderPassDepthStencilAttachment> arg) {
+    throw std::runtime_error(
+        "Invalid GPURenderPassDepthStencilAttachment::toJSI()");
+  }
+};
+
+} // namespace rnwgpu

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

@@ -0,0 +1,93 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <variant>
+#include <vector>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "JSIConverter.h"
+#include "WGPULogger.h"
+
+#include "GPUQuerySet.h"
+#include "GPURenderPassColorAttachment.h"
+#include "GPURenderPassDepthStencilAttachment.h"
+#include "GPURenderPassTimestampWrites.h"
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+struct GPURenderPassDescriptor {
+  std::vector<std::variant<std::nullptr_t,
+                           std::shared_ptr<GPURenderPassColorAttachment>>>
+      colorAttachments; // Iterable<GPURenderPassColorAttachment | null>
+  std::optional<std::shared_ptr<GPURenderPassDepthStencilAttachment>>
+      depthStencilAttachment; // GPURenderPassDepthStencilAttachment
+  std::optional<std::shared_ptr<GPUQuerySet>> occlusionQuerySet; // GPUQuerySet
+  std::optional<std::shared_ptr<GPURenderPassTimestampWrites>>
+      timestampWrites;                // GPURenderPassTimestampWrites
+  std::optional<double> maxDrawCount; // GPUSize64
+  std::optional<std::string> label;   // string
+};
+
+} // namespace rnwgpu
+
+namespace rnwgpu {
+
+template <>
+struct JSIConverter<std::shared_ptr<rnwgpu::GPURenderPassDescriptor>> {
+  static std::shared_ptr<rnwgpu::GPURenderPassDescriptor>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPURenderPassDescriptor>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "colorAttachments")) {
+        auto prop = value.getProperty(runtime, "colorAttachments");
+        result->colorAttachments = JSIConverter<std::vector<std::variant<
+            std::nullptr_t, std::shared_ptr<GPURenderPassColorAttachment>>>>::
+            fromJSI(runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "depthStencilAttachment")) {
+        auto prop = value.getProperty(runtime, "depthStencilAttachment");
+        result->depthStencilAttachment =
+            JSIConverter<std::optional<std::shared_ptr<
+                GPURenderPassDepthStencilAttachment>>>::fromJSI(runtime, prop,
+                                                                false);
+      }
+      if (value.hasProperty(runtime, "occlusionQuerySet")) {
+        auto prop = value.getProperty(runtime, "occlusionQuerySet");
+        result->occlusionQuerySet =
+            JSIConverter<std::optional<std::shared_ptr<GPUQuerySet>>>::fromJSI(
+                runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "timestampWrites")) {
+        auto prop = value.getProperty(runtime, "timestampWrites");
+        result->timestampWrites = JSIConverter<std::optional<
+            std::shared_ptr<GPURenderPassTimestampWrites>>>::fromJSI(runtime,
+                                                                     prop,
+                                                                     false);
+      }
+      if (value.hasProperty(runtime, "maxDrawCount")) {
+        auto prop = value.getProperty(runtime, "maxDrawCount");
+        result->maxDrawCount =
+            JSIConverter<std::optional<double>>::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::GPURenderPassDescriptor> arg) {
+    throw std::runtime_error("Invalid GPURenderPassDescriptor::toJSI()");
+  }
+};
+
+} // namespace rnwgpu

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

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

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

@@ -0,0 +1,104 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "JSIConverter.h"
+#include "WGPULogger.h"
+
+#include "GPUDepthStencilState.h"
+#include "GPUFragmentState.h"
+#include "GPUMultisampleState.h"
+#include "GPUPipelineLayout.h"
+#include "GPUPrimitiveState.h"
+#include "GPUVertexState.h"
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+struct GPURenderPipelineDescriptor {
+  std::shared_ptr<GPUVertexState> vertex; // GPUVertexState
+  std::optional<std::shared_ptr<GPUPrimitiveState>>
+      primitive; // GPUPrimitiveState
+  std::optional<std::shared_ptr<GPUDepthStencilState>>
+      depthStencil; // GPUDepthStencilState
+  std::optional<std::shared_ptr<GPUMultisampleState>>
+      multisample; // GPUMultisampleState
+  std::optional<std::shared_ptr<GPUFragmentState>> fragment; // GPUFragmentState
+  std::variant<std::nullptr_t, std::shared_ptr<GPUPipelineLayout>>
+      layout;                       // | GPUPipelineLayout | GPUAutoLayoutMode
+  std::optional<std::string> label; // string
+};
+
+} // namespace rnwgpu
+
+namespace rnwgpu {
+
+template <>
+struct JSIConverter<std::shared_ptr<rnwgpu::GPURenderPipelineDescriptor>> {
+  static std::shared_ptr<rnwgpu::GPURenderPipelineDescriptor>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPURenderPipelineDescriptor>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "vertex")) {
+        auto prop = value.getProperty(runtime, "vertex");
+        result->vertex = JSIConverter<std::shared_ptr<GPUVertexState>>::fromJSI(
+            runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "primitive")) {
+        auto prop = value.getProperty(runtime, "primitive");
+        result->primitive = JSIConverter<
+            std::optional<std::shared_ptr<GPUPrimitiveState>>>::fromJSI(runtime,
+                                                                        prop,
+                                                                        false);
+      }
+      if (value.hasProperty(runtime, "depthStencil")) {
+        auto prop = value.getProperty(runtime, "depthStencil");
+        result->depthStencil =
+            JSIConverter<std::optional<std::shared_ptr<GPUDepthStencilState>>>::
+                fromJSI(runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "multisample")) {
+        auto prop = value.getProperty(runtime, "multisample");
+        result->multisample =
+            JSIConverter<std::optional<std::shared_ptr<GPUMultisampleState>>>::
+                fromJSI(runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "fragment")) {
+        auto prop = value.getProperty(runtime, "fragment");
+        result->fragment = JSIConverter<
+            std::optional<std::shared_ptr<GPUFragmentState>>>::fromJSI(runtime,
+                                                                       prop,
+                                                                       false);
+      }
+      if (value.hasProperty(runtime, "layout")) {
+        auto prop = value.getProperty(runtime, "layout");
+        if (prop.isNull() || prop.isString()) {
+          result->layout = nullptr;
+        } else {
+          result->layout =
+              JSIConverter<std::shared_ptr<GPUPipelineLayout>>::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::GPURenderPipelineDescriptor> arg) {
+    throw std::runtime_error("Invalid GPURenderPipelineDescriptor::toJSI()");
+  }
+};
+
+} // namespace rnwgpu

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

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

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

@@ -0,0 +1,46 @@
+#pragma once
+
+#include <memory>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "JSIConverter.h"
+#include "WGPULogger.h"
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+struct GPUSamplerBindingLayout {
+  std::optional<wgpu::SamplerBindingType> type; // GPUSamplerBindingType
+};
+
+} // namespace rnwgpu
+
+namespace rnwgpu {
+
+template <>
+struct JSIConverter<std::shared_ptr<rnwgpu::GPUSamplerBindingLayout>> {
+  static std::shared_ptr<rnwgpu::GPUSamplerBindingLayout>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUSamplerBindingLayout>();
+    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::SamplerBindingType>>::fromJSI(
+                runtime, prop, false);
+      }
+    }
+
+    return result;
+  }
+  static jsi::Value
+  toJSI(jsi::Runtime &runtime,
+        std::shared_ptr<rnwgpu::GPUSamplerBindingLayout> arg) {
+    throw std::runtime_error("Invalid GPUSamplerBindingLayout::toJSI()");
+  }
+};
+
+} // namespace rnwgpu