react-native-nitro-ar 2026.2.1

package/nitrogen/generated/shared/c++/CameraPose.hpp

@@ -0,0 +1,87 @@
+///
+/// CameraPose.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIHelpers.hpp>)
+#include <NitroModules/JSIHelpers.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/PropNameIDCache.hpp>)
+#include <NitroModules/PropNameIDCache.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+#include <vector>
+
+namespace margelo::nitro::ar {
+
+  /**
+   * A struct which can be represented as a JavaScript object (CameraPose).
+   */
+  struct CameraPose final {
+  public:
+    std::vector<double> position     SWIFT_PRIVATE;
+    std::vector<double> rotation     SWIFT_PRIVATE;
+
+  public:
+    CameraPose() = default;
+    explicit CameraPose(std::vector<double> position, std::vector<double> rotation): position(position), rotation(rotation) {}
+
+  public:
+    friend bool operator==(const CameraPose& lhs, const CameraPose& rhs) = default;
+  };
+
+} // namespace margelo::nitro::ar
+
+namespace margelo::nitro {
+
+  // C++ CameraPose <> JS CameraPose (object)
+  template <>
+  struct JSIConverter<margelo::nitro::ar::CameraPose> final {
+    static inline margelo::nitro::ar::CameraPose fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::ar::CameraPose(
+        JSIConverter<std::vector<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "position"))),
+        JSIConverter<std::vector<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "rotation")))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::ar::CameraPose& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "position"), JSIConverter<std::vector<double>>::toJSI(runtime, arg.position));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "rotation"), JSIConverter<std::vector<double>>::toJSI(runtime, arg.rotation));
+      return obj;
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isObject()) {
+        return false;
+      }
+      jsi::Object obj = value.getObject(runtime);
+      if (!nitro::isPlainObject(runtime, obj)) {
+        return false;
+      }
+      if (!JSIConverter<std::vector<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "position")))) return false;
+      if (!JSIConverter<std::vector<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "rotation")))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

package/nitrogen/generated/shared/c++/EnvironmentTexturing.hpp

@@ -0,0 +1,80 @@
+///
+/// EnvironmentTexturing.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/NitroHash.hpp>)
+#include <NitroModules/NitroHash.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+namespace margelo::nitro::ar {
+
+  /**
+   * An enum which can be represented as a JavaScript union (EnvironmentTexturing).
+   */
+  enum class EnvironmentTexturing {
+    NONE      SWIFT_NAME(none) = 0,
+    MANUAL      SWIFT_NAME(manual) = 1,
+    AUTOMATIC      SWIFT_NAME(automatic) = 2,
+  } CLOSED_ENUM;
+
+} // namespace margelo::nitro::ar
+
+namespace margelo::nitro {
+
+  // C++ EnvironmentTexturing <> JS EnvironmentTexturing (union)
+  template <>
+  struct JSIConverter<margelo::nitro::ar::EnvironmentTexturing> final {
+    static inline margelo::nitro::ar::EnvironmentTexturing fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, arg);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("none"): return margelo::nitro::ar::EnvironmentTexturing::NONE;
+        case hashString("manual"): return margelo::nitro::ar::EnvironmentTexturing::MANUAL;
+        case hashString("automatic"): return margelo::nitro::ar::EnvironmentTexturing::AUTOMATIC;
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum EnvironmentTexturing - invalid value!");
+      }
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::ar::EnvironmentTexturing arg) {
+      switch (arg) {
+        case margelo::nitro::ar::EnvironmentTexturing::NONE: return JSIConverter<std::string>::toJSI(runtime, "none");
+        case margelo::nitro::ar::EnvironmentTexturing::MANUAL: return JSIConverter<std::string>::toJSI(runtime, "manual");
+        case margelo::nitro::ar::EnvironmentTexturing::AUTOMATIC: return JSIConverter<std::string>::toJSI(runtime, "automatic");
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert EnvironmentTexturing to JS - invalid value: "
+                                    + std::to_string(static_cast<int>(arg)) + "!");
+      }
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isString()) {
+        return false;
+      }
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, value);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("none"):
+        case hashString("manual"):
+        case hashString("automatic"):
+          return true;
+        default:
+          return false;
+      }
+    }
+  };
+
+} // namespace margelo::nitro

package/nitrogen/generated/shared/c++/HybridARAnchorSpec.cpp

