react-native-wgpu 0.1.0

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

@@ -0,0 +1,83 @@
+#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 GPUImageCopyBuffer {
+public:
+  wgpu::ImageCopyBuffer *getInstance() { return &_instance; }
+
+  wgpu::ImageCopyBuffer _instance;
+};
+} // namespace rnwgpu
+
+namespace margelo {
+
+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 buffer = value.getProperty(runtime, "buffer");
+
+        if (buffer.isUndefined()) {
+          throw std::runtime_error(
+              "Property GPUImageCopyBuffer::buffer is required");
+        }
+      } else {
+        throw std::runtime_error(
+            "Property GPUImageCopyBuffer::buffer is not defined");
+      }
+      if (value.hasProperty(runtime, "offset")) {
+        auto offset = value.getProperty(runtime, "offset");
+
+        if (offset.isNumber()) {
+          result->_instance.offset = offset.getNumber();
+        }
+      }
+      if (value.hasProperty(runtime, "bytesPerRow")) {
+        auto bytesPerRow = value.getProperty(runtime, "bytesPerRow");
+
+        if (bytesPerRow.isNumber()) {
+          result->_instance.bytesPerRow =
+              static_cast<wgpu::Size32>(bytesPerRow.getNumber());
+        }
+      }
+      if (value.hasProperty(runtime, "rowsPerImage")) {
+        auto rowsPerImage = value.getProperty(runtime, "rowsPerImage");
+
+        if (rowsPerImage.isNumber()) {
+          result->_instance.rowsPerImage =
+              static_cast<wgpu::Size32>(rowsPerImage.getNumber());
+        }
+      }
+    }
+    rnwgpu::Logger::logToConsole("GPUImageCopyBuffer::buffer = %f",
+                                 result->_instance.buffer);
+    rnwgpu::Logger::logToConsole("GPUImageCopyBuffer::offset = %f",
+                                 result->_instance.offset);
+    rnwgpu::Logger::logToConsole("GPUImageCopyBuffer::bytesPerRow = %f",
+                                 result->_instance.bytesPerRow);
+    rnwgpu::Logger::logToConsole("GPUImageCopyBuffer::rowsPerImage = %f",
+                                 result->_instance.rowsPerImage);
+    return result;
+  }
+  static jsi::Value toJSI(jsi::Runtime &runtime,
+                          std::shared_ptr<rnwgpu::GPUImageCopyBuffer> arg) {
+    // No conversions here
+    return jsi::Value::null();
+  }
+};
+} // namespace margelo

package/cpp/rnwgpu/api/descriptors/GPUImageCopyExternalImage.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 GPUImageCopyExternalImage {
+public:
+  wgpu::ImageCopyExternalImage *getInstance() { return &_instance; }
+
+  wgpu::ImageCopyExternalImage _instance;
+};
+} // namespace rnwgpu
+
+namespace margelo {
+
+template <>
+struct JSIConverter<std::shared_ptr<rnwgpu::GPUImageCopyExternalImage>> {
+  static std::shared_ptr<rnwgpu::GPUImageCopyExternalImage>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUImageCopyExternalImage>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "source")) {
+        auto source = value.getProperty(runtime, "source");
+
+        if (source.isUndefined()) {
+          throw std::runtime_error(
+              "Property GPUImageCopyExternalImage::source is required");
+        }
+      } else {
+        throw std::runtime_error(
+            "Property GPUImageCopyExternalImage::source is not defined");
+      }
+      if (value.hasProperty(runtime, "origin")) {
+        auto origin = value.getProperty(runtime, "origin");
+      }
+      if (value.hasProperty(runtime, "flipY")) {
+        auto flipY = value.getProperty(runtime, "flipY");
+      }
+    }
+    rnwgpu::Logger::logToConsole("GPUImageCopyExternalImage::source = %f",
+                                 result->_instance.source);
+    rnwgpu::Logger::logToConsole("GPUImageCopyExternalImage::origin = %f",
+                                 result->_instance.origin);
+    rnwgpu::Logger::logToConsole("GPUImageCopyExternalImage::flipY = %f",
+                                 result->_instance.flipY);
+    return result;
+  }
+  static jsi::Value
+  toJSI(jsi::Runtime &runtime,
+        std::shared_ptr<rnwgpu::GPUImageCopyExternalImage> arg) {
+    // No conversions here
+    return jsi::Value::null();
+  }
+};
+} // namespace margelo

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

