react-native-wgpu 0.1.0 → 0.1.2

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

@@ -5,26 +5,28 @@
 
 #include "webgpu/webgpu_cpp.h"
 
-#include "Logger.h"
 #include "RNFJSIConverter.h"
-#include <RNFHybridObject.h>
+#include "WGPULogger.h"
+
+#include "RNFHybridObject.h"
 
 namespace jsi = facebook::jsi;
+namespace m = margelo;
 
 namespace rnwgpu {
 
-class GPUQuerySetDescriptor {
-public:
-  wgpu::QuerySetDescriptor *getInstance() { return &_instance; }
-
-  wgpu::QuerySetDescriptor _instance;
-
-  std::string label;
+struct GPUQuerySetDescriptor {
+  wgpu::QueryType type;             // GPUQueryType
+  double count;                     // GPUSize32
+  std::optional<std::string> label; // string
 };
+
 } // namespace rnwgpu
 
 namespace margelo {
 
+using namespace rnwgpu; // NOLINT(build/namespaces)
+
 template <>
 struct JSIConverter<std::shared_ptr<rnwgpu::GPUQuerySetDescriptor>> {
   static std::shared_ptr<rnwgpu::GPUQuerySetDescriptor>
@@ -33,49 +35,27 @@ struct JSIConverter<std::shared_ptr<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");
+        auto prop = value.getProperty(runtime, "type");
+        result->type =
+            JSIConverter<wgpu::QueryType>::fromJSI(runtime, prop, false);
       }
       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");
+        auto prop = value.getProperty(runtime, "count");
+        result->count = JSIConverter<double>::fromJSI(runtime, prop, false);
       }
       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();
-        }
+        auto prop = value.getProperty(runtime, "label");
+        result->label = JSIConverter<std::optional<std::string>>::fromJSI(
+            runtime, prop, false);
       }
     }
-    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();
+    throw std::runtime_error("Invalid GPUQuerySetDescriptor::toJSI()");
   }
 };
-} // namespace margelo
+
+} // namespace margelo

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

@@ -0,0 +1,49 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "RNFJSIConverter.h"
+#include "WGPULogger.h"
+
+#include "RNFHybridObject.h"
+
+namespace jsi = facebook::jsi;
+namespace m = margelo;
+
+namespace rnwgpu {
+
+struct GPUQueueDescriptor {
+  std::optional<std::string> label; // string
+};
+
+} // namespace rnwgpu
+
+namespace margelo {
+
+using namespace rnwgpu; // NOLINT(build/namespaces)
+
+template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUQueueDescriptor>> {
+  static std::shared_ptr<rnwgpu::GPUQueueDescriptor>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUQueueDescriptor>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      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::GPUQueueDescriptor> arg) {
+    throw std::runtime_error("Invalid GPUQueueDescriptor::toJSI()");
+  }
+};
+
+} // namespace margelo

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

@@ -0,0 +1,51 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "RNFJSIConverter.h"
+#include "WGPULogger.h"
+
+#include "RNFHybridObject.h"
+
+namespace jsi = facebook::jsi;
+namespace m = margelo;
+
+namespace rnwgpu {
+
+struct GPURenderBundleDescriptor {
+  std::optional<std::string> label; // string
+};
+
+} // namespace rnwgpu
+
+namespace margelo {
+
+using namespace rnwgpu; // NOLINT(build/namespaces)
+
+template <>
+struct JSIConverter<std::shared_ptr<rnwgpu::GPURenderBundleDescriptor>> {
+  static std::shared_ptr<rnwgpu::GPURenderBundleDescriptor>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPURenderBundleDescriptor>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      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::GPURenderBundleDescriptor> arg) {
+    throw std::runtime_error("Invalid GPURenderBundleDescriptor::toJSI()");
+  }
+};
+
+} // namespace margelo

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

@@ -2,29 +2,36 @@
 
 #include <memory>
 #include <string>
+#include <vector>
 
 #include "webgpu/webgpu_cpp.h"
 
-#include "Logger.h"
 #include "RNFJSIConverter.h"
