react-native-wgpu 0.1.0 → 0.1.3

package/cpp/rnwgpu/api/GPUSupportedLimits.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"
 
@@ -23,11 +22,136 @@ public:
 public:
   std::string getBrand() { return _name; }
 
+  double getMaxTextureDimension1D();
+  double getMaxTextureDimension2D();
+  double getMaxTextureDimension3D();
+  double getMaxTextureArrayLayers();
+  double getMaxBindGroups();
+  double getMaxBindGroupsPlusVertexBuffers();
+  double getMaxBindingsPerBindGroup();
+  double getMaxDynamicUniformBuffersPerPipelineLayout();
+  double getMaxDynamicStorageBuffersPerPipelineLayout();
+  double getMaxSampledTexturesPerShaderStage();
+  double getMaxSamplersPerShaderStage();
+  double getMaxStorageBuffersPerShaderStage();
+  double getMaxStorageTexturesPerShaderStage();
+  double getMaxUniformBuffersPerShaderStage();
+  double getMaxUniformBufferBindingSize();
+  double getMaxStorageBufferBindingSize();
+  double getMinUniformBufferOffsetAlignment();
+  double getMinStorageBufferOffsetAlignment();
+  double getMaxVertexBuffers();
+  double getMaxBufferSize();
+  double getMaxVertexAttributes();
+  double getMaxVertexBufferArrayStride();
+  double getMaxInterStageShaderComponents();
+  double getMaxInterStageShaderVariables();
+  double getMaxColorAttachments();
+  double getMaxColorAttachmentBytesPerSample();
+  double getMaxComputeWorkgroupStorageSize();
+  double getMaxComputeInvocationsPerWorkgroup();
+  double getMaxComputeWorkgroupSizeX();
+  double getMaxComputeWorkgroupSizeY();
+  double getMaxComputeWorkgroupSizeZ();
+  double getMaxComputeWorkgroupsPerDimension();
+
   void loadHybridMethods() override {
     registerHybridGetter("__brand", &GPUSupportedLimits::getBrand, this);
+
+    registerHybridGetter("maxTextureDimension1D",
+                         &GPUSupportedLimits::getMaxTextureDimension1D, this);
+    registerHybridGetter("maxTextureDimension2D",
+                         &GPUSupportedLimits::getMaxTextureDimension2D, this);
+    registerHybridGetter("maxTextureDimension3D",
+                         &GPUSupportedLimits::getMaxTextureDimension3D, this);
+    registerHybridGetter("maxTextureArrayLayers",
+                         &GPUSupportedLimits::getMaxTextureArrayLayers, this);
+    registerHybridGetter("maxBindGroups", &GPUSupportedLimits::getMaxBindGroups,
+                         this);
+    registerHybridGetter("maxBindGroupsPlusVertexBuffers",
+                         &GPUSupportedLimits::getMaxBindGroupsPlusVertexBuffers,
+                         this);
+    registerHybridGetter("maxBindingsPerBindGroup",
+                         &GPUSupportedLimits::getMaxBindingsPerBindGroup, this);
+    registerHybridGetter(
+        "maxDynamicUniformBuffersPerPipelineLayout",
+        &GPUSupportedLimits::getMaxDynamicUniformBuffersPerPipelineLayout,
+        this);
+    registerHybridGetter(
+        "maxDynamicStorageBuffersPerPipelineLayout",
+        &GPUSupportedLimits::getMaxDynamicStorageBuffersPerPipelineLayout,
+        this);
+    registerHybridGetter(
+        "maxSampledTexturesPerShaderStage",
+        &GPUSupportedLimits::getMaxSampledTexturesPerShaderStage, this);
+    registerHybridGetter("maxSamplersPerShaderStage",
+                         &GPUSupportedLimits::getMaxSamplersPerShaderStage,
+                         this);
+    registerHybridGetter(
+        "maxStorageBuffersPerShaderStage",
+        &GPUSupportedLimits::getMaxStorageBuffersPerShaderStage, this);
+    registerHybridGetter(
+        "maxStorageTexturesPerShaderStage",
+        &GPUSupportedLimits::getMaxStorageTexturesPerShaderStage, this);
+    registerHybridGetter(
+        "maxUniformBuffersPerShaderStage",
+        &GPUSupportedLimits::getMaxUniformBuffersPerShaderStage, this);
+    registerHybridGetter("maxUniformBufferBindingSize",
+                         &GPUSupportedLimits::getMaxUniformBufferBindingSize,
+                         this);
+    registerHybridGetter("maxStorageBufferBindingSize",
+                         &GPUSupportedLimits::getMaxStorageBufferBindingSize,
+                         this);
+    registerHybridGetter(
+        "minUniformBufferOffsetAlignment",
+        &GPUSupportedLimits::getMinUniformBufferOffsetAlignment, this);
+    registerHybridGetter(
+        "minStorageBufferOffsetAlignment",
+        &GPUSupportedLimits::getMinStorageBufferOffsetAlignment, this);
+    registerHybridGetter("maxVertexBuffers",
+                         &GPUSupportedLimits::getMaxVertexBuffers, this);
+    registerHybridGetter("maxBufferSize", &GPUSupportedLimits::getMaxBufferSize,
+                         this);
+    registerHybridGetter("maxVertexAttributes",
+                         &GPUSupportedLimits::getMaxVertexAttributes, this);
+    registerHybridGetter("maxVertexBufferArrayStride",
+                         &GPUSupportedLimits::getMaxVertexBufferArrayStride,
+                         this);
+    registerHybridGetter("maxInterStageShaderComponents",
+                         &GPUSupportedLimits::getMaxInterStageShaderComponents,
+                         this);
+    registerHybridGetter("maxInterStageShaderVariables",
+                         &GPUSupportedLimits::getMaxInterStageShaderVariables,
+                         this);
+    registerHybridGetter("maxColorAttachments",
+                         &GPUSupportedLimits::getMaxColorAttachments, this);
+    registerHybridGetter(
+        "maxColorAttachmentBytesPerSample",
+        &GPUSupportedLimits::getMaxColorAttachmentBytesPerSample, this);
+    registerHybridGetter("maxComputeWorkgroupStorageSize",
+                         &GPUSupportedLimits::getMaxComputeWorkgroupStorageSize,
+                         this);
+    registerHybridGetter(
+        "maxComputeInvocationsPerWorkgroup",
+        &GPUSupportedLimits::getMaxComputeInvocationsPerWorkgroup, this);
+    registerHybridGetter("maxComputeWorkgroupSizeX",
+                         &GPUSupportedLimits::getMaxComputeWorkgroupSizeX,
+                         this);
+    registerHybridGetter("maxComputeWorkgroupSizeY",
+                         &GPUSupportedLimits::getMaxComputeWorkgroupSizeY,
+                         this);
+    registerHybridGetter("maxComputeWorkgroupSizeZ",
+                         &GPUSupportedLimits::getMaxComputeWorkgroupSizeZ,
+                         this);
+    registerHybridGetter(
+        "maxComputeWorkgroupsPerDimension",
+        &GPUSupportedLimits::getMaxComputeWorkgroupsPerDimension, this);
   }
 
