react-native-nitro-ar 2026.2.1

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

@@ -0,0 +1,63 @@
+///
+/// HybridARLightEstimateSpec.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
+
+
+
+
+
+namespace margelo::nitro::ar {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `ARLightEstimate`
+   * Inherit this class to create instances of `HybridARLightEstimateSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridARLightEstimate: public HybridARLightEstimateSpec {
+   * public:
+   *   HybridARLightEstimate(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridARLightEstimateSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridARLightEstimateSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridARLightEstimateSpec() override = default;
+
+    public:
+      // Properties
+      virtual double getAmbientIntensity() = 0;
+      virtual double getAmbientColorTemperature() = 0;
+
+    public:
+      // Methods
+      
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "ARLightEstimate";
+  };
+
+} // namespace margelo::nitro::ar

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

@@ -0,0 +1,24 @@
+///
+/// HybridARMeasurementSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridARMeasurementSpec.hpp"
+
+namespace margelo::nitro::ar {
+
+  void HybridARMeasurementSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("start", &HybridARMeasurementSpec::getStart);
+      prototype.registerHybridGetter("end", &HybridARMeasurementSpec::getEnd);
+      prototype.registerHybridGetter("length", &HybridARMeasurementSpec::getLength);
+      prototype.registerHybridGetter("isValid", &HybridARMeasurementSpec::getIsValid);
+    });
+  }
+
+} // namespace margelo::nitro::ar

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

@@ -0,0 +1,67 @@
+///
+/// HybridARMeasurementSpec.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; }
+
+#include <memory>
+#include "HybridARAnchorSpec.hpp"
+
+namespace margelo::nitro::ar {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `ARMeasurement`
+   * Inherit this class to create instances of `HybridARMeasurementSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridARMeasurement: public HybridARMeasurementSpec {
+   * public:
+   *   HybridARMeasurement(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridARMeasurementSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridARMeasurementSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridARMeasurementSpec() override = default;
+
+    public:
+      // Properties
+      virtual std::shared_ptr<HybridARAnchorSpec> getStart() = 0;
+      virtual std::shared_ptr<HybridARAnchorSpec> getEnd() = 0;
+      virtual double getLength() = 0;
+      virtual bool getIsValid() = 0;
+
+    public:
+      // Methods
+      
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "ARMeasurement";
+  };
+
+} // namespace margelo::nitro::ar

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

@@ -0,0 +1,28 @@
+///
+/// HybridARMeshAnchorSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridARMeshAnchorSpec.hpp"
+
+namespace margelo::nitro::ar {
+
+  void HybridARMeshAnchorSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("identifier", &HybridARMeshAnchorSpec::getIdentifier);
+      prototype.registerHybridGetter("transform", &HybridARMeshAnchorSpec::getTransform);
+      prototype.registerHybridGetter("vertexCount", &HybridARMeshAnchorSpec::getVertexCount);
+      prototype.registerHybridGetter("faceCount", &HybridARMeshAnchorSpec::getFaceCount);
+      prototype.registerHybridGetter("vertices", &HybridARMeshAnchorSpec::getVertices);
+      prototype.registerHybridGetter("faces", &HybridARMeshAnchorSpec::getFaces);
+      prototype.registerHybridGetter("normals", &HybridARMeshAnchorSpec::getNormals);
+      prototype.registerHybridGetter("classifications", &HybridARMeshAnchorSpec::getClassifications);
+    });
+  }
+
+} // namespace margelo::nitro::ar

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

