react-native-cesium 1.2.3 → 1.2.5

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,32 @@ 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;
+      virtual std::optional<std::function<void(const CameraState& /* camera */)>> getOnActualCamera() = 0;
+      virtual void setOnActualCamera(const std::optional<std::function<void(const CameraState& /* camera */)>>& onActualCamera) = 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);
@@ -256,6 +306,16 @@ namespace margelo::nitro::reactnativecesium::views {
         throw std::runtime_error(std::string("CesiumView.onMetrics: ") + exc.what());
       }
     }()),
+    onActualCamera([&]() -> CachedProp<std::optional<std::function<void(const CameraState& /* camera */)>>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("onActualCamera", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.onActualCamera;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::function<void(const CameraState& /* camera */)>>>::fromRawValue(*runtime, value.asObject(*runtime).getProperty(*runtime, PropNameIDCache::get(*runtime, "f")), sourceProps.onActualCamera);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("CesiumView.onActualCamera: ") + exc.what());
+      }
+    }()),
     hybridRef([&]() -> CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridCesiumViewSpec>& /* ref */)>>> {
       try {
         const react::RawValue* rawValue = rawProps.at("hybridRef", nullptr, nullptr);
@@ -291,7 +351,13 @@ 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("onActualCamera"): return true;
       case hashString("hybridRef"): return true;
       default: return false;
     }

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

@@ -66,7 +66,13 @@ 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 CameraState& /* camera */)>>> onActualCamera;
     CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridCesiumViewSpec>& /* ref */)>>> hybridRef;
 
   private:

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

@@ -26,7 +26,13 @@
     "sqliteCacheMaxRows": true,
     "taskProcessorThreads": true,
     "minAltitudeAboveTerrain": true,
+    "maxYawRateDegSec": true,
+    "maxPitchRateDegSec": true,
+    "maxRollRateDegSec": true,
+    "maxClimbRateMps": true,
+    "maxGroundSpeedMps": true,
     "onMetrics": true,
+    "onActualCamera": true,
     "hybridRef": true
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-cesium",
-  "version": "1.2.3",
+  "version": "1.2.5",
   "description": "Experimental Cesium rendering for React Native via Nitro (iOS/Metal today; Android planned)",
   "main": "./lib/commonjs/index.js",
   "module": "./lib/module/index.js",

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,103 @@ 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
+
+  /**
+   * Called at ~5 Hz with the post-integration actual camera — the same state
+   * returned by `getActualCamera()`. Only fires when at least one field has
+   * changed beyond its epsilon threshold since the last emission, so a
+   * stationary camera produces no bridge traffic. Use this to keep HUD overlay
+   * symbology aligned with the rendered view without polling from JS.
+   */
+  onActualCamera?: (camera: CameraState) => 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.
    */
-  setCamera(camera: CameraState): void
+  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
+
   /**
-   * Same fields as `setCamera`, plus a camera-space rotation applied after HPR
-   * (e.g. boresight / HUD alignment). See README.
+   * 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.
    */
-  setCameraQuaternion(camera: CameraState, viewCorrection: Quaternion): void
-  /** Current view-correction quaternion (identity if never set via `setCameraQuaternion`). */
+  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>
+
+  /**
+   * What the consumer last asked for (per-DoF demand). Useful for
+   * diagnostics or for showing the requested camera alongside the rendered
+   * one.
+   */
+  getDemandCamera(): Promise<CameraState>
+
+  /** Current view-correction quaternion (smoothed toward the latest demand). */
   getViewCorrection(): Promise<Quaternion>
 }
 

package/cpp/engine/CameraSmoother.cpp