+  inline const wgpu::SupportedLimits get() { return _instance; }
+
 private:
   wgpu::SupportedLimits _instance;
 };
+
 } // namespace rnwgpu

package/cpp/rnwgpu/api/GPUTexture.cpp

@@ -0,0 +1,47 @@
+#include "GPUTexture.h"
+
+#include <memory>
+
+#include "Convertors.h"
+
+namespace rnwgpu {
+
+void GPUTexture::destroy() { _instance.Destroy(); }
+
+std::shared_ptr<GPUTextureView> GPUTexture::createView(
+    std::optional<std::shared_ptr<GPUTextureViewDescriptor>> descriptor) {
+  wgpu::TextureViewDescriptor desc;
+  Convertor conv;
+  if (!conv(desc, descriptor)) {
+    throw std::runtime_error("GPUTextureView.createView(): couldn't access "
+                             "GPUTextureViewDescriptor");
+  }
+  auto view = _instance.CreateView(&desc);
+  return std::make_shared<GPUTextureView>(
+      view,
+      descriptor.has_value() ? descriptor.value()->label.value_or("") : "");
+}
+
+uint32_t GPUTexture::getWidth() { return _instance.GetWidth(); }
+
+uint32_t GPUTexture::getHeight() { return _instance.GetHeight(); }
+
+uint32_t GPUTexture::getDepthOrArrayLayers() {
+  return _instance.GetDepthOrArrayLayers();
+}
+
+uint32_t GPUTexture::getMipLevelCount() { return _instance.GetMipLevelCount(); }
+
+uint32_t GPUTexture::getSampleCount() { return _instance.GetSampleCount(); }
+
+wgpu::TextureDimension GPUTexture::getDimension() {
+  return _instance.GetDimension();
+}
+
+wgpu::TextureFormat GPUTexture::getFormat() { return _instance.GetFormat(); }
+
+double GPUTexture::getUsage() {
+  return static_cast<double>(_instance.GetUsage());
+}
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUTexture.h

@@ -1,16 +1,19 @@
 #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"
 
+#include "GPUTextureView.h"
+#include "GPUTextureViewDescriptor.h"
+
 namespace rnwgpu {
 
 namespace m = margelo;
@@ -23,16 +26,47 @@ public:
 public:
   std::string getBrand() { return _name; }
 
+  std::shared_ptr<GPUTextureView> createView(
+      std::optional<std::shared_ptr<GPUTextureViewDescriptor>> descriptor);
+  void destroy();
+
+  uint32_t getWidth();
+  uint32_t getHeight();
+  uint32_t getDepthOrArrayLayers();
+  uint32_t getMipLevelCount();
+  uint32_t getSampleCount();
+  wgpu::TextureDimension getDimension();
+  wgpu::TextureFormat getFormat();
+  double getUsage();
+
   std::string getLabel() { return _label; }
+  void setLabel(const std::string &label) {
+    _label = label;
+    _instance.SetLabel(_label.c_str());
+  }
 
   void loadHybridMethods() override {
     registerHybridGetter("__brand", &GPUTexture::getBrand, this);
-
+    registerHybridMethod("createView", &GPUTexture::createView, this);
+    registerHybridMethod("destroy", &GPUTexture::destroy, this);
+    registerHybridGetter("width", &GPUTexture::getWidth, this);
+    registerHybridGetter("height", &GPUTexture::getHeight, this);
+    registerHybridGetter("depthOrArrayLayers",
+                         &GPUTexture::getDepthOrArrayLayers, this);
+    registerHybridGetter("mipLevelCount", &GPUTexture::getMipLevelCount, this);
+    registerHybridGetter("sampleCount", &GPUTexture::getSampleCount, this);
+    registerHybridGetter("dimension", &GPUTexture::getDimension, this);
+    registerHybridGetter("format", &GPUTexture::getFormat, this);
+    registerHybridGetter("usage", &GPUTexture::getUsage, this);
     registerHybridGetter("label", &GPUTexture::getLabel, this);
+    registerHybridSetter("label", &GPUTexture::setLabel, this);
   }
 
+  inline const wgpu::Texture get() { return _instance; }
+
 private:
   wgpu::Texture _instance;
   std::string _label;
 };
+
 } // namespace rnwgpu

