react-native-webgpu 0.5.11

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

@@ -0,0 +1,65 @@
+#pragma once
+
+#include <memory>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "JSIConverter.h"
+#include "WGPULogger.h"
+
+#include "GPUError.h"
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+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 rnwgpu {
+
+template <>
+struct JSIConverter<std::shared_ptr<rnwgpu::GPUUncapturedErrorEventInit>> {
+  static std::shared_ptr<rnwgpu::GPUUncapturedErrorEventInit>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUUncapturedErrorEventInit>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "error")) {
+        auto prop = value.getProperty(runtime, "error");
+        result->error = JSIConverter<std::shared_ptr<GPUError>>::fromJSI(
+            runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "bubbles")) {
+        auto prop = value.getProperty(runtime, "bubbles");
+        result->bubbles =
+            JSIConverter<std::optional<bool>>::fromJSI(runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "cancelable")) {
+        auto prop = value.getProperty(runtime, "cancelable");
+        result->cancelable =
+            JSIConverter<std::optional<bool>>::fromJSI(runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "composed")) {
+        auto prop = value.getProperty(runtime, "composed");
+        result->composed =
+            JSIConverter<std::optional<bool>>::fromJSI(runtime, prop, false);
+      }
+    }
+
+    return result;
+  }
+  static jsi::Value
+  toJSI(jsi::Runtime &runtime,
+        std::shared_ptr<rnwgpu::GPUUncapturedErrorEventInit> arg) {
+    throw std::runtime_error("Invalid GPUUncapturedErrorEventInit::toJSI()");
+  }
+};
+
+} // namespace rnwgpu

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

@@ -0,0 +1,54 @@
+#pragma once
+
+#include <memory>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "JSIConverter.h"
+#include "WGPULogger.h"
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+struct GPUVertexAttribute {
+  wgpu::VertexFormat format; // GPUVertexFormat
+  double offset;             // GPUSize64
+  double shaderLocation;     // GPUIndex32
+};
+
+} // namespace rnwgpu
+
+namespace rnwgpu {
+
+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 prop = value.getProperty(runtime, "format");
+        result->format =
+            JSIConverter<wgpu::VertexFormat>::fromJSI(runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "offset")) {
+        auto prop = value.getProperty(runtime, "offset");
+        result->offset = JSIConverter<double>::fromJSI(runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "shaderLocation")) {
+        auto prop = value.getProperty(runtime, "shaderLocation");
+        result->shaderLocation =
+            JSIConverter<double>::fromJSI(runtime, prop, false);
+      }
+    }
+
+    return result;
+  }
+  static jsi::Value toJSI(jsi::Runtime &runtime,
+                          std::shared_ptr<rnwgpu::GPUVertexAttribute> arg) {
+    throw std::runtime_error("Invalid GPUVertexAttribute::toJSI()");
+  }
+};
+
+} // namespace rnwgpu

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

@@ -0,0 +1,63 @@
+#pragma once
+
+#include <memory>
+#include <vector>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "JSIConverter.h"
+#include "WGPULogger.h"
+
+#include "GPUVertexAttribute.h"
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+struct GPUVertexBufferLayout {
+  double arrayStride;                           // GPUSize64
+  std::optional<wgpu::VertexStepMode> stepMode; // GPUVertexStepMode
+  std::vector<std::shared_ptr<GPUVertexAttribute>>
+      attributes; // Iterable<GPUVertexAttribute>
+};
+
+} // namespace rnwgpu
+
+namespace rnwgpu {
+
+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 prop = value.getProperty(runtime, "arrayStride");
+        result->arrayStride =
+            JSIConverter<double>::fromJSI(runtime, prop, false);
+      }
+      if (value.hasProperty(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 prop = value.getProperty(runtime, "attributes");
+        result->attributes = JSIConverter<
+            std::vector<std::shared_ptr<GPUVertexAttribute>>>::fromJSI(runtime,
+                                                                       prop,
+                                                                       false);
+      }
+    }
+
+    return result;
+  }
+  static jsi::Value toJSI(jsi::Runtime &runtime,
+                          std::shared_ptr<rnwgpu::GPUVertexBufferLayout> arg) {
+    throw std::runtime_error("Invalid GPUVertexBufferLayout::toJSI()");
+  }
+};
+
+} // namespace rnwgpu

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

@@ -0,0 +1,74 @@
+#pragma once
+
+#include <map>
+#include <memory>
+#include <string>
+#include <variant>
+#include <vector>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "JSIConverter.h"
+#include "WGPULogger.h"
+
+#include "GPUShaderModule.h"
+#include "GPUVertexBufferLayout.h"
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+struct GPUVertexState {
+  std::optional<std::vector<
+      std::variant<std::nullptr_t, std::shared_ptr<GPUVertexBufferLayout>>>>
+      buffers; // Iterable<GPUVertexBufferLayout | null>
+  std::shared_ptr<GPUShaderModule> module; // GPUShaderModule
+  std::optional<std::string> entryPoint;   // string
+  std::optional<std::map<std::string, double>>
+      constants; // Record< string, GPUPipelineConstantValue >
+};
+
+} // namespace rnwgpu
+
+namespace rnwgpu {
+
+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 prop = value.getProperty(runtime, "buffers");
+        result->buffers = JSIConverter<std::optional<std::vector<std::variant<
+            std::nullptr_t, std::shared_ptr<GPUVertexBufferLayout>>>>>::
+            fromJSI(runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "module")) {
+        auto prop = value.getProperty(runtime, "module");
+        result->module =
+            JSIConverter<std::shared_ptr<GPUShaderModule>>::fromJSI(
+                runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "entryPoint")) {
+        auto prop = value.getProperty(runtime, "entryPoint");
+        result->entryPoint = JSIConverter<std::optional<std::string>>::fromJSI(
+            runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "constants")) {
+        auto prop = value.getProperty(runtime, "constants");
+        result->constants =
+            JSIConverter<std::optional<std::map<std::string, double>>>::fromJSI(
+                runtime, prop, false);
+      }
+    }
+
+    return result;
+  }
+  static jsi::Value toJSI(jsi::Runtime &runtime,
+                          std::shared_ptr<rnwgpu::GPUVertexState> arg) {
+    throw std::runtime_error("Invalid GPUVertexState::toJSI()");
+  }
+};
+
+} // namespace rnwgpu