react-native-wgpu 0.1.0 → 0.1.3

package/cpp/rnwgpu/api/GPUOrigin3D.h

@@ -0,0 +1,66 @@
+#pragma once
+
+#include <memory>
+
+#include "RNFJSIConverter.h"
+
+#include "webgpu/webgpu_cpp.h"
+
+namespace rnwgpu {
+
+struct GPUOrigin3D {
+  double x = 0;
+  double y = 0;
+  double z = 0;
+};
+
+} // namespace rnwgpu
+
+namespace margelo {
+
+template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUOrigin3D>> {
+  static std::shared_ptr<rnwgpu::GPUOrigin3D>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUOrigin3D>();
+    if (!outOfBounds && arg.isObject()) {
+      if (arg.getObject(runtime).isArray(runtime)) {
+        auto array = arg.getObject(runtime).asArray(runtime);
+        auto size = array.size(runtime);
+        if (size == 0) {
+          throw std::runtime_error(
+              "Expected an array of size >1 for GPUTExtent3D");
+        }
+        if (size > 0) {
+          result->x = array.getValueAtIndex(runtime, 0).asNumber();
+        }
+        if (size > 1) {
+          result->y = array.getValueAtIndex(runtime, 1).asNumber();
+        }
+        if (size > 2) {
+          result->z = array.getValueAtIndex(runtime, 2).asNumber();
+        }
+      } else {
+        auto object = arg.getObject(runtime);
+        if (object.hasProperty(runtime, "x")) {
+          result->x = object.getProperty(runtime, "x").asNumber();
+        }
+        if (object.hasProperty(runtime, "y")) {
+          result->y = object.getProperty(runtime, "y").asNumber();
+        }
+        if (object.hasProperty(runtime, "z")) {
+          result->z = object.getProperty(runtime, "z").asNumber();
+        }
+      }
+    } else {
+      throw std::runtime_error("Expected an object for GPUOrigin3D");
+    }
+    return result;
+  }
+  static jsi::Value toJSI(jsi::Runtime &runtime,
+                          std::shared_ptr<rnwgpu::GPUOrigin3D> arg) {
+    // No conversions here
+    return jsi::Value::null();
+  }
+};
+
+} // namespace margelo

package/cpp/rnwgpu/api/GPUPipelineLayout.h

@@ -1,13 +1,12 @@
 #pragma once
 
-#include <future>
-#include <memory>
 #include <string>
 
 #include "Unions.h"
-#include <RNFHybridObject.h>
 
-#include "MutableBuffer.h"
+#include "RNFHybridObject.h"
+
+#include "AsyncRunner.h"
 
 #include "webgpu/webgpu_cpp.h"
 
@@ -24,15 +23,23 @@ public:
   std::string getBrand() { return _name; }
 
   std::string getLabel() { return _label; }
+  void setLabel(const std::string &label) {
+    _label = label;
+    _instance.SetLabel(_label.c_str());
+  }
 
   void loadHybridMethods() override {
     registerHybridGetter("__brand", &GPUPipelineLayout::getBrand, this);
 
     registerHybridGetter("label", &GPUPipelineLayout::getLabel, this);
+    registerHybridSetter("label", &GPUPipelineLayout::setLabel, this);
   }
 
+  inline const wgpu::PipelineLayout get() { return _instance; }
+
 private:
   wgpu::PipelineLayout _instance;
   std::string _label;
 };
+
 } // namespace rnwgpu

package/cpp/rnwgpu/api/GPUQuerySet.cpp