@@ -0,0 +1,72 @@
+///
+/// HybridARMeshAnchorSpec.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 `MeshClassification` to properly resolve imports.
+namespace margelo::nitro::ar { enum class MeshClassification; }
+
+#include <string>
+#include <vector>
+#include "MeshClassification.hpp"
+
+namespace margelo::nitro::ar {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `ARMeshAnchor`
+   * Inherit this class to create instances of `HybridARMeshAnchorSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridARMeshAnchor: public HybridARMeshAnchorSpec {
+   * public:
+   *   HybridARMeshAnchor(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridARMeshAnchorSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridARMeshAnchorSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridARMeshAnchorSpec() override = default;
+
+    public:
+      // Properties
+      virtual std::string getIdentifier() = 0;
+      virtual std::vector<double> getTransform() = 0;
+      virtual double getVertexCount() = 0;
+      virtual double getFaceCount() = 0;
+      virtual std::vector<double> getVertices() = 0;
+      virtual std::vector<double> getFaces() = 0;
+      virtual std::vector<double> getNormals() = 0;
+      virtual std::vector<MeshClassification> getClassifications() = 0;
+
+    public:
+      // Methods
+      
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "ARMeshAnchor";
+  };
+
+} // namespace margelo::nitro::ar

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

@@ -0,0 +1,28 @@
+///
+/// HybridARPlaneAnchorSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridARPlaneAnchorSpec.hpp"
+
+namespace margelo::nitro::ar {
+
+  void HybridARPlaneAnchorSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("identifier", &HybridARPlaneAnchorSpec::getIdentifier);
+      prototype.registerHybridGetter("position", &HybridARPlaneAnchorSpec::getPosition);
+      prototype.registerHybridGetter("rotation", &HybridARPlaneAnchorSpec::getRotation);
+      prototype.registerHybridGetter("alignment", &HybridARPlaneAnchorSpec::getAlignment);
+      prototype.registerHybridGetter("classification", &HybridARPlaneAnchorSpec::getClassification);
+      prototype.registerHybridGetter("extent", &HybridARPlaneAnchorSpec::getExtent);
+      prototype.registerHybridGetter("center", &HybridARPlaneAnchorSpec::getCenter);
+      prototype.registerHybridGetter("geometry", &HybridARPlaneAnchorSpec::getGeometry);
+    });
+  }
+
+} // namespace margelo::nitro::ar

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

@@ -0,0 +1,79 @@
+///
+/// HybridARPlaneAnchorSpec.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 `PlaneAlignment` to properly resolve imports.
+namespace margelo::nitro::ar { enum class PlaneAlignment; }
+// Forward declaration of `PlaneClassification` to properly resolve imports.
+namespace margelo::nitro::ar { enum class PlaneClassification; }
+// Forward declaration of `HybridARPlaneGeometrySpec` to properly resolve imports.
+namespace margelo::nitro::ar { class HybridARPlaneGeometrySpec; }
+
+#include <string>
+#include <vector>
+#include "PlaneAlignment.hpp"
+#include "PlaneClassification.hpp"
+#include <memory>
+#include "HybridARPlaneGeometrySpec.hpp"
+
+namespace margelo::nitro::ar {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `ARPlaneAnchor`
+   * Inherit this class to create instances of `HybridARPlaneAnchorSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridARPlaneAnchor: public HybridARPlaneAnchorSpec {
+   * public:
+   *   HybridARPlaneAnchor(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridARPlaneAnchorSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridARPlaneAnchorSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridARPlaneAnchorSpec() override = default;
+
+    public:
+      // Properties
+      virtual std::string getIdentifier() = 0;
+      virtual std::vector<double> getPosition() = 0;
+      virtual std::vector<double> getRotation() = 0;
+      virtual PlaneAlignment getAlignment() = 0;
+      virtual PlaneClassification getClassification() = 0;
+      virtual std::vector<double> getExtent() = 0;
+      virtual std::vector<double> getCenter() = 0;
+      virtual std::shared_ptr<HybridARPlaneGeometrySpec> getGeometry() = 0;
+
+    public:
+      // Methods
+      
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "ARPlaneAnchor";
+  };
+
+} // namespace margelo::nitro::ar

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

@@ -0,0 +1,24 @@
+///
+/// HybridARPlaneGeometrySpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridARPlaneGeometrySpec.hpp"
+
+namespace margelo::nitro::ar {
+
+  void HybridARPlaneGeometrySpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("vertices", &HybridARPlaneGeometrySpec::getVertices);
+      prototype.registerHybridGetter("textureCoordinates", &HybridARPlaneGeometrySpec::getTextureCoordinates);
+      prototype.registerHybridGetter("triangleIndices", &HybridARPlaneGeometrySpec::getTriangleIndices);
+      prototype.registerHybridGetter("boundaryVertices", &HybridARPlaneGeometrySpec::getBoundaryVertices);
+    });
+  }
+
+} // namespace margelo::nitro::ar

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

