react-native-nitro-ar 2026.2.1

package/nitrogen/generated/ios/c++/HybridARPlaneGeometrySpecSwift.hpp

@@ -0,0 +1,90 @@
+///
+/// HybridARPlaneGeometrySpecSwift.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include "HybridARPlaneGeometrySpec.hpp"
+
+// Forward declaration of `HybridARPlaneGeometrySpec_cxx` to properly resolve imports.
+namespace NitroAR { class HybridARPlaneGeometrySpec_cxx; }
+
+
+
+#include <vector>
+
+#include "NitroAR-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::ar {
+
+  /**
+   * The C++ part of HybridARPlaneGeometrySpec_cxx.swift.
+   *
+   * HybridARPlaneGeometrySpecSwift (C++) accesses HybridARPlaneGeometrySpec_cxx (Swift), and might
+   * contain some additional bridging code for C++ <> Swift interop.
+   *
+   * Since this obviously introduces an overhead, I hope at some point in
+   * the future, HybridARPlaneGeometrySpec_cxx can directly inherit from the C++ class HybridARPlaneGeometrySpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridARPlaneGeometrySpecSwift: public virtual HybridARPlaneGeometrySpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridARPlaneGeometrySpecSwift(const NitroAR::HybridARPlaneGeometrySpec_cxx& swiftPart):
+      HybridObject(HybridARPlaneGeometrySpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline NitroAR::HybridARPlaneGeometrySpec_cxx& getSwiftPart() noexcept {
+      return _swiftPart;
+    }
+
+  public:
+    inline size_t getExternalMemorySize() noexcept override {
+      return _swiftPart.getMemorySize();
+    }
+    bool equals(const std::shared_ptr<HybridObject>& other) override {
+      if (auto otherCast = std::dynamic_pointer_cast<HybridARPlaneGeometrySpecSwift>(other)) {
+        return _swiftPart.equals(otherCast->_swiftPart);
+      }
+      return false;
+    }
+    void dispose() noexcept override {
+      _swiftPart.dispose();
+    }
+    std::string toString() override {
+      return _swiftPart.toString();
+    }
+
+  public:
+    // Properties
+    inline std::vector<double> getVertices() noexcept override {
+      auto __result = _swiftPart.getVertices();
+      return __result;
+    }
+    inline std::vector<double> getTextureCoordinates() noexcept override {
+      auto __result = _swiftPart.getTextureCoordinates();
+      return __result;
+    }
+    inline std::vector<double> getTriangleIndices() noexcept override {
+      auto __result = _swiftPart.getTriangleIndices();
+      return __result;
+    }
+    inline std::vector<double> getBoundaryVertices() noexcept override {
+      auto __result = _swiftPart.getBoundaryVertices();
+      return __result;
+    }
+
+  public:
+    // Methods
+    
+
+  private:
+    NitroAR::HybridARPlaneGeometrySpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::ar

package/nitrogen/generated/ios/c++/HybridARRaycastResultSpecSwift.cpp

@@ -0,0 +1,11 @@
+///
+/// HybridARRaycastResultSpecSwift.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridARRaycastResultSpecSwift.hpp"
+
+namespace margelo::nitro::ar {
+} // namespace margelo::nitro::ar

package/nitrogen/generated/ios/c++/HybridARRaycastResultSpecSwift.hpp

@@ -0,0 +1,97 @@
+///
+/// HybridARRaycastResultSpecSwift.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include "HybridARRaycastResultSpec.hpp"
+
+// Forward declaration of `HybridARRaycastResultSpec_cxx` to properly resolve imports.
+namespace NitroAR { class HybridARRaycastResultSpec_cxx; }
+
+// Forward declaration of `RaycastTarget` to properly resolve imports.
+namespace margelo::nitro::ar { enum class RaycastTarget; }
+
+#include <vector>
+#include "RaycastTarget.hpp"
+#include <string>
+#include <optional>
+
+#include "NitroAR-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::ar {
+
+  /**
+   * The C++ part of HybridARRaycastResultSpec_cxx.swift.
+   *
+   * HybridARRaycastResultSpecSwift (C++) accesses HybridARRaycastResultSpec_cxx (Swift), and might
+   * contain some additional bridging code for C++ <> Swift interop.
+   *
+   * Since this obviously introduces an overhead, I hope at some point in
+   * the future, HybridARRaycastResultSpec_cxx can directly inherit from the C++ class HybridARRaycastResultSpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridARRaycastResultSpecSwift: public virtual HybridARRaycastResultSpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridARRaycastResultSpecSwift(const NitroAR::HybridARRaycastResultSpec_cxx& swiftPart):
+      HybridObject(HybridARRaycastResultSpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline NitroAR::HybridARRaycastResultSpec_cxx& getSwiftPart() noexcept {
+      return _swiftPart;
+    }
+
+  public:
+    inline size_t getExternalMemorySize() noexcept override {
+      return _swiftPart.getMemorySize();
+    }
+    bool equals(const std::shared_ptr<HybridObject>& other) override {
+      if (auto otherCast = std::dynamic_pointer_cast<HybridARRaycastResultSpecSwift>(other)) {
+        return _swiftPart.equals(otherCast->_swiftPart);
+      }
+      return false;
+    }
+    void dispose() noexcept override {
+      _swiftPart.dispose();
+    }
+    std::string toString() override {
+      return _swiftPart.toString();
+    }
+
+  public:
+    // Properties
+    inline std::vector<double> getPosition() noexcept override {
+      auto __result = _swiftPart.getPosition();
+      return __result;
+    }
+    inline std::vector<double> getRotation() noexcept override {
+      auto __result = _swiftPart.getRotation();
+      return __result;
+    }
+    inline double getDistance() noexcept override {
+      return _swiftPart.getDistance();
+    }
+    inline RaycastTarget getTarget() noexcept override {
+      auto __result = _swiftPart.getTarget();
+      return static_cast<RaycastTarget>(__result);
+    }
+    inline std::optional<std::string> getAnchorId() noexcept override {
+      auto __result = _swiftPart.getAnchorId();
+      return __result;
+    }
+
+  public:
+    // Methods
+    
+
+  private:
+    NitroAR::HybridARRaycastResultSpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::ar

package/nitrogen/generated/ios/c++/HybridARSessionSpecSwift.cpp

@@ -0,0 +1,11 @@
+///
+/// HybridARSessionSpecSwift.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridARSessionSpecSwift.hpp"
+
+namespace margelo::nitro::ar {
+} // namespace margelo::nitro::ar

package/nitrogen/generated/ios/c++/HybridARSessionSpecSwift.hpp

@@ -0,0 +1,296 @@
+///
+/// HybridARSessionSpecSwift.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include "HybridARSessionSpec.hpp"
+
+// Forward declaration of `HybridARSessionSpec_cxx` to properly resolve imports.
+namespace NitroAR { class HybridARSessionSpec_cxx; }
+
+// Forward declaration of `TrackingState` to properly resolve imports.
+namespace margelo::nitro::ar { enum class TrackingState; }
+// Forward declaration of `TrackingStateReason` to properly resolve imports.
+namespace margelo::nitro::ar { enum class TrackingStateReason; }
+// Forward declaration of `WorldMappingStatus` to properly resolve imports.
+namespace margelo::nitro::ar { enum class WorldMappingStatus; }
+// Forward declaration of `HybridARFrameSpec` to properly resolve imports.
+namespace margelo::nitro::ar { class HybridARFrameSpec; }
+// Forward declaration of `HybridARAnchorSpec` to properly resolve imports.
+namespace margelo::nitro::ar { class HybridARAnchorSpec; }
+// Forward declaration of `HybridARPlaneAnchorSpec` to properly resolve imports.
+namespace margelo::nitro::ar { class HybridARPlaneAnchorSpec; }
+// Forward declaration of `HybridARMeshAnchorSpec` to properly resolve imports.
+namespace margelo::nitro::ar { class HybridARMeshAnchorSpec; }
+// Forward declaration of `ARSessionConfiguration` to properly resolve imports.
+namespace margelo::nitro::ar { struct ARSessionConfiguration; }
+// Forward declaration of `PlaneDetectionMode` to properly resolve imports.
+namespace margelo::nitro::ar { enum class PlaneDetectionMode; }
+// Forward declaration of `EnvironmentTexturing` to properly resolve imports.
+namespace margelo::nitro::ar { enum class EnvironmentTexturing; }
+// Forward declaration of `WorldAlignment` to properly resolve imports.
+namespace margelo::nitro::ar { enum class WorldAlignment; }
+// Forward declaration of `SceneReconstructionMode` to properly resolve imports.
+namespace margelo::nitro::ar { enum class SceneReconstructionMode; }
+// Forward declaration of `CameraPose` to properly resolve imports.
+namespace margelo::nitro::ar { struct CameraPose; }
+// Forward declaration of `HybridARRaycastResultSpec` to properly resolve imports.
+namespace margelo::nitro::ar { class HybridARRaycastResultSpec; }
+// Forward declaration of `RaycastQuery` to properly resolve imports.
+namespace margelo::nitro::ar { struct RaycastQuery; }
+// Forward declaration of `RaycastTarget` to properly resolve imports.
+namespace margelo::nitro::ar { enum class RaycastTarget; }
+// Forward declaration of `RaycastAlignment` to properly resolve imports.
+namespace margelo::nitro::ar { enum class RaycastAlignment; }
+// Forward declaration of `HybridARMeasurementSpec` to properly resolve imports.
+namespace margelo::nitro::ar { class HybridARMeasurementSpec; }
+// Forward declaration of `HybridARWorldMapSpec` to properly resolve imports.
+namespace margelo::nitro::ar { class HybridARWorldMapSpec; }
+// Forward declaration of `LiDARCapabilities` to properly resolve imports.
+namespace margelo::nitro::ar { struct LiDARCapabilities; }
+
+#include "TrackingState.hpp"
+#include "TrackingStateReason.hpp"
+#include "WorldMappingStatus.hpp"
+#include <memory>
+#include "HybridARFrameSpec.hpp"
+#include <optional>
+#include "HybridARAnchorSpec.hpp"
+#include <vector>
+#include "HybridARPlaneAnchorSpec.hpp"
+#include "HybridARMeshAnchorSpec.hpp"
+#include "ARSessionConfiguration.hpp"
+#include "PlaneDetectionMode.hpp"
+#include "EnvironmentTexturing.hpp"
+#include "WorldAlignment.hpp"
+#include <string>
+#include "SceneReconstructionMode.hpp"
+#include "CameraPose.hpp"
+#include "HybridARRaycastResultSpec.hpp"
+#include "RaycastQuery.hpp"
+#include "RaycastTarget.hpp"
+#include "RaycastAlignment.hpp"
+#include "HybridARMeasurementSpec.hpp"
+#include "HybridARWorldMapSpec.hpp"
+#include <NitroModules/Promise.hpp>
+#include <functional>
+#include "LiDARCapabilities.hpp"
+
+#include "NitroAR-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::ar {
+
+  /**
+   * The C++ part of HybridARSessionSpec_cxx.swift.
+   *
+   * HybridARSessionSpecSwift (C++) accesses HybridARSessionSpec_cxx (Swift), and might
+   * contain some additional bridging code for C++ <> Swift interop.
+   *
+   * Since this obviously introduces an overhead, I hope at some point in
+   * the future, HybridARSessionSpec_cxx can directly inherit from the C++ class HybridARSessionSpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridARSessionSpecSwift: public virtual HybridARSessionSpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridARSessionSpecSwift(const NitroAR::HybridARSessionSpec_cxx& swiftPart):
+      HybridObject(HybridARSessionSpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline NitroAR::HybridARSessionSpec_cxx& getSwiftPart() noexcept {
+      return _swiftPart;
+    }
+
+  public:
+    inline size_t getExternalMemorySize() noexcept override {
+      return _swiftPart.getMemorySize();
+    }
+    bool equals(const std::shared_ptr<HybridObject>& other) override {
+      if (auto otherCast = std::dynamic_pointer_cast<HybridARSessionSpecSwift>(other)) {
+        return _swiftPart.equals(otherCast->_swiftPart);
+      }
+      return false;
+    }
+    void dispose() noexcept override {
+      _swiftPart.dispose();
+    }
+    std::string toString() override {
+      return _swiftPart.toString();
+    }
+
+  public:
+    // Properties
+    inline TrackingState getTrackingState() noexcept override {
+      auto __result = _swiftPart.getTrackingState();
+      return static_cast<TrackingState>(__result);
+    }
+    inline TrackingStateReason getTrackingStateReason() noexcept override {
+      auto __result = _swiftPart.getTrackingStateReason();
+      return static_cast<TrackingStateReason>(__result);
+    }
+    inline WorldMappingStatus getWorldMappingStatus() noexcept override {
+      auto __result = _swiftPart.getWorldMappingStatus();
+      return static_cast<WorldMappingStatus>(__result);
+    }
+    inline bool getIsRunning() noexcept override {
+      return _swiftPart.isRunning();
+    }
+    inline std::optional<std::shared_ptr<HybridARFrameSpec>> getCurrentFrame() noexcept override {
+      auto __result = _swiftPart.getCurrentFrame();
+      return __result;
+    }
+    inline std::vector<std::shared_ptr<HybridARAnchorSpec>> getAnchors() noexcept override {
+      auto __result = _swiftPart.getAnchors();
+      return __result;
+    }
+    inline std::vector<std::shared_ptr<HybridARPlaneAnchorSpec>> getPlaneAnchors() noexcept override {
+      auto __result = _swiftPart.getPlaneAnchors();
+      return __result;
+    }
+    inline std::vector<std::shared_ptr<HybridARMeshAnchorSpec>> getMeshAnchors() noexcept override {
+      auto __result = _swiftPart.getMeshAnchors();
+      return __result;
+    }
+
+  public:
+    // Methods
+    inline void start(const std::optional<ARSessionConfiguration>& config) override {
+      auto __result = _swiftPart.start(config);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void pause() override {
+      auto __result = _swiftPart.pause();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void reset() override {
+      auto __result = _swiftPart.reset();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline CameraPose getCameraPose() override {
+      auto __result = _swiftPart.getCameraPose();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::optional<std::shared_ptr<HybridARRaycastResultSpec>> raycast(double x, double y) override {
+      auto __result = _swiftPart.raycast(std::forward<decltype(x)>(x), std::forward<decltype(y)>(y));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::vector<std::shared_ptr<HybridARRaycastResultSpec>> raycastWithQuery(const RaycastQuery& query) override {
+      auto __result = _swiftPart.raycastWithQuery(std::forward<decltype(query)>(query));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<HybridARAnchorSpec> createAnchor(const std::shared_ptr<HybridARRaycastResultSpec>& hit) override {
+      auto __result = _swiftPart.createAnchor(hit);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<HybridARAnchorSpec> createAnchorAtPosition(const std::vector<double>& position, const std::optional<std::vector<double>>& rotation) override {
+      auto __result = _swiftPart.createAnchorAtPosition(position, rotation);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline void removeAnchor(const std::shared_ptr<HybridARAnchorSpec>& anchor) override {
+      auto __result = _swiftPart.removeAnchor(anchor);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline std::shared_ptr<HybridARMeasurementSpec> createMeasurement(const std::shared_ptr<HybridARAnchorSpec>& start, const std::shared_ptr<HybridARAnchorSpec>& end) override {
+      auto __result = _swiftPart.createMeasurement(start, end);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<std::shared_ptr<HybridARWorldMapSpec>>> getCurrentWorldMap() override {
+      auto __result = _swiftPart.getCurrentWorldMap();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::function<void()> onFrameUpdate(const std::function<void(const std::shared_ptr<HybridARFrameSpec>& /* frame */)>& callback) override {
+      auto __result = _swiftPart.onFrameUpdate(callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::function<void()> onTrackingStateChanged(const std::function<void(TrackingState /* state */, TrackingStateReason /* reason */)>& callback) override {
+      auto __result = _swiftPart.onTrackingStateChanged(callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::function<void()> onAnchorsUpdated(const std::function<void(const std::vector<std::shared_ptr<HybridARAnchorSpec>>& /* added */, const std::vector<std::shared_ptr<HybridARAnchorSpec>>& /* updated */, const std::vector<std::string>& /* removed */)>& callback) override {
+      auto __result = _swiftPart.onAnchorsUpdated(callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::function<void()> onPlanesUpdated(const std::function<void(const std::vector<std::shared_ptr<HybridARPlaneAnchorSpec>>& /* added */, const std::vector<std::shared_ptr<HybridARPlaneAnchorSpec>>& /* updated */, const std::vector<std::string>& /* removed */)>& callback) override {
+      auto __result = _swiftPart.onPlanesUpdated(callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline LiDARCapabilities getLiDARCapabilities() override {
+      auto __result = _swiftPart.getLiDARCapabilities();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::function<void()> onMeshUpdated(const std::function<void(const std::vector<std::shared_ptr<HybridARMeshAnchorSpec>>& /* added */, const std::vector<std::shared_ptr<HybridARMeshAnchorSpec>>& /* updated */, const std::vector<std::string>& /* removed */)>& callback) override {
+      auto __result = _swiftPart.onMeshUpdated(callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+
+  private:
+    NitroAR::HybridARSessionSpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::ar

package/nitrogen/generated/ios/c++/HybridARViewSpecSwift.cpp

@@ -0,0 +1,11 @@
+///
+/// HybridARViewSpecSwift.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridARViewSpecSwift.hpp"
+
+namespace margelo::nitro::ar {
+} // namespace margelo::nitro::ar