react-native-wgpu 0.1.0

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

@@ -0,0 +1,54 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "Logger.h"
+#include "RNFJSIConverter.h"
+#include <RNFHybridObject.h>
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+class GPUPipelineErrorInit {
+public:
+  wgpu::PipelineErrorInit *getInstance() { return &_instance; }
+
+  wgpu::PipelineErrorInit _instance;
+};
+} // namespace rnwgpu
+
+namespace margelo {
+
+template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUPipelineErrorInit>> {
+  static std::shared_ptr<rnwgpu::GPUPipelineErrorInit>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUPipelineErrorInit>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "reason")) {
+        auto reason = value.getProperty(runtime, "reason");
+
+        if (reason.isUndefined()) {
+          throw std::runtime_error(
+              "Property GPUPipelineErrorInit::reason is required");
+        }
+      } else {
+        throw std::runtime_error(
+            "Property GPUPipelineErrorInit::reason is not defined");
+      }
+    }
+    rnwgpu::Logger::logToConsole("GPUPipelineErrorInit::reason = %f",
+                                 result->_instance.reason);
+    return result;
+  }
+  static jsi::Value toJSI(jsi::Runtime &runtime,
+                          std::shared_ptr<rnwgpu::GPUPipelineErrorInit> arg) {
+    // No conversions here
+    return jsi::Value::null();
+  }
+};
+} // namespace margelo

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

@@ -0,0 +1,72 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "Logger.h"
+#include "RNFJSIConverter.h"
+#include <RNFHybridObject.h>
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+class GPUPipelineLayoutDescriptor {
+public:
+  wgpu::PipelineLayoutDescriptor *getInstance() { return &_instance; }
+
+  wgpu::PipelineLayoutDescriptor _instance;
+
+  std::string label;
+};
+} // namespace rnwgpu
+
+namespace margelo {
+
+template <>
+struct JSIConverter<std::shared_ptr<rnwgpu::GPUPipelineLayoutDescriptor>> {
+  static std::shared_ptr<rnwgpu::GPUPipelineLayoutDescriptor>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUPipelineLayoutDescriptor>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "bindGroupLayouts")) {
+        auto bindGroupLayouts = value.getProperty(runtime, "bindGroupLayouts");
+
+        if (bindGroupLayouts.isUndefined()) {
+          throw std::runtime_error(
+              "Property GPUPipelineLayoutDescriptor::bindGroupLayouts is "
+              "required");
+        }
+      } else {
+        throw std::runtime_error(
+            "Property GPUPipelineLayoutDescriptor::bindGroupLayouts is not "
+            "defined");
+      }
+      if (value.hasProperty(runtime, "label")) {
+        auto label = value.getProperty(runtime, "label");
+
+        if (label.isString()) {
+          auto str = label.asString(runtime).utf8(runtime);
+          result->label = str;
+          result->_instance.label = result->label.c_str();
+        }
+      }
+    }
+    rnwgpu::Logger::logToConsole(
+        "GPUPipelineLayoutDescriptor::bindGroupLayouts = %f",
+        result->_instance.bindGroupLayouts);
+    rnwgpu::Logger::logToConsole("GPUPipelineLayoutDescriptor::label = %f",
+                                 result->_instance.label);
+    return result;
+  }
+  static jsi::Value
+  toJSI(jsi::Runtime &runtime,
+        std::shared_ptr<rnwgpu::GPUPipelineLayoutDescriptor> arg) {
+    // No conversions here
+    return jsi::Value::null();
+  }
+};
+} // namespace margelo

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

