@shopify/react-native-skia 2.9.1 → 2.10.1

package/cpp/rnwgpu/api/NativeBufferUtils.h

@@ -1,87 +0,0 @@
-#pragma once
-
-#include <cstdint>
-#include <stdexcept>
-#include <string>
-
-#include "webgpu/webgpu_cpp.h"
-
-#if defined(__APPLE__)
-#include "AppleNativeBuffer.h"
-#elif defined(__ANDROID__)
-#include <android/hardware_buffer.h>
-#endif
-
-namespace rnwgpu {
-
-// Import a Skia NativeBuffer pointer (a CVPixelBufferRef on Apple, an
-// AHardwareBuffer* on Android, as returned by Skia.NativeBuffer.MakeFromImage /
-// MakeTestBuffer) as a wgpu::SharedTextureMemory on `device`. When non-null,
-// outWidth/outHeight receive the surface dimensions. Returns a null
-// SharedTextureMemory if the import itself fails (the caller decides how to
-// report that); throws std::runtime_error for pre-import failures (a buffer
-// with no IOSurface, or an unsupported platform).
-//
-// The platform-specific chained descriptor only needs to outlive the
-// ImportSharedTextureMemory call, so it lives entirely within this function.
-// Shared by GPUDevice::importSharedTextureMemory and
-// GPUExternalTexture::Create.
-inline wgpu::SharedTextureMemory importNativeBufferAsSharedTextureMemory(
-    const wgpu::Device &device, void *bufferPtr, const std::string &label,
-    uint32_t *outWidth, uint32_t *outHeight) {
-  wgpu::SharedTextureMemoryDescriptor memDesc{};
-  if (!label.empty()) {
-    memDesc.label = wgpu::StringView(label.c_str(), label.size());
-  }
-
-  uint32_t width = 0;
-  uint32_t height = 0;
-  wgpu::SharedTextureMemory memory;
-
-#if defined(__APPLE__)
-  // Skia's NativeBuffer is a CVPixelBufferRef; extract its backing IOSurface
-  // (and dimensions) in Objective-C++ since CoreVideo isn't available here.
-  void *ioSurface = GetIOSurfaceFromNativeBuffer(bufferPtr, &width, &height);
-  if (ioSurface == nullptr) {
-    throw std::runtime_error(
-        "importNativeBufferAsSharedTextureMemory(): native "
-        "buffer has no IOSurface");
-  }
-  wgpu::SharedTextureMemoryIOSurfaceDescriptor platformDesc{};
-  platformDesc.ioSurface = ioSurface;
-  // Default off: enabling it propagates StorageBinding into properties.usage,
-  // which then forces memory.createTexture() (no-descriptor form) to validate
-  // the format against storage capabilities. bgra8unorm (the standard
-  // CVPixelBuffer format) only supports storage when the device opts into the
-  // bgra8unorm-storage feature, so unconditionally setting this here breaks the
-  // common sample-only case.
-  platformDesc.allowStorageBinding = false;
-  memDesc.nextInChain = &platformDesc;
-  memory = device.ImportSharedTextureMemory(&memDesc);
-#elif defined(__ANDROID__)
-  auto *ahb = reinterpret_cast<AHardwareBuffer *>(bufferPtr);
-  AHardwareBuffer_Desc ahbDesc = {};
-  AHardwareBuffer_describe(ahb, &ahbDesc);
-  width = ahbDesc.width;
-  height = ahbDesc.height;
-  wgpu::SharedTextureMemoryAHardwareBufferDescriptor platformDesc{};
-  platformDesc.handle = ahb;
-  memDesc.nextInChain = &platformDesc;
-  memory = device.ImportSharedTextureMemory(&memDesc);
-#else
-  (void)device;
-  (void)bufferPtr;
-  throw std::runtime_error(
-      "importNativeBufferAsSharedTextureMemory(): unsupported platform");
-#endif
-
-  if (outWidth != nullptr) {
-    *outWidth = width;
-  }
-  if (outHeight != nullptr) {
-    *outHeight = height;
-  }
-  return memory;
-}
-
-} // namespace rnwgpu

package/cpp/rnwgpu/api/RNWebGPU.h