@@ -0,0 +1,74 @@
+#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 GPUImageCopyTexture {
+public:
+  wgpu::ImageCopyTexture *getInstance() { return &_instance; }
+
+  wgpu::ImageCopyTexture _instance;
+};
+} // namespace rnwgpu
+
+namespace margelo {
+
+template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUImageCopyTexture>> {
+  static std::shared_ptr<rnwgpu::GPUImageCopyTexture>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUImageCopyTexture>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "texture")) {
+        auto texture = value.getProperty(runtime, "texture");
+
+        if (texture.isUndefined()) {
+          throw std::runtime_error(
+              "Property GPUImageCopyTexture::texture is required");
+        }
+      } else {
+        throw std::runtime_error(
+            "Property GPUImageCopyTexture::texture is not defined");
+      }
+      if (value.hasProperty(runtime, "mipLevel")) {
+        auto mipLevel = value.getProperty(runtime, "mipLevel");
+
+        if (mipLevel.isNumber()) {
+          result->_instance.mipLevel =
+              static_cast<wgpu::IntegerCoordinate>(mipLevel.getNumber());
+        }
+      }
+      if (value.hasProperty(runtime, "origin")) {
+        auto origin = value.getProperty(runtime, "origin");
+      }
+      if (value.hasProperty(runtime, "aspect")) {
+        auto aspect = value.getProperty(runtime, "aspect");
+      }
+    }
+    rnwgpu::Logger::logToConsole("GPUImageCopyTexture::texture = %f",
+                                 result->_instance.texture);
+    rnwgpu::Logger::logToConsole("GPUImageCopyTexture::mipLevel = %f",
+                                 result->_instance.mipLevel);
+    rnwgpu::Logger::logToConsole("GPUImageCopyTexture::origin = %f",
+                                 result->_instance.origin);
+    rnwgpu::Logger::logToConsole("GPUImageCopyTexture::aspect = %f",
+                                 result->_instance.aspect);
+    return result;
+  }
+  static jsi::Value toJSI(jsi::Runtime &runtime,
+                          std::shared_ptr<rnwgpu::GPUImageCopyTexture> arg) {
+    // No conversions here
+    return jsi::Value::null();
+  }
+};
+} // namespace margelo

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

