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

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

@@ -1,56 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "jsi/JSIConverter.h"
-
-namespace jsi = facebook::jsi;
-
-namespace rnwgpu {
-
-// Non-standard, Dawn-only. Mirrors wgpu::DawnTogglesDescriptor field-for-field
-// so the mapping to the native chained struct is 1:1. Chained onto the
-// wgpu::DeviceDescriptor in GPUAdapter::requestDevice.
-struct GPUDawnTogglesDescriptor {
-  std::optional<std::vector<std::string>> enabledToggles;  // Iterable<string>
-  std::optional<std::vector<std::string>> disabledToggles; // Iterable<string>
-};
-
-} // namespace rnwgpu
-
-namespace rnwgpu {
-
-template <>
-struct JSIConverter<std::shared_ptr<rnwgpu::GPUDawnTogglesDescriptor>> {
-  static std::shared_ptr<rnwgpu::GPUDawnTogglesDescriptor>
-  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
-    auto result = std::make_unique<rnwgpu::GPUDawnTogglesDescriptor>();
-    if (!outOfBounds && arg.isObject()) {
-      auto value = arg.getObject(runtime);
-      if (value.hasProperty(runtime, "enabledToggles")) {
-        auto prop = value.getProperty(runtime, "enabledToggles");
-        result->enabledToggles =
-            JSIConverter<std::optional<std::vector<std::string>>>::fromJSI(
-                runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "disabledToggles")) {
-        auto prop = value.getProperty(runtime, "disabledToggles");
-        result->disabledToggles =
-            JSIConverter<std::optional<std::vector<std::string>>>::fromJSI(
-                runtime, prop, false);
-      }
-    }
-    return result;
-  }
-  static jsi::Value
-  toJSI(jsi::Runtime &runtime,
-        std::shared_ptr<rnwgpu::GPUDawnTogglesDescriptor> arg) {
-    throw std::runtime_error("Invalid GPUDawnTogglesDescriptor::toJSI()");
-  }
-};
-
-} // namespace rnwgpu

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

@@ -1,103 +0,0 @@
-#pragma once
-
-#include <memory>
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "jsi/JSIConverter.h"
-
-#include "GPUStencilFaceState.h"
-
-namespace jsi = facebook::jsi;
-
-namespace rnwgpu {
-
-struct GPUDepthStencilState {
-  wgpu::TextureFormat format;                        // GPUTextureFormat
-  std::optional<bool> depthWriteEnabled;             // boolean
-  std::optional<wgpu::CompareFunction> depthCompare; // GPUCompareFunction
-  std::optional<std::shared_ptr<GPUStencilFaceState>>
-      stencilFront; // GPUStencilFaceState
-  std::optional<std::shared_ptr<GPUStencilFaceState>>
-      stencilBack;                           // GPUStencilFaceState
-  std::optional<double> stencilReadMask;     // GPUStencilValue
-  std::optional<double> stencilWriteMask;    // GPUStencilValue
-  std::optional<double> depthBias;           // GPUDepthBias
-  std::optional<double> depthBiasSlopeScale; // number
-  std::optional<double> depthBiasClamp;      // number
-};
-
-} // namespace rnwgpu
-
-namespace rnwgpu {
-
-template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUDepthStencilState>> {
-  static std::shared_ptr<rnwgpu::GPUDepthStencilState>
-  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
-    auto result = std::make_unique<rnwgpu::GPUDepthStencilState>();
-    if (!outOfBounds && arg.isObject()) {
-      auto value = arg.getObject(runtime);
-      if (value.hasProperty(runtime, "format")) {
-        auto prop = value.getProperty(runtime, "format");
-        result->format =
-            JSIConverter<wgpu::TextureFormat>::fromJSI(runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "depthWriteEnabled")) {
-        auto prop = value.getProperty(runtime, "depthWriteEnabled");
-        result->depthWriteEnabled =
-            JSIConverter<std::optional<bool>>::fromJSI(runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "depthCompare")) {
-        auto prop = value.getProperty(runtime, "depthCompare");
-        result->depthCompare =
-            JSIConverter<std::optional<wgpu::CompareFunction>>::fromJSI(
-                runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "stencilFront")) {
-        auto prop = value.getProperty(runtime, "stencilFront");
-        result->stencilFront =
-            JSIConverter<std::optional<std::shared_ptr<GPUStencilFaceState>>>::
-                fromJSI(runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "stencilBack")) {
-        auto prop = value.getProperty(runtime, "stencilBack");
-        result->stencilBack =
-            JSIConverter<std::optional<std::shared_ptr<GPUStencilFaceState>>>::
-                fromJSI(runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "stencilReadMask")) {
-        auto prop = value.getProperty(runtime, "stencilReadMask");
-        result->stencilReadMask =
-            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "stencilWriteMask")) {
-        auto prop = value.getProperty(runtime, "stencilWriteMask");
-        result->stencilWriteMask =
-            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "depthBias")) {
-        auto prop = value.getProperty(runtime, "depthBias");
-        result->depthBias =
-            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "depthBiasSlopeScale")) {
-        auto prop = value.getProperty(runtime, "depthBiasSlopeScale");
-        result->depthBiasSlopeScale =
-            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "depthBiasClamp")) {
-        auto prop = value.getProperty(runtime, "depthBiasClamp");
-        result->depthBiasClamp =
-            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
-      }
-    }
-
-    return result;
-  }
-  static jsi::Value toJSI(jsi::Runtime &runtime,
-                          std::shared_ptr<rnwgpu::GPUDepthStencilState> arg) {
-    throw std::runtime_error("Invalid GPUDepthStencilState::toJSI()");
-  }
-};
-
-} // namespace rnwgpu

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