@@ -1,82 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <string>
-
-#include "jsi2/NativeObject.h"
-
-#include "GPU.h"
-#include "GPUCanvasContext.h"
-#include "rnwgpu/Canvas.h"
-#include "rnwgpu/PlatformContext.h"
-
-namespace rnwgpu {
-
-namespace jsi = facebook::jsi;
-
-class RNWebGPU : public NativeObject<RNWebGPU> {
-public:
-  static constexpr const char *CLASS_NAME = "RNWebGPU";
-
-  explicit RNWebGPU(std::shared_ptr<GPU> gpu,
-                    std::shared_ptr<PlatformContext> platformContext)
-      : NativeObject(CLASS_NAME), _gpu(gpu), _platformContext(platformContext) {
-  }
-
-  std::shared_ptr<GPU> getGPU() { return _gpu; }
-
-  bool getFabric() { return true; }
-
-  std::shared_ptr<GPUCanvasContext>
-  MakeWebGPUCanvasContext(int contextId, float width, float height) {
-    auto ctx =
-        std::make_shared<GPUCanvasContext>(_gpu, contextId, width, height);
-    return ctx;
-  }
-
-  std::shared_ptr<Canvas> getNativeSurface(int contextId) {
-    auto &registry = rnwgpu::SurfaceRegistry::getInstance();
-    auto info = registry.getSurfaceInfo(contextId);
-    if (info == nullptr) {
-      return std::make_shared<Canvas>(nullptr, 0, 0);
-    }
-    auto nativeInfo = info->getNativeInfo();
-    return std::make_shared<Canvas>(nativeInfo.nativeSurface, nativeInfo.width,
-                                    nativeInfo.height);
-  }
-
-  // Retires a canvas context from the JS side (Canvas unmount cleanup).
-  // Registry entries have two owners, split by whether a native surface is
-  // attached:
-  // - A native view currently owns a surface (or one is pending): its own
-  //   teardown (WebGPUMetalView dealloc / WebGPUViewManager.onDropViewInstance)
-  //   removes the entry. Skipping here keeps React StrictMode safe: its
-  //   simulated unmount re-runs JS effects without unmounting native views,
-  //   and removing the entry then would orphan the still-attached surface.
-  // - No native surface: the JS side is the last owner and removes the entry.
-  // The check-and-erase runs atomically under the registry lock
-  // (removeSurfaceInfoIfDetached), serialized against the UI thread's
-  // find-or-create + attach (SurfaceRegistry::attachSurface), so a concurrent
-  // attach can never be orphaned by this removal.
-  void destroyContext(int contextId) {
-    auto &registry = rnwgpu::SurfaceRegistry::getInstance();
-    registry.removeSurfaceInfoIfDetached(contextId);
-  }
-
-  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
-    installGetter(runtime, prototype, "fabric", &RNWebGPU::getFabric);
-    installGetter(runtime, prototype, "gpu", &RNWebGPU::getGPU);
-    installMethod(runtime, prototype, "getNativeSurface",
-                  &RNWebGPU::getNativeSurface);
-    installMethod(runtime, prototype, "destroyContext",
-                  &RNWebGPU::destroyContext);
-    installMethod(runtime, prototype, "MakeWebGPUCanvasContext",
-                  &RNWebGPU::MakeWebGPUCanvasContext);
-  }
-
-private:
-  std::shared_ptr<GPU> _gpu;
-  std::shared_ptr<PlatformContext> _platformContext;
-};
-
-} // namespace rnwgpu

package/cpp/rnwgpu/api/WebGPUConstants.h

@@ -1,36 +0,0 @@
-#pragma once
-
-#include <jsi/jsi.h>
-
-#include "descriptors/GPUBufferUsage.h"
-#include "descriptors/GPUColorWrite.h"
-#include "descriptors/GPUMapMode.h"
-#include "descriptors/GPUShaderStage.h"
-#include "descriptors/GPUTextureUsage.h"
-
-namespace rnwgpu {
-
-namespace jsi = facebook::jsi;
-
-// Installs the WebGPU flag constants (GPUBufferUsage, GPUColorWrite, GPUMapMode,
-// GPUShaderStage, GPUTextureUsage) as plain JS objects on `runtime`'s global.
-//
-// The numeric values are derived from the Dawn wgpu::*Usage enums (single source
-// of truth in C++), so this is safe to call on ANY runtime: the main JS runtime
-// at install time, and any worklet runtime (Reanimated UI, dedicated worklet
-// runtimes, Vision Camera frame processors) via the global `installWebGPU()`
-// host function. It is idempotent: re-installing overwrites the globals with
-// equal values.
-inline void installWebGPUConstants(jsi::Runtime &runtime) {
-  auto global = runtime.global();
-  global.setProperty(runtime, "GPUBufferUsage",
-                     GPUBufferUsage::create(runtime));
-  global.setProperty(runtime, "GPUColorWrite", GPUColorWrite::create(runtime));
-  global.setProperty(runtime, "GPUMapMode", GPUMapMode::create(runtime));
-  global.setProperty(runtime, "GPUShaderStage",
-                     GPUShaderStage::create(runtime));
-  global.setProperty(runtime, "GPUTextureUsage",
-                     GPUTextureUsage::create(runtime));
-}
-
-} // namespace rnwgpu

