react-native-wgpu 0.1.0 → 0.1.3

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

@@ -2,29 +2,44 @@
 
 #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 "GPUQuerySet.h"
+#include "GPURenderPassColorAttachment.h"
+#include "GPURenderPassDepthStencilAttachment.h"
+#include "GPURenderPassTimestampWrites.h"
+#include "RNFHybridObject.h"
 
 namespace jsi = facebook::jsi;
+namespace m = margelo;
 
 namespace rnwgpu {
 
-class GPURenderPassDescriptor {
-public:
-  wgpu::RenderPassDescriptor *getInstance() { return &_instance; }
-
-  wgpu::RenderPassDescriptor _instance;
-
-  std::string label;
+struct GPURenderPassDescriptor {
+  std::vector<std::variant<std::nullptr_t,
+                           std::shared_ptr<GPURenderPassColorAttachment>>>
+      colorAttachments; // Iterable<GPURenderPassColorAttachment | null>
+  std::optional<std::shared_ptr<GPURenderPassDepthStencilAttachment>>
+      depthStencilAttachment; // GPURenderPassDepthStencilAttachment
+  std::optional<std::shared_ptr<GPUQuerySet>> occlusionQuerySet; // GPUQuerySet
+  std::optional<std::shared_ptr<GPURenderPassTimestampWrites>>
+      timestampWrites;                // GPURenderPassTimestampWrites
+  std::optional<double> maxDrawCount; // GPUSize64
+  std::optional<std::string> label;   // string
 };
+
 } // namespace rnwgpu
 
 namespace margelo {
 
+using namespace rnwgpu; // NOLINT(build/namespaces)
+
 template <>
 struct JSIConverter<std::shared_ptr<rnwgpu::GPURenderPassDescriptor>> {
   static std::shared_ptr<rnwgpu::GPURenderPassDescriptor>
@@ -33,68 +48,50 @@ struct JSIConverter<std::shared_ptr<rnwgpu::GPURenderPassDescriptor>> {
     if (!outOfBounds && arg.isObject()) {
       auto value = arg.getObject(runtime);
       if (value.hasProperty(runtime, "colorAttachments")) {
-        auto colorAttachments = value.getProperty(runtime, "colorAttachments");
-
-        if (colorAttachments.isUndefined()) {
-          throw std::runtime_error(
-              "Property GPURenderPassDescriptor::colorAttachments is required");
-        }
-      } else {
-        throw std::runtime_error(
-            "Property GPURenderPassDescriptor::colorAttachments is not "
-            "defined");
+        auto prop = value.getProperty(runtime, "colorAttachments");
+        result->colorAttachments = JSIConverter<std::vector<std::variant<
+            std::nullptr_t, std::shared_ptr<GPURenderPassColorAttachment>>>>::
+            fromJSI(runtime, prop, false);
       }
       if (value.hasProperty(runtime, "depthStencilAttachment")) {
-        auto depthStencilAttachment =
-            value.getProperty(runtime, "depthStencilAttachment");
+        auto prop = value.getProperty(runtime, "depthStencilAttachment");
+        result->depthStencilAttachment =
+            JSIConverter<std::optional<std::shared_ptr<
+                GPURenderPassDepthStencilAttachment>>>::fromJSI(runtime, prop,
+                                                                false);
       }
       if (value.hasProperty(runtime, "occlusionQuerySet")) {
-        auto occlusionQuerySet =
-            value.getProperty(runtime, "occlusionQuerySet");
+        auto prop = value.getProperty(runtime, "occlusionQuerySet");
+        result->occlusionQuerySet =
+            JSIConverter<std::optional<std::shared_ptr<GPUQuerySet>>>::fromJSI(
+                runtime, prop, false);
       }
       if (value.hasProperty(runtime, "timestampWrites")) {
-        auto timestampWrites = value.getProperty(runtime, "timestampWrites");
+        auto prop = value.getProperty(runtime, "timestampWrites");
+        result->timestampWrites = JSIConverter<std::optional<
+            std::shared_ptr<GPURenderPassTimestampWrites>>>::fromJSI(runtime,
+                                                                     prop,
+                                                                     false);
       }
       if (value.hasProperty(runtime, "maxDrawCount")) {
-        auto maxDrawCount = value.getProperty(runtime, "maxDrawCount");
-
-        if (maxDrawCount.isNumber()) {
-          result->_instance.maxDrawCount = maxDrawCount.getNumber();
-        }
+        auto prop = value.getProperty(runtime, "maxDrawCount");
+        result->maxDrawCount =
+            JSIConverter<std::optional<double>>::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(
-        "GPURenderPassDescriptor::colorAttachments = %f",
-        result->_instance.colorAttachments);
-    rnwgpu::Logger::logToConsole(
-        "GPURenderPassDescriptor::depthStencilAttachment = %f",
-        result->_instance.depthStencilAttachment);
-    rnwgpu::Logger::logToConsole(
-        "GPURenderPassDescriptor::occlusionQuerySet = %f",
-        result->_instance.occlusionQuerySet);
-    rnwgpu::Logger::logToConsole(
-        "GPURenderPassDescriptor::timestampWrites = %f",
-        result->_instance.timestampWrites);
-    rnwgpu::Logger::logToConsole("GPURenderPassDescriptor::maxDrawCount = %f",
-                                 result->_instance.maxDrawCount);
-    rnwgpu::Logger::logToConsole("GPURenderPassDescriptor::label = %f",
-                                 result->_instance.label);
+
     return result;
   }
   static jsi::Value
   toJSI(jsi::Runtime &runtime,
         std::shared_ptr<rnwgpu::GPURenderPassDescriptor> arg) {
-    // No conversions here
-    return jsi::Value::null();
+    throw std::runtime_error("Invalid GPURenderPassDescriptor::toJSI()");
   }
 };
-} // namespace margelo
+
+} // namespace margelo

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

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

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

@@ -5,26 +5,42 @@
 
 #include "webgpu/webgpu_cpp.h"
 
-#include "Logger.h"
 #include "RNFJSIConverter.h"
-#include <RNFHybridObject.h>
+#include "WGPULogger.h"
+
+#include "GPUDepthStencilState.h"
+#include "GPUFragmentState.h"
+#include "GPUMultisampleState.h"
+#include "GPUPipelineLayout.h"
+#include "GPUPrimitiveState.h"
+#include "GPUVertexState.h"
+#include "RNFHybridObject.h"
 
 namespace jsi = facebook::jsi;
+namespace m = margelo;
 
 namespace rnwgpu {
 
-class GPURenderPipelineDescriptor {
-public:
-  wgpu::RenderPipelineDescriptor *getInstance() { return &_instance; }
-
-  wgpu::RenderPipelineDescriptor _instance;
-
-  std::string label;
+struct GPURenderPipelineDescriptor {
+  std::shared_ptr<GPUVertexState> vertex; // GPUVertexState
+  std::optional<std::shared_ptr<GPUPrimitiveState>>
+      primitive; // GPUPrimitiveState
+  std::optional<std::shared_ptr<GPUDepthStencilState>>
+      depthStencil; // GPUDepthStencilState
+  std::optional<std::shared_ptr<GPUMultisampleState>>
+      multisample; // GPUMultisampleState
+  std::optional<std::shared_ptr<GPUFragmentState>> fragment; // GPUFragmentState
+  std::variant<std::nullptr_t, std::shared_ptr<GPUPipelineLayout>>
+      layout;                       // | GPUPipelineLayout | GPUAutoLayoutMode
+  std::optional<std::string> label; // string
 };
+
 } // namespace rnwgpu
 
 namespace margelo {
 
+using namespace rnwgpu; // NOLINT(build/namespaces)
+
 template <>
 struct JSIConverter<std::shared_ptr<rnwgpu::GPURenderPipelineDescriptor>> {
   static std::shared_ptr<rnwgpu::GPURenderPipelineDescriptor>
@@ -33,72 +49,60 @@ struct JSIConverter<std::shared_ptr<rnwgpu::GPURenderPipelineDescriptor>> {
     if (!outOfBounds && arg.isObject()) {
       auto value = arg.getObject(runtime);
       if (value.hasProperty(runtime, "vertex")) {
-        auto vertex = value.getProperty(runtime, "vertex");
-
-        if (vertex.isUndefined()) {
-          throw std::runtime_error(
-              "Property GPURenderPipelineDescriptor::vertex is required");
-        }
-      } else {
-        throw std::runtime_error(
-            "Property GPURenderPipelineDescriptor::vertex is not defined");
+        auto prop = value.getProperty(runtime, "vertex");
+        result->vertex = JSIConverter<std::shared_ptr<GPUVertexState>>::fromJSI(
+            runtime, prop, false);
       }
       if (value.hasProperty(runtime, "primitive")) {
-        auto primitive = value.getProperty(runtime, "primitive");
+        auto prop = value.getProperty(runtime, "primitive");
+        result->primitive = JSIConverter<
+            std::optional<std::shared_ptr<GPUPrimitiveState>>>::fromJSI(runtime,
+                                                                        prop,
+                                                                        false);
       }
       if (value.hasProperty(runtime, "depthStencil")) {
-        auto depthStencil = value.getProperty(runtime, "depthStencil");
+        auto prop = value.getProperty(runtime, "depthStencil");
+        result->depthStencil =
+            JSIConverter<std::optional<std::shared_ptr<GPUDepthStencilState>>>::
+                fromJSI(runtime, prop, false);
       }
       if (value.hasProperty(runtime, "multisample")) {
-        auto multisample = value.getProperty(runtime, "multisample");
+        auto prop = value.getProperty(runtime, "multisample");
+        result->multisample =
+            JSIConverter<std::optional<std::shared_ptr<GPUMultisampleState>>>::
+                fromJSI(runtime, prop, false);
       }
       if (value.hasProperty(runtime, "fragment")) {
-        auto fragment = value.getProperty(runtime, "fragment");
+        auto prop = value.getProperty(runtime, "fragment");
+        result->fragment = JSIConverter<
+            std::optional<std::shared_ptr<GPUFragmentState>>>::fromJSI(runtime,
+                                                                       prop,
+                                                                       false);
       }
       if (value.hasProperty(runtime, "layout")) {
-        auto layout = value.getProperty(runtime, "layout");
-
-        if (layout.isUndefined()) {
-          throw std::runtime_error(
-              "Property GPURenderPipelineDescriptor::layout is required");
+        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);
         }
-      } else {
-        throw std::runtime_error(
-            "Property GPURenderPipelineDescriptor::layout is not defined");
       }
       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("GPURenderPipelineDescriptor::vertex = %f",
-                                 result->_instance.vertex);
-    rnwgpu::Logger::logToConsole("GPURenderPipelineDescriptor::primitive = %f",
-                                 result->_instance.primitive);
-    rnwgpu::Logger::logToConsole(
-        "GPURenderPipelineDescriptor::depthStencil = %f",
-        result->_instance.depthStencil);
-    rnwgpu::Logger::logToConsole(
-        "GPURenderPipelineDescriptor::multisample = %f",
-        result->_instance.multisample);
-    rnwgpu::Logger::logToConsole("GPURenderPipelineDescriptor::fragment = %f",
-                                 result->_instance.fragment);
-    rnwgpu::Logger::logToConsole("GPURenderPipelineDescriptor::layout = %f",
-                                 result->_instance.layout);
-    rnwgpu::Logger::logToConsole("GPURenderPipelineDescriptor::label = %f",
-                                 result->_instance.label);
+
     return result;
   }
   static jsi::Value
   toJSI(jsi::Runtime &runtime,
         std::shared_ptr<rnwgpu::GPURenderPipelineDescriptor> arg) {
-    // No conversions here
-    return jsi::Value::null();
+    throw std::runtime_error("Invalid GPURenderPipelineDescriptor::toJSI()");
   }
 };
-} // namespace margelo
+
+} // namespace margelo

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

@@ -1,28 +1,30 @@
 #pragma once
 
 #include <memory>
-#include <string>
 
 #include "webgpu/webgpu_cpp.h"
 
-#include "Logger.h"
 #include "RNFJSIConverter.h"
-#include <RNFHybridObject.h>
+#include "WGPULogger.h"
+
+#include "RNFHybridObject.h"
 
 namespace jsi = facebook::jsi;
+namespace m = margelo;
 
 namespace rnwgpu {
 
-class GPURequestAdapterOptions {
-public:
-  wgpu::RequestAdapterOptions *getInstance() { return &_instance; }
-
-  wgpu::RequestAdapterOptions _instance;
+struct GPURequestAdapterOptions {
+  std::optional<wgpu::PowerPreference> powerPreference; // GPUPowerPreference
+  std::optional<bool> forceFallbackAdapter;             // boolean
 };
+
 } // namespace rnwgpu
 
 namespace margelo {
 
+using namespace rnwgpu; // NOLINT(build/namespaces)
+
 template <>
 struct JSIConverter<std::shared_ptr<rnwgpu::GPURequestAdapterOptions>> {
   static std::shared_ptr<rnwgpu::GPURequestAdapterOptions>
@@ -31,26 +33,25 @@ struct JSIConverter<std::shared_ptr<rnwgpu::GPURequestAdapterOptions>> {
     if (!outOfBounds && arg.isObject()) {
       auto value = arg.getObject(runtime);
       if (value.hasProperty(runtime, "powerPreference")) {
-        auto powerPreference = value.getProperty(runtime, "powerPreference");
+        auto prop = value.getProperty(runtime, "powerPreference");
+        result->powerPreference =
+            JSIConverter<std::optional<wgpu::PowerPreference>>::fromJSI(
+                runtime, prop, false);
       }
       if (value.hasProperty(runtime, "forceFallbackAdapter")) {
-        auto forceFallbackAdapter =
-            value.getProperty(runtime, "forceFallbackAdapter");
+        auto prop = value.getProperty(runtime, "forceFallbackAdapter");
+        result->forceFallbackAdapter =
+            JSIConverter<std::optional<bool>>::fromJSI(runtime, prop, false);
       }
     }
-    rnwgpu::Logger::logToConsole(
-        "GPURequestAdapterOptions::powerPreference = %f",
-        result->_instance.powerPreference);
-    rnwgpu::Logger::logToConsole(
-        "GPURequestAdapterOptions::forceFallbackAdapter = %f",
-        result->_instance.forceFallbackAdapter);
+
     return result;
   }
   static jsi::Value
   toJSI(jsi::Runtime &runtime,
         std::shared_ptr<rnwgpu::GPURequestAdapterOptions> arg) {
-    // No conversions here
-    return jsi::Value::null();
+    throw std::runtime_error("Invalid GPURequestAdapterOptions::toJSI()");
   }
 };
-} // namespace margelo
+
+} // namespace margelo

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

@@ -1,28 +1,29 @@
 #pragma once
 
 #include <memory>
-#include <string>
 
 #include "webgpu/webgpu_cpp.h"
 
-#include "Logger.h"
 #include "RNFJSIConverter.h"
-#include <RNFHybridObject.h>
+#include "WGPULogger.h"
+
+#include "RNFHybridObject.h"
 
 namespace jsi = facebook::jsi;
+namespace m = margelo;
 
 namespace rnwgpu {
 
-class GPUSamplerBindingLayout {
-public:
-  wgpu::SamplerBindingLayout *getInstance() { return &_instance; }
-
-  wgpu::SamplerBindingLayout _instance;
+struct GPUSamplerBindingLayout {
+  std::optional<wgpu::SamplerBindingType> type; // GPUSamplerBindingType
 };
+
 } // namespace rnwgpu
 
 namespace margelo {
 
+using namespace rnwgpu; // NOLINT(build/namespaces)
+
 template <>
 struct JSIConverter<std::shared_ptr<rnwgpu::GPUSamplerBindingLayout>> {
   static std::shared_ptr<rnwgpu::GPUSamplerBindingLayout>
@@ -31,18 +32,20 @@ struct JSIConverter<std::shared_ptr<rnwgpu::GPUSamplerBindingLayout>> {
     if (!outOfBounds && arg.isObject()) {
       auto value = arg.getObject(runtime);
       if (value.hasProperty(runtime, "type")) {
-        auto type = value.getProperty(runtime, "type");
+        auto prop = value.getProperty(runtime, "type");
+        result->type =
+            JSIConverter<std::optional<wgpu::SamplerBindingType>>::fromJSI(
+                runtime, prop, false);
       }
     }
-    rnwgpu::Logger::logToConsole("GPUSamplerBindingLayout::type = %f",
-                                 result->_instance.type);
+
     return result;
   }
   static jsi::Value
   toJSI(jsi::Runtime &runtime,
         std::shared_ptr<rnwgpu::GPUSamplerBindingLayout> arg) {
-    // No conversions here
-    return jsi::Value::null();
+    throw std::runtime_error("Invalid GPUSamplerBindingLayout::toJSI()");
   }
 };
-} // namespace margelo
+
+} // namespace margelo