react-native-wgpu 0.4.1 → 0.5.0

package/cpp/rnwgpu/api/GPUAdapter.h

@@ -6,7 +6,7 @@
 
 #include "Unions.h"
 
-#include "RNFHybridObject.h"
+#include "NativeObject.h"
 
 #include "rnwgpu/async/AsyncRunner.h"
 #include "rnwgpu/async/AsyncTaskHandle.h"
@@ -20,16 +20,18 @@
 
 namespace rnwgpu {
 
-namespace m = margelo;
+namespace jsi = facebook::jsi;
 
-class GPUAdapter : public m::HybridObject {
+class GPUAdapter : public NativeObject<GPUAdapter> {
 public:
+  static constexpr const char *CLASS_NAME = "GPUAdapter";
+
   explicit GPUAdapter(wgpu::Adapter instance,
                       std::shared_ptr<async::AsyncRunner> async)
-      : HybridObject("GPUAdapter"), _instance(instance), _async(async) {}
+      : NativeObject(CLASS_NAME), _instance(instance), _async(async) {}
 
 public:
-  std::string getBrand() { return _name; }
+  std::string getBrand() { return CLASS_NAME; }
 
   async::AsyncTaskHandle
   requestDevice(std::optional<std::shared_ptr<GPUDeviceDescriptor>> descriptor);
@@ -38,12 +40,13 @@ public:
   std::shared_ptr<GPUSupportedLimits> getLimits();
   std::shared_ptr<GPUAdapterInfo> getInfo();
 
-  void loadHybridMethods() override {
-    registerHybridGetter("__brand", &GPUAdapter::getBrand, this);
-    registerHybridMethod("requestDevice", &GPUAdapter::requestDevice, this);
-    registerHybridGetter("features", &GPUAdapter::getFeatures, this);
-    registerHybridGetter("limits", &GPUAdapter::getLimits, this);
-    registerHybridGetter("info", &GPUAdapter::getInfo, this);
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installGetter(runtime, prototype, "__brand", &GPUAdapter::getBrand);
+    installMethod(runtime, prototype, "requestDevice",
+                  &GPUAdapter::requestDevice);
+    installGetter(runtime, prototype, "features", &GPUAdapter::getFeatures);
+    installGetter(runtime, prototype, "limits", &GPUAdapter::getLimits);
+    installGetter(runtime, prototype, "info", &GPUAdapter::getInfo);
   }
 
   inline const wgpu::Adapter get() { return _instance; }

package/cpp/rnwgpu/api/GPUAdapterInfo.h

@@ -5,7 +5,7 @@
 
 #include "Unions.h"
 
-#include "RNFHybridObject.h"
+#include "NativeObject.h"
 
 #include "Convertors.h"
 
@@ -13,18 +13,20 @@
 
 namespace rnwgpu {
 
-namespace m = margelo;
+namespace jsi = facebook::jsi;
 
-class GPUAdapterInfo : public m::HybridObject {
+class GPUAdapterInfo : public NativeObject<GPUAdapterInfo> {
 public:
+  static constexpr const char *CLASS_NAME = "GPUAdapterInfo";
+
   explicit GPUAdapterInfo(wgpu::AdapterInfo &info)
-      : HybridObject("GPUAdapterInfo"), _vendor(info.vendor),
+      : NativeObject(CLASS_NAME), _vendor(info.vendor),
         _architecture(info.architecture), _device(info.device),
         _description(info.description),
         _isFallbackAdapter(info.adapterType == wgpu::AdapterType::CPU) {}
 
 public:
-  std::string getBrand() { return _name; }
+  std::string getBrand() { return CLASS_NAME; }
 
   std::string getVendor() { return _vendor; }
   std::string getArchitecture() { return _architecture; }
@@ -32,16 +34,16 @@ public:
   std::string getDescription() { return _description; }
   bool getIsFallbackAdapter() { return _isFallbackAdapter; }
 
-  void loadHybridMethods() override {
-    registerHybridGetter("__brand", &GPUAdapterInfo::getBrand, this);
-
-    registerHybridGetter("vendor", &GPUAdapterInfo::getVendor, this);
-    registerHybridGetter("architecture", &GPUAdapterInfo::getArchitecture,
-                         this);
-    registerHybridGetter("device", &GPUAdapterInfo::getDevice, this);
-    registerHybridGetter("description", &GPUAdapterInfo::getDescription, this);
-    registerHybridGetter("isFallbackAdapter",
-                         &GPUAdapterInfo::getIsFallbackAdapter, this);
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installGetter(runtime, prototype, "__brand", &GPUAdapterInfo::getBrand);
+    installGetter(runtime, prototype, "vendor", &GPUAdapterInfo::getVendor);
+    installGetter(runtime, prototype, "architecture",
+                  &GPUAdapterInfo::getArchitecture);
+    installGetter(runtime, prototype, "device", &GPUAdapterInfo::getDevice);
+    installGetter(runtime, prototype, "description",
+                  &GPUAdapterInfo::getDescription);
+    installGetter(runtime, prototype, "isFallbackAdapter",
+                  &GPUAdapterInfo::getIsFallbackAdapter);
   }
 
 private:

package/cpp/rnwgpu/api/GPUBindGroup.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 GPUBindGroup : public m::HybridObject {
+class GPUBindGroup : public NativeObject<GPUBindGroup> {
 public:
+  static constexpr const char *CLASS_NAME = "GPUBindGroup";
+
   explicit GPUBindGroup(wgpu::BindGroup instance, std::string label)
-      : HybridObject("GPUBindGroup"), _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", &GPUBindGroup::getBrand, this);
-
-    registerHybridGetter("label", &GPUBindGroup::getLabel, this);
-    registerHybridSetter("label", &GPUBindGroup::setLabel, this);
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installGetter(runtime, prototype, "__brand", &GPUBindGroup::getBrand);
+    installGetterSetter(runtime, prototype, "label", &GPUBindGroup::getLabel,
+                        &GPUBindGroup::setLabel);
   }
 
   inline const wgpu::BindGroup get() { return _instance; }

package/cpp/rnwgpu/api/GPUBindGroupLayout.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 GPUBindGroupLayout : public m::HybridObject {
+class GPUBindGroupLayout : public NativeObject<GPUBindGroupLayout> {
 public:
+  static constexpr const char *CLASS_NAME = "GPUBindGroupLayout";
+
   explicit GPUBindGroupLayout(wgpu::BindGroupLayout instance, std::string label)
-      : HybridObject("GPUBindGroupLayout"), _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", &GPUBindGroupLayout::getBrand, this);
-
-    registerHybridGetter("label", &GPUBindGroupLayout::getLabel, this);
-    registerHybridSetter("label", &GPUBindGroupLayout::setLabel, this);
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installGetter(runtime, prototype, "__brand", &GPUBindGroupLayout::getBrand);
+    installGetterSetter(runtime, prototype, "label",
+                        &GPUBindGroupLayout::getLabel,
+                        &GPUBindGroupLayout::setLabel);
   }
 
   inline const wgpu::BindGroupLayout get() { return _instance; }

package/cpp/rnwgpu/api/GPUBuffer.h

@@ -7,7 +7,7 @@
 
 #include "Unions.h"
 
-#include "RNFHybridObject.h"
+#include "NativeObject.h"
 
 #include "rnwgpu/async/AsyncRunner.h"
 #include "rnwgpu/async/AsyncTaskHandle.h"
@@ -18,18 +18,20 @@
 
 namespace rnwgpu {
 
-namespace m = margelo;
+namespace jsi = facebook::jsi;
 
-class GPUBuffer : public m::HybridObject {
+class GPUBuffer : public NativeObject<GPUBuffer> {
 public:
+  static constexpr const char *CLASS_NAME = "GPUBuffer";
+
   explicit GPUBuffer(wgpu::Buffer instance,
                      std::shared_ptr<async::AsyncRunner> async,
                      std::string label)
-      : HybridObject("GPUBuffer"), _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; }
 
   async::AsyncTaskHandle mapAsync(uint64_t modeIn,
                                   std::optional<uint64_t> offset,
@@ -49,17 +51,18 @@ public:
     _instance.SetLabel(_label.c_str());
   }
 
-  void loadHybridMethods() override {
-    registerHybridGetter("__brand", &GPUBuffer::getBrand, this);
-    registerHybridMethod("mapAsync", &GPUBuffer::mapAsync, this);
-    registerHybridMethod("getMappedRange", &GPUBuffer::getMappedRange, this);
-    registerHybridMethod("unmap", &GPUBuffer::unmap, this);
-    registerHybridMethod("destroy", &GPUBuffer::destroy, this);
-    registerHybridGetter("size", &GPUBuffer::getSize, this);
-    registerHybridGetter("usage", &GPUBuffer::getUsage, this);
-    registerHybridGetter("mapState", &GPUBuffer::getMapState, this);
-    registerHybridGetter("label", &GPUBuffer::getLabel, this);
-    registerHybridSetter("label", &GPUBuffer::setLabel, this);
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installGetter(runtime, prototype, "__brand", &GPUBuffer::getBrand);
+    installMethod(runtime, prototype, "mapAsync", &GPUBuffer::mapAsync);
+    installMethod(runtime, prototype, "getMappedRange",
+                  &GPUBuffer::getMappedRange);
+    installMethod(runtime, prototype, "unmap", &GPUBuffer::unmap);
+    installMethod(runtime, prototype, "destroy", &GPUBuffer::destroy);
+    installGetter(runtime, prototype, "size", &GPUBuffer::getSize);
+    installGetter(runtime, prototype, "usage", &GPUBuffer::getUsage);
+    installGetter(runtime, prototype, "mapState", &GPUBuffer::getMapState);
+    installGetterSetter(runtime, prototype, "label", &GPUBuffer::getLabel,
+                        &GPUBuffer::setLabel);
   }
 
   inline const wgpu::Buffer get() { return _instance; }

package/cpp/rnwgpu/api/GPUCanvasContext.h

@@ -8,7 +8,7 @@
 
 #include "webgpu/webgpu_cpp.h"
 
-#include "RNFHybridObject.h"
+#include "NativeObject.h"
 
 #include "Canvas.h"
 #include "GPU.h"
@@ -18,13 +18,15 @@
 
 namespace rnwgpu {
 
-namespace m = margelo;
+namespace jsi = facebook::jsi;
 
-class GPUCanvasContext : public m::HybridObject {
+class GPUCanvasContext : public NativeObject<GPUCanvasContext> {
 public:
+  static constexpr const char *CLASS_NAME = "GPUCanvasContext";
+
   GPUCanvasContext(std::shared_ptr<GPU> gpu, int contextId, int width,
                    int height)
-      : HybridObject("GPUCanvasContext"), _gpu(std::move(gpu)) {
+      : NativeObject(CLASS_NAME), _gpu(std::move(gpu)) {
     _canvas = std::make_shared<Canvas>(nullptr, width, height);
     auto &registry = rnwgpu::SurfaceRegistry::getInstance();
     _surfaceInfo =
@@ -32,18 +34,20 @@ public:
   }
 
 public:
-  std::string getBrand() { return _name; }
+  std::string getBrand() { return CLASS_NAME; }
 
   std::shared_ptr<Canvas> getCanvas() { return _canvas; }
 
-  void loadHybridMethods() override {
-    registerHybridGetter("__brand", &GPUCanvasContext::getBrand, this);
-    registerHybridGetter("canvas", &GPUCanvasContext::getCanvas, this);
-    registerHybridMethod("configure", &GPUCanvasContext::configure, this);
-    registerHybridMethod("unconfigure", &GPUCanvasContext::unconfigure, this);
-    registerHybridMethod("getCurrentTexture",
-                         &GPUCanvasContext::getCurrentTexture, this);
-    registerHybridMethod("present", &GPUCanvasContext::present, this);
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installGetter(runtime, prototype, "__brand", &GPUCanvasContext::getBrand);
+    installGetter(runtime, prototype, "canvas", &GPUCanvasContext::getCanvas);
+    installMethod(runtime, prototype, "configure",
+                  &GPUCanvasContext::configure);
+    installMethod(runtime, prototype, "unconfigure",
+                  &GPUCanvasContext::unconfigure);
+    installMethod(runtime, prototype, "getCurrentTexture",
+                  &GPUCanvasContext::getCurrentTexture);
+    installMethod(runtime, prototype, "present", &GPUCanvasContext::present);
   }
 
   // TODO: is this ok?

package/cpp/rnwgpu/api/GPUCommandBuffer.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 GPUCommandBuffer : public m::HybridObject {
+class GPUCommandBuffer : public NativeObject<GPUCommandBuffer> {
 public:
+  static constexpr const char *CLASS_NAME = "GPUCommandBuffer";
+
   explicit GPUCommandBuffer(wgpu::CommandBuffer instance, std::string label)
-      : HybridObject("GPUCommandBuffer"), _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", &GPUCommandBuffer::getBrand, this);
-
-    registerHybridGetter("label", &GPUCommandBuffer::getLabel, this);
-    registerHybridSetter("label", &GPUCommandBuffer::setLabel, this);
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installGetter(runtime, prototype, "__brand", &GPUCommandBuffer::getBrand);
+    installGetterSetter(runtime, prototype, "label",
+                        &GPUCommandBuffer::getLabel,
+                        &GPUCommandBuffer::setLabel);
   }
 
   inline const wgpu::CommandBuffer get() { return _instance; }

package/cpp/rnwgpu/api/GPUCommandEncoder.h

@@ -5,7 +5,7 @@
 
 #include "Unions.h"
 
-#include "RNFHybridObject.h"
+#include "NativeObject.h"
 
 #include "webgpu/webgpu_cpp.h"
 
@@ -23,15 +23,17 @@
 
 namespace rnwgpu {
 
-namespace m = margelo;
+namespace jsi = facebook::jsi;
 
-class GPUCommandEncoder : public m::HybridObject {
+class GPUCommandEncoder : public NativeObject<GPUCommandEncoder> {
 public:
+  static constexpr const char *CLASS_NAME = "GPUCommandEncoder";
+
   explicit GPUCommandEncoder(wgpu::CommandEncoder instance, std::string label)
-      : HybridObject("GPUCommandEncoder"), _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<GPURenderPassEncoder>
   beginRenderPass(std::shared_ptr<GPURenderPassDescriptor> descriptor);
@@ -69,33 +71,34 @@ public:
     _instance.SetLabel(_label.c_str());
   }
 
-  void loadHybridMethods() override {
-    registerHybridGetter("__brand", &GPUCommandEncoder::getBrand, this);
-    registerHybridMethod("beginRenderPass", &GPUCommandEncoder::beginRenderPass,
-                         this);
-    registerHybridMethod("beginComputePass",
-                         &GPUCommandEncoder::beginComputePass, this);
-    registerHybridMethod("copyBufferToBuffer",
-                         &GPUCommandEncoder::copyBufferToBuffer, this);
-    registerHybridMethod("copyBufferToTexture",
-                         &GPUCommandEncoder::copyBufferToTexture, this);
-    registerHybridMethod("copyTextureToBuffer",
-                         &GPUCommandEncoder::copyTextureToBuffer, this);
-    registerHybridMethod("copyTextureToTexture",
-                         &GPUCommandEncoder::copyTextureToTexture, this);
-    registerHybridMethod("clearBuffer", &GPUCommandEncoder::clearBuffer, this);
-    registerHybridMethod("resolveQuerySet", &GPUCommandEncoder::resolveQuerySet,
-                         this);
-    registerHybridMethod("finish", &GPUCommandEncoder::finish, this);
-    registerHybridMethod("pushDebugGroup", &GPUCommandEncoder::pushDebugGroup,
-                         this);
-    registerHybridMethod("popDebugGroup", &GPUCommandEncoder::popDebugGroup,
-                         this);
-    registerHybridMethod("insertDebugMarker",
-                         &GPUCommandEncoder::insertDebugMarker, this);
-
-    registerHybridGetter("label", &GPUCommandEncoder::getLabel, this);
-    registerHybridSetter("label", &GPUCommandEncoder::setLabel, this);
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installGetter(runtime, prototype, "__brand", &GPUCommandEncoder::getBrand);
+    installMethod(runtime, prototype, "beginRenderPass",
+                  &GPUCommandEncoder::beginRenderPass);
+    installMethod(runtime, prototype, "beginComputePass",
+                  &GPUCommandEncoder::beginComputePass);
+    installMethod(runtime, prototype, "copyBufferToBuffer",
+                  &GPUCommandEncoder::copyBufferToBuffer);
+    installMethod(runtime, prototype, "copyBufferToTexture",
+                  &GPUCommandEncoder::copyBufferToTexture);
+    installMethod(runtime, prototype, "copyTextureToBuffer",
+                  &GPUCommandEncoder::copyTextureToBuffer);
+    installMethod(runtime, prototype, "copyTextureToTexture",
+                  &GPUCommandEncoder::copyTextureToTexture);
+    installMethod(runtime, prototype, "clearBuffer",
+                  &GPUCommandEncoder::clearBuffer);
+    installMethod(runtime, prototype, "resolveQuerySet",
+                  &GPUCommandEncoder::resolveQuerySet);
+    installMethod(runtime, prototype, "finish", &GPUCommandEncoder::finish);
+    installMethod(runtime, prototype, "pushDebugGroup",
+                  &GPUCommandEncoder::pushDebugGroup);
+    installMethod(runtime, prototype, "popDebugGroup",
+                  &GPUCommandEncoder::popDebugGroup);
+    installMethod(runtime, prototype, "insertDebugMarker",
+                  &GPUCommandEncoder::insertDebugMarker);
+    installGetterSetter(runtime, prototype, "label",
+                        &GPUCommandEncoder::getLabel,
+                        &GPUCommandEncoder::setLabel);
   }
 
   inline const wgpu::CommandEncoder get() { return _instance; }

package/cpp/rnwgpu/api/GPUCompilationInfo.h

@@ -5,15 +5,15 @@
 
 #include "Unions.h"
 
-#include "RNFHybridObject.h"
+#include "NativeObject.h"
 
 #include "webgpu/webgpu_cpp.h"
 
 namespace rnwgpu {
 
-namespace m = margelo;
+namespace jsi = facebook::jsi;
 
-struct GPUCompilationMessage {
+struct GPUCompilationMessageData {
   std::string message;
   wgpu::CompilationMessageType type;
   uint64_t lineNum;
@@ -22,35 +22,35 @@ struct GPUCompilationMessage {
   uint64_t length;
 };
 
-class GPUCompilationInfo : public m::HybridObject {
+class GPUCompilationInfo : public NativeObject<GPUCompilationInfo> {
 public:
-  GPUCompilationInfo() : HybridObject("GPUCompilationInfo") {}
+  static constexpr const char *CLASS_NAME = "GPUCompilationInfo";
+
+  GPUCompilationInfo() : NativeObject(CLASS_NAME) {}
 
 public:
-  std::string getBrand() { return _name; }
+  std::string getBrand() { return CLASS_NAME; }
 
-  std::vector<GPUCompilationMessage> getMessages() { return _messages; }
+  std::vector<GPUCompilationMessageData> getMessages() { return _messages; }
 
-  void loadHybridMethods() override {
-    registerHybridGetter("__brand", &GPUCompilationInfo::getBrand, this);
-    registerHybridGetter("messages", &GPUCompilationInfo::getMessages, this);
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installGetter(runtime, prototype, "__brand", &GPUCompilationInfo::getBrand);
+    installGetter(runtime, prototype, "messages",
+                  &GPUCompilationInfo::getMessages);
   }
 
 private:
-  std::vector<GPUCompilationMessage> _messages;
+  std::vector<GPUCompilationMessageData> _messages;
   friend class GPUShaderModule;
 };
 
-} // namespace rnwgpu
-
-namespace margelo {
-template <> struct JSIConverter<std::vector<rnwgpu::GPUCompilationMessage>> {
-  static std::vector<rnwgpu::GPUCompilationMessage>
+template <> struct JSIConverter<std::vector<GPUCompilationMessageData>> {
+  static std::vector<GPUCompilationMessageData>
   fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
-    throw std::runtime_error("Invalid GPUCompilationMessage::fromJSI()");
+    throw std::runtime_error("Invalid GPUCompilationMessageData::fromJSI()");
   }
   static jsi::Value toJSI(jsi::Runtime &runtime,
-                          std::vector<rnwgpu::GPUCompilationMessage> arg) {
+                          std::vector<GPUCompilationMessageData> arg) {
     jsi::Array result = jsi::Array(runtime, arg.size());
     for (size_t i = 0; i < arg.size(); i++) {
       const auto &message = arg[i];
@@ -76,4 +76,4 @@ template <> struct JSIConverter<std::vector<rnwgpu::GPUCompilationMessage>> {
   }
 };
 
-} // namespace margelo
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUCompilationMessage.h

@@ -4,24 +4,27 @@
 
 #include "Unions.h"
 
-#include "RNFHybridObject.h"
+#include "NativeObject.h"
 
 #include "webgpu/webgpu_cpp.h"
 
 namespace rnwgpu {
 
-namespace m = margelo;
+namespace jsi = facebook::jsi;
 
-class GPUCompilationMessage : public m::HybridObject {
+class GPUCompilationMessage : public NativeObject<GPUCompilationMessage> {
 public:
+  static constexpr const char *CLASS_NAME = "GPUCompilationMessage";
+
   explicit GPUCompilationMessage(wgpu::CompilationMessage instance)
-      : HybridObject("GPUCompilationMessage"), _instance(instance) {}
+      : NativeObject(CLASS_NAME), _instance(instance) {}
 
 public:
-  std::string getBrand() { return _name; }
+  std::string getBrand() { return CLASS_NAME; }
 
-  void loadHybridMethods() override {
-    registerHybridGetter("__brand", &GPUCompilationMessage::getBrand, this);
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installGetter(runtime, prototype, "__brand",
+                  &GPUCompilationMessage::getBrand);
   }
 
   inline const wgpu::CompilationMessage get() { return _instance; }