package/cpp/rnwgpu/api/descriptors/GPUBindGroupDescriptor.h

@@ -1,64 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "jsi2/JSIConverter.h"
-
-#include "GPUBindGroupEntry.h"
-#include "rnwgpu/api/GPUBindGroupLayout.h"
-
-namespace jsi = facebook::jsi;
-
-namespace rnwgpu {
-
-struct GPUBindGroupDescriptor {
-  std::shared_ptr<GPUBindGroupLayout> layout; // GPUBindGroupLayout
-  std::vector<std::shared_ptr<GPUBindGroupEntry>>
-      entries;                      // Iterable<GPUBindGroupEntry>
-  std::optional<std::string> label; // string
-};
-
-} // namespace rnwgpu
-
-namespace rnwgpu {
-
-template <>
-struct JSIConverter<std::shared_ptr<rnwgpu::GPUBindGroupDescriptor>> {
-  static std::shared_ptr<rnwgpu::GPUBindGroupDescriptor>
-  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
-    auto result = std::make_unique<rnwgpu::GPUBindGroupDescriptor>();
-    if (!outOfBounds && arg.isObject()) {
-      auto value = arg.getObject(runtime);
-      if (value.hasProperty(runtime, "layout")) {
-        auto prop = value.getProperty(runtime, "layout");
-        result->layout =
-            JSIConverter<std::shared_ptr<GPUBindGroupLayout>>::fromJSI(
-                runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "entries")) {
-        auto prop = value.getProperty(runtime, "entries");
-        result->entries = JSIConverter<
-            std::vector<std::shared_ptr<GPUBindGroupEntry>>>::fromJSI(runtime,
-                                                                      prop,
-                                                                      false);
-      }
-      if (value.hasProperty(runtime, "label")) {
-        auto prop = value.getProperty(runtime, "label");
-        result->label = JSIConverter<std::optional<std::string>>::fromJSI(
-            runtime, prop, false);
-      }
-    }
-
-    return result;
-  }
-  static jsi::Value toJSI(jsi::Runtime &runtime,
-                          std::shared_ptr<rnwgpu::GPUBindGroupDescriptor> arg) {
-    throw std::runtime_error("Invalid GPUBindGroupDescriptor::toJSI()");
-  }
-};
-
-} // namespace rnwgpu

package/cpp/rnwgpu/api/descriptors/GPUBindGroupEntry.h

