react-native-wgpu 0.1.0 → 0.1.3

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

@@ -2,29 +2,39 @@
 
 #include <memory>
 #include <string>
+#include <vector>
 
 #include "webgpu/webgpu_cpp.h"
 
-#include "Logger.h"
 #include "RNFJSIConverter.h"
-#include <RNFHybridObject.h>
+#include "WGPULogger.h"
+
+#include "GPUExtent3D.h"
+#include "RNFHybridObject.h"
 
 namespace jsi = facebook::jsi;
+namespace m = margelo;
 
 namespace rnwgpu {
 
-class GPUTextureDescriptor {
-public:
-  wgpu::TextureDescriptor *getInstance() { return &_instance; }
-
-  wgpu::TextureDescriptor _instance;
-
-  std::string label;
+struct GPUTextureDescriptor {
+  std::shared_ptr<GPUExtent3D> size;               // GPUExtent3DStrict
+  std::optional<double> mipLevelCount;             // GPUIntegerCoordinate
+  std::optional<double> sampleCount;               // GPUSize32
+  std::optional<wgpu::TextureDimension> dimension; // GPUTextureDimension
+  wgpu::TextureFormat format;                      // GPUTextureFormat
+  double usage;                                    // GPUTextureUsageFlags
+  std::optional<std::vector<wgpu::TextureFormat>>
+      viewFormats;                  // Iterable<GPUTextureFormat>
+  std::optional<std::string> label; // string
 };
+
 } // namespace rnwgpu
 
 namespace margelo {
 
+using namespace rnwgpu; // NOLINT(build/namespaces)
+
 template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUTextureDescriptor>> {
   static std::shared_ptr<rnwgpu::GPUTextureDescriptor>
   fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
@@ -32,92 +42,55 @@ template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUTextureDescriptor>> {
     if (!outOfBounds && arg.isObject()) {
       auto value = arg.getObject(runtime);
       if (value.hasProperty(runtime, "size")) {
-        auto size = value.getProperty(runtime, "size");
-
-        if (size.isUndefined()) {
-          throw std::runtime_error(
-              "Property GPUTextureDescriptor::size is required");
-        }
-      } else {
-        throw std::runtime_error(
-            "Property GPUTextureDescriptor::size is not defined");
+        auto prop = value.getProperty(runtime, "size");
+        result->size = JSIConverter<std::shared_ptr<GPUExtent3D>>::fromJSI(
+            runtime, prop, false);
       }
       if (value.hasProperty(runtime, "mipLevelCount")) {
-        auto mipLevelCount = value.getProperty(runtime, "mipLevelCount");
-
-        if (mipLevelCount.isNumber()) {
-          result->_instance.mipLevelCount =
-              static_cast<wgpu::IntegerCoordinate>(mipLevelCount.getNumber());
-        }
+        auto prop = value.getProperty(runtime, "mipLevelCount");
+        result->mipLevelCount =
+            JSIConverter<std::optional<double>>::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, "dimension")) {
-        auto dimension = value.getProperty(runtime, "dimension");
+        auto prop = value.getProperty(runtime, "dimension");
+        result->dimension =
+            JSIConverter<std::optional<wgpu::TextureDimension>>::fromJSI(
+                runtime, prop, false);
       }
       if (value.hasProperty(runtime, "format")) {
-        auto format = value.getProperty(runtime, "format");
-
-        if (format.isUndefined()) {
-          throw std::runtime_error(
-              "Property GPUTextureDescriptor::format is required");
-        }
-      } else {
-        throw std::runtime_error(
-            "Property GPUTextureDescriptor::format is not defined");
+        auto prop = value.getProperty(runtime, "format");
+        result->format =
+            JSIConverter<wgpu::TextureFormat>::fromJSI(runtime, prop, false);
       }
       if (value.hasProperty(runtime, "usage")) {
-        auto usage = value.getProperty(runtime, "usage");
-
-        if (usage.isUndefined()) {
-          throw std::runtime_error(
-              "Property GPUTextureDescriptor::usage is required");
-        }
-      } else {
-        throw std::runtime_error(
-            "Property GPUTextureDescriptor::usage is not defined");
+        auto prop = value.getProperty(runtime, "usage");
+        result->usage = JSIConverter<double>::fromJSI(runtime, prop, false);
       }
       if (value.hasProperty(runtime, "viewFormats")) {
-        auto viewFormats = value.getProperty(runtime, "viewFormats");
+        auto prop = value.getProperty(runtime, "viewFormats");
+        result->viewFormats = JSIConverter<
+            std::optional<std::vector<wgpu::TextureFormat>>>::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("GPUTextureDescriptor::size = %f",
-                                 result->_instance.size);
-    rnwgpu::Logger::logToConsole("GPUTextureDescriptor::mipLevelCount = %f",
-                                 result->_instance.mipLevelCount);
-    rnwgpu::Logger::logToConsole("GPUTextureDescriptor::sampleCount = %f",
-                                 result->_instance.sampleCount);
-    rnwgpu::Logger::logToConsole("GPUTextureDescriptor::dimension = %f",
-                                 result->_instance.dimension);
-    rnwgpu::Logger::logToConsole("GPUTextureDescriptor::format = %f",
-                                 result->_instance.format);
-    rnwgpu::Logger::logToConsole("GPUTextureDescriptor::usage = %f",
-                                 result->_instance.usage);
-    rnwgpu::Logger::logToConsole("GPUTextureDescriptor::viewFormats = %f",
-                                 result->_instance.viewFormats);
-    rnwgpu::Logger::logToConsole("GPUTextureDescriptor::label = %f",
-                                 result->_instance.label);
+
     return result;
   }
   static jsi::Value toJSI(jsi::Runtime &runtime,
                           std::shared_ptr<rnwgpu::GPUTextureDescriptor> arg) {
-    // No conversions here
-    return jsi::Value::null();
+    throw std::runtime_error("Invalid GPUTextureDescriptor::toJSI()");
   }
 };
-} // namespace margelo
+
+} // namespace margelo

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

@@ -5,26 +5,34 @@
 
 #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 GPUTextureViewDescriptor {
-public:
-  wgpu::TextureViewDescriptor *getInstance() { return &_instance; }
-
-  wgpu::TextureViewDescriptor _instance;
-
-  std::string label;
+struct GPUTextureViewDescriptor {
+  std::optional<wgpu::TextureFormat> format; // GPUTextureFormat
+  std::optional<wgpu::TextureViewDimension>
+      dimension;                             // GPUTextureViewDimension
+  std::optional<wgpu::TextureAspect> aspect; // GPUTextureAspect
+  std::optional<double> baseMipLevel;        // GPUIntegerCoordinate
+  std::optional<double> mipLevelCount;       // GPUIntegerCoordinate
+  std::optional<double> baseArrayLayer;      // GPUIntegerCoordinate
+  std::optional<double> arrayLayerCount;     // GPUIntegerCoordinate
+  std::optional<std::string> label;          // string
 };
+
 } // namespace rnwgpu
 
 namespace margelo {
 
+using namespace rnwgpu; // NOLINT(build/namespaces)
+
 template <>
 struct JSIConverter<std::shared_ptr<rnwgpu::GPUTextureViewDescriptor>> {
   static std::shared_ptr<rnwgpu::GPUTextureViewDescriptor>
@@ -33,81 +41,57 @@ struct JSIConverter<std::shared_ptr<rnwgpu::GPUTextureViewDescriptor>> {
     if (!outOfBounds && arg.isObject()) {
       auto value = arg.getObject(runtime);
       if (value.hasProperty(runtime, "format")) {
-        auto format = value.getProperty(runtime, "format");
+        auto prop = value.getProperty(runtime, "format");
+        result->format =
+            JSIConverter<std::optional<wgpu::TextureFormat>>::fromJSI(
+                runtime, prop, false);
       }
       if (value.hasProperty(runtime, "dimension")) {
-        auto dimension = value.getProperty(runtime, "dimension");
+        auto prop = value.getProperty(runtime, "dimension");
+        result->dimension =
+            JSIConverter<std::optional<wgpu::TextureViewDimension>>::fromJSI(
+                runtime, prop, false);
       }
       if (value.hasProperty(runtime, "aspect")) {
-        auto aspect = value.getProperty(runtime, "aspect");
+        auto prop = value.getProperty(runtime, "aspect");
+        result->aspect =
+            JSIConverter<std::optional<wgpu::TextureAspect>>::fromJSI(
+                runtime, prop, false);
       }
       if (value.hasProperty(runtime, "baseMipLevel")) {
-        auto baseMipLevel = value.getProperty(runtime, "baseMipLevel");
-
-        if (baseMipLevel.isNumber()) {
-          result->_instance.baseMipLevel =
-              static_cast<wgpu::IntegerCoordinate>(baseMipLevel.getNumber());
-        }
+        auto prop = value.getProperty(runtime, "baseMipLevel");
+        result->baseMipLevel =
+            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
       }
       if (value.hasProperty(runtime, "mipLevelCount")) {
-        auto mipLevelCount = value.getProperty(runtime, "mipLevelCount");
-
-        if (mipLevelCount.isNumber()) {
-          result->_instance.mipLevelCount =
-              static_cast<wgpu::IntegerCoordinate>(mipLevelCount.getNumber());
-        }
+        auto prop = value.getProperty(runtime, "mipLevelCount");
+        result->mipLevelCount =
+            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
       }
       if (value.hasProperty(runtime, "baseArrayLayer")) {
-        auto baseArrayLayer = value.getProperty(runtime, "baseArrayLayer");
-
-        if (baseArrayLayer.isNumber()) {
-          result->_instance.baseArrayLayer =
-              static_cast<wgpu::IntegerCoordinate>(baseArrayLayer.getNumber());
-        }
+        auto prop = value.getProperty(runtime, "baseArrayLayer");
+        result->baseArrayLayer =
+            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
       }
       if (value.hasProperty(runtime, "arrayLayerCount")) {
-        auto arrayLayerCount = value.getProperty(runtime, "arrayLayerCount");
-
-        if (arrayLayerCount.isNumber()) {
-          result->_instance.arrayLayerCount =
-              static_cast<wgpu::IntegerCoordinate>(arrayLayerCount.getNumber());
-        }
+        auto prop = value.getProperty(runtime, "arrayLayerCount");
+        result->arrayLayerCount =
+            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("GPUTextureViewDescriptor::format = %f",
-                                 result->_instance.format);
-    rnwgpu::Logger::logToConsole("GPUTextureViewDescriptor::dimension = %f",
-                                 result->_instance.dimension);
-    rnwgpu::Logger::logToConsole("GPUTextureViewDescriptor::aspect = %f",
-                                 result->_instance.aspect);
-    rnwgpu::Logger::logToConsole("GPUTextureViewDescriptor::baseMipLevel = %f",
-                                 result->_instance.baseMipLevel);
-    rnwgpu::Logger::logToConsole("GPUTextureViewDescriptor::mipLevelCount = %f",
-                                 result->_instance.mipLevelCount);
-    rnwgpu::Logger::logToConsole(
-        "GPUTextureViewDescriptor::baseArrayLayer = %f",
-        result->_instance.baseArrayLayer);
-    rnwgpu::Logger::logToConsole(
-        "GPUTextureViewDescriptor::arrayLayerCount = %f",
-        result->_instance.arrayLayerCount);
-    rnwgpu::Logger::logToConsole("GPUTextureViewDescriptor::label = %f",
-                                 result->_instance.label);
+
     return result;
   }
   static jsi::Value
   toJSI(jsi::Runtime &runtime,
         std::shared_ptr<rnwgpu::GPUTextureViewDescriptor> arg) {
-    // No conversions here
-    return jsi::Value::null();
+    throw std::runtime_error("Invalid GPUTextureViewDescriptor::toJSI()");
   }
 };
-} // namespace margelo
+
+} // namespace margelo

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

@@ -1,28 +1,33 @@
 #pragma once
 
 #include <memory>
-#include <string>
 
 #include "webgpu/webgpu_cpp.h"
 
-#include "Logger.h"
 #include "RNFJSIConverter.h"
-#include <RNFHybridObject.h>
+#include "WGPULogger.h"
+
+#include "GPUError.h"
+#include "RNFHybridObject.h"
 
 namespace jsi = facebook::jsi;
+namespace m = margelo;
 
 namespace rnwgpu {
 
-class GPUUncapturedErrorEventInit {
-public:
-  wgpu::UncapturedErrorEventInit *getInstance() { return &_instance; }
-
-  wgpu::UncapturedErrorEventInit _instance;
+struct GPUUncapturedErrorEventInit {
+  std::shared_ptr<GPUError> error; // GPUError
+  std::optional<bool> bubbles;     // boolean
+  std::optional<bool> cancelable;  // boolean
+  std::optional<bool> composed;    // boolean
 };
+
 } // namespace rnwgpu
 
 namespace margelo {
 
+using namespace rnwgpu; // NOLINT(build/namespaces)
+
 template <>
 struct JSIConverter<std::shared_ptr<rnwgpu::GPUUncapturedErrorEventInit>> {
   static std::shared_ptr<rnwgpu::GPUUncapturedErrorEventInit>
@@ -31,41 +36,34 @@ struct JSIConverter<std::shared_ptr<rnwgpu::GPUUncapturedErrorEventInit>> {
     if (!outOfBounds && arg.isObject()) {
       auto value = arg.getObject(runtime);
       if (value.hasProperty(runtime, "error")) {
-        auto error = value.getProperty(runtime, "error");
-
-        if (error.isUndefined()) {
-          throw std::runtime_error(
-              "Property GPUUncapturedErrorEventInit::error is required");
-        }
-      } else {
-        throw std::runtime_error(
-            "Property GPUUncapturedErrorEventInit::error is not defined");
+        auto prop = value.getProperty(runtime, "error");
+        result->error = JSIConverter<std::shared_ptr<GPUError>>::fromJSI(
+            runtime, prop, false);
       }
       if (value.hasProperty(runtime, "bubbles")) {
-        auto bubbles = value.getProperty(runtime, "bubbles");
+        auto prop = value.getProperty(runtime, "bubbles");
+        result->bubbles =
+            JSIConverter<std::optional<bool>>::fromJSI(runtime, prop, false);
       }
       if (value.hasProperty(runtime, "cancelable")) {
-        auto cancelable = value.getProperty(runtime, "cancelable");
+        auto prop = value.getProperty(runtime, "cancelable");
+        result->cancelable =
+            JSIConverter<std::optional<bool>>::fromJSI(runtime, prop, false);
       }
       if (value.hasProperty(runtime, "composed")) {
-        auto composed = value.getProperty(runtime, "composed");
+        auto prop = value.getProperty(runtime, "composed");
+        result->composed =
+            JSIConverter<std::optional<bool>>::fromJSI(runtime, prop, false);
       }
     }
-    rnwgpu::Logger::logToConsole("GPUUncapturedErrorEventInit::error = %f",
-                                 result->_instance.error);
-    rnwgpu::Logger::logToConsole("GPUUncapturedErrorEventInit::bubbles = %f",
-                                 result->_instance.bubbles);
-    rnwgpu::Logger::logToConsole("GPUUncapturedErrorEventInit::cancelable = %f",
-                                 result->_instance.cancelable);
-    rnwgpu::Logger::logToConsole("GPUUncapturedErrorEventInit::composed = %f",
-                                 result->_instance.composed);
+
     return result;
   }
   static jsi::Value
   toJSI(jsi::Runtime &runtime,
         std::shared_ptr<rnwgpu::GPUUncapturedErrorEventInit> arg) {
-    // No conversions here
-    return jsi::Value::null();
+    throw std::runtime_error("Invalid GPUUncapturedErrorEventInit::toJSI()");
   }
 };
-} // namespace margelo
+
+} // namespace margelo

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

@@ -1,28 +1,31 @@
 #pragma once
 
 #include <memory>
-#include <string>
 
 #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 GPUVertexAttribute {
-public:
-  wgpu::VertexAttribute *getInstance() { return &_instance; }
-
-  wgpu::VertexAttribute _instance;
+struct GPUVertexAttribute {
+  wgpu::VertexFormat format; // GPUVertexFormat
+  double offset;             // GPUSize64
+  double shaderLocation;     // GPUIndex32
 };
+
 } // namespace rnwgpu
 
 namespace margelo {
 
+using namespace rnwgpu; // NOLINT(build/namespaces)
+
 template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUVertexAttribute>> {
   static std::shared_ptr<rnwgpu::GPUVertexAttribute>
   fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
@@ -30,51 +33,27 @@ template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUVertexAttribute>> {
     if (!outOfBounds && arg.isObject()) {
       auto value = arg.getObject(runtime);
       if (value.hasProperty(runtime, "format")) {
-        auto format = value.getProperty(runtime, "format");
-
-        if (format.isUndefined()) {
-          throw std::runtime_error(
-              "Property GPUVertexAttribute::format is required");
-        }
-      } else {
-        throw std::runtime_error(
-            "Property GPUVertexAttribute::format is not defined");
+        auto prop = value.getProperty(runtime, "format");
+        result->format =
+            JSIConverter<wgpu::VertexFormat>::fromJSI(runtime, prop, false);
       }
       if (value.hasProperty(runtime, "offset")) {
-        auto offset = value.getProperty(runtime, "offset");
-
-        if (offset.isUndefined()) {
-          throw std::runtime_error(
-              "Property GPUVertexAttribute::offset is required");
-        }
-      } else {
-        throw std::runtime_error(
-            "Property GPUVertexAttribute::offset is not defined");
+        auto prop = value.getProperty(runtime, "offset");
+        result->offset = JSIConverter<double>::fromJSI(runtime, prop, false);
       }
       if (value.hasProperty(runtime, "shaderLocation")) {
-        auto shaderLocation = value.getProperty(runtime, "shaderLocation");
-
-        if (shaderLocation.isUndefined()) {
-          throw std::runtime_error(
-              "Property GPUVertexAttribute::shaderLocation is required");
-        }
-      } else {
-        throw std::runtime_error(
-            "Property GPUVertexAttribute::shaderLocation is not defined");
+        auto prop = value.getProperty(runtime, "shaderLocation");
+        result->shaderLocation =
+            JSIConverter<double>::fromJSI(runtime, prop, false);
       }
     }
-    rnwgpu::Logger::logToConsole("GPUVertexAttribute::format = %f",
-                                 result->_instance.format);
-    rnwgpu::Logger::logToConsole("GPUVertexAttribute::offset = %f",
-                                 result->_instance.offset);
-    rnwgpu::Logger::logToConsole("GPUVertexAttribute::shaderLocation = %f",
-                                 result->_instance.shaderLocation);
+
     return result;
   }
   static jsi::Value toJSI(jsi::Runtime &runtime,
                           std::shared_ptr<rnwgpu::GPUVertexAttribute> arg) {
-    // No conversions here
-    return jsi::Value::null();
+    throw std::runtime_error("Invalid GPUVertexAttribute::toJSI()");
   }
 };
-} // namespace margelo
+
+} // namespace margelo

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

