@shopify/react-native-skia 2.10.0 → 2.10.2

package/cpp/rnwgpu/api/GPUFeatures.h

@@ -1,203 +0,0 @@
-#pragma once
-
-#include <string>
-
-#include <cstdio>
-
-#include "webgpu/webgpu_cpp.h"
-
-namespace rnwgpu {
-
-static void convertEnumToJSUnion(wgpu::FeatureName inEnum,
-                                 std::string *outUnion) {
-  switch (inEnum) {
-  case wgpu::FeatureName::DepthClipControl:
-    *outUnion = "depth-clip-control";
-    break;
-  case wgpu::FeatureName::Depth32FloatStencil8:
-    *outUnion = "depth32float-stencil8";
-    break;
-  case wgpu::FeatureName::TimestampQuery:
-    *outUnion = "timestamp-query";
-    break;
-  case wgpu::FeatureName::TextureCompressionBC:
-    *outUnion = "texture-compression-bc";
-    break;
-  case wgpu::FeatureName::TextureCompressionETC2:
-    *outUnion = "texture-compression-etc2";
-    break;
-  case wgpu::FeatureName::TextureCompressionASTC:
-    *outUnion = "texture-compression-astc";
-    break;
-  case wgpu::FeatureName::IndirectFirstInstance:
-    *outUnion = "indirect-first-instance";
-    break;
-  case wgpu::FeatureName::ShaderF16:
-    *outUnion = "shader-f16";
-    break;
-  case wgpu::FeatureName::RG11B10UfloatRenderable:
-    *outUnion = "rg11b10ufloat-renderable";
-    break;
-  case wgpu::FeatureName::BGRA8UnormStorage:
-    *outUnion = "bgra8unorm-storage";
-    break;
-  case wgpu::FeatureName::Float32Filterable:
-    *outUnion = "float32-filterable";
-    break;
-  case wgpu::FeatureName::Subgroups:
-    *outUnion = "subgroups";
-    break;
-  case wgpu::FeatureName::DawnInternalUsages:
-    *outUnion = "dawn-internal-usages";
-    break;
-  case wgpu::FeatureName::DawnMultiPlanarFormats:
-    *outUnion = "dawn-multi-planar-formats";
-    break;
-  case wgpu::FeatureName::DawnNative:
-    *outUnion = "dawn-native";
-    break;
-  case wgpu::FeatureName::ChromiumExperimentalTimestampQueryInsidePasses:
-    *outUnion = "chromium-experimental-timestamp-query-inside-passes";
-    break;
-  case wgpu::FeatureName::ImplicitDeviceSynchronization:
-    *outUnion = "implicit-device-synchronization";
-    break;
-  case wgpu::FeatureName::TransientAttachments:
-    *outUnion = "transient-attachments";
-    break;
-  case wgpu::FeatureName::MSAARenderToSingleSampled:
-    *outUnion = "msaa-render-to-single-sampled";
-    break;
-  case wgpu::FeatureName::DualSourceBlending:
-    *outUnion = "dual-source-blending";
-    break;
-  case wgpu::FeatureName::D3D11MultithreadProtected:
-    *outUnion = "d3d11-multithread-protected";
-    break;
-  case wgpu::FeatureName::ANGLETextureSharing:
-    *outUnion = "angle-texture-sharing";
-    break;
-  case wgpu::FeatureName::ChromiumExperimentalSubgroupMatrix:
-    *outUnion = "chromium-experimental-subgroups-matrix";
-    break;
-  case wgpu::FeatureName::PixelLocalStorageCoherent:
-    *outUnion = "pixel-local-storage-coherent";
-    break;
-  case wgpu::FeatureName::PixelLocalStorageNonCoherent:
-    *outUnion = "pixel-local-storage-non-coherent";
-    break;
-  case wgpu::FeatureName::Unorm16TextureFormats:
-    *outUnion = "unorm16-texture-formats";
-    break;
-  case wgpu::FeatureName::MultiPlanarFormatExtendedUsages:
-    *outUnion = "multi-planar-format-extended-usages";
-    break;
-  case wgpu::FeatureName::MultiPlanarFormatP010:
-    *outUnion = "multi-planar-format-p010";
-    break;
-  case wgpu::FeatureName::HostMappedPointer:
-    *outUnion = "host-mapped-pointer";
-    break;
-  case wgpu::FeatureName::MultiPlanarRenderTargets:
-    *outUnion = "multi-planar-render-targets";
-    break;
-  case wgpu::FeatureName::MultiPlanarFormatNv12a:
-    *outUnion = "multi-planar-format-nv12a";
-    break;
-  case wgpu::FeatureName::FramebufferFetch:
-    *outUnion = "framebuffer-fetch";
-    break;
-  case wgpu::FeatureName::BufferMapExtendedUsages:
-    *outUnion = "buffer-map-extended-usages";
-    break;
-  case wgpu::FeatureName::AdapterPropertiesMemoryHeaps:
-    *outUnion = "adapter-properties-memory-heaps";
-    break;
-  case wgpu::FeatureName::AdapterPropertiesD3D:
-    *outUnion = "adapter-properties-d3d";
-    break;
-  case wgpu::FeatureName::AdapterPropertiesVk:
-    *outUnion = "adapter-properties-vk";
-    break;
-  case wgpu::FeatureName::DawnFormatCapabilities:
-    *outUnion = "format-capabilities";
-    break;
-  case wgpu::FeatureName::DawnDrmFormatCapabilities:
-    *outUnion = "drm-format-capabilities";
-    break;
-  case wgpu::FeatureName::MultiPlanarFormatNv16:
-    *outUnion = "multi-planar-format-nv16";
-    break;
-  case wgpu::FeatureName::MultiPlanarFormatNv24:
-    *outUnion = "multi-planar-format-nv24";
-    break;
-  case wgpu::FeatureName::MultiPlanarFormatP210:
-    *outUnion = "multi-planar-format-p210";
-    break;
-  case wgpu::FeatureName::MultiPlanarFormatP410:
-    *outUnion = "multi-planar-format-p410";
-    break;
-  case wgpu::FeatureName::SharedTextureMemoryVkDedicatedAllocation:
-    *outUnion = "shared-texture-memory-vk-dedicated-allocation";
-    break;
-  case wgpu::FeatureName::SharedTextureMemoryAHardwareBuffer:
-    *outUnion = "shared-texture-memory-ahardware-buffer";
-    break;
-  case wgpu::FeatureName::SharedTextureMemoryDmaBuf:
-    *outUnion = "shared-texture-memory-dma-buf";
-    break;
-  case wgpu::FeatureName::SharedTextureMemoryOpaqueFD:
-    *outUnion = "shared-texture-memory-opaque-fd";
-    break;
-  case wgpu::FeatureName::SharedTextureMemoryZirconHandle:
-    *outUnion = "shared-texture-memory-zircon-handle";
-    break;
-  case wgpu::FeatureName::SharedTextureMemoryDXGISharedHandle:
-    *outUnion = "shared-texture-memory-dxgi-shared-handle";
-    break;
-  case wgpu::FeatureName::SharedTextureMemoryD3D11Texture2D:
-    *outUnion = "shared-texture-memory-d3d11-texture2d";
-    break;
-  case wgpu::FeatureName::SharedTextureMemoryIOSurface:
-    *outUnion = "shared-texture-memory-iosurface";
-    break;
-  case wgpu::FeatureName::SharedTextureMemoryEGLImage:
-    *outUnion = "shared-texture-memory-egl-image";
-    break;
-  case wgpu::FeatureName::SharedFenceVkSemaphoreOpaqueFD:
-    *outUnion = "shared-fence-vk-semaphore-opaque-fd";
-    break;
-  case wgpu::FeatureName::SharedFenceSyncFD:
-    *outUnion = "shared-fence-vk-semaphore-sync-fd";
-    break;
-  case wgpu::FeatureName::SharedFenceVkSemaphoreZirconHandle:
-    *outUnion = "shared-fence-vk-semaphore-zircon-handle";
-    break;
-  case wgpu::FeatureName::SharedFenceDXGISharedHandle:
-    *outUnion = "shared-fence-dxgi-shared-handle";
-    break;
-  case wgpu::FeatureName::SharedFenceMTLSharedEvent:
-    *outUnion = "shared-fence-mtl-shared-event";
-    break;
-  case wgpu::FeatureName::SharedBufferMemoryD3D12Resource:
-    *outUnion = "shared-buffer-memory-d3d12-resource";
-    break;
-  case wgpu::FeatureName::StaticSamplers:
-    *outUnion = "static-samplers";
-    break;
-  case wgpu::FeatureName::YCbCrVulkanSamplers:
-    *outUnion = "ycbcr-vulkan-samplers";
-    break;
-  case wgpu::FeatureName::ShaderModuleCompilationOptions:
-    *outUnion = "shader-module-compilation-options";
-    break;
-  case wgpu::FeatureName::DawnLoadResolveTexture:
-    *outUnion = "dawn-load-resolve-texture";
-    break;
-  default:
-    fprintf(stderr, "Unknown feature name %d\n", static_cast<int>(inEnum));
-    *outUnion = "";
-  }
-}
-
-} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUInternalError.h