@@ -0,0 +1,65 @@
+///
+/// HybridARPlaneGeometrySpec.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 `ARPlaneGeometry`
+   * Inherit this class to create instances of `HybridARPlaneGeometrySpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridARPlaneGeometry: public HybridARPlaneGeometrySpec {
+   * public:
+   *   HybridARPlaneGeometry(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridARPlaneGeometrySpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridARPlaneGeometrySpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridARPlaneGeometrySpec() override = default;
+
+    public:
+      // Properties
+      virtual std::vector<double> getVertices() = 0;
+      virtual std::vector<double> getTextureCoordinates() = 0;
+      virtual std::vector<double> getTriangleIndices() = 0;
+      virtual std::vector<double> getBoundaryVertices() = 0;
+
+    public:
+      // Methods
+      
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "ARPlaneGeometry";
+  };
+
+} // namespace margelo::nitro::ar

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

@@ -0,0 +1,25 @@
+///
+/// HybridARRaycastResultSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridARRaycastResultSpec.hpp"
+
+namespace margelo::nitro::ar {
+
+  void HybridARRaycastResultSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("position", &HybridARRaycastResultSpec::getPosition);
+      prototype.registerHybridGetter("rotation", &HybridARRaycastResultSpec::getRotation);
+      prototype.registerHybridGetter("distance", &HybridARRaycastResultSpec::getDistance);
+      prototype.registerHybridGetter("target", &HybridARRaycastResultSpec::getTarget);
+      prototype.registerHybridGetter("anchorId", &HybridARRaycastResultSpec::getAnchorId);
+    });
+  }
+
+} // namespace margelo::nitro::ar

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

@@ -0,0 +1,70 @@
+///
+/// HybridARRaycastResultSpec.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 `RaycastTarget` to properly resolve imports.
+namespace margelo::nitro::ar { enum class RaycastTarget; }
+
+#include <vector>
+#include "RaycastTarget.hpp"
+#include <string>
+#include <optional>
+
+namespace margelo::nitro::ar {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `ARRaycastResult`
+   * Inherit this class to create instances of `HybridARRaycastResultSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridARRaycastResult: public HybridARRaycastResultSpec {
+   * public:
+   *   HybridARRaycastResult(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridARRaycastResultSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridARRaycastResultSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridARRaycastResultSpec() override = default;
+
+    public:
+      // Properties
+      virtual std::vector<double> getPosition() = 0;
+      virtual std::vector<double> getRotation() = 0;
+      virtual double getDistance() = 0;
+      virtual RaycastTarget getTarget() = 0;
+      virtual std::optional<std::string> getAnchorId() = 0;
+
+    public:
+      // Methods
+      
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "ARRaycastResult";
+  };
+
+} // namespace margelo::nitro::ar

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

@@ -0,0 +1,45 @@
+///
+/// HybridARSessionSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridARSessionSpec.hpp"
+
+namespace margelo::nitro::ar {
+
+  void HybridARSessionSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("trackingState", &HybridARSessionSpec::getTrackingState);
+      prototype.registerHybridGetter("trackingStateReason", &HybridARSessionSpec::getTrackingStateReason);
+      prototype.registerHybridGetter("worldMappingStatus", &HybridARSessionSpec::getWorldMappingStatus);
+      prototype.registerHybridGetter("isRunning", &HybridARSessionSpec::getIsRunning);
+      prototype.registerHybridGetter("currentFrame", &HybridARSessionSpec::getCurrentFrame);
+      prototype.registerHybridGetter("anchors", &HybridARSessionSpec::getAnchors);
+      prototype.registerHybridGetter("planeAnchors", &HybridARSessionSpec::getPlaneAnchors);
+      prototype.registerHybridGetter("meshAnchors", &HybridARSessionSpec::getMeshAnchors);
+      prototype.registerHybridMethod("start", &HybridARSessionSpec::start);
+      prototype.registerHybridMethod("pause", &HybridARSessionSpec::pause);
+      prototype.registerHybridMethod("reset", &HybridARSessionSpec::reset);
+      prototype.registerHybridMethod("getCameraPose", &HybridARSessionSpec::getCameraPose);
+      prototype.registerHybridMethod("raycast", &HybridARSessionSpec::raycast);
+      prototype.registerHybridMethod("raycastWithQuery", &HybridARSessionSpec::raycastWithQuery);
+      prototype.registerHybridMethod("createAnchor", &HybridARSessionSpec::createAnchor);
+      prototype.registerHybridMethod("createAnchorAtPosition", &HybridARSessionSpec::createAnchorAtPosition);
+      prototype.registerHybridMethod("removeAnchor", &HybridARSessionSpec::removeAnchor);
+      prototype.registerHybridMethod("createMeasurement", &HybridARSessionSpec::createMeasurement);
+      prototype.registerHybridMethod("getCurrentWorldMap", &HybridARSessionSpec::getCurrentWorldMap);
+      prototype.registerHybridMethod("onFrameUpdate", &HybridARSessionSpec::onFrameUpdate);
+      prototype.registerHybridMethod("onTrackingStateChanged", &HybridARSessionSpec::onTrackingStateChanged);
+      prototype.registerHybridMethod("onAnchorsUpdated", &HybridARSessionSpec::onAnchorsUpdated);
+      prototype.registerHybridMethod("onPlanesUpdated", &HybridARSessionSpec::onPlanesUpdated);
+      prototype.registerHybridMethod("getLiDARCapabilities", &HybridARSessionSpec::getLiDARCapabilities);
+      prototype.registerHybridMethod("onMeshUpdated", &HybridARSessionSpec::onMeshUpdated);
+    });
+  }
+
+} // namespace margelo::nitro::ar