@@ -0,0 +1,26 @@
+///
+/// HybridARAnchorSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridARAnchorSpec.hpp"
+
+namespace margelo::nitro::ar {
+
+  void HybridARAnchorSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("identifier", &HybridARAnchorSpec::getIdentifier);
+      prototype.registerHybridGetter("position", &HybridARAnchorSpec::getPosition);
+      prototype.registerHybridGetter("rotation", &HybridARAnchorSpec::getRotation);
+      prototype.registerHybridGetter("transform", &HybridARAnchorSpec::getTransform);
+      prototype.registerHybridGetter("isTracked", &HybridARAnchorSpec::getIsTracked);
+      prototype.registerHybridGetter("label", &HybridARAnchorSpec::getLabel);
+    });
+  }
+
+} // namespace margelo::nitro::ar

package/nitrogen/generated/shared/c++/HybridARAnchorSpec.hpp

@@ -0,0 +1,69 @@
+///
+/// HybridARAnchorSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+#include <string>
+#include <vector>
+#include <optional>
+
+namespace margelo::nitro::ar {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `ARAnchor`
+   * Inherit this class to create instances of `HybridARAnchorSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridARAnchor: public HybridARAnchorSpec {
+   * public:
+   *   HybridARAnchor(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridARAnchorSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridARAnchorSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridARAnchorSpec() override = default;
+
+    public:
+      // Properties
+      virtual std::string getIdentifier() = 0;
+      virtual std::vector<double> getPosition() = 0;
+      virtual std::vector<double> getRotation() = 0;
+      virtual std::vector<double> getTransform() = 0;
+      virtual bool getIsTracked() = 0;
+      virtual std::optional<std::string> getLabel() = 0;
+
+    public:
+      // Methods
+      
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "ARAnchor";
+  };
+
+} // namespace margelo::nitro::ar

package/nitrogen/generated/shared/c++/HybridARBoundingBoxBuilderSpec.cpp

@@ -0,0 +1,23 @@
+///
+/// HybridARBoundingBoxBuilderSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridARBoundingBoxBuilderSpec.hpp"
+
+namespace margelo::nitro::ar {
+
+  void HybridARBoundingBoxBuilderSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("canBuild", &HybridARBoundingBoxBuilderSpec::getCanBuild);
+      prototype.registerHybridMethod("addBaseAnchor", &HybridARBoundingBoxBuilderSpec::addBaseAnchor);
+      prototype.registerHybridMethod("build", &HybridARBoundingBoxBuilderSpec::build);
+    });
+  }
+
+} // namespace margelo::nitro::ar

package/nitrogen/generated/shared/c++/HybridARBoundingBoxBuilderSpec.hpp

@@ -0,0 +1,68 @@
+///
+/// HybridARBoundingBoxBuilderSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `HybridARAnchorSpec` to properly resolve imports.
+namespace margelo::nitro::ar { class HybridARAnchorSpec; }
+// Forward declaration of `HybridARVolumeSpec` to properly resolve imports.
+namespace margelo::nitro::ar { class HybridARVolumeSpec; }
+
+#include <memory>
+#include "HybridARAnchorSpec.hpp"
+#include "HybridARVolumeSpec.hpp"
+
+namespace margelo::nitro::ar {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `ARBoundingBoxBuilder`
+   * Inherit this class to create instances of `HybridARBoundingBoxBuilderSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridARBoundingBoxBuilder: public HybridARBoundingBoxBuilderSpec {
+   * public:
+   *   HybridARBoundingBoxBuilder(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridARBoundingBoxBuilderSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridARBoundingBoxBuilderSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridARBoundingBoxBuilderSpec() override = default;
+
+    public:
+      // Properties
+      virtual bool getCanBuild() = 0;
+
+    public:
+      // Methods
+      virtual void addBaseAnchor(const std::shared_ptr<HybridARAnchorSpec>& anchor) = 0;
+      virtual std::shared_ptr<HybridARVolumeSpec> build() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "ARBoundingBoxBuilder";
+  };
+
+} // namespace margelo::nitro::ar

package/nitrogen/generated/shared/c++/HybridARDepthDataSpec.cpp

@@ -0,0 +1,26 @@
+///
+/// HybridARDepthDataSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridARDepthDataSpec.hpp"
+
+namespace margelo::nitro::ar {
+
+  void HybridARDepthDataSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("width", &HybridARDepthDataSpec::getWidth);
+      prototype.registerHybridGetter("height", &HybridARDepthDataSpec::getHeight);
+      prototype.registerHybridGetter("depthMap", &HybridARDepthDataSpec::getDepthMap);
+      prototype.registerHybridGetter("confidenceMap", &HybridARDepthDataSpec::getConfidenceMap);
+      prototype.registerHybridMethod("getDepthAt", &HybridARDepthDataSpec::getDepthAt);
+      prototype.registerHybridMethod("getConfidenceAt", &HybridARDepthDataSpec::getConfidenceAt);
+    });
+  }
+
+} // namespace margelo::nitro::ar

