react-native-wgpu 0.1.0

package/cpp/rnwgpu/api/descriptors/GPUVertexAttribute.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 GPUVertexAttribute {
+public:
+  wgpu::VertexAttribute *getInstance() { return &_instance; }
+
+  wgpu::VertexAttribute _instance;
+};
+} // namespace rnwgpu
+
+namespace margelo {
+
+template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUVertexAttribute>> {
+  static std::shared_ptr<rnwgpu::GPUVertexAttribute>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<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");
+      }
+      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");
+      }
+      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");
+      }
+    }
+    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();
+  }
+};
+} // namespace margelo

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

@@ -0,0 +1,73 @@
+#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 GPUVertexBufferLayout {
+public:
+  wgpu::VertexBufferLayout *getInstance() { return &_instance; }
+
+  wgpu::VertexBufferLayout _instance;
+};
+} // namespace rnwgpu
+
+namespace margelo {
+
+template <>
+struct JSIConverter<std::shared_ptr<rnwgpu::GPUVertexBufferLayout>> {
+  static std::shared_ptr<rnwgpu::GPUVertexBufferLayout>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<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");
+      }
+      if (value.hasProperty(runtime, "stepMode")) {
+        auto stepMode = value.getProperty(runtime, "stepMode");
+      }
+      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");
+      }
+    }
+    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();
+  }
+};
+} // namespace margelo

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

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