@@ -0,0 +1,66 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "Logger.h"
+#include "RNFJSIConverter.h"
+#include <RNFHybridObject.h>
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+class GPUPrimitiveState {
+public:
+  wgpu::PrimitiveState *getInstance() { return &_instance; }
+
+  wgpu::PrimitiveState _instance;
+};
+} // namespace rnwgpu
+
+namespace margelo {
+
+template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUPrimitiveState>> {
+  static std::shared_ptr<rnwgpu::GPUPrimitiveState>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUPrimitiveState>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "topology")) {
+        auto topology = value.getProperty(runtime, "topology");
+      }
+      if (value.hasProperty(runtime, "stripIndexFormat")) {
+        auto stripIndexFormat = value.getProperty(runtime, "stripIndexFormat");
+      }
+      if (value.hasProperty(runtime, "frontFace")) {
+        auto frontFace = value.getProperty(runtime, "frontFace");
+      }
+      if (value.hasProperty(runtime, "cullMode")) {
+        auto cullMode = value.getProperty(runtime, "cullMode");
+      }
+      if (value.hasProperty(runtime, "unclippedDepth")) {
+        auto unclippedDepth = value.getProperty(runtime, "unclippedDepth");
+      }
+    }
+    rnwgpu::Logger::logToConsole("GPUPrimitiveState::topology = %f",
+                                 result->_instance.topology);
+    rnwgpu::Logger::logToConsole("GPUPrimitiveState::stripIndexFormat = %f",
+                                 result->_instance.stripIndexFormat);
+    rnwgpu::Logger::logToConsole("GPUPrimitiveState::frontFace = %f",
+                                 result->_instance.frontFace);
+    rnwgpu::Logger::logToConsole("GPUPrimitiveState::cullMode = %f",
+                                 result->_instance.cullMode);
+    rnwgpu::Logger::logToConsole("GPUPrimitiveState::unclippedDepth = %f",
+                                 result->_instance.unclippedDepth);
+    return result;
+  }
+  static jsi::Value toJSI(jsi::Runtime &runtime,
+                          std::shared_ptr<rnwgpu::GPUPrimitiveState> arg) {
+    // No conversions here
+    return jsi::Value::null();
+  }
+};
+} // namespace margelo

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

@@ -0,0 +1,72 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "Logger.h"
+#include "RNFJSIConverter.h"
+#include <RNFHybridObject.h>
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+class GPUProgrammableStage {
+public:
+  wgpu::ProgrammableStage *getInstance() { return &_instance; }
+
+  wgpu::ProgrammableStage _instance;
+
+  std::string entryPoint;
+};
+} // namespace rnwgpu
+
+namespace margelo {
+
+template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUProgrammableStage>> {
+  static std::shared_ptr<rnwgpu::GPUProgrammableStage>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUProgrammableStage>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "module")) {
+        auto module = value.getProperty(runtime, "module");
+
+        if (module.isUndefined()) {
+          throw std::runtime_error(
+              "Property GPUProgrammableStage::module is required");
+        }
+      } else {
+        throw std::runtime_error(
+            "Property GPUProgrammableStage::module is not defined");
+      }
+      if (value.hasProperty(runtime, "entryPoint")) {
+        auto entryPoint = value.getProperty(runtime, "entryPoint");
+
+        if (entryPoint.isString()) {
+          auto str = entryPoint.asString(runtime).utf8(runtime);
+          result->entryPoint = str;
+          result->_instance.entryPoint = result->entryPoint.c_str();
+        }
+      }
+      if (value.hasProperty(runtime, "constants")) {
+        auto constants = value.getProperty(runtime, "constants");
+      }
+    }
+    rnwgpu::Logger::logToConsole("GPUProgrammableStage::module = %f",
+                                 result->_instance.module);
+    rnwgpu::Logger::logToConsole("GPUProgrammableStage::entryPoint = %f",
+                                 result->_instance.entryPoint);
+    rnwgpu::Logger::logToConsole("GPUProgrammableStage::constants = %f",
+                                 result->_instance.constants);
+    return result;
+  }
+  static jsi::Value toJSI(jsi::Runtime &runtime,
+                          std::shared_ptr<rnwgpu::GPUProgrammableStage> arg) {
+    // No conversions here
+    return jsi::Value::null();
+  }
+};
+} // namespace margelo

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

