react-native-wgpu 0.1.0 → 0.1.2

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

@@ -1,30 +1,45 @@
 #pragma once
 
 #include <memory>
+#include <optional>
 #include <string>
+#include <variant>
 
 #include "webgpu/webgpu_cpp.h"
 
-#include "Logger.h"
+#include "Convertors.h"
+
+#include "RNFHybridObject.h"
 #include "RNFJSIConverter.h"
-#include <RNFHybridObject.h>
+#include "WGPULogger.h"
 
 namespace jsi = facebook::jsi;
+namespace m = margelo;
 
 namespace rnwgpu {
 
-class GPUExternalTextureDescriptor {
-public:
-  wgpu::ExternalTextureDescriptor *getInstance() { return &_instance; }
-
-  wgpu::ExternalTextureDescriptor _instance;
-
-  std::string label;
+struct GPUExternalTextureDescriptor {
+  // std::variant<std::shared_ptr<HTMLVideoElement>,
+  // std::shared_ptr<VideoFrame>>
+  //     source; // | HTMLVideoElement | VideoFrame
+  // std::optional<wgpu::DefinedColorSpace> colorSpace; // PredefinedColorSpace
+  std::optional<std::string> label; // string
 };
+
+static bool conv(wgpu::ExternalTextureDescriptor &out,
+                 const std::shared_ptr<GPUExternalTextureDescriptor> &in) {
+  // TODO: implement
+  // return conv(out.source, in->source) && conv(out.colorSpace, in->colorSpace)
+  // &&
+  // return conv(out.label, in->label);
+  return false;
+}
 } // namespace rnwgpu
 
 namespace margelo {
 
+using namespace rnwgpu; // NOLINT(build/namespaces)
+
 template <>
 struct JSIConverter<std::shared_ptr<rnwgpu::GPUExternalTextureDescriptor>> {
   static std::shared_ptr<rnwgpu::GPUExternalTextureDescriptor>
@@ -33,43 +48,37 @@ struct JSIConverter<std::shared_ptr<rnwgpu::GPUExternalTextureDescriptor>> {
     if (!outOfBounds && arg.isObject()) {
       auto value = arg.getObject(runtime);
       if (value.hasProperty(runtime, "source")) {
-        auto source = value.getProperty(runtime, "source");
-
-        if (source.isUndefined()) {
-          throw std::runtime_error(
-              "Property GPUExternalTextureDescriptor::source is required");
-        }
-      } else {
-        throw std::runtime_error(
-            "Property GPUExternalTextureDescriptor::source is not defined");
+        auto prop = value.getProperty(runtime, "source");
+        // result->source = JSIConverter<
+        //     std::variant<std::shared_ptr<HTMLVideoElement>,
+        //                  std::shared_ptr<VideoFrame>>>::fromJSI(runtime,
+        //                  prop,
+        //                                                         false);
       }
       if (value.hasProperty(runtime, "colorSpace")) {
-        auto colorSpace = value.getProperty(runtime, "colorSpace");
+        auto prop = value.getProperty(runtime, "colorSpace");
+        if (!prop.isUndefined()) {
+          // result->colorSpace =
+          //     JSIConverter<std::optional<wgpu::definedColorSpace>>::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");
+        if (!prop.isUndefined()) {
+          result->label = JSIConverter<std::optional<std::string>>::fromJSI(
+              runtime, prop, false);
         }
       }
     }
-    rnwgpu::Logger::logToConsole("GPUExternalTextureDescriptor::source = %f",
-                                 result->_instance.source);
-    rnwgpu::Logger::logToConsole(
-        "GPUExternalTextureDescriptor::colorSpace = %f",
-        result->_instance.colorSpace);
-    rnwgpu::Logger::logToConsole("GPUExternalTextureDescriptor::label = %f",
-                                 result->_instance.label);
+
     return result;
   }
   static jsi::Value
   toJSI(jsi::Runtime &runtime,
         std::shared_ptr<rnwgpu::GPUExternalTextureDescriptor> arg) {
-    // No conversions here
-    return jsi::Value::null();
+    throw std::runtime_error("Invalid GPUExternalTextureDescriptor::toJSI()");
   }
 };
+
 } // namespace margelo

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

@@ -1,30 +1,41 @@
 #pragma once
 
+#include <map>
 #include <memory>
 #include <string>
+#include <variant>
+#include <vector>
 
 #include "webgpu/webgpu_cpp.h"
 
-#include "Logger.h"
 #include "RNFJSIConverter.h"
-#include <RNFHybridObject.h>
+#include "WGPULogger.h"
+
+#include "GPUColorTargetState.h"
+#include "GPUShaderModule.h"
+#include "RNFHybridObject.h"
 
 namespace jsi = facebook::jsi;
+namespace m = margelo;
 
 namespace rnwgpu {
 
-class GPUFragmentState {
-public:
-  wgpu::FragmentState *getInstance() { return &_instance; }
-
-  wgpu::FragmentState _instance;
-
-  std::string entryPoint;
+struct GPUFragmentState {
+  std::vector<
+      std::variant<std::nullptr_t, std::shared_ptr<GPUColorTargetState>>>
+      targets; // Iterable<GPUColorTargetState | null>
+  std::shared_ptr<GPUShaderModule> module; // GPUShaderModule
+  std::optional<std::string> entryPoint;   // string
+  std::optional<std::map<std::string, double>>
+      constants; // Record< string, GPUPipelineConstantValue >
 };
+
 } // namespace rnwgpu
 
 namespace margelo {
 
+using namespace rnwgpu; // NOLINT(build/namespaces)
+
 template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUFragmentState>> {
   static std::shared_ptr<rnwgpu::GPUFragmentState>
   fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
@@ -32,54 +43,36 @@ template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUFragmentState>> {
     if (!outOfBounds && arg.isObject()) {
       auto value = arg.getObject(runtime);
       if (value.hasProperty(runtime, "targets")) {
-        auto targets = value.getProperty(runtime, "targets");
-
-        if (targets.isUndefined()) {
-          throw std::runtime_error(
-              "Property GPUFragmentState::targets is required");
-        }
-      } else {
-        throw std::runtime_error(
-            "Property GPUFragmentState::targets is not defined");
+        auto prop = value.getProperty(runtime, "targets");
+        result->targets = JSIConverter<std::vector<std::variant<
+            std::nullptr_t, std::shared_ptr<GPUColorTargetState>>>>::
+            fromJSI(runtime, prop, false);
       }
       if (value.hasProperty(runtime, "module")) {
-        auto module = value.getProperty(runtime, "module");
-
-        if (module.isUndefined()) {
-          throw std::runtime_error(
-              "Property GPUFragmentState::module is required");
-        }
-      } else {
-        throw std::runtime_error(
-            "Property GPUFragmentState::module is not defined");
+        auto prop = value.getProperty(runtime, "module");
+        result->module =
+            JSIConverter<std::shared_ptr<GPUShaderModule>>::fromJSI(
+                runtime, prop, false);
       }
       if (value.hasProperty(runtime, "entryPoint")) {
-        auto entryPoint = value.getProperty(runtime, "entryPoint");
-
-        if (entryPoint.isString()) {
-          auto str = entryPoint.asString(runtime).utf8(runtime);
-          result->entryPoint = str;
-          result->_instance.entryPoint = result->entryPoint.c_str();
-        }
+        auto prop = value.getProperty(runtime, "entryPoint");
+        result->entryPoint = JSIConverter<std::optional<std::string>>::fromJSI(
+            runtime, prop, false);
       }
       if (value.hasProperty(runtime, "constants")) {
-        auto constants = value.getProperty(runtime, "constants");
+        auto prop = value.getProperty(runtime, "constants");
+        result->constants =
+            JSIConverter<std::optional<std::map<std::string, double>>>::fromJSI(
+                runtime, prop, false);
       }
     }
-    rnwgpu::Logger::logToConsole("GPUFragmentState::targets = %f",
-                                 result->_instance.targets);
-    rnwgpu::Logger::logToConsole("GPUFragmentState::module = %f",
-                                 result->_instance.module);
-    rnwgpu::Logger::logToConsole("GPUFragmentState::entryPoint = %f",
-                                 result->_instance.entryPoint);
-    rnwgpu::Logger::logToConsole("GPUFragmentState::constants = %f",
-                                 result->_instance.constants);
+
     return result;
   }
   static jsi::Value toJSI(jsi::Runtime &runtime,
                           std::shared_ptr<rnwgpu::GPUFragmentState> arg) {
-    // No conversions here
-    return jsi::Value::null();
+    throw std::runtime_error("Invalid GPUFragmentState::toJSI()");
   }
 };
-} // namespace margelo
+
+} // namespace margelo

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

@@ -1,28 +1,33 @@
 #pragma once
 
 #include <memory>
-#include <string>
 
 #include "webgpu/webgpu_cpp.h"
 
-#include "Logger.h"
 #include "RNFJSIConverter.h"
-#include <RNFHybridObject.h>
+#include "WGPULogger.h"
+
+#include "GPUBuffer.h"
+#include "RNFHybridObject.h"
 
 namespace jsi = facebook::jsi;
+namespace m = margelo;
 
 namespace rnwgpu {
 
-class GPUImageCopyBuffer {
-public:
-  wgpu::ImageCopyBuffer *getInstance() { return &_instance; }
-
-  wgpu::ImageCopyBuffer _instance;
+struct GPUImageCopyBuffer {
+  std::shared_ptr<GPUBuffer> buffer;  // GPUBuffer
+  std::optional<double> offset;       // GPUSize64
+  std::optional<double> bytesPerRow;  // GPUSize32
+  std::optional<double> rowsPerImage; // GPUSize32
 };
+
 } // namespace rnwgpu
 
 namespace margelo {
 
+using namespace rnwgpu; // NOLINT(build/namespaces)
+
 template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUImageCopyBuffer>> {
   static std::shared_ptr<rnwgpu::GPUImageCopyBuffer>
   fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
@@ -30,54 +35,33 @@ template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUImageCopyBuffer>> {
     if (!outOfBounds && arg.isObject()) {
       auto value = arg.getObject(runtime);
       if (value.hasProperty(runtime, "buffer")) {
-        auto buffer = value.getProperty(runtime, "buffer");
-
-        if (buffer.isUndefined()) {
-          throw std::runtime_error(
-              "Property GPUImageCopyBuffer::buffer is required");
-        }
-      } else {
-        throw std::runtime_error(
-            "Property GPUImageCopyBuffer::buffer is not defined");
+        auto prop = value.getProperty(runtime, "buffer");
+        result->buffer = JSIConverter<std::shared_ptr<GPUBuffer>>::fromJSI(
+            runtime, prop, false);
       }
       if (value.hasProperty(runtime, "offset")) {
-        auto offset = value.getProperty(runtime, "offset");
-
-        if (offset.isNumber()) {
-          result->_instance.offset = offset.getNumber();
-        }
+        auto prop = value.getProperty(runtime, "offset");
+        result->offset =
+            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
       }
       if (value.hasProperty(runtime, "bytesPerRow")) {
-        auto bytesPerRow = value.getProperty(runtime, "bytesPerRow");
-
-        if (bytesPerRow.isNumber()) {
-          result->_instance.bytesPerRow =
-              static_cast<wgpu::Size32>(bytesPerRow.getNumber());
-        }
+        auto prop = value.getProperty(runtime, "bytesPerRow");
+        result->bytesPerRow =
+            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
       }
       if (value.hasProperty(runtime, "rowsPerImage")) {
-        auto rowsPerImage = value.getProperty(runtime, "rowsPerImage");
-
-        if (rowsPerImage.isNumber()) {
-          result->_instance.rowsPerImage =
-              static_cast<wgpu::Size32>(rowsPerImage.getNumber());
-        }
+        auto prop = value.getProperty(runtime, "rowsPerImage");
+        result->rowsPerImage =
+            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
       }
     }
-    rnwgpu::Logger::logToConsole("GPUImageCopyBuffer::buffer = %f",
-                                 result->_instance.buffer);
-    rnwgpu::Logger::logToConsole("GPUImageCopyBuffer::offset = %f",
-                                 result->_instance.offset);
-    rnwgpu::Logger::logToConsole("GPUImageCopyBuffer::bytesPerRow = %f",
-                                 result->_instance.bytesPerRow);
-    rnwgpu::Logger::logToConsole("GPUImageCopyBuffer::rowsPerImage = %f",
-                                 result->_instance.rowsPerImage);
+
     return result;
   }
   static jsi::Value toJSI(jsi::Runtime &runtime,
                           std::shared_ptr<rnwgpu::GPUImageCopyBuffer> arg) {
-    // No conversions here
-    return jsi::Value::null();
+    throw std::runtime_error("Invalid GPUImageCopyBuffer::toJSI()");
   }
 };
-} // namespace margelo
+
+} // namespace margelo

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

@@ -1,66 +1,57 @@
 #pragma once
 
 #include <memory>
-#include <string>
+#include <optional>
+#include <variant>
+#include <vector>
 
 #include "webgpu/webgpu_cpp.h"
 
-#include "Logger.h"
+#include "Convertors.h"
+#include "RNFHybridObject.h"
 #include "RNFJSIConverter.h"
-#include <RNFHybridObject.h>
+
+#include "GPUOrigin2D.h"
+#include "ImageData.h"
 
 namespace jsi = facebook::jsi;
+namespace m = margelo;
 
 namespace rnwgpu {
 
-class GPUImageCopyExternalImage {
-public:
-  wgpu::ImageCopyExternalImage *getInstance() { return &_instance; }
-
-  wgpu::ImageCopyExternalImage _instance;
+struct GPUImageCopyExternalImage {
+  std::shared_ptr<ImageData> source; // GPUImageCopyExternalImageSource
+  std::optional<std::shared_ptr<GPUOrigin2D>> origin; // GPUOrigin2DStrict
+  std::optional<bool> flipY;                          // boolean
 };
+
 } // namespace rnwgpu
 
 namespace margelo {
 
+using namespace rnwgpu; // NOLINT(build/namespaces)
+
 template <>
 struct JSIConverter<std::shared_ptr<rnwgpu::GPUImageCopyExternalImage>> {
   static std::shared_ptr<rnwgpu::GPUImageCopyExternalImage>
   fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
     auto result = std::make_unique<rnwgpu::GPUImageCopyExternalImage>();
     if (!outOfBounds && arg.isObject()) {
-      auto value = arg.getObject(runtime);
-      if (value.hasProperty(runtime, "source")) {
-        auto source = value.getProperty(runtime, "source");
-
-        if (source.isUndefined()) {
-          throw std::runtime_error(
-              "Property GPUImageCopyExternalImage::source is required");
-        }
-      } else {
-        throw std::runtime_error(
-            "Property GPUImageCopyExternalImage::source is not defined");
-      }
-      if (value.hasProperty(runtime, "origin")) {
-        auto origin = value.getProperty(runtime, "origin");
-      }
-      if (value.hasProperty(runtime, "flipY")) {
-        auto flipY = value.getProperty(runtime, "flipY");
+      auto obj = arg.getObject(runtime);
+      if (obj.hasProperty(runtime, "source")) {
+        auto prop = obj.getProperty(runtime, "source");
+        result->source = JSIConverter<std::shared_ptr<ImageData>>::fromJSI(
+            runtime, prop, false);
       }
     }
-    rnwgpu::Logger::logToConsole("GPUImageCopyExternalImage::source = %f",
-                                 result->_instance.source);
-    rnwgpu::Logger::logToConsole("GPUImageCopyExternalImage::origin = %f",
-                                 result->_instance.origin);
-    rnwgpu::Logger::logToConsole("GPUImageCopyExternalImage::flipY = %f",
-                                 result->_instance.flipY);
+
     return result;
   }
   static jsi::Value
   toJSI(jsi::Runtime &runtime,
         std::shared_ptr<rnwgpu::GPUImageCopyExternalImage> arg) {
-    // No conversions here
-    return jsi::Value::null();
+    throw std::runtime_error("Invalid GPUImageCopyExternalImage::toJSI()");
   }
 };
-} // namespace margelo
+
+} // namespace margelo

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

@@ -1,28 +1,34 @@
 #pragma once
 
 #include <memory>
-#include <string>
 
 #include "webgpu/webgpu_cpp.h"
 
-#include "Logger.h"
 #include "RNFJSIConverter.h"
-#include <RNFHybridObject.h>
+#include "WGPULogger.h"
+
+#include "GPUOrigin3D.h"
+#include "GPUTexture.h"
+#include "RNFHybridObject.h"
 
 namespace jsi = facebook::jsi;
+namespace m = margelo;
 
 namespace rnwgpu {
 
-class GPUImageCopyTexture {
-public:
-  wgpu::ImageCopyTexture *getInstance() { return &_instance; }
-
-  wgpu::ImageCopyTexture _instance;
+struct GPUImageCopyTexture {
+  std::shared_ptr<GPUTexture> texture;                // GPUTexture
+  std::optional<double> mipLevel;                     // GPUIntegerCoordinate
+  std::optional<std::shared_ptr<GPUOrigin3D>> origin; // GPUOrigin3D
+  std::optional<wgpu::TextureAspect> aspect;          // GPUTextureAspect
 };
+
 } // namespace rnwgpu
 
 namespace margelo {
 
+using namespace rnwgpu; // NOLINT(build/namespaces)
+
 template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUImageCopyTexture>> {
   static std::shared_ptr<rnwgpu::GPUImageCopyTexture>
   fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
@@ -30,45 +36,35 @@ template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUImageCopyTexture>> {
     if (!outOfBounds && arg.isObject()) {
       auto value = arg.getObject(runtime);
       if (value.hasProperty(runtime, "texture")) {
-        auto texture = value.getProperty(runtime, "texture");
-
-        if (texture.isUndefined()) {
-          throw std::runtime_error(
-              "Property GPUImageCopyTexture::texture is required");
-        }
-      } else {
-        throw std::runtime_error(
-            "Property GPUImageCopyTexture::texture is not defined");
+        auto prop = value.getProperty(runtime, "texture");
+        result->texture = JSIConverter<std::shared_ptr<GPUTexture>>::fromJSI(
+            runtime, prop, false);
       }
       if (value.hasProperty(runtime, "mipLevel")) {
-        auto mipLevel = value.getProperty(runtime, "mipLevel");
-
-        if (mipLevel.isNumber()) {
-          result->_instance.mipLevel =
-              static_cast<wgpu::IntegerCoordinate>(mipLevel.getNumber());
-        }
+        auto prop = value.getProperty(runtime, "mipLevel");
+        result->mipLevel =
+            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
       }
       if (value.hasProperty(runtime, "origin")) {
-        auto origin = value.getProperty(runtime, "origin");
+        auto prop = value.getProperty(runtime, "origin");
+        result->origin =
+            JSIConverter<std::optional<std::shared_ptr<GPUOrigin3D>>>::fromJSI(
+                runtime, prop, false);
       }
       if (value.hasProperty(runtime, "aspect")) {
-        auto aspect = value.getProperty(runtime, "aspect");
+        auto prop = value.getProperty(runtime, "aspect");
+        result->aspect =
+            JSIConverter<std::optional<wgpu::TextureAspect>>::fromJSI(
+                runtime, prop, false);
       }
     }
-    rnwgpu::Logger::logToConsole("GPUImageCopyTexture::texture = %f",
-                                 result->_instance.texture);
-    rnwgpu::Logger::logToConsole("GPUImageCopyTexture::mipLevel = %f",
-                                 result->_instance.mipLevel);
-    rnwgpu::Logger::logToConsole("GPUImageCopyTexture::origin = %f",
-                                 result->_instance.origin);
-    rnwgpu::Logger::logToConsole("GPUImageCopyTexture::aspect = %f",
-                                 result->_instance.aspect);
+
     return result;
   }
   static jsi::Value toJSI(jsi::Runtime &runtime,
                           std::shared_ptr<rnwgpu::GPUImageCopyTexture> arg) {
-    // No conversions here
-    return jsi::Value::null();
+    throw std::runtime_error("Invalid GPUImageCopyTexture::toJSI()");
   }
 };
-} // namespace margelo
+
+} // namespace margelo