react-native-webgpu 0.5.11

package/cpp/rnwgpu/api/GPUBuffer.cpp

@@ -0,0 +1,97 @@
+#include "GPUBuffer.h"
+
+#include <memory>
+#include <utility>
+
+#include "Convertors.h"
+
+namespace rnwgpu {
+
+std::shared_ptr<ArrayBuffer>
+GPUBuffer::getMappedRange(std::optional<size_t> o, std::optional<size_t> size) {
+  auto offset = o.value_or(0);
+  uint64_t s = size.has_value() ? size.value() : (_instance.GetSize() - offset);
+
+  uint64_t start = offset;
+  uint64_t end = offset + s;
+  // for (auto& mapping : mappings_) {
+  //     if (mapping.Intersects(start, end)) {
+  //         Errors::OperationError(env).ThrowAsJavaScriptException();
+  //         return {};
+  //     }
+  // }
+
+  auto *ptr =
+      (_instance.GetUsage() & wgpu::BufferUsage::MapWrite)
+          ? _instance.GetMappedRange(offset, s)
+          : const_cast<void *>(_instance.GetConstMappedRange(offset, s));
+  if (!ptr) {
+    throw std::runtime_error("Failed to get getMappedRange");
+  }
+  auto array_buffer = std::make_shared<ArrayBuffer>(ptr, s, 1);
+  // TODO(crbug.com/dawn/1135): Ownership here is the wrong way around.
+  // mappings_.emplace_back(Mapping{start, end,
+  // Napi::Persistent(array_buffer)});
+  return array_buffer;
+}
+
+void GPUBuffer::destroy() { _instance.Destroy(); }
+
+async::AsyncTaskHandle GPUBuffer::mapAsync(uint64_t modeIn,
+                                           std::optional<uint64_t> offset,
+                                           std::optional<uint64_t> size) {
+  Convertor conv;
+  wgpu::MapMode mode;
+  if (!conv(mode, modeIn)) {
+    throw std::runtime_error("Couldn't get MapMode");
+  }
+  uint64_t rangeSize = size.has_value()
+                           ? size.value()
+                           : (_instance.GetSize() - offset.value_or(0));
+  auto bufferHandle = _instance;
+  uint64_t resolvedOffset = offset.value_or(0);
+
+  return _async->postTask(
+      [bufferHandle, mode, resolvedOffset,
+       rangeSize](const async::AsyncTaskHandle::ResolveFunction &resolve,
+                  const async::AsyncTaskHandle::RejectFunction &reject) {
+        bufferHandle.MapAsync(mode, resolvedOffset, rangeSize,
+                              wgpu::CallbackMode::AllowProcessEvents,
+                              [resolve, reject](wgpu::MapAsyncStatus status,
+                                                wgpu::StringView message) {
+                                switch (status) {
+                                case wgpu::MapAsyncStatus::Success:
+                                  resolve(nullptr);
+                                  break;
+                                case wgpu::MapAsyncStatus::CallbackCancelled:
+                                  reject("MapAsyncStatus::CallbackCancelled");
+                                  break;
+                                case wgpu::MapAsyncStatus::Error:
+                                  reject("MapAsyncStatus::Error");
+                                  break;
+                                case wgpu::MapAsyncStatus::Aborted:
+                                  reject("MapAsyncStatus::Aborted");
+                                  break;
+                                default:
+                                  reject(
+                                      "MapAsyncStatus: " +
+                                      std::to_string(static_cast<int>(status)));
+                                  break;
+                                }
+                              });
+      });
+}
+
+void GPUBuffer::unmap() { _instance.Unmap(); }
+
+uint64_t GPUBuffer::getSize() { return _instance.GetSize(); }
+
+double GPUBuffer::getUsage() {
+  return static_cast<double>(_instance.GetUsage());
+}
+
+wgpu::BufferMapState GPUBuffer::getMapState() {
+  return _instance.GetMapState();
+}
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUBuffer.h

@@ -0,0 +1,87 @@
+#pragma once
+
+#include <memory>
+#include <optional>
+#include <string>
+#include <vector>
+
+#include "Unions.h"
+
+#include "NativeObject.h"
+
+#include "rnwgpu/async/AsyncRunner.h"
+#include "rnwgpu/async/AsyncTaskHandle.h"
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "ArrayBuffer.h"
+
+namespace rnwgpu {
+
+namespace jsi = facebook::jsi;
+
+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)
+      : NativeObject(CLASS_NAME), _instance(instance), _async(async),
+        _label(label) {}
+
+public:
+  std::string getBrand() { return CLASS_NAME; }
+
+  async::AsyncTaskHandle mapAsync(uint64_t modeIn,
+                                  std::optional<uint64_t> offset,
+                                  std::optional<uint64_t> size);
+  std::shared_ptr<ArrayBuffer> getMappedRange(std::optional<size_t> offset,
+                                              std::optional<size_t> size);
+  void unmap();
+  void destroy();
+
+  uint64_t getSize();
+  double getUsage();
+  wgpu::BufferMapState getMapState();
+
+  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", &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; }
+
+  size_t getMemoryPressure() override { return static_cast<size_t>(getSize()); }
+
+private:
+  wgpu::Buffer _instance;
+  std::shared_ptr<async::AsyncRunner> _async;
+  std::string _label;
+  struct Mapping {
+    uint64_t start;
+    uint64_t end;
+    inline bool Intersects(uint64_t s, uint64_t e) const {
+      return s < end && e > start;
+    }
+    std::shared_ptr<ArrayBuffer> buffer;
+  };
+  std::vector<Mapping> mappings;
+};
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUCanvasContext.cpp