@@ -1,31 +0,0 @@
-#pragma once
-
-#include <string>
-
-#include "jsi/NativeObject.h"
-
-namespace rnwgpu {
-
-namespace jsi = facebook::jsi;
-
-class GPUInternalError : public NativeObject<GPUInternalError> {
-public:
-  static constexpr const char *CLASS_NAME = "GPUInternalError";
-
-  explicit GPUInternalError(std::string message)
-      : NativeObject(CLASS_NAME), _message(std::move(message)) {}
-
-public:
-  std::string getBrand() { return CLASS_NAME; }
-  std::string getMessage() { return _message; }
-
-  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
-    installGetter(runtime, prototype, "__brand", &GPUInternalError::getBrand);
-    installGetter(runtime, prototype, "message", &GPUInternalError::getMessage);
-  }
-
-private:
-  std::string _message;
-};
-
-} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUOrigin2D.h

@@ -1,55 +0,0 @@
-#pragma once
-
-#include <memory>
-
-#include "jsi/JSIConverter.h"
-
-#include "webgpu/webgpu_cpp.h"
-
-namespace rnwgpu {
-
-struct GPUOrigin2D {
-  double x = 0;
-  double y = 0;
-};
-
-template <> struct JSIConverter<std::shared_ptr<GPUOrigin2D>> {
-  static std::shared_ptr<GPUOrigin2D>
-  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
-    auto result = std::make_unique<GPUOrigin2D>();
-    if (!outOfBounds && arg.isObject()) {
-      if (arg.getObject(runtime).isArray(runtime)) {
-        auto array = arg.getObject(runtime).asArray(runtime);
-        auto size = array.size(runtime);
-        if (size == 0) {
-          throw std::runtime_error(
-              "Expected an array of size >1 for GPUTExtent2D");
-        }
-        if (size > 0) {
-          result->x = array.getValueAtIndex(runtime, 0).asNumber();
-        }
-        if (size > 1) {
-          result->y = array.getValueAtIndex(runtime, 1).asNumber();
-        }
-      } else {
-        auto object = arg.getObject(runtime);
-        if (object.hasProperty(runtime, "x")) {
-          result->x = object.getProperty(runtime, "x").asNumber();
-        }
-        if (object.hasProperty(runtime, "y")) {
-          result->y = object.getProperty(runtime, "y").asNumber();
-        }
-      }
-    } else {
-      throw std::runtime_error("Expected an object for GPUOrigin3D");
-    }
-    return result;
-  }
-  static jsi::Value toJSI(jsi::Runtime &runtime,
-                          std::shared_ptr<GPUOrigin2D> arg) {
-    // No conversions here
-    return jsi::Value::null();
-  }
-};
-
-} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUOrigin3D.h