@@ -0,0 +1,88 @@
+#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 GPUImageCopyTextureTagged {
+public:
+  wgpu::ImageCopyTextureTagged *getInstance() { return &_instance; }
+
+  wgpu::ImageCopyTextureTagged _instance;
+};
+} // namespace rnwgpu
+
+namespace margelo {
+
+template <>
+struct JSIConverter<std::shared_ptr<rnwgpu::GPUImageCopyTextureTagged>> {
+  static std::shared_ptr<rnwgpu::GPUImageCopyTextureTagged>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUImageCopyTextureTagged>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "colorSpace")) {
+        auto colorSpace = value.getProperty(runtime, "colorSpace");
+      }
+      if (value.hasProperty(runtime, "premultipliedAlpha")) {
+        auto premultipliedAlpha =
+            value.getProperty(runtime, "premultipliedAlpha");
+      }
+      if (value.hasProperty(runtime, "texture")) {
+        auto texture = value.getProperty(runtime, "texture");
+
+        if (texture.isUndefined()) {
+          throw std::runtime_error(
+              "Property GPUImageCopyTextureTagged::texture is required");
+        }
+      } else {
+        throw std::runtime_error(
+            "Property GPUImageCopyTextureTagged::texture is not defined");
+      }
+      if (value.hasProperty(runtime, "mipLevel")) {
+        auto mipLevel = value.getProperty(runtime, "mipLevel");
+
+        if (mipLevel.isNumber()) {
+          result->_instance.mipLevel =
+              static_cast<wgpu::IntegerCoordinate>(mipLevel.getNumber());
+        }
+      }
+      if (value.hasProperty(runtime, "origin")) {
+        auto origin = value.getProperty(runtime, "origin");
+      }
+      if (value.hasProperty(runtime, "aspect")) {
+        auto aspect = value.getProperty(runtime, "aspect");
+      }
+    }
+    rnwgpu::Logger::logToConsole("GPUImageCopyTextureTagged::colorSpace = %f",
+                                 result->_instance.colorSpace);
+    rnwgpu::Logger::logToConsole(
+        "GPUImageCopyTextureTagged::premultipliedAlpha = %f",
+        result->_instance.premultipliedAlpha);
+    rnwgpu::Logger::logToConsole("GPUImageCopyTextureTagged::texture = %f",
+                                 result->_instance.texture);
+    rnwgpu::Logger::logToConsole("GPUImageCopyTextureTagged::mipLevel = %f",
+                                 result->_instance.mipLevel);
+    rnwgpu::Logger::logToConsole("GPUImageCopyTextureTagged::origin = %f",
+                                 result->_instance.origin);
+    rnwgpu::Logger::logToConsole("GPUImageCopyTextureTagged::aspect = %f",
+                                 result->_instance.aspect);
+    return result;
+  }
+  static jsi::Value
+  toJSI(jsi::Runtime &runtime,
+        std::shared_ptr<rnwgpu::GPUImageCopyTextureTagged> arg) {
+    // No conversions here
+    return jsi::Value::null();
+  }
+};
+} // namespace margelo

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

@@ -0,0 +1,70 @@
+#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 GPUImageDataLayout {
+public:
+  wgpu::ImageDataLayout *getInstance() { return &_instance; }
+
+  wgpu::ImageDataLayout _instance;
+};
+} // namespace rnwgpu
+
+namespace margelo {
+
+template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUImageDataLayout>> {
+  static std::shared_ptr<rnwgpu::GPUImageDataLayout>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUImageDataLayout>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "offset")) {
+        auto offset = value.getProperty(runtime, "offset");
+
+        if (offset.isNumber()) {
+          result->_instance.offset = offset.getNumber();
+        }
+      }
+      if (value.hasProperty(runtime, "bytesPerRow")) {
+        auto bytesPerRow = value.getProperty(runtime, "bytesPerRow");
+
+        if (bytesPerRow.isNumber()) {
+          result->_instance.bytesPerRow =
+              static_cast<wgpu::Size32>(bytesPerRow.getNumber());
+        }
+      }
+      if (value.hasProperty(runtime, "rowsPerImage")) {
+        auto rowsPerImage = value.getProperty(runtime, "rowsPerImage");
+
+        if (rowsPerImage.isNumber()) {
+          result->_instance.rowsPerImage =
+              static_cast<wgpu::Size32>(rowsPerImage.getNumber());
+        }
+      }
+    }
+    rnwgpu::Logger::logToConsole("GPUImageDataLayout::offset = %f",
+                                 result->_instance.offset);
+    rnwgpu::Logger::logToConsole("GPUImageDataLayout::bytesPerRow = %f",
+                                 result->_instance.bytesPerRow);
+    rnwgpu::Logger::logToConsole("GPUImageDataLayout::rowsPerImage = %f",
+                                 result->_instance.rowsPerImage);
+    return result;
+  }
+  static jsi::Value toJSI(jsi::Runtime &runtime,
+                          std::shared_ptr<rnwgpu::GPUImageDataLayout> arg) {
+    // No conversions here
+    return jsi::Value::null();
+  }
+};
+} // namespace margelo

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

