react-native-cesium 1.2.1 → 1.2.3

package/README.md

@@ -399,14 +399,15 @@ Avoid assuming **main-thread-only** vs **JS-thread-only** labels beyond the abov
 
 #### Smoothing of incoming camera updates
 
-Every value you pass to `setCamera` / `setCameraQuaternion` is treated as a **demand** target — what you would *like* the camera to be — rather than a per-frame command. The native render thread runs an exponential filter every frame that converges the displayed camera onto your demand target, which means a coarse 1 Hz position feed (e.g. external GPS) does **not** teleport the view once a second. Instead it eases between samples.
+Every value you pass to `setCamera` / `setCameraQuaternion` is treated as a **demand** target — what you would *like* the camera to be — rather than a per-frame command. The native render thread interpolates the displayed camera toward your demand target every frame, which means a coarse 1 Hz position feed (e.g. external GPS) does **not** teleport the view once a second. Instead it moves at constant speed — exactly like looking out the window of the vehicle being tracked.
 
 | DoF | Smoothing |
 | --- | --- |
-| `latitude` / `longitude` | **Adaptive** exponential filter. Time constant `τ = clamp(α · ewmaInterval, τmin, τmax)` where `ewmaInterval` tracks the cadence of your `setCamera` calls. ~60 Hz gestures collapse `τ` to the floor (≤1 frame of trail, indistinguishable from the previous "snap" behaviour); ~1 Hz GPS feeds expand `τ` so each sample is ~95 % converged before the next arrives. Cross-planet jumps (Δ > ~0.5°) bypass the smoother and snap, so a deliberate teleport stays instant. Antimeridian crossings always rotate the short way. |
-| `altitude` | Exponential, fixed `τ ≈ 40 ms`. |
-| `heading` / `pitch` / `roll` | Exponential on the shortest-arc angular delta, fixed `τ ≈ 20–33 ms`. |
-| `viewCorrection` (quaternion) | SLERP-based exponential, fixed `τ ≈ 20 ms`, hemisphere-corrected so it always takes the short rotation. |
+| `latitude` / `longitude` | **Linear interpolation** — own independent EWMA. Constant-velocity glide at GPS cadence; near-instant at gesture rate. Cross-planet jumps (Δ > ~0.5°) bypass interpolation. Antimeridian crossings always rotate the short way. |
+| `altitude` | **Linear interpolation** — own independent EWMA. Self-tunes whether altitude comes from GPS (1 Hz → 1 s glide) or a barometer (50 Hz → ~20 ms, near-instant). Jumps > 500 m bypass interpolation. |
+| `heading` | **Linear interpolation** — own independent EWMA. Constant yaw-rate between GPS course-over-ground fixes; near-instant when heading comes from a magnetometer at high rate. Jumps > 90° bypass interpolation. |
+| `pitch` / `roll` | Exponential on the shortest-arc angular delta, fixed `τ ≈ 20 ms`. Almost always attitude-sensor driven; ease-out feel is appropriate. |
+| `viewCorrection` (quaternion) | SLERP-based exponential, fixed `τ ≈ 20 ms`, hemisphere-corrected. |
 | `verticalFovDeg` | Applied directly (not smoothed). |
 
 You don't have to do anything special to take advantage of this — the smoother already runs, it's the same code path whether your driver is a Reanimated worklet at 60 Hz, a `setInterval` push at 10 Hz, or a 1 Hz GPS subscription. Just call `setCamera` whenever you have a new value.

package/android/src/main/cpp/CesiumBridgeAndroid.cpp

