react-native-cesium 1.2.17 → 1.2.19

package/README.md

@@ -184,7 +184,7 @@ npm run build --prefix node_modules/react-native-cesium
 
 **Yarn/npm workspaces:** if `react-native-cesium` is a workspace package in your monorepo, use your tool’s workspace runner, e.g. `yarn workspace react-native-cesium run update` (exact syntax depends on your workspace layout).
 
-- `update` checks out **Cesium Native `v0.59.0`** into `vendor/cesium-native` under the package (next to its other files; typically ignored in app repos).
+- `update` checks out **Cesium Native `v0.65.0`** into `vendor/cesium-native` under the package (next to its other files; typically ignored in app repos).
 - `build` runs `scripts/cesium/build.mjs` (**CMake**, **vcpkg** under `vendor/vcpkg` unless **`VCPKG_ROOT`** is set, **Ninja** on macOS) and writes **`vendor/ios/CesiumNative.xcframework`** and/or **`vendor/android`** depending on **`CESIUM_BUILD_ONLY`**.
 
 Then install pods (iOS):

package/android/CMakeLists.txt

@@ -151,6 +151,7 @@ target_link_libraries(
         CesiumGltf
         CesiumGltfReader
         CesiumGltfContent
+        CesiumImage
         CesiumGeospatial
         CesiumGeometry
         CesiumAsync

package/android/build.gradle

@@ -5,7 +5,7 @@ buildscript {
   }
 
   dependencies {
-    classpath "com.android.tools.build:gradle:8.8.0"
+    classpath "com.android.tools.build:gradle:9.2.1"
   }
 }
 

package/android/gradle.properties

@@ -1,5 +1,5 @@
-ReactNativeCesium_kotlinVersion=2.1.20
-ReactNativeCesium_minSdkVersion=23
-ReactNativeCesium_targetSdkVersion=35
-ReactNativeCesium_compileSdkVersion=34
+ReactNativeCesium_kotlinVersion=2.2.0
+ReactNativeCesium_minSdkVersion=24
+ReactNativeCesium_targetSdkVersion=36
+ReactNativeCesium_compileSdkVersion=37
 ReactNativeCesium_ndkVersion=27.1.12297006

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

@@ -1,7 +1,7 @@
 #include "CesiumBridgeAndroid.h"
 
 #include "engine/EngineTunables.hpp"
-#include "engine/GeoidConverter.hpp"
+#include "engine/TerrainFloor.hpp"
 #include "vulkan/VulkanBackend.h"
 
 #include <android/native_window_jni.h>
@@ -191,6 +191,7 @@ void CesiumBridgeAndroid::teleport(double lat, double lon, double alt,
   p.verticalFov    = vfov;
   p.viewCorrection = integrator_->getActual().viewCorrection;
   integrator_->teleport(p);
+  reactnativecesium::noteTerrainSlew(*integrator_, terrainLead_);
   engine_->camera().setParams(p);
   forceRender_.store(true, std::memory_order_release);
 }
@@ -309,20 +310,9 @@ void CesiumBridgeAndroid::renderFrame(double nowSeconds) {
   // The integrator owns its own clock — see CameraIntegrator::step().
   // `nowSeconds` is still used below for the metrics-only dt EMA.
   auto actual = integrator_->step();
-
-  // ── Terrain floor clamp ───────────────────────────────────────────────
-  const float minAbove = engine_->getConfig().minAltitudeAboveTerrain;
-  if (minAbove > 0.0f && engine_->terrainFloorKnown()) {
-    const double geoidN =
-        reactnativecesium::mslToEllipsoidMeters(actual.latitude, actual.longitude, 0.0);
-    const double floorMsl =
-        static_cast<double>(engine_->terrainFloorEllipsoidMeters()) - geoidN;
-    const double minMsl = floorMsl + static_cast<double>(minAbove);
-    if (actual.altitude < minMsl) {
-      integrator_->clampActualAltitude(minMsl);
-      actual.altitude = minMsl;
-    }
-  }
+  actual = reactnativecesium::applyTerrainFloor(
+      *engine_, *integrator_, actual, terrainLead_,
+      static_cast<double>(engine_->getConfig().minAltitudeAboveTerrain));
 
   engine_->camera().setParams(actual);
 

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

@@ -8,6 +8,7 @@
 #include "engine/CameraIntegrator.hpp"
 #include "engine/CesiumEngine.hpp"
 #include "engine/MetricsAggregator.hpp"
+#include "engine/TerrainFloor.hpp"
 
 struct ANativeWindow;
 
@@ -144,5 +145,6 @@ private:
 
   reactnativecesium::EngineConfig      config_;
   reactnativecesium::MetricsAggregator metrics_;
+  reactnativecesium::TerrainLeadState  terrainLead_{};
   double                               lastTickSeconds_ = 0.0;
 };

