react-native-wgpu 0.1.0 → 0.1.3

package/cpp/rnwgpu/api/GPUDevice.h

@@ -3,16 +3,47 @@
 #include <future>
 #include <memory>
 #include <string>
+#include <unordered_set>
+#include <variant>
 
 #include "Unions.h"
-#include <RNFHybridObject.h>
 
-#include "MutableBuffer.h"
+#include "RNFHybridObject.h"
+
+#include "AsyncRunner.h"
 
 #include "webgpu/webgpu_cpp.h"
 
+#include "GPUBindGroup.h"
+#include "GPUBindGroupDescriptor.h"
+#include "GPUBindGroupLayout.h"
+#include "GPUBindGroupLayoutDescriptor.h"
 #include "GPUBuffer.h"
 #include "GPUBufferDescriptor.h"
+#include "GPUCommandEncoder.h"
+#include "GPUCommandEncoderDescriptor.h"
+#include "GPUComputePipeline.h"
+#include "GPUComputePipelineDescriptor.h"
+#include "GPUDeviceLostInfo.h"
+#include "GPUError.h"
+#include "GPUExternalTexture.h"
+#include "GPUExternalTextureDescriptor.h"
+#include "GPUPipelineLayout.h"
+#include "GPUPipelineLayoutDescriptor.h"
+#include "GPUQuerySet.h"
+#include "GPUQuerySetDescriptor.h"
+#include "GPUQueue.h"
+#include "GPURenderBundleEncoder.h"
+#include "GPURenderBundleEncoderDescriptor.h"
+#include "GPURenderPipeline.h"
+#include "GPURenderPipelineDescriptor.h"
+#include "GPUSampler.h"
+#include "GPUSamplerDescriptor.h"
+#include "GPUShaderModule.h"
+#include "GPUShaderModuleDescriptor.h"
+#include "GPUSupportedLimits.h"
+#include "GPUTexture.h"
+#include "GPUTextureDescriptor.h"
 
 namespace rnwgpu {
 
@@ -20,26 +51,109 @@ namespace m = margelo;
 
 class GPUDevice : public m::HybridObject {
 public:
-  explicit GPUDevice(wgpu::Device instance, std::string label)
-      : HybridObject("GPUDevice"), _instance(instance), _label(label) {}
+  explicit GPUDevice(wgpu::Device instance, std::shared_ptr<AsyncRunner> async,
+                     std::string label)
+      : HybridObject("GPUDevice"), _instance(instance), _async(async),
+        _label(label) {
+    m_lostPromise =
+        std::make_shared<std::promise<std::shared_ptr<GPUDeviceLostInfo>>>();
+  }
 
 public:
   std::string getBrand() { return _name; }
 
+  void destroy();
   std::shared_ptr<GPUBuffer>
   createBuffer(std::shared_ptr<GPUBufferDescriptor> descriptor);
+  std::shared_ptr<GPUTexture>
+  createTexture(std::shared_ptr<GPUTextureDescriptor> descriptor);
+  std::shared_ptr<GPUSampler> createSampler(
+      std::optional<std::shared_ptr<GPUSamplerDescriptor>> descriptor);
+  std::shared_ptr<GPUExternalTexture> importExternalTexture(
+      std::shared_ptr<GPUExternalTextureDescriptor> descriptor);
+  std::shared_ptr<GPUBindGroupLayout> createBindGroupLayout(
+      std::shared_ptr<GPUBindGroupLayoutDescriptor> descriptor);
+  std::shared_ptr<GPUPipelineLayout>
+  createPipelineLayout(std::shared_ptr<GPUPipelineLayoutDescriptor> descriptor);
+  std::shared_ptr<GPUBindGroup>
+  createBindGroup(std::shared_ptr<GPUBindGroupDescriptor> descriptor);
+  std::shared_ptr<GPUShaderModule>
+  createShaderModule(std::shared_ptr<GPUShaderModuleDescriptor> descriptor);
+  std::shared_ptr<GPUComputePipeline> createComputePipeline(
+      std::shared_ptr<GPUComputePipelineDescriptor> descriptor);
+  std::shared_ptr<GPURenderPipeline>
+  createRenderPipeline(std::shared_ptr<GPURenderPipelineDescriptor> descriptor);
+  std::future<std::shared_ptr<GPUComputePipeline>> createComputePipelineAsync(
+      std::shared_ptr<GPUComputePipelineDescriptor> descriptor);
+  std::future<std::shared_ptr<GPURenderPipeline>> createRenderPipelineAsync(
+      std::shared_ptr<GPURenderPipelineDescriptor> descriptor);
+  std::shared_ptr<GPUCommandEncoder> createCommandEncoder(
+      std::optional<std::shared_ptr<GPUCommandEncoderDescriptor>> descriptor);
+  std::shared_ptr<GPURenderBundleEncoder> createRenderBundleEncoder(
+      std::shared_ptr<GPURenderBundleEncoderDescriptor> descriptor);
+  std::shared_ptr<GPUQuerySet>
+  createQuerySet(std::shared_ptr<GPUQuerySetDescriptor> descriptor);
+  void pushErrorScope(wgpu::ErrorFilter filter);
+  std::future<std::variant<std::nullptr_t, std::shared_ptr<GPUError>>>
+  popErrorScope();
+
+  std::unordered_set<std::string> getFeatures();
+  std::shared_ptr<GPUSupportedLimits> getLimits();
+  std::shared_ptr<GPUQueue> getQueue();
+  std::future<std::shared_ptr<GPUDeviceLostInfo>> getLost();
 
   std::string getLabel() { return _label; }
+  void setLabel(const std::string &label) {
+    _label = label;
+    _instance.SetLabel(_label.c_str());
+  }
 
   void loadHybridMethods() override {
     registerHybridGetter("__brand", &GPUDevice::getBrand, this);
+    registerHybridMethod("destroy", &GPUDevice::destroy, this);
     registerHybridMethod("createBuffer", &GPUDevice::createBuffer, this);
-
+    registerHybridMethod("createTexture", &GPUDevice::createTexture, this);
+    registerHybridMethod("createSampler", &GPUDevice::createSampler, this);
+    registerHybridMethod("importExternalTexture",
+                         &GPUDevice::importExternalTexture, this);
+    registerHybridMethod("createBindGroupLayout",
+                         &GPUDevice::createBindGroupLayout, this);
+    registerHybridMethod("createPipelineLayout",
+                         &GPUDevice::createPipelineLayout, this);
+    registerHybridMethod("createBindGroup", &GPUDevice::createBindGroup, this);
+    registerHybridMethod("createShaderModule", &GPUDevice::createShaderModule,
+                         this);
+    registerHybridMethod("createComputePipeline",
+                         &GPUDevice::createComputePipeline, this);
+    registerHybridMethod("createRenderPipeline",
+                         &GPUDevice::createRenderPipeline, this);
+    registerHybridMethod("createComputePipelineAsync",
+                         &GPUDevice::createComputePipelineAsync, this);
+    registerHybridMethod("createRenderPipelineAsync",
+                         &GPUDevice::createRenderPipelineAsync, this);
+    registerHybridMethod("createCommandEncoder",
+                         &GPUDevice::createCommandEncoder, this);
+    registerHybridMethod("createRenderBundleEncoder",
+                         &GPUDevice::createRenderBundleEncoder, this);
+    registerHybridMethod("createQuerySet", &GPUDevice::createQuerySet, this);
+    registerHybridMethod("pushErrorScope", &GPUDevice::pushErrorScope, this);
+    registerHybridMethod("popErrorScope", &GPUDevice::popErrorScope, this);
+    registerHybridGetter("features", &GPUDevice::getFeatures, this);
+    registerHybridGetter("limits", &GPUDevice::getLimits, this);
+    registerHybridGetter("queue", &GPUDevice::getQueue, this);
+    registerHybridGetter("lost", &GPUDevice::getLost, this);
     registerHybridGetter("label", &GPUDevice::getLabel, this);
+    registerHybridSetter("label", &GPUDevice::setLabel, this);
   }
 
+  inline const wgpu::Device get() { return _instance; }
+
 private:
   wgpu::Device _instance;
+  std::shared_ptr<AsyncRunner> _async;
   std::string _label;
+  std::shared_ptr<std::promise<std::shared_ptr<GPUDeviceLostInfo>>>
+      m_lostPromise;
 };
+
 } // namespace rnwgpu

