react-native-cesium 1.2.2 → 1.2.4

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 {
@@ -566,28 +686,20 @@ open class HybridCesiumViewSpec_cxx {
 
   // 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 setCamera(camera: CameraState) -> bridge.Result_void_ {
+  public final func setAltitude(altitudeMeters: Double) -> bridge.Result_void_ {
     do {
-      try self.__implementation.setCamera(camera: camera)
+      try self.__implementation.setAltitude(altitudeMeters: altitudeMeters)
       return bridge.create_Result_void_()
     } catch (let __error) {
       let __exceptionPtr = __error.toCpp()
@@ -596,9 +708,9 @@ open class HybridCesiumViewSpec_cxx {
   }
   
   @inline(__always)
-  public final func setCameraQuaternion(camera: CameraState, viewCorrection: Quaternion) -> bridge.Result_void_ {
+  public final func setHeading(headingDeg: Double) -> bridge.Result_void_ {
     do {
-      try self.__implementation.setCameraQuaternion(camera: camera, viewCorrection: viewCorrection)
+      try self.__implementation.setHeading(headingDeg: headingDeg)
       return bridge.create_Result_void_()
     } catch (let __error) {
       let __exceptionPtr = __error.toCpp()
@@ -606,6 +718,88 @@ open class HybridCesiumViewSpec_cxx {
     }
   }
   
+  @inline(__always)
+  public final func setAttitude(pitchDeg: Double, rollDeg: Double) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.setAttitude(pitchDeg: pitchDeg, rollDeg: rollDeg)
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @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,27 @@ 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.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);
     });
   }

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

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

package/nitrogen/generated/shared/c++/views/HybridCesiumViewComponent.cpp

@@ -246,6 +246,56 @@ namespace margelo::nitro::reactnativecesium::views {
         throw std::runtime_error(std::string("CesiumView.minAltitudeAboveTerrain: ") + exc.what());
       }
     }()),
