react-native-wgpu 0.4.2 → 0.5.1

package/cpp/rnwgpu/api/GPUExtent3D.h

@@ -2,7 +2,7 @@
 
 #include <memory>
 
-#include "RNFJSIConverter.h"
+#include "JSIConverter.h"
 
 #include "webgpu/webgpu_cpp.h"
 
@@ -14,14 +14,10 @@ struct GPUExtent3D {
   double depthOrArrayLayers = 1;
 };
 
-} // namespace rnwgpu
-
-namespace margelo {
-
-template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUExtent3D>> {
-  static std::shared_ptr<rnwgpu::GPUExtent3D>
+template <> struct JSIConverter<std::shared_ptr<GPUExtent3D>> {
+  static std::shared_ptr<GPUExtent3D>
   fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
-    auto result = std::make_unique<rnwgpu::GPUExtent3D>();
+    auto result = std::make_unique<GPUExtent3D>();
     if (!outOfBounds && arg.isObject()) {
       if (arg.getObject(runtime).isArray(runtime)) {
         auto array = arg.getObject(runtime).asArray(runtime);
@@ -61,9 +57,10 @@ template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUExtent3D>> {
     return result;
   }
   static jsi::Value toJSI(jsi::Runtime &runtime,
-                          std::shared_ptr<rnwgpu::GPUExtent3D> arg) {
+                          std::shared_ptr<GPUExtent3D> arg) {
     // No conversions here
     return jsi::Value::null();
   }
 };
-} // namespace margelo
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUExternalTexture.h

@@ -4,22 +4,23 @@
 
 #include "Unions.h"
 
-#include "RNFHybridObject.h"
+#include "NativeObject.h"
 
 #include "webgpu/webgpu_cpp.h"
 
 namespace rnwgpu {
 
-namespace m = margelo;
+namespace jsi = facebook::jsi;
 
-class GPUExternalTexture : public m::HybridObject {
+class GPUExternalTexture : public NativeObject<GPUExternalTexture> {
 public:
+  static constexpr const char *CLASS_NAME = "GPUExternalTexture";
+
   explicit GPUExternalTexture(wgpu::ExternalTexture instance, std::string label)
-      : HybridObject("GPUExternalTexture"), _instance(instance), _label(label) {
-  }
+      : NativeObject(CLASS_NAME), _instance(instance), _label(label) {}
 
 public:
-  std::string getBrand() { return _name; }
+  std::string getBrand() { return CLASS_NAME; }
 
   std::string getLabel() { return _label; }
   void setLabel(const std::string &label) {
@@ -27,11 +28,11 @@ public:
     _instance.SetLabel(_label.c_str());
   }
 
-  void loadHybridMethods() override {
-    registerHybridGetter("__brand", &GPUExternalTexture::getBrand, this);
-
-    registerHybridGetter("label", &GPUExternalTexture::getLabel, this);
-    registerHybridSetter("label", &GPUExternalTexture::setLabel, this);
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installGetter(runtime, prototype, "__brand", &GPUExternalTexture::getBrand);
+    installGetterSetter(runtime, prototype, "label",
+                        &GPUExternalTexture::getLabel,
+                        &GPUExternalTexture::setLabel);
   }
 
   inline const wgpu::ExternalTexture get() { return _instance; }

package/cpp/rnwgpu/api/GPUInternalError.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <string>
+
+#include "NativeObject.h"
+
+namespace rnwgpu {
+
+namespace jsi = facebook::jsi;
+
+class GPUInternalError : public NativeObject<GPUInternalError> {
+public:
+  static constexpr const char *CLASS_NAME = "GPUInternalError";
+
+  explicit GPUInternalError(std::string message)
+      : NativeObject(CLASS_NAME), _message(std::move(message)) {}
+
+public:
+  std::string getBrand() { return CLASS_NAME; }
+  std::string getMessage() { return _message; }
+
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installGetter(runtime, prototype, "__brand", &GPUInternalError::getBrand);
+    installGetter(runtime, prototype, "message", &GPUInternalError::getMessage);
+  }
+
+private:
+  std::string _message;
+};
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUOrigin2D.h

@@ -2,7 +2,7 @@
 
 #include <memory>
 
-#include "RNFJSIConverter.h"
+#include "JSIConverter.h"
 
 #include "webgpu/webgpu_cpp.h"
 
@@ -13,14 +13,10 @@ struct GPUOrigin2D {
   double y = 0;
 };
 
-} // namespace rnwgpu
-
-namespace margelo {
-
-template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUOrigin2D>> {
-  static std::shared_ptr<rnwgpu::GPUOrigin2D>
+template <> struct JSIConverter<std::shared_ptr<GPUOrigin2D>> {
+  static std::shared_ptr<GPUOrigin2D>
   fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
-    auto result = std::make_unique<rnwgpu::GPUOrigin2D>();
+    auto result = std::make_unique<GPUOrigin2D>();
     if (!outOfBounds && arg.isObject()) {
       if (arg.getObject(runtime).isArray(runtime)) {
         auto array = arg.getObject(runtime).asArray(runtime);
@@ -50,10 +46,10 @@ template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUOrigin2D>> {
     return result;
   }
   static jsi::Value toJSI(jsi::Runtime &runtime,
-                          std::shared_ptr<rnwgpu::GPUOrigin2D> arg) {
+                          std::shared_ptr<GPUOrigin2D> arg) {
     // No conversions here
     return jsi::Value::null();
   }
 };
 
-} // namespace margelo
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUOrigin3D.h

@@ -2,7 +2,7 @@
 
 #include <memory>
 
-#include "RNFJSIConverter.h"
+#include "JSIConverter.h"
 
 #include "webgpu/webgpu_cpp.h"
 
@@ -14,14 +14,10 @@ struct GPUOrigin3D {
   double z = 0;
 };
 
-} // namespace rnwgpu
-
-namespace margelo {
-
-template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUOrigin3D>> {
-  static std::shared_ptr<rnwgpu::GPUOrigin3D>
+template <> struct JSIConverter<std::shared_ptr<GPUOrigin3D>> {
+  static std::shared_ptr<GPUOrigin3D>
   fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
-    auto result = std::make_unique<rnwgpu::GPUOrigin3D>();
+    auto result = std::make_unique<GPUOrigin3D>();
     if (!outOfBounds && arg.isObject()) {
       if (arg.getObject(runtime).isArray(runtime)) {
         auto array = arg.getObject(runtime).asArray(runtime);
@@ -57,10 +53,10 @@ template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUOrigin3D>> {
     return result;
   }
   static jsi::Value toJSI(jsi::Runtime &runtime,
-                          std::shared_ptr<rnwgpu::GPUOrigin3D> arg) {
+                          std::shared_ptr<GPUOrigin3D> arg) {
     // No conversions here
     return jsi::Value::null();
   }
 };
 
-} // namespace margelo
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUOutOfMemoryError.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include <string>
+
+#include "NativeObject.h"
+
+namespace rnwgpu {
+
+namespace jsi = facebook::jsi;
+
+class GPUOutOfMemoryError : public NativeObject<GPUOutOfMemoryError> {
+public:
+  static constexpr const char *CLASS_NAME = "GPUOutOfMemoryError";
+
+  explicit GPUOutOfMemoryError(std::string message)
+      : NativeObject(CLASS_NAME), _message(std::move(message)) {}
+
+public:
+  std::string getBrand() { return CLASS_NAME; }
+  std::string getMessage() { return _message; }
+
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installGetter(runtime, prototype, "__brand",
+                  &GPUOutOfMemoryError::getBrand);
+    installGetter(runtime, prototype, "message",
+                  &GPUOutOfMemoryError::getMessage);
+  }
+
+private:
+  std::string _message;
+};
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUPipelineLayout.h

@@ -4,21 +4,23 @@
 
 #include "Unions.h"
 
-#include "RNFHybridObject.h"
+#include "NativeObject.h"
 
 #include "webgpu/webgpu_cpp.h"
 
 namespace rnwgpu {
 
-namespace m = margelo;
+namespace jsi = facebook::jsi;
 
-class GPUPipelineLayout : public m::HybridObject {
+class GPUPipelineLayout : public NativeObject<GPUPipelineLayout> {
 public:
+  static constexpr const char *CLASS_NAME = "GPUPipelineLayout";
+
   explicit GPUPipelineLayout(wgpu::PipelineLayout instance, std::string label)
-      : HybridObject("GPUPipelineLayout"), _instance(instance), _label(label) {}
+      : NativeObject(CLASS_NAME), _instance(instance), _label(label) {}
 
 public:
-  std::string getBrand() { return _name; }
+  std::string getBrand() { return CLASS_NAME; }
 
   std::string getLabel() { return _label; }
   void setLabel(const std::string &label) {
@@ -26,11 +28,11 @@ public:
     _instance.SetLabel(_label.c_str());
   }
 
-  void loadHybridMethods() override {
-    registerHybridGetter("__brand", &GPUPipelineLayout::getBrand, this);
-
-    registerHybridGetter("label", &GPUPipelineLayout::getLabel, this);
-    registerHybridSetter("label", &GPUPipelineLayout::setLabel, this);
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installGetter(runtime, prototype, "__brand", &GPUPipelineLayout::getBrand);
+    installGetterSetter(runtime, prototype, "label",
+                        &GPUPipelineLayout::getLabel,
+                        &GPUPipelineLayout::setLabel);
   }
 
   inline const wgpu::PipelineLayout get() { return _instance; }

package/cpp/rnwgpu/api/GPUQuerySet.h

@@ -4,21 +4,23 @@
 
 #include "Unions.h"
 
-#include "RNFHybridObject.h"
+#include "NativeObject.h"
 
 #include "webgpu/webgpu_cpp.h"
 
 namespace rnwgpu {
 
-namespace m = margelo;
+namespace jsi = facebook::jsi;
 
-class GPUQuerySet : public m::HybridObject {
+class GPUQuerySet : public NativeObject<GPUQuerySet> {
 public:
+  static constexpr const char *CLASS_NAME = "GPUQuerySet";
+
   explicit GPUQuerySet(wgpu::QuerySet instance, std::string label)
-      : HybridObject("GPUQuerySet"), _instance(instance), _label(label) {}
+      : NativeObject(CLASS_NAME), _instance(instance), _label(label) {}
 
 public:
-  std::string getBrand() { return _name; }
+  std::string getBrand() { return CLASS_NAME; }
 
   void destroy();
 
@@ -31,13 +33,13 @@ public:
     _instance.SetLabel(_label.c_str());
   }
 
-  void loadHybridMethods() override {
-    registerHybridGetter("__brand", &GPUQuerySet::getBrand, this);
-    registerHybridMethod("destroy", &GPUQuerySet::destroy, this);
-    registerHybridGetter("type", &GPUQuerySet::getType, this);
-    registerHybridGetter("count", &GPUQuerySet::getCount, this);
-    registerHybridGetter("label", &GPUQuerySet::getLabel, this);
-    registerHybridSetter("label", &GPUQuerySet::setLabel, this);
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installGetter(runtime, prototype, "__brand", &GPUQuerySet::getBrand);
+    installMethod(runtime, prototype, "destroy", &GPUQuerySet::destroy);
+    installGetter(runtime, prototype, "type", &GPUQuerySet::getType);
+    installGetter(runtime, prototype, "count", &GPUQuerySet::getCount);
+    installGetterSetter(runtime, prototype, "label", &GPUQuerySet::getLabel,
+                        &GPUQuerySet::setLabel);
   }
 
   inline const wgpu::QuerySet get() { return _instance; }

package/cpp/rnwgpu/api/GPUQueue.h

@@ -6,7 +6,7 @@
 
 #include "Unions.h"
 
-#include "RNFHybridObject.h"
+#include "NativeObject.h"
 
 #include "rnwgpu/async/AsyncRunner.h"
 #include "rnwgpu/async/AsyncTaskHandle.h"
@@ -21,18 +21,20 @@
 
 namespace rnwgpu {
 
-namespace m = margelo;
+namespace jsi = facebook::jsi;
 
-class GPUQueue : public m::HybridObject {
+class GPUQueue : public NativeObject<GPUQueue> {
 public:
+  static constexpr const char *CLASS_NAME = "GPUQueue";
+
   explicit GPUQueue(wgpu::Queue instance,
                     std::shared_ptr<async::AsyncRunner> async,
                     std::string label)
-      : HybridObject("GPUQueue"), _instance(instance), _async(async),
+      : NativeObject(CLASS_NAME), _instance(instance), _async(async),
         _label(label) {}
 
 public:
-  std::string getBrand() { return _name; }
+  std::string getBrand() { return CLASS_NAME; }
 
   void submit(std::vector<std::shared_ptr<GPUCommandBuffer>> commandBuffers);
   async::AsyncTaskHandle onSubmittedWorkDone();
@@ -55,18 +57,17 @@ public:
     _instance.SetLabel(_label.c_str());
   }
 
-  void loadHybridMethods() override {
-    registerHybridGetter("__brand", &GPUQueue::getBrand, this);
-    registerHybridMethod("submit", &GPUQueue::submit, this);
-    registerHybridMethod("onSubmittedWorkDone", &GPUQueue::onSubmittedWorkDone,
-                         this);
-    registerHybridMethod("writeBuffer", &GPUQueue::writeBuffer, this);
-    registerHybridMethod("writeTexture", &GPUQueue::writeTexture, this);
-    registerHybridMethod("copyExternalImageToTexture",
-                         &GPUQueue::copyExternalImageToTexture, this);
-
-    registerHybridGetter("label", &GPUQueue::getLabel, this);
-    registerHybridSetter("label", &GPUQueue::setLabel, this);
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installGetter(runtime, prototype, "__brand", &GPUQueue::getBrand);
+    installMethod(runtime, prototype, "submit", &GPUQueue::submit);
+    installMethod(runtime, prototype, "onSubmittedWorkDone",
+                  &GPUQueue::onSubmittedWorkDone);
+    installMethod(runtime, prototype, "writeBuffer", &GPUQueue::writeBuffer);
+    installMethod(runtime, prototype, "writeTexture", &GPUQueue::writeTexture);
+    installMethod(runtime, prototype, "copyExternalImageToTexture",
+                  &GPUQueue::copyExternalImageToTexture);
+    installGetterSetter(runtime, prototype, "label", &GPUQueue::getLabel,
+                        &GPUQueue::setLabel);
   }
 
   inline const wgpu::Queue get() { return _instance; }

package/cpp/rnwgpu/api/GPURenderBundle.h

@@ -4,21 +4,23 @@
 
 #include "Unions.h"
 
-#include "RNFHybridObject.h"
+#include "NativeObject.h"
 
 #include "webgpu/webgpu_cpp.h"
 
 namespace rnwgpu {
 
-namespace m = margelo;
+namespace jsi = facebook::jsi;
 
-class GPURenderBundle : public m::HybridObject {
+class GPURenderBundle : public NativeObject<GPURenderBundle> {
 public:
+  static constexpr const char *CLASS_NAME = "GPURenderBundle";
+
   explicit GPURenderBundle(wgpu::RenderBundle instance, std::string label)
-      : HybridObject("GPURenderBundle"), _instance(instance), _label(label) {}
+      : NativeObject(CLASS_NAME), _instance(instance), _label(label) {}
 
 public:
-  std::string getBrand() { return _name; }
+  std::string getBrand() { return CLASS_NAME; }
 
   std::string getLabel() { return _label; }
   void setLabel(const std::string &label) {
@@ -26,11 +28,10 @@ public:
     _instance.SetLabel(_label.c_str());
   }
 
-  void loadHybridMethods() override {
-    registerHybridGetter("__brand", &GPURenderBundle::getBrand, this);
-
-    registerHybridGetter("label", &GPURenderBundle::getLabel, this);
-    registerHybridSetter("label", &GPURenderBundle::setLabel, this);
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installGetter(runtime, prototype, "__brand", &GPURenderBundle::getBrand);
+    installGetterSetter(runtime, prototype, "label", &GPURenderBundle::getLabel,
+                        &GPURenderBundle::setLabel);
   }
 
   inline const wgpu::RenderBundle get() { return _instance; }

package/cpp/rnwgpu/api/GPURenderBundleEncoder.h

@@ -8,7 +8,7 @@
 
 #include "Unions.h"
 
-#include "RNFHybridObject.h"
+#include "NativeObject.h"
 
 #include "webgpu/webgpu_cpp.h"
 
@@ -20,17 +20,18 @@
 
 namespace rnwgpu {
 
-namespace m = margelo;
+namespace jsi = facebook::jsi;
 
-class GPURenderBundleEncoder : public m::HybridObject {
+class GPURenderBundleEncoder : public NativeObject<GPURenderBundleEncoder> {
 public:
+  static constexpr const char *CLASS_NAME = "GPURenderBundleEncoder";
+
   explicit GPURenderBundleEncoder(wgpu::RenderBundleEncoder instance,
                                   std::string label)
-      : HybridObject("GPURenderBundleEncoder"), _instance(instance),
-        _label(label) {}
+      : NativeObject(CLASS_NAME), _instance(instance), _label(label) {}
 
 public:
-  std::string getBrand() { return _name; }
+  std::string getBrand() { return CLASS_NAME; }
 
   std::shared_ptr<GPURenderBundle>
   finish(std::optional<std::shared_ptr<GPURenderBundleDescriptor>> descriptor);
@@ -68,33 +69,35 @@ public:
     _instance.SetLabel(_label.c_str());
   }
 
-  void loadHybridMethods() override {
-    registerHybridGetter("__brand", &GPURenderBundleEncoder::getBrand, this);
-    registerHybridMethod("finish", &GPURenderBundleEncoder::finish, this);
-    registerHybridMethod("pushDebugGroup",
-                         &GPURenderBundleEncoder::pushDebugGroup, this);
-    registerHybridMethod("popDebugGroup",
-                         &GPURenderBundleEncoder::popDebugGroup, this);
-    registerHybridMethod("insertDebugMarker",
-                         &GPURenderBundleEncoder::insertDebugMarker, this);
-    registerHybridMethod("setBindGroup", &GPURenderBundleEncoder::setBindGroup,
-                         this);
-    registerHybridMethod("setPipeline", &GPURenderBundleEncoder::setPipeline,
-                         this);
-    registerHybridMethod("setIndexBuffer",
-                         &GPURenderBundleEncoder::setIndexBuffer, this);
-    registerHybridMethod("setVertexBuffer",
-                         &GPURenderBundleEncoder::setVertexBuffer, this);
-    registerHybridMethod("draw", &GPURenderBundleEncoder::draw, this);
-    registerHybridMethod("drawIndexed", &GPURenderBundleEncoder::drawIndexed,
-                         this);
-    registerHybridMethod("drawIndirect", &GPURenderBundleEncoder::drawIndirect,
-                         this);
-    registerHybridMethod("drawIndexedIndirect",
-                         &GPURenderBundleEncoder::drawIndexedIndirect, this);
-
-    registerHybridGetter("label", &GPURenderBundleEncoder::getLabel, this);
-    registerHybridSetter("label", &GPURenderBundleEncoder::setLabel, this);
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installGetter(runtime, prototype, "__brand",
+                  &GPURenderBundleEncoder::getBrand);
+    installMethod(runtime, prototype, "finish",
+                  &GPURenderBundleEncoder::finish);
+    installMethod(runtime, prototype, "pushDebugGroup",
+                  &GPURenderBundleEncoder::pushDebugGroup);
+    installMethod(runtime, prototype, "popDebugGroup",
+                  &GPURenderBundleEncoder::popDebugGroup);
+    installMethod(runtime, prototype, "insertDebugMarker",
+                  &GPURenderBundleEncoder::insertDebugMarker);
+    installMethod(runtime, prototype, "setBindGroup",
+                  &GPURenderBundleEncoder::setBindGroup);
+    installMethod(runtime, prototype, "setPipeline",
+                  &GPURenderBundleEncoder::setPipeline);
+    installMethod(runtime, prototype, "setIndexBuffer",
+                  &GPURenderBundleEncoder::setIndexBuffer);
+    installMethod(runtime, prototype, "setVertexBuffer",
+                  &GPURenderBundleEncoder::setVertexBuffer);
+    installMethod(runtime, prototype, "draw", &GPURenderBundleEncoder::draw);
+    installMethod(runtime, prototype, "drawIndexed",
+                  &GPURenderBundleEncoder::drawIndexed);
+    installMethod(runtime, prototype, "drawIndirect",
+                  &GPURenderBundleEncoder::drawIndirect);
+    installMethod(runtime, prototype, "drawIndexedIndirect",
+                  &GPURenderBundleEncoder::drawIndexedIndirect);
+    installGetterSetter(runtime, prototype, "label",
+                        &GPURenderBundleEncoder::getLabel,
+                        &GPURenderBundleEncoder::setLabel);
   }
 
   inline const wgpu::RenderBundleEncoder get() { return _instance; }