@shopify/react-native-skia 2.10.0 → 2.10.2

package/cpp/rnwgpu/api/GPURenderPipeline.h

@@ -1,61 +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 GPURenderPipeline : public NativeObject<GPURenderPipeline> {
-public:
-  static constexpr const char *CLASS_NAME = "GPURenderPipeline";
-
-  explicit GPURenderPipeline(wgpu::RenderPipeline 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", &GPURenderPipeline::getBrand);
-    installMethod(runtime, prototype, "getBindGroupLayout",
-                  &GPURenderPipeline::getBindGroupLayout);
-    installGetterSetter(runtime, prototype, "label",
-                        &GPURenderPipeline::getLabel,
-                        &GPURenderPipeline::setLabel);
-  }
-
-  inline const wgpu::RenderPipeline get() { return _instance; }
-
-  size_t getMemoryPressure() override {
-    // Render pipelines contain compiled shader state, vertex/fragment shaders,
-    // render state, and driver-specific optimized code
-    // Estimate: 24KB for a typical render pipeline with vertex + fragment
-    // shaders
-    return 24 * 1024;
-  }
-
-private:
-  wgpu::RenderPipeline _instance;
-  std::string _label;
-  friend class GPUDevice;
-};
-
-} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUSampler.h

@@ -1,44 +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 GPUSampler : public NativeObject<GPUSampler> {
-public:
-  static constexpr const char *CLASS_NAME = "GPUSampler";
-
-  explicit GPUSampler(wgpu::Sampler 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", &GPUSampler::getBrand);
-    installGetterSetter(runtime, prototype, "label", &GPUSampler::getLabel,
-                        &GPUSampler::setLabel);
-  }
-
-  inline const wgpu::Sampler get() { return _instance; }
-
-private:
-  wgpu::Sampler _instance;
-  std::string _label;
-};
-
-} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUShaderModule.cpp

@@ -1,56 +0,0 @@
-#include "GPUShaderModule.h"
-
-#include <memory>
-#include <utility>
-
-#include "jsi/JSIConverter.h"
-
-namespace rnwgpu {
-
-async::AsyncTaskHandle
-GPUShaderModule::getCompilationInfo(jsi::Runtime &runtime) {
-  auto module = _instance;
-
-  // Post to the CALLING runtime's context so the promise settles on the
-  // thread that requested it (see GPUBuffer::mapAsync).
-  auto context =
-      async::RuntimeContext::getOrCreate(runtime, _async->instance());
-  return context->postTask(
-      [module](const async::AsyncTaskHandle::ResolveFunction &resolve,
-               const async::AsyncTaskHandle::RejectFunction &reject) {
-        auto result = std::make_shared<GPUCompilationInfo>();
-        module.GetCompilationInfo(
-            wgpu::CallbackMode::AllowProcessEvents,
-            [result, resolve,
-             reject](wgpu::CompilationInfoRequestStatus status,
-                     const wgpu::CompilationInfo *compilationInfo) {
-              if (status != wgpu::CompilationInfoRequestStatus::Success ||
-                  compilationInfo == nullptr) {
-                reject("Failed to get compilation info");
-                return;
-              }
-
-              result->_messages.reserve(compilationInfo->messageCount);
-              for (size_t i = 0; i < compilationInfo->messageCount; ++i) {
-                const auto &wgpuMessage = compilationInfo->messages[i];
-                GPUCompilationMessageData message;
-                message.message =
-                    wgpuMessage.message.length ? wgpuMessage.message.data : "";
-                message.type = wgpuMessage.type;
-                message.lineNum = wgpuMessage.lineNum;
-                message.linePos = wgpuMessage.linePos;
-                message.offset = wgpuMessage.offset;
-                message.length = wgpuMessage.length;
-                result->_messages.push_back(std::move(message));
-              }
-
-              resolve([result =
-                           std::move(result)](jsi::Runtime &runtime) mutable {
-                return JSIConverter<std::shared_ptr<GPUCompilationInfo>>::toJSI(
-                    runtime, result);
-              });
-            });
-      });
-}
-
-} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUShaderModule.h

