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

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

@@ -1,60 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <string>
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "jsi/JSIConverter.h"
-
-#include "rnwgpu/api/GPUPipelineLayout.h"
-
-namespace jsi = facebook::jsi;
-
-namespace rnwgpu {
-
-struct GPUShaderModuleCompilationHint {
-  std::string entryPoint; // string
-  std::optional<
-      std::variant<std::nullptr_t, std::shared_ptr<GPUPipelineLayout>>>
-      layout; // | GPUPipelineLayout | GPUAutoLayoutMode
-};
-
-} // namespace rnwgpu
-
-namespace rnwgpu {
-
-template <>
-struct JSIConverter<std::shared_ptr<rnwgpu::GPUShaderModuleCompilationHint>> {
-  static std::shared_ptr<rnwgpu::GPUShaderModuleCompilationHint>
-  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
-    auto result = std::make_unique<rnwgpu::GPUShaderModuleCompilationHint>();
-    if (!outOfBounds && arg.isObject()) {
-      auto value = arg.getObject(runtime);
-      if (value.hasProperty(runtime, "entryPoint")) {
-        auto prop = value.getProperty(runtime, "entryPoint");
-        result->entryPoint =
-            JSIConverter<std::string>::fromJSI(runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "layout")) {
-        auto prop = value.getProperty(runtime, "layout");
-        if (prop.isNull() || prop.isString()) {
-          result->layout = nullptr;
-        } else {
-          result->layout =
-              JSIConverter<std::shared_ptr<GPUPipelineLayout>>::fromJSI(
-                  runtime, prop, false);
-        }
-      }
-    }
-
-    return result;
-  }
-  static jsi::Value
-  toJSI(jsi::Runtime &runtime,
-        std::shared_ptr<rnwgpu::GPUShaderModuleCompilationHint> arg) {
-    throw std::runtime_error("Invalid GPUShaderModuleCompilationHint::toJSI()");
-  }
-};
-
-} // namespace rnwgpu

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

