react-native-webgpu 0.5.11

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

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

package/cpp/rnwgpu/api/descriptors/GPUComputePassTimestampWrites.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 GPUComputePassTimestampWrites {
+  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::GPUComputePassTimestampWrites>> {
+  static std::shared_ptr<rnwgpu::GPUComputePassTimestampWrites>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUComputePassTimestampWrites>();
+    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::GPUComputePassTimestampWrites> arg) {
+    throw std::runtime_error("Invalid GPUComputePassTimestampWrites::toJSI()");
+  }
+};
+
+} // namespace rnwgpu

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

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

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

@@ -0,0 +1,104 @@
+#pragma once
+
+#include <memory>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "JSIConverter.h"
+#include "WGPULogger.h"
+
+#include "GPUStencilFaceState.h"
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+struct GPUDepthStencilState {
+  wgpu::TextureFormat format;                        // GPUTextureFormat
+  std::optional<bool> depthWriteEnabled;             // boolean
+  std::optional<wgpu::CompareFunction> depthCompare; // GPUCompareFunction
+  std::optional<std::shared_ptr<GPUStencilFaceState>>
+      stencilFront; // GPUStencilFaceState
+  std::optional<std::shared_ptr<GPUStencilFaceState>>
+      stencilBack;                           // GPUStencilFaceState
+  std::optional<double> stencilReadMask;     // GPUStencilValue
+  std::optional<double> stencilWriteMask;    // GPUStencilValue
+  std::optional<double> depthBias;           // GPUDepthBias
+  std::optional<double> depthBiasSlopeScale; // number
+  std::optional<double> depthBiasClamp;      // number
+};
+
+} // namespace rnwgpu
+
+namespace rnwgpu {
+
+template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUDepthStencilState>> {
+  static std::shared_ptr<rnwgpu::GPUDepthStencilState>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUDepthStencilState>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "format")) {
+        auto prop = value.getProperty(runtime, "format");
+        result->format =
+            JSIConverter<wgpu::TextureFormat>::fromJSI(runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "depthWriteEnabled")) {
+        auto prop = value.getProperty(runtime, "depthWriteEnabled");
+        result->depthWriteEnabled =
+            JSIConverter<std::optional<bool>>::fromJSI(runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "depthCompare")) {
+        auto prop = value.getProperty(runtime, "depthCompare");
+        result->depthCompare =
+            JSIConverter<std::optional<wgpu::CompareFunction>>::fromJSI(
+                runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "stencilFront")) {
+        auto prop = value.getProperty(runtime, "stencilFront");
+        result->stencilFront =
+            JSIConverter<std::optional<std::shared_ptr<GPUStencilFaceState>>>::
+                fromJSI(runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "stencilBack")) {
+        auto prop = value.getProperty(runtime, "stencilBack");
+        result->stencilBack =
+            JSIConverter<std::optional<std::shared_ptr<GPUStencilFaceState>>>::
+                fromJSI(runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "stencilReadMask")) {
+        auto prop = value.getProperty(runtime, "stencilReadMask");
+        result->stencilReadMask =
+            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "stencilWriteMask")) {
+        auto prop = value.getProperty(runtime, "stencilWriteMask");
+        result->stencilWriteMask =
+            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "depthBias")) {
+        auto prop = value.getProperty(runtime, "depthBias");
+        result->depthBias =
+            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "depthBiasSlopeScale")) {
+        auto prop = value.getProperty(runtime, "depthBiasSlopeScale");
+        result->depthBiasSlopeScale =
+            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "depthBiasClamp")) {
+        auto prop = value.getProperty(runtime, "depthBiasClamp");
+        result->depthBiasClamp =
+            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
+      }
+    }
+
+    return result;
+  }
+  static jsi::Value toJSI(jsi::Runtime &runtime,
+                          std::shared_ptr<rnwgpu::GPUDepthStencilState> arg) {
+    throw std::runtime_error("Invalid GPUDepthStencilState::toJSI()");
+  }
+};
+
+} // namespace rnwgpu

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

