react-native-wgpu 0.1.0 → 0.1.3

package/cpp/rnwgpu/api/descriptors/GPUComputePassTimestampWrites.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 GPUComputePassTimestampWrites {
-public:
-  wgpu::ComputePassTimestampWrites *getInstance() { return &_instance; }
-
-  wgpu::ComputePassTimestampWrites _instance;
+struct GPUComputePassTimestampWrites {
+  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::GPUComputePassTimestampWrites>> {
   static std::shared_ptr<rnwgpu::GPUComputePassTimestampWrites>
@@ -31,50 +35,29 @@ struct JSIConverter<std::shared_ptr<rnwgpu::GPUComputePassTimestampWrites>> {
     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 GPUComputePassTimestampWrites::querySet is required");
-        }
-      } else {
-        throw std::runtime_error(
-            "Property GPUComputePassTimestampWrites::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("GPUComputePassTimestampWrites::querySet = %f",
-                                 result->_instance.querySet);
-    rnwgpu::Logger::logToConsole(
-        "GPUComputePassTimestampWrites::beginningOfPassWriteIndex = %f",
-        result->_instance.beginningOfPassWriteIndex);
-    rnwgpu::Logger::logToConsole(
-        "GPUComputePassTimestampWrites::endOfPassWriteIndex = %f",
-        result->_instance.endOfPassWriteIndex);
+
     return result;
   }
   static jsi::Value
   toJSI(jsi::Runtime &runtime,
         std::shared_ptr<rnwgpu::GPUComputePassTimestampWrites> arg) {
-    // No conversions here
-    return jsi::Value::null();
+    throw std::runtime_error("Invalid GPUComputePassTimestampWrites::toJSI()");
   }
 };
-} // namespace margelo
+
+} // namespace margelo

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

@@ -5,26 +5,31 @@
 
 #include "webgpu/webgpu_cpp.h"
 
-#include "Logger.h"
 #include "RNFJSIConverter.h"
-#include <RNFHybridObject.h>
+#include "WGPULogger.h"
+
+#include "GPUPipelineLayout.h"
+#include "GPUProgrammableStage.h"
+#include "RNFHybridObject.h"
 
 namespace jsi = facebook::jsi;