@@ -1,78 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <variant>
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "GPUBufferBinding.h"
-#include "jsi2/JSIConverter.h"
-#include "rnwgpu/api/GPUExternalTexture.h"
-#include "rnwgpu/api/GPUSampler.h"
-#include "rnwgpu/api/GPUTextureView.h"
-
-namespace jsi = facebook::jsi;
-
-namespace rnwgpu {
-
-struct GPUBindGroupEntry {
-  double binding;
-  std::shared_ptr<GPUSampler> sampler = nullptr;
-  std::shared_ptr<GPUTextureView> textureView = nullptr;
-  std::shared_ptr<GPUBufferBinding> buffer = nullptr;
-  std::shared_ptr<GPUExternalTexture> externalTexture = nullptr;
-};
-
-} // namespace rnwgpu
-
-namespace rnwgpu {
-
-template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUBindGroupEntry>> {
-  static std::shared_ptr<rnwgpu::GPUBindGroupEntry>
-  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
-    auto result = std::make_unique<rnwgpu::GPUBindGroupEntry>();
-    if (!outOfBounds && arg.isObject()) {
-      auto value = arg.getObject(runtime);
-      if (value.hasProperty(runtime, "binding")) {
-        result->binding = value.getProperty(runtime, "binding").asNumber();
-      }
-      if (value.hasProperty(runtime, "resource")) {
-        auto prop = value.getProperty(runtime, "resource");
-        if (prop.isObject()) {
-          auto obj = prop.getObject(runtime);
-          if (obj.hasNativeState<rnwgpu::GPUSampler>(runtime)) {
-            result->sampler = obj.getNativeState<rnwgpu::GPUSampler>(runtime);
-          } else if (obj.hasNativeState<rnwgpu::GPUTextureView>(runtime)) {
-            result->textureView =
-                obj.getNativeState<rnwgpu::GPUTextureView>(runtime);
-          } else if (obj.hasNativeState<rnwgpu::GPUExternalTexture>(runtime)) {
-            result->externalTexture =
-                obj.getNativeState<rnwgpu::GPUExternalTexture>(runtime);
-          } else if (obj.hasNativeState<rnwgpu::GPUBuffer>(runtime)) {
-            auto binding = std::make_shared<rnwgpu::GPUBufferBinding>();
-            binding->buffer = obj.getNativeState<rnwgpu::GPUBuffer>(runtime);
-            result->buffer = binding;
-          } else {
-            result->buffer = JSIConverter<
-                std::shared_ptr<rnwgpu::GPUBufferBinding>>::fromJSI(runtime,
-                                                                    prop,
-                                                                    false);
-          }
-        }
-        // result->resource = JSIConverter<std::variant<
-        //     std::shared_ptr<GPUSampler>, std::shared_ptr<GPUTextureView>,
-        //     std::shared_ptr<GPUBufferBinding>,
-        //     std::shared_ptr<GPUExternalTexture>>>::fromJSI(runtime, prop,
-        //                                                    false);
-      }
-    }
-
-    return result;
-  }
-  static jsi::Value toJSI(jsi::Runtime &runtime,
-                          std::shared_ptr<rnwgpu::GPUBindGroupEntry> arg) {
-    throw std::runtime_error("Invalid GPUBindGroupEntry::toJSI()");
-  }
-};
-
-} // namespace rnwgpu

package/cpp/rnwgpu/api/descriptors/GPUBindGroupLayoutDescriptor.h

@@ -1,56 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "jsi2/JSIConverter.h"
-
-#include "GPUBindGroupLayoutEntry.h"
-
-namespace jsi = facebook::jsi;
-
-namespace rnwgpu {
-
-struct GPUBindGroupLayoutDescriptor {
-  std::vector<std::shared_ptr<GPUBindGroupLayoutEntry>>
-      entries;                      // Iterable<GPUBindGroupLayoutEntry>
-  std::optional<std::string> label; // string
-};
-
-} // namespace rnwgpu
-
-namespace rnwgpu {
-
-template <>
-struct JSIConverter<std::shared_ptr<rnwgpu::GPUBindGroupLayoutDescriptor>> {
-  static std::shared_ptr<rnwgpu::GPUBindGroupLayoutDescriptor>
-  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
-    auto result = std::make_unique<rnwgpu::GPUBindGroupLayoutDescriptor>();
-    if (!outOfBounds && arg.isObject()) {
-      auto value = arg.getObject(runtime);
-      if (value.hasProperty(runtime, "entries")) {
-        auto prop = value.getProperty(runtime, "entries");
-        result->entries = JSIConverter<std::vector<
-            std::shared_ptr<GPUBindGroupLayoutEntry>>>::fromJSI(runtime, prop,
-                                                                false);
-      }
-      if (value.hasProperty(runtime, "label")) {
-        auto prop = value.getProperty(runtime, "label");
-        result->label = JSIConverter<std::optional<std::string>>::fromJSI(
-            runtime, prop, false);
-      }
-    }
-
-    return result;
-  }
-  static jsi::Value
-  toJSI(jsi::Runtime &runtime,
-        std::shared_ptr<rnwgpu::GPUBindGroupLayoutDescriptor> arg) {
-    throw std::runtime_error("Invalid GPUBindGroupLayoutDescriptor::toJSI()");
-  }
-};
-
-} // namespace rnwgpu

package/cpp/rnwgpu/api/descriptors/GPUBindGroupLayoutEntry.h