@@ -0,0 +1,67 @@
+#include "GPUCanvasContext.h"
+#include "Convertors.h"
+#include "RNWebGPUManager.h"
+#include <memory>
+
+#ifdef __APPLE__
+namespace dawn::native::metal {
+
+void WaitForCommandsToBeScheduled(WGPUDevice device);
+
+}
+#endif
+
+namespace rnwgpu {
+
+void GPUCanvasContext::configure(
+    std::shared_ptr<GPUCanvasConfiguration> configuration) {
+  Convertor conv;
+  wgpu::SurfaceConfiguration surfaceConfiguration;
+  surfaceConfiguration.device = configuration->device->get();
+  if (configuration->viewFormats.has_value()) {
+    if (!conv(surfaceConfiguration.viewFormats,
+              surfaceConfiguration.viewFormatCount,
+              configuration->viewFormats.value())) {
+      throw std::runtime_error("Error with SurfaceConfiguration");
+    }
+  }
+  if (!conv(surfaceConfiguration.usage, configuration->usage) ||
+      !conv(surfaceConfiguration.format, configuration->format)) {
+    throw std::runtime_error("Error with SurfaceConfiguration");
+  }
+
+#ifdef __APPLE__
+  surfaceConfiguration.alphaMode = configuration->alphaMode;
+#endif
+  surfaceConfiguration.presentMode = wgpu::PresentMode::Fifo;
+  _surfaceInfo->configure(surfaceConfiguration);
+}
+
+void GPUCanvasContext::unconfigure() {}
+
+std::shared_ptr<GPUTexture> GPUCanvasContext::getCurrentTexture() {
+  auto prevSize = _surfaceInfo->getConfig();
+  auto width = _canvas->getWidth();
+  auto height = _canvas->getHeight();
+  auto sizeHasChanged = prevSize.width != width || prevSize.height != height;
+  if (sizeHasChanged) {
+    _surfaceInfo->reconfigure(width, height);
+  }
+  auto texture = _surfaceInfo->getCurrentTexture();
+  // Pass reportsMemoryPressure=false to avoid triggering spurious Hermes GC
+  // cycles every frame since the canvas texture doesn't own the buffer.
+  return std::make_shared<GPUTexture>(texture, "", false);
+}
+
+void GPUCanvasContext::present() {
+#ifdef __APPLE__
+  dawn::native::metal::WaitForCommandsToBeScheduled(
+      _surfaceInfo->getDevice().Get());
+#endif
+  auto size = _surfaceInfo->getSize();
+  _canvas->setClientWidth(size.width);
+  _canvas->setClientHeight(size.height);
+  _surfaceInfo->present();
+}
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUCanvasContext.h

@@ -0,0 +1,66 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <utility>
+
+#include "Unions.h"
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "NativeObject.h"
+
+#include "Canvas.h"
+#include "GPU.h"
+#include "GPUCanvasConfiguration.h"
+#include "GPUTexture.h"
+#include "SurfaceRegistry.h"
+
+namespace rnwgpu {
+
+namespace jsi = facebook::jsi;
+
+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)
+      : NativeObject(CLASS_NAME), _gpu(std::move(gpu)) {
+    _canvas = std::make_shared<Canvas>(nullptr, width, height);
+    auto &registry = rnwgpu::SurfaceRegistry::getInstance();
+    _surfaceInfo =
+        registry.getSurfaceInfoOrCreate(contextId, _gpu->get(), width, height);
+  }
+
+public:
+  std::string getBrand() { return CLASS_NAME; }
+
+  std::shared_ptr<Canvas> getCanvas() { return _canvas; }
+
+  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?
+  inline const wgpu::Surface get() { return nullptr; }
+  void configure(std::shared_ptr<GPUCanvasConfiguration> configuration);
+  void unconfigure();
+  std::shared_ptr<GPUTexture> getCurrentTexture();
+  void present();
+
+private:
+  std::shared_ptr<Canvas> _canvas;
+  std::shared_ptr<SurfaceInfo> _surfaceInfo;
+  std::shared_ptr<GPU> _gpu;
+};
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUCommandBuffer.h