package/nitrogen/generated/shared/c++/HybridARDepthDataSpec.hpp

@@ -0,0 +1,66 @@
+///
+/// HybridARDepthDataSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+#include <vector>
+
+namespace margelo::nitro::ar {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `ARDepthData`
+   * Inherit this class to create instances of `HybridARDepthDataSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridARDepthData: public HybridARDepthDataSpec {
+   * public:
+   *   HybridARDepthData(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridARDepthDataSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridARDepthDataSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridARDepthDataSpec() override = default;
+
+    public:
+      // Properties
+      virtual double getWidth() = 0;
+      virtual double getHeight() = 0;
+      virtual std::vector<double> getDepthMap() = 0;
+      virtual std::vector<double> getConfidenceMap() = 0;
+
+    public:
+      // Methods
+      virtual double getDepthAt(double x, double y) = 0;
+      virtual double getConfidenceAt(double x, double y) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "ARDepthData";
+  };
+
+} // namespace margelo::nitro::ar

package/nitrogen/generated/shared/c++/HybridARDirectionalLightEstimateSpec.cpp

@@ -0,0 +1,24 @@
+///
+/// HybridARDirectionalLightEstimateSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridARDirectionalLightEstimateSpec.hpp"
+
+namespace margelo::nitro::ar {
+
+  void HybridARDirectionalLightEstimateSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    HybridARLightEstimateSpec::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("primaryLightDirection", &HybridARDirectionalLightEstimateSpec::getPrimaryLightDirection);
+      prototype.registerHybridGetter("primaryLightIntensity", &HybridARDirectionalLightEstimateSpec::getPrimaryLightIntensity);
+      prototype.registerHybridGetter("sphericalHarmonicsCoefficients", &HybridARDirectionalLightEstimateSpec::getSphericalHarmonicsCoefficients);
+    });
+  }
+
+} // namespace margelo::nitro::ar

package/nitrogen/generated/shared/c++/HybridARDirectionalLightEstimateSpec.hpp

@@ -0,0 +1,67 @@
+///
+/// HybridARDirectionalLightEstimateSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `HybridARLightEstimateSpec` to properly resolve imports.
+namespace margelo::nitro::ar { class HybridARLightEstimateSpec; }
+
+#include <vector>
+#include <memory>
+#include "HybridARLightEstimateSpec.hpp"
+
+namespace margelo::nitro::ar {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `ARDirectionalLightEstimate`
+   * Inherit this class to create instances of `HybridARDirectionalLightEstimateSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridARDirectionalLightEstimate: public HybridARDirectionalLightEstimateSpec {
+   * public:
+   *   HybridARDirectionalLightEstimate(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridARDirectionalLightEstimateSpec: public virtual HybridObject, public virtual HybridARLightEstimateSpec {
+    public:
+      // Constructor
+      explicit HybridARDirectionalLightEstimateSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridARDirectionalLightEstimateSpec() override = default;
+
+    public:
+      // Properties
+      virtual std::vector<double> getPrimaryLightDirection() = 0;
+      virtual double getPrimaryLightIntensity() = 0;
+      virtual std::vector<double> getSphericalHarmonicsCoefficients() = 0;
+
+    public:
+      // Methods
+      
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "ARDirectionalLightEstimate";
+  };
+
+} // namespace margelo::nitro::ar

package/nitrogen/generated/shared/c++/HybridARFrameSpec.cpp

@@ -0,0 +1,32 @@
+///
+/// HybridARFrameSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridARFrameSpec.hpp"
+
+namespace margelo::nitro::ar {
+
+  void HybridARFrameSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("timestamp", &HybridARFrameSpec::getTimestamp);
+      prototype.registerHybridGetter("cameraPosition", &HybridARFrameSpec::getCameraPosition);
+      prototype.registerHybridGetter("cameraRotation", &HybridARFrameSpec::getCameraRotation);
+      prototype.registerHybridGetter("projectionMatrix", &HybridARFrameSpec::getProjectionMatrix);
+      prototype.registerHybridGetter("viewMatrix", &HybridARFrameSpec::getViewMatrix);
+      prototype.registerHybridGetter("cameraIntrinsics", &HybridARFrameSpec::getCameraIntrinsics);
+      prototype.registerHybridGetter("imageResolution", &HybridARFrameSpec::getImageResolution);
+      prototype.registerHybridGetter("lightEstimate", &HybridARFrameSpec::getLightEstimate);
+      prototype.registerHybridGetter("directionalLightEstimate", &HybridARFrameSpec::getDirectionalLightEstimate);
+      prototype.registerHybridGetter("sceneDepth", &HybridARFrameSpec::getSceneDepth);
+      prototype.registerHybridGetter("smoothedSceneDepth", &HybridARFrameSpec::getSmoothedSceneDepth);
+      prototype.registerHybridMethod("getCapturedImage", &HybridARFrameSpec::getCapturedImage);
+    });
+  }
+
+} // namespace margelo::nitro::ar