@@ -1,109 +0,0 @@
-#pragma once
-
-#include <map>
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "jsi/JSIConverter.h"
-
-#include "GPUDawnTogglesDescriptor.h"
-#include "GPUQueueDescriptor.h"
-
-namespace jsi = facebook::jsi;
-
-namespace rnwgpu {
-
-struct GPUDeviceDescriptor {
-  std::optional<std::vector<wgpu::FeatureName>>
-      requiredFeatures; // Iterable<GPUFeatureName>
-  std::optional<std::map<std::string, double>>
-      requiredLimits; // Record< string, GPUSize64 >
-  std::optional<std::shared_ptr<GPUQueueDescriptor>>
-      defaultQueue;                 // GPUQueueDescriptor
-  std::optional<std::string> label; // string
-  // Non-standard Dawn-only device toggles, chained onto the wgpu::Device
-  // descriptor in GPUAdapter::requestDevice.
-  std::optional<std::shared_ptr<GPUDawnTogglesDescriptor>> dawnToggles;
-};
-
-} // namespace rnwgpu
-
-namespace rnwgpu {
-
-// We add this extra convertor because we found so library that are sending
-// invalid feature elements
-template <> struct JSIConverter<std::vector<wgpu::FeatureName>> {
-
-  static std::vector<wgpu::FeatureName>
-  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
-    jsi::Array array = arg.asObject(runtime).asArray(runtime);
-    size_t length = array.size(runtime);
-
-    std::vector<wgpu::FeatureName> vector;
-    vector.reserve(length);
-    for (size_t i = 0; i < length; ++i) {
-      jsi::Value elementValue = array.getValueAtIndex(runtime, i);
-      if (elementValue.isString()) {
-        vector.emplace_back(JSIConverter<wgpu::FeatureName>::fromJSI(
-            runtime, elementValue, outOfBounds));
-      }
-    }
-    return vector;
-  }
-  static jsi::Value toJSI(jsi::Runtime &runtime,
-                          std::shared_ptr<rnwgpu::GPUDeviceDescriptor> arg) {
-    throw std::runtime_error(
-        "Invalid JSIConverter<std::vector<wgpu::FeatureName>>::toJSI()");
-  }
-};
-
-template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUDeviceDescriptor>> {
-  static std::shared_ptr<rnwgpu::GPUDeviceDescriptor>
-  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
-    auto result = std::make_unique<rnwgpu::GPUDeviceDescriptor>();
-    if (!outOfBounds && arg.isObject()) {
-      auto value = arg.getObject(runtime);
-      if (value.hasProperty(runtime, "requiredFeatures")) {
-        auto prop = value.getProperty(runtime, "requiredFeatures");
-        result->requiredFeatures = JSIConverter<
-            std::optional<std::vector<wgpu::FeatureName>>>::fromJSI(runtime,
-                                                                    prop,
-                                                                    false);
-      }
-      if (value.hasProperty(runtime, "requiredLimits")) {
-        auto prop = value.getProperty(runtime, "requiredLimits");
-        result->requiredLimits =
-            JSIConverter<std::optional<std::map<std::string, double>>>::fromJSI(
-                runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "defaultQueue")) {
-        auto prop = value.getProperty(runtime, "defaultQueue");
-        result->defaultQueue =
-            JSIConverter<std::optional<std::shared_ptr<GPUQueueDescriptor>>>::
-                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);
-      }
-      if (value.hasProperty(runtime, "dawnToggles")) {
-        auto prop = value.getProperty(runtime, "dawnToggles");
-        result->dawnToggles = JSIConverter<std::optional<
-            std::shared_ptr<GPUDawnTogglesDescriptor>>>::fromJSI(runtime, prop,
-                                                                 false);
-      }
-    }
-
-    return result;
-  }
-  static jsi::Value toJSI(jsi::Runtime &runtime,
-                          std::shared_ptr<rnwgpu::GPUDeviceDescriptor> arg) {
-    throw std::runtime_error("Invalid GPUDeviceDescriptor::toJSI()");
-  }
-};
-
-} // namespace rnwgpu

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

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

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