@@ -0,0 +1,45 @@
+#pragma once
+
+#include <string>
+
+#include "Unions.h"
+
+#include "NativeObject.h"
+
+#include "webgpu/webgpu_cpp.h"
+
+namespace rnwgpu {
+
+namespace jsi = facebook::jsi;
+
+class GPUCommandBuffer : public NativeObject<GPUCommandBuffer> {
+public:
+  static constexpr const char *CLASS_NAME = "GPUCommandBuffer";
+
+  explicit GPUCommandBuffer(wgpu::CommandBuffer 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", &GPUCommandBuffer::getBrand);
+    installGetterSetter(runtime, prototype, "label",
+                        &GPUCommandBuffer::getLabel,
+                        &GPUCommandBuffer::setLabel);
+  }
+
+  inline const wgpu::CommandBuffer get() { return _instance; }
+
+private:
+  wgpu::CommandBuffer _instance;
+  std::string _label;
+};
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUCommandEncoder.cpp

@@ -0,0 +1,179 @@
+#include "GPUCommandEncoder.h"
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "Convertors.h"
+
+namespace rnwgpu {
+
+void GPUCommandEncoder::copyBufferToBuffer(
+    std::shared_ptr<GPUBuffer> source, uint64_t sourceOffset,
+    std::shared_ptr<GPUBuffer> destination, uint64_t destinationOffset,
+    uint64_t size) {
+  Convertor conv;
+
+  wgpu::Buffer src{};
+  wgpu::Buffer dst{};
+  if (!conv(src, source) || //
+      !conv(dst, destination)) {
+    return;
+  }
+  _instance.CopyBufferToBuffer(src, sourceOffset, dst, destinationOffset, size);
+}
+
+std::shared_ptr<GPUCommandBuffer> GPUCommandEncoder::finish(
+    std::optional<std::shared_ptr<GPUCommandBufferDescriptor>> descriptor) {
+  wgpu::CommandBufferDescriptor desc{};
+  Convertor conv;
+  if (!conv(desc, descriptor)) {
+    throw std::runtime_error(
+        "GPUCommandEncoder::finish(): error with GPUCommandBufferDescriptor");
+  }
+  auto commandBuffer = _instance.Finish(&desc);
+  return std::make_shared<GPUCommandBuffer>(
+      commandBuffer,
+      descriptor.has_value() ? descriptor.value()->label.value_or("") : "");
+}
+
+std::shared_ptr<GPURenderPassEncoder> GPUCommandEncoder::beginRenderPass(
+    std::shared_ptr<GPURenderPassDescriptor> descriptor) {
+
+  wgpu::RenderPassDescriptor desc{};
+  wgpu::RenderPassMaxDrawCount maxDrawCountDesc{};
+  desc.nextInChain = &maxDrawCountDesc;
+  Convertor conv;
+
+  // TODO: why is this not in Converter
+  if (!conv(desc.colorAttachments, desc.colorAttachmentCount,
+            descriptor->colorAttachments) ||
+      !conv(desc.depthStencilAttachment, descriptor->depthStencilAttachment) ||
+      !conv(desc.label, descriptor->label) ||
+      !conv(desc.occlusionQuerySet, descriptor->occlusionQuerySet) ||
+      !conv(desc.timestampWrites, descriptor->timestampWrites) ||
+      !conv(maxDrawCountDesc.maxDrawCount, descriptor->maxDrawCount)) {
+    throw std::runtime_error("PUCommandEncoder::beginRenderPass(): couldn't "
+                             "get GPURenderPassDescriptor");
+  }
+  auto renderPass = _instance.BeginRenderPass(&desc);
+  return std::make_shared<GPURenderPassEncoder>(renderPass,
+                                                descriptor->label.value_or(""));
+}
+
+void GPUCommandEncoder::copyTextureToBuffer(
+    std::shared_ptr<GPUImageCopyTexture> source,
+    std::shared_ptr<GPUImageCopyBuffer> destination,
+    std::shared_ptr<GPUExtent3D> copySize) {
+  Convertor conv;
+  wgpu::TexelCopyTextureInfo src{};
+  wgpu::TexelCopyBufferInfo dst{};
+  wgpu::Extent3D size{};
+  if (!conv(src, source) ||      //
+      !conv(dst, destination) || //
+      !conv(size, copySize)) {
+    return;
+  }
+  _instance.CopyTextureToBuffer(&src, &dst, &size);
+}
+
+void GPUCommandEncoder::copyTextureToTexture(
+    std::shared_ptr<GPUImageCopyTexture> source,
+    std::shared_ptr<GPUImageCopyTexture> destination,
+    std::shared_ptr<GPUExtent3D> copySize) {
+  Convertor conv;
+
+  wgpu::TexelCopyTextureInfo src{};
+  wgpu::TexelCopyTextureInfo dst{};
+  wgpu::Extent3D size{};
+  if (!conv(src, source) ||      //
+      !conv(dst, destination) || //
+      !conv(size, copySize)) {
+    return;
+  }
+
+  _instance.CopyTextureToTexture(&src, &dst, &size);
+}
+
+std::shared_ptr<GPUComputePassEncoder> GPUCommandEncoder::beginComputePass(
+    std::optional<std::shared_ptr<GPUComputePassDescriptor>> descriptor) {
+  wgpu::ComputePassDescriptor desc;
+  Convertor conv;
+  if (!conv(desc, descriptor)) {
+    throw std::runtime_error("GPUCommandEncoder.beginComputePass(): couldn't "
+                             "access GPUComputePassDescriptor.");
+  }
+  auto computePass = _instance.BeginComputePass(&desc);
+  return std::make_shared<GPUComputePassEncoder>(
+      computePass,
+      descriptor.has_value() ? descriptor.value()->label.value_or("") : "");
+}
+
+void GPUCommandEncoder::resolveQuerySet(std::shared_ptr<GPUQuerySet> querySet,
+                                        uint32_t firstQuery,
+                                        uint32_t queryCount,
+                                        std::shared_ptr<GPUBuffer> destination,
+                                        uint64_t destinationOffset) {
+  Convertor conv;
+
+  wgpu::QuerySet q{};
+  uint32_t f = 0;
+  uint32_t c = 0;
+  wgpu::Buffer b{};
+  uint64_t o = 0;
+
+  if (!conv(q, querySet) ||    //
+      !conv(f, firstQuery) ||  //
+      !conv(c, queryCount) ||  //
+      !conv(b, destination) || //
+      !conv(o, destinationOffset)) {
+    return;
+  }
+
+  _instance.ResolveQuerySet(q, f, c, b, o);
+}
+
+void GPUCommandEncoder::copyBufferToTexture(
+    std::shared_ptr<GPUImageCopyBuffer> source,
+    std::shared_ptr<GPUImageCopyTexture> destination,
+    std::shared_ptr<GPUExtent3D> copySize) {
+  Convertor conv;
+
+  wgpu::TexelCopyBufferInfo src{};
+  wgpu::TexelCopyTextureInfo dst{};
+  wgpu::Extent3D size{};
+  if (!conv(src, source) ||      //
+      !conv(dst, destination) || //
+      !conv(size, copySize)) {
+    return;
+  }
+
+  _instance.CopyBufferToTexture(&src, &dst, &size);
+}
+
+void GPUCommandEncoder::clearBuffer(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.ClearBuffer(b, offset.value_or(0), s);
+}
+
+void GPUCommandEncoder::pushDebugGroup(std::string groupLabel) {
+  _instance.PushDebugGroup(groupLabel.c_str());
+}
+
+void GPUCommandEncoder::popDebugGroup() { _instance.PopDebugGroup(); }
+
+void GPUCommandEncoder::insertDebugMarker(std::string markerLabel) {
+  _instance.InsertDebugMarker(markerLabel.c_str());
+}
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUCommandEncoder.h

@@ -0,0 +1,111 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "Unions.h"
+
+#include "NativeObject.h"
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "GPUBuffer.h"
+#include "GPUCommandBuffer.h"
+#include "GPUCommandBufferDescriptor.h"
+#include "GPUComputePassDescriptor.h"
+#include "GPUComputePassEncoder.h"
+#include "GPUExtent3D.h"
+#include "GPUImageCopyBuffer.h"
+#include "GPUImageCopyTexture.h"
+#include "GPUQuerySet.h"
+#include "GPURenderPassDescriptor.h"
+#include "GPURenderPassEncoder.h"
+
+namespace rnwgpu {
+
+namespace jsi = facebook::jsi;
+
+class GPUCommandEncoder : public NativeObject<GPUCommandEncoder> {
+public:
+  static constexpr const char *CLASS_NAME = "GPUCommandEncoder";
+
+  explicit GPUCommandEncoder(wgpu::CommandEncoder instance, std::string label)
+      : NativeObject(CLASS_NAME), _instance(instance), _label(label) {}
+
+public:
+  std::string getBrand() { return CLASS_NAME; }
+
+  std::shared_ptr<GPURenderPassEncoder>
+  beginRenderPass(std::shared_ptr<GPURenderPassDescriptor> descriptor);
+  std::shared_ptr<GPUComputePassEncoder> beginComputePass(
+      std::optional<std::shared_ptr<GPUComputePassDescriptor>> descriptor);
+  void copyBufferToBuffer(std::shared_ptr<GPUBuffer> source,
+                          uint64_t sourceOffset,
+                          std::shared_ptr<GPUBuffer> destination,
+                          uint64_t destinationOffset, uint64_t size);
+  void copyBufferToTexture(std::shared_ptr<GPUImageCopyBuffer> source,
+                           std::shared_ptr<GPUImageCopyTexture> destination,
+                           std::shared_ptr<GPUExtent3D> copySize);
+  void copyTextureToBuffer(std::shared_ptr<GPUImageCopyTexture> source,
+                           std::shared_ptr<GPUImageCopyBuffer> destination,
+                           std::shared_ptr<GPUExtent3D> copySize);
+  void copyTextureToTexture(std::shared_ptr<GPUImageCopyTexture> source,
+                            std::shared_ptr<GPUImageCopyTexture> destination,
+                            std::shared_ptr<GPUExtent3D> copySize);
+  void clearBuffer(std::shared_ptr<GPUBuffer> buffer,
+                   std::optional<uint64_t> offset,
+                   std::optional<uint64_t> size);
+  void resolveQuerySet(std::shared_ptr<GPUQuerySet> querySet,
+                       uint32_t firstQuery, uint32_t queryCount,
+                       std::shared_ptr<GPUBuffer> destination,
+                       uint64_t destinationOffset);
+  std::shared_ptr<GPUCommandBuffer>
+  finish(std::optional<std::shared_ptr<GPUCommandBufferDescriptor>> descriptor);
+  void pushDebugGroup(std::string groupLabel);
+  void popDebugGroup();
+  void insertDebugMarker(std::string markerLabel);
+
+  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", &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; }
+
+private:
+  wgpu::CommandEncoder _instance;
+  std::string _label;
+};
+
+} // namespace rnwgpu