package/nitrogen/generated/shared/c++/HybridARFrameSpec.hpp

@@ -0,0 +1,83 @@
+///
+/// HybridARFrameSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `HybridARLightEstimateSpec` to properly resolve imports.
+namespace margelo::nitro::ar { class HybridARLightEstimateSpec; }
+// Forward declaration of `HybridARDirectionalLightEstimateSpec` to properly resolve imports.
+namespace margelo::nitro::ar { class HybridARDirectionalLightEstimateSpec; }
+// Forward declaration of `HybridARDepthDataSpec` to properly resolve imports.
+namespace margelo::nitro::ar { class HybridARDepthDataSpec; }
+
+#include <vector>
+#include <memory>
+#include "HybridARLightEstimateSpec.hpp"
+#include <optional>
+#include "HybridARDirectionalLightEstimateSpec.hpp"
+#include "HybridARDepthDataSpec.hpp"
+#include <string>
+
+namespace margelo::nitro::ar {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `ARFrame`
+   * Inherit this class to create instances of `HybridARFrameSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridARFrame: public HybridARFrameSpec {
+   * public:
+   *   HybridARFrame(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridARFrameSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridARFrameSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridARFrameSpec() override = default;
+
+    public:
+      // Properties
+      virtual double getTimestamp() = 0;
+      virtual std::vector<double> getCameraPosition() = 0;
+      virtual std::vector<double> getCameraRotation() = 0;
+      virtual std::vector<double> getProjectionMatrix() = 0;
+      virtual std::vector<double> getViewMatrix() = 0;
+      virtual std::vector<double> getCameraIntrinsics() = 0;
+      virtual std::vector<double> getImageResolution() = 0;
+      virtual std::optional<std::shared_ptr<HybridARLightEstimateSpec>> getLightEstimate() = 0;
+      virtual std::optional<std::shared_ptr<HybridARDirectionalLightEstimateSpec>> getDirectionalLightEstimate() = 0;
+      virtual std::optional<std::shared_ptr<HybridARDepthDataSpec>> getSceneDepth() = 0;
+      virtual std::optional<std::shared_ptr<HybridARDepthDataSpec>> getSmoothedSceneDepth() = 0;
+
+    public:
+      // Methods
+      virtual std::string getCapturedImage(double quality) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "ARFrame";
+  };
+
+} // namespace margelo::nitro::ar

package/nitrogen/generated/shared/c++/HybridARLightEstimateSpec.cpp

@@ -0,0 +1,22 @@
+///
+/// HybridARLightEstimateSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridARLightEstimateSpec.hpp"
+
+namespace margelo::nitro::ar {
+
+  void HybridARLightEstimateSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("ambientIntensity", &HybridARLightEstimateSpec::getAmbientIntensity);
+      prototype.registerHybridGetter("ambientColorTemperature", &HybridARLightEstimateSpec::getAmbientColorTemperature);
+    });
+  }
+
+} // namespace margelo::nitro::ar