@@ -0,0 +1,81 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "Logger.h"
+#include "RNFJSIConverter.h"
+#include <RNFHybridObject.h>
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+class GPUQuerySetDescriptor {
+public:
+  wgpu::QuerySetDescriptor *getInstance() { return &_instance; }
+
+  wgpu::QuerySetDescriptor _instance;
+
+  std::string label;
+};
+} // namespace rnwgpu
+
+namespace margelo {
+
+template <>
+struct JSIConverter<std::shared_ptr<rnwgpu::GPUQuerySetDescriptor>> {
+  static std::shared_ptr<rnwgpu::GPUQuerySetDescriptor>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUQuerySetDescriptor>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "type")) {
+        auto type = value.getProperty(runtime, "type");
+
+        if (type.isUndefined()) {
+          throw std::runtime_error(
+              "Property GPUQuerySetDescriptor::type is required");
+        }
+      } else {
+        throw std::runtime_error(
+            "Property GPUQuerySetDescriptor::type is not defined");
+      }
+      if (value.hasProperty(runtime, "count")) {
+        auto count = value.getProperty(runtime, "count");
+
+        if (count.isUndefined()) {
+          throw std::runtime_error(
+              "Property GPUQuerySetDescriptor::count is required");
+        }
+      } else {
+        throw std::runtime_error(
+            "Property GPUQuerySetDescriptor::count is not defined");
+      }
+      if (value.hasProperty(runtime, "label")) {
+        auto label = value.getProperty(runtime, "label");
+
+        if (label.isString()) {
+          auto str = label.asString(runtime).utf8(runtime);
+          result->label = str;
+          result->_instance.label = result->label.c_str();
+        }
+      }
+    }
+    rnwgpu::Logger::logToConsole("GPUQuerySetDescriptor::type = %f",
+                                 result->_instance.type);
+    rnwgpu::Logger::logToConsole("GPUQuerySetDescriptor::count = %f",
+                                 result->_instance.count);
+    rnwgpu::Logger::logToConsole("GPUQuerySetDescriptor::label = %f",
+                                 result->_instance.label);
+    return result;
+  }
+  static jsi::Value toJSI(jsi::Runtime &runtime,
+                          std::shared_ptr<rnwgpu::GPUQuerySetDescriptor> arg) {
+    // No conversions here
+    return jsi::Value::null();
+  }
+};
+} // namespace margelo

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

@@ -0,0 +1,102 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "Logger.h"
+#include "RNFJSIConverter.h"
+#include <RNFHybridObject.h>
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+class GPURenderBundleEncoderDescriptor {
+public:
+  wgpu::RenderBundleEncoderDescriptor *getInstance() { return &_instance; }
+
+  wgpu::RenderBundleEncoderDescriptor _instance;
+
+  std::string label;
+};
+} // namespace rnwgpu
+
+namespace margelo {
+
+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 depthReadOnly = value.getProperty(runtime, "depthReadOnly");
+      }
+      if (value.hasProperty(runtime, "stencilReadOnly")) {
+        auto stencilReadOnly = value.getProperty(runtime, "stencilReadOnly");
+      }
+      if (value.hasProperty(runtime, "colorFormats")) {
+        auto colorFormats = value.getProperty(runtime, "colorFormats");
+
+        if (colorFormats.isUndefined()) {
+          throw std::runtime_error(
+              "Property GPURenderBundleEncoderDescriptor::colorFormats is "
+              "required");
+        }
+      } else {
+        throw std::runtime_error(
+            "Property GPURenderBundleEncoderDescriptor::colorFormats is not "
+            "defined");
+      }
+      if (value.hasProperty(runtime, "depthStencilFormat")) {
+        auto depthStencilFormat =
+            value.getProperty(runtime, "depthStencilFormat");
+      }
+      if (value.hasProperty(runtime, "sampleCount")) {
+        auto sampleCount = value.getProperty(runtime, "sampleCount");
+
+        if (sampleCount.isNumber()) {
+          result->_instance.sampleCount =
+              static_cast<wgpu::Size32>(sampleCount.getNumber());
+        }
+      }
+      if (value.hasProperty(runtime, "label")) {
+        auto label = value.getProperty(runtime, "label");
+
+        if (label.isString()) {
+          auto str = label.asString(runtime).utf8(runtime);
+          result->label = str;
+          result->_instance.label = result->label.c_str();
+        }
+      }
+    }
+    rnwgpu::Logger::logToConsole(
+        "GPURenderBundleEncoderDescriptor::depthReadOnly = %f",
+        result->_instance.depthReadOnly);
+    rnwgpu::Logger::logToConsole(
+        "GPURenderBundleEncoderDescriptor::stencilReadOnly = %f",
+        result->_instance.stencilReadOnly);
+    rnwgpu::Logger::logToConsole(
+        "GPURenderBundleEncoderDescriptor::colorFormats = %f",
+        result->_instance.colorFormats);
+    rnwgpu::Logger::logToConsole(
+        "GPURenderBundleEncoderDescriptor::depthStencilFormat = %f",
+        result->_instance.depthStencilFormat);
+    rnwgpu::Logger::logToConsole(
+        "GPURenderBundleEncoderDescriptor::sampleCount = %f",
+        result->_instance.sampleCount);
+    rnwgpu::Logger::logToConsole("GPURenderBundleEncoderDescriptor::label = %f",
+                                 result->_instance.label);
+    return result;
+  }
+  static jsi::Value
+  toJSI(jsi::Runtime &runtime,
+        std::shared_ptr<rnwgpu::GPURenderBundleEncoderDescriptor> arg) {
+    // No conversions here
+    return jsi::Value::null();
+  }
+};
+} // namespace margelo

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

