@shopify/react-native-skia 2.9.1 → 2.10.1

package/cpp/rnwgpu/api/GPUBindGroupLayout.h

@@ -1,52 +0,0 @@
-#pragma once
-
-#include <string>
-
-#include "descriptors/Unions.h"
-
-#include "jsi2/NativeObject.h"
-
-#include "webgpu/webgpu_cpp.h"
-
-namespace rnwgpu {
-
-namespace jsi = facebook::jsi;
-
-class GPUBindGroupLayout : public NativeObject<GPUBindGroupLayout> {
-public:
-  static constexpr const char *CLASS_NAME = "GPUBindGroupLayout";
-
-  explicit GPUBindGroupLayout(wgpu::BindGroupLayout 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", &GPUBindGroupLayout::getBrand);
-    installGetterSetter(runtime, prototype, "label",
-                        &GPUBindGroupLayout::getLabel,
-                        &GPUBindGroupLayout::setLabel);
-  }
-
-  inline const wgpu::BindGroupLayout get() { return _instance; }
-
-  size_t getMemoryPressure() override {
-    // Bind group layouts define the structure/schema for bind groups
-    // They store binding descriptors, types, and validation info
-    // Estimate: 512 bytes per layout (smaller than actual bind groups)
-    return 512;
-  }
-
-private:
-  wgpu::BindGroupLayout _instance;
-  std::string _label;
-};
-
-} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUBuffer.cpp

@@ -1,107 +0,0 @@
-#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(jsi::Runtime &runtime,
-                                           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);
-
-  // Post to the CALLING runtime's context, not the one captured at buffer
-  // creation (_async): the buffer may have been created on another runtime and
-  // boxed across (e.g. device created on the main JS runtime, mapAsync called
-  // from a worklet). The returned Promise lives on the calling runtime, so it
-  // must be settled from that runtime's own thread — and postTask itself
-  // schedules the pump through its context's runtime (setTimeout), which is
-  // only safe for the runtime we are currently executing on.
-  auto context =
-      async::RuntimeContext::getOrCreate(runtime, _async->instance());
-  return context->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

@@ -1,88 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <optional>
-#include <string>
-#include <vector>
-
-#include "descriptors/Unions.h"
-
-#include "jsi2/NativeObject.h"
-
-#include "rnwgpu/async/AsyncTaskHandle.h"
-#include "rnwgpu/async/RuntimeContext.h"
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "rnwgpu/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::RuntimeContext> async,
-                     std::string label)
-      : NativeObject(CLASS_NAME), _instance(instance), _async(async),
-        _label(label) {}
-
-public:
-  std::string getBrand() { return CLASS_NAME; }
-
-  async::AsyncTaskHandle mapAsync(jsi::Runtime &runtime, 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);
-    installMethodWithRuntime(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::RuntimeContext> _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

@@ -1,75 +0,0 @@
-#include "GPUCanvasContext.h"
-#include "Convertors.h"
-#include <algorithm>
-#include <memory>
-#include <utility>
-#include <vector>
-
-namespace rnwgpu {
-
-void GPUCanvasContext::configure(
-    std::shared_ptr<GPUCanvasConfiguration> configuration) {
-  Convertor conv;
-  wgpu::SurfaceConfiguration surfaceConfiguration;
-  surfaceConfiguration.device = configuration->device->get();
-  if (!conv(surfaceConfiguration.usage, configuration->usage) ||
-      !conv(surfaceConfiguration.format, configuration->format)) {
-    throw std::runtime_error("Error with SurfaceConfiguration");
-  }
-  // viewFormats are deep-copied into SurfaceInfo (which outlives this call);
-  // Convertor-allocated arrays would dangle.
-  std::vector<wgpu::TextureFormat> viewFormats;
-  if (configuration->viewFormats.has_value()) {
-    viewFormats = configuration->viewFormats.value();
-  }
-
-#ifdef __APPLE__
-  surfaceConfiguration.alphaMode = configuration->alphaMode;
-#endif
-  surfaceConfiguration.presentMode = wgpu::PresentMode::Fifo;
-  _surfaceInfo->configure(surfaceConfiguration, std::move(viewFormats));
-}
-
-void GPUCanvasContext::unconfigure() { _surfaceInfo->unconfigure(); }
-
-std::shared_ptr<GPUTexture> GPUCanvasContext::getCurrentTexture() {
-  if (!_surfaceInfo->isConfigured()) {
-    // Web parity: on the web this is an InvalidStateError, not a crash.
-    throw std::runtime_error(
-        "[WebGPU] getCurrentTexture() called on a canvas context that is not "
-        "configured; call context.configure() first");
-  }
-  // The drawing buffer tracks canvas.width/height (like on the web); resize it
-  // lazily when they changed. Sizes are clamped to 1 so a canvas that has not
-  // been laid out yet (0x0) keeps working.
-  auto prevSize = _surfaceInfo->getConfig();
-  auto width = std::max(1, _canvas->getWidth());
-  auto height = std::max(1, _canvas->getHeight());
-  auto sizeHasChanged = prevSize.width != static_cast<uint32_t>(width) ||
-                        prevSize.height != static_cast<uint32_t>(height);
-  if (sizeHasChanged) {
-    _surfaceInfo->reconfigure(width, height);
-  }
-
-  auto texture = _surfaceInfo->getCurrentTexture();
-  if (texture == nullptr) {
-    throw std::runtime_error(
-        "[WebGPU] getCurrentTexture() failed to acquire a texture");
-  }
-
-  auto size = _surfaceInfo->getSize();
-  _canvas->setClientWidth(size.width);
-  _canvas->setClientHeight(size.height);
-
-  return std::make_shared<GPUTexture>(texture, "", false);
-}
-
-void GPUCanvasContext::present() {
-  // presentFrame() is the end-of-frame boundary: it presents when this frame's
-  // texture was acquired from the on-screen surface (offscreen and dropped
-  // frames are skipped), clears the frame state, and adopts any surface that
-  // attached while the frame was in flight.
-  _surfaceInfo->presentFrame();
-}
-
-} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUCanvasContext.h

@@ -1,70 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <string>
-#include <utility>
-
-#include "descriptors/Unions.h"
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "jsi2/NativeObject.h"
-
-#include "GPU.h"
-#include "GPUTexture.h"
-#include "descriptors/GPUCanvasConfiguration.h"
-#include "rnwgpu/Canvas.h"
-#include "rnwgpu/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);
-  }
-
-  inline const wgpu::Surface get() { return nullptr; }
-  void configure(std::shared_ptr<GPUCanvasConfiguration> configuration);
-  void unconfigure();
-  std::shared_ptr<GPUTexture> getCurrentTexture();
-  // Present is explicit on every runtime (main JS, Reanimated UI, and dedicated
-  // worklet runtimes). It runs synchronously on the calling thread, preserving
-  // Dawn surface thread-affinity; frames rendered offscreen (no surface
-  // attached) are skipped. It is also the end-of-frame boundary at which a
-  // newly attached native surface is adopted (see SurfaceInfo).
-  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

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

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