react-native-cesium 1.2.6 → 1.2.8

package/android/src/main/cpp/vulkan/shaders/terrain.frag

@@ -27,7 +27,7 @@ layout(push_constant) uniform PC {
   float translationY;       // byte  112
   float scaleX;             // byte  116
   float scaleY;             // byte  120
-  float _pad;               // byte  124
+  float lodFade;            // byte  124
 } pc;
 
 layout(set = 1, binding = 0) uniform sampler2D overlayTex;
@@ -56,6 +56,20 @@ vec3 hypsometricColor(float alt, float steep) {
 }
 
 void main() {
+#ifdef TERRAIN_DITHER
+  // ── LOD transition dither (IGN / Jorge Jimenez) ─────────────────────────────
+  // Compiled only into the dither pipeline so the solid pipeline keeps the GPU's
+  // early-Z optimisation enabled at full speed.  Interleaved Gradient Noise
+  // produces a per-pixel threshold approximating blue noise without a texture
+  // lookup; the pattern is far less perceptible than Bayer 4×4.
+  // lodFade=1 → all pass; lodFade=0 → all discard.
+  {
+    float ign = fract(52.9829189 *
+        fract(0.06711056 * gl_FragCoord.x + 0.00583715 * gl_FragCoord.y));
+    if (pc.lodFade <= ign) { discard; }
+  }
+#endif
+
   // ── World position (RTC reconstruction) ────────────────────────────────────
   // wp = tile-local pos + RTC centre (both float32 at ~6.4 Mm scale).
   // ~0.75 m ULP — far better than eyeRelPos + cameraEcef at altitude.
@@ -86,10 +100,16 @@ void main() {
     vec2 texUV = fragUV * vec2(pc.scaleX, pc.scaleY)
                + vec2(pc.translationX, pc.translationY);
     texUV.y = 1.0 - texUV.y;
+    // Return the overlay RGBA directly — preserves any transparency at tile
+    // edges and avoids incorrectly stamping the coastline outline on top of
+    // satellite imagery.  The dither discard above fires before this return,
+    // so LOD fading still works correctly on overlay tiles.
     outColor = texture(overlayTex, texUV);
     return;
   }
 
+  vec3 lit;
+  {
   // ── Hypsometric path ──────────────────────────────────────────────────────
   vec3  dpdx_v = dFdx(localPos), dpdy_v = dFdy(localPos);
   vec3  rawN   = cross(dpdx_v, dpdy_v);
@@ -115,24 +135,32 @@ void main() {
   vec3  oceanBlue = vec3(0.04, 0.26, 0.52);
   float landAlt   = (pc.hasWaterMask != 0u) ? max(rawAlt, 0.0) : rawAlt;
   vec3  landLit   = hypsometricColor(landAlt, steep) * (amb + diff * 0.72 + rim);
-  vec3  lit       = mix(landLit, oceanBlue, waterVal);
+  lit             = mix(landLit, oceanBlue, waterVal);
 
   // 1 km lat/lon grid — fades when sub-pixel to suppress Moiré.
   const float gridLat = 1000.0 / 6371000.0;
-  float cosLat  = max(cos(lat), 0.001);
+  // cosLat from pxy (already computed above for the Bowring iteration) —
+  // avoids a second cos() transcendental.  pxy/a_e is the geocentric cosine;
+  // the ~0.2 % geodetic difference is imperceptible at grid-line scale.
+  float cosLat  = max(pxy / 6378137.0, 0.001);
   float gridLon = gridLat / cosLat;
   float wLat    = fwidth(lat) * 1.5, wLon = fwidth(lon) * 1.5;
   float gridVis = clamp(min(gridLat / max(wLat, 1e-9),
                             gridLon / max(wLon, 1e-9)), 0.0, 1.0);
-  float latCell = lat - gridLat * floor(lat / gridLat);
-  float lonCell = lon - gridLon * floor(lon / gridLon);
+  // GLSL mod() is floor-based (always non-negative) — equivalent to the
+  // original floor dance but one instruction cleaner.
+  float latCell = mod(lat, gridLat);
+  float lonCell = mod(lon, gridLon);
   float dLat    = min(latCell, gridLat - latCell);
   float dLon    = min(lonCell, gridLon - lonCell);
-  float gridA   = max(1.0 - smoothstep(0.0, wLat, dLat),
-                      1.0 - smoothstep(0.0, wLon, dLon)) * gridVis;
+  // Linear ramp instead of smoothstep cubic — visually identical for a
+  // 1.5 px anti-aliased line, saves two multiplies per component.
+  float gridA   = max(clamp(1.0 - dLat / max(wLat, 1e-9), 0.0, 1.0),
+                      clamp(1.0 - dLon / max(wLon, 1e-9), 0.0, 1.0)) * gridVis;
   lit = mix(lit, vec3(0.15, 0.15, 0.15), gridA * 0.6);
+  } // end hypsometric block
 
-  // Coastline outline from water mask.
+  // Coastline outline from water mask (hypsometric path only — overlay returns above).
   if (pc.isEllipsoidFallback == 0u) {
     float dWater  = fwidth(waterVal);
     float coastPx = abs(waterVal - 0.5) / max(dWater * 0.5, 0.01);

package/android/src/main/java/com/margelo/nitro/reactnativecesium/HybridCesiumView.kt

@@ -29,6 +29,10 @@ class HybridCesiumView(private val appContext: Context) : HybridCesiumViewSpec()
   private var idleProbeAccumulator = 0.0
   private var renderLoopActive = false
   private val renderInFlight = AtomicBoolean(false)
+  // Last System.nanoTime() when tilesLoading was > 0. Used to keep the render
+  // loop at full speed for a grace period after loading finishes — prevents the
+  // cascade of idle gaps between LOD refinement phases. 0 = not yet seen.
+  private var lastLoadingTimeNs: Long = 0L
 
   /// Set in `surfaceDestroyed` before any teardown work begins. Render-thread
   /// callbacks and choreographer frame ticks check this flag and bail out so
@@ -199,11 +203,20 @@ class HybridCesiumView(private val appContext: Context) : HybridCesiumViewSpec()
       return
     }
 
-    val shouldRender = b.shouldRenderNextFrame()
+    // Post-loading grace period: keep the loop at full speed for 2 seconds
+    // after the last non-zero loading frame so LOD transitions complete quickly
+    // and the next refinement level is discovered without a multi-second idle gap.
+    val nowNs = System.nanoTime()
+    val inGracePeriod = lastLoadingTimeNs > 0L &&
+        (nowNs - lastLoadingTimeNs) < 2_000_000_000L
+
+    val shouldRender = b.shouldRenderNextFrame() || inGracePeriod
     val nextImmediate: Boolean
     if (shouldRender) {
       idleProbeAccumulator = 0.0
       b.renderFrame(nowSeconds)
+      // Stamp after renderFrame so the freshly-updated tile counts are used.
+      if (b.getMetricsTilesLoading() > 0) lastLoadingTimeNs = nowNs
       nextImmediate = true
     } else {
       // Approximate dt for the idle probe; not used for motion.

package/cpp/engine/CameraIntegrator.cpp

@@ -15,6 +15,10 @@ namespace {
 // isolation without linking CesiumGeospatial. Matches Ellipsoid::WGS84.
 inline constexpr double kEarthMeanRadiusM = 6371008.7714150595;
 
+// Hard ceiling on altitude (metres MSL). Enforced on both the demand and the
+// running estimate so no code path can push the camera above this value.
+inline constexpr double kMaxAltMeters = 100'000.0;
+
 inline double shortAngleDeltaDeg(double from, double to) {
   return std::fmod(to - from + 540.0, 360.0) - 180.0;
 }
@@ -105,7 +109,8 @@ void CameraIntegrator::updateAlphaBeta(
   s.tLastMeas = tz;
 }
 
-void CameraIntegrator::extrapolate(AlphaBeta& s, TimePoint now, double maxRateAbs) {
+void CameraIntegrator::extrapolate(
+    AlphaBeta& s, TimePoint now, double maxRateAbs, double demand) {
   double dt = std::chrono::duration<double>(now - s.tState).count();
   if (dt <= 0.0) {
     s.tState = now;
@@ -121,9 +126,14 @@ void CameraIntegrator::extrapolate(AlphaBeta& s, TimePoint now, double maxRateAb
   // grace window and the decay τ scale with the EWMA of inter-arrival times
   // so a 60 Hz worklet bleeds in ~50 ms while a 1 Hz GPS glide is left
   // alone between fixes.
+  //
+  // silence and grace are hoisted out of the block so the demand-pull term
+  // below can reuse them without a second chrono subtraction.
+  double silence = -1.0; // negative sentinel: "no measurement seen yet"
+  double grace   = 0.0;
   if (s.tLastMeas.time_since_epoch().count() > 0) {
-    const double silence = std::chrono::duration<double>(now - s.tLastMeas).count();
-    const double grace   = tunables::kVelocitySilenceGraceFactor * s.meanIntervalSec;
+    silence = std::chrono::duration<double>(now - s.tLastMeas).count();
+    grace   = tunables::kVelocitySilenceGraceFactor * s.meanIntervalSec;
     if (silence > grace) {
       const double tau = tunables::kVelocityBleedTauFactor * s.meanIntervalSec;
       if (tau > 1.0e-6) {
@@ -139,6 +149,16 @@ void CameraIntegrator::extrapolate(AlphaBeta& s, TimePoint now, double maxRateAb
   }
   s.value += s.velocity * dt;
   s.tState = now;
+
+  // Demand pull — guarantees convergence to the last demanded value for
+  // one-shot API calls (e.g. setAltitude from a button tap). Active only
+  // when measurements have stopped (silence > grace); continuous gesture or
+  // sensor streams always deliver a new update before the grace window
+  // expires, so this term is never active for them.
+  if (silence > grace && tunables::kDemandPullTauSec > 1.0e-6) {
+    s.value += (1.0 - std::exp(-dt / tunables::kDemandPullTauSec))
+               * (demand - s.value);
+  }
 }
 
 // ── Demand setters ────────────────────────────────────────────────────────
@@ -172,6 +192,7 @@ void CameraIntegrator::setAltitude(double altitudeMeters) {
     return;
   }
 
+  altitudeMeters = std::min(altitudeMeters, kMaxAltMeters);
   updateAlphaBeta(alt_, altitudeMeters, now,
                   tunables::kAlphaAlt, tunables::kBetaAlt, false);
   demand_.altitude = altitudeMeters;
@@ -285,16 +306,17 @@ CameraParams CameraIntegrator::step() {
     latLonCapDegSec = glm::degrees(groundCap / kEarthMeanRadiusM);
   }
 
-  extrapolate(lat_,   now, latLonCapDegSec);
-  extrapolate(lon_,   now, latLonCapDegSec);
-  extrapolate(alt_,   now, climbCap);
-  extrapolate(hdg_,   now, yawCap);
-  extrapolate(pitch_, now, pitchCap);
-  extrapolate(roll_,  now, rollCap);
-  extrapolate(vfov_,  now, 0.0); // no velocity term anyway
+  extrapolate(lat_,   now, latLonCapDegSec, demand_.latitude);
+  extrapolate(lon_,   now, latLonCapDegSec, demand_.longitude);
+  extrapolate(alt_,   now, climbCap,        demand_.altitude);
+  extrapolate(hdg_,   now, yawCap,          demand_.heading);
+  extrapolate(pitch_, now, pitchCap,        demand_.pitch);
+  extrapolate(roll_,  now, rollCap,         demand_.roll);
+  extrapolate(vfov_,  now, 0.0,             demand_.verticalFov);
 
   hdg_.value = wrap360(hdg_.value);
   lat_.value = std::clamp(lat_.value, -90.0, 90.0);
+  alt_.value = std::min(alt_.value, kMaxAltMeters);
   // Longitude is allowed to drift over ±180; consumers usually want the raw
   // continuous value for short-arc maths and the camera transform doesn't
   // care.

package/cpp/engine/CameraIntegrator.hpp

@@ -124,7 +124,7 @@ private:
   // Advance the running estimate to `now`, clamp velocity to `maxRateAbs`
   // (per second; 0 = uncapped). For angles, the resulting value is also
   // normalised to its canonical range by the caller as needed.
-  static void extrapolate(AlphaBeta& s, TimePoint now, double maxRateAbs);
+  static void extrapolate(AlphaBeta& s, TimePoint now, double maxRateAbs, double demand);
 
   mutable std::mutex mutex_;