@shopify/react-native-skia 2.4.15 → 2.4.17

package/cpp/rnwgpu/api/GPUOrigin3D.h

@@ -0,0 +1,62 @@
+#pragma once
+
+#include <memory>
+
+#include "jsi2/JSIConverter.h"
+
+#include "webgpu/webgpu_cpp.h"
+
+namespace rnwgpu {
+
+struct GPUOrigin3D {
+  double x = 0;
+  double y = 0;
+  double z = 0;
+};
+
+template <> struct JSIConverter<std::shared_ptr<GPUOrigin3D>> {
+  static std::shared_ptr<GPUOrigin3D>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<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<GPUOrigin3D> arg) {
+    // No conversions here
+    return jsi::Value::null();
+  }
+};
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUOutOfMemoryError.h

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

package/cpp/rnwgpu/api/GPUPipelineLayout.h

@@ -0,0 +1,45 @@
+#pragma once
+
+#include <string>
+
+#include "descriptors/Unions.h"
+
+#include "jsi2/NativeObject.h"
+
+#include "webgpu/webgpu_cpp.h"
+
+namespace rnwgpu {
+
+namespace jsi = facebook::jsi;
+
+class GPUPipelineLayout : public NativeObject<GPUPipelineLayout> {
+public:
+  static constexpr const char *CLASS_NAME = "GPUPipelineLayout";
+
+  explicit GPUPipelineLayout(wgpu::PipelineLayout instance, std::string label)
+      : NativeObject(CLASS_NAME), _instance(instance), _label(label) {}
+
+public:
+  std::string getBrand() { return CLASS_NAME; }
+
+  std::string getLabel() { return _label; }
+  void setLabel(const std::string &label) {
+    _label = label;
+    _instance.SetLabel(_label.c_str());
+  }
+
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installGetter(runtime, prototype, "__brand", &GPUPipelineLayout::getBrand);
+    installGetterSetter(runtime, prototype, "label",
+                        &GPUPipelineLayout::getLabel,
+                        &GPUPipelineLayout::setLabel);
+  }
+
+  inline const wgpu::PipelineLayout get() { return _instance; }
+
+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

@@ -0,0 +1,73 @@
+#pragma once
+
+#include <string>
+
+#include "descriptors/Unions.h"
+
+#include "jsi2/NativeObject.h"
+
+#include "webgpu/webgpu_cpp.h"
+
+namespace rnwgpu {
+
+namespace jsi = facebook::jsi;
+
+class GPUQuerySet : public NativeObject<GPUQuerySet> {
+public:
+  static constexpr const char *CLASS_NAME = "GPUQuerySet";
+
+  explicit GPUQuerySet(wgpu::QuerySet instance, std::string label)
+      : NativeObject(CLASS_NAME), _instance(instance), _label(label) {}
+
+public:
+  std::string getBrand() { return CLASS_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());
+  }
+
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installGetter(runtime, prototype, "__brand", &GPUQuerySet::getBrand);
+    installMethod(runtime, prototype, "destroy", &GPUQuerySet::destroy);
+    installGetter(runtime, prototype, "type", &GPUQuerySet::getType);
+    installGetter(runtime, prototype, "count", &GPUQuerySet::getCount);
+    installGetterSetter(runtime, prototype, "label", &GPUQuerySet::getLabel,
+                        &GPUQuerySet::setLabel);
+  }
+
+  inline const wgpu::QuerySet get() { return _instance; }
+
+  size_t getMemoryPressure() override {
+    uint32_t count = getCount();
+    wgpu::QueryType type = getType();
+
+    // Estimate bytes per query based on type
+    size_t bytesPerQuery = 8; // Default estimate
+    switch (type) {
+    case wgpu::QueryType::Occlusion:
+      bytesPerQuery = 8; // 64-bit counter
+      break;
+    case wgpu::QueryType::Timestamp:
+      bytesPerQuery = 8; // 64-bit timestamp
+      break;
+    default:
+      bytesPerQuery = 8; // Safe default
+      break;
+    }
+
+    return static_cast<size_t>(count) * bytesPerQuery;
+  }
+
+private:
+  wgpu::QuerySet _instance;
+  std::string _label;
+};
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUQueue.cpp

