react-native-cesium 1.2.2 → 1.2.4

package/nitrogen/generated/android/c++/JHybridCesiumViewSpec.cpp

@@ -256,6 +256,51 @@ namespace margelo::nitro::reactnativecesium {
     static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* minAltitudeAboveTerrain */)>("setMinAltitudeAboveTerrain");
     method(_javaPart, minAltitudeAboveTerrain.has_value() ? jni::JDouble::valueOf(minAltitudeAboveTerrain.value()) : nullptr);
   }
+  std::optional<double> JHybridCesiumViewSpec::getMaxYawRateDegSec() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getMaxYawRateDegSec");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->value()) : std::nullopt;
+  }
+  void JHybridCesiumViewSpec::setMaxYawRateDegSec(std::optional<double> maxYawRateDegSec) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* maxYawRateDegSec */)>("setMaxYawRateDegSec");
+    method(_javaPart, maxYawRateDegSec.has_value() ? jni::JDouble::valueOf(maxYawRateDegSec.value()) : nullptr);
+  }
+  std::optional<double> JHybridCesiumViewSpec::getMaxPitchRateDegSec() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getMaxPitchRateDegSec");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->value()) : std::nullopt;
+  }
+  void JHybridCesiumViewSpec::setMaxPitchRateDegSec(std::optional<double> maxPitchRateDegSec) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* maxPitchRateDegSec */)>("setMaxPitchRateDegSec");
+    method(_javaPart, maxPitchRateDegSec.has_value() ? jni::JDouble::valueOf(maxPitchRateDegSec.value()) : nullptr);
+  }
+  std::optional<double> JHybridCesiumViewSpec::getMaxRollRateDegSec() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getMaxRollRateDegSec");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->value()) : std::nullopt;
+  }
+  void JHybridCesiumViewSpec::setMaxRollRateDegSec(std::optional<double> maxRollRateDegSec) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* maxRollRateDegSec */)>("setMaxRollRateDegSec");
+    method(_javaPart, maxRollRateDegSec.has_value() ? jni::JDouble::valueOf(maxRollRateDegSec.value()) : nullptr);
+  }
+  std::optional<double> JHybridCesiumViewSpec::getMaxClimbRateMps() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getMaxClimbRateMps");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->value()) : std::nullopt;
+  }
+  void JHybridCesiumViewSpec::setMaxClimbRateMps(std::optional<double> maxClimbRateMps) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* maxClimbRateMps */)>("setMaxClimbRateMps");
+    method(_javaPart, maxClimbRateMps.has_value() ? jni::JDouble::valueOf(maxClimbRateMps.value()) : nullptr);
+  }
+  std::optional<double> JHybridCesiumViewSpec::getMaxGroundSpeedMps() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getMaxGroundSpeedMps");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->value()) : std::nullopt;
+  }
+  void JHybridCesiumViewSpec::setMaxGroundSpeedMps(std::optional<double> maxGroundSpeedMps) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* maxGroundSpeedMps */)>("setMaxGroundSpeedMps");
+    method(_javaPart, maxGroundSpeedMps.has_value() ? jni::JDouble::valueOf(maxGroundSpeedMps.value()) : nullptr);
+  }
   std::optional<std::function<void(const CesiumMetrics& /* metrics */)>> JHybridCesiumViewSpec::getOnMetrics() {
     static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFunc_void_CesiumMetrics::javaobject>()>("getOnMetrics_cxx");
     auto __result = method(_javaPart);
@@ -275,8 +320,36 @@ namespace margelo::nitro::reactnativecesium {
   }
 
   // Methods
-  std::shared_ptr<Promise<CameraState>> JHybridCesiumViewSpec::getCameraState() {
-    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("getCameraState");
+  void JHybridCesiumViewSpec::setPosition(double latitude, double longitude) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(double /* latitude */, double /* longitude */)>("setPosition");
+    method(_javaPart, latitude, longitude);
+  }
+  void JHybridCesiumViewSpec::setAltitude(double altitudeMeters) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(double /* altitudeMeters */)>("setAltitude");
+    method(_javaPart, altitudeMeters);
+  }
+  void JHybridCesiumViewSpec::setHeading(double headingDeg) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(double /* headingDeg */)>("setHeading");
+    method(_javaPart, headingDeg);
+  }
+  void JHybridCesiumViewSpec::setAttitude(double pitchDeg, double rollDeg) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(double /* pitchDeg */, double /* rollDeg */)>("setAttitude");
+    method(_javaPart, pitchDeg, rollDeg);
+  }
+  void JHybridCesiumViewSpec::setViewCorrection(const Quaternion& q) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JQuaternion> /* q */)>("setViewCorrection");
+    method(_javaPart, JQuaternion::fromCpp(q));
+  }
+  void JHybridCesiumViewSpec::setVerticalFov(double deg) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(double /* deg */)>("setVerticalFov");
+    method(_javaPart, deg);
+  }
+  void JHybridCesiumViewSpec::teleport(const CameraState& camera) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JCameraState> /* camera */)>("teleport");
+    method(_javaPart, JCameraState::fromCpp(camera));
+  }
+  std::shared_ptr<Promise<CameraState>> JHybridCesiumViewSpec::getActualCamera() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("getActualCamera");
     auto __result = method(_javaPart);
     return [&]() {
       auto __promise = Promise<CameraState>::create();
@@ -291,13 +364,21 @@ namespace margelo::nitro::reactnativecesium {
       return __promise;
     }();
   }