@@ -1,66 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <string>
-
-#include "descriptors/Unions.h"
-
-#include "jsi/NativeObject.h"
-
-#include "rnwgpu/async/AsyncTaskHandle.h"
-#include "rnwgpu/async/RuntimeContext.h"
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "GPUCompilationInfo.h"
-
-namespace rnwgpu {
-
-namespace jsi = facebook::jsi;
-
-class GPUShaderModule : public NativeObject<GPUShaderModule> {
-public:
-  static constexpr const char *CLASS_NAME = "GPUShaderModule";
-
-  explicit GPUShaderModule(wgpu::ShaderModule 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 getCompilationInfo(jsi::Runtime &runtime);
-
-  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", &GPUShaderModule::getBrand);
-    installMethodWithRuntime(runtime, prototype, "getCompilationInfo",
-                             &GPUShaderModule::getCompilationInfo);
-    installGetterSetter(runtime, prototype, "label", &GPUShaderModule::getLabel,
-                        &GPUShaderModule::setLabel);
-  }
-
-  inline const wgpu::ShaderModule get() { return _instance; }
-
-  size_t getMemoryPressure() override {
-    // Estimate memory usage for compiled shader module
-    // Shaders can vary widely, but a reasonable estimate is 8-16KB for typical
-    // shaders Complex shaders (with many uniforms, textures, or computations)
-    // can be much larger
-    return 12 * 1024; // 12KB estimate for average shader
-  }
-
-private:
-  wgpu::ShaderModule _instance;
-  std::shared_ptr<async::RuntimeContext> _async;
-  std::string _label;
-};
-
-} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUSharedFence.cpp

@@ -1,80 +0,0 @@
-#include "GPUSharedFence.h"
-
-#include <cstdint>
-#include <string>
-
-#if defined(__ANDROID__)
-#include <fcntl.h>
-#endif
-
-namespace rnwgpu {
-
-namespace {
-
-// Kebab-case names matching the shared-fence-* feature strings (see Unions.h /
-// GPUFeatures.h).
-std::string sharedFenceTypeToString(wgpu::SharedFenceType type) {
-  switch (type) {
-  case wgpu::SharedFenceType::MTLSharedEvent:
-    return "mtl-shared-event";
-  case wgpu::SharedFenceType::SyncFD:
-    return "sync-fd";
-  case wgpu::SharedFenceType::VkSemaphoreOpaqueFD:
-    return "vk-semaphore-opaque-fd";
-  case wgpu::SharedFenceType::VkSemaphoreZirconHandle:
-    return "vk-semaphore-zircon-handle";
-  case wgpu::SharedFenceType::DXGISharedHandle:
-    return "dxgi-shared-handle";
-  case wgpu::SharedFenceType::EGLSync:
-    return "egl-sync";
-  default:
-    return "";
-  }
-}
-
-} // namespace
-
-jsi::Value GPUSharedFence::exportInfo(jsi::Runtime &runtime, const jsi::Value &,
-                                      const jsi::Value *, size_t) {
-  wgpu::SharedFenceExportInfo info{};
-  uint64_t handle = 0;
-
-#if defined(__APPLE__)
-  // Apple: the handle is an id<MTLSharedEvent> pointer.
-  wgpu::SharedFenceMTLSharedEventExportInfo mtlInfo{};
-  info.nextInChain = &mtlInfo;
-  _instance.ExportInfo(&info);
-  handle = reinterpret_cast<uint64_t>(mtlInfo.sharedEvent);
-#elif defined(__ANDROID__)
-  // Android: the handle is an OS file descriptor (sync_fd). Dawn's ExportInfo
-  // returns a BORROWED fd: it is owned by the SharedFence and closed when the
-  // fence is destroyed. This exported handle is documented as caller-owned (the
-  // caller must close() it), so dup() it. Without the dup the same fd is closed
-  // twice (once by the caller and once by Dawn on fence destruction), tripping
-  // Android's fdsan (double-close abort).
-  wgpu::SharedFenceSyncFDExportInfo fdInfo{};
-  info.nextInChain = &fdInfo;
-  _instance.ExportInfo(&info);
-  int exportedFd = fdInfo.handle >= 0
-                       ? ::fcntl(fdInfo.handle, F_DUPFD_CLOEXEC, 0)
-                       : fdInfo.handle;
-  handle = static_cast<uint64_t>(static_cast<uint32_t>(exportedFd));
-#else
-  // react-native-skia only targets Apple (Metal) and Android (Vulkan). On any
-  // other platform there is no native handle convention to expose, so fail
-  // loudly rather than handing back a meaningless handle of 0.
-  throw jsi::JSError(runtime,
-                     "GPUSharedFence::export(): unsupported platform (only "
-                     "Apple/Metal and Android/Vulkan are supported)");
-#endif
-
-  jsi::Object result(runtime);
-  result.setProperty(
-      runtime, "type",
-      jsi::String::createFromUtf8(runtime, sharedFenceTypeToString(info.type)));
-  result.setProperty(runtime, "handle",
-                     jsi::BigInt::fromUint64(runtime, handle));
-  return result;
-}
-
-} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUSharedFence.h