package/cpp/rnwgpu/api/GPUDeviceLostInfo.cpp

@@ -0,0 +1,6 @@
+#include "GPUDeviceLostInfo.h"
+
+namespace rnwgpu {
+wgpu::DeviceLostReason getReason();
+std::string getMessage();
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUDeviceLostInfo.h

@@ -1,13 +1,12 @@
 #pragma once
 
-#include <future>
-#include <memory>
 #include <string>
 
 #include "Unions.h"
-#include <RNFHybridObject.h>
 
-#include "MutableBuffer.h"
+#include "RNFHybridObject.h"
+
+#include "AsyncRunner.h"
 
 #include "webgpu/webgpu_cpp.h"
 
@@ -17,17 +16,25 @@ namespace m = margelo;
 
 class GPUDeviceLostInfo : public m::HybridObject {
 public:
-  explicit GPUDeviceLostInfo(wgpu::DeviceLostInfo instance)
-      : HybridObject("GPUDeviceLostInfo"), _instance(instance) {}
+  explicit GPUDeviceLostInfo(wgpu::DeviceLostReason reason, std::string message)
+      : HybridObject("GPUDeviceLostInfo"), _reason(reason), _message(message) {}
 
 public:
   std::string getBrand() { return _name; }
 
+  wgpu::DeviceLostReason getReason() { return _reason; }
+  std::string getMessage() { return _message; }
+
   void loadHybridMethods() override {
     registerHybridGetter("__brand", &GPUDeviceLostInfo::getBrand, this);
+
+    registerHybridGetter("reason", &GPUDeviceLostInfo::getReason, this);
+    registerHybridGetter("message", &GPUDeviceLostInfo::getMessage, this);
   }
 
 private:
-  wgpu::DeviceLostInfo _instance;
+  wgpu::DeviceLostReason _reason;
+  std::string _message;
 };
+
 } // namespace rnwgpu

