react-native-wgpu 0.1.0

package/cpp/rnwgpu/api/GPUBuffer.h

@@ -0,0 +1,44 @@
+#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 GPUBuffer : public m::HybridObject {
+public:
+  explicit GPUBuffer(wgpu::Buffer instance, std::string label)
+      : HybridObject("GPUBuffer"), _instance(instance), _label(label) {}
+
+public:
+  std::string getBrand() { return _name; }
+
+  std::shared_ptr<MutableJSIBuffer> getMappedRange(std::optional<size_t> offset,
+                                                   std::optional<size_t> size);
+  void unmap();
+
+  std::string getLabel() { return _label; }
+
+  void loadHybridMethods() override {
+    registerHybridGetter("__brand", &GPUBuffer::getBrand, this);
+    registerHybridMethod("getMappedRange", &GPUBuffer::getMappedRange, this);
+    registerHybridMethod("unmap", &GPUBuffer::unmap, this);
+
+    registerHybridGetter("label", &GPUBuffer::getLabel, this);
+  }
+
+private:
+  wgpu::Buffer _instance;
+  std::string _label;
+};
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUCanvasContext.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 GPUCanvasContext : public m::HybridObject {
+public:
+  explicit GPUCanvasContext(wgpu::CanvasContext instance)
+      : HybridObject("GPUCanvasContext"), _instance(instance) {}
+
+public:
+  std::string getBrand() { return _name; }
+
+  void loadHybridMethods() override {
+    registerHybridGetter("__brand", &GPUCanvasContext::getBrand, this);
+  }
+
+private:
+  wgpu::CanvasContext _instance;
+};
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUCommandBuffer.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 GPUCommandBuffer : public m::HybridObject {
+public:
+  explicit GPUCommandBuffer(wgpu::CommandBuffer instance, std::string label)
+      : HybridObject("GPUCommandBuffer"), _instance(instance), _label(label) {}
+
+public:
+  std::string getBrand() { return _name; }
+
+  std::string getLabel() { return _label; }
+
+  void loadHybridMethods() override {
+    registerHybridGetter("__brand", &GPUCommandBuffer::getBrand, this);
+
+    registerHybridGetter("label", &GPUCommandBuffer::getLabel, this);
+  }
+
+private:
+  wgpu::CommandBuffer _instance;
+  std::string _label;
+};
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUCommandEncoder.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 GPUCommandEncoder : public m::HybridObject {
+public:
+  explicit GPUCommandEncoder(wgpu::CommandEncoder instance, std::string label)
+      : HybridObject("GPUCommandEncoder"), _instance(instance), _label(label) {}
+
+public:
+  std::string getBrand() { return _name; }
+
+  std::string getLabel() { return _label; }
+
+  void loadHybridMethods() override {
+    registerHybridGetter("__brand", &GPUCommandEncoder::getBrand, this);
+
+    registerHybridGetter("label", &GPUCommandEncoder::getLabel, this);
+  }
+
+private:
+  wgpu::CommandEncoder _instance;
+  std::string _label;
+};
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUCompilationInfo.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 GPUCompilationInfo : public m::HybridObject {
+public:
+  explicit GPUCompilationInfo(wgpu::CompilationInfo instance)
+      : HybridObject("GPUCompilationInfo"), _instance(instance) {}
+
+public:
+  std::string getBrand() { return _name; }
+
+  void loadHybridMethods() override {
+    registerHybridGetter("__brand", &GPUCompilationInfo::getBrand, this);
+  }
+
+private:
+  wgpu::CompilationInfo _instance;
+};
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUCompilationMessage.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 GPUCompilationMessage : public m::HybridObject {
+public:
+  explicit GPUCompilationMessage(wgpu::CompilationMessage instance)
+      : HybridObject("GPUCompilationMessage"), _instance(instance) {}
+
+public:
+  std::string getBrand() { return _name; }
+
+  void loadHybridMethods() override {
+    registerHybridGetter("__brand", &GPUCompilationMessage::getBrand, this);
+  }
+
+private:
+  wgpu::CompilationMessage _instance;
+};
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUComputePassEncoder.h