+namespace m = margelo;
 
 namespace rnwgpu {
 
-class GPUComputePipelineDescriptor {
-public:
-  wgpu::ComputePipelineDescriptor *getInstance() { return &_instance; }
-
-  wgpu::ComputePipelineDescriptor _instance;
-
-  std::string label;
+struct GPUComputePipelineDescriptor {
+  std::shared_ptr<GPUProgrammableStage> compute; // GPUProgrammableStage
+  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::GPUComputePipelineDescriptor>> {
   static std::shared_ptr<rnwgpu::GPUComputePipelineDescriptor>
@@ -33,50 +38,35 @@ struct JSIConverter<std::shared_ptr<rnwgpu::GPUComputePipelineDescriptor>> {
     if (!outOfBounds && arg.isObject()) {
       auto value = arg.getObject(runtime);
       if (value.hasProperty(runtime, "compute")) {
-        auto compute = value.getProperty(runtime, "compute");
-
-        if (compute.isUndefined()) {
-          throw std::runtime_error(
-              "Property GPUComputePipelineDescriptor::compute is required");
-        }
-      } else {
-        throw std::runtime_error(
-            "Property GPUComputePipelineDescriptor::compute is not defined");
+        auto prop = value.getProperty(runtime, "compute");
+        result->compute =
+            JSIConverter<std::shared_ptr<GPUProgrammableStage>>::fromJSI(
+                runtime, prop, false);
       }
       if (value.hasProperty(runtime, "layout")) {
-        auto layout = value.getProperty(runtime, "layout");
-
-        if (layout.isUndefined()) {
-          throw std::runtime_error(
-              "Property GPUComputePipelineDescriptor::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 GPUComputePipelineDescriptor::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("GPUComputePipelineDescriptor::compute = %f",
-                                 result->_instance.compute);
-    rnwgpu::Logger::logToConsole("GPUComputePipelineDescriptor::layout = %f",
-                                 result->_instance.layout);
-    rnwgpu::Logger::logToConsole("GPUComputePipelineDescriptor::label = %f",
-                                 result->_instance.label);
+
     return result;
   }
   static jsi::Value
   toJSI(jsi::Runtime &runtime,
         std::shared_ptr<rnwgpu::GPUComputePipelineDescriptor> arg) {
-    // No conversions here
-    return jsi::Value::null();
+    throw std::runtime_error("Invalid GPUComputePipelineDescriptor::toJSI()");
   }
 };
-} // namespace margelo
+
+} // namespace margelo

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

@@ -1,28 +1,41 @@
 #pragma once
 
 #include <memory>
-#include <string>
 
 #include "webgpu/webgpu_cpp.h"
 
-#include "Logger.h"
 #include "RNFJSIConverter.h"
-#include <RNFHybridObject.h>
+#include "WGPULogger.h"
+
+#include "GPUStencilFaceState.h"
+#include "RNFHybridObject.h"
 
 namespace jsi = facebook::jsi;
+namespace m = margelo;
 
 namespace rnwgpu {
 
-class GPUDepthStencilState {
-public:
-  wgpu::DepthStencilState *getInstance() { return &_instance; }
-
-  wgpu::DepthStencilState _instance;
+struct GPUDepthStencilState {
+  wgpu::TextureFormat format;                        // GPUTextureFormat
+  std::optional<bool> depthWriteEnabled;             // boolean
+  std::optional<wgpu::CompareFunction> depthCompare; // GPUCompareFunction
+  std::optional<std::shared_ptr<GPUStencilFaceState>>
+      stencilFront; // GPUStencilFaceState
+  std::optional<std::shared_ptr<GPUStencilFaceState>>
+      stencilBack;                           // GPUStencilFaceState
+  std::optional<double> stencilReadMask;     // GPUStencilValue
+  std::optional<double> stencilWriteMask;    // GPUStencilValue
+  std::optional<double> depthBias;           // GPUDepthBias
+  std::optional<double> depthBiasSlopeScale; // number
+  std::optional<double> depthBiasClamp;      // number
 };
+
 } // namespace rnwgpu
 
 namespace margelo {
 
+using namespace rnwgpu; // NOLINT(build/namespaces)
+
 template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUDepthStencilState>> {
   static std::shared_ptr<rnwgpu::GPUDepthStencilState>
   fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
@@ -30,97 +43,66 @@ template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUDepthStencilState>> {
     if (!outOfBounds && arg.isObject()) {
       auto value = arg.getObject(runtime);
       if (value.hasProperty(runtime, "format")) {
-        auto format = value.getProperty(runtime, "format");
-
-        if (format.isUndefined()) {
-          throw std::runtime_error(
-              "Property GPUDepthStencilState::format is required");
-        }
-      } else {
-        throw std::runtime_error(
-            "Property GPUDepthStencilState::format is not defined");
+        auto prop = value.getProperty(runtime, "format");
+        result->format =
+            JSIConverter<wgpu::TextureFormat>::fromJSI(runtime, prop, false);
       }
       if (value.hasProperty(runtime, "depthWriteEnabled")) {
-        auto depthWriteEnabled =
-            value.getProperty(runtime, "depthWriteEnabled");
+        auto prop = value.getProperty(runtime, "depthWriteEnabled");
+        result->depthWriteEnabled =
+            JSIConverter<std::optional<bool>>::fromJSI(runtime, prop, false);
       }
       if (value.hasProperty(runtime, "depthCompare")) {
-        auto depthCompare = value.getProperty(runtime, "depthCompare");
+        auto prop = value.getProperty(runtime, "depthCompare");
+        result->depthCompare =
+            JSIConverter<std::optional<wgpu::CompareFunction>>::fromJSI(
+                runtime, prop, false);
       }
       if (value.hasProperty(runtime, "stencilFront")) {
-        auto stencilFront = value.getProperty(runtime, "stencilFront");
+        auto prop = value.getProperty(runtime, "stencilFront");
+        result->stencilFront =
+            JSIConverter<std::optional<std::shared_ptr<GPUStencilFaceState>>>::
+                fromJSI(runtime, prop, false);
       }
       if (value.hasProperty(runtime, "stencilBack")) {
-        auto stencilBack = value.getProperty(runtime, "stencilBack");
+        auto prop = value.getProperty(runtime, "stencilBack");
+        result->stencilBack =
+            JSIConverter<std::optional<std::shared_ptr<GPUStencilFaceState>>>::
+                fromJSI(runtime, prop, false);
       }
       if (value.hasProperty(runtime, "stencilReadMask")) {
-        auto stencilReadMask = value.getProperty(runtime, "stencilReadMask");
-
-        if (stencilReadMask.isNumber()) {
-          result->_instance.stencilReadMask =
-              static_cast<wgpu::StencilValue>(stencilReadMask.getNumber());
-        }
+        auto prop = value.getProperty(runtime, "stencilReadMask");
+        result->stencilReadMask =
+            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
       }
       if (value.hasProperty(runtime, "stencilWriteMask")) {
-        auto stencilWriteMask = value.getProperty(runtime, "stencilWriteMask");
-
-        if (stencilWriteMask.isNumber()) {
-          result->_instance.stencilWriteMask =
-              static_cast<wgpu::StencilValue>(stencilWriteMask.getNumber());
-        }
+        auto prop = value.getProperty(runtime, "stencilWriteMask");
+        result->stencilWriteMask =
+            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
       }
       if (value.hasProperty(runtime, "depthBias")) {
-        auto depthBias = value.getProperty(runtime, "depthBias");
-
-        if (depthBias.isNumber()) {
-          result->_instance.depthBias =
-              static_cast<wgpu::DepthBias>(depthBias.getNumber());
-        }
+        auto prop = value.getProperty(runtime, "depthBias");
+        result->depthBias =
+            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
       }
       if (value.hasProperty(runtime, "depthBiasSlopeScale")) {
-        auto depthBiasSlopeScale =
-            value.getProperty(runtime, "depthBiasSlopeScale");
-
-        if (depthBiasSlopeScale.isNumber()) {
-          result->_instance.depthBiasSlopeScale =
-              depthBiasSlopeScale.getNumber();
-        }
+        auto prop = value.getProperty(runtime, "depthBiasSlopeScale");
+        result->depthBiasSlopeScale =
+            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
       }
       if (value.hasProperty(runtime, "depthBiasClamp")) {
-        auto depthBiasClamp = value.getProperty(runtime, "depthBiasClamp");
-
-        if (depthBiasClamp.isNumber()) {
-          result->_instance.depthBiasClamp = depthBiasClamp.getNumber();
-        }
+        auto prop = value.getProperty(runtime, "depthBiasClamp");
+        result->depthBiasClamp =
+            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
       }
     }
-    rnwgpu::Logger::logToConsole("GPUDepthStencilState::format = %f",
-                                 result->_instance.format);
-    rnwgpu::Logger::logToConsole("GPUDepthStencilState::depthWriteEnabled = %f",
-                                 result->_instance.depthWriteEnabled);
-    rnwgpu::Logger::logToConsole("GPUDepthStencilState::depthCompare = %f",
-                                 result->_instance.depthCompare);
-    rnwgpu::Logger::logToConsole("GPUDepthStencilState::stencilFront = %f",
-                                 result->_instance.stencilFront);
-    rnwgpu::Logger::logToConsole("GPUDepthStencilState::stencilBack = %f",
-                                 result->_instance.stencilBack);
-    rnwgpu::Logger::logToConsole("GPUDepthStencilState::stencilReadMask = %f",
-                                 result->_instance.stencilReadMask);
-    rnwgpu::Logger::logToConsole("GPUDepthStencilState::stencilWriteMask = %f",
-                                 result->_instance.stencilWriteMask);
-    rnwgpu::Logger::logToConsole("GPUDepthStencilState::depthBias = %f",
-                                 result->_instance.depthBias);
-    rnwgpu::Logger::logToConsole(
-        "GPUDepthStencilState::depthBiasSlopeScale = %f",
-        result->_instance.depthBiasSlopeScale);
-    rnwgpu::Logger::logToConsole("GPUDepthStencilState::depthBiasClamp = %f",
-                                 result->_instance.depthBiasClamp);
+
     return result;
   }
   static jsi::Value toJSI(jsi::Runtime &runtime,
                           std::shared_ptr<rnwgpu::GPUDepthStencilState> arg) {
-    // No conversions here
-    return jsi::Value::null();
+    throw std::runtime_error("Invalid GPUDepthStencilState::toJSI()");
   }
 };
-} // namespace margelo
+
+} // namespace margelo

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

@@ -1,30 +1,39 @@
 #pragma once
 
+#include <map>
 #include <memory>
 #include <string>
+#include <vector>
 
 #include "webgpu/webgpu_cpp.h"
 
-#include "Logger.h"
 #include "RNFJSIConverter.h"
-#include <RNFHybridObject.h>
+#include "WGPULogger.h"
+
+#include "GPUQueueDescriptor.h"
+#include "RNFHybridObject.h"
 
 namespace jsi = facebook::jsi;
+namespace m = margelo;
 
 namespace rnwgpu {
 
-class GPUDeviceDescriptor {
-public:
-  wgpu::DeviceDescriptor *getInstance() { return &_instance; }
-
-  wgpu::DeviceDescriptor _instance;
-
-  std::string label;
+struct GPUDeviceDescriptor {
+  std::optional<std::vector<wgpu::FeatureName>>
+      requiredFeatures; // Iterable<GPUFeatureName>
+  std::optional<std::map<std::string, double>>
+      requiredLimits; // Record< string, GPUSize64 >
+  std::optional<std::shared_ptr<GPUQueueDescriptor>>
+      defaultQueue;                 // GPUQueueDescriptor
+  std::optional<std::string> label; // string
 };
+
 } // namespace rnwgpu
 
 namespace margelo {
 
+using namespace rnwgpu; // NOLINT(build/namespaces)
+
 template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUDeviceDescriptor>> {
   static std::shared_ptr<rnwgpu::GPUDeviceDescriptor>
   fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
@@ -32,38 +41,37 @@ template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUDeviceDescriptor>> {
     if (!outOfBounds && arg.isObject()) {
       auto value = arg.getObject(runtime);
       if (value.hasProperty(runtime, "requiredFeatures")) {
-        auto requiredFeatures = value.getProperty(runtime, "requiredFeatures");
+        auto prop = value.getProperty(runtime, "requiredFeatures");
+        result->requiredFeatures = JSIConverter<
+            std::optional<std::vector<wgpu::FeatureName>>>::fromJSI(runtime,
+                                                                    prop,
+                                                                    false);
       }
       if (value.hasProperty(runtime, "requiredLimits")) {
-        auto requiredLimits = value.getProperty(runtime, "requiredLimits");
+        auto prop = value.getProperty(runtime, "requiredLimits");
+        result->requiredLimits =
+            JSIConverter<std::optional<std::map<std::string, double>>>::fromJSI(
+                runtime, prop, false);
       }
       if (value.hasProperty(runtime, "defaultQueue")) {
-        auto defaultQueue = value.getProperty(runtime, "defaultQueue");
+        auto prop = value.getProperty(runtime, "defaultQueue");
+        result->defaultQueue =
+            JSIConverter<std::optional<std::shared_ptr<GPUQueueDescriptor>>>::
+                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("GPUDeviceDescriptor::requiredFeatures = %f",
-                                 result->_instance.requiredFeatures);
-    rnwgpu::Logger::logToConsole("GPUDeviceDescriptor::requiredLimits = %f",
-                                 result->_instance.requiredLimits);
-    rnwgpu::Logger::logToConsole("GPUDeviceDescriptor::defaultQueue = %f",
-                                 result->_instance.defaultQueue);
-    rnwgpu::Logger::logToConsole("GPUDeviceDescriptor::label = %f",
-                                 result->_instance.label);
+
     return result;
   }
   static jsi::Value toJSI(jsi::Runtime &runtime,
                           std::shared_ptr<rnwgpu::GPUDeviceDescriptor> arg) {
-    // No conversions here
-    return jsi::Value::null();
+    throw std::runtime_error("Invalid GPUDeviceDescriptor::toJSI()");
   }
 };
-} // namespace margelo
+
+} // namespace margelo

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

@@ -1,28 +1,27 @@
 #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 GPUExternalTextureBindingLayout {
-public:
-  wgpu::ExternalTextureBindingLayout *getInstance() { return &_instance; }
+struct GPUExternalTextureBindingLayout {};
 
-  wgpu::ExternalTextureBindingLayout _instance;
-};
 } // namespace rnwgpu
 
 namespace margelo {
 
+using namespace rnwgpu; // NOLINT(build/namespaces)
+
 template <>
 struct JSIConverter<std::shared_ptr<rnwgpu::GPUExternalTextureBindingLayout>> {
   static std::shared_ptr<rnwgpu::GPUExternalTextureBindingLayout>
@@ -37,8 +36,9 @@ struct JSIConverter<std::shared_ptr<rnwgpu::GPUExternalTextureBindingLayout>> {
   static jsi::Value
   toJSI(jsi::Runtime &runtime,
         std::shared_ptr<rnwgpu::GPUExternalTextureBindingLayout> arg) {
-    // No conversions here
-    return jsi::Value::null();
+    throw std::runtime_error(
+        "Invalid GPUExternalTextureBindingLayout::toJSI()");
   }
 };
-} // namespace margelo
+
+} // namespace margelo