@@ -1,68 +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 / altitude / heading: snap directly to the (already linearly-
-  // interpolated) target from CameraTargetState::snapshot(). The constant-
-  // velocity motion is fully handled there; no additional smoothing is applied
-  // here so the movement stays linear rather than decelerating.
-  next.latitude  = target.latitude;
-  next.longitude = target.longitude;
-  next.altitude  = target.altitude;
-  next.heading   = target.heading;
-
-  // pitch / roll / viewCorrection: exponential ease-out. These are almost
-  // always driven by high-rate attitude sensors (accelerometer, gyroscope)
-  // where the ease-out feel is appropriate and desired.
-  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.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 for exponential DoFs: snap once sub-epsilon.
-  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

package/cpp/engine/CameraSmoother.hpp

@@ -1,28 +0,0 @@
-#pragma once
-
-#include "GlobeCamera.hpp"
-
-namespace reactnativecesium {
-
-// Stateless helper. Given a current camera state and a target camera state,
-// returns the next camera state for a frame of duration `dt` seconds.
-//
-// lat / lon / altitude / heading are snapped directly to the target.
-// CameraTargetState::snapshot() has already linearly interpolated those DoFs
-// to their "current" position based on each DoF's own EWMA inter-arrival
-// interval, so snapping here gives constant-velocity motion between fixes
-// with no ease-in/ease-out. At gesture rates (~60 Hz) the EWMA collapses to
-// ~16 ms so the snap is indistinguishable from the previous behaviour.
-//
-// pitch / roll / viewCorrection use fixed-rate exponential decay
-// `1 - exp(-k * dt)` with k from EngineTunables — appropriate for high-rate
-// attitude sensors where the ease-out feel is desirable.
-// Once a DoF drops below its matching epsilon it is snapped to exact equality.
-class CameraSmoother {
-public:
-  static CameraParams step(const CameraParams& current,
-                           const CameraParams& target,
-                           double dt);
-};
-
-} // namespace reactnativecesium

package/cpp/engine/CameraTargetState.cpp

@@ -1,205 +0,0 @@
-#include "CameraTargetState.hpp"
-
-#include <algorithm>
-#include <cmath>
-
-namespace reactnativecesium {
-
-namespace {
-
-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)));
-}
-
-// Shortest signed angular delta wrapped to [-180, 180].
-inline double shortAngleDeltaDeg(double from, double to) {
-  return std::fmod(to - from + 540.0, 360.0) - 180.0;
-}
-
-// Advance an EWMA with a new sample, or seed it on first use.
-inline void updateEwma(double& ewma, bool& active,
-                       std::chrono::steady_clock::time_point& lastTime,
-                       const std::chrono::steady_clock::time_point& now,
-                       double seedSec) {
-  if (!active) {
-    ewma     = seedSec;
-    lastTime = now;
-    active   = true;
-  } else {
-    const double dt = std::chrono::duration<double>(now - lastTime).count();
-    if (dt > 0.0) {
-      ewma = ewma + tunables::kEwmaIntervalAlpha * (dt - ewma);
-    }
-    lastTime = now;
-  }
-}
-
-} // namespace
-
-// ── Public writers ────────────────────────────────────────────────────────────
-
-void CameraTargetState::setAll(const CameraParams& target) {
-  {
-    std::lock_guard<std::mutex> g(mutex_);
-    target_ = target;
-    // Deliberately do NOT touch any interpolation state: setAll is init-only
-    // and the first rendered frame must snap to the requested position.
-  }
-  dirty_.store(true, std::memory_order_release);
-  forceRender_.store(true, std::memory_order_release);
-}
-
-void CameraTargetState::setHpr(double lat, double lon, double alt,
-                                double heading, double pitch, double roll) {
-  {
-    std::lock_guard<std::mutex> g(mutex_);
-
-    const auto now = std::chrono::steady_clock::now();
-
-    // ── lat / lon ─────────────────────────────────────────────────────────
-    const bool posChanged =
-        std::abs(lat - target_.latitude)  > tunables::kEpsLatLon ||
-        std::abs(lon - target_.longitude) > tunables::kEpsLatLon;
-
-    if (posChanged) {
-      if (!hasPosInterp_) {
-        // First runtime change: seed "from" = destination for a clean snap,
-        // then enable interpolation for subsequent updates.
-        posFromLat_ = lat;
-        posFromLon_ = lon;
-        updateEwma(posEwmaIntervalSec_, hasPosInterp_, posUpdateTime_, now,
-                   tunables::kSmoothPositionTauMax / tunables::kSmoothPositionAlpha);
-      } else {
-        posFromLat_ = target_.latitude;
-        posFromLon_ = target_.longitude;
-        updateEwma(posEwmaIntervalSec_, hasPosInterp_, posUpdateTime_, now,
-                   tunables::kSmoothPositionTauMax / tunables::kSmoothPositionAlpha);
-      }
-    }
-
-    // ── altitude ──────────────────────────────────────────────────────────
-    const bool altChanged =
-        std::abs(alt - target_.altitude) > tunables::kEpsAltitudeMeters;
-
-    if (altChanged) {
-      if (!hasAltInterp_) {
-        altFrom_ = alt;
-        updateEwma(altEwmaIntervalSec_, hasAltInterp_, altUpdateTime_, now,
-                   tunables::kSmoothPositionTauMax / tunables::kSmoothPositionAlpha);
-      } else {
-        altFrom_ = target_.altitude;
-        updateEwma(altEwmaIntervalSec_, hasAltInterp_, altUpdateTime_, now,
-                   tunables::kSmoothPositionTauMax / tunables::kSmoothPositionAlpha);
-      }
-    }
-
-    // ── heading ───────────────────────────────────────────────────────────
-    const bool hdgChanged =
-        angleDeltaAbsDeg(heading, target_.heading) > tunables::kEpsAngleDeg;
-
-    if (hdgChanged) {
-      if (!hasHdgInterp_) {
-        hdgFrom_ = heading;
-        updateEwma(hdgEwmaIntervalSec_, hasHdgInterp_, hdgUpdateTime_, now,
-                   tunables::kSmoothPositionTauMax / tunables::kSmoothPositionAlpha);
-      } else {
-        hdgFrom_ = target_.heading;
-        updateEwma(hdgEwmaIntervalSec_, hasHdgInterp_, hdgUpdateTime_, now,
-                   tunables::kSmoothPositionTauMax / tunables::kSmoothPositionAlpha);
-      }
-    }
-
-    target_.latitude  = lat;
-    target_.longitude = lon;
-    target_.altitude  = alt;
-    target_.heading   = heading;
-    target_.pitch     = pitch;
-    target_.roll      = roll;
-  }
-  dirty_.store(true, std::memory_order_release);
-  forceRender_.store(true, std::memory_order_release);
-}
-
-void CameraTargetState::setViewCorrection(const glm::dquat& q) {
-  {
-    std::lock_guard<std::mutex> g(mutex_);
-    target_.viewCorrection = q;
-    // Interpolation state is not touched — viewCorrection carries no
-    // positional information and must not affect any of the three EWMAs.
-  }
-  dirty_.store(true, std::memory_order_release);
-  forceRender_.store(true, std::memory_order_release);
-}
-
-// ── Snapshot (render-thread read) ─────────────────────────────────────────────
-
-CameraParams CameraTargetState::snapshot() const {
-  const auto now = std::chrono::steady_clock::now();
-  std::lock_guard<std::mutex> g(mutex_);
-
-  CameraParams result = target_;
-
-  // ── lat / lon ─────────────────────────────────────────────────────────────
-  if (hasPosInterp_ && posEwmaIntervalSec_ > 0.0) {
-    const double dLat = target_.latitude - posFromLat_;
-    const double dLon = shortAngleDeltaDeg(posFromLon_, target_.longitude);
-
-    const bool snapThrough =
-        std::abs(dLat) > tunables::kPosSnapThroughDeg ||
-        std::abs(dLon) > tunables::kPosSnapThroughDeg;
-
-    if (!snapThrough) {
-      const double elapsed =
-          std::chrono::duration<double>(now - posUpdateTime_).count();
-      const double t = std::min(elapsed / posEwmaIntervalSec_, 1.0);
-      result.latitude  = posFromLat_ + t * dLat;
-      result.longitude = posFromLon_ + t * dLon;
-    }
-  }
-
-  // ── altitude ──────────────────────────────────────────────────────────────
-  if (hasAltInterp_ && altEwmaIntervalSec_ > 0.0) {
-    const double dAlt = target_.altitude - altFrom_;
-
-    if (std::abs(dAlt) <= tunables::kAltSnapThroughMeters) {
-      const double elapsed =
-          std::chrono::duration<double>(now - altUpdateTime_).count();
-      const double t = std::min(elapsed / altEwmaIntervalSec_, 1.0);
-      result.altitude = altFrom_ + t * dAlt;
-    }
-  }
-
-  // ── heading ───────────────────────────────────────────────────────────────
-  if (hasHdgInterp_ && hdgEwmaIntervalSec_ > 0.0) {
-    const double dHdg = shortAngleDeltaDeg(hdgFrom_, target_.heading);
-
-    if (std::abs(dHdg) <= tunables::kHdgSnapThroughDeg) {
-      const double elapsed =
-          std::chrono::duration<double>(now - hdgUpdateTime_).count();
-      const double t = std::min(elapsed / hdgEwmaIntervalSec_, 1.0);
-      result.heading = hdgFrom_ + t * dHdg;
-    }
-  }
-
-  return result;
-}
-
-// ── Epsilon check (shared) ────────────────────────────────────────────────────
-
-bool CameraTargetState::deltaExceedsEpsilon(
-    const CameraParams& a, const CameraParams& b) {
-  return std::abs(a.latitude  - b.latitude)  > tunables::kEpsLatLon
-      || std::abs(a.longitude - b.longitude) > tunables::kEpsLatLon
-      || std::abs(a.altitude  - b.altitude)  > tunables::kEpsAltitudeMeters
-      || angleDeltaAbsDeg(a.heading, b.heading) > tunables::kEpsAngleDeg
-      || angleDeltaAbsDeg(a.pitch,   b.pitch)   > tunables::kEpsAngleDeg
-      || angleDeltaAbsDeg(a.roll,    b.roll)    > tunables::kEpsAngleDeg
-      || (1.0 - quatDotAbs(a.viewCorrection, b.viewCorrection))
-             > tunables::kEpsQuatDot;
-}
-
-} // namespace reactnativecesium