@@ -1,62 +0,0 @@
-#pragma once
-
-#include <memory>
-
-#include "jsi/JSIConverter.h"
-
-#include "webgpu/webgpu_cpp.h"
-
-namespace rnwgpu {
-
-struct GPUOrigin3D {
-  double x = 0;
-  double y = 0;
-  double z = 0;
-};
-
-template <> struct JSIConverter<std::shared_ptr<GPUOrigin3D>> {
-  static std::shared_ptr<GPUOrigin3D>
-  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
-    auto result = std::make_unique<GPUOrigin3D>();
-    if (!outOfBounds && arg.isObject()) {
-      if (arg.getObject(runtime).isArray(runtime)) {
-        auto array = arg.getObject(runtime).asArray(runtime);
-        auto size = array.size(runtime);
-        if (size == 0) {
-          throw std::runtime_error(
-              "Expected an array of size >1 for GPUTExtent3D");
-        }
-        if (size > 0) {
-          result->x = array.getValueAtIndex(runtime, 0).asNumber();
-        }
-        if (size > 1) {
-          result->y = array.getValueAtIndex(runtime, 1).asNumber();
-        }
-        if (size > 2) {
-          result->z = array.getValueAtIndex(runtime, 2).asNumber();
-        }
-      } else {
-        auto object = arg.getObject(runtime);
-        if (object.hasProperty(runtime, "x")) {
-          result->x = object.getProperty(runtime, "x").asNumber();
-        }
-        if (object.hasProperty(runtime, "y")) {
-          result->y = object.getProperty(runtime, "y").asNumber();
-        }
-        if (object.hasProperty(runtime, "z")) {
-          result->z = object.getProperty(runtime, "z").asNumber();
-        }
-      }
-    } else {
-      throw std::runtime_error("Expected an object for GPUOrigin3D");
-    }
-    return result;
-  }
-  static jsi::Value toJSI(jsi::Runtime &runtime,
-                          std::shared_ptr<GPUOrigin3D> arg) {
-    // No conversions here
-    return jsi::Value::null();
-  }
-};
-
-} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUOutOfMemoryError.h

