react-native-nitro-ar 2026.2.1

package/nitrogen/generated/ios/NitroAR-Swift-Cxx-Umbrella.hpp

@@ -0,0 +1,169 @@
+///
+/// NitroAR-Swift-Cxx-Umbrella.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+// Forward declarations of C++ defined types
+// Forward declaration of `ARSessionConfiguration` to properly resolve imports.
+namespace margelo::nitro::ar { struct ARSessionConfiguration; }
+// Forward declaration of `ARViewHitResult` to properly resolve imports.
+namespace margelo::nitro::ar { struct ARViewHitResult; }
+// Forward declaration of `CameraPose` to properly resolve imports.
+namespace margelo::nitro::ar { struct CameraPose; }
+// Forward declaration of `EnvironmentTexturing` to properly resolve imports.
+namespace margelo::nitro::ar { enum class EnvironmentTexturing; }
+// Forward declaration of `HybridARAnchorSpec` to properly resolve imports.
+namespace margelo::nitro::ar { class HybridARAnchorSpec; }
+// Forward declaration of `HybridARBoundingBoxBuilderSpec` to properly resolve imports.
+namespace margelo::nitro::ar { class HybridARBoundingBoxBuilderSpec; }
+// Forward declaration of `HybridARDepthDataSpec` to properly resolve imports.
+namespace margelo::nitro::ar { class HybridARDepthDataSpec; }
+// Forward declaration of `HybridARDirectionalLightEstimateSpec` to properly resolve imports.
+namespace margelo::nitro::ar { class HybridARDirectionalLightEstimateSpec; }
+// Forward declaration of `HybridARFrameSpec` to properly resolve imports.
+namespace margelo::nitro::ar { class HybridARFrameSpec; }
+// Forward declaration of `HybridARLightEstimateSpec` to properly resolve imports.
+namespace margelo::nitro::ar { class HybridARLightEstimateSpec; }
+// Forward declaration of `HybridARMeasurementSpec` to properly resolve imports.
+namespace margelo::nitro::ar { class HybridARMeasurementSpec; }
+// Forward declaration of `HybridARMeshAnchorSpec` to properly resolve imports.
+namespace margelo::nitro::ar { class HybridARMeshAnchorSpec; }
+// Forward declaration of `HybridARPlaneAnchorSpec` to properly resolve imports.
+namespace margelo::nitro::ar { class HybridARPlaneAnchorSpec; }
+// Forward declaration of `HybridARPlaneGeometrySpec` to properly resolve imports.
+namespace margelo::nitro::ar { class HybridARPlaneGeometrySpec; }
+// Forward declaration of `HybridARRaycastResultSpec` to properly resolve imports.
+namespace margelo::nitro::ar { class HybridARRaycastResultSpec; }
+// Forward declaration of `HybridARSessionSpec` to properly resolve imports.
+namespace margelo::nitro::ar { class HybridARSessionSpec; }
+// Forward declaration of `HybridARViewSpec` to properly resolve imports.
+namespace margelo::nitro::ar { class HybridARViewSpec; }
+// Forward declaration of `HybridARVolumeSpec` to properly resolve imports.
+namespace margelo::nitro::ar { class HybridARVolumeSpec; }
+// 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; }
+// Forward declaration of `MeshClassification` to properly resolve imports.
+namespace margelo::nitro::ar { enum class MeshClassification; }
+// 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 `PlaneDetectionMode` to properly resolve imports.
+namespace margelo::nitro::ar { enum class PlaneDetectionMode; }
+// Forward declaration of `RaycastAlignment` to properly resolve imports.
+namespace margelo::nitro::ar { enum class RaycastAlignment; }
+// 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 `SceneReconstructionMode` to properly resolve imports.
+namespace margelo::nitro::ar { enum class SceneReconstructionMode; }
+// Forward declaration of `TrackingStateReason` to properly resolve imports.
+namespace margelo::nitro::ar { enum class TrackingStateReason; }
+// Forward declaration of `TrackingState` to properly resolve imports.
+namespace margelo::nitro::ar { enum class TrackingState; }
+// Forward declaration of `WorldAlignment` to properly resolve imports.
+namespace margelo::nitro::ar { enum class WorldAlignment; }
+// Forward declaration of `WorldMappingStatus` to properly resolve imports.
+namespace margelo::nitro::ar { enum class WorldMappingStatus; }
+
+// Include C++ defined types
+#include "ARSessionConfiguration.hpp"
+#include "ARViewHitResult.hpp"
+#include "CameraPose.hpp"
+#include "EnvironmentTexturing.hpp"
+#include "HybridARAnchorSpec.hpp"
+#include "HybridARBoundingBoxBuilderSpec.hpp"
+#include "HybridARDepthDataSpec.hpp"
+#include "HybridARDirectionalLightEstimateSpec.hpp"
+#include "HybridARFrameSpec.hpp"
+#include "HybridARLightEstimateSpec.hpp"
+#include "HybridARMeasurementSpec.hpp"
+#include "HybridARMeshAnchorSpec.hpp"
+#include "HybridARPlaneAnchorSpec.hpp"
+#include "HybridARPlaneGeometrySpec.hpp"
+#include "HybridARRaycastResultSpec.hpp"
+#include "HybridARSessionSpec.hpp"
+#include "HybridARViewSpec.hpp"
+#include "HybridARVolumeSpec.hpp"
+#include "HybridARWorldMapSpec.hpp"
+#include "LiDARCapabilities.hpp"
+#include "MeshClassification.hpp"
+#include "PlaneAlignment.hpp"
+#include "PlaneClassification.hpp"
+#include "PlaneDetectionMode.hpp"
+#include "RaycastAlignment.hpp"
+#include "RaycastQuery.hpp"
+#include "RaycastTarget.hpp"
+#include "SceneReconstructionMode.hpp"
+#include "TrackingState.hpp"
+#include "TrackingStateReason.hpp"
+#include "WorldAlignment.hpp"
+#include "WorldMappingStatus.hpp"
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/Result.hpp>
+#include <exception>
+#include <functional>
+#include <memory>
+#include <optional>
+#include <string>
+#include <vector>
+
+// C++ helpers for Swift
+#include "NitroAR-Swift-Cxx-Bridge.hpp"
+
+// Common C++ types used in Swift
+#include <NitroModules/ArrayBufferHolder.hpp>
+#include <NitroModules/AnyMapUtils.hpp>
+#include <NitroModules/RuntimeError.hpp>
+#include <NitroModules/DateToChronoDate.hpp>
+
+// Forward declarations of Swift defined types
+// Forward declaration of `HybridARAnchorSpec_cxx` to properly resolve imports.
+namespace NitroAR { class HybridARAnchorSpec_cxx; }
+// Forward declaration of `HybridARBoundingBoxBuilderSpec_cxx` to properly resolve imports.
+namespace NitroAR { class HybridARBoundingBoxBuilderSpec_cxx; }
+// Forward declaration of `HybridARDepthDataSpec_cxx` to properly resolve imports.
+namespace NitroAR { class HybridARDepthDataSpec_cxx; }
+// Forward declaration of `HybridARDirectionalLightEstimateSpec_cxx` to properly resolve imports.
+namespace NitroAR { class HybridARDirectionalLightEstimateSpec_cxx; }
+// Forward declaration of `HybridARFrameSpec_cxx` to properly resolve imports.
+namespace NitroAR { class HybridARFrameSpec_cxx; }
+// Forward declaration of `HybridARLightEstimateSpec_cxx` to properly resolve imports.
+namespace NitroAR { class HybridARLightEstimateSpec_cxx; }
+// Forward declaration of `HybridARMeasurementSpec_cxx` to properly resolve imports.
+namespace NitroAR { class HybridARMeasurementSpec_cxx; }
+// Forward declaration of `HybridARMeshAnchorSpec_cxx` to properly resolve imports.
+namespace NitroAR { class HybridARMeshAnchorSpec_cxx; }
+// Forward declaration of `HybridARPlaneAnchorSpec_cxx` to properly resolve imports.
+namespace NitroAR { class HybridARPlaneAnchorSpec_cxx; }
+// Forward declaration of `HybridARPlaneGeometrySpec_cxx` to properly resolve imports.
+namespace NitroAR { class HybridARPlaneGeometrySpec_cxx; }
+// Forward declaration of `HybridARRaycastResultSpec_cxx` to properly resolve imports.
+namespace NitroAR { class HybridARRaycastResultSpec_cxx; }
+// Forward declaration of `HybridARSessionSpec_cxx` to properly resolve imports.
+namespace NitroAR { class HybridARSessionSpec_cxx; }
+// Forward declaration of `HybridARViewSpec_cxx` to properly resolve imports.
+namespace NitroAR { class HybridARViewSpec_cxx; }
+// Forward declaration of `HybridARVolumeSpec_cxx` to properly resolve imports.
+namespace NitroAR { class HybridARVolumeSpec_cxx; }
+// Forward declaration of `HybridARWorldMapSpec_cxx` to properly resolve imports.
+namespace NitroAR { class HybridARWorldMapSpec_cxx; }
+
+// Include Swift defined types
+#if __has_include("NitroAR-Swift.h")
+// This header is generated by Xcode/Swift on every app build.
+// If it cannot be found, make sure the Swift module's name (= podspec name) is actually "NitroAR".
+#include "NitroAR-Swift.h"
+// Same as above, but used when building with frameworks (`use_frameworks`)
+#elif __has_include(<NitroAR/NitroAR-Swift.h>)
+#include <NitroAR/NitroAR-Swift.h>
+#else
+#error NitroAR's autogenerated Swift header cannot be found! Make sure the Swift module's name (= podspec name) is actually "NitroAR", and try building the app first.
+#endif