@@ -1,97 +0,0 @@
-#pragma once
-
-#include <memory>
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "jsi2/JSIConverter.h"
-
-#include "GPUBufferBindingLayout.h"
-#include "GPUExternalTextureBindingLayout.h"
-#include "GPUSamplerBindingLayout.h"
-#include "GPUStorageTextureBindingLayout.h"
-#include "GPUTextureBindingLayout.h"
-
-namespace jsi = facebook::jsi;
-
-namespace rnwgpu {
-
-struct GPUBindGroupLayoutEntry {
-  double binding;    // GPUIndex32
-  double visibility; // GPUShaderStageFlags
-  std::optional<std::shared_ptr<GPUBufferBindingLayout>>
-      buffer; // GPUBufferBindingLayout
-  std::optional<std::shared_ptr<GPUSamplerBindingLayout>>
-      sampler; // GPUSamplerBindingLayout
-  std::optional<std::shared_ptr<GPUTextureBindingLayout>>
-      texture; // GPUTextureBindingLayout
-  std::optional<std::shared_ptr<GPUStorageTextureBindingLayout>>
-      storageTexture; // GPUStorageTextureBindingLayout
-  std::optional<std::shared_ptr<GPUExternalTextureBindingLayout>>
-      externalTexture; // GPUExternalTextureBindingLayout
-};
-
-} // namespace rnwgpu
-
-namespace rnwgpu {
-
-template <>
-struct JSIConverter<std::shared_ptr<rnwgpu::GPUBindGroupLayoutEntry>> {
-  static std::shared_ptr<rnwgpu::GPUBindGroupLayoutEntry>
-  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
-    auto result = std::make_unique<rnwgpu::GPUBindGroupLayoutEntry>();
-    if (!outOfBounds && arg.isObject()) {
-      auto value = arg.getObject(runtime);
-      if (value.hasProperty(runtime, "binding")) {
-        auto prop = value.getProperty(runtime, "binding");
-        result->binding = JSIConverter<double>::fromJSI(runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "visibility")) {
-        auto prop = value.getProperty(runtime, "visibility");
-        result->visibility =
-            JSIConverter<double>::fromJSI(runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "buffer")) {
-        auto prop = value.getProperty(runtime, "buffer");
-        result->buffer = JSIConverter<std::optional<
-            std::shared_ptr<GPUBufferBindingLayout>>>::fromJSI(runtime, prop,
-                                                               false);
-      }
-      if (value.hasProperty(runtime, "sampler")) {
-        auto prop = value.getProperty(runtime, "sampler");
-        result->sampler = JSIConverter<std::optional<
-            std::shared_ptr<GPUSamplerBindingLayout>>>::fromJSI(runtime, prop,
-                                                                false);
-      }
-      if (value.hasProperty(runtime, "texture")) {
-        auto prop = value.getProperty(runtime, "texture");
-        result->texture = JSIConverter<std::optional<
-            std::shared_ptr<GPUTextureBindingLayout>>>::fromJSI(runtime, prop,
-                                                                false);
-      }
-      if (value.hasProperty(runtime, "storageTexture")) {
-        auto prop = value.getProperty(runtime, "storageTexture");
-        result->storageTexture = JSIConverter<std::optional<
-            std::shared_ptr<GPUStorageTextureBindingLayout>>>::fromJSI(runtime,
-                                                                       prop,
-                                                                       false);
-      }
-      if (value.hasProperty(runtime, "externalTexture")) {
-        auto prop = value.getProperty(runtime, "externalTexture");
-        result->externalTexture = JSIConverter<std::optional<
-            std::shared_ptr<GPUExternalTextureBindingLayout>>>::fromJSI(runtime,
-                                                                        prop,
-                                                                        false);
-      }
-    }
-
-    return result;
-  }
-  static jsi::Value
-  toJSI(jsi::Runtime &runtime,
-        std::shared_ptr<rnwgpu::GPUBindGroupLayoutEntry> arg) {
-    throw std::runtime_error("Invalid GPUBindGroupLayoutEntry::toJSI()");
-  }
-};
-
-} // namespace rnwgpu

package/cpp/rnwgpu/api/descriptors/GPUBlendComponent.h