-#include <RNFHybridObject.h>
+#include "WGPULogger.h"
+
+#include "RNFHybridObject.h"
 
 namespace jsi = facebook::jsi;
+namespace m = margelo;
 
 namespace rnwgpu {
 
-class GPURenderBundleEncoderDescriptor {
-public:
-  wgpu::RenderBundleEncoderDescriptor *getInstance() { return &_instance; }
-
-  wgpu::RenderBundleEncoderDescriptor _instance;
-
-  std::string label;
+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 margelo {
 
+using namespace rnwgpu; // NOLINT(build/namespaces)
+
 template <>
 struct JSIConverter<std::shared_ptr<rnwgpu::GPURenderBundleEncoderDescriptor>> {
   static std::shared_ptr<rnwgpu::GPURenderBundleEncoderDescriptor>
@@ -33,70 +40,47 @@ struct JSIConverter<std::shared_ptr<rnwgpu::GPURenderBundleEncoderDescriptor>> {
     if (!outOfBounds && arg.isObject()) {
       auto value = arg.getObject(runtime);
       if (value.hasProperty(runtime, "depthReadOnly")) {
-        auto depthReadOnly = value.getProperty(runtime, "depthReadOnly");
+        auto prop = value.getProperty(runtime, "depthReadOnly");
+        result->depthReadOnly =
+            JSIConverter<std::optional<bool>>::fromJSI(runtime, prop, false);
       }
       if (value.hasProperty(runtime, "stencilReadOnly")) {
-        auto stencilReadOnly = value.getProperty(runtime, "stencilReadOnly");
+        auto prop = value.getProperty(runtime, "stencilReadOnly");
+        result->stencilReadOnly =
+            JSIConverter<std::optional<bool>>::fromJSI(runtime, prop, false);
       }
       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");
+        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 depthStencilFormat =
-            value.getProperty(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 sampleCount = value.getProperty(runtime, "sampleCount");
-
-        if (sampleCount.isNumber()) {
-          result->_instance.sampleCount =
-              static_cast<wgpu::Size32>(sampleCount.getNumber());
-        }
+        auto prop = value.getProperty(runtime, "sampleCount");
+        result->sampleCount =
+            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
       }
       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();
-        }
+        auto prop = value.getProperty(runtime, "label");
+        result->label = JSIConverter<std::optional<std::string>>::fromJSI(
+            runtime, prop, false);
       }
     }
-    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();
+    throw std::runtime_error(
+        "Invalid GPURenderBundleEncoderDescriptor::toJSI()");
   }
 };
-} // namespace margelo
+
+} // namespace margelo

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

@@ -1,28 +1,37 @@
 #pragma once
 
 #include <memory>
-#include <string>
 
 #include "webgpu/webgpu_cpp.h"
 
-#include "Logger.h"
 #include "RNFJSIConverter.h"
-#include <RNFHybridObject.h>
+#include "WGPULogger.h"
+
+#include "GPUColor.h"
+#include "GPUTextureView.h"
+#include "RNFHybridObject.h"
 
 namespace jsi = facebook::jsi;
+namespace m = margelo;
 
 namespace rnwgpu {
 
-class GPURenderPassColorAttachment {
-public:
-  wgpu::RenderPassColorAttachment *getInstance() { return &_instance; }
-
-  wgpu::RenderPassColorAttachment _instance;
+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 margelo {
 
+using namespace rnwgpu; // NOLINT(build/namespaces)
+
 template <>
 struct JSIConverter<std::shared_ptr<rnwgpu::GPURenderPassColorAttachment>> {
   static std::shared_ptr<rnwgpu::GPURenderPassColorAttachment>
@@ -31,75 +40,47 @@ struct JSIConverter<std::shared_ptr<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");
+        auto prop = value.getProperty(runtime, "view");
+        result->view = JSIConverter<std::shared_ptr<GPUTextureView>>::fromJSI(
+            runtime, prop, false);
       }
       if (value.hasProperty(runtime, "depthSlice")) {
-        auto depthSlice = value.getProperty(runtime, "depthSlice");
-
-        if (depthSlice.isNumber()) {
-          result->_instance.depthSlice =
-              static_cast<wgpu::IntegerCoordinate>(depthSlice.getNumber());
-        }
+        auto prop = value.getProperty(runtime, "depthSlice");
+        result->depthSlice =
+            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
       }
       if (value.hasProperty(runtime, "resolveTarget")) {
-        auto resolveTarget = value.getProperty(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 clearValue = value.getProperty(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 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");
+        auto prop = value.getProperty(runtime, "loadOp");
+        result->loadOp =
+            JSIConverter<wgpu::LoadOp>::fromJSI(runtime, prop, false);
       }
       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");
+        auto prop = value.getProperty(runtime, "storeOp");
+        result->storeOp =
+            JSIConverter<wgpu::StoreOp>::fromJSI(runtime, prop, false);
       }
     }
-    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();
+    throw std::runtime_error("Invalid GPURenderPassColorAttachment::toJSI()");
   }
 };
-} // namespace margelo
+
+} // namespace margelo

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