package/android/src/main/cpp/vulkan/VulkanBackend.cpp

@@ -607,6 +607,32 @@ void VulkanBackend::createSwapchain() {
   VkSwapchainCreateInfoKHR swapInfo{};
   swapInfo.sType            = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
   swapInfo.surface          = surface_;
+  // ── Surface rotation (Android pre-rotation) ──────────────────────────────
+  // We deliberately let the Android Compositor handle device rotation instead
+  // of pre-rotating the scene ourselves: present with an IDENTITY transform so
+  // the presentation engine rotates the rendered image to the current device
+  // orientation before scan-out.
+  //
+  // The alternative — preTransform = caps.currentTransform — only renders
+  // correctly if the app ALSO swaps the swapchain extent for 90/270 rotations
+  // AND bakes a matching rotation into every MVP/VP matrix. Doing neither (as
+  // before) made the scene render sideways once the device left its identity
+  // orientation: in landscape Android reports ROTATE_90/270, the compositor
+  // was told "already handled", and the un-rotated terrain appeared rotated
+  // 90° (ground stuck on the side of the screen). Since the swapchain image is
+  // the engine's only render target and modern Android display processors
+  // rotate essentially for free, the compositor path is both correct and cheap.
+  //
+  // Consequence: while the device is rotated, preTransform != currentTransform,
+  // so vkAcquireNextImageKHR / vkQueuePresentKHR return VK_SUBOPTIMAL_KHR every
+  // frame. That is expected here and must NOT trigger swapchain recreation (see
+  // beginFrame() / endFrame()); genuine size/orientation changes are driven by
+  // surfaceChanged() -> resize() instead.
+  VkSurfaceTransformFlagBitsKHR preTransform = caps.currentTransform;
+  if (caps.supportedTransforms & VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR) {
+    preTransform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
+  }
+
   swapInfo.minImageCount    = imageCount;
   swapInfo.imageFormat      = swapchainFormat_;
   swapInfo.imageColorSpace  = colorSpace;
@@ -614,7 +640,7 @@ void VulkanBackend::createSwapchain() {
   swapInfo.imageArrayLayers = 1;
   swapInfo.imageUsage       = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
   swapInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
-  swapInfo.preTransform     = caps.currentTransform;
+  swapInfo.preTransform     = preTransform;
   swapInfo.compositeAlpha   = compositeAlpha;
   swapInfo.presentMode      = pickPresentMode();
   swapInfo.clipped          = VK_TRUE;
@@ -2076,13 +2102,18 @@ void VulkanBackend::beginFrame(const FrameParams& /*params*/) {
     frameBegan_ = false;
     return;
   }
-  if (result == VK_ERROR_OUT_OF_DATE_KHR || result == VK_SUBOPTIMAL_KHR) {
+  // Only OUT_OF_DATE forces a recreate. VK_SUBOPTIMAL_KHR is expected on every
+  // frame while the device is rotated: we present with an IDENTITY preTransform
+  // and let the compositor rotate (see createSwapchain). The acquired image is
+  // still valid, so we proceed and use it. Genuine size/orientation changes
+  // arrive via surfaceChanged() -> resize() -> needsSwapchainRecreate_.
+  if (result == VK_ERROR_OUT_OF_DATE_KHR) {
     recreateSwapchain();
     result = vkAcquireNextImageKHR(device_, swapchain_, UINT64_MAX,
                                    imageAvailableSemaphores_[frameIndex_],
                                    VK_NULL_HANDLE, &imageIndex_);
   }
-  if (result != VK_SUCCESS) {
+  if (result != VK_SUCCESS && result != VK_SUBOPTIMAL_KHR) {
     frameBegan_ = false;
     return;
   }
@@ -2355,7 +2386,12 @@ void VulkanBackend::endFrame() {
   presentInfo.pImageIndices      = &imageIndex_;
 
   VkResult result = vkQueuePresentKHR(presentQueue_, &presentInfo);
-  if (result == VK_ERROR_OUT_OF_DATE_KHR || result == VK_SUBOPTIMAL_KHR) {
+  // VK_SUBOPTIMAL_KHR is expected every frame while the device is rotated (we
+  // present an IDENTITY preTransform and let the compositor rotate — see
+  // createSwapchain), so it must NOT trigger a recreate or we'd thrash the
+  // swapchain every frame. Real changes come through surfaceChanged() ->
+  // resize() -> needsSwapchainRecreate_.
+  if (result == VK_ERROR_OUT_OF_DATE_KHR) {
     needsSwapchainRecreate_ = true;
   }
 

package/cpp/engine/CameraIntegrator.cpp

@@ -110,7 +110,7 @@ void CameraIntegrator::updateAlphaBeta(
 }
 
 void CameraIntegrator::extrapolate(
-    AlphaBeta& s, TimePoint now, double maxRateAbs, double demand) {
+    AlphaBeta& s, TimePoint now, double maxRateAbs, double demand, bool wrapAngle) {
   double dt = std::chrono::duration<double>(now - s.tState).count();
   if (dt <= 0.0) {
     s.tState = now;
@@ -166,8 +166,9 @@ void CameraIntegrator::extrapolate(
   // sensor streams always deliver a new update before the grace window
   // expires, so this term is never active for them.
   if (measurementsStopped && tunables::kDemandPullTauSec > 1.0e-6) {
-    s.value += (1.0 - std::exp(-dt / tunables::kDemandPullTauSec))
-               * (demand - s.value);
+    const double delta = wrapAngle ? shortAngleDeltaDeg(s.value, demand)
+                                   : (demand - s.value);
+    s.value += (1.0 - std::exp(-dt / tunables::kDemandPullTauSec)) * delta;
   }
 }
 
@@ -203,21 +204,11 @@ void CameraIntegrator::setAltitude(double altitudeMeters) {
   }
 
   altitudeMeters = std::min(altitudeMeters, kMaxAltMeters);
-  
-  // Adaptive alpha based on altitude error magnitude:
-  // - Large changes (pinch gesture, cliffs) → fast (α ≈ 0.7)
-  // - Small changes (gentle terrain) → smooth (α ≈ 0.3)
-  const double error = std::abs(altitudeMeters - alt_.value);
-  constexpr double kMinAlpha = 0.3;   // Smooth for small changes
-  constexpr double kMaxAlpha = 0.7;   // Fast for large changes
-  constexpr double kErrorScale = 20.0; // 20m error → max alpha
-  
-  const double adaptiveAlpha = kMinAlpha + (kMaxAlpha - kMinAlpha) * 
-                               std::min(error / kErrorScale, 1.0);
-  
+
   updateAlphaBeta(alt_, altitudeMeters, now,
-                  adaptiveAlpha, tunables::kBetaAlt, false);
+                  tunables::kAlphaAlt, tunables::kBetaAlt, false);
   demand_.altitude = altitudeMeters;
+  enforceTerrainFloor();
 }
 
 void CameraIntegrator::setHeading(double headingDeg) {
@@ -261,13 +252,8 @@ void CameraIntegrator::setViewCorrection(const glm::dquat& q) {
 }
 
 void CameraIntegrator::setVerticalFov(double degrees) {
-  const auto now = Clock::now();
   std::lock_guard<std::mutex> g(mutex_);
-
-  const double residual = degrees - vfov_.value;
-  vfov_.value   += tunables::kAlphaVfov * residual;
-  vfov_.velocity = 0.0;
-  vfov_.tState   = now;
+  demand_.verticalFov = degrees;
 }
 
 void CameraIntegrator::teleport(const CameraParams& target) {
@@ -305,6 +291,12 @@ void CameraIntegrator::teleport(const CameraParams& target) {
   if (demand_.verticalFov <= 0.0) {
     demand_.verticalFov = vfov_.value;
   }
+
+  // A slew lands on the requested altitude. The next rendered frame samples
+  // the terrain at the new position and establishes a new floor.
+  terrainFloorActive_ = false;
+  terrainFloorMsl_    = 0.0;
+  lastStep_           = now;
 }
 
 CameraParams CameraIntegrator::step() {
@@ -328,13 +320,27 @@ CameraParams CameraIntegrator::step() {
     latLonCapDegSec = glm::degrees(groundCap / kEarthMeanRadiusM);
   }
 
-  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);
+  extrapolate(lat_,   now, latLonCapDegSec, demand_.latitude,  false);
+  extrapolate(lon_,   now, latLonCapDegSec, demand_.longitude, true);
+  extrapolate(alt_,   now, climbCap,        demand_.altitude,  false);
+  extrapolate(hdg_,   now, yawCap,          demand_.heading,   true);
+  extrapolate(pitch_, now, pitchCap,        demand_.pitch,     true);
+  extrapolate(roll_,  now, rollCap,         demand_.roll,      true);
+
+  double frameDt = 0.0;
+  if (lastStep_.time_since_epoch().count() > 0) {
+    frameDt = std::chrono::duration<double>(now - lastStep_).count();
+    if (frameDt < 0.0) frameDt = 0.0;
+    if (frameDt > tunables::kMaxFrameDtSec) frameDt = tunables::kMaxFrameDtSec;
+  }
+  lastStep_ = now;
+
+  if (frameDt > 0.0 && tunables::kVfovTauSec > 1.0e-6) {
+    const double blend = 1.0 - std::exp(-frameDt / tunables::kVfovTauSec);
+    vfov_.value += blend * (demand_.verticalFov - vfov_.value);
+    vfov_.velocity = 0.0;
+    vfov_.tState = now;
+  }
 
   hdg_.value = wrap360(hdg_.value);
   lat_.value = std::clamp(lat_.value, -90.0, 90.0);
@@ -343,12 +349,19 @@ CameraParams CameraIntegrator::step() {
   // continuous value for short-arc maths and the camera transform doesn't
   // care.
 
-  // viewCorrection: SLERP toward the latest target.
+  // viewCorrection: time-based SLERP toward the latest target.
   glm::dquat cur = glm::normalize(viewCorrActual_);
   glm::dquat tgt = glm::normalize(viewCorrTarget_);
   if (glm::dot(cur, tgt) < 0.0) tgt = -tgt;
-  viewCorrActual_ = glm::normalize(
-      glm::slerp(cur, tgt, tunables::kAlphaViewCorr));
+  double slerpT = 1.0;
+  if (tunables::kViewCorrTauSec > 1.0e-6) {
+    slerpT = (frameDt > 0.0)
+                 ? (1.0 - std::exp(-frameDt / tunables::kViewCorrTauSec))
+                 : 0.0;
+  }
+  viewCorrActual_ = glm::normalize(glm::slerp(cur, tgt, slerpT));
+
+  enforceTerrainFloor();
 
   CameraParams out;
   out.latitude       = lat_.value;
@@ -362,23 +375,40 @@ CameraParams CameraIntegrator::step() {
   return out;
 }
 
-void CameraIntegrator::clampActualAltitude(double newAltMsl) {
-  const auto now = Clock::now();
+void CameraIntegrator::setTerrainFloor(double floorMsl) {
   std::lock_guard<std::mutex> g(mutex_);
-  
-  // Instead of snapping, feed the clamped altitude through the alpha-beta
-  // tracker for smooth interpolation. This matches how heading/pitch/roll work.
-  updateAlphaBeta(alt_, newAltMsl, now,
-                  tunables::kAlphaAlt, tunables::kBetaAlt, false);
-  
-  // Only clamp DOWNWARD velocity to prevent descending through terrain.
-  // Allow upward velocity for smooth ascents over rising terrain.
-  if (alt_.velocity < 0.0) {
+  if (!std::isfinite(floorMsl)) return;
+  terrainFloorActive_ = true;
+  terrainFloorMsl_ = std::min(floorMsl, kMaxAltMeters);
+  enforceTerrainFloor();
+}
+
+void CameraIntegrator::clearTerrainFloor() {
+  std::lock_guard<std::mutex> g(mutex_);
+  terrainFloorActive_ = false;
+  terrainFloorMsl_ = 0.0;
+}
+
+void CameraIntegrator::clampActualAltitude(double newAltMsl) {
+  setTerrainFloor(newAltMsl);
+}
+
+void CameraIntegrator::enforceTerrainFloor() {
+  if (!terrainFloorActive_) return;
+
+  const bool inContact =
+      demand_.altitude <= terrainFloorMsl_ + tunables::kEpsAltitudeMeters;
+  if (inContact) {
+    // Contour contact: the floor sample owns altitude, both directions.
+    // Residual vertical velocity would carry the camera into the next face.
+    alt_.value = terrainFloorMsl_;
     alt_.velocity = 0.0;
+    return;
+  }
+  if (alt_.value < terrainFloorMsl_) {
+    alt_.value = terrainFloorMsl_;
+    if (alt_.velocity < 0.0) alt_.velocity = 0.0;
   }
-  
-  // Do not touch demand_.altitude — getDemand() should still report what the
-  // user asked for.
 }
 
 void CameraIntegrator::setRateCaps(const CameraRateCaps& caps) {
@@ -410,7 +440,12 @@ bool CameraIntegrator::isActive() const {
   if (std::abs(demand_.latitude  - lat_.value)  > tunables::kEpsLatLon)         return true;
   if (std::abs(shortAngleDeltaDeg(lon_.value, demand_.longitude))
         > tunables::kEpsLatLon)                                                  return true;
-  if (std::abs(demand_.altitude  - alt_.value)  > tunables::kEpsAltitudeMeters) return true;
+  if (terrainFloorActive_ &&
+      demand_.altitude <= terrainFloorMsl_ + tunables::kEpsAltitudeMeters) {
+    if (std::abs(alt_.value - terrainFloorMsl_) > tunables::kEpsAltitudeMeters) return true;
+  } else if (std::abs(demand_.altitude - alt_.value) > tunables::kEpsAltitudeMeters) {
+    return true;
+  }
   if (angleAbsDeltaDeg(demand_.heading, hdg_.value) > tunables::kEpsAngleDeg)   return true;
   if (angleAbsDeltaDeg(demand_.pitch,   pitch_.value) > tunables::kEpsAngleDeg) return true;
   if (angleAbsDeltaDeg(demand_.roll,    roll_.value)  > tunables::kEpsAngleDeg) return true;

package/cpp/engine/CameraIntegrator.hpp

@@ -73,11 +73,18 @@ public:
   // values and an instant runaway.
   CameraParams step();
 
-  // Terrain-floor write-back hook. Replaces the *actual* altitude value with
-  // `newAltMsl` and zeroes vertical velocity so the integrator does not
-  // immediately try to descend back through the floor. The *demand* altitude
-  // is left untouched — getDemand().altitude continues to reflect what the
-  // consumer asked for.
+  // Terrain floor in metres MSL. While active, the rendered altitude is never
+  // below this value. When the demand altitude is at or below the floor the
+  // camera rides it exactly (uphill and downhill), so a later setAltitude
+  // under the surface cannot pull the rendered camera back inside. Demand
+  // itself is left untouched.
+  void setTerrainFloor(double floorMsl);
+
+  // Drops the floor so the next slew or the next frame can establish a new
+  // one. Used by teleport().
+  void clearTerrainFloor();
+
+  // Sets the terrain floor to `newAltMsl`. Same as setTerrainFloor.
   void clampActualAltitude(double newAltMsl);
 
   // Runtime override of the rate caps (driven by view props). 0 = uncapped
@@ -122,9 +129,14 @@ private:
                               double alpha, double beta, bool wrapAngle);
 
   // 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, double demand);
+  // (per second; 0 = uncapped). `wrapAngle` makes the silence demand-pull
+  // take the short arc (longitude, heading, pitch, roll).
+  static void extrapolate(AlphaBeta& s, TimePoint now, double maxRateAbs,
+                          double demand, bool wrapAngle);
+
+  // Snap the rendered altitude onto the floor when the camera is in contact
+  // or currently below it. Demand is not modified.
+  void enforceTerrainFloor();
 
   mutable std::mutex mutex_;
 
@@ -141,6 +153,13 @@ private:
 
   // Runtime overrides; 0 = use compile-time defaults from EngineTunables.
   CameraRateCaps caps_{};
+
+  // Last step() timestamp. Drives the dt-based fov blend and view-correction
+  // slerp. Epoch means "no step yet".
+  TimePoint lastStep_{};
+
+  bool   terrainFloorActive_ = false;
+  double terrainFloorMsl_    = 0.0;
 };
 
 } // namespace reactnativecesium