@@ -0,0 +1,100 @@
+#pragma once
+
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "JSIConverter.h"
+#include "WGPULogger.h"
+
+#include "GPUQueueDescriptor.h"
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+struct GPUDeviceDescriptor {
+  std::optional<std::vector<wgpu::FeatureName>>
+      requiredFeatures; // Iterable<GPUFeatureName>
+  std::optional<std::map<std::string, double>>
+      requiredLimits; // Record< string, GPUSize64 >
+  std::optional<std::shared_ptr<GPUQueueDescriptor>>
+      defaultQueue;                 // GPUQueueDescriptor
+  std::optional<std::string> label; // string
+};
+
+} // namespace rnwgpu
+
+namespace rnwgpu {
+
+// We add this extra convertor because we found so library that are sending
+// invalid feature elements
+template <> struct JSIConverter<std::vector<wgpu::FeatureName>> {
+
+  static std::vector<wgpu::FeatureName>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    jsi::Array array = arg.asObject(runtime).asArray(runtime);
+    size_t length = array.size(runtime);
+
+    std::vector<wgpu::FeatureName> vector;
+    vector.reserve(length);
+    for (size_t i = 0; i < length; ++i) {
+      jsi::Value elementValue = array.getValueAtIndex(runtime, i);
+      if (elementValue.isString()) {
+        vector.emplace_back(JSIConverter<wgpu::FeatureName>::fromJSI(
+            runtime, elementValue, outOfBounds));
+      }
+    }
+    return vector;
+  }
+  static jsi::Value toJSI(jsi::Runtime &runtime,
+                          std::shared_ptr<rnwgpu::GPUDeviceDescriptor> arg) {
+    throw std::runtime_error(
+        "Invalid JSIConverter<std::vector<wgpu::FeatureName>>::toJSI()");
+  }
+};
+
+template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUDeviceDescriptor>> {
+  static std::shared_ptr<rnwgpu::GPUDeviceDescriptor>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUDeviceDescriptor>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "requiredFeatures")) {
+        auto prop = value.getProperty(runtime, "requiredFeatures");
+        result->requiredFeatures = JSIConverter<
+            std::optional<std::vector<wgpu::FeatureName>>>::fromJSI(runtime,
+                                                                    prop,
+                                                                    false);
+      }
+      if (value.hasProperty(runtime, "requiredLimits")) {
+        auto prop = value.getProperty(runtime, "requiredLimits");
+        result->requiredLimits =
+            JSIConverter<std::optional<std::map<std::string, double>>>::fromJSI(
+                runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "defaultQueue")) {
+        auto prop = value.getProperty(runtime, "defaultQueue");
+        result->defaultQueue =
+            JSIConverter<std::optional<std::shared_ptr<GPUQueueDescriptor>>>::
+                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::GPUDeviceDescriptor> arg) {
+    throw std::runtime_error("Invalid GPUDeviceDescriptor::toJSI()");
+  }
+};
+
+} // namespace rnwgpu

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

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

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

@@ -0,0 +1,80 @@
+#pragma once
+
+#include <memory>
+#include <optional>
+#include <string>
+#include <variant>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "Convertors.h"
+
+#include "JSIConverter.h"
+#include "WGPULogger.h"
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+struct GPUExternalTextureDescriptor {
+  // std::variant<std::shared_ptr<HTMLVideoElement>,
+  // std::shared_ptr<VideoFrame>>
+  //     source; // | HTMLVideoElement | VideoFrame
+  // std::optional<wgpu::DefinedColorSpace> colorSpace; // PredefinedColorSpace
+  std::optional<std::string> label; // string
+};
+
+static bool conv(wgpu::ExternalTextureDescriptor &out,
+                 const std::shared_ptr<GPUExternalTextureDescriptor> &in) {
+  // TODO: implement
+  // return conv(out.source, in->source) && conv(out.colorSpace, in->colorSpace)
+  // &&
+  // return conv(out.label, in->label);
+  return false;
+}
+} // namespace rnwgpu
+
+namespace rnwgpu {
+
+template <>
+struct JSIConverter<std::shared_ptr<rnwgpu::GPUExternalTextureDescriptor>> {
+  static std::shared_ptr<rnwgpu::GPUExternalTextureDescriptor>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUExternalTextureDescriptor>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "source")) {
+        auto prop = value.getProperty(runtime, "source");
+        // result->source = JSIConverter<
+        //     std::variant<std::shared_ptr<HTMLVideoElement>,
+        //                  std::shared_ptr<VideoFrame>>>::fromJSI(runtime,
+        //                  prop,
+        //                                                         false);
+      }
+      if (value.hasProperty(runtime, "colorSpace")) {
+        auto prop = value.getProperty(runtime, "colorSpace");
+        if (!prop.isUndefined()) {
+          // result->colorSpace =
+          //     JSIConverter<std::optional<wgpu::definedColorSpace>>::fromJSI(
+          //         runtime, prop, false);
+        }
+      }
+      if (value.hasProperty(runtime, "label")) {
+        auto prop = value.getProperty(runtime, "label");
+        if (!prop.isUndefined()) {
+          result->label = JSIConverter<std::optional<std::string>>::fromJSI(
+              runtime, prop, false);
+        }
+      }
+    }
+
+    return result;
+  }
+  static jsi::Value
+  toJSI(jsi::Runtime &runtime,
+        std::shared_ptr<rnwgpu::GPUExternalTextureDescriptor> arg) {
+    throw std::runtime_error("Invalid GPUExternalTextureDescriptor::toJSI()");
+  }
+};
+
+} // namespace rnwgpu

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