package/cpp/rnwgpu/api/GPUTextureView.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"
 
@@ -24,15 +23,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", &GPUTextureView::getBrand, this);
 
     registerHybridGetter("label", &GPUTextureView::getLabel, this);
+    registerHybridSetter("label", &GPUTextureView::setLabel, this);
   }
 
+  inline const wgpu::TextureView get() { return _instance; }
+
 private:
   wgpu::TextureView _instance;
   std::string _label;
 };
+
 } // namespace rnwgpu

package/cpp/rnwgpu/api/ImageBitmap.h

@@ -0,0 +1,34 @@
+#pragma once
+
+#include <memory>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "PlatformContext.h"
+#include "RNFHybridObject.h"
+
+namespace rnwgpu {
+
+class ImageBitmap : public margelo::HybridObject {
+public:
+  explicit ImageBitmap(ImageData &imageData)
+      : HybridObject("ImageBitmap"), _imageData(imageData) {}
+
+  size_t getWidth() { return _imageData.width; }
+
+  size_t getHeight() { return _imageData.height; }
+
+  void *getData() { return _imageData.data.data(); }
+
+  size_t getSize() { return _imageData.data.size(); }
+
+  void loadHybridMethods() override {
+    registerHybridGetter("width", &ImageBitmap::getWidth, this);
+    registerHybridGetter("height", &ImageBitmap::getHeight, this);
+  }
+
+private:
+  ImageData _imageData;
+};
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/RNWebGPU.h

@@ -0,0 +1,100 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "GPU.h"
+#include "GPUCanvasContext.h"
+#include "ImageBitmap.h"
+#include "PlatformContext.h"
+
+namespace rnwgpu {
+
+namespace m = margelo;
+
+struct Blob {
+  std::string blobId;
+  double size;
+  double offset;
+  std::string type;
+  std::string name;
+};
+
+class RNWebGPU : public m::HybridObject {
+public:
+  explicit RNWebGPU(std::shared_ptr<GPU> gpu,
+                    std::shared_ptr<PlatformContext> platformContext)
+      : HybridObject("RNWebGPU"), _gpu(gpu), _platformContext(platformContext) {
+  }
+
+  std::shared_ptr<GPU> getGPU() { return _gpu; }
+
+  std::shared_ptr<GPUCanvasContext>
+  MakeWebGPUCanvasContext(std::shared_ptr<Canvas> canvas) {
+    auto nativeSurface = canvas->getSurface();
+    auto width = canvas->getWidth();
+    auto height = canvas->getHeight();
+    auto surface = _platformContext->makeSurface(
+        _gpu->get(), reinterpret_cast<void *>(nativeSurface), width, height);
+    if (surface == nullptr) {
+      throw std::runtime_error("null surface");
+    }
+    auto ctx = std::make_shared<GPUCanvasContext>(surface, canvas);
+    return ctx;
+  }
+
+  std::shared_ptr<ImageBitmap> createImageBitmap(std::shared_ptr<Blob> blob) {
+    auto imageData = _platformContext->createImageBitmap(
+        blob->blobId, blob->offset, blob->size);
+    auto imageBitmap = std::make_shared<ImageBitmap>(imageData);
+    return imageBitmap;
+  }
+
+  void loadHybridMethods() override {
+    registerHybridGetter("gpu", &RNWebGPU::getGPU, this);
+    registerHybridMethod("createImageBitmap", &RNWebGPU::createImageBitmap,
+                         this);
+    registerHybridMethod("MakeWebGPUCanvasContext",
+                         &RNWebGPU::MakeWebGPUCanvasContext, this);
+  }
+
+private:
+  std::shared_ptr<GPU> _gpu;
+  std::shared_ptr<PlatformContext> _platformContext;
+};
+
+} // namespace rnwgpu
+
+namespace margelo {
+
+template <> struct JSIConverter<std::shared_ptr<rnwgpu::Blob>> {
+  static std::shared_ptr<rnwgpu::Blob>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    if (!outOfBounds && arg.isObject()) {
+      auto result = std::make_unique<rnwgpu::Blob>();
+      auto val = arg.asObject(runtime);
+      if (val.hasProperty(runtime, "_data")) {
+        auto value = val.getPropertyAsObject(runtime, "_data");
+        result->blobId = JSIConverter<std::string>::fromJSI(
+            runtime, value.getProperty(runtime, "blobId"), false);
+        //        result->type = JSIConverter<std::string>::fromJSI(
+        //            runtime, value.getProperty(runtime, "type"), false);
+        //        result->name = JSIConverter<std::string>::fromJSI(
+        //            runtime, value.getProperty(runtime, "name"), false);
+        result->size = JSIConverter<double>::fromJSI(
+            runtime, value.getProperty(runtime, "size"), false);
+        result->offset = JSIConverter<double>::fromJSI(
+            runtime, value.getProperty(runtime, "offset"), false);
+      }
+      return result;
+    } else {
+      throw std::runtime_error("Invalid Blob::fromJSI()");
+    }
+  }
+  static jsi::Value toJSI(jsi::Runtime &runtime,
+                          std::shared_ptr<rnwgpu::Blob> arg) {
+    throw std::runtime_error("Invalid Blob::toJSI()");
+  }
+};
+
+} // namespace margelo

