react-native-nitro-ar 2026.2.1

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

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

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

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

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

@@ -0,0 +1,135 @@
+///
+/// HybridARFrameSpecSwift.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include "HybridARFrameSpec.hpp"
+
+// Forward declaration of `HybridARFrameSpec_cxx` to properly resolve imports.
+namespace NitroAR { class HybridARFrameSpec_cxx; }
+
+// 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>
+
+#include "NitroAR-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::ar {
+
+  /**
+   * The C++ part of HybridARFrameSpec_cxx.swift.
+   *
+   * HybridARFrameSpecSwift (C++) accesses HybridARFrameSpec_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, HybridARFrameSpec_cxx can directly inherit from the C++ class HybridARFrameSpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridARFrameSpecSwift: public virtual HybridARFrameSpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridARFrameSpecSwift(const NitroAR::HybridARFrameSpec_cxx& swiftPart):
+      HybridObject(HybridARFrameSpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline NitroAR::HybridARFrameSpec_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<HybridARFrameSpecSwift>(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 getTimestamp() noexcept override {
+      return _swiftPart.getTimestamp();
+    }
+    inline std::vector<double> getCameraPosition() noexcept override {
+      auto __result = _swiftPart.getCameraPosition();
+      return __result;
+    }
+    inline std::vector<double> getCameraRotation() noexcept override {
+      auto __result = _swiftPart.getCameraRotation();
+      return __result;
+    }
+    inline std::vector<double> getProjectionMatrix() noexcept override {
+      auto __result = _swiftPart.getProjectionMatrix();
+      return __result;
+    }
+    inline std::vector<double> getViewMatrix() noexcept override {
+      auto __result = _swiftPart.getViewMatrix();
+      return __result;
+    }
+    inline std::vector<double> getCameraIntrinsics() noexcept override {
+      auto __result = _swiftPart.getCameraIntrinsics();
+      return __result;
+    }
+    inline std::vector<double> getImageResolution() noexcept override {
+      auto __result = _swiftPart.getImageResolution();
+      return __result;
+    }
+    inline std::optional<std::shared_ptr<HybridARLightEstimateSpec>> getLightEstimate() noexcept override {
+      auto __result = _swiftPart.getLightEstimate();
+      return __result;
+    }
+    inline std::optional<std::shared_ptr<HybridARDirectionalLightEstimateSpec>> getDirectionalLightEstimate() noexcept override {
+      auto __result = _swiftPart.getDirectionalLightEstimate();
+      return __result;
+    }
+    inline std::optional<std::shared_ptr<HybridARDepthDataSpec>> getSceneDepth() noexcept override {
+      auto __result = _swiftPart.getSceneDepth();
+      return __result;
+    }
+    inline std::optional<std::shared_ptr<HybridARDepthDataSpec>> getSmoothedSceneDepth() noexcept override {
+      auto __result = _swiftPart.getSmoothedSceneDepth();
+      return __result;
+    }
+
+  public:
+    // Methods
+    inline std::string getCapturedImage(double quality) override {
+      auto __result = _swiftPart.getCapturedImage(std::forward<decltype(quality)>(quality));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+
+  private:
+    NitroAR::HybridARFrameSpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::ar

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,116 @@
+///
+/// HybridARPlaneAnchorSpecSwift.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include "HybridARPlaneAnchorSpec.hpp"
+
+// Forward declaration of `HybridARPlaneAnchorSpec_cxx` to properly resolve imports.
+namespace NitroAR { class HybridARPlaneAnchorSpec_cxx; }
+
+// 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"
+
+#include "NitroAR-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::ar {
+
+  /**
+   * The C++ part of HybridARPlaneAnchorSpec_cxx.swift.
+   *
+   * HybridARPlaneAnchorSpecSwift (C++) accesses HybridARPlaneAnchorSpec_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, HybridARPlaneAnchorSpec_cxx can directly inherit from the C++ class HybridARPlaneAnchorSpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridARPlaneAnchorSpecSwift: public virtual HybridARPlaneAnchorSpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridARPlaneAnchorSpecSwift(const NitroAR::HybridARPlaneAnchorSpec_cxx& swiftPart):
+      HybridObject(HybridARPlaneAnchorSpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline NitroAR::HybridARPlaneAnchorSpec_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<HybridARPlaneAnchorSpecSwift>(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 PlaneAlignment getAlignment() noexcept override {
+      auto __result = _swiftPart.getAlignment();
+      return static_cast<PlaneAlignment>(__result);
+    }
+    inline PlaneClassification getClassification() noexcept override {
+      auto __result = _swiftPart.getClassification();
+      return static_cast<PlaneClassification>(__result);
+    }
+    inline std::vector<double> getExtent() noexcept override {
+      auto __result = _swiftPart.getExtent();
+      return __result;
+    }
+    inline std::vector<double> getCenter() noexcept override {
+      auto __result = _swiftPart.getCenter();
+      return __result;
+    }
+    inline std::shared_ptr<HybridARPlaneGeometrySpec> getGeometry() noexcept override {
+      auto __result = _swiftPart.getGeometry();
+      return __result;
+    }
+
+  public:
+    // Methods
+    
+
+  private:
+    NitroAR::HybridARPlaneAnchorSpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::ar

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

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