@@ -0,0 +1,40 @@
+#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 GPUComputePassEncoder : public m::HybridObject {
+public:
+  explicit GPUComputePassEncoder(wgpu::ComputePassEncoder instance,
+                                 std::string label)
+      : HybridObject("GPUComputePassEncoder"), _instance(instance),
+        _label(label) {}
+
+public:
+  std::string getBrand() { return _name; }
+
+  std::string getLabel() { return _label; }
+
+  void loadHybridMethods() override {
+    registerHybridGetter("__brand", &GPUComputePassEncoder::getBrand, this);
+
+    registerHybridGetter("label", &GPUComputePassEncoder::getLabel, this);
+  }
+
+private:
+  wgpu::ComputePassEncoder _instance;
+  std::string _label;
+};
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUComputePipeline.h

@@ -0,0 +1,39 @@
+#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 GPUComputePipeline : public m::HybridObject {
+public:
+  explicit GPUComputePipeline(wgpu::ComputePipeline instance, std::string label)
+      : HybridObject("GPUComputePipeline"), _instance(instance), _label(label) {
+  }
+
+public:
+  std::string getBrand() { return _name; }
+
+  std::string getLabel() { return _label; }
+
+  void loadHybridMethods() override {
+    registerHybridGetter("__brand", &GPUComputePipeline::getBrand, this);
+
+    registerHybridGetter("label", &GPUComputePipeline::getLabel, this);
+  }
+
+private:
+  wgpu::ComputePipeline _instance;
+  std::string _label;
+};
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUDevice.cpp