@@ -0,0 +1,25 @@
+#pragma once
+#include <string>
+
+#include <RNFHybridObject.h>
+
+#include "webgpu/webgpu_cpp.h"
+
+namespace rnwgpu {
+
+namespace m = margelo;
+
+class GPUMapMode : public m::HybridObject {
+public:
+  GPUMapMode() : HybridObject("GPUMapMode") {}
+
+public:
+  double Read() { return static_cast<double>(wgpu::MapMode::Read); }
+  double Write() { return static_cast<double>(wgpu::MapMode::Write); }
+
+  void loadHybridMethods() override {
+    registerHybridGetter("READ", &GPUMapMode::Read, this);
+    registerHybridGetter("WRITE", &GPUMapMode::Write, this);
+  }
+};
+} // namespace rnwgpu

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

@@ -0,0 +1,68 @@
+#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 GPUMultisampleState {
+public:
+  wgpu::MultisampleState *getInstance() { return &_instance; }
+
+  wgpu::MultisampleState _instance;
+};
+} // namespace rnwgpu
+
+namespace margelo {
+
+template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUMultisampleState>> {
+  static std::shared_ptr<rnwgpu::GPUMultisampleState>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUMultisampleState>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "count")) {
+        auto count = value.getProperty(runtime, "count");
+
+        if (count.isNumber()) {
+          result->_instance.count =
+              static_cast<wgpu::Size32>(count.getNumber());
+        }
+      }
+      if (value.hasProperty(runtime, "mask")) {
+        auto mask = value.getProperty(runtime, "mask");
+
+        if (mask.isNumber()) {
+          result->_instance.mask =
+              static_cast<wgpu::SampleMask>(mask.getNumber());
+        }
+      }
+      if (value.hasProperty(runtime, "alphaToCoverageEnabled")) {
+        auto alphaToCoverageEnabled =
+            value.getProperty(runtime, "alphaToCoverageEnabled");
+      }
+    }
+    rnwgpu::Logger::logToConsole("GPUMultisampleState::count = %f",
+                                 result->_instance.count);
+    rnwgpu::Logger::logToConsole("GPUMultisampleState::mask = %f",
+                                 result->_instance.mask);
+    rnwgpu::Logger::logToConsole(
+        "GPUMultisampleState::alphaToCoverageEnabled = %f",
+        result->_instance.alphaToCoverageEnabled);
+    return result;
+  }
+  static jsi::Value toJSI(jsi::Runtime &runtime,
+                          std::shared_ptr<rnwgpu::GPUMultisampleState> arg) {
+    // No conversions here
+    return jsi::Value::null();
+  }
+};
+} // namespace margelo

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

@@ -0,0 +1,61 @@
+#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 GPUOrigin2DDict {
+public:
+  wgpu::Origin2DDict *getInstance() { return &_instance; }
+
+  wgpu::Origin2DDict _instance;
+};
+} // namespace rnwgpu
+
+namespace margelo {
+
+template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUOrigin2DDict>> {
+  static std::shared_ptr<rnwgpu::GPUOrigin2DDict>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUOrigin2DDict>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "x")) {
+        auto x = value.getProperty(runtime, "x");
+
+        if (x.isNumber()) {
+          result->_instance.x =
+              static_cast<wgpu::IntegerCoordinate>(x.getNumber());
+        }
+      }
+      if (value.hasProperty(runtime, "y")) {
+        auto y = value.getProperty(runtime, "y");
+
+        if (y.isNumber()) {
+          result->_instance.y =
+              static_cast<wgpu::IntegerCoordinate>(y.getNumber());
+        }
+      }
+    }
+    rnwgpu::Logger::logToConsole("GPUOrigin2DDict::x = %f",
+                                 result->_instance.x);
+    rnwgpu::Logger::logToConsole("GPUOrigin2DDict::y = %f",
+                                 result->_instance.y);
+    return result;
+  }
+  static jsi::Value toJSI(jsi::Runtime &runtime,
+                          std::shared_ptr<rnwgpu::GPUOrigin2DDict> arg) {
+    // No conversions here
+    return jsi::Value::null();
+  }
+};
+} // namespace margelo

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