@@ -1,90 +0,0 @@
-#pragma once
-
-#include <cstdint>
-#include <memory>
-#include <optional>
-#include <string>
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "jsi/JSIConverter.h"
-
-namespace jsi = facebook::jsi;
-
-namespace rnwgpu {
-
-// Mirror of GPUExternalTextureDescriptor from the WebGPU spec, adapted to
-// Skia's binding. Skia has no VideoFrame; instead `source` is a native buffer
-// pointer (the BigInt returned by Skia.NativeBuffer.MakeFromImage): a
-// CVPixelBufferRef on Apple, an AHardwareBuffer* on Android. The pointer's
-// lifetime is owned by the caller (Skia.NativeBuffer.Release); the imported
-// texture must not outlive it.
-//
-// We don't expose colorSpace yet; the C++ side picks dst-sRGB and identity
-// gamut, the right default for "render this BGRA frame to an sRGB framebuffer".
-//
-// `rotation` / `mirrored` are a non-spec extension baked into Dawn's sampling
-// transform. `rotation` is in degrees and must be one of 0 / 90 / 180 / 270.
-struct GPUExternalTextureDescriptor {
-  // native buffer pointer (CVPixelBufferRef / AHardwareBuffer*)
-  uint64_t source = 0;
-  std::optional<std::string> label;
-  std::optional<double> rotation;
-  std::optional<bool> mirrored;
-};
-
-} // namespace rnwgpu
-
-namespace rnwgpu {
-
-template <>
-struct JSIConverter<std::shared_ptr<rnwgpu::GPUExternalTextureDescriptor>> {
-  static std::shared_ptr<rnwgpu::GPUExternalTextureDescriptor>
-  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
-    auto result = std::make_shared<rnwgpu::GPUExternalTextureDescriptor>();
-    if (!outOfBounds && arg.isObject()) {
-      auto value = arg.getObject(runtime);
-      if (value.hasProperty(runtime, "source")) {
-        auto prop = value.getProperty(runtime, "source");
-        // The native buffer pointer arrives as a BigInt (uintptr_t value). It
-        // must be a BigInt: a JS number can't represent a 64-bit pointer
-        // without truncation, so we reject it rather than corrupt the address.
-        if (prop.isBigInt()) {
-          result->source = prop.asBigInt(runtime).asUint64(runtime);
-        } else if (!prop.isUndefined() && !prop.isNull()) {
-          throw jsi::JSError(
-              runtime, "GPUExternalTextureDescriptor.source must be a "
-                       "NativeBuffer (BigInt) from "
-                       "Skia.NativeBuffer.MakeFromImage / MakeTestBuffer");
-        }
-      }
-      if (value.hasProperty(runtime, "label")) {
-        auto prop = value.getProperty(runtime, "label");
-        if (!prop.isUndefined()) {
-          result->label = JSIConverter<std::optional<std::string>>::fromJSI(
-              runtime, prop, false);
-        }
-      }
-      if (value.hasProperty(runtime, "rotation")) {
-        auto prop = value.getProperty(runtime, "rotation");
-        if (prop.isNumber()) {
-          result->rotation = prop.asNumber();
-        }
-      }
-      if (value.hasProperty(runtime, "mirrored")) {
-        auto prop = value.getProperty(runtime, "mirrored");
-        if (prop.isBool()) {
-          result->mirrored = prop.getBool();
-        }
-      }
-    }
-    return result;
-  }
-  static jsi::Value
-  toJSI(jsi::Runtime & /*runtime*/,
-        std::shared_ptr<rnwgpu::GPUExternalTextureDescriptor> /*arg*/) {
-    throw std::runtime_error("Invalid GPUExternalTextureDescriptor::toJSI()");
-  }
-};
-
-} // namespace rnwgpu

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