@@ -1,53 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <string>
-
-#include "jsi/NativeObject.h"
-
-#include "webgpu/webgpu_cpp.h"
-
-namespace rnwgpu {
-
-namespace jsi = facebook::jsi;
-
-// Wraps a wgpu::SharedFence: a native GPU sync primitive (id<MTLSharedEvent> on
-// Apple, sync-fd / VkSemaphore on Android).
-class GPUSharedFence : public NativeObject<GPUSharedFence> {
-public:
-  static constexpr const char *CLASS_NAME = "GPUSharedFence";
-
-  explicit GPUSharedFence(wgpu::SharedFence instance, std::string label)
-      : NativeObject(CLASS_NAME), _instance(std::move(instance)),
-        _label(std::move(label)) {}
-
-public:
-  std::string getBrand() { return CLASS_NAME; }
-
-  // export() -> { type, handle }: exposes the native handle (as a BigInt) so
-  // app code can wait on or signal the fence. The caller owns the returned
-  // handle (e.g. an exported sync-fd must be close()d).
-  jsi::Value exportInfo(jsi::Runtime &runtime, const jsi::Value &thisVal,
-                        const jsi::Value *args, size_t count);
-
-  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", &GPUSharedFence::getBrand);
-    installMethod(runtime, prototype, "export", &GPUSharedFence::exportInfo);
-    installGetterSetter(runtime, prototype, "label", &GPUSharedFence::getLabel,
-                        &GPUSharedFence::setLabel);
-  }
-
-  inline wgpu::SharedFence get() { return _instance; }
-
-private:
-  wgpu::SharedFence _instance;
-  std::string _label;
-};
-
-} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUSharedTextureMemory.cpp

