react-native-cesium 1.2.3 → 1.2.4

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

package/cpp/engine/CameraTargetState.hpp

@@ -1,126 +0,0 @@
-#pragma once
-
-#include "EngineTunables.hpp"
-#include "GlobeCamera.hpp"
-
-#include <atomic>
-#include <chrono>
-#include <mutex>
-
-namespace reactnativecesium {
-
-// Thread-safe holder for the *demand* camera (what the JS side last asked for).
-//
-// Writers: the React Native JS / worklet thread, via setCamera / setCameraQuaternion.
-// Readers: the dedicated render thread (per frame), via shouldRenderNextFrame /
-//          renderFrame.
-//
-// We use a small mutex around `target_` because the writes are uncontended and
-// the read side only happens once per frame; the cost is negligible compared to
-// the cost of *not* synchronising a 56-byte struct that contains a glm::dquat.
-//
-// `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. 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);
-
-  void setViewCorrection(const glm::dquat& q);
-
-  // 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.
-  bool isDirty() const noexcept {
-    return dirty_.load(std::memory_order_acquire);
-  }
-  void clearDirty() noexcept {
-    dirty_.store(false, std::memory_order_release);
-  }
-
-  bool consumeForceRender() noexcept {
-    return forceRender_.exchange(false, std::memory_order_acq_rel);
-  }
-  void requestForceRender() noexcept {
-    forceRender_.store(true, std::memory_order_release);
-  }
-
-  // Compares snapshot to "current" (the engine's current camera) and returns
-  // true if any DoF differs by more than the matching epsilon. Used to decide
-  // whether to render this frame.
-  static bool deltaExceedsEpsilon(const CameraParams& a, const CameraParams& b);
-
-private:
-  mutable std::mutex mutex_;
-  CameraParams target_;
-  std::atomic<bool> dirty_{false};
-  std::atomic<bool> forceRender_{true};
-
-  // ── 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