react-native-wgpu 0.1.0

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

@@ -0,0 +1,100 @@
+#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 GPURenderPassDescriptor {
+public:
+  wgpu::RenderPassDescriptor *getInstance() { return &_instance; }
+
+  wgpu::RenderPassDescriptor _instance;
+
+  std::string label;
+};
+} // namespace rnwgpu
+
+namespace margelo {
+
+template <>
+struct JSIConverter<std::shared_ptr<rnwgpu::GPURenderPassDescriptor>> {
+  static std::shared_ptr<rnwgpu::GPURenderPassDescriptor>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPURenderPassDescriptor>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "colorAttachments")) {
+        auto colorAttachments = value.getProperty(runtime, "colorAttachments");
+
+        if (colorAttachments.isUndefined()) {
+          throw std::runtime_error(
+              "Property GPURenderPassDescriptor::colorAttachments is required");
+        }
+      } else {
+        throw std::runtime_error(
+            "Property GPURenderPassDescriptor::colorAttachments is not "
+            "defined");
+      }
+      if (value.hasProperty(runtime, "depthStencilAttachment")) {
+        auto depthStencilAttachment =
+            value.getProperty(runtime, "depthStencilAttachment");
+      }
+      if (value.hasProperty(runtime, "occlusionQuerySet")) {
+        auto occlusionQuerySet =
+            value.getProperty(runtime, "occlusionQuerySet");
+      }
+      if (value.hasProperty(runtime, "timestampWrites")) {
+        auto timestampWrites = value.getProperty(runtime, "timestampWrites");
+      }
+      if (value.hasProperty(runtime, "maxDrawCount")) {
+        auto maxDrawCount = value.getProperty(runtime, "maxDrawCount");
+
+        if (maxDrawCount.isNumber()) {
+          result->_instance.maxDrawCount = maxDrawCount.getNumber();
+        }
+      }
+      if (value.hasProperty(runtime, "label")) {
+        auto label = value.getProperty(runtime, "label");
+
+        if (label.isString()) {
+          auto str = label.asString(runtime).utf8(runtime);
+          result->label = str;
+          result->_instance.label = result->label.c_str();
+        }
+      }
+    }
+    rnwgpu::Logger::logToConsole(
+        "GPURenderPassDescriptor::colorAttachments = %f",
+        result->_instance.colorAttachments);
+    rnwgpu::Logger::logToConsole(
+        "GPURenderPassDescriptor::depthStencilAttachment = %f",
+        result->_instance.depthStencilAttachment);
+    rnwgpu::Logger::logToConsole(
+        "GPURenderPassDescriptor::occlusionQuerySet = %f",
+        result->_instance.occlusionQuerySet);
+    rnwgpu::Logger::logToConsole(
+        "GPURenderPassDescriptor::timestampWrites = %f",
+        result->_instance.timestampWrites);
+    rnwgpu::Logger::logToConsole("GPURenderPassDescriptor::maxDrawCount = %f",
+                                 result->_instance.maxDrawCount);
+    rnwgpu::Logger::logToConsole("GPURenderPassDescriptor::label = %f",
+                                 result->_instance.label);
+    return result;
+  }
+  static jsi::Value
+  toJSI(jsi::Runtime &runtime,
+        std::shared_ptr<rnwgpu::GPURenderPassDescriptor> arg) {
+    // No conversions here
+    return jsi::Value::null();
+  }
+};
+} // namespace margelo

package/cpp/rnwgpu/api/descriptors/GPURenderPassLayout.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 GPURenderPassLayout {
+public:
+  wgpu::RenderPassLayout *getInstance() { return &_instance; }
+
+  wgpu::RenderPassLayout _instance;
+
+  std::string label;
+};
+} // namespace rnwgpu
+
+namespace margelo {
+
+template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPURenderPassLayout>> {
+  static std::shared_ptr<rnwgpu::GPURenderPassLayout>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPURenderPassLayout>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "colorFormats")) {
+        auto colorFormats = value.getProperty(runtime, "colorFormats");
+
+        if (colorFormats.isUndefined()) {
+          throw std::runtime_error(
+              "Property GPURenderPassLayout::colorFormats is required");
+        }
+      } else {
+        throw std::runtime_error(
+            "Property GPURenderPassLayout::colorFormats is not defined");
+      }
+      if (value.hasProperty(runtime, "depthStencilFormat")) {
+        auto depthStencilFormat =
+            value.getProperty(runtime, "depthStencilFormat");
+      }
+      if (value.hasProperty(runtime, "sampleCount")) {
+        auto sampleCount = value.getProperty(runtime, "sampleCount");
+
+        if (sampleCount.isNumber()) {
+          result->_instance.sampleCount =
+              static_cast<wgpu::Size32>(sampleCount.getNumber());
+        }
+      }
+      if (value.hasProperty(runtime, "label")) {
+        auto label = value.getProperty(runtime, "label");
+
+        if (label.isString()) {
+          auto str = label.asString(runtime).utf8(runtime);
+          result->label = str;
+          result->_instance.label = result->label.c_str();
+        }
+      }
+    }
+    rnwgpu::Logger::logToConsole("GPURenderPassLayout::colorFormats = %f",
+                                 result->_instance.colorFormats);
+    rnwgpu::Logger::logToConsole("GPURenderPassLayout::depthStencilFormat = %f",
+                                 result->_instance.depthStencilFormat);
+    rnwgpu::Logger::logToConsole("GPURenderPassLayout::sampleCount = %f",
+                                 result->_instance.sampleCount);
+    rnwgpu::Logger::logToConsole("GPURenderPassLayout::label = %f",
+                                 result->_instance.label);
+    return result;
+  }
+  static jsi::Value toJSI(jsi::Runtime &runtime,
+                          std::shared_ptr<rnwgpu::GPURenderPassLayout> arg) {
+    // No conversions here
+    return jsi::Value::null();
+  }
+};
+} // namespace margelo

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

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

