react-native-webgpu 0.5.11

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

@@ -0,0 +1,111 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "JSIConverter.h"
+#include "WGPULogger.h"
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+struct GPUSamplerDescriptor {
+  std::optional<wgpu::AddressMode> addressModeU;      // GPUAddressMode
+  std::optional<wgpu::AddressMode> addressModeV;      // GPUAddressMode
+  std::optional<wgpu::AddressMode> addressModeW;      // GPUAddressMode
+  std::optional<wgpu::FilterMode> magFilter;          // GPUFilterMode
+  std::optional<wgpu::FilterMode> minFilter;          // GPUFilterMode
+  std::optional<wgpu::MipmapFilterMode> mipmapFilter; // GPUMipmapFilterMode
+  std::optional<double> lodMinClamp;                  // number
+  std::optional<double> lodMaxClamp;                  // number
+  std::optional<wgpu::CompareFunction> compare;       // GPUCompareFunction
+  std::optional<double> maxAnisotropy;                // number
+  std::optional<std::string> label;                   // string
+};
+
+} // namespace rnwgpu
+
+namespace rnwgpu {
+
+template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUSamplerDescriptor>> {
+  static std::shared_ptr<rnwgpu::GPUSamplerDescriptor>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUSamplerDescriptor>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "addressModeU")) {
+        auto prop = value.getProperty(runtime, "addressModeU");
+        result->addressModeU =
+            JSIConverter<std::optional<wgpu::AddressMode>>::fromJSI(
+                runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "addressModeV")) {
+        auto prop = value.getProperty(runtime, "addressModeV");
+        result->addressModeV =
+            JSIConverter<std::optional<wgpu::AddressMode>>::fromJSI(
+                runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "addressModeW")) {
+        auto prop = value.getProperty(runtime, "addressModeW");
+        result->addressModeW =
+            JSIConverter<std::optional<wgpu::AddressMode>>::fromJSI(
+                runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "magFilter")) {
+        auto prop = value.getProperty(runtime, "magFilter");
+        result->magFilter =
+            JSIConverter<std::optional<wgpu::FilterMode>>::fromJSI(runtime,
+                                                                   prop, false);
+      }
+      if (value.hasProperty(runtime, "minFilter")) {
+        auto prop = value.getProperty(runtime, "minFilter");
+        result->minFilter =
+            JSIConverter<std::optional<wgpu::FilterMode>>::fromJSI(runtime,
+                                                                   prop, false);
+      }
+      if (value.hasProperty(runtime, "mipmapFilter")) {
+        auto prop = value.getProperty(runtime, "mipmapFilter");
+        result->mipmapFilter =
+            JSIConverter<std::optional<wgpu::MipmapFilterMode>>::fromJSI(
+                runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "lodMinClamp")) {
+        auto prop = value.getProperty(runtime, "lodMinClamp");
+        result->lodMinClamp =
+            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "lodMaxClamp")) {
+        auto prop = value.getProperty(runtime, "lodMaxClamp");
+        result->lodMaxClamp =
+            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
+      }
+      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, "maxAnisotropy")) {
+        auto prop = value.getProperty(runtime, "maxAnisotropy");
+        result->maxAnisotropy =
+            JSIConverter<std::optional<double>>::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::GPUSamplerDescriptor> arg) {
+    throw std::runtime_error("Invalid GPUSamplerDescriptor::toJSI()");
+  }
+};
+
+} // namespace rnwgpu

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

@@ -0,0 +1,61 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "JSIConverter.h"
+#include "WGPULogger.h"
+
+#include "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

@@ -0,0 +1,63 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "JSIConverter.h"
+#include "WGPULogger.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

@@ -0,0 +1,25 @@
+#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/GPUStencilFaceState.h

@@ -0,0 +1,65 @@
+#pragma once
+
+#include <memory>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "JSIConverter.h"
+#include "WGPULogger.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

@@ -0,0 +1,60 @@
+#pragma once
+
+#include <memory>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "JSIConverter.h"
+#include "WGPULogger.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

@@ -0,0 +1,60 @@
+#pragma once
+
+#include <memory>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "JSIConverter.h"
+#include "WGPULogger.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

@@ -0,0 +1,92 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "JSIConverter.h"
+#include "WGPULogger.h"
+
+#include "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

@@ -0,0 +1,29 @@
+#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

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

@@ -0,0 +1,92 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "JSIConverter.h"
+#include "WGPULogger.h"
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+struct GPUTextureViewDescriptor {
+  std::optional<wgpu::TextureFormat> format; // GPUTextureFormat
+  std::optional<wgpu::TextureViewDimension>
+      dimension;                             // GPUTextureViewDimension
+  std::optional<wgpu::TextureAspect> aspect; // GPUTextureAspect
+  std::optional<double> baseMipLevel;        // GPUIntegerCoordinate
+  std::optional<double> mipLevelCount;       // GPUIntegerCoordinate
+  std::optional<double> baseArrayLayer;      // GPUIntegerCoordinate
+  std::optional<double> arrayLayerCount;     // GPUIntegerCoordinate
+  std::optional<std::string> label;          // string
+};
+
+} // namespace rnwgpu
+
+namespace rnwgpu {
+
+template <>
+struct JSIConverter<std::shared_ptr<rnwgpu::GPUTextureViewDescriptor>> {
+  static std::shared_ptr<rnwgpu::GPUTextureViewDescriptor>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUTextureViewDescriptor>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "format")) {
+        auto prop = value.getProperty(runtime, "format");
+        result->format =
+            JSIConverter<std::optional<wgpu::TextureFormat>>::fromJSI(
+                runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "dimension")) {
+        auto prop = value.getProperty(runtime, "dimension");
+        result->dimension =
+            JSIConverter<std::optional<wgpu::TextureViewDimension>>::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);
+      }
+      if (value.hasProperty(runtime, "baseMipLevel")) {
+        auto prop = value.getProperty(runtime, "baseMipLevel");
+        result->baseMipLevel =
+            JSIConverter<std::optional<double>>::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, "baseArrayLayer")) {
+        auto prop = value.getProperty(runtime, "baseArrayLayer");
+        result->baseArrayLayer =
+            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "arrayLayerCount")) {
+        auto prop = value.getProperty(runtime, "arrayLayerCount");
+        result->arrayLayerCount =
+            JSIConverter<std::optional<double>>::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::GPUTextureViewDescriptor> arg) {
+    throw std::runtime_error("Invalid GPUTextureViewDescriptor::toJSI()");
+  }
+};
+
+} // namespace rnwgpu