@@ -0,0 +1,11 @@
+#include "GPUQuerySet.h"
+
+namespace rnwgpu {
+
+void GPUQuerySet::destroy() { _instance.Destroy(); }
+
+wgpu::QueryType GPUQuerySet::getType() { return _instance.GetType(); }
+
+uint32_t GPUQuerySet::getCount() { return _instance.GetCount(); }
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUQuerySet.h

@@ -1,13 +1,12 @@
 #pragma once
 
-#include <future>
-#include <memory>
 #include <string>
 
 #include "Unions.h"
-#include <RNFHybridObject.h>
 
-#include "MutableBuffer.h"
+#include "RNFHybridObject.h"
+
+#include "AsyncRunner.h"
 
 #include "webgpu/webgpu_cpp.h"
 
@@ -23,16 +22,31 @@ public:
 public:
   std::string getBrand() { return _name; }
 
+  void destroy();
+
+  wgpu::QueryType getType();
+  uint32_t getCount();
+
   std::string getLabel() { return _label; }
+  void setLabel(const std::string &label) {
+    _label = label;
+    _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);
   }
 
+  inline const wgpu::QuerySet get() { return _instance; }
+
 private:
   wgpu::QuerySet _instance;
   std::string _label;
 };
+
 } // namespace rnwgpu

package/cpp/rnwgpu/api/GPUQueue.cpp

