react-native-cesium 1.2.2 → 1.2.4

package/cpp/engine/CameraSmoother.hpp

@@ -1,25 +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.
-//
-// Per-DoF smoothing rules:
-//   - lat / lon: snapped directly to target. The target itself is already a
-//     linearly-interpolated position produced by CameraTargetState::snapshot(),
-//     so snapping here gives constant-velocity motion between position fixes.
-//   - 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.
-class CameraSmoother {
-public:
-  static CameraParams step(const CameraParams& current,
-                           const CameraParams& target,
-                           double dt);
-};
-
-} // namespace reactnativecesium

package/cpp/engine/CameraTargetState.cpp

@@ -1,140 +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 for longitude, wrapped to [-180, 180].
-inline double lonDeltaDeg(double from, double to) {
-  return std::fmod(to - from + 540.0, 360.0) - 180.0;
-}
-
-} // namespace
-
-// ── Public writers ────────────────────────────────────────────────────────────
-
-void CameraTargetState::setAll(const CameraParams& target) {
-  {
-    std::lock_guard<std::mutex> g(mutex_);
-    target_ = target;
-    // Deliberately do NOT touch interpolation state: setAll is engine-init only
-    // and the first frame must snap to the requested position immediately.
-  }
-  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 bool posChanged =
-        std::abs(lat - target_.latitude)  > tunables::kEpsLatLon ||
-        std::abs(lon - target_.longitude) > tunables::kEpsLatLon;
-
-    if (posChanged) {
-      const auto now = std::chrono::steady_clock::now();
-
-      if (!hasInterpolation_) {
-        // First runtime lat/lon update: seed posFrom = destination so that
-        // lerp(dest, dest, t) = dest for all t — clean snap, no startup glide.
-        posFromLat_       = lat;
-        posFromLon_       = lon;
-        ewmaIntervalSec_  = tunables::kSmoothPositionTauMax / tunables::kSmoothPositionAlpha;
-        posUpdateTime_    = now;
-        hasInterpolation_ = true;
-      } else {
-        // Subsequent update: record where we're moving FROM (the previous
-        // target), update the EWMA interval, and reset the clock.
-        posFromLat_ = target_.latitude;
-        posFromLon_ = target_.longitude;
-
-        const double dt = std::chrono::duration<double>(now - posUpdateTime_).count();
-        if (dt > 0.0) {
-          ewmaIntervalSec_ = ewmaIntervalSec_ +
-              tunables::kEwmaIntervalAlpha * (dt - ewmaIntervalSec_);
-        }
-        posUpdateTime_ = now;
-      }
-    }
-
-    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;
-    // Position cadence intentionally NOT updated — viewCorrection changes
-    // carry no lat/lon information and must not affect the interpolation window.
-  }
-  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_;
-
-  if (hasInterpolation_ && ewmaIntervalSec_ > 0.0) {
-    const double dLat = target_.latitude - posFromLat_;
-    const double dLon = lonDeltaDeg(posFromLon_, target_.longitude);
-
-    // Snap-through guard: genuine teleports (setCamera(NewYork → Tokyo)) bypass
-    // the interpolation so they remain instant rather than gliding across the planet.
-    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 / ewmaIntervalSec_, 1.0);
-
-      result.latitude  = posFromLat_ + t * dLat;
-      result.longitude = posFromLon_ + t * dLon;
-    }
-  }
-
-  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,103 +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.
-//
-// Lat/lon interpolation
-// ─────────────────────
-// When setHpr is called with a new lat/lon, `posFrom` (old target) and
-// `posUpdateTime` are recorded inside the mutex. snapshot() then linearly
-// interpolates posFrom → target over `ewmaIntervalSec` (EWMA of inter-arrival
-// times). This produces constant-velocity motion between position fixes —
-// realistic for any vehicle/GPS source — without any changes to the public API.
-//
-// Special cases handled in snapshot():
-//   - t >= 1 : camera has reached the target, returns target_ directly.
-//   - Snap-through guard: deltas > kPosSnapThroughDeg bypass interpolation so
-//     deliberate teleports (setCamera(NewYork → Tokyo)) remain instant.
-//   - First setHpr for a given lat/lon: posFrom is set to the *destination*
-//     so lerp(dest, dest, t) = dest — no startup glide.
-//   - setAll (initialisation only): does not touch interpolation state; always
-//     snaps directly.
-class CameraTargetState {
-public:
-  CameraTargetState() = default;
-
-  // Replace the entire target. Used only for engine initialisation; does NOT
-  // update position-interpolation state so the first rendered frame snaps.
-  void setAll(const CameraParams& target);
-
-  // Update lat/lon/alt + heading/pitch/roll, leaving viewCorrection unchanged.
-  // When lat/lon actually changes, updates the linear-interpolation bookkeeping.
-  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 are linearly
-  // interpolated between the previous target (posFrom) and the current target
-  // over the EWMA inter-arrival interval.  All other DoFs are returned as-is
-  // (the smoother 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};
-
-  // ── Lat/lon linear interpolation state (all protected by mutex_) ──────────
-  // posFromLat_/posFromLon_: the target position when the last update arrived
-  //   (i.e. where we are smoothly moving FROM).
-  // posUpdateTime_:          wall-clock time of the last lat/lon change.
-  // ewmaIntervalSec_:        EWMA of inter-arrival times of lat/lon changes.
-  // hasInterpolation_:       true once we have valid posFrom + posUpdateTime
-  //                          data (false until the second distinct lat/lon value).
-  double                                 posFromLat_{0.0};
-  double                                 posFromLon_{0.0};
-  std::chrono::steady_clock::time_point  posUpdateTime_{};
-  double                                 ewmaIntervalSec_{0.0};
-  bool                                   hasInterpolation_{false};
-};
-
-} // namespace reactnativecesium