@@ -1,62 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "jsi/JSIConverter.h"
-
-#include "GPUShaderModuleCompilationHint.h"
-
-namespace jsi = facebook::jsi;
-
-namespace rnwgpu {
-
-struct GPUShaderModuleDescriptor {
-  std::string code; // string
-  std::optional<std::vector<std::shared_ptr<GPUShaderModuleCompilationHint>>>
-      compilationHints;             // Array<GPUShaderModuleCompilationHint>
-  std::optional<std::string> label; // string
-};
-
-} // namespace rnwgpu
-
-namespace rnwgpu {
-
-template <>
-struct JSIConverter<std::shared_ptr<rnwgpu::GPUShaderModuleDescriptor>> {
-  static std::shared_ptr<rnwgpu::GPUShaderModuleDescriptor>
-  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
-    auto result = std::make_unique<rnwgpu::GPUShaderModuleDescriptor>();
-    if (!outOfBounds && arg.isObject()) {
-      auto value = arg.getObject(runtime);
-      if (value.hasProperty(runtime, "code")) {
-        auto prop = value.getProperty(runtime, "code");
-        result->code = JSIConverter<std::string>::fromJSI(runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "compilationHints")) {
-        auto prop = value.getProperty(runtime, "compilationHints");
-        result->compilationHints = JSIConverter<std::optional<std::vector<
-            std::shared_ptr<GPUShaderModuleCompilationHint>>>>::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::GPUShaderModuleDescriptor> arg) {
-    throw std::runtime_error("Invalid GPUShaderModuleDescriptor::toJSI()");
-  }
-};
-
-} // namespace rnwgpu

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

@@ -1,25 +0,0 @@
-#pragma once
-
-#include <jsi/jsi.h>
-
-#include "webgpu/webgpu_cpp.h"
-
-namespace rnwgpu {
-
-namespace jsi = facebook::jsi;
-
-class GPUShaderStage {
-public:
-  static jsi::Object create(jsi::Runtime &runtime) {
-    jsi::Object obj(runtime);
-    obj.setProperty(runtime, "VERTEX",
-                    static_cast<double>(wgpu::ShaderStage::Vertex));
-    obj.setProperty(runtime, "FRAGMENT",
-                    static_cast<double>(wgpu::ShaderStage::Fragment));
-    obj.setProperty(runtime, "COMPUTE",
-                    static_cast<double>(wgpu::ShaderStage::Compute));
-    return obj;
-  }
-};
-
-} // namespace rnwgpu

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

@@ -1,58 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <optional>
-#include <string>
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "jsi/JSIConverter.h"
-
-namespace jsi = facebook::jsi;
-
-namespace rnwgpu {
-
-// Descriptor for GPUDevice.importSharedFence. `handle` is the native handle
-// (an id<MTLSharedEvent> pointer on Apple, an OS file descriptor on Android),
-// passed from JS as a BigInt.
-struct GPUSharedFenceDescriptor {
-  std::string type;
-  void *handle = nullptr;
-  std::optional<std::string> label;
-};
-
-} // namespace rnwgpu
-
-namespace rnwgpu {
-
-template <>
-struct JSIConverter<std::shared_ptr<rnwgpu::GPUSharedFenceDescriptor>> {
-  static std::shared_ptr<rnwgpu::GPUSharedFenceDescriptor>
-  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
-    auto result = std::make_unique<rnwgpu::GPUSharedFenceDescriptor>();
-    if (!outOfBounds && arg.isObject()) {
-      auto value = arg.getObject(runtime);
-      if (value.hasProperty(runtime, "type")) {
-        result->type =
-            value.getProperty(runtime, "type").asString(runtime).utf8(runtime);
-      }
-      if (value.hasProperty(runtime, "handle")) {
-        auto prop = value.getProperty(runtime, "handle");
-        result->handle = JSIConverter<void *>::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::GPUSharedFenceDescriptor> /*arg*/) {
-    throw std::runtime_error("Invalid GPUSharedFenceDescriptor::toJSI()");
-  }
-};
-
-} // namespace rnwgpu

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

@@ -1,51 +0,0 @@
-#pragma once
-
-#include <cstdint>
-#include <memory>
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "jsi/JSIConverter.h"
-
-#include "rnwgpu/api/GPUSharedFence.h"
-
-namespace jsi = facebook::jsi;
-
-namespace rnwgpu {
-
-// A fence and the timeline value to wait for / signal at.
-struct GPUSharedFenceState {
-  std::shared_ptr<GPUSharedFence> fence;
-  uint64_t signaledValue = 0;
-};
-
-} // namespace rnwgpu
-
-namespace rnwgpu {
-
-template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUSharedFenceState>> {
-  static std::shared_ptr<rnwgpu::GPUSharedFenceState>
-  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
-    auto result = std::make_unique<rnwgpu::GPUSharedFenceState>();
-    if (!outOfBounds && arg.isObject()) {
-      auto value = arg.getObject(runtime);
-      if (value.hasProperty(runtime, "fence")) {
-        auto prop = value.getProperty(runtime, "fence");
-        result->fence = JSIConverter<std::shared_ptr<GPUSharedFence>>::fromJSI(
-            runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "signaledValue")) {
-        auto prop = value.getProperty(runtime, "signaledValue");
-        result->signaledValue =
-            JSIConverter<uint64_t>::fromJSI(runtime, prop, false);
-      }
-    }
-    return result;
-  }
-  static jsi::Value toJSI(jsi::Runtime &runtime,
-                          std::shared_ptr<rnwgpu::GPUSharedFenceState> arg) {
-    throw std::runtime_error("Invalid GPUSharedFenceState::toJSI()");
-  }
-};
-
-} // namespace rnwgpu

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

@@ -1,73 +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 {
-
-// Descriptor for GPUDevice.importSharedTextureMemory.
-//
-// `handle` is a native buffer pointer as a uintptr_t (passed as a BigInt from
-// JS), i.e. the value returned by Skia.NativeBuffer.MakeFromImage:
-//   - Apple platforms: CVPixelBufferRef (its backing IOSurface is imported)
-//   - Android: AHardwareBuffer*
-//
-// Lifetime: the caller is responsible for keeping the underlying object alive
-// (via Skia.NativeBuffer.Release) for as long as this shared memory is in use.
-struct GPUSharedTextureMemoryDescriptor {
-  uint64_t handle = 0;
-  std::optional<std::string> label;
-};
-
-} // namespace rnwgpu
-
-namespace rnwgpu {
-
-template <>
-struct JSIConverter<std::shared_ptr<rnwgpu::GPUSharedTextureMemoryDescriptor>> {
-  static std::shared_ptr<rnwgpu::GPUSharedTextureMemoryDescriptor>
-  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
-    auto result = std::make_shared<rnwgpu::GPUSharedTextureMemoryDescriptor>();
-    if (!outOfBounds && arg.isObject()) {
-      auto value = arg.getObject(runtime);
-      if (value.hasProperty(runtime, "handle")) {
-        auto prop = value.getProperty(runtime, "handle");
-        // 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->handle = prop.asBigInt(runtime).asUint64(runtime);
-        } else if (!prop.isUndefined() && !prop.isNull()) {
-          throw jsi::JSError(
-              runtime, "GPUSharedTextureMemoryDescriptor.handle 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);
-        }
-      }
-    }
-    return result;
-  }
-  static jsi::Value
-  toJSI(jsi::Runtime & /*runtime*/,
-        std::shared_ptr<rnwgpu::GPUSharedTextureMemoryDescriptor> /*arg*/) {
-    throw std::runtime_error(
-        "Invalid GPUSharedTextureMemoryDescriptor::toJSI()");
-  }
-};
-
-} // namespace rnwgpu

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