@@ -1,73 +0,0 @@
-#pragma once
-
-#include <map>
-#include <memory>
-#include <string>
-#include <variant>
-#include <vector>
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "jsi/JSIConverter.h"
-
-#include "GPUColorTargetState.h"
-#include "rnwgpu/api/GPUShaderModule.h"
-
-namespace jsi = facebook::jsi;
-
-namespace rnwgpu {
-
-struct GPUFragmentState {
-  std::vector<
-      std::variant<std::nullptr_t, std::shared_ptr<GPUColorTargetState>>>
-      targets; // Iterable<GPUColorTargetState | null>
-  std::shared_ptr<GPUShaderModule> module; // GPUShaderModule
-  std::optional<std::string> entryPoint;   // string
-  std::optional<std::map<std::string, double>>
-      constants; // Record< string, GPUPipelineConstantValue >
-};
-
-} // namespace rnwgpu
-
-namespace rnwgpu {
-
-template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUFragmentState>> {
-  static std::shared_ptr<rnwgpu::GPUFragmentState>
-  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
-    auto result = std::make_unique<rnwgpu::GPUFragmentState>();
-    if (!outOfBounds && arg.isObject()) {
-      auto value = arg.getObject(runtime);
-      if (value.hasProperty(runtime, "targets")) {
-        auto prop = value.getProperty(runtime, "targets");
-        result->targets = JSIConverter<std::vector<std::variant<
-            std::nullptr_t, std::shared_ptr<GPUColorTargetState>>>>::
-            fromJSI(runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "module")) {
-        auto prop = value.getProperty(runtime, "module");
-        result->module =
-            JSIConverter<std::shared_ptr<GPUShaderModule>>::fromJSI(
-                runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "entryPoint")) {
-        auto prop = value.getProperty(runtime, "entryPoint");
-        result->entryPoint = JSIConverter<std::optional<std::string>>::fromJSI(
-            runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "constants")) {
-        auto prop = value.getProperty(runtime, "constants");
-        result->constants =
-            JSIConverter<std::optional<std::map<std::string, double>>>::fromJSI(
-                runtime, prop, false);
-      }
-    }
-
-    return result;
-  }
-  static jsi::Value toJSI(jsi::Runtime &runtime,
-                          std::shared_ptr<rnwgpu::GPUFragmentState> arg) {
-    throw std::runtime_error("Invalid GPUFragmentState::toJSI()");
-  }
-};
-
-} // namespace rnwgpu

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

@@ -1,62 +0,0 @@
-#pragma once
-
-#include <memory>
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "jsi/JSIConverter.h"
-
-#include "rnwgpu/api/GPUBuffer.h"
-
-namespace jsi = facebook::jsi;
-
-namespace rnwgpu {
-
-struct GPUImageCopyBuffer {
-  std::shared_ptr<GPUBuffer> buffer;  // GPUBuffer
-  std::optional<double> offset;       // GPUSize64
-  std::optional<double> bytesPerRow;  // GPUSize32
-  std::optional<double> rowsPerImage; // GPUSize32
-};
-
-} // namespace rnwgpu
-
-namespace rnwgpu {
-
-template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUImageCopyBuffer>> {
-  static std::shared_ptr<rnwgpu::GPUImageCopyBuffer>
-  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
-    auto result = std::make_unique<rnwgpu::GPUImageCopyBuffer>();
-    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, "bytesPerRow")) {
-        auto prop = value.getProperty(runtime, "bytesPerRow");
-        result->bytesPerRow =
-            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "rowsPerImage")) {
-        auto prop = value.getProperty(runtime, "rowsPerImage");
-        result->rowsPerImage =
-            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
-      }
-    }
-
-    return result;
-  }
-  static jsi::Value toJSI(jsi::Runtime &runtime,
-                          std::shared_ptr<rnwgpu::GPUImageCopyBuffer> arg) {
-    throw std::runtime_error("Invalid GPUImageCopyBuffer::toJSI()");
-  }
-};
-
-} // namespace rnwgpu

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