@@ -244,8 +244,7 @@ void CesiumBridgeAndroid::renderFrame(double dt) {
 
   const auto cur    = engine_->camera().getParams();
   const auto tgt    = target_.snapshot();
-  auto smooth = reactnativecesium::CameraSmoother::step(
-      cur, tgt, dt, target_.recentIntervalSec());
+  auto smooth = reactnativecesium::CameraSmoother::step(cur, tgt, dt);
 
   // ── Terrain floor clamp ───────────────────────────────────────────────
   const float minAbove = engine_->getConfig().minAltitudeAboveTerrain;

package/cpp/engine/CameraSmoother.cpp

@@ -2,7 +2,6 @@
 
 #include "EngineTunables.hpp"
 
-#include <algorithm>
 #include <cmath>
 
 namespace reactnativecesium {
@@ -24,67 +23,37 @@ inline double quatDotAbs(const glm::dquat& a, const glm::dquat& b) {
   return std::abs(glm::dot(glm::normalize(a), glm::normalize(b)));
 }
 
-inline double wrapLonDeltaDeg(double a, double b) {
-  return std::fmod(b - a + 540.0, 360.0) - 180.0;
-}
-
 } // namespace
 
 CameraParams CameraSmoother::step(
-    const CameraParams& current, const CameraParams& target, double dt,
-    double recentIntervalSec) {
+    const CameraParams& current, const CameraParams& target, double dt) {
   CameraParams next = current;
 
-  // ── lat/lon: adaptive exponential smoothing ─────────────────────────────
-  // τ scales with the cadence of incoming setCamera calls so gestures feel
-  // instant (τ at the floor) while sparse GPS-rate updates ease across each
-  // interval (τ near the ceiling).
-  const double tau  = std::clamp(
-      tunables::kSmoothPositionAlpha * recentIntervalSec,
-      tunables::kSmoothPositionTauMin,
-      tunables::kSmoothPositionTauMax);
-  const double aPos = 1.0 - std::exp(-dt / tau);
-
-  const double dLat = target.latitude - current.latitude;
-  const double dLon = wrapLonDeltaDeg(current.longitude, target.longitude);
-  const bool snapThrough =
-      std::abs(dLat) > tunables::kPosSnapThroughDeg ||
-      std::abs(dLon) > tunables::kPosSnapThroughDeg;
-
-  if (snapThrough) {
-    next.latitude  = target.latitude;
-    next.longitude = target.longitude;
-  } else {
-    next.latitude  = current.latitude + aPos * dLat;
-    next.longitude = lerpAngleDeg(current.longitude, target.longitude, aPos);
-  }
-
-  const double aAlt   = 1.0 - std::exp(-tunables::kSmoothAltitude * dt);
-  const double aHdg   = 1.0 - std::exp(-tunables::kSmoothHeading  * dt);
+  // 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.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);
+  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.latitude - next.latitude) <= tunables::kEpsLatLon)
-    next.latitude = target.latitude;
-  if (std::abs(wrapLonDeltaDeg(next.longitude, target.longitude))
-        <= tunables::kEpsLatLon)
-    next.longitude = target.longitude;
-  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;
+  // 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)

package/cpp/engine/CameraSmoother.hpp

@@ -7,23 +7,22 @@ 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.
 //
-// Per-DoF smoothing rules:
-//   - lat / lon: adaptive exponential smoothing `1 - exp(-dt/τ)` where
-//     τ = clamp(α · recentIntervalSec, τmin, τmax). High update rates (60 Hz
-//     gestures) drive τ to the floor so the camera tracks the finger without
-//     perceptible lag; sparse updates (1 Hz GPS) widen τ so each sample
-//     interpolates smoothly across its interval. Snap-through guard for
-//     genuine teleports keeps cross-planet `setCamera` jumps instant.
-//   - altitude / heading / pitch / roll / viewCorrection: exponential decay
-//     `1 - exp(-k * dt)` per DoF with k taken from EngineTunables.
-//   - When the delta drops below the matching epsilon, the value is snapped
-//     to the target so we eventually reach exact equality.
+// 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,
-                           double recentIntervalSec);
+                           double dt);
 };
 
 } // namespace reactnativecesium

package/cpp/engine/CameraTargetState.cpp

@@ -1,18 +1,195 @@
 #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
@@ -25,25 +202,4 @@ bool CameraTargetState::deltaExceedsEpsilon(
              > tunables::kEpsQuatDot;
 }
 
