react-native-wgpu 0.4.2 → 0.5.1

package/cpp/rnwgpu/api/GPURenderPassEncoder.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 GPURenderPassEncoder : public m::HybridObject {
+class GPURenderPassEncoder : public NativeObject<GPURenderPassEncoder> {
 public:
+  static constexpr const char *CLASS_NAME = "GPURenderPassEncoder";
+
   explicit GPURenderPassEncoder(wgpu::RenderPassEncoder instance,
                                 std::string label)
-      : HybridObject("GPURenderPassEncoder"), _instance(instance),
-        _label(label) {}
+      : NativeObject(CLASS_NAME), _instance(instance), _label(label) {}
 
 public:
-  std::string getBrand() { return _name; }
+  std::string getBrand() { return CLASS_NAME; }
 
   void setViewport(double x, double y, double width, double height,
                    double minDepth, double maxDepth);
@@ -75,47 +76,48 @@ public:
     _instance.SetLabel(_label.c_str());
   }
 
-  void loadHybridMethods() override {
-    registerHybridGetter("__brand", &GPURenderPassEncoder::getBrand, this);
-    registerHybridMethod("setViewport", &GPURenderPassEncoder::setViewport,
-                         this);
-    registerHybridMethod("setScissorRect",
-                         &GPURenderPassEncoder::setScissorRect, this);
-    registerHybridMethod("setBlendConstant",
-                         &GPURenderPassEncoder::setBlendConstant, this);
-    registerHybridMethod("setStencilReference",
-                         &GPURenderPassEncoder::setStencilReference, this);
-    registerHybridMethod("beginOcclusionQuery",
-                         &GPURenderPassEncoder::beginOcclusionQuery, this);
-    registerHybridMethod("endOcclusionQuery",
-                         &GPURenderPassEncoder::endOcclusionQuery, this);
-    registerHybridMethod("executeBundles",
-                         &GPURenderPassEncoder::executeBundles, this);
-    registerHybridMethod("end", &GPURenderPassEncoder::end, this);
-    registerHybridMethod("pushDebugGroup",
-                         &GPURenderPassEncoder::pushDebugGroup, this);
-    registerHybridMethod("popDebugGroup", &GPURenderPassEncoder::popDebugGroup,
-                         this);
-    registerHybridMethod("insertDebugMarker",
-                         &GPURenderPassEncoder::insertDebugMarker, this);
-    registerHybridMethod("setBindGroup", &GPURenderPassEncoder::setBindGroup,
-                         this);
-    registerHybridMethod("setPipeline", &GPURenderPassEncoder::setPipeline,
-                         this);
-    registerHybridMethod("setIndexBuffer",
-                         &GPURenderPassEncoder::setIndexBuffer, this);
-    registerHybridMethod("setVertexBuffer",
-                         &GPURenderPassEncoder::setVertexBuffer, this);
-    registerHybridMethod("draw", &GPURenderPassEncoder::draw, this);
-    registerHybridMethod("drawIndexed", &GPURenderPassEncoder::drawIndexed,
-                         this);
-    registerHybridMethod("drawIndirect", &GPURenderPassEncoder::drawIndirect,
-                         this);
-    registerHybridMethod("drawIndexedIndirect",
-                         &GPURenderPassEncoder::drawIndexedIndirect, this);
-
-    registerHybridGetter("label", &GPURenderPassEncoder::getLabel, this);
-    registerHybridSetter("label", &GPURenderPassEncoder::setLabel, this);
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installGetter(runtime, prototype, "__brand",
+                  &GPURenderPassEncoder::getBrand);
+    installMethod(runtime, prototype, "setViewport",
+                  &GPURenderPassEncoder::setViewport);
+    installMethod(runtime, prototype, "setScissorRect",
+                  &GPURenderPassEncoder::setScissorRect);
+    installMethod(runtime, prototype, "setBlendConstant",
+                  &GPURenderPassEncoder::setBlendConstant);
+    installMethod(runtime, prototype, "setStencilReference",
+                  &GPURenderPassEncoder::setStencilReference);
+    installMethod(runtime, prototype, "beginOcclusionQuery",
+                  &GPURenderPassEncoder::beginOcclusionQuery);
+    installMethod(runtime, prototype, "endOcclusionQuery",
+                  &GPURenderPassEncoder::endOcclusionQuery);
+    installMethod(runtime, prototype, "executeBundles",
+                  &GPURenderPassEncoder::executeBundles);
+    installMethod(runtime, prototype, "end", &GPURenderPassEncoder::end);
+    installMethod(runtime, prototype, "pushDebugGroup",
+                  &GPURenderPassEncoder::pushDebugGroup);
+    installMethod(runtime, prototype, "popDebugGroup",
+                  &GPURenderPassEncoder::popDebugGroup);
+    installMethod(runtime, prototype, "insertDebugMarker",
+                  &GPURenderPassEncoder::insertDebugMarker);
+    installMethod(runtime, prototype, "setBindGroup",
+                  &GPURenderPassEncoder::setBindGroup);
+    installMethod(runtime, prototype, "setPipeline",
+                  &GPURenderPassEncoder::setPipeline);
+    installMethod(runtime, prototype, "setIndexBuffer",
+                  &GPURenderPassEncoder::setIndexBuffer);
+    installMethod(runtime, prototype, "setVertexBuffer",
+                  &GPURenderPassEncoder::setVertexBuffer);
+    installMethod(runtime, prototype, "draw", &GPURenderPassEncoder::draw);
+    installMethod(runtime, prototype, "drawIndexed",
+                  &GPURenderPassEncoder::drawIndexed);
+    installMethod(runtime, prototype, "drawIndirect",
+                  &GPURenderPassEncoder::drawIndirect);
+    installMethod(runtime, prototype, "drawIndexedIndirect",
+                  &GPURenderPassEncoder::drawIndexedIndirect);
+    installGetterSetter(runtime, prototype, "label",
+                        &GPURenderPassEncoder::getLabel,
+                        &GPURenderPassEncoder::setLabel);
   }
 
   inline const wgpu::RenderPassEncoder get() { return _instance; }

package/cpp/rnwgpu/api/GPURenderPipeline.h

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

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

package/cpp/rnwgpu/api/GPUShaderModule.cpp

@@ -3,7 +3,7 @@
 #include <memory>
 #include <utility>
 
-#include "RNFJSIConverter.h"
+#include "JSIConverter.h"
 
 namespace rnwgpu {
 
@@ -28,7 +28,7 @@ async::AsyncTaskHandle GPUShaderModule::getCompilationInfo() {
               result->_messages.reserve(compilationInfo->messageCount);
               for (size_t i = 0; i < compilationInfo->messageCount; ++i) {
                 const auto &wgpuMessage = compilationInfo->messages[i];
-                GPUCompilationMessage message;
+                GPUCompilationMessageData message;
                 message.message =
                     wgpuMessage.message.length ? wgpuMessage.message.data : "";
                 message.type = wgpuMessage.type;
@@ -39,12 +39,11 @@ async::AsyncTaskHandle GPUShaderModule::getCompilationInfo() {
                 result->_messages.push_back(std::move(message));
               }
 
-              resolve(
-                  [result = std::move(result)](jsi::Runtime &runtime) mutable {
-                    return margelo::JSIConverter<
-                        std::shared_ptr<GPUCompilationInfo>>::toJSI(runtime,
-                                                                    result);
-                  });
+              resolve([result =
+                           std::move(result)](jsi::Runtime &runtime) mutable {
+                return JSIConverter<std::shared_ptr<GPUCompilationInfo>>::toJSI(
+                    runtime, result);
+              });
             });
       });
 }

