react-native-wgpu 0.1.0

package/cpp/rnwgpu/api/descriptors/GPUBufferBinding.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 GPUBufferBinding {
+public:
+  wgpu::BufferBinding *getInstance() { return &_instance; }
+
+  wgpu::BufferBinding _instance;
+};
+} // namespace rnwgpu
+
+namespace margelo {
+
+template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUBufferBinding>> {
+  static std::shared_ptr<rnwgpu::GPUBufferBinding>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUBufferBinding>();
+    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 GPUBufferBinding::buffer is required");
+        }
+      } else {
+        throw std::runtime_error(
+            "Property GPUBufferBinding::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, "size")) {
+        auto size = value.getProperty(runtime, "size");
+
+        if (size.isNumber()) {
+          result->_instance.size = size.getNumber();
+        }
+      }
+    }
+    rnwgpu::Logger::logToConsole("GPUBufferBinding::buffer = %f",
+                                 result->_instance.buffer);
+    rnwgpu::Logger::logToConsole("GPUBufferBinding::offset = %f",
+                                 result->_instance.offset);
+    rnwgpu::Logger::logToConsole("GPUBufferBinding::size = %f",
+                                 result->_instance.size);
+    return result;
+  }
+  static jsi::Value toJSI(jsi::Runtime &runtime,
+                          std::shared_ptr<rnwgpu::GPUBufferBinding> arg) {
+    // No conversions here
+    return jsi::Value::null();
+  }
+};
+} // namespace margelo

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

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

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

@@ -0,0 +1,85 @@
+#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 GPUBufferDescriptor {
+public:
+  wgpu::BufferDescriptor *getInstance() { return &_instance; }
+
+  wgpu::BufferDescriptor _instance;
+
+  std::string label;
+};
+} // namespace rnwgpu
+
+namespace margelo {
+
+template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUBufferDescriptor>> {
+  static std::shared_ptr<rnwgpu::GPUBufferDescriptor>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUBufferDescriptor>();
+    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 GPUBufferDescriptor::size is required");
+        }
+      } else {
+        throw std::runtime_error(
+            "Property GPUBufferDescriptor::size is not defined");
+      }
+      if (value.hasProperty(runtime, "usage")) {
+        auto usage = value.getProperty(runtime, "usage");
+
+        if (usage.isUndefined()) {
+          throw std::runtime_error(
+              "Property GPUBufferDescriptor::usage is required");
+        }
+      } else {
+        throw std::runtime_error(
+            "Property GPUBufferDescriptor::usage is not defined");
+      }
+      if (value.hasProperty(runtime, "mappedAtCreation")) {
+        auto mappedAtCreation = value.getProperty(runtime, "mappedAtCreation");
+      }
+      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("GPUBufferDescriptor::size = %f",
+                                 result->_instance.size);
+    rnwgpu::Logger::logToConsole("GPUBufferDescriptor::usage = %f",
+                                 result->_instance.usage);
+    rnwgpu::Logger::logToConsole("GPUBufferDescriptor::mappedAtCreation = %f",
+                                 result->_instance.mappedAtCreation);
+    rnwgpu::Logger::logToConsole("GPUBufferDescriptor::label = %f",
+                                 result->_instance.label);
+    return result;
+  }
+  static jsi::Value toJSI(jsi::Runtime &runtime,
+                          std::shared_ptr<rnwgpu::GPUBufferDescriptor> arg) {
+    // No conversions here
+    return jsi::Value::null();
+  }
+};
+} // namespace margelo

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

@@ -0,0 +1,43 @@
+#pragma once
+#include <string>
+
+#include <RNFHybridObject.h>
+
+#include "webgpu/webgpu_cpp.h"
+
+namespace rnwgpu {
+
+namespace m = margelo;
+
+class GPUBufferUsage : public m::HybridObject {
+public:
+  GPUBufferUsage() : HybridObject("GPUBufferUsage") {}
+
+public:
+  double MapRead() { return static_cast<double>(wgpu::BufferUsage::MapRead); }
+  double MapWrite() { return static_cast<double>(wgpu::BufferUsage::MapWrite); }
+  double CopySrc() { return static_cast<double>(wgpu::BufferUsage::CopySrc); }
+  double CopyDst() { return static_cast<double>(wgpu::BufferUsage::CopyDst); }
+  double Index() { return static_cast<double>(wgpu::BufferUsage::Index); }
+  double Vertex() { return static_cast<double>(wgpu::BufferUsage::Vertex); }
+  double Uniform() { return static_cast<double>(wgpu::BufferUsage::Uniform); }
+  double Storage() { return static_cast<double>(wgpu::BufferUsage::Storage); }
+  double Indirect() { return static_cast<double>(wgpu::BufferUsage::Indirect); }
+  double QueryResolve() {
+    return static_cast<double>(wgpu::BufferUsage::QueryResolve);
+  }
+
+  void loadHybridMethods() override {
+    registerHybridGetter("MAP_READ", &GPUBufferUsage::MapRead, this);
+    registerHybridGetter("MAP_WRITE", &GPUBufferUsage::MapWrite, this);
+    registerHybridGetter("COPY_SRC", &GPUBufferUsage::CopySrc, this);
+    registerHybridGetter("COPY_DST", &GPUBufferUsage::CopyDst, this);
+    registerHybridGetter("INDEX", &GPUBufferUsage::Index, this);
+    registerHybridGetter("VERTEX", &GPUBufferUsage::Vertex, this);
+    registerHybridGetter("UNIFORM", &GPUBufferUsage::Uniform, this);
+    registerHybridGetter("STORAGE", &GPUBufferUsage::Storage, this);
+    registerHybridGetter("INDIRECT", &GPUBufferUsage::Indirect, this);
+    registerHybridGetter("QUERY_RESOLVE", &GPUBufferUsage::QueryResolve, this);
+  }
+};
+} // namespace rnwgpu

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

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

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

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

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

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

@@ -0,0 +1,31 @@
+#pragma once
+#include <string>
+
+#include <RNFHybridObject.h>
+
+#include "webgpu/webgpu_cpp.h"
+
+namespace rnwgpu {
+
+namespace m = margelo;
+
+class GPUColorWrite : public m::HybridObject {
+public:
+  GPUColorWrite() : HybridObject("GPUColorWrite") {}
+
+public:
+  double Red() { return static_cast<double>(wgpu::ColorWriteMask::Red); }
+  double Green() { return static_cast<double>(wgpu::ColorWriteMask::Green); }
+  double Blue() { return static_cast<double>(wgpu::ColorWriteMask::Blue); }
+  double Alpha() { return static_cast<double>(wgpu::ColorWriteMask::Alpha); }
+  double All() { return static_cast<double>(wgpu::ColorWriteMask::All); }
+
+  void loadHybridMethods() override {
+    registerHybridGetter("RED", &GPUColorWrite::Red, this);
+    registerHybridGetter("GREEN", &GPUColorWrite::Green, this);
+    registerHybridGetter("BLUE", &GPUColorWrite::Blue, this);
+    registerHybridGetter("ALPHA", &GPUColorWrite::Alpha, this);
+    registerHybridGetter("ALL", &GPUColorWrite::All, this);
+  }
+};
+} // namespace rnwgpu

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

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

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

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