@@ -1,28 +1,38 @@
 #pragma once
 
 #include <memory>
-#include <string>
 
 #include "webgpu/webgpu_cpp.h"
 
-#include "Logger.h"
 #include "RNFJSIConverter.h"
-#include <RNFHybridObject.h>
+#include "WGPULogger.h"
+
+#include "GPUTextureView.h"
+#include "RNFHybridObject.h"
 
 namespace jsi = facebook::jsi;
+namespace m = margelo;
 
 namespace rnwgpu {
 
-class GPURenderPassDepthStencilAttachment {
-public:
-  wgpu::RenderPassDepthStencilAttachment *getInstance() { return &_instance; }
-
-  wgpu::RenderPassDepthStencilAttachment _instance;
+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 margelo {
 
+using namespace rnwgpu; // NOLINT(build/namespaces)
+
 template <>
 struct JSIConverter<
     std::shared_ptr<rnwgpu::GPURenderPassDepthStencilAttachment>> {
@@ -33,86 +43,64 @@ struct JSIConverter<
     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");
+        auto prop = value.getProperty(runtime, "view");
+        result->view = JSIConverter<std::shared_ptr<GPUTextureView>>::fromJSI(
+            runtime, prop, false);
       }
       if (value.hasProperty(runtime, "depthClearValue")) {
-        auto depthClearValue = value.getProperty(runtime, "depthClearValue");
-
-        if (depthClearValue.isNumber()) {
-          result->_instance.depthClearValue = depthClearValue.getNumber();
-        }
+        auto prop = value.getProperty(runtime, "depthClearValue");
+        result->depthClearValue =
+            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
       }
       if (value.hasProperty(runtime, "depthLoadOp")) {
-        auto depthLoadOp = value.getProperty(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 depthStoreOp = value.getProperty(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 depthReadOnly = value.getProperty(runtime, "depthReadOnly");
+        auto prop = value.getProperty(runtime, "depthReadOnly");
+        result->depthReadOnly =
+            JSIConverter<std::optional<bool>>::fromJSI(runtime, prop, false);
       }
       if (value.hasProperty(runtime, "stencilClearValue")) {
-        auto stencilClearValue =
-            value.getProperty(runtime, "stencilClearValue");
-
-        if (stencilClearValue.isNumber()) {
-          result->_instance.stencilClearValue =
-              static_cast<wgpu::StencilValue>(stencilClearValue.getNumber());
-        }
+        auto prop = value.getProperty(runtime, "stencilClearValue");
+        result->stencilClearValue =
+            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
       }
       if (value.hasProperty(runtime, "stencilLoadOp")) {
-        auto stencilLoadOp = value.getProperty(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 stencilStoreOp = value.getProperty(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 stencilReadOnly = value.getProperty(runtime, "stencilReadOnly");
+        auto prop = value.getProperty(runtime, "stencilReadOnly");
+        result->stencilReadOnly =
+            JSIConverter<std::optional<bool>>::fromJSI(runtime, prop, false);
       }
     }
-    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();
+    throw std::runtime_error(
+        "Invalid GPURenderPassDepthStencilAttachment::toJSI()");
   }
 };
-} // namespace margelo
+
+} // namespace margelo