react-native-webgpu 0.5.11

package/cpp/rnwgpu/api/GPUCompilationInfo.h

@@ -0,0 +1,79 @@
+#pragma once
+
+#include <string>
+#include <vector>
+
+#include "Unions.h"
+
+#include "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 "Unions.h"
+
+#include "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

package/cpp/rnwgpu/api/GPUComputePassEncoder.h

@@ -0,0 +1,85 @@
+#pragma once
+
+#include <memory>
+#include <optional>
+#include <string>
+#include <variant>
+#include <vector>
+
+#include "Unions.h"
+
+#include "NativeObject.h"
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "GPUBindGroup.h"
+#include "GPUBuffer.h"
+#include "GPUComputePipeline.h"
+
+namespace rnwgpu {
+
+namespace jsi = facebook::jsi;
+
+class GPUComputePassEncoder : public NativeObject<GPUComputePassEncoder> {
+public:
+  static constexpr const char *CLASS_NAME = "GPUComputePassEncoder";
+
+  explicit GPUComputePassEncoder(wgpu::ComputePassEncoder instance,
+                                 std::string label)
+      : NativeObject(CLASS_NAME), _instance(instance), _label(label) {}
+
+public:
+  std::string getBrand() { return CLASS_NAME; }
+
+  void setPipeline(std::shared_ptr<GPUComputePipeline> pipeline);
+  void dispatchWorkgroups(uint32_t workgroupCountX,
+                          std::optional<uint32_t> workgroupCountY,
+                          std::optional<uint32_t> workgroupCountZ);
+  void dispatchWorkgroupsIndirect(std::shared_ptr<GPUBuffer> indirectBuffer,
+                                  uint64_t indirectOffset);
+  void end();
+  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);
+
+  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",
+                  &GPUComputePassEncoder::getBrand);
+    installMethod(runtime, prototype, "setPipeline",
+                  &GPUComputePassEncoder::setPipeline);
+    installMethod(runtime, prototype, "dispatchWorkgroups",
+                  &GPUComputePassEncoder::dispatchWorkgroups);
+    installMethod(runtime, prototype, "dispatchWorkgroupsIndirect",
+                  &GPUComputePassEncoder::dispatchWorkgroupsIndirect);
+    installMethod(runtime, prototype, "end", &GPUComputePassEncoder::end);
+    installMethod(runtime, prototype, "pushDebugGroup",
+                  &GPUComputePassEncoder::pushDebugGroup);
+    installMethod(runtime, prototype, "popDebugGroup",
+                  &GPUComputePassEncoder::popDebugGroup);
+    installMethod(runtime, prototype, "insertDebugMarker",
+                  &GPUComputePassEncoder::insertDebugMarker);
+    installMethod(runtime, prototype, "setBindGroup",
+                  &GPUComputePassEncoder::setBindGroup);
+    installGetterSetter(runtime, prototype, "label",
+                        &GPUComputePassEncoder::getLabel,
+                        &GPUComputePassEncoder::setLabel);
+  }
+
+  inline const wgpu::ComputePassEncoder get() { return _instance; }
+
+private:
+  wgpu::ComputePassEncoder _instance;
+  std::string _label;
+};
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUComputePipeline.cpp

@@ -0,0 +1,12 @@
+#include "GPUComputePipeline.h"
+#include <memory>
+
+namespace rnwgpu {
+
+std::shared_ptr<GPUBindGroupLayout>
+GPUComputePipeline::getBindGroupLayout(uint32_t groupIndex) {
+  auto bindGroup = _instance.GetBindGroupLayout(groupIndex);
+  return std::make_shared<GPUBindGroupLayout>(bindGroup, "");
+}
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUComputePipeline.h

@@ -0,0 +1,60 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "Unions.h"
+
+#include "NativeObject.h"
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "GPUBindGroupLayout.h"
+
+namespace rnwgpu {
+
+namespace jsi = facebook::jsi;
+
+class GPUComputePipeline : public NativeObject<GPUComputePipeline> {
+public:
+  static constexpr const char *CLASS_NAME = "GPUComputePipeline";
+
+  explicit GPUComputePipeline(wgpu::ComputePipeline instance, std::string label)
+      : NativeObject(CLASS_NAME), _instance(instance), _label(label) {}
+
+public:
+  std::string getBrand() { return CLASS_NAME; }
+
+  std::shared_ptr<GPUBindGroupLayout> getBindGroupLayout(uint32_t index);
+
+  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", &GPUComputePipeline::getBrand);
+    installMethod(runtime, prototype, "getBindGroupLayout",
+                  &GPUComputePipeline::getBindGroupLayout);
+    installGetterSetter(runtime, prototype, "label",
+                        &GPUComputePipeline::getLabel,
+                        &GPUComputePipeline::setLabel);
+  }
+
+  inline const wgpu::ComputePipeline get() { return _instance; }
+
+  size_t getMemoryPressure() override {
+    // Compute pipelines contain compiled compute shader state and
+    // driver-specific optimized code
+    // Estimate: 16KB for a typical compute pipeline (single compute shader)
+    return 16 * 1024;
+  }
+
+private:
+  wgpu::ComputePipeline _instance;
+  std::string _label;
+  friend class GPUDevice;
+};
+
+} // namespace rnwgpu