package/cpp/rnwgpu/api/GPUError.h

@@ -0,0 +1,42 @@
+#pragma once
+
+#include <memory>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "RNFEnumMapper.h"
+#include "RNFJSIConverter.h"
+
+namespace rnwgpu {
+
+class GPUError {
+
+public:
+  GPUError(wgpu::ErrorType aType, char const *aMessage)
+      : type(aType), message(aMessage) {}
+
+  wgpu::ErrorType type;
+  char const *message;
+};
+
+} // namespace rnwgpu
+
+namespace margelo {
+
+using namespace rnwgpu; // NOLINT(build/namespaces)
+
+template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUError>> {
+  static std::shared_ptr<rnwgpu::GPUBindGroupEntry>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    throw std::runtime_error("Invalid GPUBindGroupEntry::fromJSI()");
+  }
+  static jsi::Value toJSI(jsi::Runtime &runtime,
+                          std::shared_ptr<rnwgpu::GPUError> arg) {
+    jsi::Object result(runtime);
+    result.setProperty(runtime, "message",
+                       jsi::String::createFromUtf8(runtime, arg->message));
+    return result;
+  }
+};
+
+} // namespace margelo

package/cpp/rnwgpu/api/GPUExtent3D.h

@@ -0,0 +1,69 @@
+#pragma once
+
+#include <memory>
+
+#include "RNFJSIConverter.h"
+
+#include "webgpu/webgpu_cpp.h"
+
+namespace rnwgpu {
+
+struct GPUExtent3D {
+  double width;
+  double height = 1;
+  double depthOrArrayLayers = 1;
+};
+
+} // namespace rnwgpu
+
+namespace margelo {
+
+template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUExtent3D>> {
+  static std::shared_ptr<rnwgpu::GPUExtent3D>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUExtent3D>();
+    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->width = array.getValueAtIndex(runtime, 0).asNumber();
+        }
+        if (size > 1) {
+          result->height = array.getValueAtIndex(runtime, 1).asNumber();
+        }
+        if (size > 2) {
+          result->depthOrArrayLayers =
+              array.getValueAtIndex(runtime, 2).asNumber();
+        }
+      } else {
+        auto object = arg.getObject(runtime);
+        if (object.hasProperty(runtime, "width")) {
+          result->width = object.getProperty(runtime, "width").asNumber();
+        } else {
+          throw std::runtime_error("Property GPUTExtent3D::width is required");
+        }
+        if (object.hasProperty(runtime, "height")) {
+          result->height = object.getProperty(runtime, "height").asNumber();
+        }
+        if (object.hasProperty(runtime, "depthOrArrayLayers")) {
+          result->depthOrArrayLayers =
+              object.getProperty(runtime, "depthOrArrayLayers").asNumber();
+        }
+      }
+    } else {
+      throw std::runtime_error("Expected an object for GPUTExtent3D");
+    }
+    return result;
+  }
+  static jsi::Value toJSI(jsi::Runtime &runtime,
+                          std::shared_ptr<rnwgpu::GPUExtent3D> arg) {
+    // No conversions here
+    return jsi::Value::null();
+  }
+};
+} // namespace margelo