@@ -1,64 +0,0 @@
-#pragma once
-
-#include <memory>
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "jsi/JSIConverter.h"
-
-namespace jsi = facebook::jsi;
-
-namespace rnwgpu {
-
-struct GPUStencilFaceState {
-  std::optional<wgpu::CompareFunction> compare;      // GPUCompareFunction
-  std::optional<wgpu::StencilOperation> failOp;      // GPUStencilOperation
-  std::optional<wgpu::StencilOperation> depthFailOp; // GPUStencilOperation
-  std::optional<wgpu::StencilOperation> passOp;      // GPUStencilOperation
-};
-
-} // namespace rnwgpu
-
-namespace rnwgpu {
-
-template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUStencilFaceState>> {
-  static std::shared_ptr<rnwgpu::GPUStencilFaceState>
-  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
-    auto result = std::make_unique<rnwgpu::GPUStencilFaceState>();
-    if (!outOfBounds && arg.isObject()) {
-      auto value = arg.getObject(runtime);
-      if (value.hasProperty(runtime, "compare")) {
-        auto prop = value.getProperty(runtime, "compare");
-        result->compare =
-            JSIConverter<std::optional<wgpu::CompareFunction>>::fromJSI(
-                runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "failOp")) {
-        auto prop = value.getProperty(runtime, "failOp");
-        result->failOp =
-            JSIConverter<std::optional<wgpu::StencilOperation>>::fromJSI(
-                runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "depthFailOp")) {
-        auto prop = value.getProperty(runtime, "depthFailOp");
-        result->depthFailOp =
-            JSIConverter<std::optional<wgpu::StencilOperation>>::fromJSI(
-                runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "passOp")) {
-        auto prop = value.getProperty(runtime, "passOp");
-        result->passOp =
-            JSIConverter<std::optional<wgpu::StencilOperation>>::fromJSI(
-                runtime, prop, false);
-      }
-    }
-
-    return result;
-  }
-  static jsi::Value toJSI(jsi::Runtime &runtime,
-                          std::shared_ptr<rnwgpu::GPUStencilFaceState> arg) {
-    throw std::runtime_error("Invalid GPUStencilFaceState::toJSI()");
-  }
-};
-
-} // namespace rnwgpu

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

