react-native-wgpu 0.4.1 → 0.5.0

package/cpp/rnwgpu/api/GPUComputePassEncoder.h

@@ -8,7 +8,7 @@
 
 #include "Unions.h"
 
-#include "RNFHybridObject.h"
+#include "NativeObject.h"
 
 #include "webgpu/webgpu_cpp.h"
 
@@ -18,17 +18,18 @@
 
 namespace rnwgpu {
 
-namespace m = margelo;
+namespace jsi = facebook::jsi;
 
-class GPUComputePassEncoder : public m::HybridObject {
+class GPUComputePassEncoder : public NativeObject<GPUComputePassEncoder> {
 public:
+  static constexpr const char *CLASS_NAME = "GPUComputePassEncoder";
+
   explicit GPUComputePassEncoder(wgpu::ComputePassEncoder instance,
                                  std::string label)
-      : HybridObject("GPUComputePassEncoder"), _instance(instance),
-        _label(label) {}
+      : NativeObject(CLASS_NAME), _instance(instance), _label(label) {}
 
 public:
-  std::string getBrand() { return _name; }
+  std::string getBrand() { return CLASS_NAME; }
 
   void setPipeline(std::shared_ptr<GPUComputePipeline> pipeline);
   void dispatchWorkgroups(uint32_t workgroupCountX,
@@ -51,27 +52,27 @@ public:
     _instance.SetLabel(_label.c_str());
   }
 
-  void loadHybridMethods() override {
-    registerHybridGetter("__brand", &GPUComputePassEncoder::getBrand, this);
-    registerHybridMethod("setPipeline", &GPUComputePassEncoder::setPipeline,
-                         this);
-    registerHybridMethod("dispatchWorkgroups",
-                         &GPUComputePassEncoder::dispatchWorkgroups, this);
-    registerHybridMethod("dispatchWorkgroupsIndirect",
-                         &GPUComputePassEncoder::dispatchWorkgroupsIndirect,
-                         this);
-    registerHybridMethod("end", &GPUComputePassEncoder::end, this);
-    registerHybridMethod("pushDebugGroup",
-                         &GPUComputePassEncoder::pushDebugGroup, this);
-    registerHybridMethod("popDebugGroup", &GPUComputePassEncoder::popDebugGroup,
-                         this);
-    registerHybridMethod("insertDebugMarker",
-                         &GPUComputePassEncoder::insertDebugMarker, this);
-    registerHybridMethod("setBindGroup", &GPUComputePassEncoder::setBindGroup,
-                         this);
-
-    registerHybridGetter("label", &GPUComputePassEncoder::getLabel, this);
-    registerHybridSetter("label", &GPUComputePassEncoder::setLabel, this);
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installGetter(runtime, prototype, "__brand",
+                  &GPUComputePassEncoder::getBrand);
+    installMethod(runtime, prototype, "setPipeline",
+                  &GPUComputePassEncoder::setPipeline);
+    installMethod(runtime, prototype, "dispatchWorkgroups",
+                  &GPUComputePassEncoder::dispatchWorkgroups);
+    installMethod(runtime, prototype, "dispatchWorkgroupsIndirect",
+                  &GPUComputePassEncoder::dispatchWorkgroupsIndirect);
+    installMethod(runtime, prototype, "end", &GPUComputePassEncoder::end);
+    installMethod(runtime, prototype, "pushDebugGroup",
+                  &GPUComputePassEncoder::pushDebugGroup);
+    installMethod(runtime, prototype, "popDebugGroup",
+                  &GPUComputePassEncoder::popDebugGroup);
+    installMethod(runtime, prototype, "insertDebugMarker",
+                  &GPUComputePassEncoder::insertDebugMarker);
+    installMethod(runtime, prototype, "setBindGroup",
+                  &GPUComputePassEncoder::setBindGroup);
+    installGetterSetter(runtime, prototype, "label",
+                        &GPUComputePassEncoder::getLabel,
+                        &GPUComputePassEncoder::setLabel);
   }
 
   inline const wgpu::ComputePassEncoder get() { return _instance; }

package/cpp/rnwgpu/api/GPUComputePipeline.h

@@ -5,7 +5,7 @@
 
 #include "Unions.h"
 
-#include "RNFHybridObject.h"
+#include "NativeObject.h"
 
 #include "webgpu/webgpu_cpp.h"
 
@@ -13,16 +13,17 @@
 
 namespace rnwgpu {
 
-namespace m = margelo;
+namespace jsi = facebook::jsi;
 
-class GPUComputePipeline : public m::HybridObject {
+class GPUComputePipeline : public NativeObject<GPUComputePipeline> {
 public:
+  static constexpr const char *CLASS_NAME = "GPUComputePipeline";
+
   explicit GPUComputePipeline(wgpu::ComputePipeline instance, std::string label)
-      : HybridObject("GPUComputePipeline"), _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<GPUBindGroupLayout> getBindGroupLayout(uint32_t index);
 
@@ -32,13 +33,13 @@ public:
     _instance.SetLabel(_label.c_str());
   }
 
-  void loadHybridMethods() override {
-    registerHybridGetter("__brand", &GPUComputePipeline::getBrand, this);
-    registerHybridMethod("getBindGroupLayout",
-                         &GPUComputePipeline::getBindGroupLayout, this);
-
-    registerHybridGetter("label", &GPUComputePipeline::getLabel, this);
-    registerHybridSetter("label", &GPUComputePipeline::setLabel, this);
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installGetter(runtime, prototype, "__brand", &GPUComputePipeline::getBrand);
+    installMethod(runtime, prototype, "getBindGroupLayout",
+                  &GPUComputePipeline::getBindGroupLayout);
+    installGetterSetter(runtime, prototype, "label",
+                        &GPUComputePipeline::getLabel,
+                        &GPUComputePipeline::setLabel);
   }
 
   inline const wgpu::ComputePipeline get() { return _instance; }

package/cpp/rnwgpu/api/GPUDevice.cpp

@@ -7,9 +7,12 @@
 #include <vector>
 
 #include "Convertors.h"
-#include "RNFJSIConverter.h"
+#include "JSIConverter.h"
 
 #include "GPUFeatures.h"
+#include "GPUInternalError.h"
+#include "GPUOutOfMemoryError.h"
+#include "GPUValidationError.h"
 
 namespace rnwgpu {
 
@@ -26,8 +29,8 @@ void GPUDevice::notifyDeviceLost(wgpu::DeviceLostReason reason,
     auto resolve = std::move(*_lostResolve);
     _lostResolve.reset();
     resolve([info = _lostInfo](jsi::Runtime &runtime) mutable {
-      return margelo::JSIConverter<std::shared_ptr<GPUDeviceLostInfo>>::toJSI(
-          runtime, info);
+      return JSIConverter<std::shared_ptr<GPUDeviceLostInfo>>::toJSI(runtime,
+                                                                     info);
     });
   }
 
@@ -248,31 +251,31 @@ async::AsyncTaskHandle GPUDevice::createComputePipelineAsync(
       descriptor->label.has_value() ? descriptor->label.value() : "");
   auto pipelineHolder = std::make_shared<GPUComputePipeline>(nullptr, label);
 
-  return _async->postTask(
-      [device = _instance, desc, descriptor,
-       pipelineHolder](const async::AsyncTaskHandle::ResolveFunction &resolve,
-                       const async::AsyncTaskHandle::RejectFunction &reject) {
-        (void)descriptor;
-        device.CreateComputePipelineAsync(
-            &desc, wgpu::CallbackMode::AllowProcessEvents,
-            [pipelineHolder, resolve,
-             reject](wgpu::CreatePipelineAsyncStatus status,
-                     wgpu::ComputePipeline pipeline, const char *msg) mutable {
-              if (status == wgpu::CreatePipelineAsyncStatus::Success &&
-                  pipeline) {
-                pipelineHolder->_instance = pipeline;
-                resolve([pipelineHolder](jsi::Runtime &runtime) mutable {
-                  return margelo::
-                      JSIConverter<std::shared_ptr<GPUComputePipeline>>::toJSI(
-                          runtime, pipelineHolder);
-                });
-              } else {
-                std::string error = msg ? std::string(msg)
-                                        : "Failed to create compute pipeline";
-                reject(std::move(error));
-              }
+  return _async->postTask([device = _instance, desc, descriptor,
+                           pipelineHolder](
+                              const async::AsyncTaskHandle::ResolveFunction
+                                  &resolve,
+                              const async::AsyncTaskHandle::RejectFunction
+                                  &reject) {
+    (void)descriptor;
+    device.CreateComputePipelineAsync(
+        &desc, wgpu::CallbackMode::AllowProcessEvents,
+        [pipelineHolder, resolve,
+         reject](wgpu::CreatePipelineAsyncStatus status,
+                 wgpu::ComputePipeline pipeline, const char *msg) mutable {
+          if (status == wgpu::CreatePipelineAsyncStatus::Success && pipeline) {
+            pipelineHolder->_instance = pipeline;
+            resolve([pipelineHolder](jsi::Runtime &runtime) mutable {
+              return JSIConverter<std::shared_ptr<GPUComputePipeline>>::toJSI(
+                  runtime, pipelineHolder);
             });
-      });
+          } else {
+            std::string error =
+                msg ? std::string(msg) : "Failed to create compute pipeline";
+            reject(std::move(error));
+          }
+        });
+  });
 }
 
 async::AsyncTaskHandle GPUDevice::createRenderPipelineAsync(
@@ -289,31 +292,31 @@ async::AsyncTaskHandle GPUDevice::createRenderPipelineAsync(
       descriptor->label.has_value() ? descriptor->label.value() : "");
   auto pipelineHolder = std::make_shared<GPURenderPipeline>(nullptr, label);
 
-  return _async->postTask(
-      [device = _instance, desc, descriptor,
-       pipelineHolder](const async::AsyncTaskHandle::ResolveFunction &resolve,
-                       const async::AsyncTaskHandle::RejectFunction &reject) {
-        (void)descriptor;
-        device.CreateRenderPipelineAsync(
-            &desc, wgpu::CallbackMode::AllowProcessEvents,
-            [pipelineHolder, resolve,
-             reject](wgpu::CreatePipelineAsyncStatus status,
-                     wgpu::RenderPipeline pipeline, const char *msg) mutable {
-              if (status == wgpu::CreatePipelineAsyncStatus::Success &&
-                  pipeline) {
-                pipelineHolder->_instance = pipeline;
-                resolve([pipelineHolder](jsi::Runtime &runtime) mutable {
-                  return margelo::
-                      JSIConverter<std::shared_ptr<GPURenderPipeline>>::toJSI(
-                          runtime, pipelineHolder);
-                });
-              } else {
-                std::string error =
-                    msg ? std::string(msg) : "Failed to create render pipeline";
-                reject(std::move(error));
-              }
+  return _async->postTask([device = _instance, desc, descriptor,
+                           pipelineHolder](
+                              const async::AsyncTaskHandle::ResolveFunction
+                                  &resolve,
+                              const async::AsyncTaskHandle::RejectFunction
+                                  &reject) {
+    (void)descriptor;
+    device.CreateRenderPipelineAsync(
+        &desc, wgpu::CallbackMode::AllowProcessEvents,
+        [pipelineHolder, resolve,
+         reject](wgpu::CreatePipelineAsyncStatus status,
+                 wgpu::RenderPipeline pipeline, const char *msg) mutable {
+          if (status == wgpu::CreatePipelineAsyncStatus::Success && pipeline) {
+            pipelineHolder->_instance = pipeline;
+            resolve([pipelineHolder](jsi::Runtime &runtime) mutable {
+              return JSIConverter<std::shared_ptr<GPURenderPipeline>>::toJSI(
+                  runtime, pipelineHolder);
             });
-      });
+          } else {
+            std::string error =
+                msg ? std::string(msg) : "Failed to create render pipeline";
+            reject(std::move(error));
+          }
+        });
+  });
 }
 
 void GPUDevice::pushErrorScope(wgpu::ErrorFilter filter) {
@@ -323,47 +326,60 @@ void GPUDevice::pushErrorScope(wgpu::ErrorFilter filter) {
 async::AsyncTaskHandle GPUDevice::popErrorScope() {
   auto device = _instance;
 
-  return _async->postTask(
-      [device](const async::AsyncTaskHandle::ResolveFunction &resolve,
-               const async::AsyncTaskHandle::RejectFunction &reject) {
-        device.PopErrorScope(
-            wgpu::CallbackMode::AllowProcessEvents,
-            [resolve, reject](wgpu::PopErrorScopeStatus status,
-                              wgpu::ErrorType type, wgpu::StringView message) {
-              if (status == wgpu::PopErrorScopeStatus::Error ||
-                  status == wgpu::PopErrorScopeStatus::CallbackCancelled) {
-                reject("PopErrorScope failed");
-                return;
-              }
-
-              std::variant<std::nullptr_t, std::shared_ptr<GPUError>> result =
-                  nullptr;
-
-              switch (type) {
-              case wgpu::ErrorType::NoError:
-                break;
-              case wgpu::ErrorType::OutOfMemory:
-              case wgpu::ErrorType::Validation:
-              case wgpu::ErrorType::Internal:
-              case wgpu::ErrorType::Unknown: {
-                std::string messageString =
-                    message.length ? std::string(message.data, message.length)
-                                   : "";
-                result = std::make_shared<GPUError>(type, messageString);
-                break;
-              }
-              default:
-                reject("Unhandled GPU error type");
-                return;
-              }
-
-              resolve([result =
-                           std::move(result)](jsi::Runtime &runtime) mutable {
-                return margelo::JSIConverter<decltype(result)>::toJSI(runtime,
-                                                                      result);
-              });
+  return _async->postTask([device](const async::AsyncTaskHandle::ResolveFunction
+                                       &resolve,
+                                   const async::AsyncTaskHandle::RejectFunction
+                                       &reject) {
+    device.PopErrorScope(
+        wgpu::CallbackMode::AllowProcessEvents,
+        [resolve, reject](wgpu::PopErrorScopeStatus status,
+                          wgpu::ErrorType type, wgpu::StringView message) {
+          if (status == wgpu::PopErrorScopeStatus::Error ||
+              status == wgpu::PopErrorScopeStatus::CallbackCancelled) {
+            reject("PopErrorScope failed");
+            return;
+          }
+
+          std::string messageString =
+              message.length ? std::string(message.data, message.length) : "";
+
+          switch (type) {
+          case wgpu::ErrorType::NoError:
+            resolve([](jsi::Runtime &runtime) mutable {
+              return jsi::Value::null();
             });
-      });
+            break;
+          case wgpu::ErrorType::Validation: {
+            auto error = std::make_shared<GPUValidationError>(messageString);
+            resolve([error](jsi::Runtime &runtime) mutable {
+              return JSIConverter<std::shared_ptr<GPUValidationError>>::toJSI(
+                  runtime, error);
+            });
+            break;
+          }
+          case wgpu::ErrorType::OutOfMemory: {
+            auto error = std::make_shared<GPUOutOfMemoryError>(messageString);
+            resolve([error](jsi::Runtime &runtime) mutable {
+              return JSIConverter<std::shared_ptr<GPUOutOfMemoryError>>::toJSI(
+                  runtime, error);
+            });
+            break;
+          }
+          case wgpu::ErrorType::Internal:
+          case wgpu::ErrorType::Unknown: {
+            auto error = std::make_shared<GPUInternalError>(messageString);
+            resolve([error](jsi::Runtime &runtime) mutable {
+              return JSIConverter<std::shared_ptr<GPUInternalError>>::toJSI(
+                  runtime, error);
+            });
+            break;
+          }
+          default:
+            reject("Unhandled GPU error type");
+            return;
+          }
+        });
+  });
 }
 
 std::unordered_set<std::string> GPUDevice::getFeatures() {
@@ -390,8 +406,8 @@ async::AsyncTaskHandle GPUDevice::getLost() {
             const async::AsyncTaskHandle::ResolveFunction &resolve,
             const async::AsyncTaskHandle::RejectFunction & /*reject*/) {
           resolve([info](jsi::Runtime &runtime) mutable {
-            return margelo::JSIConverter<
-                std::shared_ptr<GPUDeviceLostInfo>>::toJSI(runtime, info);
+            return JSIConverter<std::shared_ptr<GPUDeviceLostInfo>>::toJSI(
+                runtime, info);
           });
         },
         false);
@@ -402,8 +418,8 @@ async::AsyncTaskHandle GPUDevice::getLost() {
              const async::AsyncTaskHandle::RejectFunction & /*reject*/) {
         if (_lostSettled && _lostInfo) {
           resolve([info = _lostInfo](jsi::Runtime &runtime) mutable {
-            return margelo::JSIConverter<
-                std::shared_ptr<GPUDeviceLostInfo>>::toJSI(runtime, info);
+            return JSIConverter<std::shared_ptr<GPUDeviceLostInfo>>::toJSI(
+                runtime, info);
           });
           return;
         }

package/cpp/rnwgpu/api/GPUDevice.h

@@ -9,7 +9,7 @@
 
 #include "Unions.h"
 
-#include "RNFHybridObject.h"
+#include "NativeObject.h"
 
 #include "rnwgpu/async/AsyncRunner.h"
 #include "rnwgpu/async/AsyncTaskHandle.h"
@@ -49,18 +49,20 @@
 
 namespace rnwgpu {
 
-namespace m = margelo;
+namespace jsi = facebook::jsi;
 
-class GPUDevice : public m::HybridObject {
+class GPUDevice : public NativeObject<GPUDevice> {
 public:
+  static constexpr const char *CLASS_NAME = "GPUDevice";
+
   explicit GPUDevice(wgpu::Device instance,
                      std::shared_ptr<async::AsyncRunner> async,
                      std::string label)
-      : HybridObject("GPUDevice"), _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 destroy();
   std::shared_ptr<GPUBuffer>
@@ -109,44 +111,50 @@ public:
     _instance.SetLabel(_label.c_str());
   }
 
-  void loadHybridMethods() override {
-    registerHybridGetter("__brand", &GPUDevice::getBrand, this);
-    registerHybridMethod("destroy", &GPUDevice::destroy, this);
-    registerHybridMethod("createBuffer", &GPUDevice::createBuffer, this);
-    registerHybridMethod("createTexture", &GPUDevice::createTexture, this);
-    registerHybridMethod("createSampler", &GPUDevice::createSampler, this);
-    registerHybridMethod("importExternalTexture",
-                         &GPUDevice::importExternalTexture, this);
-    registerHybridMethod("createBindGroupLayout",
-                         &GPUDevice::createBindGroupLayout, this);
-    registerHybridMethod("createPipelineLayout",
-                         &GPUDevice::createPipelineLayout, this);
-    registerHybridMethod("createBindGroup", &GPUDevice::createBindGroup, this);
-    registerHybridMethod("createShaderModule", &GPUDevice::createShaderModule,
-                         this);
-    registerHybridMethod("createComputePipeline",
-                         &GPUDevice::createComputePipeline, this);
-    registerHybridMethod("createRenderPipeline",
-                         &GPUDevice::createRenderPipeline, this);
-    registerHybridMethod("createComputePipelineAsync",
-                         &GPUDevice::createComputePipelineAsync, this);
-    registerHybridMethod("createRenderPipelineAsync",
-                         &GPUDevice::createRenderPipelineAsync, this);
-    registerHybridMethod("createCommandEncoder",
-                         &GPUDevice::createCommandEncoder, this);
-    registerHybridMethod("createRenderBundleEncoder",
-                         &GPUDevice::createRenderBundleEncoder, this);
-    registerHybridMethod("createQuerySet", &GPUDevice::createQuerySet, this);
-    registerHybridMethod("pushErrorScope", &GPUDevice::pushErrorScope, this);
-    registerHybridMethod("popErrorScope", &GPUDevice::popErrorScope, this);
-    registerHybridGetter("features", &GPUDevice::getFeatures, this);
-    registerHybridGetter("limits", &GPUDevice::getLimits, this);
-    registerHybridGetter("queue", &GPUDevice::getQueue, this);
-    registerHybridGetter("lost", &GPUDevice::getLost, this);
-    registerHybridGetter("label", &GPUDevice::getLabel, this);
-    registerHybridSetter("label", &GPUDevice::setLabel, this);
-    registerHybridMethod("forceLossForTesting", &GPUDevice::forceLossForTesting,
-                         this);
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installGetter(runtime, prototype, "__brand", &GPUDevice::getBrand);
+    installMethod(runtime, prototype, "destroy", &GPUDevice::destroy);
+    installMethod(runtime, prototype, "createBuffer", &GPUDevice::createBuffer);
+    installMethod(runtime, prototype, "createTexture",
+                  &GPUDevice::createTexture);
+    installMethod(runtime, prototype, "createSampler",
+                  &GPUDevice::createSampler);
+    installMethod(runtime, prototype, "importExternalTexture",
+                  &GPUDevice::importExternalTexture);
+    installMethod(runtime, prototype, "createBindGroupLayout",
+                  &GPUDevice::createBindGroupLayout);
+    installMethod(runtime, prototype, "createPipelineLayout",
+                  &GPUDevice::createPipelineLayout);
+    installMethod(runtime, prototype, "createBindGroup",
+                  &GPUDevice::createBindGroup);
+    installMethod(runtime, prototype, "createShaderModule",
+                  &GPUDevice::createShaderModule);
+    installMethod(runtime, prototype, "createComputePipeline",
+                  &GPUDevice::createComputePipeline);
+    installMethod(runtime, prototype, "createRenderPipeline",
+                  &GPUDevice::createRenderPipeline);
+    installMethod(runtime, prototype, "createComputePipelineAsync",
+                  &GPUDevice::createComputePipelineAsync);
+    installMethod(runtime, prototype, "createRenderPipelineAsync",
+                  &GPUDevice::createRenderPipelineAsync);
+    installMethod(runtime, prototype, "createCommandEncoder",
+                  &GPUDevice::createCommandEncoder);
+    installMethod(runtime, prototype, "createRenderBundleEncoder",
+                  &GPUDevice::createRenderBundleEncoder);
+    installMethod(runtime, prototype, "createQuerySet",
+                  &GPUDevice::createQuerySet);
+    installMethod(runtime, prototype, "pushErrorScope",
+                  &GPUDevice::pushErrorScope);
+    installMethod(runtime, prototype, "popErrorScope",
+                  &GPUDevice::popErrorScope);
+    installGetter(runtime, prototype, "features", &GPUDevice::getFeatures);
+    installGetter(runtime, prototype, "limits", &GPUDevice::getLimits);
+    installGetter(runtime, prototype, "queue", &GPUDevice::getQueue);
+    installGetter(runtime, prototype, "lost", &GPUDevice::getLost);
+    installGetterSetter(runtime, prototype, "label", &GPUDevice::getLabel,
+                        &GPUDevice::setLabel);
+    installMethod(runtime, prototype, "forceLossForTesting",
+                  &GPUDevice::forceLossForTesting);
   }
 
   inline const wgpu::Device get() { return _instance; }

package/cpp/rnwgpu/api/GPUDeviceLostInfo.h

@@ -4,30 +4,32 @@
 
 #include "Unions.h"
 
-#include "RNFHybridObject.h"
+#include "NativeObject.h"
 
 #include "webgpu/webgpu_cpp.h"
 
 namespace rnwgpu {
 
-namespace m = margelo;
+namespace jsi = facebook::jsi;
 
-class GPUDeviceLostInfo : public m::HybridObject {
+class GPUDeviceLostInfo : public NativeObject<GPUDeviceLostInfo> {
 public:
+  static constexpr const char *CLASS_NAME = "GPUDeviceLostInfo";
+
   explicit GPUDeviceLostInfo(wgpu::DeviceLostReason reason, std::string message)
-      : HybridObject("GPUDeviceLostInfo"), _reason(reason), _message(message) {}
+      : NativeObject(CLASS_NAME), _reason(reason), _message(message) {}
 
 public:
-  std::string getBrand() { return _name; }
+  std::string getBrand() { return CLASS_NAME; }
 
   wgpu::DeviceLostReason getReason() { return _reason; }
   std::string getMessage() { return _message; }
 
-  void loadHybridMethods() override {
-    registerHybridGetter("__brand", &GPUDeviceLostInfo::getBrand, this);
-
-    registerHybridGetter("reason", &GPUDeviceLostInfo::getReason, this);
-    registerHybridGetter("message", &GPUDeviceLostInfo::getMessage, this);
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installGetter(runtime, prototype, "__brand", &GPUDeviceLostInfo::getBrand);
+    installGetter(runtime, prototype, "reason", &GPUDeviceLostInfo::getReason);
+    installGetter(runtime, prototype, "message",
+                  &GPUDeviceLostInfo::getMessage);
   }
 
 private:

package/cpp/rnwgpu/api/GPUError.h

@@ -1,45 +1,35 @@
 #pragma once
 
-#include <memory>
 #include <string>
-#include <utility>
 
-#include "webgpu/webgpu_cpp.h"
-
-#include "RNFEnumMapper.h"
-#include "RNFJSIConverter.h"
+#include "NativeObject.h"
 
 namespace rnwgpu {
 
-class GPUError {
+namespace jsi = facebook::jsi;
 
+class GPUError : public NativeObject<GPUError> {
 public:
-  GPUError(wgpu::ErrorType aType, std::string aMessage)
-      : type(aType), message(std::move(aMessage)) {}
+  static constexpr const char *CLASS_NAME = "GPUError";
 
-  wgpu::ErrorType type;
-  std::string message;
-};
+  explicit GPUError(std::string message)
+      : NativeObject(CLASS_NAME), _message(std::move(message)) {}
 
-} // namespace rnwgpu
+public:
+  std::string getBrand() { return CLASS_NAME; }
+  std::string getMessage() { return _message; }
 
-namespace margelo {
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installGetter(runtime, prototype, "__brand", &GPUError::getBrand);
+    installGetter(runtime, prototype, "message", &GPUError::getMessage);
+  }
 
-using namespace rnwgpu; // NOLINT(build/namespaces)
+protected:
+  // Protected constructor for subclasses
+  GPUError(const char *className, std::string message)
+      : NativeObject(className), _message(std::move(message)) {}
 
-template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUError>> {
-  static std::shared_ptr<rnwgpu::GPUBindGroupEntry>
-  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
-    throw std::runtime_error("Invalid GPUBindGroupEntry::fromJSI()");
-  }
-  static jsi::Value toJSI(jsi::Runtime &runtime,
-                          std::shared_ptr<rnwgpu::GPUError> arg) {
-    jsi::Object result(runtime);
-    result.setProperty(
-        runtime, "message",
-        jsi::String::createFromUtf8(runtime, arg->message.c_str()));
-    return result;
-  }
+  std::string _message;
 };
 
-} // namespace margelo
+} // namespace rnwgpu