@shopify/react-native-skia 2.4.15 → 2.4.17

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 "descriptors/Unions.h"
+
+#include "jsi2/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/GPUCommandBuffer.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 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 "descriptors/Unions.h"
+
+#include "jsi2/NativeObject.h"
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "GPUBuffer.h"
+#include "GPUCommandBuffer.h"
+#include "descriptors/GPUCommandBufferDescriptor.h"
+#include "descriptors/GPUComputePassDescriptor.h"
+#include "GPUComputePassEncoder.h"
+#include "GPUExtent3D.h"
+#include "descriptors/GPUImageCopyBuffer.h"
+#include "descriptors/GPUImageCopyTexture.h"
+#include "GPUQuerySet.h"
+#include "descriptors/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

package/cpp/rnwgpu/api/GPUCompilationInfo.h

@@ -0,0 +1,79 @@
+#pragma once
+
+#include <string>
+#include <vector>
+
+#include "descriptors/Unions.h"
+
+#include "jsi2/NativeObject.h"
+
+#include "webgpu/webgpu_cpp.h"
+
+namespace rnwgpu {
+
+namespace jsi = facebook::jsi;
+
+struct GPUCompilationMessageData {
+  std::string message;
+  wgpu::CompilationMessageType type;
+  uint64_t lineNum;
+  uint64_t linePos;
+  uint64_t offset;
+  uint64_t length;
+};
+
+class GPUCompilationInfo : public NativeObject<GPUCompilationInfo> {
+public:
+  static constexpr const char *CLASS_NAME = "GPUCompilationInfo";
+
+  GPUCompilationInfo() : NativeObject(CLASS_NAME) {}
+
+public:
+  std::string getBrand() { return CLASS_NAME; }
+
+  std::vector<GPUCompilationMessageData> getMessages() { return _messages; }
+
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installGetter(runtime, prototype, "__brand", &GPUCompilationInfo::getBrand);
+    installGetter(runtime, prototype, "messages",
+                  &GPUCompilationInfo::getMessages);
+  }
+
+private:
+  std::vector<GPUCompilationMessageData> _messages;
+  friend class GPUShaderModule;
+};
+
+template <> struct JSIConverter<std::vector<GPUCompilationMessageData>> {
+  static std::vector<GPUCompilationMessageData>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    throw std::runtime_error("Invalid GPUCompilationMessageData::fromJSI()");
+  }
+  static jsi::Value toJSI(jsi::Runtime &runtime,
+                          std::vector<GPUCompilationMessageData> arg) {
+    jsi::Array result = jsi::Array(runtime, arg.size());
+    for (size_t i = 0; i < arg.size(); i++) {
+      const auto &message = arg[i];
+      jsi::Object messageObj(runtime);
+      messageObj.setProperty(
+          runtime, "message",
+          jsi::String::createFromUtf8(runtime, message.message));
+      std::string typeStr;
+      EnumMapper::convertEnumToJSUnion(message.type, &typeStr);
+      messageObj.setProperty(runtime, "type",
+                             jsi::String::createFromUtf8(runtime, typeStr));
+      messageObj.setProperty(runtime, "lineNum",
+                             static_cast<double>(message.lineNum));
+      messageObj.setProperty(runtime, "linePos",
+                             static_cast<double>(message.linePos));
+      messageObj.setProperty(runtime, "offset",
+                             static_cast<double>(message.offset));
+      messageObj.setProperty(runtime, "length",
+                             static_cast<double>(message.length));
+      result.setValueAtIndex(runtime, i, messageObj);
+    }
+    return result;
+  }
+};
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUCompilationMessage.h

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

package/cpp/rnwgpu/api/GPUComputePassEncoder.cpp

@@ -0,0 +1,60 @@
+#include "GPUComputePassEncoder.h"
+#include <memory>
+#include <string>
+
+namespace rnwgpu {
+
+void GPUComputePassEncoder::setPipeline(
+    std::shared_ptr<GPUComputePipeline> pipeline) {
+  _instance.SetPipeline(pipeline->get());
+}
+
+void GPUComputePassEncoder::end() { _instance.End(); }
+
+void GPUComputePassEncoder::setBindGroup(
+    uint32_t index,
+    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(index, nullptr, 0, nullptr);
+    } else {
+      auto group = std::get<std::shared_ptr<GPUBindGroup>>(bindGroup);
+      _instance.SetBindGroup(index, group->get(), 0, nullptr);
+    }
+  } else {
+    if (std::holds_alternative<std::nullptr_t>(bindGroup)) {
+      _instance.SetBindGroup(index, nullptr, dynOffsets.size(),
+                             dynamicOffsets->data());
+    } else {
+      auto group = std::get<std::shared_ptr<GPUBindGroup>>(bindGroup);
+      _instance.SetBindGroup(index, group->get(), dynOffsets.size(),
+                             dynamicOffsets->data());
+    }
+  }
+}
+
+void GPUComputePassEncoder::dispatchWorkgroups(
+    uint32_t workgroupCountX, std::optional<uint32_t> workgroupCountY,
+    std::optional<uint32_t> workgroupCountZ) {
+  _instance.DispatchWorkgroups(workgroupCountX, workgroupCountY.value_or(1),
+                               workgroupCountZ.value_or(1));
+}
+
+void GPUComputePassEncoder::dispatchWorkgroupsIndirect(
+    std::shared_ptr<GPUBuffer> indirectBuffer, uint64_t indirectOffset) {
+  _instance.DispatchWorkgroupsIndirect(indirectBuffer->get(), indirectOffset);
+}
+
+void GPUComputePassEncoder::pushDebugGroup(std::string groupLabel) {
+  _instance.PushDebugGroup(groupLabel.c_str());
+}
+
+void GPUComputePassEncoder::popDebugGroup() { _instance.PopDebugGroup(); }
+
+void GPUComputePassEncoder::insertDebugMarker(std::string markerLabel) {
+  _instance.InsertDebugMarker(markerLabel.c_str());
+}
+
+} // namespace rnwgpu