@@ -1,33 +0,0 @@
-#pragma once
-
-#include <string>
-
-#include "jsi/NativeObject.h"
-
-namespace rnwgpu {
-
-namespace jsi = facebook::jsi;
-
-class GPUOutOfMemoryError : public NativeObject<GPUOutOfMemoryError> {
-public:
-  static constexpr const char *CLASS_NAME = "GPUOutOfMemoryError";
-
-  explicit GPUOutOfMemoryError(std::string message)
-      : NativeObject(CLASS_NAME), _message(std::move(message)) {}
-
-public:
-  std::string getBrand() { return CLASS_NAME; }
-  std::string getMessage() { return _message; }
-
-  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
-    installGetter(runtime, prototype, "__brand",
-                  &GPUOutOfMemoryError::getBrand);
-    installGetter(runtime, prototype, "message",
-                  &GPUOutOfMemoryError::getMessage);
-  }
-
-private:
-  std::string _message;
-};
-
-} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUPipelineLayout.h

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

package/cpp/rnwgpu/api/GPUQuerySet.cpp

@@ -1,11 +0,0 @@
-#include "GPUQuerySet.h"
-
-namespace rnwgpu {
-
-void GPUQuerySet::destroy() { _instance.Destroy(); }
-
-wgpu::QueryType GPUQuerySet::getType() { return _instance.GetType(); }
-
-uint32_t GPUQuerySet::getCount() { return _instance.GetCount(); }
-
-} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUQuerySet.h

@@ -1,73 +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 GPUQuerySet : public NativeObject<GPUQuerySet> {
-public:
-  static constexpr const char *CLASS_NAME = "GPUQuerySet";
-
-  explicit GPUQuerySet(wgpu::QuerySet instance, std::string label)
-      : NativeObject(CLASS_NAME), _instance(instance), _label(label) {}
-
-public:
-  std::string getBrand() { return CLASS_NAME; }
-
-  void destroy();
-
-  wgpu::QueryType getType();
-  uint32_t getCount();
-
-  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", &GPUQuerySet::getBrand);
-    installMethod(runtime, prototype, "destroy", &GPUQuerySet::destroy);
-    installGetter(runtime, prototype, "type", &GPUQuerySet::getType);
-    installGetter(runtime, prototype, "count", &GPUQuerySet::getCount);
-    installGetterSetter(runtime, prototype, "label", &GPUQuerySet::getLabel,
-                        &GPUQuerySet::setLabel);
-  }
-
-  inline const wgpu::QuerySet get() { return _instance; }
-
-  size_t getMemoryPressure() override {
-    uint32_t count = getCount();
-    wgpu::QueryType type = getType();
-
-    // Estimate bytes per query based on type
-    size_t bytesPerQuery = 8; // Default estimate
-    switch (type) {
-    case wgpu::QueryType::Occlusion:
-      bytesPerQuery = 8; // 64-bit counter
-      break;
-    case wgpu::QueryType::Timestamp:
-      bytesPerQuery = 8; // 64-bit timestamp
-      break;
-    default:
-      bytesPerQuery = 8; // Safe default
-      break;
-    }
-
-    return static_cast<size_t>(count) * bytesPerQuery;
-  }
-
-private:
-  wgpu::QuerySet _instance;
-  std::string _label;
-};
-
-} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUQueue.cpp