package/cpp/rnwgpu/api/WebGPUCanvasContextFactory.h

@@ -0,0 +1,59 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <utility>
+
+#include "Unions.h"
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "RNFHybridObject.h"
+
+#include "AsyncRunner.h"
+
+#include "GPUCanvasContext.h"
+
+#ifdef __APPLE__
+#include "WebGPUModule.h"
+#endif
+
+namespace rnwgpu {
+
+namespace m = margelo;
+
+class WebGPUCanvasContextFactory : public m::HybridObject {
+public:
+  GPUCanvasContextFactory() : HybridObject("GPUCanvasContextFactory") {}
+
+public:
+  std::shared_ptr<GPUCanvasContext> Make(uint64_t surface, int width,
+                                         int height) {
+#ifdef __APPLE__
+    wgpu::SurfaceDescriptorFromMetalLayer metalSurfaceDesc;
+    metalSurfaceDesc.layer = reinterpret_cast<void *>(surface);
+
+    wgpu::SurfaceDescriptor surfaceDescriptor;
+    surfaceDescriptor.nextInChain = &metalSurfaceDesc;
+
+    auto surfaceGpu = std::make_unique<wgpu::Surface>(
+        WebGPUModule::getManager()->getGPU()->get().CreateSurface(
+            &surfaceDescriptor));
+    const float scaleFactor = 1;
+    const float scaledWidth = width * scaleFactor;
+    const float scaledHeight = height * scaleFactor;
+
+    rnwgpu::SurfaceData surfaceData{scaledWidth, scaledHeight,
+                                    std::move(surfaceGpu)};
+#elif __ANDROID__
+    throw std::runtime_error("Not implemented");
+#endif
+    return std::make_shared<rnwgpu::GPUCanvasContext>(surfaceData);
+  }
+
+  void loadHybridMethods() override {
+    registerHybridGetter("Make", &GPUCanvasContextFactory::Make, this);
+  }
+};
+
+} // namespace rnwgpu

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