@@ -0,0 +1,74 @@
+#pragma once
+
+#include <map>
+#include <memory>
+#include <string>
+#include <variant>
+#include <vector>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "JSIConverter.h"
+#include "WGPULogger.h"
+
+#include "GPUColorTargetState.h"
+#include "GPUShaderModule.h"
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+struct GPUFragmentState {
+  std::vector<
+      std::variant<std::nullptr_t, std::shared_ptr<GPUColorTargetState>>>
+      targets; // Iterable<GPUColorTargetState | null>
+  std::shared_ptr<GPUShaderModule> module; // GPUShaderModule
+  std::optional<std::string> entryPoint;   // string
+  std::optional<std::map<std::string, double>>
+      constants; // Record< string, GPUPipelineConstantValue >
+};
+
+} // namespace rnwgpu
+
+namespace rnwgpu {
+
+template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUFragmentState>> {
+  static std::shared_ptr<rnwgpu::GPUFragmentState>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUFragmentState>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "targets")) {
+        auto prop = value.getProperty(runtime, "targets");
+        result->targets = JSIConverter<std::vector<std::variant<
+            std::nullptr_t, std::shared_ptr<GPUColorTargetState>>>>::
+            fromJSI(runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "module")) {
+        auto prop = value.getProperty(runtime, "module");
+        result->module =
+            JSIConverter<std::shared_ptr<GPUShaderModule>>::fromJSI(
+                runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "entryPoint")) {
+        auto prop = value.getProperty(runtime, "entryPoint");
+        result->entryPoint = JSIConverter<std::optional<std::string>>::fromJSI(
+            runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "constants")) {
+        auto prop = value.getProperty(runtime, "constants");
+        result->constants =
+            JSIConverter<std::optional<std::map<std::string, double>>>::fromJSI(
+                runtime, prop, false);
+      }
+    }
+
+    return result;
+  }
+  static jsi::Value toJSI(jsi::Runtime &runtime,
+                          std::shared_ptr<rnwgpu::GPUFragmentState> arg) {
+    throw std::runtime_error("Invalid GPUFragmentState::toJSI()");
+  }
+};
+
+} // namespace rnwgpu

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

@@ -0,0 +1,63 @@
+#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 GPUImageCopyBuffer {
+  std::shared_ptr<GPUBuffer> buffer;  // GPUBuffer
+  std::optional<double> offset;       // GPUSize64
+  std::optional<double> bytesPerRow;  // GPUSize32
+  std::optional<double> rowsPerImage; // GPUSize32
+};
+
+} // namespace rnwgpu
+
+namespace rnwgpu {
+
+template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUImageCopyBuffer>> {
+  static std::shared_ptr<rnwgpu::GPUImageCopyBuffer>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUImageCopyBuffer>();
+    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, "bytesPerRow")) {
+        auto prop = value.getProperty(runtime, "bytesPerRow");
+        result->bytesPerRow =
+            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "rowsPerImage")) {
+        auto prop = value.getProperty(runtime, "rowsPerImage");
+        result->rowsPerImage =
+            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
+      }
+    }
+
+    return result;
+  }
+  static jsi::Value toJSI(jsi::Runtime &runtime,
+                          std::shared_ptr<rnwgpu::GPUImageCopyBuffer> arg) {
+    throw std::runtime_error("Invalid GPUImageCopyBuffer::toJSI()");
+  }
+};
+
+} // namespace rnwgpu