@@ -1,135 +0,0 @@
-#include "GPUSharedTextureMemory.h"
-
-#include <cstdint>
-#include <memory>
-#include <optional>
-#include <stdexcept>
-#include <string>
-#include <vector>
-
-#include "Convertors.h"
-
-namespace rnwgpu {
-
-std::shared_ptr<GPUTexture> GPUSharedTextureMemory::createTexture(
-    std::optional<std::shared_ptr<GPUTextureDescriptor>> descriptor) {
-  if (!descriptor.has_value() || descriptor.value() == nullptr) {
-    auto texture = _instance.CreateTexture();
-    // The texture aliases the shared memory; it doesn't own GPU allocation, so
-    // it doesn't report memory pressure.
-    return std::make_shared<GPUTexture>(texture, "", false);
-  }
-
-  wgpu::TextureDescriptor desc{};
-  Convertor conv;
-  if (!conv(desc, descriptor.value())) {
-    throw std::runtime_error(
-        "GPUSharedTextureMemory::createTexture(): Error with "
-        "GPUTextureDescriptor");
-  }
-  auto texture = _instance.CreateTexture(&desc);
-  return std::make_shared<GPUTexture>(
-      texture, descriptor.value()->label.value_or(""), false);
-}
-
-void GPUSharedTextureMemory::beginAccess(
-    std::shared_ptr<GPUTexture> texture, bool initialized,
-    std::optional<std::vector<std::shared_ptr<GPUSharedFenceState>>> fences) {
-  if (!texture) {
-    throw std::runtime_error(
-        "GPUSharedTextureMemory::beginAccess(): texture is null");
-  }
-  wgpu::SharedTextureMemoryBeginAccessDescriptor desc{};
-  desc.initialized = initialized;
-  desc.concurrentRead = false;
-
-  // Built in lockstep so fenceCount covers both arrays, and kept in locals so
-  // the raw pointers outlive the synchronous BeginAccess() below.
-  std::vector<wgpu::SharedFence> rawFences;
-  std::vector<uint64_t> values;
-  if (fences.has_value()) {
-    for (const auto &state : *fences) {
-      if (state && state->fence) {
-        rawFences.push_back(state->fence->get());
-        values.push_back(state->signaledValue);
-      }
-    }
-  }
-  if (!rawFences.empty()) {
-    desc.fenceCount = rawFences.size();
-    desc.fences = rawFences.data();
-    desc.signaledValues = values.data();
-  } else {
-    desc.fenceCount = 0;
-    desc.fences = nullptr;
-    desc.signaledValues = nullptr;
-  }
-
-#if defined(__ANDROID__)
-  // Dawn's Vulkan backend (AHardwareBuffer) validates that the begin-access
-  // descriptor chains a SharedTextureMemoryVkImageLayoutBeginState specifying
-  // the VkImageLayout to acquire the image into. UNDEFINED (= 0) on both ends
-  // is the canonical "no prior GPU producer" pattern: Dawn performs an
-  // external-queue acquire from VK_QUEUE_FAMILY_EXTERNAL which preserves the
-  // AHB contents, then transitions to whatever layout the texture's actual
-  // usage requires.
-  wgpu::SharedTextureMemoryVkImageLayoutBeginState vkLayout{};
-  vkLayout.oldLayout = 0;
-  vkLayout.newLayout = 0;
-  desc.nextInChain = &vkLayout;
-#endif
-
-  auto status = _instance.BeginAccess(texture->get(), &desc);
-  if (!status) {
-    throw std::runtime_error("GPUSharedTextureMemory::beginAccess() failed");
-  }
-}
-
-jsi::Value GPUSharedTextureMemory::endAccess(jsi::Runtime &runtime,
-                                             const jsi::Value &,
-                                             const jsi::Value *args,
-                                             size_t count) {
-  if (count < 1 || !args[0].isObject()) {
-    throw jsi::JSError(
-        runtime, "GPUSharedTextureMemory::endAccess(): expected (texture)");
-  }
-  auto texture = GPUTexture::fromValue(runtime, args[0]);
-
-  wgpu::SharedTextureMemoryEndAccessState state{};
-
-#if defined(__ANDROID__)
-  // Dawn's Vulkan backend writes the released old/new VkImageLayouts back into
-  // a chained SharedTextureMemoryVkImageLayoutEndState; validation requires
-  // the chain even when the caller doesn't read the values.
-  wgpu::SharedTextureMemoryVkImageLayoutEndState vkLayout{};
-  state.nextInChain = &vkLayout;
-#endif
-
-  auto status = _instance.EndAccess(texture->get(), &state);
-  if (!status) {
-    throw jsi::JSError(runtime, "GPUSharedTextureMemory::endAccess() failed");
-  }
-
-  // Copy each wgpu::SharedFence (ref-counted) into its own GPUSharedFence
-  // wrapper before `state` is destroyed.
-  jsi::Array fences(runtime, state.fenceCount);
-  for (size_t i = 0; i < state.fenceCount; i++) {
-    wgpu::SharedFence fence = state.fences[i];
-    auto wrapper = std::make_shared<GPUSharedFence>(std::move(fence), "");
-    jsi::Object entry(runtime);
-    entry.setProperty(runtime, "fence",
-                      GPUSharedFence::create(runtime, std::move(wrapper)));
-    entry.setProperty(
-        runtime, "signaledValue",
-        jsi::BigInt::fromUint64(runtime, state.signaledValues[i]));
-    fences.setValueAtIndex(runtime, i, std::move(entry));
-  }
-
-  jsi::Object result(runtime);
-  result.setProperty(runtime, "initialized",
-                     jsi::Value(static_cast<bool>(state.initialized)));
-  result.setProperty(runtime, "fences", std::move(fences));
-  return result;
-}
-
-} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUSharedTextureMemory.h

