react-native-wgpu 0.1.0

package/cpp/rnwgpu/api/GPURenderPipeline.h

@@ -0,0 +1,38 @@
+#pragma once
+
+#include <future>
+#include <memory>
+#include <string>
+
+#include "Unions.h"
+#include <RNFHybridObject.h>
+
+#include "MutableBuffer.h"
+
+#include "webgpu/webgpu_cpp.h"
+
+namespace rnwgpu {
+
+namespace m = margelo;
+
+class GPURenderPipeline : public m::HybridObject {
+public:
+  explicit GPURenderPipeline(wgpu::RenderPipeline instance, std::string label)
+      : HybridObject("GPURenderPipeline"), _instance(instance), _label(label) {}
+
+public:
+  std::string getBrand() { return _name; }
+
+  std::string getLabel() { return _label; }
+
+  void loadHybridMethods() override {
+    registerHybridGetter("__brand", &GPURenderPipeline::getBrand, this);
+
+    registerHybridGetter("label", &GPURenderPipeline::getLabel, this);
+  }
+
+private:
+  wgpu::RenderPipeline _instance;
+  std::string _label;
+};
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUSampler.h

@@ -0,0 +1,38 @@
+#pragma once
+
+#include <future>
+#include <memory>
+#include <string>
+
+#include "Unions.h"
+#include <RNFHybridObject.h>
+
+#include "MutableBuffer.h"
+
+#include "webgpu/webgpu_cpp.h"
+
+namespace rnwgpu {
+
+namespace m = margelo;
+
+class GPUSampler : public m::HybridObject {
+public:
+  explicit GPUSampler(wgpu::Sampler instance, std::string label)
+      : HybridObject("GPUSampler"), _instance(instance), _label(label) {}
+
+public:
+  std::string getBrand() { return _name; }
+
+  std::string getLabel() { return _label; }
+
+  void loadHybridMethods() override {
+    registerHybridGetter("__brand", &GPUSampler::getBrand, this);
+
+    registerHybridGetter("label", &GPUSampler::getLabel, this);
+  }
+
+private:
+  wgpu::Sampler _instance;
+  std::string _label;
+};
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUShaderModule.h

@@ -0,0 +1,38 @@
+#pragma once
+
+#include <future>
+#include <memory>
+#include <string>
+
+#include "Unions.h"
+#include <RNFHybridObject.h>
+
+#include "MutableBuffer.h"
+
+#include "webgpu/webgpu_cpp.h"
+
+namespace rnwgpu {
+
+namespace m = margelo;
+
+class GPUShaderModule : public m::HybridObject {
+public:
+  explicit GPUShaderModule(wgpu::ShaderModule instance, std::string label)
+      : HybridObject("GPUShaderModule"), _instance(instance), _label(label) {}
+
+public:
+  std::string getBrand() { return _name; }
+
+  std::string getLabel() { return _label; }
+
+  void loadHybridMethods() override {
+    registerHybridGetter("__brand", &GPUShaderModule::getBrand, this);
+
+    registerHybridGetter("label", &GPUShaderModule::getLabel, this);
+  }
+
+private:
+  wgpu::ShaderModule _instance;
+  std::string _label;
+};
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUSupportedLimits.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include <future>
+#include <memory>
+#include <string>
+
+#include "Unions.h"
+#include <RNFHybridObject.h>
+
+#include "MutableBuffer.h"
+
+#include "webgpu/webgpu_cpp.h"
+
+namespace rnwgpu {
+
+namespace m = margelo;
+
+class GPUSupportedLimits : public m::HybridObject {
+public:
+  explicit GPUSupportedLimits(wgpu::SupportedLimits instance)
+      : HybridObject("GPUSupportedLimits"), _instance(instance) {}
+
+public:
+  std::string getBrand() { return _name; }
+
+  void loadHybridMethods() override {
+    registerHybridGetter("__brand", &GPUSupportedLimits::getBrand, this);
+  }
+
+private:
+  wgpu::SupportedLimits _instance;
+};
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUTexture.h

@@ -0,0 +1,38 @@
+#pragma once
+
+#include <future>
+#include <memory>
+#include <string>
+
+#include "Unions.h"
+#include <RNFHybridObject.h>
+
+#include "MutableBuffer.h"
+
+#include "webgpu/webgpu_cpp.h"
+
+namespace rnwgpu {
+
+namespace m = margelo;
+
+class GPUTexture : public m::HybridObject {
+public:
+  explicit GPUTexture(wgpu::Texture instance, std::string label)
+      : HybridObject("GPUTexture"), _instance(instance), _label(label) {}
+
+public:
+  std::string getBrand() { return _name; }
+
+  std::string getLabel() { return _label; }
+
+  void loadHybridMethods() override {
+    registerHybridGetter("__brand", &GPUTexture::getBrand, this);
+
+    registerHybridGetter("label", &GPUTexture::getLabel, this);
+  }
+
+private:
+  wgpu::Texture _instance;
+  std::string _label;
+};
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUTextureView.h

@@ -0,0 +1,38 @@
+#pragma once
+
+#include <future>
+#include <memory>
+#include <string>
+
+#include "Unions.h"
+#include <RNFHybridObject.h>
+
+#include "MutableBuffer.h"
+
+#include "webgpu/webgpu_cpp.h"
+
+namespace rnwgpu {
+
+namespace m = margelo;
+
+class GPUTextureView : public m::HybridObject {
+public:
+  explicit GPUTextureView(wgpu::TextureView instance, std::string label)
+      : HybridObject("GPUTextureView"), _instance(instance), _label(label) {}
+
+public:
+  std::string getBrand() { return _name; }
+
+  std::string getLabel() { return _label; }
+
+  void loadHybridMethods() override {
+    registerHybridGetter("__brand", &GPUTextureView::getBrand, this);
+
+    registerHybridGetter("label", &GPUTextureView::getLabel, this);
+  }
+
+private:
+  wgpu::TextureView _instance;
+  std::string _label;
+};
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUUncapturedErrorEvent.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include <future>
+#include <memory>
+#include <string>
+
+#include "Unions.h"
+#include <RNFHybridObject.h>
+
+#include "MutableBuffer.h"
+
+#include "webgpu/webgpu_cpp.h"
+
+namespace rnwgpu {
+
+namespace m = margelo;
+
+class GPUUncapturedErrorEvent : public m::HybridObject {
+public:
+  explicit GPUUncapturedErrorEvent(wgpu::UncapturedErrorEvent instance)
+      : HybridObject("GPUUncapturedErrorEvent"), _instance(instance) {}
+
+public:
+  std::string getBrand() { return _name; }
+
+  void loadHybridMethods() override {
+    registerHybridGetter("__brand", &GPUUncapturedErrorEvent::getBrand, this);
+  }
+
+private:
+  wgpu::UncapturedErrorEvent _instance;
+};
+} // namespace rnwgpu

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

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

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

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

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

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

package/cpp/rnwgpu/api/descriptors/GPUBlendComponent.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 GPUBlendComponent {
+public:
+  wgpu::BlendComponent *getInstance() { return &_instance; }
+
+  wgpu::BlendComponent _instance;
+};
+} // namespace rnwgpu
+
+namespace margelo {
+
+template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUBlendComponent>> {
+  static std::shared_ptr<rnwgpu::GPUBlendComponent>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUBlendComponent>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "operation")) {
+        auto operation = value.getProperty(runtime, "operation");
+      }
+      if (value.hasProperty(runtime, "srcFactor")) {
+        auto srcFactor = value.getProperty(runtime, "srcFactor");
+      }
+      if (value.hasProperty(runtime, "dstFactor")) {
+        auto dstFactor = value.getProperty(runtime, "dstFactor");
+      }
+    }
+    rnwgpu::Logger::logToConsole("GPUBlendComponent::operation = %f",
+                                 result->_instance.operation);
+    rnwgpu::Logger::logToConsole("GPUBlendComponent::srcFactor = %f",
+                                 result->_instance.srcFactor);
+    rnwgpu::Logger::logToConsole("GPUBlendComponent::dstFactor = %f",
+                                 result->_instance.dstFactor);
+    return result;
+  }
+  static jsi::Value toJSI(jsi::Runtime &runtime,
+                          std::shared_ptr<rnwgpu::GPUBlendComponent> arg) {
+    // No conversions here
+    return jsi::Value::null();
+  }
+};
+} // namespace margelo

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

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