@@ -0,0 +1,75 @@
+#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 GPUOrigin2DDictStrict {
+public:
+  wgpu::Origin2DDictStrict *getInstance() { return &_instance; }
+
+  wgpu::Origin2DDictStrict _instance;
+};
+} // namespace rnwgpu
+
+namespace margelo {
+
+template <>
+struct JSIConverter<std::shared_ptr<rnwgpu::GPUOrigin2DDictStrict>> {
+  static std::shared_ptr<rnwgpu::GPUOrigin2DDictStrict>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUOrigin2DDictStrict>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "z")) {
+        auto z = value.getProperty(runtime, "z");
+
+        if (z.isUndefined()) {
+          throw std::runtime_error(
+              "Property GPUOrigin2DDictStrict::z is required");
+        }
+      } else {
+        throw std::runtime_error(
+            "Property GPUOrigin2DDictStrict::z is not defined");
+      }
+      if (value.hasProperty(runtime, "x")) {
+        auto x = value.getProperty(runtime, "x");
+
+        if (x.isNumber()) {
+          result->_instance.x =
+              static_cast<wgpu::IntegerCoordinate>(x.getNumber());
+        }
+      }
+      if (value.hasProperty(runtime, "y")) {
+        auto y = value.getProperty(runtime, "y");
+
+        if (y.isNumber()) {
+          result->_instance.y =
+              static_cast<wgpu::IntegerCoordinate>(y.getNumber());
+        }
+      }
+    }
+    rnwgpu::Logger::logToConsole("GPUOrigin2DDictStrict::z = %f",
+                                 result->_instance.z);
+    rnwgpu::Logger::logToConsole("GPUOrigin2DDictStrict::x = %f",
+                                 result->_instance.x);
+    rnwgpu::Logger::logToConsole("GPUOrigin2DDictStrict::y = %f",
+                                 result->_instance.y);
+    return result;
+  }
+  static jsi::Value toJSI(jsi::Runtime &runtime,
+                          std::shared_ptr<rnwgpu::GPUOrigin2DDictStrict> arg) {
+    // No conversions here
+    return jsi::Value::null();
+  }
+};
+} // namespace margelo

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

@@ -0,0 +1,71 @@
+#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 GPUOrigin3DDict {
+public:
+  wgpu::Origin3DDict *getInstance() { return &_instance; }
+
+  wgpu::Origin3DDict _instance;
+};
+} // namespace rnwgpu
+
+namespace margelo {
+
+template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUOrigin3DDict>> {
+  static std::shared_ptr<rnwgpu::GPUOrigin3DDict>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUOrigin3DDict>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "x")) {
+        auto x = value.getProperty(runtime, "x");
+
+        if (x.isNumber()) {
+          result->_instance.x =
+              static_cast<wgpu::IntegerCoordinate>(x.getNumber());
+        }
+      }
+      if (value.hasProperty(runtime, "y")) {
+        auto y = value.getProperty(runtime, "y");
+
+        if (y.isNumber()) {
+          result->_instance.y =
+              static_cast<wgpu::IntegerCoordinate>(y.getNumber());
+        }
+      }
+      if (value.hasProperty(runtime, "z")) {
+        auto z = value.getProperty(runtime, "z");
+
+        if (z.isNumber()) {
+          result->_instance.z =
+              static_cast<wgpu::IntegerCoordinate>(z.getNumber());
+        }
+      }
+    }
+    rnwgpu::Logger::logToConsole("GPUOrigin3DDict::x = %f",
+                                 result->_instance.x);
+    rnwgpu::Logger::logToConsole("GPUOrigin3DDict::y = %f",
+                                 result->_instance.y);
+    rnwgpu::Logger::logToConsole("GPUOrigin3DDict::z = %f",
+                                 result->_instance.z);
+    return result;
+  }
+  static jsi::Value toJSI(jsi::Runtime &runtime,
+                          std::shared_ptr<rnwgpu::GPUOrigin3DDict> arg) {
+    // No conversions here
+    return jsi::Value::null();
+  }
+};
+} // namespace margelo