@@ -1,63 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <optional>
-#include <variant>
-#include <vector>
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "jsi/JSIConverter.h"
-#include "rnwgpu/api/Convertors.h"
-
-#include "rnwgpu/api/GPUOrigin2D.h"
-#include "rnwgpu/api/ImageBitmap.h"
-
-namespace jsi = facebook::jsi;
-
-namespace rnwgpu {
-
-struct GPUImageCopyExternalImage {
-  std::shared_ptr<ImageBitmap> source; // GPUImageCopyExternalImageSource
-  std::optional<std::shared_ptr<GPUOrigin2D>> origin; // GPUOrigin2DStrict
-  std::optional<bool> flipY;                          // boolean
-};
-
-} // namespace rnwgpu
-
-namespace rnwgpu {
-
-template <>
-struct JSIConverter<std::shared_ptr<rnwgpu::GPUImageCopyExternalImage>> {
-  static std::shared_ptr<rnwgpu::GPUImageCopyExternalImage>
-  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
-    auto result = std::make_unique<rnwgpu::GPUImageCopyExternalImage>();
-    if (!outOfBounds && arg.isObject()) {
-      auto obj = arg.getObject(runtime);
-      if (obj.hasProperty(runtime, "source")) {
-        auto prop = obj.getProperty(runtime, "source");
-        result->source = JSIConverter<std::shared_ptr<ImageBitmap>>::fromJSI(
-            runtime, prop, false);
-      }
-      if (obj.hasProperty(runtime, "origin")) {
-        auto prop = obj.getProperty(runtime, "origin");
-        result->origin = JSIConverter<std::shared_ptr<GPUOrigin2D>>::fromJSI(
-            runtime, prop, false);
-      }
-
-      if (obj.hasProperty(runtime, "flipY")) {
-        auto prop = obj.getProperty(runtime, "flipY");
-        result->flipY = JSIConverter<bool>::fromJSI(runtime, prop, false);
-      }
-    }
-
-    return result;
-  }
-  static jsi::Value
-  toJSI(jsi::Runtime &runtime,
-        std::shared_ptr<rnwgpu::GPUImageCopyExternalImage> arg) {
-    throw std::runtime_error("Invalid GPUImageCopyExternalImage::toJSI()");
-  }
-};
-
-} // namespace rnwgpu

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

@@ -1,65 +0,0 @@
-#pragma once
-
-#include <memory>
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "jsi/JSIConverter.h"
-
-#include "rnwgpu/api/GPUOrigin3D.h"
-#include "rnwgpu/api/GPUTexture.h"
-
-namespace jsi = facebook::jsi;
-
-namespace rnwgpu {
-
-struct GPUImageCopyTexture {
-  std::shared_ptr<GPUTexture> texture;                // GPUTexture
-  std::optional<double> mipLevel;                     // GPUIntegerCoordinate
-  std::optional<std::shared_ptr<GPUOrigin3D>> origin; // GPUOrigin3D
-  std::optional<wgpu::TextureAspect> aspect;          // GPUTextureAspect
-};
-
-} // namespace rnwgpu
-
-namespace rnwgpu {
-
-template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUImageCopyTexture>> {
-  static std::shared_ptr<rnwgpu::GPUImageCopyTexture>
-  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
-    auto result = std::make_unique<rnwgpu::GPUImageCopyTexture>();
-    if (!outOfBounds && arg.isObject()) {
-      auto value = arg.getObject(runtime);
-      if (value.hasProperty(runtime, "texture")) {
-        auto prop = value.getProperty(runtime, "texture");
-        result->texture = JSIConverter<std::shared_ptr<GPUTexture>>::fromJSI(
-            runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "mipLevel")) {
-        auto prop = value.getProperty(runtime, "mipLevel");
-        result->mipLevel =
-            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "origin")) {
-        auto prop = value.getProperty(runtime, "origin");
-        result->origin =
-            JSIConverter<std::optional<std::shared_ptr<GPUOrigin3D>>>::fromJSI(
-                runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "aspect")) {
-        auto prop = value.getProperty(runtime, "aspect");
-        result->aspect =
-            JSIConverter<std::optional<wgpu::TextureAspect>>::fromJSI(
-                runtime, prop, false);
-      }
-    }
-
-    return result;
-  }
-  static jsi::Value toJSI(jsi::Runtime &runtime,
-                          std::shared_ptr<rnwgpu::GPUImageCopyTexture> arg) {
-    throw std::runtime_error("Invalid GPUImageCopyTexture::toJSI()");
-  }
-};
-
-} // namespace rnwgpu