@@ -1,59 +0,0 @@
-#pragma once
-
-#include <memory>
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "jsi/JSIConverter.h"
-
-namespace jsi = facebook::jsi;
-
-namespace rnwgpu {
-
-struct GPUStorageTextureBindingLayout {
-  std::optional<wgpu::StorageTextureAccess> access; // GPUStorageTextureAccess
-  wgpu::TextureFormat format;                       // GPUTextureFormat
-  std::optional<wgpu::TextureViewDimension>
-      viewDimension; // GPUTextureViewDimension
-};
-
-} // namespace rnwgpu
-
-namespace rnwgpu {
-
-template <>
-struct JSIConverter<std::shared_ptr<rnwgpu::GPUStorageTextureBindingLayout>> {
-  static std::shared_ptr<rnwgpu::GPUStorageTextureBindingLayout>
-  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
-    auto result = std::make_unique<rnwgpu::GPUStorageTextureBindingLayout>();
-    if (!outOfBounds && arg.isObject()) {
-      auto value = arg.getObject(runtime);
-      if (value.hasProperty(runtime, "access")) {
-        auto prop = value.getProperty(runtime, "access");
-        result->access =
-            JSIConverter<std::optional<wgpu::StorageTextureAccess>>::fromJSI(
-                runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "format")) {
-        auto prop = value.getProperty(runtime, "format");
-        result->format =
-            JSIConverter<wgpu::TextureFormat>::fromJSI(runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "viewDimension")) {
-        auto prop = value.getProperty(runtime, "viewDimension");
-        result->viewDimension =
-            JSIConverter<std::optional<wgpu::TextureViewDimension>>::fromJSI(
-                runtime, prop, false);
-      }
-    }
-
-    return result;
-  }
-  static jsi::Value
-  toJSI(jsi::Runtime &runtime,
-        std::shared_ptr<rnwgpu::GPUStorageTextureBindingLayout> arg) {
-    throw std::runtime_error("Invalid GPUStorageTextureBindingLayout::toJSI()");
-  }
-};
-
-} // namespace rnwgpu

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

@@ -1,59 +0,0 @@
-#pragma once
-
-#include <memory>
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "jsi/JSIConverter.h"
-
-namespace jsi = facebook::jsi;
-
-namespace rnwgpu {
-
-struct GPUTextureBindingLayout {
-  std::optional<wgpu::TextureSampleType> sampleType; // GPUTextureSampleType
-  std::optional<wgpu::TextureViewDimension>
-      viewDimension;                // GPUTextureViewDimension
-  std::optional<bool> multisampled; // boolean
-};
-
-} // namespace rnwgpu
-
-namespace rnwgpu {
-
-template <>
-struct JSIConverter<std::shared_ptr<rnwgpu::GPUTextureBindingLayout>> {
-  static std::shared_ptr<rnwgpu::GPUTextureBindingLayout>
-  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
-    auto result = std::make_unique<rnwgpu::GPUTextureBindingLayout>();
-    if (!outOfBounds && arg.isObject()) {
-      auto value = arg.getObject(runtime);
-      if (value.hasProperty(runtime, "sampleType")) {
-        auto prop = value.getProperty(runtime, "sampleType");
-        result->sampleType =
-            JSIConverter<std::optional<wgpu::TextureSampleType>>::fromJSI(
-                runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "viewDimension")) {
-        auto prop = value.getProperty(runtime, "viewDimension");
-        result->viewDimension =
-            JSIConverter<std::optional<wgpu::TextureViewDimension>>::fromJSI(
-                runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "multisampled")) {
-        auto prop = value.getProperty(runtime, "multisampled");
-        result->multisampled =
-            JSIConverter<std::optional<bool>>::fromJSI(runtime, prop, false);
-      }
-    }
-
-    return result;
-  }
-  static jsi::Value
-  toJSI(jsi::Runtime &runtime,
-        std::shared_ptr<rnwgpu::GPUTextureBindingLayout> arg) {
-    throw std::runtime_error("Invalid GPUTextureBindingLayout::toJSI()");
-  }
-};
-
-} // namespace rnwgpu

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

