react-native-wgpu 0.1.0 → 0.1.2

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

@@ -1,28 +1,37 @@
 #pragma once
 
 #include <memory>
-#include <string>
+#include <variant>
 
 #include "webgpu/webgpu_cpp.h"
 
-#include "Logger.h"
+#include "GPUBufferBinding.h"
+#include "GPUExternalTexture.h"
+#include "GPUSampler.h"
+#include "GPUTextureView.h"
+#include "RNFHybridObject.h"
 #include "RNFJSIConverter.h"
-#include <RNFHybridObject.h>
+#include "WGPULogger.h"
 
 namespace jsi = facebook::jsi;
+namespace m = margelo;
 
 namespace rnwgpu {
 
-class GPUBindGroupEntry {
-public:
-  wgpu::BindGroupEntry *getInstance() { return &_instance; }
-
-  wgpu::BindGroupEntry _instance;
+struct GPUBindGroupEntry {
+  double binding;
+  std::shared_ptr<GPUSampler> sampler = nullptr;
+  std::shared_ptr<GPUTextureView> textureView = nullptr;
+  std::shared_ptr<GPUBufferBinding> buffer = nullptr;
+  // external textures
 };
+
 } // namespace rnwgpu
 
 namespace margelo {
 
+using namespace rnwgpu; // NOLINT(build/namespaces)
+
 template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUBindGroupEntry>> {
   static std::shared_ptr<rnwgpu::GPUBindGroupEntry>
   fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
@@ -30,38 +39,38 @@ template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUBindGroupEntry>> {
     if (!outOfBounds && arg.isObject()) {
       auto value = arg.getObject(runtime);
       if (value.hasProperty(runtime, "binding")) {
-        auto binding = value.getProperty(runtime, "binding");
-
-        if (binding.isUndefined()) {
-          throw std::runtime_error(
-              "Property GPUBindGroupEntry::binding is required");
-        }
-      } else {
-        throw std::runtime_error(
-            "Property GPUBindGroupEntry::binding is not defined");
+        result->binding = value.getProperty(runtime, "binding").asNumber();
       }
       if (value.hasProperty(runtime, "resource")) {
-        auto resource = value.getProperty(runtime, "resource");
-
-        if (resource.isUndefined()) {
-          throw std::runtime_error(
-              "Property GPUBindGroupEntry::resource is required");
+        auto prop = value.getProperty(runtime, "resource");
+        if (prop.isObject()) {
+          auto obj = prop.getObject(runtime);
+          if (obj.isHostObject<rnwgpu::GPUSampler>(runtime)) {
+            result->sampler = obj.getHostObject<rnwgpu::GPUSampler>(runtime);
+          } else if (obj.isHostObject<rnwgpu::GPUTextureView>(runtime)) {
+            result->textureView =
+                obj.getHostObject<rnwgpu::GPUTextureView>(runtime);
+          } else {
+            result->buffer = JSIConverter<
+                std::shared_ptr<rnwgpu::GPUBufferBinding>>::fromJSI(runtime,
+                                                                    prop,
+                                                                    false);
+          }
         }
-      } else {
-        throw std::runtime_error(
-            "Property GPUBindGroupEntry::resource is not defined");
+        // result->resource = JSIConverter<std::variant<
+        //     std::shared_ptr<GPUSampler>, std::shared_ptr<GPUTextureView>,
+        //     std::shared_ptr<GPUBufferBinding>,
+        //     std::shared_ptr<GPUExternalTexture>>>::fromJSI(runtime, prop,
+        //                                                    false);
       }
     }
-    rnwgpu::Logger::logToConsole("GPUBindGroupEntry::binding = %f",
-                                 result->_instance.binding);
-    rnwgpu::Logger::logToConsole("GPUBindGroupEntry::resource = %f",
-                                 result->_instance.resource);
+
     return result;
   }
   static jsi::Value toJSI(jsi::Runtime &runtime,
                           std::shared_ptr<rnwgpu::GPUBindGroupEntry> arg) {
-    // No conversions here
-    return jsi::Value::null();
+    throw std::runtime_error("Invalid GPUBindGroupEntry::toJSI()");
   }
 };
+
 } // namespace margelo

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

@@ -2,29 +2,33 @@
 
 #include <memory>
 #include <string>
+#include <vector>
 
 #include "webgpu/webgpu_cpp.h"
 
-#include "Logger.h"
 #include "RNFJSIConverter.h"
-#include <RNFHybridObject.h>
+#include "WGPULogger.h"
+
+#include "GPUBindGroupLayoutEntry.h"
+#include "RNFHybridObject.h"
 
 namespace jsi = facebook::jsi;
+namespace m = margelo;
 
 namespace rnwgpu {
 
-class GPUBindGroupLayoutDescriptor {
-public:
-  wgpu::BindGroupLayoutDescriptor *getInstance() { return &_instance; }
-
-  wgpu::BindGroupLayoutDescriptor _instance;
-
-  std::string label;
+struct GPUBindGroupLayoutDescriptor {
+  std::vector<std::shared_ptr<GPUBindGroupLayoutEntry>>
+      entries;                      // Iterable<GPUBindGroupLayoutEntry>
+  std::optional<std::string> label; // string
 };
+
 } // namespace rnwgpu
 
 namespace margelo {
 
+using namespace rnwgpu; // NOLINT(build/namespaces)
+
 template <>
 struct JSIConverter<std::shared_ptr<rnwgpu::GPUBindGroupLayoutDescriptor>> {
   static std::shared_ptr<rnwgpu::GPUBindGroupLayoutDescriptor>
@@ -33,37 +37,25 @@ struct JSIConverter<std::shared_ptr<rnwgpu::GPUBindGroupLayoutDescriptor>> {
     if (!outOfBounds && arg.isObject()) {
       auto value = arg.getObject(runtime);
       if (value.hasProperty(runtime, "entries")) {
-        auto entries = value.getProperty(runtime, "entries");
-
-        if (entries.isUndefined()) {
-          throw std::runtime_error(
-              "Property GPUBindGroupLayoutDescriptor::entries is required");
-        }
-      } else {
-        throw std::runtime_error(
-            "Property GPUBindGroupLayoutDescriptor::entries is not defined");
+        auto prop = value.getProperty(runtime, "entries");
+        result->entries = JSIConverter<std::vector<
+            std::shared_ptr<GPUBindGroupLayoutEntry>>>::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("GPUBindGroupLayoutDescriptor::entries = %f",
-                                 result->_instance.entries);
-    rnwgpu::Logger::logToConsole("GPUBindGroupLayoutDescriptor::label = %f",
-                                 result->_instance.label);
+
     return result;
   }
   static jsi::Value
   toJSI(jsi::Runtime &runtime,
         std::shared_ptr<rnwgpu::GPUBindGroupLayoutDescriptor> arg) {
-    // No conversions here
-    return jsi::Value::null();
+    throw std::runtime_error("Invalid GPUBindGroupLayoutDescriptor::toJSI()");
   }
 };
-} // namespace margelo
+
+} // namespace margelo

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

@@ -1,28 +1,45 @@
 #pragma once
 
 #include <memory>
-#include <string>
 
 #include "webgpu/webgpu_cpp.h"
 
-#include "Logger.h"
 #include "RNFJSIConverter.h"
-#include <RNFHybridObject.h>
+#include "WGPULogger.h"
+
+#include "GPUBufferBindingLayout.h"
+#include "GPUExternalTextureBindingLayout.h"
+#include "GPUSamplerBindingLayout.h"
+#include "GPUStorageTextureBindingLayout.h"
+#include "GPUTextureBindingLayout.h"
+#include "RNFHybridObject.h"
 
 namespace jsi = facebook::jsi;
+namespace m = margelo;
 
 namespace rnwgpu {
 
-class GPUBindGroupLayoutEntry {
-public:
-  wgpu::BindGroupLayoutEntry *getInstance() { return &_instance; }
-
-  wgpu::BindGroupLayoutEntry _instance;
+struct GPUBindGroupLayoutEntry {
+  double binding;    // GPUIndex32
+  double visibility; // GPUShaderStageFlags
+  std::optional<std::shared_ptr<GPUBufferBindingLayout>>
+      buffer; // GPUBufferBindingLayout
+  std::optional<std::shared_ptr<GPUSamplerBindingLayout>>
+      sampler; // GPUSamplerBindingLayout
+  std::optional<std::shared_ptr<GPUTextureBindingLayout>>
+      texture; // GPUTextureBindingLayout
+  std::optional<std::shared_ptr<GPUStorageTextureBindingLayout>>
+      storageTexture; // GPUStorageTextureBindingLayout
+  std::optional<std::shared_ptr<GPUExternalTextureBindingLayout>>
+      externalTexture; // GPUExternalTextureBindingLayout
 };
+
 } // namespace rnwgpu
 
 namespace margelo {
 
+using namespace rnwgpu; // NOLINT(build/namespaces)
+
 template <>
 struct JSIConverter<std::shared_ptr<rnwgpu::GPUBindGroupLayoutEntry>> {
   static std::shared_ptr<rnwgpu::GPUBindGroupLayoutEntry>
@@ -31,65 +48,55 @@ struct JSIConverter<std::shared_ptr<rnwgpu::GPUBindGroupLayoutEntry>> {
     if (!outOfBounds && arg.isObject()) {
       auto value = arg.getObject(runtime);
       if (value.hasProperty(runtime, "binding")) {
-        auto binding = value.getProperty(runtime, "binding");
-
-        if (binding.isUndefined()) {
-          throw std::runtime_error(
-              "Property GPUBindGroupLayoutEntry::binding is required");
-        }
-      } else {
-        throw std::runtime_error(
-            "Property GPUBindGroupLayoutEntry::binding is not defined");
+        auto prop = value.getProperty(runtime, "binding");
+        result->binding = JSIConverter<double>::fromJSI(runtime, prop, false);
       }
       if (value.hasProperty(runtime, "visibility")) {
-        auto visibility = value.getProperty(runtime, "visibility");
-
-        if (visibility.isUndefined()) {
-          throw std::runtime_error(
-              "Property GPUBindGroupLayoutEntry::visibility is required");
-        }
-      } else {
-        throw std::runtime_error(
-            "Property GPUBindGroupLayoutEntry::visibility is not defined");
+        auto prop = value.getProperty(runtime, "visibility");
+        result->visibility =
+            JSIConverter<double>::fromJSI(runtime, prop, false);
       }
       if (value.hasProperty(runtime, "buffer")) {
-        auto buffer = value.getProperty(runtime, "buffer");
+        auto prop = value.getProperty(runtime, "buffer");
+        result->buffer = JSIConverter<std::optional<
+            std::shared_ptr<GPUBufferBindingLayout>>>::fromJSI(runtime, prop,
+                                                               false);
       }
       if (value.hasProperty(runtime, "sampler")) {
-        auto sampler = value.getProperty(runtime, "sampler");
+        auto prop = value.getProperty(runtime, "sampler");
+        result->sampler = JSIConverter<std::optional<
+            std::shared_ptr<GPUSamplerBindingLayout>>>::fromJSI(runtime, prop,
+                                                                false);
       }
       if (value.hasProperty(runtime, "texture")) {
-        auto texture = value.getProperty(runtime, "texture");
+        auto prop = value.getProperty(runtime, "texture");
+        result->texture = JSIConverter<std::optional<
+            std::shared_ptr<GPUTextureBindingLayout>>>::fromJSI(runtime, prop,
+                                                                false);
       }
       if (value.hasProperty(runtime, "storageTexture")) {
-        auto storageTexture = value.getProperty(runtime, "storageTexture");
+        auto prop = value.getProperty(runtime, "storageTexture");
+        result->storageTexture = JSIConverter<std::optional<
+            std::shared_ptr<GPUStorageTextureBindingLayout>>>::fromJSI(runtime,
+                                                                       prop,
+                                                                       false);
       }
       if (value.hasProperty(runtime, "externalTexture")) {
-        auto externalTexture = value.getProperty(runtime, "externalTexture");
+        auto prop = value.getProperty(runtime, "externalTexture");
+        result->externalTexture = JSIConverter<std::optional<
+            std::shared_ptr<GPUExternalTextureBindingLayout>>>::fromJSI(runtime,
+                                                                        prop,
+                                                                        false);
       }
     }
-    rnwgpu::Logger::logToConsole("GPUBindGroupLayoutEntry::binding = %f",
-                                 result->_instance.binding);
-    rnwgpu::Logger::logToConsole("GPUBindGroupLayoutEntry::visibility = %f",
-                                 result->_instance.visibility);
-    rnwgpu::Logger::logToConsole("GPUBindGroupLayoutEntry::buffer = %f",
-                                 result->_instance.buffer);
-    rnwgpu::Logger::logToConsole("GPUBindGroupLayoutEntry::sampler = %f",
-                                 result->_instance.sampler);
-    rnwgpu::Logger::logToConsole("GPUBindGroupLayoutEntry::texture = %f",
-                                 result->_instance.texture);
-    rnwgpu::Logger::logToConsole("GPUBindGroupLayoutEntry::storageTexture = %f",
-                                 result->_instance.storageTexture);
-    rnwgpu::Logger::logToConsole(
-        "GPUBindGroupLayoutEntry::externalTexture = %f",
-        result->_instance.externalTexture);
+
     return result;
   }
   static jsi::Value
   toJSI(jsi::Runtime &runtime,
         std::shared_ptr<rnwgpu::GPUBindGroupLayoutEntry> arg) {
-    // No conversions here
-    return jsi::Value::null();
+    throw std::runtime_error("Invalid GPUBindGroupLayoutEntry::toJSI()");
   }
 };
-} // namespace margelo
+
+} // namespace margelo

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

@@ -1,28 +1,31 @@
 #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 GPUBlendComponent {
-public:
-  wgpu::BlendComponent *getInstance() { return &_instance; }
-
-  wgpu::BlendComponent _instance;
+struct GPUBlendComponent {
+  std::optional<wgpu::BlendOperation> operation; // GPUBlendOperation
+  std::optional<wgpu::BlendFactor> srcFactor;    // GPUBlendFactor
+  std::optional<wgpu::BlendFactor> dstFactor;    // GPUBlendFactor
 };
+
 } // namespace rnwgpu
 
 namespace margelo {
 
+using namespace rnwgpu; // NOLINT(build/namespaces)
+
 template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUBlendComponent>> {
   static std::shared_ptr<rnwgpu::GPUBlendComponent>
   fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
@@ -30,27 +33,31 @@ template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUBlendComponent>> {
     if (!outOfBounds && arg.isObject()) {
       auto value = arg.getObject(runtime);
       if (value.hasProperty(runtime, "operation")) {
-        auto operation = value.getProperty(runtime, "operation");
+        auto prop = value.getProperty(runtime, "operation");
+        result->operation =
+            JSIConverter<std::optional<wgpu::BlendOperation>>::fromJSI(
+                runtime, prop, false);
       }
       if (value.hasProperty(runtime, "srcFactor")) {
-        auto srcFactor = value.getProperty(runtime, "srcFactor");
+        auto prop = value.getProperty(runtime, "srcFactor");
+        result->srcFactor =
+            JSIConverter<std::optional<wgpu::BlendFactor>>::fromJSI(
+                runtime, prop, false);
       }
       if (value.hasProperty(runtime, "dstFactor")) {
-        auto dstFactor = value.getProperty(runtime, "dstFactor");
+        auto prop = value.getProperty(runtime, "dstFactor");
+        result->dstFactor =
+            JSIConverter<std::optional<wgpu::BlendFactor>>::fromJSI(
+                runtime, prop, false);
       }
     }
-    rnwgpu::Logger::logToConsole("GPUBlendComponent::operation = %f",
-                                 result->_instance.operation);
-    rnwgpu::Logger::logToConsole("GPUBlendComponent::srcFactor = %f",
-                                 result->_instance.srcFactor);
-    rnwgpu::Logger::logToConsole("GPUBlendComponent::dstFactor = %f",
-                                 result->_instance.dstFactor);
+
     return result;
   }
   static jsi::Value toJSI(jsi::Runtime &runtime,
                           std::shared_ptr<rnwgpu::GPUBlendComponent> arg) {
-    // No conversions here
-    return jsi::Value::null();
+    throw std::runtime_error("Invalid GPUBlendComponent::toJSI()");
   }
 };
-} // namespace margelo
+
+} // namespace margelo

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

@@ -1,28 +1,31 @@
 #pragma once
 
 #include <memory>
-#include <string>
 
 #include "webgpu/webgpu_cpp.h"
 
-#include "Logger.h"
 #include "RNFJSIConverter.h"
-#include <RNFHybridObject.h>
+#include "WGPULogger.h"
+
+#include "GPUBlendComponent.h"
+#include "RNFHybridObject.h"
 
 namespace jsi = facebook::jsi;
+namespace m = margelo;
 
 namespace rnwgpu {
 
-class GPUBlendState {
-public:
-  wgpu::BlendState *getInstance() { return &_instance; }
-
-  wgpu::BlendState _instance;
+struct GPUBlendState {
+  std::shared_ptr<GPUBlendComponent> color; // GPUBlendComponent
+  std::shared_ptr<GPUBlendComponent> alpha; // GPUBlendComponent
 };
+
 } // namespace rnwgpu
 
 namespace margelo {
 
+using namespace rnwgpu; // NOLINT(build/namespaces)
+
 template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUBlendState>> {
   static std::shared_ptr<rnwgpu::GPUBlendState>
   fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
@@ -30,36 +33,25 @@ template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUBlendState>> {
     if (!outOfBounds && arg.isObject()) {
       auto value = arg.getObject(runtime);
       if (value.hasProperty(runtime, "color")) {
-        auto color = value.getProperty(runtime, "color");
-
-        if (color.isUndefined()) {
-          throw std::runtime_error("Property GPUBlendState::color is required");
-        }
-      } else {
-        throw std::runtime_error(
-            "Property GPUBlendState::color is not defined");
+        auto prop = value.getProperty(runtime, "color");
+        result->color =
+            JSIConverter<std::shared_ptr<GPUBlendComponent>>::fromJSI(
+                runtime, prop, false);
       }
       if (value.hasProperty(runtime, "alpha")) {
-        auto alpha = value.getProperty(runtime, "alpha");
-
-        if (alpha.isUndefined()) {
-          throw std::runtime_error("Property GPUBlendState::alpha is required");
-        }
-      } else {
-        throw std::runtime_error(
-            "Property GPUBlendState::alpha is not defined");
+        auto prop = value.getProperty(runtime, "alpha");
+        result->alpha =
+            JSIConverter<std::shared_ptr<GPUBlendComponent>>::fromJSI(
+                runtime, prop, false);
       }
     }
-    rnwgpu::Logger::logToConsole("GPUBlendState::color = %f",
-                                 result->_instance.color);
-    rnwgpu::Logger::logToConsole("GPUBlendState::alpha = %f",
-                                 result->_instance.alpha);
+
     return result;
   }
   static jsi::Value toJSI(jsi::Runtime &runtime,
                           std::shared_ptr<rnwgpu::GPUBlendState> arg) {
-    // No conversions here
-    return jsi::Value::null();
+    throw std::runtime_error("Invalid GPUBlendState::toJSI()");
   }
 };
-} // namespace margelo
+
+} // namespace margelo

package/cpp/rnwgpu/api/descriptors/GPUBufferBinding.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 "GPUBuffer.h"
+#include "RNFHybridObject.h"
 
 namespace jsi = facebook::jsi;
+namespace m = margelo;
 
 namespace rnwgpu {
 
-class GPUBufferBinding {
-public:
-  wgpu::BufferBinding *getInstance() { return &_instance; }
-
-  wgpu::BufferBinding _instance;
+struct GPUBufferBinding {
+  std::shared_ptr<GPUBuffer> buffer; // GPUBuffer
+  std::optional<double> offset;      // GPUSize64
+  std::optional<double> size;        // GPUSize64
 };
+
 } // namespace rnwgpu
 
 namespace margelo {
 
+using namespace rnwgpu; // NOLINT(build/namespaces)
+
 template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUBufferBinding>> {
   static std::shared_ptr<rnwgpu::GPUBufferBinding>
   fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
@@ -30,43 +34,28 @@ template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUBufferBinding>> {
     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 GPUBufferBinding::buffer is required");
-        }
-      } else {
-        throw std::runtime_error(
-            "Property GPUBufferBinding::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, "size")) {
-        auto size = value.getProperty(runtime, "size");
-
-        if (size.isNumber()) {
-          result->_instance.size = size.getNumber();
-        }
+        auto prop = value.getProperty(runtime, "size");
+        result->size =
+            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
       }
     }
-    rnwgpu::Logger::logToConsole("GPUBufferBinding::buffer = %f",
-                                 result->_instance.buffer);
-    rnwgpu::Logger::logToConsole("GPUBufferBinding::offset = %f",
-                                 result->_instance.offset);
-    rnwgpu::Logger::logToConsole("GPUBufferBinding::size = %f",
-                                 result->_instance.size);
+
     return result;
   }
   static jsi::Value toJSI(jsi::Runtime &runtime,
                           std::shared_ptr<rnwgpu::GPUBufferBinding> arg) {
-    // No conversions here
-    return jsi::Value::null();
+    throw std::runtime_error("Invalid GPUBufferBinding::toJSI()");
   }
 };
-} // namespace margelo
+
+} // namespace margelo