@@ -1,28 +1,34 @@
 #pragma once
 
 #include <memory>
-#include <string>
+#include <vector>
 
 #include "webgpu/webgpu_cpp.h"
 
-#include "Logger.h"
 #include "RNFJSIConverter.h"
-#include <RNFHybridObject.h>
+#include "WGPULogger.h"
+
+#include "GPUVertexAttribute.h"
+#include "RNFHybridObject.h"
 
 namespace jsi = facebook::jsi;
+namespace m = margelo;
 
 namespace rnwgpu {
 
-class GPUVertexBufferLayout {
-public:
-  wgpu::VertexBufferLayout *getInstance() { return &_instance; }
-
-  wgpu::VertexBufferLayout _instance;
+struct GPUVertexBufferLayout {
+  double arrayStride;                           // GPUSize64
+  std::optional<wgpu::VertexStepMode> stepMode; // GPUVertexStepMode
+  std::vector<std::shared_ptr<GPUVertexAttribute>>
+      attributes; // Iterable<GPUVertexAttribute>
 };
+
 } // namespace rnwgpu
 
 namespace margelo {
 
+using namespace rnwgpu; // NOLINT(build/namespaces)
+
 template <>
 struct JSIConverter<std::shared_ptr<rnwgpu::GPUVertexBufferLayout>> {
   static std::shared_ptr<rnwgpu::GPUVertexBufferLayout>
@@ -31,43 +37,31 @@ struct JSIConverter<std::shared_ptr<rnwgpu::GPUVertexBufferLayout>> {
     if (!outOfBounds && arg.isObject()) {
       auto value = arg.getObject(runtime);
       if (value.hasProperty(runtime, "arrayStride")) {
-        auto arrayStride = value.getProperty(runtime, "arrayStride");
-
-        if (arrayStride.isUndefined()) {
-          throw std::runtime_error(
-              "Property GPUVertexBufferLayout::arrayStride is required");
-        }
-      } else {
-        throw std::runtime_error(
-            "Property GPUVertexBufferLayout::arrayStride is not defined");
+        auto prop = value.getProperty(runtime, "arrayStride");
+        result->arrayStride =
+            JSIConverter<double>::fromJSI(runtime, prop, false);
       }
       if (value.hasProperty(runtime, "stepMode")) {
-        auto stepMode = value.getProperty(runtime, "stepMode");
+        auto prop = value.getProperty(runtime, "stepMode");
+        result->stepMode =
+            JSIConverter<std::optional<wgpu::VertexStepMode>>::fromJSI(
+                runtime, prop, false);
       }
       if (value.hasProperty(runtime, "attributes")) {
-        auto attributes = value.getProperty(runtime, "attributes");
-
-        if (attributes.isUndefined()) {
-          throw std::runtime_error(
-              "Property GPUVertexBufferLayout::attributes is required");
-        }
-      } else {
-        throw std::runtime_error(
-            "Property GPUVertexBufferLayout::attributes is not defined");
+        auto prop = value.getProperty(runtime, "attributes");
+        result->attributes = JSIConverter<
+            std::vector<std::shared_ptr<GPUVertexAttribute>>>::fromJSI(runtime,
+                                                                       prop,
+                                                                       false);
       }
     }
-    rnwgpu::Logger::logToConsole("GPUVertexBufferLayout::arrayStride = %f",
-                                 result->_instance.arrayStride);
-    rnwgpu::Logger::logToConsole("GPUVertexBufferLayout::stepMode = %f",
-                                 result->_instance.stepMode);
-    rnwgpu::Logger::logToConsole("GPUVertexBufferLayout::attributes = %f",
-                                 result->_instance.attributes);
+
     return result;
   }
   static jsi::Value toJSI(jsi::Runtime &runtime,
                           std::shared_ptr<rnwgpu::GPUVertexBufferLayout> arg) {
-    // No conversions here
-    return jsi::Value::null();
+    throw std::runtime_error("Invalid GPUVertexBufferLayout::toJSI()");
   }
 };
-} // namespace margelo
+
+} // namespace margelo