@@ -0,0 +1,12 @@
+#include "GPUDevice.h"
+
+namespace rnwgpu {
+
+std::shared_ptr<GPUBuffer>
+GPUDevice::createBuffer(std::shared_ptr<GPUBufferDescriptor> descriptor) {
+  auto aDescriptor = descriptor->getInstance();
+  auto result = _instance.CreateBuffer(aDescriptor);
+  return std::make_shared<GPUBuffer>(result, descriptor->label);
+}
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUDevice.h

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

package/cpp/rnwgpu/api/GPUDeviceLostInfo.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 GPUDeviceLostInfo : public m::HybridObject {
+public:
+  explicit GPUDeviceLostInfo(wgpu::DeviceLostInfo instance)
+      : HybridObject("GPUDeviceLostInfo"), _instance(instance) {}
+
+public:
+  std::string getBrand() { return _name; }
+
+  void loadHybridMethods() override {
+    registerHybridGetter("__brand", &GPUDeviceLostInfo::getBrand, this);
+  }
+
+private:
+  wgpu::DeviceLostInfo _instance;
+};
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUExternalTexture.h

@@ -0,0 +1,39 @@
+#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 GPUExternalTexture : public m::HybridObject {
+public:
+  explicit GPUExternalTexture(wgpu::ExternalTexture instance, std::string label)
+      : HybridObject("GPUExternalTexture"), _instance(instance), _label(label) {
+  }
+
+public:
+  std::string getBrand() { return _name; }
+
+  std::string getLabel() { return _label; }
+
+  void loadHybridMethods() override {
+    registerHybridGetter("__brand", &GPUExternalTexture::getBrand, this);
+
+    registerHybridGetter("label", &GPUExternalTexture::getLabel, this);
+  }
+
+private:
+  wgpu::ExternalTexture _instance;
+  std::string _label;
+};
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUPipelineLayout.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 GPUPipelineLayout : public m::HybridObject {
+public:
+  explicit GPUPipelineLayout(wgpu::PipelineLayout instance, std::string label)
+      : HybridObject("GPUPipelineLayout"), _instance(instance), _label(label) {}
+
+public:
+  std::string getBrand() { return _name; }
+
+  std::string getLabel() { return _label; }
+
+  void loadHybridMethods() override {
+    registerHybridGetter("__brand", &GPUPipelineLayout::getBrand, this);
+
+    registerHybridGetter("label", &GPUPipelineLayout::getLabel, this);
+  }
+
+private:
+  wgpu::PipelineLayout _instance;
+  std::string _label;
+};
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUQuerySet.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 GPUQuerySet : public m::HybridObject {
+public:
+  explicit GPUQuerySet(wgpu::QuerySet instance, std::string label)
+      : HybridObject("GPUQuerySet"), _instance(instance), _label(label) {}
+
+public:
+  std::string getBrand() { return _name; }
+
+  std::string getLabel() { return _label; }
+
+  void loadHybridMethods() override {
+    registerHybridGetter("__brand", &GPUQuerySet::getBrand, this);
+
+    registerHybridGetter("label", &GPUQuerySet::getLabel, this);
+  }
+
+private:
+  wgpu::QuerySet _instance;
+  std::string _label;
+};
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUQueue.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 GPUQueue : public m::HybridObject {
+public:
+  explicit GPUQueue(wgpu::Queue instance, std::string label)
+      : HybridObject("GPUQueue"), _instance(instance), _label(label) {}
+
+public:
+  std::string getBrand() { return _name; }
+
+  std::string getLabel() { return _label; }
+
+  void loadHybridMethods() override {
+    registerHybridGetter("__brand", &GPUQueue::getBrand, this);
+
+    registerHybridGetter("label", &GPUQueue::getLabel, this);
+  }
+
+private:
+  wgpu::Queue _instance;
+  std::string _label;
+};
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPURenderBundle.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 GPURenderBundle : public m::HybridObject {
+public:
+  explicit GPURenderBundle(wgpu::RenderBundle instance, std::string label)
+      : HybridObject("GPURenderBundle"), _instance(instance), _label(label) {}
+
+public:
+  std::string getBrand() { return _name; }
+
+  std::string getLabel() { return _label; }
+
+  void loadHybridMethods() override {
+    registerHybridGetter("__brand", &GPURenderBundle::getBrand, this);
+
+    registerHybridGetter("label", &GPURenderBundle::getLabel, this);
+  }
+
+private:
+  wgpu::RenderBundle _instance;
+  std::string _label;
+};
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPURenderBundleEncoder.h

@@ -0,0 +1,40 @@
+#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 GPURenderBundleEncoder : public m::HybridObject {
+public:
+  explicit GPURenderBundleEncoder(wgpu::RenderBundleEncoder instance,
+                                  std::string label)
+      : HybridObject("GPURenderBundleEncoder"), _instance(instance),
+        _label(label) {}
+
+public:
+  std::string getBrand() { return _name; }
+
+  std::string getLabel() { return _label; }
+
+  void loadHybridMethods() override {
+    registerHybridGetter("__brand", &GPURenderBundleEncoder::getBrand, this);
+
+    registerHybridGetter("label", &GPURenderBundleEncoder::getLabel, this);
+  }
+
+private:
+  wgpu::RenderBundleEncoder _instance;
+  std::string _label;
+};
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPURenderPassEncoder.h

@@ -0,0 +1,40 @@
+#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 GPURenderPassEncoder : public m::HybridObject {
+public:
+  explicit GPURenderPassEncoder(wgpu::RenderPassEncoder instance,
+                                std::string label)
+      : HybridObject("GPURenderPassEncoder"), _instance(instance),
+        _label(label) {}
+
+public:
+  std::string getBrand() { return _name; }
+
+  std::string getLabel() { return _label; }
+
+  void loadHybridMethods() override {
+    registerHybridGetter("__brand", &GPURenderPassEncoder::getBrand, this);
+
+    registerHybridGetter("label", &GPURenderPassEncoder::getLabel, this);
+  }
+
+private:
+  wgpu::RenderPassEncoder _instance;
+  std::string _label;
+};
+} // namespace rnwgpu