-void CameraTargetState::noteUpdateCadence() noexcept {
-  const auto now = std::chrono::steady_clock::now();
-  if (!hasLastUpdate_) {
-    // Seed the EWMA with τmax so the first sample after a quiet period uses
-    // the full smoothing budget rather than the floor (5 ms ≈ snap).
-    ewmaIntervalSec_.store(tunables::kSmoothPositionTauMax / tunables::kSmoothPositionAlpha,
-                           std::memory_order_release);
-    lastUpdateTime_ = now;
-    hasLastUpdate_  = true;
-    return;
-  }
-
-  const double dt = std::chrono::duration<double>(now - lastUpdateTime_).count();
-  lastUpdateTime_ = now;
-  if (dt <= 0.0) return; // back-to-back writes from the same frame: ignore.
-
-  const double prev = ewmaIntervalSec_.load(std::memory_order_relaxed);
-  const double next = prev + tunables::kEwmaIntervalAlpha * (dt - prev);
-  ewmaIntervalSec_.store(next, std::memory_order_release);
-}
-
 } // namespace reactnativecesium

package/cpp/engine/CameraTargetState.hpp

@@ -21,54 +21,51 @@ namespace reactnativecesium {
 //
 // `dirty_` and `forceRender_` are independent atomic flags so the read side can
 // poll without taking the lock when the camera has not moved.
+//
+// Per-DoF linear interpolation (lat/lon, altitude, heading)
+// ──────────────────────────────────────────────────────────
+// Each of lat/lon, altitude, and heading maintains its own independent EWMA
+// of inter-arrival times and only updates that EWMA when *its own value*
+// actually changes. snapshot() then linearly interpolates each DoF from its
+// previous value to its current target over its own EWMA interval.
+//
+// This means lat/lon, altitude, and heading each self-tune independently:
+//   - 60 Hz gesture input → EWMA ~16 ms → interpolation near-instant (snap)
+//   - 1 Hz GPS → EWMA ~1 s → constant-velocity glide between fixes
+//   - 50 Hz barometer for altitude + 1 Hz GPS for lat/lon → altitude behaves
+//     near-instant, lat/lon glides — with no special-casing needed.
+//
+// Special cases in snapshot():
+//   - t >= 1: camera has reached the target, returns target_ directly.
+//   - Snap-through guard: large jumps bypass interpolation so deliberate
+//     teleports remain instant.
+//   - First change per DoF: "from" = destination, so lerp(dest, dest, t) = dest
+//     for all t — clean snap, no startup glide.
+//   - setAll (init-only): never touches any interpolation state.
+//
+// pitch / roll / viewCorrection are NOT interpolated here; CameraSmoother
+// applies fixed-rate exponential curves to them (appropriate for high-rate
+// attitude sensors).
 class CameraTargetState {
 public:
   CameraTargetState() = default;
 
-  // Replace the entire target (does not touch viewCorrection if you want to
-  // preserve it — use setHpr instead).
-  void setAll(const CameraParams& target) {
-    {
-      std::lock_guard<std::mutex> g(mutex_);
-      target_ = target;
-    }
-    noteUpdateCadence();
-    dirty_.store(true, std::memory_order_release);
-    forceRender_.store(true, std::memory_order_release);
-  }
+  // Replace the entire target. Used only for engine initialisation; does NOT
+  // update any interpolation state so the first rendered frame snaps.
+  void setAll(const CameraParams& target);
 
   // Update lat/lon/alt + heading/pitch/roll, leaving viewCorrection unchanged.
+  // Independently tracks cadence for lat/lon, altitude, and heading.
   void setHpr(double lat, double lon, double alt,
-              double heading, double pitch, double roll) {
-    {
-      std::lock_guard<std::mutex> g(mutex_);
-      target_.latitude  = lat;
-      target_.longitude = lon;
-      target_.altitude  = alt;
-      target_.heading   = heading;
-      target_.pitch     = pitch;
-      target_.roll      = roll;
-    }
-    noteUpdateCadence();
-    dirty_.store(true, std::memory_order_release);
-    forceRender_.store(true, std::memory_order_release);
-  }
+              double heading, double pitch, double roll);
 
-  void setViewCorrection(const glm::dquat& q) {
-    {
-      std::lock_guard<std::mutex> g(mutex_);
-      target_.viewCorrection = q;
-    }
-    noteUpdateCadence();
-    dirty_.store(true, std::memory_order_release);
-    forceRender_.store(true, std::memory_order_release);
-  }
+  void setViewCorrection(const glm::dquat& q);
 
-  // Snapshot the demand target (read side; one mutex per frame).
-  CameraParams snapshot() const {
-    std::lock_guard<std::mutex> g(mutex_);
-    return target_;
-  }
+  // Snapshot the demand target for this render frame. lat/lon, altitude, and
+  // heading are linearly interpolated to their "current" position based on
+  // each DoF's own EWMA interval. pitch/roll/viewCorrection are returned as-is
+  // (CameraSmoother handles their exponential curves).
+  CameraParams snapshot() const;
 
   // Lightweight, lock-free check used by the render thread to decide whether
   // it should bother taking a full snapshot at all.
@@ -91,31 +88,39 @@ public:
   // whether to render this frame.
   static bool deltaExceedsEpsilon(const CameraParams& a, const CameraParams& b);
 
-  // EWMA of the inter-arrival interval (seconds) of demand updates. Used by
-  // CameraSmoother to scale the lat/lon time constant: high update rate ⇒
-  // tiny τ (snappy gestures); low update rate ⇒ larger τ (smooth GPS catch-up).
-  // Lock-free read on the render-thread hot path.
-  double recentIntervalSec() const noexcept {
-    return ewmaIntervalSec_.load(std::memory_order_acquire);
-  }
-
 private:
-  // Folds the time since the previous demand update into ewmaIntervalSec_.
-  // Called under (or after) the target_ mutex; the EWMA itself is atomic so
-  // the read side never blocks. Writes are uncontended (only JS-thread).
-  void noteUpdateCadence() noexcept;
-
   mutable std::mutex mutex_;
   CameraParams target_;
   std::atomic<bool> dirty_{false};
   std::atomic<bool> forceRender_{true};
 
-  // Cadence tracker. lastUpdateTime_ is only touched on the writer (JS)
-  // thread, so it does not need synchronisation; ewmaIntervalSec_ is read
-  // by the render thread without taking the mutex.
-  std::chrono::steady_clock::time_point lastUpdateTime_{};
-  bool                                  hasLastUpdate_{false};
-  std::atomic<double>                   ewmaIntervalSec_{0.0};
+  // ── Per-DoF linear interpolation state (all protected by mutex_) ─────────
+  // Each DoF has: a "from" value, a wall-clock timestamp of the last change,
+  // an EWMA of inter-arrival times, and an "active" flag.
+  //
+  // Pattern per DoF:
+  //   First change:      from = destination (snap), seed EWMA, set active.
+  //   Subsequent change: from = old target, update EWMA, reset clock.
+  //   snapshot():        t = clamp(elapsed/ewma, 0, 1); result = from + t*delta.
+
+  // lat / lon
+  double                                posFromLat_{0.0};
+  double                                posFromLon_{0.0};
+  std::chrono::steady_clock::time_point posUpdateTime_{};
+  double                                posEwmaIntervalSec_{0.0};
+  bool                                  hasPosInterp_{false};
+
+  // altitude
+  double                                altFrom_{0.0};
+  std::chrono::steady_clock::time_point altUpdateTime_{};
+  double                                altEwmaIntervalSec_{0.0};
+  bool                                  hasAltInterp_{false};
+
+  // heading
+  double                                hdgFrom_{0.0};
+  std::chrono::steady_clock::time_point hdgUpdateTime_{};
+  double                                hdgEwmaIntervalSec_{0.0};
+  bool                                  hasHdgInterp_{false};
 };
 
 } // namespace reactnativecesium