+    maxYawRateDegSec([&]() -> CachedProp<std::optional<double>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("maxYawRateDegSec", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.maxYawRateDegSec;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<double>>::fromRawValue(*runtime, value, sourceProps.maxYawRateDegSec);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("CesiumView.maxYawRateDegSec: ") + exc.what());
+      }
+    }()),
+    maxPitchRateDegSec([&]() -> CachedProp<std::optional<double>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("maxPitchRateDegSec", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.maxPitchRateDegSec;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<double>>::fromRawValue(*runtime, value, sourceProps.maxPitchRateDegSec);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("CesiumView.maxPitchRateDegSec: ") + exc.what());
+      }
+    }()),
+    maxRollRateDegSec([&]() -> CachedProp<std::optional<double>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("maxRollRateDegSec", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.maxRollRateDegSec;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<double>>::fromRawValue(*runtime, value, sourceProps.maxRollRateDegSec);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("CesiumView.maxRollRateDegSec: ") + exc.what());
+      }
+    }()),
+    maxClimbRateMps([&]() -> CachedProp<std::optional<double>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("maxClimbRateMps", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.maxClimbRateMps;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<double>>::fromRawValue(*runtime, value, sourceProps.maxClimbRateMps);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("CesiumView.maxClimbRateMps: ") + exc.what());
+      }
+    }()),
+    maxGroundSpeedMps([&]() -> CachedProp<std::optional<double>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("maxGroundSpeedMps", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.maxGroundSpeedMps;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<double>>::fromRawValue(*runtime, value, sourceProps.maxGroundSpeedMps);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("CesiumView.maxGroundSpeedMps: ") + exc.what());
+      }
+    }()),
     onMetrics([&]() -> CachedProp<std::optional<std::function<void(const CesiumMetrics& /* metrics */)>>> {
       try {
         const react::RawValue* rawValue = rawProps.at("onMetrics", nullptr, nullptr);
@@ -291,6 +341,11 @@ namespace margelo::nitro::reactnativecesium::views {
       case hashString("sqliteCacheMaxRows"): return true;
       case hashString("taskProcessorThreads"): return true;
       case hashString("minAltitudeAboveTerrain"): return true;
+      case hashString("maxYawRateDegSec"): return true;
+      case hashString("maxPitchRateDegSec"): return true;
+      case hashString("maxRollRateDegSec"): return true;
+      case hashString("maxClimbRateMps"): return true;
+      case hashString("maxGroundSpeedMps"): return true;
       case hashString("onMetrics"): return true;
       case hashString("hybridRef"): return true;
       default: return false;

package/nitrogen/generated/shared/c++/views/HybridCesiumViewComponent.hpp

@@ -66,6 +66,11 @@ namespace margelo::nitro::reactnativecesium::views {
     CachedProp<std::optional<double>> sqliteCacheMaxRows;
     CachedProp<std::optional<double>> taskProcessorThreads;
     CachedProp<std::optional<double>> minAltitudeAboveTerrain;
+    CachedProp<std::optional<double>> maxYawRateDegSec;
+    CachedProp<std::optional<double>> maxPitchRateDegSec;
+    CachedProp<std::optional<double>> maxRollRateDegSec;
+    CachedProp<std::optional<double>> maxClimbRateMps;
+    CachedProp<std::optional<double>> maxGroundSpeedMps;
     CachedProp<std::optional<std::function<void(const CesiumMetrics& /* metrics */)>>> onMetrics;
     CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridCesiumViewSpec>& /* ref */)>>> hybridRef;
 

package/nitrogen/generated/shared/json/CesiumViewConfig.json

@@ -26,6 +26,11 @@
     "sqliteCacheMaxRows": true,
     "taskProcessorThreads": true,
     "minAltitudeAboveTerrain": true,
+    "maxYawRateDegSec": true,
+    "maxPitchRateDegSec": true,
+    "maxRollRateDegSec": true,
+    "maxClimbRateMps": true,
+    "maxGroundSpeedMps": true,
     "onMetrics": true,
     "hybridRef": true
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-cesium",
-  "version": "1.2.2",
+  "version": "1.2.4",
   "description": "Experimental Cesium rendering for React Native via Nitro (iOS/Metal today; Android planned)",
   "main": "./lib/commonjs/index.js",
   "module": "./lib/module/index.js",
@@ -79,7 +79,7 @@
     "conventional-changelog-conventionalcommits": "^9.3.1",
     "nitrogen": "0.35.6",
     "react": "19.2.3",
-    "react-native": "0.85.2",
+    "react-native": "0.85.3",
     "react-native-builder-bob": "^0.41.0",
     "semantic-release": "^25.0.3",
     "typescript": "^5.9.3"

package/src/specs/cesium-view.nitro.ts

@@ -4,7 +4,10 @@ import type {
   HybridViewMethods,
 } from 'react-native-nitro-modules'
 
-/** Snapshot of the native camera for persistence / sync with React state. */
+/**
+ * Snapshot of the native camera for persistence / sync with React state.
+ * Returned by `getActualCamera()` and `getDemandCamera()`.
+ */
 export interface CameraState {
   latitude: number
   longitude: number
@@ -16,8 +19,9 @@ export interface CameraState {
 }
 
 /**
- * Unit quaternion (w + xi + yj + zk). Used for camera-space view correction.
- * Non-unit values are normalized on the native side.
+ * Unit quaternion (w + xi + yj + zk). Used for camera-space view correction
+ * applied after HPR (boresight / HUD alignment). Non-unit values are
+ * normalised on the native side.
  */
 export interface Quaternion {
   w: number
@@ -42,7 +46,11 @@ export interface CesiumMetrics {
 export interface CesiumViewProps extends HybridViewProps {
   ionAccessToken: string
   ionAssetId: number
-  /** Construction-time seed camera. Use `setCamera()` for runtime updates. */
+  /**
+   * Initial camera applied via `teleport(...)` once when the native bridge is
+   * created. Subsequent prop writes are ignored — use the per-DoF setters or
+   * `teleport(...)` for runtime updates.
+   */
   initialCamera: CameraState
   pauseRendering: boolean
   maximumScreenSpaceError: number
@@ -52,7 +60,7 @@ export interface CesiumViewProps extends HybridViewProps {
   msaaSampleCount: number
   ionImageryAssetId: number
 
-  // ── Optional perf / quality knobs (added in 1.1) ─────────────────────
+  // ── Optional perf / quality knobs ────────────────────────────────────────
   /** RAM budget for live tileset, in mebibytes. Default 256. */
   maximumCachedMiB?: number
   /** Pre-load ancestor tiles around the visible set (smoother panning, more loads). Default true. */
@@ -85,23 +93,94 @@ export interface CesiumViewProps extends HybridViewProps {
    */
   minAltitudeAboveTerrain?: number
 
+  // ── Optional rate caps (flight-sim feel) ─────────────────────────────────
+  // All defaults: 0 = uncapped. Override per-screen to enforce a maximum
+  // angular / linear speed on the integrator's per-DoF velocity. Useful when
+  // your sensor feed is noisy and you would rather drop the change than
+  // visually whip the camera.
+  /** Maximum yaw rate (degrees per second). 0 = uncapped. */
+  maxYawRateDegSec?: number
+  /** Maximum pitch rate (degrees per second). 0 = uncapped. */
+  maxPitchRateDegSec?: number
+  /** Maximum roll rate (degrees per second). 0 = uncapped. */
+  maxRollRateDegSec?: number
+  /** Maximum climb / descent rate (metres per second). 0 = uncapped. */
+  maxClimbRateMps?: number
+  /** Maximum horizontal ground speed (metres per second). 0 = uncapped. */
+  maxGroundSpeedMps?: number
+
   onMetrics?: (metrics: CesiumMetrics) => void
 }
 
+/**
+ * Per-DoF camera control. Every setter records the measurement with the
+ * native steady_clock time of arrival and feeds it into an α-β tracker
+ * (constant-velocity predictor) that owns both demand and actual state.
+ *
+ * All setters are synchronous and thread-safe. Calling them from a
+ * Reanimated worklet via a Nitro `hybridRef` is the supported path for
+ * high-frequency updates; the worklet thread takes the integrator's mutex
+ * briefly and returns immediately.
+ *
+ * Getters return Promises and should be called from the JS thread (e.g. a
+ * `useEffect` or a throttled HUD update), not from a worklet.
+ */
 export interface CesiumViewMethods extends HybridViewMethods {
-  /** Returns the current native camera state. */
-  getCameraState(): Promise<CameraState>
   /**
-   * Runtime camera control (heading/pitch/roll + position + VFOV).
-   * Does not change the view-correction quaternion; use `setCameraQuaternion` to set that.
+   * New geographic position demand (latitude / longitude in degrees). Use
+   * for GPS or scripted position updates. Latitude is clamped to ±90 by the
+   * integrator; longitude is continuous (no wrap normalisation) so the
+   * shortest-arc residual maths stays correct across the antimeridian.
+   */
+  setPosition(latitude: number, longitude: number): void
+
+  /** New altitude demand (metres above mean sea level). */
+  setAltitude(altitudeMeters: number): void
+
+  /** New heading demand (degrees, 0 = north, increasing clockwise). */
+  setHeading(headingDeg: number): void
+
+  /**
+   * New attitude demand (pitch and roll in degrees). Bundled because almost
+   * every IMU emits them together — but you can pass the previous value for
+   * either axis if you only have one of them.
    */
-  setCamera(camera: CameraState): void
+  setAttitude(pitchDeg: number, rollDeg: number): void
+
+  /**
+   * New camera-space rotation applied after HPR (unit quaternion). Use for
+   * boresight calibration or screen-fixed HUD alignment. SLERPed toward the
+   * latest demand each frame.
+   */
+  setViewCorrection(q: Quaternion): void
+
+  /** New vertical field-of-view demand (degrees). Clamped to 20..100. */
+  setVerticalFov(deg: number): void
+
+  /**
+   * Atomically reset every DoF to the given camera state (value, velocity
+   * and demand all snap to the target). Bypasses the integrator entirely;
+   * use for `Fly to coordinate` actions or initial seeding from saved
+   * state.
+   */
+  teleport(camera: CameraState): void
+
+  /**
+   * Most recent camera that was rendered (post-integration). This is what
+   * the user is currently looking at and is what a HUD overlay should
+   * mirror. Differs from `getDemandCamera()` while a glide is in progress
+   * or when the terrain-floor clamp has raised the altitude.
+   */
+  getActualCamera(): Promise<CameraState>
+
   /**
-   * Same fields as `setCamera`, plus a camera-space rotation applied after HPR
-   * (e.g. boresight / HUD alignment). See README.
+   * What the consumer last asked for (per-DoF demand). Useful for
+   * diagnostics or for showing the requested camera alongside the rendered
+   * one.
    */
-  setCameraQuaternion(camera: CameraState, viewCorrection: Quaternion): void
-  /** Current view-correction quaternion (identity if never set via `setCameraQuaternion`). */
+  getDemandCamera(): Promise<CameraState>
+
+  /** Current view-correction quaternion (smoothed toward the latest demand). */
   getViewCorrection(): Promise<Quaternion>
 }
 

package/cpp/engine/CameraSmoother.cpp

@@ -1,71 +0,0 @@
-#include "CameraSmoother.hpp"
-
-#include "EngineTunables.hpp"
-
-#include <cmath>
-
-namespace reactnativecesium {
-
-namespace {
-
-inline double lerpAngleDeg(double a, double b, double t) {
-  // Wraps difference to [-180, 180] before applying the mix factor so we
-  // always rotate the short way around the unit circle.
-  double diff = std::fmod(b - a + 540.0, 360.0) - 180.0;
-  return a + diff * t;
-}
-
-inline double angleDeltaAbsDeg(double a, double b) {
-  return std::abs(std::fmod(b - a + 540.0, 360.0) - 180.0);
-}
-
-inline double quatDotAbs(const glm::dquat& a, const glm::dquat& b) {
-  return std::abs(glm::dot(glm::normalize(a), glm::normalize(b)));
-}
-
-} // namespace
-
-CameraParams CameraSmoother::step(
-    const CameraParams& current, const CameraParams& target, double dt) {
-  CameraParams next = current;
-
-  // lat/lon: snap directly to the target.
-  // CameraTargetState::snapshot() already produces a linearly-interpolated
-  // position that advances at constant speed between position fixes, so
-  // snapping here gives smooth, constant-velocity motion with no ease-in/out.
-  next.latitude  = target.latitude;
-  next.longitude = target.longitude;
-
-  const double aAlt   = 1.0 - std::exp(-tunables::kSmoothAltitude * dt);
-  const double aHdg   = 1.0 - std::exp(-tunables::kSmoothHeading  * dt);
-  const double aPitch = 1.0 - std::exp(-tunables::kSmoothPitch    * dt);
-  const double aRoll  = 1.0 - std::exp(-tunables::kSmoothRoll     * dt);
-  const double aViewQ = 1.0 - std::exp(-tunables::kSmoothViewCorr * dt);
-
-  next.altitude = current.altitude + aAlt * (target.altitude - current.altitude);
-  next.heading  = lerpAngleDeg(current.heading, target.heading, aHdg);
-  next.pitch    = lerpAngleDeg(current.pitch,   target.pitch,   aPitch);
-  next.roll     = lerpAngleDeg(current.roll,    target.roll,    aRoll);
-
-  glm::dquat cq = glm::normalize(current.viewCorrection);
-  glm::dquat tq = glm::normalize(target.viewCorrection);
-  if (glm::dot(cq, tq) < 0.0) tq = -tq;
-  next.viewCorrection = glm::normalize(glm::slerp(cq, tq, aViewQ));
-
-  // Eventually-exact convergence: snap once the residual is sub-epsilon.
-  if (std::abs(target.altitude - next.altitude) <= tunables::kEpsAltitudeMeters)
-    next.altitude = target.altitude;
-  if (angleDeltaAbsDeg(next.heading, target.heading) <= tunables::kEpsAngleDeg)
-    next.heading = target.heading;
-  if (angleDeltaAbsDeg(next.pitch, target.pitch) <= tunables::kEpsAngleDeg)
-    next.pitch = target.pitch;
-  if (angleDeltaAbsDeg(next.roll, target.roll) <= tunables::kEpsAngleDeg)
-    next.roll = target.roll;
-  if ((1.0 - quatDotAbs(next.viewCorrection, target.viewCorrection))
-        <= tunables::kEpsQuatDot)
-    next.viewCorrection = target.viewCorrection;
-
-  return next;
-}
-
-} // namespace reactnativecesium