@@ -0,0 +1,105 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "Logger.h"
+#include "RNFJSIConverter.h"
+#include <RNFHybridObject.h>
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+class GPURenderPassColorAttachment {
+public:
+  wgpu::RenderPassColorAttachment *getInstance() { return &_instance; }
+
+  wgpu::RenderPassColorAttachment _instance;
+};
+} // namespace rnwgpu
+
+namespace margelo {
+
+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 view = value.getProperty(runtime, "view");
+
+        if (view.isUndefined()) {
+          throw std::runtime_error(
+              "Property GPURenderPassColorAttachment::view is required");
+        }
+      } else {
+        throw std::runtime_error(
+            "Property GPURenderPassColorAttachment::view is not defined");
+      }
+      if (value.hasProperty(runtime, "depthSlice")) {
+        auto depthSlice = value.getProperty(runtime, "depthSlice");
+
+        if (depthSlice.isNumber()) {
+          result->_instance.depthSlice =
+              static_cast<wgpu::IntegerCoordinate>(depthSlice.getNumber());
+        }
+      }
+      if (value.hasProperty(runtime, "resolveTarget")) {
+        auto resolveTarget = value.getProperty(runtime, "resolveTarget");
+      }
+      if (value.hasProperty(runtime, "clearValue")) {
+        auto clearValue = value.getProperty(runtime, "clearValue");
+      }
+      if (value.hasProperty(runtime, "loadOp")) {
+        auto loadOp = value.getProperty(runtime, "loadOp");
+
+        if (loadOp.isUndefined()) {
+          throw std::runtime_error(
+              "Property GPURenderPassColorAttachment::loadOp is required");
+        }
+      } else {
+        throw std::runtime_error(
+            "Property GPURenderPassColorAttachment::loadOp is not defined");
+      }
+      if (value.hasProperty(runtime, "storeOp")) {
+        auto storeOp = value.getProperty(runtime, "storeOp");
+
+        if (storeOp.isUndefined()) {
+          throw std::runtime_error(
+              "Property GPURenderPassColorAttachment::storeOp is required");
+        }
+      } else {
+        throw std::runtime_error(
+            "Property GPURenderPassColorAttachment::storeOp is not defined");
+      }
+    }
+    rnwgpu::Logger::logToConsole("GPURenderPassColorAttachment::view = %f",
+                                 result->_instance.view);
+    rnwgpu::Logger::logToConsole(
+        "GPURenderPassColorAttachment::depthSlice = %f",
+        result->_instance.depthSlice);
+    rnwgpu::Logger::logToConsole(
+        "GPURenderPassColorAttachment::resolveTarget = %f",
+        result->_instance.resolveTarget);
+    rnwgpu::Logger::logToConsole(
+        "GPURenderPassColorAttachment::clearValue = %f",
+        result->_instance.clearValue);
+    rnwgpu::Logger::logToConsole("GPURenderPassColorAttachment::loadOp = %f",
+                                 result->_instance.loadOp);
+    rnwgpu::Logger::logToConsole("GPURenderPassColorAttachment::storeOp = %f",
+                                 result->_instance.storeOp);
+    return result;
+  }
+  static jsi::Value
+  toJSI(jsi::Runtime &runtime,
+        std::shared_ptr<rnwgpu::GPURenderPassColorAttachment> arg) {
+    // No conversions here
+    return jsi::Value::null();
+  }
+};
+} // namespace margelo

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

