@shopify/react-native-skia 2.10.0 → 2.11.0-next.1

package/cpp/rnwgpu/api/GPUCommandEncoder.h

@@ -1,111 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <string>
-
-#include "descriptors/Unions.h"
-
-#include "jsi/NativeObject.h"
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "GPUBuffer.h"
-#include "GPUCommandBuffer.h"
-#include "GPUComputePassEncoder.h"
-#include "GPUExtent3D.h"
-#include "GPUQuerySet.h"
-#include "GPURenderPassEncoder.h"
-#include "descriptors/GPUCommandBufferDescriptor.h"
-#include "descriptors/GPUComputePassDescriptor.h"
-#include "descriptors/GPUImageCopyBuffer.h"
-#include "descriptors/GPUImageCopyTexture.h"
-#include "descriptors/GPURenderPassDescriptor.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

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

@@ -1,36 +0,0 @@
-#pragma once
-
-#include <string>
-
-#include "descriptors/Unions.h"
-
-#include "jsi/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

@@ -1,60 +0,0 @@
-#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

@@ -1,85 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <optional>
-#include <string>
-#include <variant>
-#include <vector>
-
-#include "descriptors/Unions.h"
-
-#include "jsi/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

@@ -1,12 +0,0 @@
-#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

@@ -1,60 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <string>
-
-#include "descriptors/Unions.h"
-
-#include "jsi/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