@@ -0,0 +1,169 @@
+#include "GPUQueue.h"
+
+#include <limits>
+#include <memory>
+#include <vector>
+
+#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 >
+      static_cast<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 = static_cast<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 > static_cast<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));
+}
+
+async::AsyncTaskHandle GPUQueue::onSubmittedWorkDone() {
+  auto queue = _instance;
+  return _async->postTask(
+      [queue](const async::AsyncTaskHandle::ResolveFunction &resolve,
+              const async::AsyncTaskHandle::RejectFunction &reject) {
+        queue.OnSubmittedWorkDone(
+            wgpu::CallbackMode::AllowProcessEvents,
+            [resolve, reject](wgpu::QueueWorkDoneStatus status,
+                              wgpu::StringView message) {
+              if (status == wgpu::QueueWorkDoneStatus::Success) {
+                resolve(nullptr);
+              } else {
+                std::string error =
+                    message.length ? std::string(message.data, message.length)
+                                   : "Queue work did not complete successfully";
+                reject(std::move(error));
+              }
+            });
+      });
+}
+
+void GPUQueue::copyExternalImageToTexture(
+    std::shared_ptr<GPUImageCopyExternalImage> source,
+    std::shared_ptr<GPUImageCopyTextureTagged> destination,
+    std::shared_ptr<GPUExtent3D> size) {
+//  wgpu::TexelCopyTextureInfo dst{};
+//  wgpu::TexelCopyBufferLayout 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::TexelCopyTextureInfo dst{};
+  wgpu::TexelCopyBufferLayout 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

@@ -0,0 +1,84 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "descriptors/Unions.h"
+
+#include "jsi2/NativeObject.h"
+
+#include "rnwgpu/async/AsyncRunner.h"
+#include "rnwgpu/async/AsyncTaskHandle.h"
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "rnwgpu/ArrayBuffer.h"
+#include "GPUBuffer.h"
+#include "GPUCommandBuffer.h"
+#include "GPUExtent3D.h"
+#include "descriptors/GPUImageCopyExternalImage.h"
+#include "descriptors/GPUImageCopyTexture.h"
+#include "descriptors/GPUImageCopyTextureTagged.h"
+#include "descriptors/GPUImageDataLayout.h"
+
+namespace rnwgpu {
+
+namespace jsi = facebook::jsi;
+
+class GPUQueue : public NativeObject<GPUQueue> {
+public:
+  static constexpr const char *CLASS_NAME = "GPUQueue";
+
+  explicit GPUQueue(wgpu::Queue instance,
+                    std::shared_ptr<async::AsyncRunner> async,
+                    std::string label)
+      : NativeObject(CLASS_NAME), _instance(instance), _async(async),
+        _label(label) {}
+
+public:
+  std::string getBrand() { return CLASS_NAME; }
+
+  void submit(std::vector<std::shared_ptr<GPUCommandBuffer>> commandBuffers);
+  async::AsyncTaskHandle 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());
+  }
+
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installGetter(runtime, prototype, "__brand", &GPUQueue::getBrand);
+    installMethod(runtime, prototype, "submit", &GPUQueue::submit);
+    installMethod(runtime, prototype, "onSubmittedWorkDone",
+                  &GPUQueue::onSubmittedWorkDone);
+    installMethod(runtime, prototype, "writeBuffer", &GPUQueue::writeBuffer);
+    installMethod(runtime, prototype, "writeTexture", &GPUQueue::writeTexture);
+    installMethod(runtime, prototype, "copyExternalImageToTexture",
+                  &GPUQueue::copyExternalImageToTexture);
+    installGetterSetter(runtime, prototype, "label", &GPUQueue::getLabel,
+                        &GPUQueue::setLabel);
+  }
+
+  inline const wgpu::Queue get() { return _instance; }
+
+private:
+  wgpu::Queue _instance;
+  std::shared_ptr<async::AsyncRunner> _async;
+  std::string _label;
+};
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPURenderBundle.h

@@ -0,0 +1,44 @@
+#pragma once
+
+#include <string>
+
+#include "descriptors/Unions.h"
+
+#include "jsi2/NativeObject.h"
+
+#include "webgpu/webgpu_cpp.h"
+
+namespace rnwgpu {
+
+namespace jsi = facebook::jsi;
+
+class GPURenderBundle : public NativeObject<GPURenderBundle> {
+public:
+  static constexpr const char *CLASS_NAME = "GPURenderBundle";
+
+  explicit GPURenderBundle(wgpu::RenderBundle instance, std::string label)
+      : NativeObject(CLASS_NAME), _instance(instance), _label(label) {}
+
+public:
+  std::string getBrand() { return CLASS_NAME; }
+
+  std::string getLabel() { return _label; }
+  void setLabel(const std::string &label) {
+    _label = label;
+    _instance.SetLabel(_label.c_str());
+  }
+
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installGetter(runtime, prototype, "__brand", &GPURenderBundle::getBrand);
+    installGetterSetter(runtime, prototype, "label", &GPURenderBundle::getLabel,
+                        &GPURenderBundle::setLabel);
+  }
+
+  inline const wgpu::RenderBundle get() { return _instance; }
+
+private:
+  wgpu::RenderBundle _instance;
+  std::string _label;
+};
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPURenderBundleEncoder.cpp

@@ -0,0 +1,131 @@
+#include "GPURenderBundleEncoder.h"
+
+#include <memory>
+#include <string>
+
+#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