react-native-cesium 1.2.3 → 1.2.5

package/nitrogen/generated/ios/ReactNativeCesium-Swift-Cxx-Bridge.hpp

@@ -108,40 +108,55 @@ namespace margelo::nitro::reactnativecesium::bridge::swift {
     return optional.value();
   }
   
-  // pragma MARK: std::shared_ptr<Promise<CameraState>>
-  /**
-   * Specialized version of `std::shared_ptr<Promise<CameraState>>`.
-   */
-  using std__shared_ptr_Promise_CameraState__ = std::shared_ptr<Promise<CameraState>>;
-  inline std::shared_ptr<Promise<CameraState>> create_std__shared_ptr_Promise_CameraState__() noexcept {
-    return Promise<CameraState>::create();
-  }
-  inline PromiseHolder<CameraState> wrap_std__shared_ptr_Promise_CameraState__(std::shared_ptr<Promise<CameraState>> promise) noexcept {
-    return PromiseHolder<CameraState>(std::move(promise));
-  }
-  
-  // pragma MARK: std::function<void(const CameraState& /* result */)>
+  // pragma MARK: std::function<void(const CameraState& /* camera */)>
   /**
    * Specialized version of `std::function<void(const CameraState&)>`.
    */
-  using Func_void_CameraState = std::function<void(const CameraState& /* result */)>;
+  using Func_void_CameraState = std::function<void(const CameraState& /* camera */)>;
   /**
-   * Wrapper class for a `std::function<void(const CameraState& / * result * /)>`, this can be used from Swift.
+   * Wrapper class for a `std::function<void(const CameraState& / * camera * /)>`, this can be used from Swift.
    */
   class Func_void_CameraState_Wrapper final {
   public:
-    explicit Func_void_CameraState_Wrapper(std::function<void(const CameraState& /* result */)>&& func): _function(std::make_unique<std::function<void(const CameraState& /* result */)>>(std::move(func))) {}
-    inline void call(CameraState result) const noexcept {
-      _function->operator()(result);
+    explicit Func_void_CameraState_Wrapper(std::function<void(const CameraState& /* camera */)>&& func): _function(std::make_unique<std::function<void(const CameraState& /* camera */)>>(std::move(func))) {}
+    inline void call(CameraState camera) const noexcept {
+      _function->operator()(camera);
     }
   private:
-    std::unique_ptr<std::function<void(const CameraState& /* result */)>> _function;
+    std::unique_ptr<std::function<void(const CameraState& /* camera */)>> _function;
   } SWIFT_NONCOPYABLE;
   Func_void_CameraState create_Func_void_CameraState(void* NON_NULL swiftClosureWrapper) noexcept;
   inline Func_void_CameraState_Wrapper wrap_Func_void_CameraState(Func_void_CameraState value) noexcept {
     return Func_void_CameraState_Wrapper(std::move(value));
   }
   
+  // pragma MARK: std::optional<std::function<void(const CameraState& /* camera */)>>
+  /**
+   * Specialized version of `std::optional<std::function<void(const CameraState& / * camera * /)>>`.
+   */
+  using std__optional_std__function_void_const_CameraState_____camera______ = std::optional<std::function<void(const CameraState& /* camera */)>>;
+  inline std::optional<std::function<void(const CameraState& /* camera */)>> create_std__optional_std__function_void_const_CameraState_____camera______(const std::function<void(const CameraState& /* camera */)>& value) noexcept {
+    return std::optional<std::function<void(const CameraState& /* camera */)>>(value);
+  }
+  inline bool has_value_std__optional_std__function_void_const_CameraState_____camera______(const std::optional<std::function<void(const CameraState& /* camera */)>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::function<void(const CameraState& /* camera */)> get_std__optional_std__function_void_const_CameraState_____camera______(const std::optional<std::function<void(const CameraState& /* camera */)>>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<CameraState>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<CameraState>>`.
+   */
+  using std__shared_ptr_Promise_CameraState__ = std::shared_ptr<Promise<CameraState>>;
+  inline std::shared_ptr<Promise<CameraState>> create_std__shared_ptr_Promise_CameraState__() noexcept {
+    return Promise<CameraState>::create();
+  }
+  inline PromiseHolder<CameraState> wrap_std__shared_ptr_Promise_CameraState__(std::shared_ptr<Promise<CameraState>> promise) noexcept {
+    return PromiseHolder<CameraState>(std::move(promise));
+  }
+  
   // pragma MARK: std::function<void(const std::exception_ptr& /* error */)>
   /**
    * Specialized version of `std::function<void(const std::exception_ptr&)>`.
@@ -210,15 +225,6 @@ namespace margelo::nitro::reactnativecesium::bridge::swift {
   using std__weak_ptr_HybridCesiumViewSpec_ = std::weak_ptr<HybridCesiumViewSpec>;
   inline std__weak_ptr_HybridCesiumViewSpec_ weakify_std__shared_ptr_HybridCesiumViewSpec_(const std::shared_ptr<HybridCesiumViewSpec>& strong) noexcept { return strong; }
   
-  // pragma MARK: Result<std::shared_ptr<Promise<CameraState>>>
-  using Result_std__shared_ptr_Promise_CameraState___ = Result<std::shared_ptr<Promise<CameraState>>>;
-  inline Result_std__shared_ptr_Promise_CameraState___ create_Result_std__shared_ptr_Promise_CameraState___(const std::shared_ptr<Promise<CameraState>>& value) noexcept {
-    return Result<std::shared_ptr<Promise<CameraState>>>::withValue(value);
-  }
-  inline Result_std__shared_ptr_Promise_CameraState___ create_Result_std__shared_ptr_Promise_CameraState___(const std::exception_ptr& error) noexcept {
-    return Result<std::shared_ptr<Promise<CameraState>>>::withError(error);
-  }
-  
   // pragma MARK: Result<void>
   using Result_void_ = Result<void>;
   inline Result_void_ create_Result_void_() noexcept {
@@ -228,6 +234,15 @@ namespace margelo::nitro::reactnativecesium::bridge::swift {
     return Result<void>::withError(error);
   }
   
+  // pragma MARK: Result<std::shared_ptr<Promise<CameraState>>>
+  using Result_std__shared_ptr_Promise_CameraState___ = Result<std::shared_ptr<Promise<CameraState>>>;
+  inline Result_std__shared_ptr_Promise_CameraState___ create_Result_std__shared_ptr_Promise_CameraState___(const std::shared_ptr<Promise<CameraState>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<CameraState>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_CameraState___ create_Result_std__shared_ptr_Promise_CameraState___(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<CameraState>>>::withError(error);
+  }
+  
   // pragma MARK: Result<std::shared_ptr<Promise<Quaternion>>>
   using Result_std__shared_ptr_Promise_Quaternion___ = Result<std::shared_ptr<Promise<Quaternion>>>;
   inline Result_std__shared_ptr_Promise_Quaternion___ create_Result_std__shared_ptr_Promise_Quaternion___(const std::shared_ptr<Promise<Quaternion>>& value) noexcept {

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

@@ -24,8 +24,8 @@ namespace margelo::nitro::reactnativecesium { struct Quaternion; }
 #include <optional>
 #include "CesiumMetrics.hpp"
 #include <functional>
-#include <NitroModules/Promise.hpp>
 #include "Quaternion.hpp"
+#include <NitroModules/Promise.hpp>
 
 #include "ReactNativeCesium-Swift-Cxx-Umbrella.hpp"
 
@@ -219,6 +219,41 @@ namespace margelo::nitro::reactnativecesium {
     inline void setMinAltitudeAboveTerrain(std::optional<double> minAltitudeAboveTerrain) noexcept override {
       _swiftPart.setMinAltitudeAboveTerrain(minAltitudeAboveTerrain);
     }
+    inline std::optional<double> getMaxYawRateDegSec() noexcept override {
+      auto __result = _swiftPart.getMaxYawRateDegSec();
+      return __result;
+    }
+    inline void setMaxYawRateDegSec(std::optional<double> maxYawRateDegSec) noexcept override {
+      _swiftPart.setMaxYawRateDegSec(maxYawRateDegSec);
+    }
+    inline std::optional<double> getMaxPitchRateDegSec() noexcept override {
+      auto __result = _swiftPart.getMaxPitchRateDegSec();
+      return __result;
+    }
+    inline void setMaxPitchRateDegSec(std::optional<double> maxPitchRateDegSec) noexcept override {
+      _swiftPart.setMaxPitchRateDegSec(maxPitchRateDegSec);
+    }
+    inline std::optional<double> getMaxRollRateDegSec() noexcept override {
+      auto __result = _swiftPart.getMaxRollRateDegSec();
+      return __result;
+    }
+    inline void setMaxRollRateDegSec(std::optional<double> maxRollRateDegSec) noexcept override {
+      _swiftPart.setMaxRollRateDegSec(maxRollRateDegSec);
+    }
+    inline std::optional<double> getMaxClimbRateMps() noexcept override {
+      auto __result = _swiftPart.getMaxClimbRateMps();
+      return __result;
+    }
+    inline void setMaxClimbRateMps(std::optional<double> maxClimbRateMps) noexcept override {
+      _swiftPart.setMaxClimbRateMps(maxClimbRateMps);
+    }
+    inline std::optional<double> getMaxGroundSpeedMps() noexcept override {
+      auto __result = _swiftPart.getMaxGroundSpeedMps();
+      return __result;
+    }
+    inline void setMaxGroundSpeedMps(std::optional<double> maxGroundSpeedMps) noexcept override {
+      _swiftPart.setMaxGroundSpeedMps(maxGroundSpeedMps);
+    }
     inline std::optional<std::function<void(const CesiumMetrics& /* metrics */)>> getOnMetrics() noexcept override {
       auto __result = _swiftPart.getOnMetrics();
       return __result;
@@ -226,29 +261,74 @@ namespace margelo::nitro::reactnativecesium {
     inline void setOnMetrics(const std::optional<std::function<void(const CesiumMetrics& /* metrics */)>>& onMetrics) noexcept override {
       _swiftPart.setOnMetrics(onMetrics);
     }
+    inline std::optional<std::function<void(const CameraState& /* camera */)>> getOnActualCamera() noexcept override {
+      auto __result = _swiftPart.getOnActualCamera();
+      return __result;
+    }
+    inline void setOnActualCamera(const std::optional<std::function<void(const CameraState& /* camera */)>>& onActualCamera) noexcept override {
+      _swiftPart.setOnActualCamera(onActualCamera);
+    }
 
   public:
     // Methods
-    inline std::shared_ptr<Promise<CameraState>> getCameraState() override {
-      auto __result = _swiftPart.getCameraState();
+    inline void setPosition(double latitude, double longitude) override {
+      auto __result = _swiftPart.setPosition(std::forward<decltype(latitude)>(latitude), std::forward<decltype(longitude)>(longitude));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void setAltitude(double altitudeMeters) override {
+      auto __result = _swiftPart.setAltitude(std::forward<decltype(altitudeMeters)>(altitudeMeters));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void setHeading(double headingDeg) override {
+      auto __result = _swiftPart.setHeading(std::forward<decltype(headingDeg)>(headingDeg));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void setAttitude(double pitchDeg, double rollDeg) override {
+      auto __result = _swiftPart.setAttitude(std::forward<decltype(pitchDeg)>(pitchDeg), std::forward<decltype(rollDeg)>(rollDeg));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void setViewCorrection(const Quaternion& q) override {
+      auto __result = _swiftPart.setViewCorrection(std::forward<decltype(q)>(q));
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
       }
-      auto __value = std::move(__result.value());
-      return __value;
     }
-    inline void setCamera(const CameraState& camera) override {
-      auto __result = _swiftPart.setCamera(std::forward<decltype(camera)>(camera));
+    inline void setVerticalFov(double deg) override {
+      auto __result = _swiftPart.setVerticalFov(std::forward<decltype(deg)>(deg));
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
       }
     }
-    inline void setCameraQuaternion(const CameraState& camera, const Quaternion& viewCorrection) override {
-      auto __result = _swiftPart.setCameraQuaternion(std::forward<decltype(camera)>(camera), std::forward<decltype(viewCorrection)>(viewCorrection));
+    inline void teleport(const CameraState& camera) override {
+      auto __result = _swiftPart.teleport(std::forward<decltype(camera)>(camera));
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
       }
     }
+    inline std::shared_ptr<Promise<CameraState>> getActualCamera() override {
+      auto __result = _swiftPart.getActualCamera();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<CameraState>> getDemandCamera() override {
+      auto __result = _swiftPart.getDemandCamera();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
     inline std::shared_ptr<Promise<Quaternion>> getViewCorrection() override {
       auto __result = _swiftPart.getViewCorrection();
       if (__result.hasError()) [[unlikely]] {

package/nitrogen/generated/ios/c++/views/HybridCesiumViewComponent.mm

@@ -189,11 +189,41 @@ using namespace margelo::nitro::reactnativecesium::views;
     swiftPart.setMinAltitudeAboveTerrain(newViewProps.minAltitudeAboveTerrain.value);
     newViewProps.minAltitudeAboveTerrain.isDirty = false;
   }
+  // maxYawRateDegSec: optional
+  if (newViewProps.maxYawRateDegSec.isDirty) {
+    swiftPart.setMaxYawRateDegSec(newViewProps.maxYawRateDegSec.value);
+    newViewProps.maxYawRateDegSec.isDirty = false;
+  }
+  // maxPitchRateDegSec: optional
+  if (newViewProps.maxPitchRateDegSec.isDirty) {
+    swiftPart.setMaxPitchRateDegSec(newViewProps.maxPitchRateDegSec.value);
+    newViewProps.maxPitchRateDegSec.isDirty = false;
+  }
+  // maxRollRateDegSec: optional
+  if (newViewProps.maxRollRateDegSec.isDirty) {
+    swiftPart.setMaxRollRateDegSec(newViewProps.maxRollRateDegSec.value);
+    newViewProps.maxRollRateDegSec.isDirty = false;
+  }
+  // maxClimbRateMps: optional
+  if (newViewProps.maxClimbRateMps.isDirty) {
+    swiftPart.setMaxClimbRateMps(newViewProps.maxClimbRateMps.value);
+    newViewProps.maxClimbRateMps.isDirty = false;
+  }
+  // maxGroundSpeedMps: optional
+  if (newViewProps.maxGroundSpeedMps.isDirty) {
+    swiftPart.setMaxGroundSpeedMps(newViewProps.maxGroundSpeedMps.value);
+    newViewProps.maxGroundSpeedMps.isDirty = false;
+  }
   // onMetrics: optional
   if (newViewProps.onMetrics.isDirty) {
     swiftPart.setOnMetrics(newViewProps.onMetrics.value);
     newViewProps.onMetrics.isDirty = false;
   }
+  // onActualCamera: optional
+  if (newViewProps.onActualCamera.isDirty) {
+    swiftPart.setOnActualCamera(newViewProps.onActualCamera.value);
+    newViewProps.onActualCamera.isDirty = false;
+  }
 
   swiftPart.afterUpdate();
 

package/nitrogen/generated/ios/swift/Func_void_CameraState.swift

@@ -8,21 +8,21 @@
 import NitroModules
 
 /**
- * Wraps a Swift `(_ value: CameraState) -> Void` as a class.
+ * Wraps a Swift `(_ camera: CameraState) -> Void` as a class.
  * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`.
  */
 public final class Func_void_CameraState {
   public typealias bridge = margelo.nitro.reactnativecesium.bridge.swift
 
-  private let closure: (_ value: CameraState) -> Void
+  private let closure: (_ camera: CameraState) -> Void
 
-  public init(_ closure: @escaping (_ value: CameraState) -> Void) {
+  public init(_ closure: @escaping (_ camera: CameraState) -> Void) {
     self.closure = closure
   }
 
   @inline(__always)
-  public func call(value: CameraState) -> Void {
-    self.closure(value)
+  public func call(camera: CameraState) -> Void {
+    self.closure(camera)
   }
 
   /**

package/nitrogen/generated/ios/swift/HybridCesiumViewSpec.swift

@@ -32,12 +32,24 @@ public protocol HybridCesiumViewSpec_protocol: HybridObject, HybridView {
   var sqliteCacheMaxRows: Double? { get set }
   var taskProcessorThreads: Double? { get set }
   var minAltitudeAboveTerrain: Double? { get set }
+  var maxYawRateDegSec: Double? { get set }
+  var maxPitchRateDegSec: Double? { get set }
+  var maxRollRateDegSec: Double? { get set }
+  var maxClimbRateMps: Double? { get set }
+  var maxGroundSpeedMps: Double? { get set }
   var onMetrics: ((_ metrics: CesiumMetrics) -> Void)? { get set }
+  var onActualCamera: ((_ camera: CameraState) -> Void)? { get set }
 
   // Methods
-  func getCameraState() throws -> Promise<CameraState>
-  func setCamera(camera: CameraState) throws -> Void
-  func setCameraQuaternion(camera: CameraState, viewCorrection: Quaternion) throws -> Void
+  func setPosition(latitude: Double, longitude: Double) throws -> Void
+  func setAltitude(altitudeMeters: Double) throws -> Void
+  func setHeading(headingDeg: Double) throws -> Void
+  func setAttitude(pitchDeg: Double, rollDeg: Double) throws -> Void
+  func setViewCorrection(q: Quaternion) throws -> Void
+  func setVerticalFov(deg: Double) throws -> Void
+  func teleport(camera: CameraState) throws -> Void
+  func getActualCamera() throws -> Promise<CameraState>
+  func getDemandCamera() throws -> Promise<CameraState>
   func getViewCorrection() throws -> Promise<Quaternion>
 }
 

package/nitrogen/generated/ios/swift/HybridCesiumViewSpec_cxx.swift

@@ -532,6 +532,126 @@ open class HybridCesiumViewSpec_cxx {
     }
   }
   
+  public final var maxYawRateDegSec: bridge.std__optional_double_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_double_ in
+        if let __unwrappedValue = self.__implementation.maxYawRateDegSec {
+          return bridge.create_std__optional_double_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.maxYawRateDegSec = { () -> Double? in
+        if bridge.has_value_std__optional_double_(newValue) {
+          let __unwrapped = bridge.get_std__optional_double_(newValue)
+          return __unwrapped
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+  
+  public final var maxPitchRateDegSec: bridge.std__optional_double_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_double_ in
+        if let __unwrappedValue = self.__implementation.maxPitchRateDegSec {
+          return bridge.create_std__optional_double_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.maxPitchRateDegSec = { () -> Double? in
+        if bridge.has_value_std__optional_double_(newValue) {
+          let __unwrapped = bridge.get_std__optional_double_(newValue)
+          return __unwrapped
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+  
+  public final var maxRollRateDegSec: bridge.std__optional_double_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_double_ in
+        if let __unwrappedValue = self.__implementation.maxRollRateDegSec {
+          return bridge.create_std__optional_double_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.maxRollRateDegSec = { () -> Double? in
+        if bridge.has_value_std__optional_double_(newValue) {
+          let __unwrapped = bridge.get_std__optional_double_(newValue)
+          return __unwrapped
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+  
+  public final var maxClimbRateMps: bridge.std__optional_double_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_double_ in
+        if let __unwrappedValue = self.__implementation.maxClimbRateMps {
+          return bridge.create_std__optional_double_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.maxClimbRateMps = { () -> Double? in
+        if bridge.has_value_std__optional_double_(newValue) {
+          let __unwrapped = bridge.get_std__optional_double_(newValue)
+          return __unwrapped
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+  
+  public final var maxGroundSpeedMps: bridge.std__optional_double_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_double_ in
+        if let __unwrappedValue = self.__implementation.maxGroundSpeedMps {
+          return bridge.create_std__optional_double_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.maxGroundSpeedMps = { () -> Double? in
+        if bridge.has_value_std__optional_double_(newValue) {
+          let __unwrapped = bridge.get_std__optional_double_(newValue)
+          return __unwrapped
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+  
   public final var onMetrics: bridge.std__optional_std__function_void_const_CesiumMetrics_____metrics______ {
     @inline(__always)
     get {
@@ -563,31 +683,66 @@ open class HybridCesiumViewSpec_cxx {
       }()
     }
   }
+  
+  public final var onActualCamera: bridge.std__optional_std__function_void_const_CameraState_____camera______ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_std__function_void_const_CameraState_____camera______ in
+        if let __unwrappedValue = self.__implementation.onActualCamera {
+          return bridge.create_std__optional_std__function_void_const_CameraState_____camera______({ () -> bridge.Func_void_CameraState in
+            let __closureWrapper = Func_void_CameraState(__unwrappedValue)
+            return bridge.create_Func_void_CameraState(__closureWrapper.toUnsafe())
+          }())
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.onActualCamera = { () -> ((_ camera: CameraState) -> Void)? in
+        if bridge.has_value_std__optional_std__function_void_const_CameraState_____camera______(newValue) {
+          let __unwrapped = bridge.get_std__optional_std__function_void_const_CameraState_____camera______(newValue)
+          return { () -> (CameraState) -> Void in
+            let __wrappedFunction = bridge.wrap_Func_void_CameraState(__unwrapped)
+            return { (__camera: CameraState) -> Void in
+              __wrappedFunction.call(__camera)
+            }
+          }()
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
 
   // Methods
   @inline(__always)
-  public final func getCameraState() -> bridge.Result_std__shared_ptr_Promise_CameraState___ {
+  public final func setPosition(latitude: Double, longitude: Double) -> bridge.Result_void_ {
     do {
-      let __result = try self.__implementation.getCameraState()
-      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_CameraState__ in
-        let __promise = bridge.create_std__shared_ptr_Promise_CameraState__()
-        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_CameraState__(__promise)
-        __result
-          .then({ __result in __promiseHolder.resolve(__result) })
-          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
-        return __promise
-      }()
-      return bridge.create_Result_std__shared_ptr_Promise_CameraState___(__resultCpp)
+      try self.__implementation.setPosition(latitude: latitude, longitude: longitude)
+      return bridge.create_Result_void_()
     } catch (let __error) {
       let __exceptionPtr = __error.toCpp()
-      return bridge.create_Result_std__shared_ptr_Promise_CameraState___(__exceptionPtr)
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func setAltitude(altitudeMeters: Double) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.setAltitude(altitudeMeters: altitudeMeters)
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public final func setCamera(camera: CameraState) -> bridge.Result_void_ {
+  public final func setHeading(headingDeg: Double) -> bridge.Result_void_ {
     do {
-      try self.__implementation.setCamera(camera: camera)
+      try self.__implementation.setHeading(headingDeg: headingDeg)
       return bridge.create_Result_void_()
     } catch (let __error) {
       let __exceptionPtr = __error.toCpp()
@@ -596,9 +751,9 @@ open class HybridCesiumViewSpec_cxx {
   }
   
   @inline(__always)
-  public final func setCameraQuaternion(camera: CameraState, viewCorrection: Quaternion) -> bridge.Result_void_ {
+  public final func setAttitude(pitchDeg: Double, rollDeg: Double) -> bridge.Result_void_ {
     do {
-      try self.__implementation.setCameraQuaternion(camera: camera, viewCorrection: viewCorrection)
+      try self.__implementation.setAttitude(pitchDeg: pitchDeg, rollDeg: rollDeg)
       return bridge.create_Result_void_()
     } catch (let __error) {
       let __exceptionPtr = __error.toCpp()
@@ -606,6 +761,77 @@ open class HybridCesiumViewSpec_cxx {
     }
   }
   
+  @inline(__always)
+  public final func setViewCorrection(q: Quaternion) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.setViewCorrection(q: q)
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func setVerticalFov(deg: Double) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.setVerticalFov(deg: deg)
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func teleport(camera: CameraState) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.teleport(camera: camera)
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func getActualCamera() -> bridge.Result_std__shared_ptr_Promise_CameraState___ {
+    do {
+      let __result = try self.__implementation.getActualCamera()
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_CameraState__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_CameraState__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_CameraState__(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve(__result) })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_CameraState___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_CameraState___(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func getDemandCamera() -> bridge.Result_std__shared_ptr_Promise_CameraState___ {
+    do {
+      let __result = try self.__implementation.getDemandCamera()
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_CameraState__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_CameraState__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_CameraState__(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve(__result) })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_CameraState___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_CameraState___(__exceptionPtr)
+    }
+  }
+  
   @inline(__always)
   public final func getViewCorrection() -> bridge.Result_std__shared_ptr_Promise_Quaternion___ {
     do {

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

@@ -58,11 +58,29 @@ namespace margelo::nitro::reactnativecesium {
       prototype.registerHybridSetter("taskProcessorThreads", &HybridCesiumViewSpec::setTaskProcessorThreads);
       prototype.registerHybridGetter("minAltitudeAboveTerrain", &HybridCesiumViewSpec::getMinAltitudeAboveTerrain);
       prototype.registerHybridSetter("minAltitudeAboveTerrain", &HybridCesiumViewSpec::setMinAltitudeAboveTerrain);
+      prototype.registerHybridGetter("maxYawRateDegSec", &HybridCesiumViewSpec::getMaxYawRateDegSec);
+      prototype.registerHybridSetter("maxYawRateDegSec", &HybridCesiumViewSpec::setMaxYawRateDegSec);
+      prototype.registerHybridGetter("maxPitchRateDegSec", &HybridCesiumViewSpec::getMaxPitchRateDegSec);
+      prototype.registerHybridSetter("maxPitchRateDegSec", &HybridCesiumViewSpec::setMaxPitchRateDegSec);
+      prototype.registerHybridGetter("maxRollRateDegSec", &HybridCesiumViewSpec::getMaxRollRateDegSec);
+      prototype.registerHybridSetter("maxRollRateDegSec", &HybridCesiumViewSpec::setMaxRollRateDegSec);
+      prototype.registerHybridGetter("maxClimbRateMps", &HybridCesiumViewSpec::getMaxClimbRateMps);
+      prototype.registerHybridSetter("maxClimbRateMps", &HybridCesiumViewSpec::setMaxClimbRateMps);
+      prototype.registerHybridGetter("maxGroundSpeedMps", &HybridCesiumViewSpec::getMaxGroundSpeedMps);
+      prototype.registerHybridSetter("maxGroundSpeedMps", &HybridCesiumViewSpec::setMaxGroundSpeedMps);
       prototype.registerHybridGetter("onMetrics", &HybridCesiumViewSpec::getOnMetrics);
       prototype.registerHybridSetter("onMetrics", &HybridCesiumViewSpec::setOnMetrics);
-      prototype.registerHybridMethod("getCameraState", &HybridCesiumViewSpec::getCameraState);
-      prototype.registerHybridMethod("setCamera", &HybridCesiumViewSpec::setCamera);
-      prototype.registerHybridMethod("setCameraQuaternion", &HybridCesiumViewSpec::setCameraQuaternion);
+      prototype.registerHybridGetter("onActualCamera", &HybridCesiumViewSpec::getOnActualCamera);
+      prototype.registerHybridSetter("onActualCamera", &HybridCesiumViewSpec::setOnActualCamera);
+      prototype.registerHybridMethod("setPosition", &HybridCesiumViewSpec::setPosition);
+      prototype.registerHybridMethod("setAltitude", &HybridCesiumViewSpec::setAltitude);
+      prototype.registerHybridMethod("setHeading", &HybridCesiumViewSpec::setHeading);
+      prototype.registerHybridMethod("setAttitude", &HybridCesiumViewSpec::setAttitude);
+      prototype.registerHybridMethod("setViewCorrection", &HybridCesiumViewSpec::setViewCorrection);
+      prototype.registerHybridMethod("setVerticalFov", &HybridCesiumViewSpec::setVerticalFov);
+      prototype.registerHybridMethod("teleport", &HybridCesiumViewSpec::teleport);
+      prototype.registerHybridMethod("getActualCamera", &HybridCesiumViewSpec::getActualCamera);
+      prototype.registerHybridMethod("getDemandCamera", &HybridCesiumViewSpec::getDemandCamera);
       prototype.registerHybridMethod("getViewCorrection", &HybridCesiumViewSpec::getViewCorrection);
     });
   }