package/cpp/engine/CesiumEngine.cpp

@@ -434,7 +434,9 @@ void CesiumEngine::updateFrame(double w, double h, FrameResult& result) {
   asyncSystem_.dispatchMainThreadTasks();
 
   const auto viewState     = camera_.computeViewState(w, h);
-  const auto& updateResult = tileset_->updateView({viewState});
+  const auto& updateResult =
+      tileset_->updateViewGroup(tileset_->getDefaultViewGroup(), {viewState});
+  tileset_->loadTiles();
 
   // Only emit the fallback ellipsoid when no real terrain is being rendered
   // this frame. Otherwise it would be over-drawn anyway (~8k vertices and

package/cpp/engine/EngineTunables.hpp

@@ -43,31 +43,43 @@ inline constexpr int32_t kDefaultLoadingDescendantLimit       = 20;
 
 // Camera smoothing constants — shared between platform bridges so jank /
 // motion feel is identical on iOS and Android.
-inline constexpr double kSmoothAltitude     = 25.0;
-inline constexpr double kSmoothHeading      = 30.0;
+//
+// lat / lon / altitude / heading use per-DoF linear interpolation inside
+// CameraTargetState::snapshot(): each DoF tracks its own EWMA of inter-arrival
+// times and linearly lerps from its previous value to its current target over
+// that interval. At ~60 Hz (gestures) the EWMA collapses to ~16 ms so the
+// motion is indistinguishable from a snap; at 1 Hz (GPS) the DoF glides at
+// constant velocity between fixes — no teleports or ease-out deceleration.
+// pitch / roll / viewCorrection remain on their fixed exponential curves
+// because they are almost always driven by high-rate attitude sensors.
+
+// Exponential smoothing for pitch / roll / viewCorrection (k = 1/τ).
 inline constexpr double kSmoothPitch        = 50.0;
 inline constexpr double kSmoothRoll         = 50.0;
 inline constexpr double kSmoothViewCorr     = 50.0;
+
+// Convergence epsilons (used by deltaExceedsEpsilon and snap-to-exact).
 inline constexpr double kEpsLatLon          = 1e-7;
 inline constexpr double kEpsAltitudeMeters  = 0.1;
 inline constexpr double kEpsAngleDeg        = 0.05;
 inline constexpr double kEpsQuatDot         = 1e-8;
 
-// Lat/lon are smoothed adaptively: τ = clamp(α · ewmaInterval, τmin, τmax),
-// then per frame we apply 1 - exp(-dt/τ). α<1 means the camera converges
-// before the next sample lands. With ~60 Hz gestures the EWMA interval is
-// ~16 ms ⇒ τ at the floor (5 ms) ⇒ ≤1-frame trail (indistinguishable from
-// the previous snap). With a 1 Hz GPS feed τ ≈ 450 ms ⇒ ~95 % converged
-// before the next sample arrives, removing the per-second teleport.
+// Linear interpolation parameters shared by lat/lon, altitude, and heading.
+//
+// kSmoothPositionTauMax / kSmoothPositionAlpha is the seed value for the EWMA
+// on the first update (gives a generous interpolation window before the cadence
+// is known). kEwmaIntervalAlpha controls how quickly the EWMA adapts to a rate
+// change (0.3 = ~3-5 samples to converge to a new cadence).
 inline constexpr double kSmoothPositionAlpha   = 0.45;
-inline constexpr double kSmoothPositionTauMin  = 0.005;
 inline constexpr double kSmoothPositionTauMax  = 0.6;
-// Genuine teleports (e.g. setCamera(NewYork) → setCamera(Tokyo)) skip the
-// smoother — easing across the planet over 600 ms looks worse than a snap.
-inline constexpr double kPosSnapThroughDeg     = 0.5;
-// EWMA mixing factor for the inter-arrival interval of setCamera calls.
 inline constexpr double kEwmaIntervalAlpha     = 0.3;
 
+// Snap-through guards: deltas larger than these skip interpolation so a
+// deliberate teleport (e.g. setCamera(NewYork → Tokyo)) remains instant.
+inline constexpr double kPosSnapThroughDeg     = 0.5;    // lat or lon, ~55 km
+inline constexpr double kAltSnapThroughMeters  = 500.0;  // altitude
+inline constexpr double kHdgSnapThroughDeg     = 90.0;   // heading
+
 // Metrics throttle: emit telemetry every N rendered frames.
 inline constexpr int kMetricsEmitEveryFrames = 20;
 

package/ios/CesiumBridge.mm

@@ -277,8 +277,7 @@
 
     const auto cur    = _engine->camera().getParams();
     const auto tgt    = _target.snapshot();
-    auto smooth = reactnativecesium::CameraSmoother::step(
-        cur, tgt, dt, _target.recentIntervalSec());
+    auto smooth = reactnativecesium::CameraSmoother::step(cur, tgt, dt);
 
     // ── Terrain floor clamp ───────────────────────────────────────────────
     // Uses terrain floor from the previous frame (one-frame lag is

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-cesium",
-  "version": "1.2.1",
+  "version": "1.2.3",
   "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"