@@ -0,0 +1,153 @@
+#include "GPUQueue.h"
+
+#include <limits>
+
+#include "Convertors.h"
+
+namespace rnwgpu {
+
+struct BufferSource {
+  void *data;
+  size_t size;            // in bytes
+  size_t bytesPerElement; // 1 for ArrayBuffers
+};
+
+void GPUQueue::submit(
+    std::vector<std::shared_ptr<GPUCommandBuffer>> commandBuffers) {
+  std::vector<wgpu::CommandBuffer> bufs(commandBuffers.size());
+  for (size_t i = 0; i < commandBuffers.size(); i++) {
+    bufs[i] = commandBuffers[i]->get();
+  }
+  Convertor conv;
+  uint32_t bufs_size;
+  if (!conv(bufs_size, bufs.size())) {
+    return;
+  }
+  _instance.Submit(bufs_size, bufs.data());
+}
+
+void GPUQueue::writeBuffer(std::shared_ptr<GPUBuffer> buffer,
+                           uint64_t bufferOffset,
+                           std::shared_ptr<ArrayBuffer> data,
+                           std::optional<uint64_t> dataOffsetElements,
+                           std::optional<size_t> sizeElements) {
+  wgpu::Buffer buf = buffer->get();
+  BufferSource src{.data = data->_data,
+                   .size = data->_size,
+                   .bytesPerElement = data->_bytesPerElement};
+
+  // Note that in the JS semantics of WebGPU, writeBuffer works in number of
+  // elements of the typed arrays.
+  if (dataOffsetElements > uint64_t(src.size / src.bytesPerElement)) {
+    throw std::runtime_error("dataOffset is larger than data's size.");
+    return;
+  }
+  uint64_t dataOffset = dataOffsetElements.value_or(0) * src.bytesPerElement;
+  src.data = reinterpret_cast<uint8_t *>(src.data) + dataOffset;
+  src.size -= dataOffset;
+
+  // Size defaults to dataSize - dataOffset. Instead of computing in elements,
+  // we directly use it in bytes, and convert the provided value, if any, in
+  // bytes.
+  uint64_t size64 = uint64_t(src.size);
+  if (sizeElements.has_value()) {
+    if (sizeElements.value() >
+        std::numeric_limits<uint64_t>::max() / src.bytesPerElement) {
+      throw std::runtime_error("size overflows.");
+      return;
+    }
+    size64 = sizeElements.value() * src.bytesPerElement;
+  }
+
+  if (size64 > uint64_t(src.size)) {
+    throw std::runtime_error("size + dataOffset is larger than data's size.");
+    return;
+  }
+
+  if (size64 % 4 != 0) {
+    throw std::runtime_error("size is not a multiple of 4 bytes.");
+
+    return;
+  }
+
+  assert(size64 <= std::numeric_limits<size_t>::max());
+  _instance.WriteBuffer(buf, bufferOffset, src.data,
+                        static_cast<size_t>(size64));
+}
+
+std::future<void> GPUQueue::onSubmittedWorkDone() {
+  return _async->runAsync([=] {
+    return _instance.OnSubmittedWorkDone(
+        wgpu::CallbackMode::WaitAnyOnly,
+        [](wgpu::QueueWorkDoneStatus status) {});
+  });
+}
+
+void GPUQueue::copyExternalImageToTexture(
+    std::shared_ptr<GPUImageCopyExternalImage> source,
+    std::shared_ptr<GPUImageCopyTextureTagged> destination,
+    std::shared_ptr<GPUExtent3D> size) {
+  wgpu::ImageCopyTexture dst{};
+  wgpu::TextureDataLayout layout{};
+  wgpu::Extent3D sz{};
+  Convertor conv;
+  uint32_t bytesPerPixel =
+      source->source->getSize() /
+      (source->source->getWidth() * source->source->getHeight());
+  auto dataLayout = std::make_shared<GPUImageDataLayout>(GPUImageDataLayout{
+      std::optional<double>{0.0},
+      std::optional<double>{
+          static_cast<double>(bytesPerPixel * source->source->getWidth())},
+      std::optional<double>{static_cast<double>(source->source->getHeight())}});
+  if (!conv(dst.aspect, destination->aspect) ||
+      !conv(dst.mipLevel, destination->mipLevel) ||
+      !conv(dst.origin, destination->origin) ||
+      !conv(dst.texture, destination->texture) ||
+      !conv(layout, dataLayout) || //
+      !conv(sz, size)) {
+    throw std::runtime_error("Invalid input for GPUQueue::writeTexture()");
+  }
+
+  if (source->flipY) {
+    // Calculate the row size and total size
+    uint32_t rowSize = bytesPerPixel * source->source->getWidth();
+    uint32_t totalSize = source->source->getSize();
+
+    // Create a new buffer for the flipped data
+    std::vector<uint8_t> flippedData(totalSize);
+
+    // Flip the data vertically
+    for (uint32_t row = 0; row < source->source->getHeight(); ++row) {
+      std::memcpy(flippedData.data() +
+                      (source->source->getHeight() - 1 - row) * rowSize,
+                  static_cast<const uint8_t *>(source->source->getData()) +
+                      row * rowSize,
+                  rowSize);
+    }
+    // Use the flipped data for writing to texture
+    _instance.WriteTexture(&dst, flippedData.data(), totalSize, &layout, &sz);
+  } else {
+
+    _instance.WriteTexture(&dst, source->source->getData(),
+                           source->source->getSize(), &layout, &sz);
+  }
+}
+
+void GPUQueue::writeTexture(std::shared_ptr<GPUImageCopyTexture> destination,
+                            std::shared_ptr<ArrayBuffer> data,
+                            std::shared_ptr<GPUImageDataLayout> dataLayout,
+                            std::shared_ptr<GPUExtent3D> size) {
+  wgpu::ImageCopyTexture dst{};
+  wgpu::TextureDataLayout layout{};
+  wgpu::Extent3D sz{};
+  Convertor conv;
+  if (!conv(dst, destination) ||   //
+      !conv(layout, dataLayout) || //
+      !conv(sz, size)) {
+    throw std::runtime_error("Invalid input for GPUQueue::writeTexture()");
+  }
+
+  _instance.WriteTexture(&dst, data->_data, data->_size, &layout, &sz);
+}
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUQueue.h

@@ -3,36 +3,77 @@
 #include <future>
 #include <memory>
 #include <string>
+#include <vector>
 
 #include "Unions.h"
-#include <RNFHybridObject.h>
 
-#include "MutableBuffer.h"
+#include "RNFHybridObject.h"
+
+#include "AsyncRunner.h"
 
 #include "webgpu/webgpu_cpp.h"
 
+#include "ArrayBuffer.h"
+#include "GPUBuffer.h"
+#include "GPUCommandBuffer.h"
+#include "GPUImageCopyExternalImage.h"
+#include "GPUImageCopyTextureTagged.h"
+
 namespace rnwgpu {
 
 namespace m = margelo;
 
 class GPUQueue : public m::HybridObject {
 public:
-  explicit GPUQueue(wgpu::Queue instance, std::string label)
-      : HybridObject("GPUQueue"), _instance(instance), _label(label) {}
+  explicit GPUQueue(wgpu::Queue instance, std::shared_ptr<AsyncRunner> async,
+                    std::string label)
+      : HybridObject("GPUQueue"), _instance(instance), _async(async),
+        _label(label) {}
 
 public:
   std::string getBrand() { return _name; }
 
+  void submit(std::vector<std::shared_ptr<GPUCommandBuffer>> commandBuffers);
+  std::future<void> onSubmittedWorkDone();
+  void writeBuffer(std::shared_ptr<GPUBuffer> buffer, uint64_t bufferOffset,
+                   std::shared_ptr<ArrayBuffer> data,
+                   std::optional<uint64_t> dataOffsetElements,
+                   std::optional<size_t> sizeElements);
+  void writeTexture(std::shared_ptr<GPUImageCopyTexture> destination,
+                    std::shared_ptr<ArrayBuffer> data,
+                    std::shared_ptr<GPUImageDataLayout> dataLayout,
+                    std::shared_ptr<GPUExtent3D> size);
+  void copyExternalImageToTexture(
+      std::shared_ptr<GPUImageCopyExternalImage> source,
+      std::shared_ptr<GPUImageCopyTextureTagged> destination,
+      std::shared_ptr<GPUExtent3D> copySize);
+
   std::string getLabel() { return _label; }
+  void setLabel(const std::string &label) {
+    _label = label;
+    _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);
   }
 
+  inline const wgpu::Queue get() { return _instance; }
+
 private:
   wgpu::Queue _instance;
+  std::shared_ptr<AsyncRunner> _async;
   std::string _label;
 };
+
 } // namespace rnwgpu