@@ -0,0 +1,104 @@
+#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 GPURenderPipelineDescriptor {
+public:
+  wgpu::RenderPipelineDescriptor *getInstance() { return &_instance; }
+
+  wgpu::RenderPipelineDescriptor _instance;
+
+  std::string label;
+};
+} // namespace rnwgpu
+
+namespace margelo {
+
+template <>
+struct JSIConverter<std::shared_ptr<rnwgpu::GPURenderPipelineDescriptor>> {
+  static std::shared_ptr<rnwgpu::GPURenderPipelineDescriptor>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPURenderPipelineDescriptor>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "vertex")) {
+        auto vertex = value.getProperty(runtime, "vertex");
+
+        if (vertex.isUndefined()) {
+          throw std::runtime_error(
+              "Property GPURenderPipelineDescriptor::vertex is required");
+        }
+      } else {
+        throw std::runtime_error(
+            "Property GPURenderPipelineDescriptor::vertex is not defined");
+      }
+      if (value.hasProperty(runtime, "primitive")) {
+        auto primitive = value.getProperty(runtime, "primitive");
+      }
+      if (value.hasProperty(runtime, "depthStencil")) {
+        auto depthStencil = value.getProperty(runtime, "depthStencil");
+      }
+      if (value.hasProperty(runtime, "multisample")) {
+        auto multisample = value.getProperty(runtime, "multisample");
+      }
+      if (value.hasProperty(runtime, "fragment")) {
+        auto fragment = value.getProperty(runtime, "fragment");
+      }
+      if (value.hasProperty(runtime, "layout")) {
+        auto layout = value.getProperty(runtime, "layout");
+
+        if (layout.isUndefined()) {
+          throw std::runtime_error(
+              "Property GPURenderPipelineDescriptor::layout is required");
+        }
+      } else {
+        throw std::runtime_error(
+            "Property GPURenderPipelineDescriptor::layout is not defined");
+      }
+      if (value.hasProperty(runtime, "label")) {
+        auto label = value.getProperty(runtime, "label");
+
+        if (label.isString()) {
+          auto str = label.asString(runtime).utf8(runtime);
+          result->label = str;
+          result->_instance.label = result->label.c_str();
+        }
+      }
+    }
+    rnwgpu::Logger::logToConsole("GPURenderPipelineDescriptor::vertex = %f",
+                                 result->_instance.vertex);
+    rnwgpu::Logger::logToConsole("GPURenderPipelineDescriptor::primitive = %f",
+                                 result->_instance.primitive);
+    rnwgpu::Logger::logToConsole(
+        "GPURenderPipelineDescriptor::depthStencil = %f",
+        result->_instance.depthStencil);
+    rnwgpu::Logger::logToConsole(
+        "GPURenderPipelineDescriptor::multisample = %f",
+        result->_instance.multisample);
+    rnwgpu::Logger::logToConsole("GPURenderPipelineDescriptor::fragment = %f",
+                                 result->_instance.fragment);
+    rnwgpu::Logger::logToConsole("GPURenderPipelineDescriptor::layout = %f",
+                                 result->_instance.layout);
+    rnwgpu::Logger::logToConsole("GPURenderPipelineDescriptor::label = %f",
+                                 result->_instance.label);
+    return result;
+  }
+  static jsi::Value
+  toJSI(jsi::Runtime &runtime,
+        std::shared_ptr<rnwgpu::GPURenderPipelineDescriptor> arg) {
+    // No conversions here
+    return jsi::Value::null();
+  }
+};
+} // namespace margelo

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

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

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

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

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