package/cpp/rnwgpu/api/GPUExternalTexture.h

@@ -1,13 +1,12 @@
 #pragma once
 
-#include <future>
-#include <memory>
 #include <string>
 
 #include "Unions.h"
-#include <RNFHybridObject.h>
 
-#include "MutableBuffer.h"
+#include "RNFHybridObject.h"
+
+#include "AsyncRunner.h"
 
 #include "webgpu/webgpu_cpp.h"
 
@@ -25,15 +24,23 @@ public:
   std::string getBrand() { return _name; }
 
   std::string getLabel() { return _label; }
+  void setLabel(const std::string &label) {
+    _label = label;
+    _instance.SetLabel(_label.c_str());
+  }
 
   void loadHybridMethods() override {
     registerHybridGetter("__brand", &GPUExternalTexture::getBrand, this);
 
     registerHybridGetter("label", &GPUExternalTexture::getLabel, this);
+    registerHybridSetter("label", &GPUExternalTexture::setLabel, this);
   }
 
+  inline const wgpu::ExternalTexture get() { return _instance; }
+
 private:
   wgpu::ExternalTexture _instance;
   std::string _label;
 };
+
 } // namespace rnwgpu

package/cpp/rnwgpu/api/GPUFeatures.h

@@ -0,0 +1,221 @@
+#pragma once
+
+#include <string>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "WGPULogger.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::SubgroupsF16:
+    *outUnion = "subgroups-f16";
+    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::SurfaceCapabilities:
+    *outUnion = "surface-capabilities";
+    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::ChromiumExperimentalSubgroups:
+    *outUnion = "chromium-experimental-subgroups";
+    break;
+  case wgpu::FeatureName::ChromiumExperimentalSubgroupUniformControlFlow:
+    *outUnion = "chromium-experimental-subgroup-uniform-control-flow";
+    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::Snorm16TextureFormats:
+    *outUnion = "snorm16-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::R8UnormStorage:
+    *outUnion = "r8unorm-storage";
+    break;
+  case wgpu::FeatureName::FormatCapabilities:
+    *outUnion = "format-capabilities";
+    break;
+  case wgpu::FeatureName::DrmFormatCapabilities:
+    *outUnion = "drm-format-capabilities";
+    break;
+  case wgpu::FeatureName::Norm16TextureFormats:
+    *outUnion = "norm16-texture-formats";
+    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::SharedFenceVkSemaphoreSyncFD:
+    *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:
+    Logger::logToConsole("Unknown feature name %d", inEnum);
+    *outUnion = "";
+  }
+}
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUOrigin2D.h

@@ -0,0 +1,59 @@
+#pragma once
+
+#include <memory>
+
+#include "RNFJSIConverter.h"
+
+#include "webgpu/webgpu_cpp.h"
+
+namespace rnwgpu {
+
+struct GPUOrigin2D {
+  double x = 0;
+  double y = 0;
+};
+
+} // namespace rnwgpu
+
+namespace margelo {
+
+template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUOrigin2D>> {
+  static std::shared_ptr<rnwgpu::GPUOrigin2D>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::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<rnwgpu::GPUOrigin2D> arg) {
+    // No conversions here
+    return jsi::Value::null();
+  }
+};
+
+} // namespace margelo