-  void JHybridCesiumViewSpec::setCamera(const CameraState& camera) {
-    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JCameraState> /* camera */)>("setCamera");
-    method(_javaPart, JCameraState::fromCpp(camera));
-  }
-  void JHybridCesiumViewSpec::setCameraQuaternion(const CameraState& camera, const Quaternion& viewCorrection) {
-    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JCameraState> /* camera */, jni::alias_ref<JQuaternion> /* viewCorrection */)>("setCameraQuaternion");
-    method(_javaPart, JCameraState::fromCpp(camera), JQuaternion::fromCpp(viewCorrection));
+  std::shared_ptr<Promise<CameraState>> JHybridCesiumViewSpec::getDemandCamera() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("getDemandCamera");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<CameraState>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<JCameraState>(__boxedResult);
+        __promise->resolve(__result->toCpp());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
   }
   std::shared_ptr<Promise<Quaternion>> JHybridCesiumViewSpec::getViewCorrection() {
     static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("getViewCorrection");

package/nitrogen/generated/android/c++/JHybridCesiumViewSpec.hpp

@@ -94,14 +94,30 @@ namespace margelo::nitro::reactnativecesium {
     void setTaskProcessorThreads(std::optional<double> taskProcessorThreads) override;
     std::optional<double> getMinAltitudeAboveTerrain() override;
     void setMinAltitudeAboveTerrain(std::optional<double> minAltitudeAboveTerrain) override;
+    std::optional<double> getMaxYawRateDegSec() override;
+    void setMaxYawRateDegSec(std::optional<double> maxYawRateDegSec) override;
+    std::optional<double> getMaxPitchRateDegSec() override;
+    void setMaxPitchRateDegSec(std::optional<double> maxPitchRateDegSec) override;
+    std::optional<double> getMaxRollRateDegSec() override;
+    void setMaxRollRateDegSec(std::optional<double> maxRollRateDegSec) override;
+    std::optional<double> getMaxClimbRateMps() override;
+    void setMaxClimbRateMps(std::optional<double> maxClimbRateMps) override;
+    std::optional<double> getMaxGroundSpeedMps() override;
+    void setMaxGroundSpeedMps(std::optional<double> maxGroundSpeedMps) override;
     std::optional<std::function<void(const CesiumMetrics& /* metrics */)>> getOnMetrics() override;
     void setOnMetrics(const std::optional<std::function<void(const CesiumMetrics& /* metrics */)>>& onMetrics) override;
 
   public:
     // Methods
-    std::shared_ptr<Promise<CameraState>> getCameraState() override;
-    void setCamera(const CameraState& camera) override;
-    void setCameraQuaternion(const CameraState& camera, const Quaternion& viewCorrection) override;
+    void setPosition(double latitude, double longitude) override;
+    void setAltitude(double altitudeMeters) override;
+    void setHeading(double headingDeg) override;
+    void setAttitude(double pitchDeg, double rollDeg) override;
+    void setViewCorrection(const Quaternion& q) override;
+    void setVerticalFov(double deg) override;
+    void teleport(const CameraState& camera) override;
+    std::shared_ptr<Promise<CameraState>> getActualCamera() override;
+    std::shared_ptr<Promise<CameraState>> getDemandCamera() override;
     std::shared_ptr<Promise<Quaternion>> getViewCorrection() override;
 
   private:

package/nitrogen/generated/android/c++/views/JHybridCesiumViewStateUpdater.cpp

@@ -125,6 +125,26 @@ void JHybridCesiumViewStateUpdater::updateViewProps(jni::alias_ref<jni::JClass>
     hybridView->setMinAltitudeAboveTerrain(props->minAltitudeAboveTerrain.value);
     props->minAltitudeAboveTerrain.isDirty = false;
   }
+  if (props->maxYawRateDegSec.isDirty) {
+    hybridView->setMaxYawRateDegSec(props->maxYawRateDegSec.value);
+    props->maxYawRateDegSec.isDirty = false;
+  }
+  if (props->maxPitchRateDegSec.isDirty) {
+    hybridView->setMaxPitchRateDegSec(props->maxPitchRateDegSec.value);
+    props->maxPitchRateDegSec.isDirty = false;
+  }
+  if (props->maxRollRateDegSec.isDirty) {
+    hybridView->setMaxRollRateDegSec(props->maxRollRateDegSec.value);
+    props->maxRollRateDegSec.isDirty = false;
+  }
+  if (props->maxClimbRateMps.isDirty) {
+    hybridView->setMaxClimbRateMps(props->maxClimbRateMps.value);
+    props->maxClimbRateMps.isDirty = false;
+  }
+  if (props->maxGroundSpeedMps.isDirty) {
+    hybridView->setMaxGroundSpeedMps(props->maxGroundSpeedMps.value);
+    props->maxGroundSpeedMps.isDirty = false;
+  }
   if (props->onMetrics.isDirty) {
     hybridView->setOnMetrics(props->onMetrics.value);
     props->onMetrics.isDirty = false;

package/nitrogen/generated/android/kotlin/com/margelo/nitro/reactnativecesium/HybridCesiumViewSpec.kt

@@ -159,6 +159,36 @@ abstract class HybridCesiumViewSpec: HybridView() {
   @set:Keep
   abstract var minAltitudeAboveTerrain: Double?
   
+  @get:DoNotStrip
+  @get:Keep
+  @set:DoNotStrip
+  @set:Keep
+  abstract var maxYawRateDegSec: Double?
+  
+  @get:DoNotStrip
+  @get:Keep
+  @set:DoNotStrip
+  @set:Keep
+  abstract var maxPitchRateDegSec: Double?
+  
+  @get:DoNotStrip
+  @get:Keep
+  @set:DoNotStrip
+  @set:Keep
+  abstract var maxRollRateDegSec: Double?
+  
+  @get:DoNotStrip
+  @get:Keep
+  @set:DoNotStrip
+  @set:Keep
+  abstract var maxClimbRateMps: Double?
+  
+  @get:DoNotStrip
+  @get:Keep
+  @set:DoNotStrip
+  @set:Keep
+  abstract var maxGroundSpeedMps: Double?
+  
   abstract var onMetrics: ((metrics: CesiumMetrics) -> Unit)?
   
   private var onMetrics_cxx: Func_void_CesiumMetrics?
@@ -176,15 +206,39 @@ abstract class HybridCesiumViewSpec: HybridView() {
   // Methods
   @DoNotStrip
   @Keep
-  abstract fun getCameraState(): Promise<CameraState>
+  abstract fun setPosition(latitude: Double, longitude: Double): Unit
+  
+  @DoNotStrip
+  @Keep
+  abstract fun setAltitude(altitudeMeters: Double): Unit
+  
+  @DoNotStrip
+  @Keep
+  abstract fun setHeading(headingDeg: Double): Unit
+  
+  @DoNotStrip
+  @Keep
+  abstract fun setAttitude(pitchDeg: Double, rollDeg: Double): Unit
+  
+  @DoNotStrip
+  @Keep
+  abstract fun setViewCorrection(q: Quaternion): Unit
+  
+  @DoNotStrip
+  @Keep
+  abstract fun setVerticalFov(deg: Double): Unit
+  
+  @DoNotStrip
+  @Keep
+  abstract fun teleport(camera: CameraState): Unit
   
   @DoNotStrip
   @Keep
-  abstract fun setCamera(camera: CameraState): Unit
+  abstract fun getActualCamera(): Promise<CameraState>
   
   @DoNotStrip
   @Keep
-  abstract fun setCameraQuaternion(camera: CameraState, viewCorrection: Quaternion): Unit
+  abstract fun getDemandCamera(): Promise<CameraState>
   
   @DoNotStrip
   @Keep

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

@@ -210,15 +210,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 +219,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;
@@ -229,26 +264,64 @@ namespace margelo::nitro::reactnativecesium {
 
   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());
       }
-      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 setHeading(double headingDeg) override {
+      auto __result = _swiftPart.setHeading(std::forward<decltype(headingDeg)>(headingDeg));
       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 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());
+      }
+    }
+    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 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,6 +189,31 @@ 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);

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

@@ -32,12 +32,23 @@ 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 }
 
   // 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>
 }