@@ -0,0 +1,116 @@
+#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 GPUSamplerDescriptor {
+public:
+  wgpu::SamplerDescriptor *getInstance() { return &_instance; }
+
+  wgpu::SamplerDescriptor _instance;
+
+  std::string label;
+};
+} // namespace rnwgpu
+
+namespace margelo {
+
+template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUSamplerDescriptor>> {
+  static std::shared_ptr<rnwgpu::GPUSamplerDescriptor>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUSamplerDescriptor>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "addressModeU")) {
+        auto addressModeU = value.getProperty(runtime, "addressModeU");
+      }
+      if (value.hasProperty(runtime, "addressModeV")) {
+        auto addressModeV = value.getProperty(runtime, "addressModeV");
+      }
+      if (value.hasProperty(runtime, "addressModeW")) {
+        auto addressModeW = value.getProperty(runtime, "addressModeW");
+      }
+      if (value.hasProperty(runtime, "magFilter")) {
+        auto magFilter = value.getProperty(runtime, "magFilter");
+      }
+      if (value.hasProperty(runtime, "minFilter")) {
+        auto minFilter = value.getProperty(runtime, "minFilter");
+      }
+      if (value.hasProperty(runtime, "mipmapFilter")) {
+        auto mipmapFilter = value.getProperty(runtime, "mipmapFilter");
+      }
+      if (value.hasProperty(runtime, "lodMinClamp")) {
+        auto lodMinClamp = value.getProperty(runtime, "lodMinClamp");
+
+        if (lodMinClamp.isNumber()) {
+          result->_instance.lodMinClamp = lodMinClamp.getNumber();
+        }
+      }
+      if (value.hasProperty(runtime, "lodMaxClamp")) {
+        auto lodMaxClamp = value.getProperty(runtime, "lodMaxClamp");
+
+        if (lodMaxClamp.isNumber()) {
+          result->_instance.lodMaxClamp = lodMaxClamp.getNumber();
+        }
+      }
+      if (value.hasProperty(runtime, "compare")) {
+        auto compare = value.getProperty(runtime, "compare");
+      }
+      if (value.hasProperty(runtime, "maxAnisotropy")) {
+        auto maxAnisotropy = value.getProperty(runtime, "maxAnisotropy");
+
+        if (maxAnisotropy.isNumber()) {
+          result->_instance.maxAnisotropy = maxAnisotropy.getNumber();
+        }
+      }
+      if (value.hasProperty(runtime, "label")) {
+        auto label = value.getProperty(runtime, "label");
+
+        if (label.isString()) {
+          auto str = label.asString(runtime).utf8(runtime);
+          result->label = str;
+          result->_instance.label = result->label.c_str();
+        }
+      }
+    }
+    rnwgpu::Logger::logToConsole("GPUSamplerDescriptor::addressModeU = %f",
+                                 result->_instance.addressModeU);
+    rnwgpu::Logger::logToConsole("GPUSamplerDescriptor::addressModeV = %f",
+                                 result->_instance.addressModeV);
+    rnwgpu::Logger::logToConsole("GPUSamplerDescriptor::addressModeW = %f",
+                                 result->_instance.addressModeW);
+    rnwgpu::Logger::logToConsole("GPUSamplerDescriptor::magFilter = %f",
+                                 result->_instance.magFilter);
+    rnwgpu::Logger::logToConsole("GPUSamplerDescriptor::minFilter = %f",
+                                 result->_instance.minFilter);
+    rnwgpu::Logger::logToConsole("GPUSamplerDescriptor::mipmapFilter = %f",
+                                 result->_instance.mipmapFilter);
+    rnwgpu::Logger::logToConsole("GPUSamplerDescriptor::lodMinClamp = %f",
+                                 result->_instance.lodMinClamp);
+    rnwgpu::Logger::logToConsole("GPUSamplerDescriptor::lodMaxClamp = %f",
+                                 result->_instance.lodMaxClamp);
+    rnwgpu::Logger::logToConsole("GPUSamplerDescriptor::compare = %f",
+                                 result->_instance.compare);
+    rnwgpu::Logger::logToConsole("GPUSamplerDescriptor::maxAnisotropy = %f",
+                                 result->_instance.maxAnisotropy);
+    rnwgpu::Logger::logToConsole("GPUSamplerDescriptor::label = %f",
+                                 result->_instance.label);
+    return result;
+  }
+  static jsi::Value toJSI(jsi::Runtime &runtime,
+                          std::shared_ptr<rnwgpu::GPUSamplerDescriptor> arg) {
+    // No conversions here
+    return jsi::Value::null();
+  }
+};
+} // namespace margelo

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

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