@@ -2,29 +2,35 @@
 
 #include <memory>
 #include <string>
+#include <vector>
 
 #include "webgpu/webgpu_cpp.h"
 
-#include "Logger.h"
 #include "RNFJSIConverter.h"
-#include <RNFHybridObject.h>
+#include "WGPULogger.h"
+
+#include "GPUBindGroupEntry.h"
+#include "GPUBindGroupLayout.h"
+#include "RNFHybridObject.h"
 
 namespace jsi = facebook::jsi;
+namespace m = margelo;
 
 namespace rnwgpu {
 
-class GPUBindGroupDescriptor {
-public:
-  wgpu::BindGroupDescriptor *getInstance() { return &_instance; }
-
-  wgpu::BindGroupDescriptor _instance;
-
-  std::string label;
+struct GPUBindGroupDescriptor {
+  std::shared_ptr<GPUBindGroupLayout> layout; // GPUBindGroupLayout
+  std::vector<std::shared_ptr<GPUBindGroupEntry>>
+      entries;                      // Iterable<GPUBindGroupEntry>
+  std::optional<std::string> label; // string
 };
+
 } // namespace rnwgpu
 
 namespace margelo {
 
+using namespace rnwgpu; // NOLINT(build/namespaces)
+
 template <>
 struct JSIConverter<std::shared_ptr<rnwgpu::GPUBindGroupDescriptor>> {
   static std::shared_ptr<rnwgpu::GPUBindGroupDescriptor>
@@ -33,49 +39,31 @@ struct JSIConverter<std::shared_ptr<rnwgpu::GPUBindGroupDescriptor>> {
     if (!outOfBounds && arg.isObject()) {
       auto value = arg.getObject(runtime);
       if (value.hasProperty(runtime, "layout")) {
-        auto layout = value.getProperty(runtime, "layout");
-
-        if (layout.isUndefined()) {
-          throw std::runtime_error(
-              "Property GPUBindGroupDescriptor::layout is required");
-        }
-      } else {
-        throw std::runtime_error(
-            "Property GPUBindGroupDescriptor::layout is not defined");
+        auto prop = value.getProperty(runtime, "layout");
+        result->layout =
+            JSIConverter<std::shared_ptr<GPUBindGroupLayout>>::fromJSI(
+                runtime, prop, false);
       }
       if (value.hasProperty(runtime, "entries")) {
-        auto entries = value.getProperty(runtime, "entries");
-
-        if (entries.isUndefined()) {
-          throw std::runtime_error(
-              "Property GPUBindGroupDescriptor::entries is required");
-        }
-      } else {
-        throw std::runtime_error(
-            "Property GPUBindGroupDescriptor::entries is not defined");
+        auto prop = value.getProperty(runtime, "entries");
+        result->entries = JSIConverter<
+            std::vector<std::shared_ptr<GPUBindGroupEntry>>>::fromJSI(runtime,
+                                                                      prop,
+                                                                      false);
       }
       if (value.hasProperty(runtime, "label")) {
-        auto label = value.getProperty(runtime, "label");
-
-        if (label.isString()) {
-          auto str = label.asString(runtime).utf8(runtime);
-          result->label = str;
-          result->_instance.label = result->label.c_str();
-        }
+        auto prop = value.getProperty(runtime, "label");
+        result->label = JSIConverter<std::optional<std::string>>::fromJSI(
+            runtime, prop, false);
       }
     }
-    rnwgpu::Logger::logToConsole("GPUBindGroupDescriptor::layout = %f",
-                                 result->_instance.layout);
-    rnwgpu::Logger::logToConsole("GPUBindGroupDescriptor::entries = %f",
-                                 result->_instance.entries);
-    rnwgpu::Logger::logToConsole("GPUBindGroupDescriptor::label = %f",
-                                 result->_instance.label);
+
     return result;
   }
   static jsi::Value toJSI(jsi::Runtime &runtime,
                           std::shared_ptr<rnwgpu::GPUBindGroupDescriptor> arg) {
-    // No conversions here
-    return jsi::Value::null();
+    throw std::runtime_error("Invalid GPUBindGroupDescriptor::toJSI()");
   }
 };
-} // namespace margelo
+
+} // namespace margelo