@@ -0,0 +1,118 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "Logger.h"
+#include "RNFJSIConverter.h"
+#include <RNFHybridObject.h>
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+class GPURenderPassDepthStencilAttachment {
+public:
+  wgpu::RenderPassDepthStencilAttachment *getInstance() { return &_instance; }
+
+  wgpu::RenderPassDepthStencilAttachment _instance;
+};
+} // namespace rnwgpu
+
+namespace margelo {
+
+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 view = value.getProperty(runtime, "view");
+
+        if (view.isUndefined()) {
+          throw std::runtime_error(
+              "Property GPURenderPassDepthStencilAttachment::view is required");
+        }
+      } else {
+        throw std::runtime_error(
+            "Property GPURenderPassDepthStencilAttachment::view is not "
+            "defined");
+      }
+      if (value.hasProperty(runtime, "depthClearValue")) {
+        auto depthClearValue = value.getProperty(runtime, "depthClearValue");
+
+        if (depthClearValue.isNumber()) {
+          result->_instance.depthClearValue = depthClearValue.getNumber();
+        }
+      }
+      if (value.hasProperty(runtime, "depthLoadOp")) {
+        auto depthLoadOp = value.getProperty(runtime, "depthLoadOp");
+      }
+      if (value.hasProperty(runtime, "depthStoreOp")) {
+        auto depthStoreOp = value.getProperty(runtime, "depthStoreOp");
+      }
+      if (value.hasProperty(runtime, "depthReadOnly")) {
+        auto depthReadOnly = value.getProperty(runtime, "depthReadOnly");
+      }
+      if (value.hasProperty(runtime, "stencilClearValue")) {
+        auto stencilClearValue =
+            value.getProperty(runtime, "stencilClearValue");
+
+        if (stencilClearValue.isNumber()) {
+          result->_instance.stencilClearValue =
+              static_cast<wgpu::StencilValue>(stencilClearValue.getNumber());
+        }
+      }
+      if (value.hasProperty(runtime, "stencilLoadOp")) {
+        auto stencilLoadOp = value.getProperty(runtime, "stencilLoadOp");
+      }
+      if (value.hasProperty(runtime, "stencilStoreOp")) {
+        auto stencilStoreOp = value.getProperty(runtime, "stencilStoreOp");
+      }
+      if (value.hasProperty(runtime, "stencilReadOnly")) {
+        auto stencilReadOnly = value.getProperty(runtime, "stencilReadOnly");
+      }
+    }
+    rnwgpu::Logger::logToConsole(
+        "GPURenderPassDepthStencilAttachment::view = %f",
+        result->_instance.view);
+    rnwgpu::Logger::logToConsole(
+        "GPURenderPassDepthStencilAttachment::depthClearValue = %f",
+        result->_instance.depthClearValue);
+    rnwgpu::Logger::logToConsole(
+        "GPURenderPassDepthStencilAttachment::depthLoadOp = %f",
+        result->_instance.depthLoadOp);
+    rnwgpu::Logger::logToConsole(
+        "GPURenderPassDepthStencilAttachment::depthStoreOp = %f",
+        result->_instance.depthStoreOp);
+    rnwgpu::Logger::logToConsole(
+        "GPURenderPassDepthStencilAttachment::depthReadOnly = %f",
+        result->_instance.depthReadOnly);
+    rnwgpu::Logger::logToConsole(
+        "GPURenderPassDepthStencilAttachment::stencilClearValue = %f",
+        result->_instance.stencilClearValue);
+    rnwgpu::Logger::logToConsole(
+        "GPURenderPassDepthStencilAttachment::stencilLoadOp = %f",
+        result->_instance.stencilLoadOp);
+    rnwgpu::Logger::logToConsole(
+        "GPURenderPassDepthStencilAttachment::stencilStoreOp = %f",
+        result->_instance.stencilStoreOp);
+    rnwgpu::Logger::logToConsole(
+        "GPURenderPassDepthStencilAttachment::stencilReadOnly = %f",
+        result->_instance.stencilReadOnly);
+    return result;
+  }
+  static jsi::Value
+  toJSI(jsi::Runtime &runtime,
+        std::shared_ptr<rnwgpu::GPURenderPassDepthStencilAttachment> arg) {
+    // No conversions here
+    return jsi::Value::null();
+  }
+};
+} // namespace margelo