package/nitrogen/generated/ios/NitroARAutolinking.mm

@@ -0,0 +1,49 @@
+///
+/// NitroARAutolinking.mm
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#import <Foundation/Foundation.h>
+#import <NitroModules/HybridObjectRegistry.hpp>
+#import "NitroAR-Swift-Cxx-Umbrella.hpp"
+#import <type_traits>
+
+#include "HybridARSessionSpecSwift.hpp"
+#include "HybridARBoundingBoxBuilderSpecSwift.hpp"
+#include "HybridARViewSpecSwift.hpp"
+
+@interface NitroARAutolinking : NSObject
+@end
+
+@implementation NitroARAutolinking
+
++ (void) load {
+  using namespace margelo::nitro;
+  using namespace margelo::nitro::ar;
+
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "ARSession",
+    []() -> std::shared_ptr<HybridObject> {
+      std::shared_ptr<HybridARSessionSpec> hybridObject = NitroAR::NitroARAutolinking::createARSession();
+      return hybridObject;
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "ARBoundingBoxBuilder",
+    []() -> std::shared_ptr<HybridObject> {
+      std::shared_ptr<HybridARBoundingBoxBuilderSpec> hybridObject = NitroAR::NitroARAutolinking::createARBoundingBoxBuilder();
+      return hybridObject;
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "ARView",
+    []() -> std::shared_ptr<HybridObject> {
+      std::shared_ptr<HybridARViewSpec> hybridObject = NitroAR::NitroARAutolinking::createARView();
+      return hybridObject;
+    }
+  );
+}
+
+@end

package/nitrogen/generated/ios/NitroARAutolinking.swift

@@ -0,0 +1,50 @@
+///
+/// NitroARAutolinking.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+// TODO: Use empty enums once Swift supports exporting them as namespaces
+//       See: https://github.com/swiftlang/swift/pull/83616
+public final class NitroARAutolinking {
+  public typealias bridge = margelo.nitro.ar.bridge.swift
+
+  public static func createARSession() -> bridge.std__shared_ptr_HybridARSessionSpec_ {
+    let hybridObject = HybridARSession()
+    return { () -> bridge.std__shared_ptr_HybridARSessionSpec_ in
+      let __cxxWrapped = hybridObject.getCxxWrapper()
+      return __cxxWrapped.getCxxPart()
+    }()
+  }
+  
+  public static func isARSessionRecyclable() -> Bool {
+    return HybridARSession.self is any RecyclableView.Type
+  }
+  
+  public static func createARBoundingBoxBuilder() -> bridge.std__shared_ptr_HybridARBoundingBoxBuilderSpec_ {
+    let hybridObject = HybridARBoundingBoxBuilder()
+    return { () -> bridge.std__shared_ptr_HybridARBoundingBoxBuilderSpec_ in
+      let __cxxWrapped = hybridObject.getCxxWrapper()
+      return __cxxWrapped.getCxxPart()
+    }()
+  }
+  
+  public static func isARBoundingBoxBuilderRecyclable() -> Bool {
+    return HybridARBoundingBoxBuilder.self is any RecyclableView.Type
+  }
+  
+  public static func createARView() -> bridge.std__shared_ptr_HybridARViewSpec_ {
+    let hybridObject = HybridARView()
+    return { () -> bridge.std__shared_ptr_HybridARViewSpec_ in
+      let __cxxWrapped = hybridObject.getCxxWrapper()
+      return __cxxWrapped.getCxxPart()
+    }()
+  }
+  
+  public static func isARViewRecyclable() -> Bool {
+    return HybridARView.self is any RecyclableView.Type
+  }
+}

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

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

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

@@ -0,0 +1,99 @@
+///
+/// HybridARAnchorSpecSwift.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include "HybridARAnchorSpec.hpp"
+
+// Forward declaration of `HybridARAnchorSpec_cxx` to properly resolve imports.
+namespace NitroAR { class HybridARAnchorSpec_cxx; }
+
+
+
+#include <string>
+#include <vector>
+#include <optional>
+
+#include "NitroAR-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::ar {
+
+  /**
+   * The C++ part of HybridARAnchorSpec_cxx.swift.
+   *
+   * HybridARAnchorSpecSwift (C++) accesses HybridARAnchorSpec_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, HybridARAnchorSpec_cxx can directly inherit from the C++ class HybridARAnchorSpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridARAnchorSpecSwift: public virtual HybridARAnchorSpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridARAnchorSpecSwift(const NitroAR::HybridARAnchorSpec_cxx& swiftPart):
+      HybridObject(HybridARAnchorSpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline NitroAR::HybridARAnchorSpec_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<HybridARAnchorSpecSwift>(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::string getIdentifier() noexcept override {
+      auto __result = _swiftPart.getIdentifier();
+      return __result;
+    }
+    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 std::vector<double> getTransform() noexcept override {
+      auto __result = _swiftPart.getTransform();
+      return __result;
+    }
+    inline bool getIsTracked() noexcept override {
+      return _swiftPart.isTracked();
+    }
+    inline std::optional<std::string> getLabel() noexcept override {
+      auto __result = _swiftPart.getLabel();
+      return __result;
+    }
+
+  public:
+    // Methods
+    
+
+  private:
+    NitroAR::HybridARAnchorSpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::ar

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

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

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

@@ -0,0 +1,95 @@
+///
+/// HybridARBoundingBoxBuilderSpecSwift.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include "HybridARBoundingBoxBuilderSpec.hpp"
+
+// Forward declaration of `HybridARBoundingBoxBuilderSpec_cxx` to properly resolve imports.
+namespace NitroAR { class HybridARBoundingBoxBuilderSpec_cxx; }
+
+// 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"
+
+#include "NitroAR-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::ar {
+
+  /**
+   * The C++ part of HybridARBoundingBoxBuilderSpec_cxx.swift.
+   *
+   * HybridARBoundingBoxBuilderSpecSwift (C++) accesses HybridARBoundingBoxBuilderSpec_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, HybridARBoundingBoxBuilderSpec_cxx can directly inherit from the C++ class HybridARBoundingBoxBuilderSpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridARBoundingBoxBuilderSpecSwift: public virtual HybridARBoundingBoxBuilderSpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridARBoundingBoxBuilderSpecSwift(const NitroAR::HybridARBoundingBoxBuilderSpec_cxx& swiftPart):
+      HybridObject(HybridARBoundingBoxBuilderSpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline NitroAR::HybridARBoundingBoxBuilderSpec_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<HybridARBoundingBoxBuilderSpecSwift>(other)) {
+        return _swiftPart.equals(otherCast->_swiftPart);
+      }
+      return false;
+    }
+    void dispose() noexcept override {
+      _swiftPart.dispose();
+    }
+    std::string toString() override {
+      return _swiftPart.toString();
+    }
+
+  public:
+    // Properties
+    inline bool getCanBuild() noexcept override {
+      return _swiftPart.getCanBuild();
+    }
+
+  public:
+    // Methods
+    inline void addBaseAnchor(const std::shared_ptr<HybridARAnchorSpec>& anchor) override {
+      auto __result = _swiftPart.addBaseAnchor(anchor);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline std::shared_ptr<HybridARVolumeSpec> build() override {
+      auto __result = _swiftPart.build();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+
+  private:
+    NitroAR::HybridARBoundingBoxBuilderSpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::ar

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

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

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

@@ -0,0 +1,103 @@
+///
+/// HybridARDepthDataSpecSwift.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include "HybridARDepthDataSpec.hpp"
+
+// Forward declaration of `HybridARDepthDataSpec_cxx` to properly resolve imports.
+namespace NitroAR { class HybridARDepthDataSpec_cxx; }
+
+
+
+#include <vector>
+
+#include "NitroAR-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::ar {
+
+  /**
+   * The C++ part of HybridARDepthDataSpec_cxx.swift.
+   *
+   * HybridARDepthDataSpecSwift (C++) accesses HybridARDepthDataSpec_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, HybridARDepthDataSpec_cxx can directly inherit from the C++ class HybridARDepthDataSpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridARDepthDataSpecSwift: public virtual HybridARDepthDataSpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridARDepthDataSpecSwift(const NitroAR::HybridARDepthDataSpec_cxx& swiftPart):
+      HybridObject(HybridARDepthDataSpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline NitroAR::HybridARDepthDataSpec_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<HybridARDepthDataSpecSwift>(other)) {
+        return _swiftPart.equals(otherCast->_swiftPart);
+      }
+      return false;
+    }
+    void dispose() noexcept override {
+      _swiftPart.dispose();
+    }
+    std::string toString() override {
+      return _swiftPart.toString();
+    }
+
+  public:
+    // Properties
+    inline double getWidth() noexcept override {
+      return _swiftPart.getWidth();
+    }
+    inline double getHeight() noexcept override {
+      return _swiftPart.getHeight();
+    }
+    inline std::vector<double> getDepthMap() noexcept override {
+      auto __result = _swiftPart.getDepthMap();
+      return __result;
+    }
+    inline std::vector<double> getConfidenceMap() noexcept override {
+      auto __result = _swiftPart.getConfidenceMap();
+      return __result;
+    }
+
+  public:
+    // Methods
+    inline double getDepthAt(double x, double y) override {
+      auto __result = _swiftPart.getDepthAt(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 double getConfidenceAt(double x, double y) override {
+      auto __result = _swiftPart.getConfidenceAt(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;
+    }
+
+  private:
+    NitroAR::HybridARDepthDataSpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::ar

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

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