@shopify/react-native-skia 2.4.15 → 2.4.17

package/cpp/rnwgpu/api/GPUComputePassEncoder.h

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

package/cpp/rnwgpu/api/GPUDevice.cpp

@@ -0,0 +1,434 @@
+#include "GPUDevice.h"
+
+#include <memory>
+#include <string>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+
+#include "Convertors.h"
+#include "jsi2/JSIConverter.h"
+
+#include "GPUFeatures.h"
+#include "GPUInternalError.h"
+#include "GPUOutOfMemoryError.h"
+#include "GPUValidationError.h"
+
+namespace rnwgpu {
+
+void GPUDevice::notifyDeviceLost(wgpu::DeviceLostReason reason,
+                                 std::string message) {
+  if (_lostSettled) {
+    return;
+  }
+
+  _lostSettled = true;
+  _lostInfo = std::make_shared<GPUDeviceLostInfo>(reason, std::move(message));
+
+  if (_lostResolve.has_value()) {
+    auto resolve = std::move(*_lostResolve);
+    _lostResolve.reset();
+    resolve([info = _lostInfo](jsi::Runtime &runtime) mutable {
+      return JSIConverter<std::shared_ptr<GPUDeviceLostInfo>>::toJSI(runtime,
+                                                                     info);
+    });
+  }
+
+  _lostHandle.reset();
+}
+
+void GPUDevice::forceLossForTesting() {
+  // wgpu::StringView view("forceLossForTesting invoked from JS");
+  _instance.ForceLoss(wgpu::DeviceLostReason::Unknown,
+                      "forceLossForTesting invoked from JS");
+}
+
+std::shared_ptr<GPUBuffer>
+GPUDevice::createBuffer(std::shared_ptr<GPUBufferDescriptor> descriptor) {
+  wgpu::BufferDescriptor desc;
+  Convertor conv;
+  if (!conv(desc, descriptor)) {
+    throw std::runtime_error(
+        "GPUDevice::createBuffer(): Error with GPUBufferDescriptor");
+  }
+  auto result = _instance.CreateBuffer(&desc);
+  return std::make_shared<GPUBuffer>(result, _async,
+                                     descriptor->label.value_or(""));
+}
+
+std::shared_ptr<GPUSupportedLimits> GPUDevice::getLimits() {
+  wgpu::Limits limits{};
+  if (!_instance.GetLimits(&limits)) {
+    throw std::runtime_error("failed to get device limits");
+  }
+  return std::make_shared<GPUSupportedLimits>(limits);
+}
+
+std::shared_ptr<GPUQueue> GPUDevice::getQueue() {
+  auto result = _instance.GetQueue();
+  return std::make_shared<GPUQueue>(result, _async, _label);
+}
+
+std::shared_ptr<GPUCommandEncoder> GPUDevice::createCommandEncoder(
+    std::optional<std::shared_ptr<GPUCommandEncoderDescriptor>> descriptor) {
+  wgpu::CommandEncoderDescriptor desc;
+  Convertor conv;
+  if (!conv(desc, descriptor)) {
+    throw std::runtime_error("Error with GPUCommandEncoderDescriptor");
+  }
+  auto result = _instance.CreateCommandEncoder(&desc);
+  return std::make_shared<GPUCommandEncoder>(
+      result,
+      descriptor.has_value() ? descriptor.value()->label.value_or("") : "");
+}
+
+void GPUDevice::destroy() {
+  _instance.Destroy();
+  notifyDeviceLost(wgpu::DeviceLostReason::Destroyed, "device was destroyed");
+}
+
+std::shared_ptr<GPUTexture>
+GPUDevice::createTexture(std::shared_ptr<GPUTextureDescriptor> descriptor) {
+  wgpu::TextureDescriptor desc;
+  Convertor conv;
+  if (!conv(desc, descriptor)) {
+    throw std::runtime_error("Error with GPUTextureDescriptor");
+  }
+  auto texture = _instance.CreateTexture(&desc);
+  return std::make_shared<GPUTexture>(texture, descriptor->label.value_or(""));
+}
+
+std::shared_ptr<GPUShaderModule> GPUDevice::createShaderModule(
+    std::shared_ptr<GPUShaderModuleDescriptor> descriptor) {
+  wgpu::ShaderSourceWGSL wgsl_desc{};
+  wgpu::ShaderModuleDescriptor sm_desc{};
+  Convertor conv;
+  if (!conv(wgsl_desc.code, descriptor->code) ||
+      !conv(sm_desc.label, descriptor->label)) {
+    return {};
+  }
+  sm_desc.nextInChain = &wgsl_desc;
+  if (descriptor->code.find('\0') != std::string::npos) {
+    auto mod = _instance.CreateErrorShaderModule(
+        &sm_desc, "The WGSL shader contains an illegal character '\\0'");
+    return std::make_shared<GPUShaderModule>(mod, _async, sm_desc.label.data);
+  }
+  auto module = _instance.CreateShaderModule(&sm_desc);
+  return std::make_shared<GPUShaderModule>(module, _async,
+                                           descriptor->label.value_or(""));
+}
+
+std::shared_ptr<GPURenderPipeline> GPUDevice::createRenderPipeline(
+    std::shared_ptr<GPURenderPipelineDescriptor> descriptor) {
+  wgpu::RenderPipelineDescriptor desc{};
+  Convertor conv;
+  if (!conv(desc, descriptor)) {
+    throw std::runtime_error("Error with GPURenderPipelineDescriptor");
+  }
+  // assert(desc.fragment != nullptr && "Fragment state must not be null");
+  auto renderPipeline = _instance.CreateRenderPipeline(&desc);
+  return std::make_shared<GPURenderPipeline>(renderPipeline,
+                                             descriptor->label.value_or(""));
+}
+
+std::shared_ptr<GPUBindGroup>
+GPUDevice::createBindGroup(std::shared_ptr<GPUBindGroupDescriptor> descriptor) {
+  Convertor conv;
+  wgpu::BindGroupDescriptor desc{};
+  if (!conv(desc.label, descriptor->label) ||
+      !conv(desc.layout, descriptor->layout) ||
+      !conv(desc.entries, desc.entryCount, descriptor->entries)) {
+    throw std::runtime_error(
+        "GPUBindGroup::createBindGroup(): Error with GPUBindGroupDescriptor");
+  }
+  auto bindGroup = _instance.CreateBindGroup(&desc);
+  return std::make_shared<GPUBindGroup>(bindGroup,
+                                        descriptor->label.value_or(""));
+}
+
+std::shared_ptr<GPUSampler> GPUDevice::createSampler(
+    std::optional<std::shared_ptr<GPUSamplerDescriptor>> descriptor) {
+  wgpu::SamplerDescriptor desc;
+  Convertor conv;
+  if (!conv(desc, descriptor)) {
+    throw std::runtime_error("GPUDevice::createSampler(): Error with "
+                             "GPUSamplerDescriptor");
+  }
+  auto sampler = _instance.CreateSampler(&desc);
+  return std::make_shared<GPUSampler>(
+      sampler,
+      descriptor.has_value() ? descriptor.value()->label.value_or("") : "");
+}
+
+std::shared_ptr<GPUComputePipeline> GPUDevice::createComputePipeline(
+    std::shared_ptr<GPUComputePipelineDescriptor> descriptor) {
+  wgpu::ComputePipelineDescriptor desc;
+  Convertor conv;
+  if (!conv(desc, descriptor)) {
+    throw std::runtime_error("GPUDevice::createComputePipeline(): Error with "
+                             "GPUComputePipelineDescriptor");
+  }
+  auto computePipeline = _instance.CreateComputePipeline(&desc);
+  return std::make_shared<GPUComputePipeline>(computePipeline,
+                                              descriptor->label.value_or(""));
+}
+
+std::shared_ptr<GPUQuerySet>
+GPUDevice::createQuerySet(std::shared_ptr<GPUQuerySetDescriptor> descriptor) {
+  wgpu::QuerySetDescriptor desc;
+  Convertor conv;
+  if (!conv(desc, descriptor)) {
+    throw std::runtime_error("GPUDevice::createQuerySet(): Error with "
+                             "GPUQuerySetDescriptor");
+  }
+  auto querySet = _instance.CreateQuerySet(&desc);
+  return std::make_shared<GPUQuerySet>(querySet,
+                                       descriptor->label.value_or(""));
+}
+
+std::shared_ptr<GPURenderBundleEncoder> GPUDevice::createRenderBundleEncoder(
+    std::shared_ptr<GPURenderBundleEncoderDescriptor> descriptor) {
+  Convertor conv;
+
+  wgpu::RenderBundleEncoderDescriptor desc{};
+  if (!conv(desc.label, descriptor->label) ||
+      !conv(desc.colorFormats, desc.colorFormatCount,
+            descriptor->colorFormats) ||
+      !conv(desc.depthStencilFormat, descriptor->depthStencilFormat) ||
+      !conv(desc.sampleCount, descriptor->sampleCount) ||
+      !conv(desc.depthReadOnly, descriptor->depthReadOnly) ||
+      !conv(desc.stencilReadOnly, descriptor->stencilReadOnly)) {
+    return {};
+  }
+  return std::make_shared<GPURenderBundleEncoder>(
+      _instance.CreateRenderBundleEncoder(&desc),
+      descriptor->label.value_or(""));
+}
+
+std::shared_ptr<GPUBindGroupLayout> GPUDevice::createBindGroupLayout(
+    std::shared_ptr<GPUBindGroupLayoutDescriptor> descriptor) {
+  Convertor conv;
+
+  wgpu::BindGroupLayoutDescriptor desc{};
+  if (!conv(desc.label, descriptor->label) ||
+      !conv(desc.entries, desc.entryCount, descriptor->entries)) {
+    return {};
+  }
+  return std::make_shared<GPUBindGroupLayout>(
+      _instance.CreateBindGroupLayout(&desc), descriptor->label.value_or(""));
+}
+
+std::shared_ptr<GPUPipelineLayout> GPUDevice::createPipelineLayout(
+    std::shared_ptr<GPUPipelineLayoutDescriptor> descriptor) {
+  Convertor conv;
+
+  wgpu::PipelineLayoutDescriptor desc{};
+  if (!conv(desc.label, descriptor->label) ||
+      !conv(desc.bindGroupLayouts, desc.bindGroupLayoutCount,
+            descriptor->bindGroupLayouts)) {
+    return {};
+  }
+  return std::make_shared<GPUPipelineLayout>(
+      _instance.CreatePipelineLayout(&desc), descriptor->label.value_or(""));
+}
+
+std::shared_ptr<GPUExternalTexture> GPUDevice::importExternalTexture(
+    std::shared_ptr<GPUExternalTextureDescriptor> descriptor) {
+  throw std::runtime_error(
+      "GPUDevice::importExternalTexture(): Not implemented");
+}
+
+async::AsyncTaskHandle GPUDevice::createComputePipelineAsync(
+    std::shared_ptr<GPUComputePipelineDescriptor> descriptor) {
+  wgpu::ComputePipelineDescriptor desc{};
+  Convertor conv;
+  if (!conv(desc, descriptor)) {
+    throw std::runtime_error("GPUDevice::createComputePipeline(): Error with "
+                             "GPUComputePipelineDescriptor");
+  }
+
+  auto label = std::string(
+      descriptor->label.has_value() ? descriptor->label.value() : "");
+  auto pipelineHolder = std::make_shared<GPUComputePipeline>(nullptr, label);
+
+  return _async->postTask([device = _instance, desc, descriptor,
+                           pipelineHolder](
+                              const async::AsyncTaskHandle::ResolveFunction
+                                  &resolve,
+                              const async::AsyncTaskHandle::RejectFunction
+                                  &reject) {
+    (void)descriptor;
+    device.CreateComputePipelineAsync(
+        &desc, wgpu::CallbackMode::AllowProcessEvents,
+        [pipelineHolder, resolve,
+         reject](wgpu::CreatePipelineAsyncStatus status,
+                 wgpu::ComputePipeline pipeline, const char *msg) mutable {
+          if (status == wgpu::CreatePipelineAsyncStatus::Success && pipeline) {
+            pipelineHolder->_instance = pipeline;
+            resolve([pipelineHolder](jsi::Runtime &runtime) mutable {
+              return JSIConverter<std::shared_ptr<GPUComputePipeline>>::toJSI(
+                  runtime, pipelineHolder);
+            });
+          } else {
+            std::string error =
+                msg ? std::string(msg) : "Failed to create compute pipeline";
+            reject(std::move(error));
+          }
+        });
+  });
+}
+
+async::AsyncTaskHandle GPUDevice::createRenderPipelineAsync(
+    std::shared_ptr<GPURenderPipelineDescriptor> descriptor) {
+  wgpu::RenderPipelineDescriptor desc{};
+  Convertor conv;
+  if (!conv(desc, descriptor)) {
+    throw std::runtime_error(
+        "GPUDevice::createRenderPipelineAsync(): Error with "
+        "GPURenderPipelineDescriptor");
+  }
+
+  auto label = std::string(
+      descriptor->label.has_value() ? descriptor->label.value() : "");
+  auto pipelineHolder = std::make_shared<GPURenderPipeline>(nullptr, label);
+
+  return _async->postTask([device = _instance, desc, descriptor,
+                           pipelineHolder](
+                              const async::AsyncTaskHandle::ResolveFunction
+                                  &resolve,
+                              const async::AsyncTaskHandle::RejectFunction
+                                  &reject) {
+    (void)descriptor;
+    device.CreateRenderPipelineAsync(
+        &desc, wgpu::CallbackMode::AllowProcessEvents,
+        [pipelineHolder, resolve,
+         reject](wgpu::CreatePipelineAsyncStatus status,
+                 wgpu::RenderPipeline pipeline, const char *msg) mutable {
+          if (status == wgpu::CreatePipelineAsyncStatus::Success && pipeline) {
+            pipelineHolder->_instance = pipeline;
+            resolve([pipelineHolder](jsi::Runtime &runtime) mutable {
+              return JSIConverter<std::shared_ptr<GPURenderPipeline>>::toJSI(
+                  runtime, pipelineHolder);
+            });
+          } else {
+            std::string error =
+                msg ? std::string(msg) : "Failed to create render pipeline";
+            reject(std::move(error));
+          }
+        });
+  });
+}
+
+void GPUDevice::pushErrorScope(wgpu::ErrorFilter filter) {
+  _instance.PushErrorScope(filter);
+}
+
+async::AsyncTaskHandle GPUDevice::popErrorScope() {
+  auto device = _instance;
+
+  return _async->postTask([device](const async::AsyncTaskHandle::ResolveFunction
+                                       &resolve,
+                                   const async::AsyncTaskHandle::RejectFunction
+                                       &reject) {
+    device.PopErrorScope(
+        wgpu::CallbackMode::AllowProcessEvents,
+        [resolve, reject](wgpu::PopErrorScopeStatus status,
+                          wgpu::ErrorType type, wgpu::StringView message) {
+          if (status == wgpu::PopErrorScopeStatus::Error ||
+              status == wgpu::PopErrorScopeStatus::CallbackCancelled) {
+            reject("PopErrorScope failed");
+            return;
+          }
+
+          std::string messageString =
+              message.length ? std::string(message.data, message.length) : "";
+
+          switch (type) {
+          case wgpu::ErrorType::NoError:
+            resolve([](jsi::Runtime &runtime) mutable {
+              return jsi::Value::null();
+            });
+            break;
+          case wgpu::ErrorType::Validation: {
+            auto error = std::make_shared<GPUValidationError>(messageString);
+            resolve([error](jsi::Runtime &runtime) mutable {
+              return JSIConverter<std::shared_ptr<GPUValidationError>>::toJSI(
+                  runtime, error);
+            });
+            break;
+          }
+          case wgpu::ErrorType::OutOfMemory: {
+            auto error = std::make_shared<GPUOutOfMemoryError>(messageString);
+            resolve([error](jsi::Runtime &runtime) mutable {
+              return JSIConverter<std::shared_ptr<GPUOutOfMemoryError>>::toJSI(
+                  runtime, error);
+            });
+            break;
+          }
+          case wgpu::ErrorType::Internal:
+          case wgpu::ErrorType::Unknown: {
+            auto error = std::make_shared<GPUInternalError>(messageString);
+            resolve([error](jsi::Runtime &runtime) mutable {
+              return JSIConverter<std::shared_ptr<GPUInternalError>>::toJSI(
+                  runtime, error);
+            });
+            break;
+          }
+          default:
+            reject("Unhandled GPU error type");
+            return;
+          }
+        });
+  });
+}
+
+std::unordered_set<std::string> GPUDevice::getFeatures() {
+  wgpu::SupportedFeatures supportedFeatures;
+  _instance.GetFeatures(&supportedFeatures);
+  std::unordered_set<std::string> result;
+  for (size_t i = 0; i < supportedFeatures.featureCount; ++i) {
+    auto feature = supportedFeatures.features[i];
+    std::string name;
+    convertEnumToJSUnion(feature, &name);
+    result.insert(name);
+  }
+  return result;
+}
+
+async::AsyncTaskHandle GPUDevice::getLost() {
+  if (_lostHandle.has_value()) {
+    return *_lostHandle;
+  }
+
+  if (_lostSettled && _lostInfo) {
+    return _async->postTask(
+        [info = _lostInfo](
+            const async::AsyncTaskHandle::ResolveFunction &resolve,
+            const async::AsyncTaskHandle::RejectFunction & /*reject*/) {
+          resolve([info](jsi::Runtime &runtime) mutable {
+            return JSIConverter<std::shared_ptr<GPUDeviceLostInfo>>::toJSI(
+                runtime, info);
+          });
+        },
+        false);
+  }
+
+  auto handle = _async->postTask(
+      [this](const async::AsyncTaskHandle::ResolveFunction &resolve,
+             const async::AsyncTaskHandle::RejectFunction & /*reject*/) {
+        if (_lostSettled && _lostInfo) {
+          resolve([info = _lostInfo](jsi::Runtime &runtime) mutable {
+            return JSIConverter<std::shared_ptr<GPUDeviceLostInfo>>::toJSI(
+                runtime, info);
+          });
+          return;
+        }
+
+        _lostResolve = resolve;
+      },
+      false);
+
+  _lostHandle = handle;
+  return handle;
+}
+} // namespace rnwgpu