@@ -1,179 +0,0 @@
-#include "GPUQueue.h"
-
-#include <cstring>
-#include <limits>
-#include <memory>
-#include <vector>
-
-#include "Convertors.h"
-
-namespace rnwgpu {
-
-struct BufferSource {
-  void *data;
-  size_t size;            // in bytes
-  size_t bytesPerElement; // 1 for ArrayBuffers
-};
-
-void GPUQueue::submit(
-    std::vector<std::shared_ptr<GPUCommandBuffer>> commandBuffers) {
-  std::vector<wgpu::CommandBuffer> bufs(commandBuffers.size());
-  for (size_t i = 0; i < commandBuffers.size(); i++) {
-    bufs[i] = commandBuffers[i]->get();
-  }
-  Convertor conv;
-  uint32_t bufs_size;
-  if (!conv(bufs_size, bufs.size())) {
-    return;
-  }
-  _instance.Submit(bufs_size, bufs.data());
-}
-
-void GPUQueue::writeBuffer(std::shared_ptr<GPUBuffer> buffer,
-                           uint64_t bufferOffset,
-                           std::shared_ptr<ArrayBuffer> data,
-                           std::optional<uint64_t> dataOffsetElements,
-                           std::optional<size_t> sizeElements) {
-  wgpu::Buffer buf = buffer->get();
-  BufferSource src{.data = data->_data,
-                   .size = data->_size,
-                   .bytesPerElement = data->_bytesPerElement};
-
-  // Note that in the JS semantics of WebGPU, writeBuffer works in number of
-  // elements of the typed arrays.
-  if (dataOffsetElements >
-      static_cast<uint64_t>(src.size / src.bytesPerElement)) {
-    throw std::runtime_error("dataOffset is larger than data's size.");
-    return;
-  }
-  uint64_t dataOffset = dataOffsetElements.value_or(0) * src.bytesPerElement;
-  src.data = reinterpret_cast<uint8_t *>(src.data) + dataOffset;
-  src.size -= dataOffset;
-
-  // Size defaults to dataSize - dataOffset. Instead of computing in elements,
-  // we directly use it in bytes, and convert the provided value, if any, in
-  // bytes.
-  uint64_t size64 = static_cast<uint64_t>(src.size);
-  if (sizeElements.has_value()) {
-    if (sizeElements.value() >
-        std::numeric_limits<uint64_t>::max() / src.bytesPerElement) {
-      throw std::runtime_error("size overflows.");
-      return;
-    }
-    size64 = sizeElements.value() * src.bytesPerElement;
-  }
-
-  if (size64 > static_cast<uint64_t>(src.size)) {
-    throw std::runtime_error("size + dataOffset is larger than data's size.");
-    return;
-  }
-
-  if (size64 % 4 != 0) {
-    throw std::runtime_error("size is not a multiple of 4 bytes.");
-
-    return;
-  }
-
-  assert(size64 <= std::numeric_limits<size_t>::max());
-  _instance.WriteBuffer(buf, bufferOffset, src.data,
-                        static_cast<size_t>(size64));
-}
-
-async::AsyncTaskHandle GPUQueue::onSubmittedWorkDone(jsi::Runtime &runtime) {
-  auto queue = _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(
-      [queue](const async::AsyncTaskHandle::ResolveFunction &resolve,
-              const async::AsyncTaskHandle::RejectFunction &reject) {
-        queue.OnSubmittedWorkDone(
-            wgpu::CallbackMode::AllowProcessEvents,
-            [resolve, reject](wgpu::QueueWorkDoneStatus status,
-                              wgpu::StringView message) {
-              if (status == wgpu::QueueWorkDoneStatus::Success) {
-                resolve(nullptr);
-              } else {
-                std::string error =
-                    message.length ? std::string(message.data, message.length)
-                                   : "Queue work did not complete successfully";
-                reject(std::move(error));
-              }
-            });
-      });
-}
-
-void GPUQueue::copyExternalImageToTexture(
-    std::shared_ptr<GPUImageCopyExternalImage> source,
-    std::shared_ptr<GPUImageCopyTextureTagged> destination,
-    std::shared_ptr<GPUExtent3D> size) {
-  if (!source || source->source == nullptr) {
-    throw std::runtime_error("GPUQueue::copyExternalImageToTexture(): "
-                             "source.source (ImageBitmap) is required");
-  }
-  // ImageBitmap holds decoded, row-major RGBA8 pixels. We upload them with
-  // WriteTexture (a CPU staging copy) rather than a GPU blit; that is enough
-  // for the common "decode an image, sample it" path and avoids needing a
-  // source GPUTexture.
-  const auto &pixels = source->source->data();
-  auto width = static_cast<uint32_t>(source->source->getWidth());
-  auto height = static_cast<uint32_t>(source->source->getHeight());
-  if (pixels.empty() || width == 0 || height == 0) {
-    throw std::runtime_error("GPUQueue::copyExternalImageToTexture(): "
-                             "ImageBitmap has no pixels (was it closed?)");
-  }
-  auto bytesPerPixel = static_cast<uint32_t>(
-      pixels.size() / (static_cast<size_t>(width) * height));
-  uint32_t rowSize = bytesPerPixel * width;
-
-  wgpu::TexelCopyTextureInfo dst{};
-  wgpu::TexelCopyBufferLayout layout{};
-  wgpu::Extent3D sz{};
-  Convertor conv;
-  auto dataLayout = std::make_shared<GPUImageDataLayout>(
-      GPUImageDataLayout{std::optional<double>{0.0},
-                         std::optional<double>{static_cast<double>(rowSize)},
-                         std::optional<double>{static_cast<double>(height)}});
-  if (!conv(dst.aspect, destination->aspect) ||
-      !conv(dst.mipLevel, destination->mipLevel) ||
-      !conv(dst.origin, destination->origin) ||
-      !conv(dst.texture, destination->texture) || !conv(layout, dataLayout) ||
-      !conv(sz, size)) {
-    throw std::runtime_error(
-        "Invalid input for GPUQueue::copyExternalImageToTexture()");
-  }
-
-  if (source->flipY.value_or(false)) {
-    // Flip rows so the image is uploaded bottom-up (matches the WebGPU
-    // copyExternalImageToTexture flipY semantics).
-    std::vector<uint8_t> flippedData(pixels.size());
-    for (uint32_t row = 0; row < height; ++row) {
-      std::memcpy(flippedData.data() + (height - 1 - row) * rowSize,
-                  pixels.data() + row * rowSize, rowSize);
-    }
-    _instance.WriteTexture(&dst, flippedData.data(), flippedData.size(),
-                           &layout, &sz);
-  } else {
-    _instance.WriteTexture(&dst, pixels.data(), pixels.size(), &layout, &sz);
-  }
-}
-
-void GPUQueue::writeTexture(std::shared_ptr<GPUImageCopyTexture> destination,
-                            std::shared_ptr<ArrayBuffer> data,
-                            std::shared_ptr<GPUImageDataLayout> dataLayout,
-                            std::shared_ptr<GPUExtent3D> size) {
-  wgpu::TexelCopyTextureInfo dst{};
-  wgpu::TexelCopyBufferLayout layout{};
-  wgpu::Extent3D sz{};
-  Convertor conv;
-  if (!conv(dst, destination) ||   //
-      !conv(layout, dataLayout) || //
-      !conv(sz, size)) {
-    throw std::runtime_error("Invalid input for GPUQueue::writeTexture()");
-  }
-
-  _instance.WriteTexture(&dst, data->_data, data->_size, &layout, &sz);
-}
-
-} // namespace rnwgpu