@@ -1,75 +0,0 @@
-#pragma once
-
-#include <cstdint>
-#include <memory>
-#include <optional>
-#include <string>
-#include <vector>
-
-#include "jsi/NativeObject.h"
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "GPUSharedFence.h"
-#include "GPUTexture.h"
-#include "descriptors/GPUSharedFenceState.h"
-#include "descriptors/GPUTextureDescriptor.h"
-
-namespace rnwgpu {
-
-namespace jsi = facebook::jsi;
-
-class GPUSharedTextureMemory : public NativeObject<GPUSharedTextureMemory> {
-public:
-  static constexpr const char *CLASS_NAME = "GPUSharedTextureMemory";
-
-  explicit GPUSharedTextureMemory(wgpu::SharedTextureMemory instance,
-                                  std::string label)
-      : NativeObject(CLASS_NAME), _instance(std::move(instance)),
-        _label(std::move(label)) {}
-
-public:
-  std::string getBrand() { return CLASS_NAME; }
-
-  std::shared_ptr<GPUTexture> createTexture(
-      std::optional<std::shared_ptr<GPUTextureDescriptor>> descriptor);
-
-  // Optional `fences` are wait fences: Dawn waits for each to reach its
-  // signaledValue before writing the surface. Throws on failure.
-  void beginAccess(
-      std::shared_ptr<GPUTexture> texture, bool initialized,
-      std::optional<std::vector<std::shared_ptr<GPUSharedFenceState>>> fences);
-
-  // endAccess(texture) -> { initialized, fences: { fence, signaledValue }[] }
-  // Surfaces the fences Dawn produced for the access. Throws on failure.
-  jsi::Value endAccess(jsi::Runtime &runtime, const jsi::Value &thisVal,
-                       const jsi::Value *args, size_t count);
-
-  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",
-                  &GPUSharedTextureMemory::getBrand);
-    installMethod(runtime, prototype, "createTexture",
-                  &GPUSharedTextureMemory::createTexture);
-    installMethod(runtime, prototype, "beginAccess",
-                  &GPUSharedTextureMemory::beginAccess);
-    installMethod(runtime, prototype, "endAccess",
-                  &GPUSharedTextureMemory::endAccess);
-    installGetterSetter(runtime, prototype, "label",
-                        &GPUSharedTextureMemory::getLabel,
-                        &GPUSharedTextureMemory::setLabel);
-  }
-
-  inline const wgpu::SharedTextureMemory get() { return _instance; }
-
-private:
-  wgpu::SharedTextureMemory _instance;
-  std::string _label;
-};
-
-} // namespace rnwgpu