@@ -1,91 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "jsi/JSIConverter.h"
-
-#include "rnwgpu/api/GPUExtent3D.h"
-
-namespace jsi = facebook::jsi;
-
-namespace rnwgpu {
-
-struct GPUTextureDescriptor {
-  std::shared_ptr<GPUExtent3D> size;               // GPUExtent3DStrict
-  std::optional<double> mipLevelCount;             // GPUIntegerCoordinate
-  std::optional<double> sampleCount;               // GPUSize32
-  std::optional<wgpu::TextureDimension> dimension; // GPUTextureDimension
-  wgpu::TextureFormat format;                      // GPUTextureFormat
-  double usage;                                    // GPUTextureUsageFlags
-  std::optional<std::vector<wgpu::TextureFormat>>
-      viewFormats;                  // Iterable<GPUTextureFormat>
-  std::optional<std::string> label; // string
-};
-
-} // namespace rnwgpu
-
-namespace rnwgpu {
-
-template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUTextureDescriptor>> {
-  static std::shared_ptr<rnwgpu::GPUTextureDescriptor>
-  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
-    auto result = std::make_unique<rnwgpu::GPUTextureDescriptor>();
-    if (!outOfBounds && arg.isObject()) {
-      auto value = arg.getObject(runtime);
-      if (value.hasProperty(runtime, "size")) {
-        auto prop = value.getProperty(runtime, "size");
-        result->size = JSIConverter<std::shared_ptr<GPUExtent3D>>::fromJSI(
-            runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "mipLevelCount")) {
-        auto prop = value.getProperty(runtime, "mipLevelCount");
-        result->mipLevelCount =
-            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "sampleCount")) {
-        auto prop = value.getProperty(runtime, "sampleCount");
-        result->sampleCount =
-            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "dimension")) {
-        auto prop = value.getProperty(runtime, "dimension");
-        result->dimension =
-            JSIConverter<std::optional<wgpu::TextureDimension>>::fromJSI(
-                runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "format")) {
-        auto prop = value.getProperty(runtime, "format");
-        result->format =
-            JSIConverter<wgpu::TextureFormat>::fromJSI(runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "usage")) {
-        auto prop = value.getProperty(runtime, "usage");
-        result->usage = JSIConverter<double>::fromJSI(runtime, prop, false);
-      }
-      if (value.hasProperty(runtime, "viewFormats")) {
-        auto prop = value.getProperty(runtime, "viewFormats");
-        result->viewFormats = JSIConverter<
-            std::optional<std::vector<wgpu::TextureFormat>>>::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::GPUTextureDescriptor> arg) {
-    throw std::runtime_error("Invalid GPUTextureDescriptor::toJSI()");
-  }
-};
-
-} // namespace rnwgpu

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

@@ -1,29 +0,0 @@
-#pragma once
-
-#include <jsi/jsi.h>
-
-#include "webgpu/webgpu_cpp.h"
-
-namespace rnwgpu {
-
-namespace jsi = facebook::jsi;
-
-class GPUTextureUsage {
-public:
-  static jsi::Object create(jsi::Runtime &runtime) {
-    jsi::Object obj(runtime);
-    obj.setProperty(runtime, "COPY_SRC",
-                    static_cast<double>(wgpu::TextureUsage::CopySrc));
-    obj.setProperty(runtime, "COPY_DST",
-                    static_cast<double>(wgpu::TextureUsage::CopyDst));
-    obj.setProperty(runtime, "TEXTURE_BINDING",
-                    static_cast<double>(wgpu::TextureUsage::TextureBinding));
-    obj.setProperty(runtime, "STORAGE_BINDING",
-                    static_cast<double>(wgpu::TextureUsage::StorageBinding));
-    obj.setProperty(runtime, "RENDER_ATTACHMENT",
-                    static_cast<double>(wgpu::TextureUsage::RenderAttachment));
-    return obj;
-  }
-};
-
-} // namespace rnwgpu