@@ -1,57 +0,0 @@
-#pragma once
-
-#include <memory>
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "jsi2/JSIConverter.h"
-
-namespace jsi = facebook::jsi;
-
-namespace rnwgpu {
-
-struct GPUBlendComponent {
-  std::optional<wgpu::BlendOperation> operation; // GPUBlendOperation
-  std::optional<wgpu::BlendFactor> srcFactor;    // GPUBlendFactor
-  std::optional<wgpu::BlendFactor> dstFactor;    // GPUBlendFactor
-};
-
-} // namespace rnwgpu
-
-namespace rnwgpu {
-
-template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUBlendComponent>> {
-  static std::shared_ptr<rnwgpu::GPUBlendComponent>
-  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
-    auto result = std::make_unique<rnwgpu::GPUBlendComponent>();
-    if (!outOfBounds && arg.isObject()) {
-      auto value = arg.getObject(runtime);
-      if (value.hasProperty(runtime, "operation")) {
-        auto prop = value.getProperty(runtime, "operation");
-        result->operation =
-            JSIConverter<std::optional<wgpu::BlendOperation>>::fromJSI(
-                runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "srcFactor")) {
-        auto prop = value.getProperty(runtime, "srcFactor");
-        result->srcFactor =
-            JSIConverter<std::optional<wgpu::BlendFactor>>::fromJSI(
-                runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "dstFactor")) {
-        auto prop = value.getProperty(runtime, "dstFactor");
-        result->dstFactor =
-            JSIConverter<std::optional<wgpu::BlendFactor>>::fromJSI(
-                runtime, prop, false);
-      }
-    }
-
-    return result;
-  }
-  static jsi::Value toJSI(jsi::Runtime &runtime,
-                          std::shared_ptr<rnwgpu::GPUBlendComponent> arg) {
-    throw std::runtime_error("Invalid GPUBlendComponent::toJSI()");
-  }
-};
-
-} // namespace rnwgpu

package/cpp/rnwgpu/api/descriptors/GPUBlendState.h

@@ -1,52 +0,0 @@
-#pragma once
-
-#include <memory>
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "jsi2/JSIConverter.h"
-
-#include "GPUBlendComponent.h"
-
-namespace jsi = facebook::jsi;
-
-namespace rnwgpu {
-
-struct GPUBlendState {
-  std::shared_ptr<GPUBlendComponent> color; // GPUBlendComponent
-  std::shared_ptr<GPUBlendComponent> alpha; // GPUBlendComponent
-};
-
-} // namespace rnwgpu
-
-namespace rnwgpu {
-
-template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUBlendState>> {
-  static std::shared_ptr<rnwgpu::GPUBlendState>
-  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
-    auto result = std::make_unique<rnwgpu::GPUBlendState>();
-    if (!outOfBounds && arg.isObject()) {
-      auto value = arg.getObject(runtime);
-      if (value.hasProperty(runtime, "color")) {
-        auto prop = value.getProperty(runtime, "color");
-        result->color =
-            JSIConverter<std::shared_ptr<GPUBlendComponent>>::fromJSI(
-                runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "alpha")) {
-        auto prop = value.getProperty(runtime, "alpha");
-        result->alpha =
-            JSIConverter<std::shared_ptr<GPUBlendComponent>>::fromJSI(
-                runtime, prop, false);
-      }
-    }
-
-    return result;
-  }
-  static jsi::Value toJSI(jsi::Runtime &runtime,
-                          std::shared_ptr<rnwgpu::GPUBlendState> arg) {
-    throw std::runtime_error("Invalid GPUBlendState::toJSI()");
-  }
-};
-
-} // namespace rnwgpu

package/cpp/rnwgpu/api/descriptors/GPUBufferBinding.h

@@ -1,56 +0,0 @@
-#pragma once
-
-#include <memory>
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "jsi2/JSIConverter.h"
-
-#include "rnwgpu/api/GPUBuffer.h"
-
-namespace jsi = facebook::jsi;
-
-namespace rnwgpu {
-
-struct GPUBufferBinding {
-  std::shared_ptr<GPUBuffer> buffer; // GPUBuffer
-  std::optional<double> offset;      // GPUSize64
-  std::optional<double> size;        // GPUSize64
-};
-
-} // namespace rnwgpu
-
-namespace rnwgpu {
-
-template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUBufferBinding>> {
-  static std::shared_ptr<rnwgpu::GPUBufferBinding>
-  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
-    auto result = std::make_unique<rnwgpu::GPUBufferBinding>();
-    if (!outOfBounds && arg.isObject()) {
-      auto value = arg.getObject(runtime);
-      if (value.hasProperty(runtime, "buffer")) {
-        auto prop = value.getProperty(runtime, "buffer");
-        result->buffer = JSIConverter<std::shared_ptr<GPUBuffer>>::fromJSI(
-            runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "offset")) {
-        auto prop = value.getProperty(runtime, "offset");
-        result->offset =
-            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "size")) {
-        auto prop = value.getProperty(runtime, "size");
-        result->size =
-            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
-      }
-    }
-
-    return result;
-  }
-  static jsi::Value toJSI(jsi::Runtime &runtime,
-                          std::shared_ptr<rnwgpu::GPUBufferBinding> arg) {
-    throw std::runtime_error("Invalid GPUBufferBinding::toJSI()");
-  }
-};
-
-} // namespace rnwgpu