package/cpp/rnwgpu/api/GPUShaderModule.h

@@ -5,7 +5,7 @@
 
 #include "Unions.h"
 
-#include "RNFHybridObject.h"
+#include "NativeObject.h"
 
 #include "rnwgpu/async/AsyncRunner.h"
 #include "rnwgpu/async/AsyncTaskHandle.h"
@@ -16,18 +16,20 @@
 
 namespace rnwgpu {
 
-namespace m = margelo;
+namespace jsi = facebook::jsi;
 
-class GPUShaderModule : public m::HybridObject {
+class GPUShaderModule : public NativeObject<GPUShaderModule> {
 public:
+  static constexpr const char *CLASS_NAME = "GPUShaderModule";
+
   explicit GPUShaderModule(wgpu::ShaderModule instance,
                            std::shared_ptr<async::AsyncRunner> async,
                            std::string label)
-      : HybridObject("GPUShaderModule"), _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 getCompilationInfo();
 
@@ -37,13 +39,12 @@ public:
     _instance.SetLabel(_label.c_str());
   }
 
-  void loadHybridMethods() override {
-    registerHybridGetter("__brand", &GPUShaderModule::getBrand, this);
-    registerHybridMethod("getCompilationInfo",
-                         &GPUShaderModule::getCompilationInfo, this);
-
-    registerHybridGetter("label", &GPUShaderModule::getLabel, this);
-    registerHybridSetter("label", &GPUShaderModule::setLabel, this);
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installGetter(runtime, prototype, "__brand", &GPUShaderModule::getBrand);
+    installMethod(runtime, prototype, "getCompilationInfo",
+                  &GPUShaderModule::getCompilationInfo);
+    installGetterSetter(runtime, prototype, "label", &GPUShaderModule::getLabel,
+                        &GPUShaderModule::setLabel);
   }
 
   inline const wgpu::ShaderModule get() { return _instance; }

package/cpp/rnwgpu/api/GPUSupportedLimits.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 GPUSupportedLimits : public m::HybridObject {
+class GPUSupportedLimits : public NativeObject<GPUSupportedLimits> {
 public:
+  static constexpr const char *CLASS_NAME = "GPUSupportedLimits";
+
   explicit GPUSupportedLimits(wgpu::Limits instance)
-      : HybridObject("GPUSupportedLimits"), _instance(instance) {}
+      : NativeObject(CLASS_NAME), _instance(instance) {}
 
 public:
-  std::string getBrand() { return _name; }
+  std::string getBrand() { return CLASS_NAME; }
 
   double getMaxTextureDimension1D();
   double getMaxTextureDimension2D();
@@ -52,94 +54,72 @@ public:
   double getMaxComputeWorkgroupSizeZ();
   double getMaxComputeWorkgroupsPerDimension();
 
-  void loadHybridMethods() override {
-    registerHybridGetter("__brand", &GPUSupportedLimits::getBrand, this);
-
-    registerHybridGetter("maxTextureDimension1D",
-                         &GPUSupportedLimits::getMaxTextureDimension1D, this);
-    registerHybridGetter("maxTextureDimension2D",
-                         &GPUSupportedLimits::getMaxTextureDimension2D, this);
-    registerHybridGetter("maxTextureDimension3D",
-                         &GPUSupportedLimits::getMaxTextureDimension3D, this);
-    registerHybridGetter("maxTextureArrayLayers",
-                         &GPUSupportedLimits::getMaxTextureArrayLayers, this);
-    registerHybridGetter("maxBindGroups", &GPUSupportedLimits::getMaxBindGroups,
-                         this);
-    registerHybridGetter("maxBindGroupsPlusVertexBuffers",
-                         &GPUSupportedLimits::getMaxBindGroupsPlusVertexBuffers,
-                         this);
-    registerHybridGetter("maxBindingsPerBindGroup",
-                         &GPUSupportedLimits::getMaxBindingsPerBindGroup, this);
-    registerHybridGetter(
-        "maxDynamicUniformBuffersPerPipelineLayout",
-        &GPUSupportedLimits::getMaxDynamicUniformBuffersPerPipelineLayout,
-        this);
-    registerHybridGetter(
-        "maxDynamicStorageBuffersPerPipelineLayout",
-        &GPUSupportedLimits::getMaxDynamicStorageBuffersPerPipelineLayout,
-        this);
-    registerHybridGetter(
-        "maxSampledTexturesPerShaderStage",
-        &GPUSupportedLimits::getMaxSampledTexturesPerShaderStage, this);
-    registerHybridGetter("maxSamplersPerShaderStage",
-                         &GPUSupportedLimits::getMaxSamplersPerShaderStage,
-                         this);
-    registerHybridGetter(
-        "maxStorageBuffersPerShaderStage",
-        &GPUSupportedLimits::getMaxStorageBuffersPerShaderStage, this);
-    registerHybridGetter(
-        "maxStorageTexturesPerShaderStage",
-        &GPUSupportedLimits::getMaxStorageTexturesPerShaderStage, this);
-    registerHybridGetter(
-        "maxUniformBuffersPerShaderStage",
-        &GPUSupportedLimits::getMaxUniformBuffersPerShaderStage, this);
-    registerHybridGetter("maxUniformBufferBindingSize",
-                         &GPUSupportedLimits::getMaxUniformBufferBindingSize,
-                         this);
-    registerHybridGetter("maxStorageBufferBindingSize",
-                         &GPUSupportedLimits::getMaxStorageBufferBindingSize,
-                         this);
-    registerHybridGetter(
-        "minUniformBufferOffsetAlignment",
-        &GPUSupportedLimits::getMinUniformBufferOffsetAlignment, this);
-    registerHybridGetter(
-        "minStorageBufferOffsetAlignment",
-        &GPUSupportedLimits::getMinStorageBufferOffsetAlignment, this);
-    registerHybridGetter("maxVertexBuffers",
-                         &GPUSupportedLimits::getMaxVertexBuffers, this);
-    registerHybridGetter("maxBufferSize", &GPUSupportedLimits::getMaxBufferSize,
-                         this);
-    registerHybridGetter("maxVertexAttributes",
-                         &GPUSupportedLimits::getMaxVertexAttributes, this);
-    registerHybridGetter("maxVertexBufferArrayStride",
-                         &GPUSupportedLimits::getMaxVertexBufferArrayStride,
-                         this);
-    registerHybridGetter("maxInterStageShaderVariables",
-                         &GPUSupportedLimits::getMaxInterStageShaderVariables,
-                         this);
-    registerHybridGetter("maxColorAttachments",
-                         &GPUSupportedLimits::getMaxColorAttachments, this);
-    registerHybridGetter(
-        "maxColorAttachmentBytesPerSample",
-        &GPUSupportedLimits::getMaxColorAttachmentBytesPerSample, this);
-    registerHybridGetter("maxComputeWorkgroupStorageSize",
-                         &GPUSupportedLimits::getMaxComputeWorkgroupStorageSize,
-                         this);
-    registerHybridGetter(
-        "maxComputeInvocationsPerWorkgroup",
-        &GPUSupportedLimits::getMaxComputeInvocationsPerWorkgroup, this);
-    registerHybridGetter("maxComputeWorkgroupSizeX",
-                         &GPUSupportedLimits::getMaxComputeWorkgroupSizeX,
-                         this);
-    registerHybridGetter("maxComputeWorkgroupSizeY",
-                         &GPUSupportedLimits::getMaxComputeWorkgroupSizeY,
-                         this);
-    registerHybridGetter("maxComputeWorkgroupSizeZ",
-                         &GPUSupportedLimits::getMaxComputeWorkgroupSizeZ,
-                         this);
-    registerHybridGetter(
-        "maxComputeWorkgroupsPerDimension",
-        &GPUSupportedLimits::getMaxComputeWorkgroupsPerDimension, this);
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installGetter(runtime, prototype, "__brand", &GPUSupportedLimits::getBrand);
+    installGetter(runtime, prototype, "maxTextureDimension1D",
+                  &GPUSupportedLimits::getMaxTextureDimension1D);
+    installGetter(runtime, prototype, "maxTextureDimension2D",
+                  &GPUSupportedLimits::getMaxTextureDimension2D);
+    installGetter(runtime, prototype, "maxTextureDimension3D",
+                  &GPUSupportedLimits::getMaxTextureDimension3D);
+    installGetter(runtime, prototype, "maxTextureArrayLayers",
+                  &GPUSupportedLimits::getMaxTextureArrayLayers);
+    installGetter(runtime, prototype, "maxBindGroups",
+                  &GPUSupportedLimits::getMaxBindGroups);
+    installGetter(runtime, prototype, "maxBindGroupsPlusVertexBuffers",
+                  &GPUSupportedLimits::getMaxBindGroupsPlusVertexBuffers);
+    installGetter(runtime, prototype, "maxBindingsPerBindGroup",
+                  &GPUSupportedLimits::getMaxBindingsPerBindGroup);
+    installGetter(
+        runtime, prototype, "maxDynamicUniformBuffersPerPipelineLayout",
+        &GPUSupportedLimits::getMaxDynamicUniformBuffersPerPipelineLayout);
+    installGetter(
+        runtime, prototype, "maxDynamicStorageBuffersPerPipelineLayout",
+        &GPUSupportedLimits::getMaxDynamicStorageBuffersPerPipelineLayout);
+    installGetter(runtime, prototype, "maxSampledTexturesPerShaderStage",
+                  &GPUSupportedLimits::getMaxSampledTexturesPerShaderStage);
+    installGetter(runtime, prototype, "maxSamplersPerShaderStage",
+                  &GPUSupportedLimits::getMaxSamplersPerShaderStage);
+    installGetter(runtime, prototype, "maxStorageBuffersPerShaderStage",
+                  &GPUSupportedLimits::getMaxStorageBuffersPerShaderStage);
+    installGetter(runtime, prototype, "maxStorageTexturesPerShaderStage",
+                  &GPUSupportedLimits::getMaxStorageTexturesPerShaderStage);
+    installGetter(runtime, prototype, "maxUniformBuffersPerShaderStage",
+                  &GPUSupportedLimits::getMaxUniformBuffersPerShaderStage);
+    installGetter(runtime, prototype, "maxUniformBufferBindingSize",
+                  &GPUSupportedLimits::getMaxUniformBufferBindingSize);
+    installGetter(runtime, prototype, "maxStorageBufferBindingSize",
+                  &GPUSupportedLimits::getMaxStorageBufferBindingSize);
+    installGetter(runtime, prototype, "minUniformBufferOffsetAlignment",
+                  &GPUSupportedLimits::getMinUniformBufferOffsetAlignment);
+    installGetter(runtime, prototype, "minStorageBufferOffsetAlignment",
+                  &GPUSupportedLimits::getMinStorageBufferOffsetAlignment);
+    installGetter(runtime, prototype, "maxVertexBuffers",
+                  &GPUSupportedLimits::getMaxVertexBuffers);
+    installGetter(runtime, prototype, "maxBufferSize",
+                  &GPUSupportedLimits::getMaxBufferSize);
+    installGetter(runtime, prototype, "maxVertexAttributes",
+                  &GPUSupportedLimits::getMaxVertexAttributes);
+    installGetter(runtime, prototype, "maxVertexBufferArrayStride",
+                  &GPUSupportedLimits::getMaxVertexBufferArrayStride);
+    installGetter(runtime, prototype, "maxInterStageShaderVariables",
+                  &GPUSupportedLimits::getMaxInterStageShaderVariables);
+    installGetter(runtime, prototype, "maxColorAttachments",
+                  &GPUSupportedLimits::getMaxColorAttachments);
+    installGetter(runtime, prototype, "maxColorAttachmentBytesPerSample",
+                  &GPUSupportedLimits::getMaxColorAttachmentBytesPerSample);
+    installGetter(runtime, prototype, "maxComputeWorkgroupStorageSize",
+                  &GPUSupportedLimits::getMaxComputeWorkgroupStorageSize);
+    installGetter(runtime, prototype, "maxComputeInvocationsPerWorkgroup",
+                  &GPUSupportedLimits::getMaxComputeInvocationsPerWorkgroup);
+    installGetter(runtime, prototype, "maxComputeWorkgroupSizeX",
+                  &GPUSupportedLimits::getMaxComputeWorkgroupSizeX);
+    installGetter(runtime, prototype, "maxComputeWorkgroupSizeY",
+                  &GPUSupportedLimits::getMaxComputeWorkgroupSizeY);
+    installGetter(runtime, prototype, "maxComputeWorkgroupSizeZ",
+                  &GPUSupportedLimits::getMaxComputeWorkgroupSizeZ);
+    installGetter(runtime, prototype, "maxComputeWorkgroupsPerDimension",
+                  &GPUSupportedLimits::getMaxComputeWorkgroupsPerDimension);
   }
 
   inline const wgpu::Limits get() { return _instance; }

package/cpp/rnwgpu/api/GPUTexture.h

@@ -6,7 +6,7 @@
 
 #include "Unions.h"
 
-#include "RNFHybridObject.h"
+#include "NativeObject.h"
 
 #include "webgpu/webgpu_cpp.h"
 
@@ -15,15 +15,17 @@
 
 namespace rnwgpu {
 
-namespace m = margelo;
+namespace jsi = facebook::jsi;
 
-class GPUTexture : public m::HybridObject {
+class GPUTexture : public NativeObject<GPUTexture> {
 public:
+  static constexpr const char *CLASS_NAME = "GPUTexture";
+
   explicit GPUTexture(wgpu::Texture instance, std::string label)
-      : HybridObject("GPUTexture"), _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<GPUTextureView> createView(
       std::optional<std::shared_ptr<GPUTextureViewDescriptor>> descriptor);
@@ -44,21 +46,23 @@ public:
     _instance.SetLabel(_label.c_str());
   }
 
-  void loadHybridMethods() override {
-    registerHybridGetter("__brand", &GPUTexture::getBrand, this);
-    registerHybridMethod("createView", &GPUTexture::createView, this);
-    registerHybridMethod("destroy", &GPUTexture::destroy, this);
-    registerHybridGetter("width", &GPUTexture::getWidth, this);
-    registerHybridGetter("height", &GPUTexture::getHeight, this);
-    registerHybridGetter("depthOrArrayLayers",
-                         &GPUTexture::getDepthOrArrayLayers, this);
-    registerHybridGetter("mipLevelCount", &GPUTexture::getMipLevelCount, this);
-    registerHybridGetter("sampleCount", &GPUTexture::getSampleCount, this);
-    registerHybridGetter("dimension", &GPUTexture::getDimension, this);
-    registerHybridGetter("format", &GPUTexture::getFormat, this);
-    registerHybridGetter("usage", &GPUTexture::getUsage, this);
-    registerHybridGetter("label", &GPUTexture::getLabel, this);
-    registerHybridSetter("label", &GPUTexture::setLabel, this);
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installGetter(runtime, prototype, "__brand", &GPUTexture::getBrand);
+    installMethod(runtime, prototype, "createView", &GPUTexture::createView);
+    installMethod(runtime, prototype, "destroy", &GPUTexture::destroy);
+    installGetter(runtime, prototype, "width", &GPUTexture::getWidth);
+    installGetter(runtime, prototype, "height", &GPUTexture::getHeight);
+    installGetter(runtime, prototype, "depthOrArrayLayers",
+                  &GPUTexture::getDepthOrArrayLayers);
+    installGetter(runtime, prototype, "mipLevelCount",
+                  &GPUTexture::getMipLevelCount);
+    installGetter(runtime, prototype, "sampleCount",
+                  &GPUTexture::getSampleCount);
+    installGetter(runtime, prototype, "dimension", &GPUTexture::getDimension);
+    installGetter(runtime, prototype, "format", &GPUTexture::getFormat);
+    installGetter(runtime, prototype, "usage", &GPUTexture::getUsage);
+    installGetterSetter(runtime, prototype, "label", &GPUTexture::getLabel,
+                        &GPUTexture::setLabel);
   }
 
   inline const wgpu::Texture get() { return _instance; }

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