package/cpp/rnwgpu/api/GPURenderBundle.h

@@ -1,13 +1,12 @@
 #pragma once
 
-#include <future>
-#include <memory>
 #include <string>
 
 #include "Unions.h"
-#include <RNFHybridObject.h>
 
-#include "MutableBuffer.h"
+#include "RNFHybridObject.h"
+
+#include "AsyncRunner.h"
 
 #include "webgpu/webgpu_cpp.h"
 
@@ -24,15 +23,23 @@ public:
   std::string getBrand() { return _name; }
 
   std::string getLabel() { return _label; }
+  void setLabel(const std::string &label) {
+    _label = label;
+    _instance.SetLabel(_label.c_str());
+  }
 
   void loadHybridMethods() override {
     registerHybridGetter("__brand", &GPURenderBundle::getBrand, this);
 
     registerHybridGetter("label", &GPURenderBundle::getLabel, this);
+    registerHybridSetter("label", &GPURenderBundle::setLabel, this);
   }
 
+  inline const wgpu::RenderBundle get() { return _instance; }
+
 private:
   wgpu::RenderBundle _instance;
   std::string _label;
 };
+
 } // namespace rnwgpu

package/cpp/rnwgpu/api/GPURenderBundleEncoder.cpp

@@ -0,0 +1,128 @@
+#include "GPURenderBundleEncoder.h"
+
+#include "Convertors.h"
+
+namespace rnwgpu {
+
+std::shared_ptr<GPURenderBundle> GPURenderBundleEncoder::finish(
+    std::optional<std::shared_ptr<GPURenderBundleDescriptor>> descriptor) {
+  wgpu::RenderBundleDescriptor desc;
+  Convertor conv;
+  if (!conv(desc, descriptor)) {
+    throw std::runtime_error("GPURenderBundleEncoder.finish(): couldn't get "
+                             "GPURenderBundleDescriptor");
+  }
+  auto bundle = _instance.Finish(&desc);
+  return std::make_shared<GPURenderBundle>(
+      bundle,
+      descriptor.has_value() ? descriptor.value()->label.value_or("") : "");
+}
+
+void GPURenderBundleEncoder::setPipeline(
+    std::shared_ptr<GPURenderPipeline> pipeline) {
+  _instance.SetPipeline(pipeline->get());
+}
+
+void GPURenderBundleEncoder::draw(uint32_t vertexCount,
+                                  std::optional<uint32_t> instanceCount,
+                                  std::optional<uint32_t> firstVertex,
+                                  std::optional<uint32_t> firstInstance) {
+  _instance.Draw(vertexCount, instanceCount.value_or(1),
+                 firstVertex.value_or(0), firstInstance.value_or(0));
+}
+
+void GPURenderBundleEncoder::setVertexBuffer(
+    uint32_t slot,
+    std::variant<std::nullptr_t, std::shared_ptr<GPUBuffer>> buffer,
+    std::optional<uint64_t> offset, std::optional<uint64_t> size) {
+  Convertor conv;
+
+  wgpu::Buffer b{};
+  uint64_t s = wgpu::kWholeSize;
+  if (!conv(b, buffer) || !conv(s, size)) {
+    return;
+  }
+  _instance.SetVertexBuffer(slot, b, offset.value_or(0), s);
+}
+
+void GPURenderBundleEncoder::setBindGroup(
+    uint32_t groupIndex,
+    std::variant<std::nullptr_t, std::shared_ptr<GPUBindGroup>> bindGroup,
+    std::optional<std::vector<uint32_t>> dynamicOffsets) {
+  auto dynOffsets = dynamicOffsets.value_or(std::vector<uint32_t>());
+  if (dynOffsets.size() == 0) {
+    if (std::holds_alternative<std::nullptr_t>(bindGroup)) {
+      _instance.SetBindGroup(groupIndex, nullptr, 0, nullptr);
+    } else {
+      auto group = std::get<std::shared_ptr<GPUBindGroup>>(bindGroup);
+      _instance.SetBindGroup(groupIndex, group->get(), 0, nullptr);
+    }
+  } else {
+    if (std::holds_alternative<std::nullptr_t>(bindGroup)) {
+      _instance.SetBindGroup(groupIndex, nullptr, dynOffsets.size(),
+                             dynamicOffsets->data());
+    } else {
+      auto group = std::get<std::shared_ptr<GPUBindGroup>>(bindGroup);
+      _instance.SetBindGroup(groupIndex, group->get(), dynOffsets.size(),
+                             dynamicOffsets->data());
+    }
+  }
+}
+
+void GPURenderBundleEncoder::setIndexBuffer(std::shared_ptr<GPUBuffer> buffer,
+                                            wgpu::IndexFormat indexFormat,
+                                            std::optional<uint64_t> offset,
+                                            std::optional<uint64_t> size) {
+  Convertor conv;
+
+  wgpu::Buffer b{};
+  wgpu::IndexFormat f{};
+  uint64_t o = 0;
+  uint64_t s = wgpu::kWholeSize;
+  if (!conv(b, buffer) ||      //
+      !conv(f, indexFormat) || //
+      !conv(o, offset) ||      //
+      !conv(s, size)) {
+    return;
+  }
+
+  _instance.SetIndexBuffer(b, f, o, s);
+}
+
+void GPURenderBundleEncoder::drawIndexed(
+    uint32_t indexCount, std::optional<uint32_t> instanceCount,
+    std::optional<uint32_t> firstIndex, std::optional<double> baseVertex,
+    std::optional<uint32_t> firstInstance) {
+  _instance.DrawIndexed(indexCount, instanceCount.value_or(1),
+                        firstIndex.value_or(0), baseVertex.value_or(0),
+                        firstInstance.value_or(0));
+}
+
+void GPURenderBundleEncoder::pushDebugGroup(std::string groupLabel) {
+  _instance.PushDebugGroup(groupLabel.c_str());
+}
+
+void GPURenderBundleEncoder::popDebugGroup() { _instance.PopDebugGroup(); }
+
+void GPURenderBundleEncoder::insertDebugMarker(std::string markerLabel) {
+  _instance.InsertDebugMarker(markerLabel.c_str());
+}
+void GPURenderBundleEncoder::drawIndirect(
+    std::shared_ptr<GPUBuffer> indirectBuffer, uint64_t indirectOffset) {
+  Convertor conv;
+  wgpu::Buffer b{};
+  if (!conv(b, indirectBuffer)) {
+    return;
+  }
+  _instance.DrawIndirect(b, indirectOffset);
+}
+void GPURenderBundleEncoder::drawIndexedIndirect(
+    std::shared_ptr<GPUBuffer> indirectBuffer, uint64_t indirectOffset) {
+  Convertor conv;
+  wgpu::Buffer b{};
+  if (!conv(b, indirectBuffer)) {
+    return;
+  }
+  _instance.DrawIndexedIndirect(b, indirectOffset);
+}
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPURenderBundleEncoder.h

@@ -1,16 +1,25 @@
 #pragma once
 
-#include <future>
 #include <memory>
+#include <optional>
 #include <string>
+#include <variant>
+#include <vector>
 
 #include "Unions.h"
-#include <RNFHybridObject.h>
 
-#include "MutableBuffer.h"
+#include "RNFHybridObject.h"
+
+#include "AsyncRunner.h"
 
 #include "webgpu/webgpu_cpp.h"
 
+#include "GPUBindGroup.h"
+#include "GPUBuffer.h"
+#include "GPURenderBundle.h"
+#include "GPURenderBundleDescriptor.h"
+#include "GPURenderPipeline.h"
+
 namespace rnwgpu {
 
 namespace m = margelo;
@@ -25,16 +34,76 @@ public:
 public:
   std::string getBrand() { return _name; }
 
+  std::shared_ptr<GPURenderBundle>
+  finish(std::optional<std::shared_ptr<GPURenderBundleDescriptor>> descriptor);
+  void pushDebugGroup(std::string groupLabel);
+  void popDebugGroup();
+  void insertDebugMarker(std::string markerLabel);
+  void setBindGroup(
+      uint32_t index,
+      std::variant<std::nullptr_t, std::shared_ptr<GPUBindGroup>> bindGroup,
+      std::optional<std::vector<uint32_t>> dynamicOffsets);
+  void setPipeline(std::shared_ptr<GPURenderPipeline> pipeline);
+  void setIndexBuffer(std::shared_ptr<GPUBuffer> buffer,
+                      wgpu::IndexFormat indexFormat,
+                      std::optional<uint64_t> offset,
+                      std::optional<uint64_t> size);
+  void setVertexBuffer(
+      uint32_t slot,
+      std::variant<std::nullptr_t, std::shared_ptr<GPUBuffer>> buffer,
+      std::optional<uint64_t> offset, std::optional<uint64_t> size);
+  void draw(uint32_t vertexCount, std::optional<uint32_t> instanceCount,
+            std::optional<uint32_t> firstVertex,
+            std::optional<uint32_t> firstInstance);
+  void drawIndexed(uint32_t indexCount, std::optional<uint32_t> instanceCount,
+                   std::optional<uint32_t> firstIndex,
+                   std::optional<double> baseVertex,
+                   std::optional<uint32_t> firstInstance);
+  void drawIndirect(std::shared_ptr<GPUBuffer> indirectBuffer,
+                    uint64_t indirectOffset);
+  void drawIndexedIndirect(std::shared_ptr<GPUBuffer> indirectBuffer,
+                           uint64_t indirectOffset);
+
   std::string getLabel() { return _label; }
+  void setLabel(const std::string &label) {
+    _label = label;
+    _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);
   }
 
+  inline const wgpu::RenderBundleEncoder get() { return _instance; }
+
 private:
   wgpu::RenderBundleEncoder _instance;
   std::string _label;
 };
+
 } // namespace rnwgpu