react-native-cesium 1.2.18 → 1.2.19

package/cpp/engine/GltfToMesh.cpp

@@ -10,6 +10,7 @@
 
 #include <cmath>
 #include <cstring>
+#include <optional>
 
 namespace reactnativecesium {
 
@@ -64,12 +65,17 @@ GltfToMesh::convert(const CesiumGltf::Model& model,
 
         const CesiumGltf::PositionAccessorType posAccessor =
             CesiumGltf::getPositionAccessorView(gltf, primitive);
-        if (posAccessor.status() != CesiumGltf::AccessorViewStatus::Valid ||
-            posAccessor.size() <= 0)
+        const CesiumGltf::AccessorViewStatus posStatus =
+            std::visit(CesiumGltf::StatusFromAccessor{}, posAccessor);
+        if (posStatus != CesiumGltf::AccessorViewStatus::Valid)
+          return;
+
+        const int64_t vertexCount =
+            std::visit(CesiumGltf::CountFromAccessor{}, posAccessor);
+        if (vertexCount <= 0)
           return;
 
         const glm::dmat4 worldTransform = rootTransform * nodeTransform;
-        const int64_t    vertexCount    = posAccessor.size();
 
         // RTC centre = translation column of the world transform.
         // After applyRtcCenter this is the tile's ECEF centre embedded by
@@ -82,8 +88,11 @@ GltfToMesh::convert(const CesiumGltf::Model& model,
         prim.altitudes.reserve(static_cast<size_t>(vertexCount));
 
         for (int64_t i = 0; i < vertexCount; ++i) {
-          const auto&      p    = posAccessor[i];
-          const glm::dvec3 gltfLocal(p.value[0], p.value[1], p.value[2]);
+          const std::optional<glm::dvec3> pos = std::visit(
+              CesiumGltf::PositionFromAccessor{i}, posAccessor);
+          if (!pos)
+            continue;
+          const glm::dvec3 gltfLocal = *pos;
           // Absolute ECEF in double precision.
           const glm::dvec3 ecef(worldTransform * glm::dvec4(gltfLocal, 1.0));
           // Tile-local position (small float, retains full float32 precision

package/cpp/engine/ResourcePreparer.cpp

@@ -1,7 +1,7 @@
 #include "ResourcePreparer.hpp"
 
 #include <Cesium3DTilesSelection/Tile.h>
-#include <CesiumGltf/ImageAsset.h>
+#include <CesiumImage/ImageAsset.h>
 #include <CesiumGltf/Model.h>
 #include <CesiumUtility/JsonValue.h>
 
@@ -117,12 +117,12 @@ void ResourcePreparer::free(Cesium3DTilesSelection::Tile& /*tile*/,
 
 // ── Raster overlay pipeline ─────────────────────────────────────────────────
 
-void* ResourcePreparer::prepareRasterInLoadThread(CesiumGltf::ImageAsset& image,
+void* ResourcePreparer::prepareRasterInLoadThread(CesiumImage::ImageAsset& image,
                                                    const std::any&) {
   if (image.pixelData.empty() || image.width <= 0 || image.height <= 0) {
     return nullptr;
   }
-  if (image.compressedPixelFormat != CesiumGltf::GpuCompressedPixelFormat::NONE) {
+  if (image.compressedPixelFormat != CesiumImage::GpuCompressedPixelFormat::NONE) {
     return nullptr;
   }
   if (image.bytesPerChannel != 1) return nullptr;

package/cpp/engine/ResourcePreparer.hpp

@@ -64,7 +64,7 @@ public:
   void free(Cesium3DTilesSelection::Tile& tile, void* pLoadThreadResult,
             void* pMainThreadResult) noexcept override;
 
-  void* prepareRasterInLoadThread(CesiumGltf::ImageAsset& image,
+  void* prepareRasterInLoadThread(CesiumImage::ImageAsset& image,
                                   const std::any& rendererOptions) override;
   void* prepareRasterInMainThread(
       CesiumRasterOverlays::RasterOverlayTile& rasterTile,

package/cpp/engine/TerrainFloor.hpp

@@ -0,0 +1,70 @@
+#pragma once
+
+#include "CameraIntegrator.hpp"
+#include "CesiumEngine.hpp"
+#include "GeoidConverter.hpp"
+#include "TerrainHeight.hpp"
+
+#include <algorithm>
+
+namespace reactnativecesium {
+
+// Previous horizontal position and whether a real mesh sample has landed.
+// Shared by the iOS and Android render loops so both follow the same floor.
+struct TerrainLeadState {
+  bool hasPrev = false;
+  bool latched = false;
+  double prevLatDeg = 0.0;
+  double prevLonDeg = 0.0;
+};
+
+// A position slew drops the old floor and the one-frame lead. The next
+// rendered frame samples terrain at the new position.
+inline void noteTerrainSlew(CameraIntegrator& integrator, TerrainLeadState& lead) {
+  integrator.clearTerrainFloor();
+  lead = {};
+}
+
+// Samples the resident mesh at the stepped camera and one frame ahead, then
+// holds the rendered altitude to surface + clearance before the frame is drawn.
+// Demand is not modified. Returns the camera to render.
+inline CameraParams applyTerrainFloor(CesiumEngine& engine,
+                                      CameraIntegrator& integrator,
+                                      const CameraParams& stepped,
+                                      TerrainLeadState& lead,
+                                      double clearanceMeters) {
+  const double clearance = std::max(0.0, clearanceMeters);
+
+  double leadLat = stepped.latitude;
+  double leadLon = stepped.longitude;
+  const bool sampleLead = terrainLeadLatLon(
+      stepped.latitude, stepped.longitude,
+      lead.prevLatDeg, lead.prevLonDeg, lead.hasPrev,
+      leadLat, leadLon);
+
+  float nadir = 0.0f;
+  float ahead = 0.0f;
+  const bool hasNadir =
+      engine.sampleTerrainEllipsoidMeters(stepped.latitude, stepped.longitude, nadir);
+  const bool hasAhead = sampleLead &&
+      engine.sampleTerrainEllipsoidMeters(leadLat, leadLon, ahead);
+
+  float surface = 0.0f;
+  const bool haveMesh = resolveSurfaceEllipsoid(hasNadir, nadir, hasAhead, ahead, surface);
+  const double geoidN = mslToEllipsoidMeters(stepped.latitude, stepped.longitude, 0.0);
+  if (haveMesh) {
+    integrator.setTerrainFloor(static_cast<double>(surface) - geoidN + clearance);
+    lead.latched = true;
+  } else if (!lead.latched) {
+    // No mesh yet: stay at or above the ellipsoid. Once a mesh sample has
+    // landed, a later miss keeps the last floor instead of dropping to sea level.
+    integrator.setTerrainFloor(-geoidN + clearance);
+  }
+
+  lead.prevLatDeg = stepped.latitude;
+  lead.prevLonDeg = stepped.longitude;
+  lead.hasPrev = true;
+  return integrator.getActual();
+}
+
+} // namespace reactnativecesium

package/cpp/engine/TerrainHeight.hpp

@@ -0,0 +1,113 @@
+#pragma once
+
+#include <algorithm>
+#include <cmath>
+
+namespace reactnativecesium {
+
+// Pure terrain-floor helpers. No Cesium types, so the host harness can test
+// contour rules without a tileset.
+
+// Ignore a lead step shorter than this (hover) or longer than this (a slew,
+// not one frame of travel).
+inline constexpr double kTerrainLeadMinMeters = 0.05;
+inline constexpr double kTerrainLeadMaxMeters = 80.0;
+inline constexpr double kEarthRadiusMeters    = 6371008.7714150595;
+
+// Horizontal barycentric height. (pe, pn) and the triangle are in metres in
+// the same local east/north frame. Near-vertical triangles (terrain skirts)
+// have ~0 horizontal area and are rejected. On a hit, outHeight is the
+// interpolated ellipsoid height in metres.
+inline bool horizontalTriangleHeight(double pe, double pn,
+                                     double e0, double n0, float h0,
+                                     double e1, double n1, float h1,
+                                     double e2, double n2, float h2,
+                                     float& outHeight) {
+  const double v0e = e1 - e0;
+  const double v0n = n1 - n0;
+  const double v1e = e2 - e0;
+  const double v1n = n2 - n0;
+  const double v2e = pe - e0;
+  const double v2n = pn - n0;
+
+  const double dot00 = v0e * v0e + v0n * v0n;
+  const double dot01 = v0e * v1e + v0n * v1n;
+  const double dot11 = v1e * v1e + v1n * v1n;
+  const double dot02 = v0e * v2e + v0n * v2n;
+  const double dot12 = v1e * v2e + v1n * v2n;
+
+  // denom = (2 * signed horizontal area)^2.
+  const double denom = dot00 * dot11 - dot01 * dot01;
+  if (std::abs(denom) < 1.0e-12) return false;
+
+  const double e20 = e2 - e1;
+  const double n20 = n2 - n1;
+  const double edge2 = e20 * e20 + n20 * n20;
+  const double longest = std::sqrt(std::max(dot00, std::max(dot11, edge2)));
+  const double twiceArea = std::sqrt(std::abs(denom));
+  // Width of the triangle across its longest edge. Terrain skirts are
+  // vertical, so float error leaves them only millimetres wide.
+  if (longest < 1.0e-6 || twiceArea / longest < 0.05) return false;
+
+  const double inv = 1.0 / denom;
+  const double u = (dot11 * dot02 - dot01 * dot12) * inv;
+  const double v = (dot00 * dot12 - dot01 * dot02) * inv;
+  const double w = 1.0 - u - v;
+
+  constexpr double kEdge = -1.0e-4;
+  if (u < kEdge || v < kEdge || w < kEdge) return false;
+
+  outHeight = static_cast<float>(w * static_cast<double>(h0) +
+                                 u * static_cast<double>(h1) +
+                                 v * static_cast<double>(h2));
+  return true;
+}
+
+// Fresh each frame. The higher of the nadir sample and the one-frame lead.
+// A lower lead (past a crest) does not keep the previous peak. A higher lead
+// (valley turning uphill) raises the floor in this frame. No memory.
+inline bool resolveSurfaceEllipsoid(bool hasNadir, float nadir,
+                                    bool hasAhead, float ahead,
+                                    float& outHeight) {
+  if (hasNadir && hasAhead) {
+    outHeight = std::max(nadir, ahead);
+    return true;
+  }
+  if (hasNadir) {
+    outHeight = nadir;
+    return true;
+  }
+  if (hasAhead) {
+    outHeight = ahead;
+    return true;
+  }
+  return false;
+}
+
+// One frame ahead of (latDeg, lonDeg) along the last step. Returns false when
+// there is no distinct lead; out* are then equal to the current position.
+inline bool terrainLeadLatLon(double latDeg, double lonDeg,
+                              double prevLatDeg, double prevLonDeg,
+                              bool hasPrev,
+                              double& outLatDeg, double& outLonDeg) {
+  outLatDeg = latDeg;
+  outLonDeg = lonDeg;
+  if (!hasPrev) return false;
+
+  const double dLat = latDeg - prevLatDeg;
+  double dLon = lonDeg - prevLonDeg;
+  dLon = std::fmod(dLon + 540.0, 360.0) - 180.0;
+
+  const double latRad = latDeg * (3.14159265358979323846 / 180.0);
+  const double northM = dLat * (3.14159265358979323846 / 180.0) * kEarthRadiusMeters;
+  const double eastM =
+      dLon * (3.14159265358979323846 / 180.0) * kEarthRadiusMeters * std::cos(latRad);
+  const double dist = std::hypot(eastM, northM);
+  if (dist < kTerrainLeadMinMeters || dist > kTerrainLeadMaxMeters) return false;
+
+  outLatDeg = latDeg + dLat;
+  outLonDeg = lonDeg + dLon;
+  return true;
+}
+
+} // namespace reactnativecesium

package/cpp/engine/test/CameraIntegratorTest.cpp

@@ -11,7 +11,9 @@
 
 #include "../CameraIntegrator.hpp"
 #include "../EngineTunables.hpp"
+#include "../TerrainHeight.hpp"
 
+#include <algorithm>
 #include <chrono>
 #include <cmath>
 #include <cstdio>
@@ -189,6 +191,257 @@ static void testTerrainClamp() {
   CHECK(approxEq(demand.altitude, 100.0, 1e-6), "terrain_clamp.demand_preserved");
 }
 
+static void followFloors(const double* floors, int count, const char* label,
+                         bool expectRiseThenFall) {
+  CameraIntegrator integ;
+  CameraParams seed;
+  seed.altitude = floors[0];
+  integ.teleport(seed);
+  // A demand under every floor, plus a downward velocity sample, must not
+  // pull the rendered camera through the surface.
+  integ.setAltitude(0.0);
+  std::this_thread::sleep_for(std::chrono::milliseconds(20));
+  integ.setAltitude(0.0);
+
+  double prev = 0.0;
+  bool havePrev = false;
+  bool sawPeak = false;
+  for (int i = 0; i < count; ++i) {
+    const double floor = floors[i];
+    integ.setAltitude(0.0);
+    integ.setTerrainFloor(floor);
+    const CameraParams actual = integ.step();
+    char buf[96];
+    std::snprintf(buf, sizeof(buf), "%s.exact_%d", label, i);
+    CHECK(approxEq(actual.altitude, floor, 1e-6), buf);
+    CHECK(approxEq(integ.getDemand().altitude, 0.0, 1e-9), label);
+    if (havePrev) {
+      if (!expectRiseThenFall) {
+        std::snprintf(buf, sizeof(buf), "%s.monotonic_%d", label, i);
+        if (floors[i] > floors[i - 1]) {
+          CHECK(actual.altitude > prev - 1e-6, buf);
+        } else {
+          CHECK(actual.altitude < prev + 1e-6, buf);
+        }
+      }
+      if (expectRiseThenFall && floors[i] < floors[i - 1]) {
+        sawPeak = true;
+        std::snprintf(buf, sizeof(buf), "%s.descends_%d", label, i);
+        CHECK(actual.altitude < prev - 1e-6, buf);
+      }
+      if (expectRiseThenFall && sawPeak && floors[i] > floors[i - 1]) {
+        std::snprintf(buf, sizeof(buf), "%s.climbs_%d", label, i);
+        CHECK(actual.altitude > prev + 1e-6, buf);
+      }
+    }
+    prev = actual.altitude;
+    havePrev = true;
+  }
+}
+
+static void testUphillContact() {
+  const double floors[] = {100.0, 110.0, 120.0, 130.0};
+  followFloors(floors, 4, "uphill", false);
+}
+
+static void testDownhillContact() {
+  const double floors[] = {130.0, 120.0, 110.0, 100.0};
+  followFloors(floors, 4, "downhill", false);
+}
+
+static void testCrest() {
+  const double floors[] = {100.0, 110.0, 120.0, 110.0, 100.0};
+  followFloors(floors, 5, "crest", true);
+}
+
+static void testValley() {
+  const double floors[] = {120.0, 110.0, 100.0, 110.0, 120.0};
+  followFloors(floors, 5, "valley", true);
+
+  // Descent velocity must not carry the camera into the rising face.
+  CameraIntegrator integ;
+  CameraParams seed;
+  seed.altitude = 100.0;
+  integ.teleport(seed);
+  integ.clearTerrainFloor();
+  integ.setAltitude(0.0);
+  std::this_thread::sleep_for(std::chrono::milliseconds(20));
+  integ.setAltitude(0.0);
+  CHECK(integ.getActual().altitude < 100.0, "valley.velocity_descended");
+  integ.setTerrainFloor(110.0);
+  CHECK(approxEq(integ.getActual().altitude, 110.0, 1e-6), "valley.climb_exact");
+  CHECK(approxEq(integ.step().altitude, 110.0, 1e-6), "valley.climb_holds");
+}
+
+static void testSetAltitudeUnderFloor() {
+  CameraIntegrator integ;
+  CameraParams seed;
+  seed.altitude = 100.0;
+  integ.teleport(seed);
+  integ.setTerrainFloor(150.0);
+  integ.setAltitude(10.0);
+  CHECK(approxEq(integ.getActual().altitude, 150.0, 1e-6), "under_floor.actual");
+  CHECK(approxEq(integ.getDemand().altitude, 10.0, 1e-9), "under_floor.demand");
+  const CameraParams stepped = integ.step();
+  CHECK(approxEq(stepped.altitude, 150.0, 1e-6), "under_floor.after_step");
+}
+
+static void testIdleOnFloor() {
+  CameraIntegrator integ;
+  CameraParams seed;
+  seed.altitude = 100.0;
+  integ.teleport(seed);
+  integ.setTerrainFloor(150.0);
+  integ.setAltitude(40.0);
+  const CameraParams stepped = integ.step();
+  CHECK(approxEq(stepped.altitude, 150.0, 1e-6), "idle_floor.actual");
+  CHECK(!integ.isActive(), "idle_floor.inactive");
+}
+
+static void testFlyingAboveFloor() {
+  CameraIntegrator integ;
+  CameraParams seed;
+  seed.altitude = 500.0;
+  integ.teleport(seed);
+  integ.setTerrainFloor(100.0);
+  const CameraParams stepped = integ.step();
+  CHECK(approxEq(stepped.altitude, 500.0, 1e-3), "above_floor.untouched");
+  CHECK(approxEq(integ.getDemand().altitude, 500.0, 1e-9), "above_floor.demand");
+}
+
+static double wrap180(double deg) {
+  double v = std::fmod(deg + 180.0, 360.0);
+  if (v < 0.0) v += 360.0;
+  return v - 180.0;
+}
+
+static void testHeadingShortPull() {
+  CameraIntegrator integ;
+  CameraParams seed;
+  seed.heading = 350.0;
+  integ.teleport(seed);
+  integ.setHeading(10.0);
+  std::this_thread::sleep_for(std::chrono::milliseconds(250));
+  bool onShortArc = true;
+  for (int i = 0; i < 90; ++i) {
+    std::this_thread::sleep_for(std::chrono::milliseconds(20));
+    const double h = integ.step().heading;
+    if (!(h >= 330.0 || h <= 40.0)) onShortArc = false;
+  }
+  CHECK(onShortArc, "heading_pull.short_arc");
+  const double end = integ.getActual().heading;
+  const double err = std::abs(wrap180(end - 10.0));
+  CHECK(err < 2.0, "heading_pull.converged");
+}
+
+static void testLongitudeShortPull() {
+  CameraIntegrator integ;
+  CameraParams seed;
+  seed.longitude = 179.0;
+  integ.teleport(seed);
+  integ.setPosition(seed.latitude, -179.0);
+  std::this_thread::sleep_for(std::chrono::milliseconds(250));
+  bool onShortArc = true;
+  for (int i = 0; i < 90; ++i) {
+    std::this_thread::sleep_for(std::chrono::milliseconds(20));
+    const double wrapped = wrap180(integ.step().longitude);
+    if (!(std::abs(wrapped) > 90.0)) onShortArc = false;
+  }
+  CHECK(onShortArc, "lon_pull.short_arc");
+  const double err = std::abs(wrap180(integ.getActual().longitude - (-179.0)));
+  CHECK(err < 2.0, "lon_pull.converged");
+}
+
+static void testVerticalFovConverges() {
+  CameraIntegrator integ;
+  CameraParams seed;
+  seed.verticalFov = 60.0;
+  integ.teleport(seed);
+  integ.setVerticalFov(30.0);
+  std::this_thread::sleep_for(std::chrono::milliseconds(16));
+  const double first = integ.step().verticalFov;
+  CHECK(first < 59.0 && first > 40.0, "vfov.first_step_eases");
+  CameraParams mid;
+  for (int i = 0; i < 80; ++i) {
+    std::this_thread::sleep_for(std::chrono::milliseconds(16));
+    mid = integ.step();
+  }
+  CHECK(approxEq(mid.verticalFov, 30.0, 0.5), "vfov.converged");
+  std::this_thread::sleep_for(std::chrono::milliseconds(200));
+  const double held = integ.step().verticalFov;
+  CHECK(approxEq(held, 30.0, 0.5), "vfov.stays");
+}
+
+static void testLeadAndTriangle() {
+  float out = 0.0f;
+  CHECK(resolveSurfaceEllipsoid(true, 100.0f, true, 90.0f, out) && out == 100.0f,
+        "lead.crest_no_sticky_peak");
+  CHECK(resolveSurfaceEllipsoid(true, 100.0f, true, 110.0f, out) && out == 110.0f,
+        "lead.valley_raises");
+  CHECK(resolveSurfaceEllipsoid(true, 120.0f, false, 0.0f, out) && out == 120.0f,
+        "lead.nadir_only");
+  CHECK(!resolveSurfaceEllipsoid(false, 0.0f, false, 0.0f, out), "lead.neither");
+
+  double lat = 0.0, lon = 0.0;
+  const bool slew = terrainLeadLatLon(0.0, 1.0, 0.0, 0.0, true, lat, lon);
+  CHECK(!slew, "lead.slew_ignored");
+
+  const bool step = terrainLeadLatLon(0.0, 0.0001, 0.0, 0.0, true, lat, lon);
+  CHECK(step, "lead.one_frame");
+  CHECK(approxEq(lat, 0.0, 1e-12), "lead.lat");
+  CHECK(approxEq(lon, 0.0002, 1e-9), "lead.lon_ahead");
+
+  float h = -1.0f;
+  const bool hit = horizontalTriangleHeight(
+      2.0, 2.0,
+      0.0, 0.0, 0.0f,
+      10.0, 0.0, 0.0f,
+      0.0, 10.0, 30.0f,
+      h);
+  CHECK(hit && approxEq(h, 6.0, 1e-3), "tri.interpolated");
+
+  float outside = 0.0f;
+  CHECK(!horizontalTriangleHeight(
+            20.0, 20.0,
+            0.0, 0.0, 0.0f,
+            10.0, 0.0, 0.0f,
+            0.0, 10.0, 30.0f,
+            outside),
+        "tri.outside");
+
+  float skirt = 0.0f;
+  CHECK(!horizontalTriangleHeight(
+            1.0, 0.0,
+            0.0, 0.0, 100.0f,
+            0.0, 0.0, 0.0f,
+            5.0, 0.0, 100.0f,
+            skirt),
+        "tri.skirt_rejected");
+  // 100 m edge, 1 mm of horizontal width: a float-error skirt, not terrain.
+  CHECK(!horizontalTriangleHeight(
+            0.0, 0.0005,
+            0.0, 0.0, 100.0f,
+            100.0, 0.0, 100.0f,
+            0.0, 0.001, 0.0f,
+            skirt),
+        "tri.thin_skirt_rejected");
+
+  float low = 0.0f, high = 0.0f;
+  const bool lowHit = horizontalTriangleHeight(
+      2.0, 2.0,
+      0.0, 0.0, 5.0f,
+      10.0, 0.0, 5.0f,
+      0.0, 10.0, 5.0f,
+      low);
+  const bool highHit = horizontalTriangleHeight(
+      2.0, 2.0,
+      0.0, 0.0, 20.0f,
+      10.0, 0.0, 20.0f,
+      0.0, 10.0, 20.0f,
+      high);
+  CHECK(lowHit && highHit && std::max(low, high) == 20.0f, "tri.overlap_keeps_higher");
+}
+
 int main() {
   testStepInput();
   testConstantVelocity();
@@ -196,6 +449,17 @@ int main() {
   testLongPause();
   testGestureEndBleed();
   testTerrainClamp();
+  testUphillContact();
+  testDownhillContact();
+  testCrest();
+  testValley();
+  testSetAltitudeUnderFloor();
+  testIdleOnFloor();
+  testFlyingAboveFloor();
+  testHeadingShortPull();
+  testLongitudeShortPull();
+  testVerticalFovConverges();
+  testLeadAndTriangle();
   if (g_failures == 0) {
     std::fprintf(stderr, "\nALL TESTS PASSED.\n");
   } else {

package/ios/CesiumBridge.mm

@@ -4,8 +4,8 @@
 #include "engine/CameraIntegrator.hpp"
 #include "engine/CesiumEngine.hpp"
 #include "engine/EngineTunables.hpp"
-#include "engine/GeoidConverter.hpp"
 #include "engine/MetricsAggregator.hpp"
+#include "engine/TerrainFloor.hpp"
 #include "metal/MetalBackend.h"
 
 #include <glm/gtc/quaternion.hpp>
@@ -48,6 +48,8 @@
   // Sentinel (epoch) means "no loading seen yet".
   std::chrono::steady_clock::time_point _lastLoadingTime;
 
+  reactnativecesium::TerrainLeadState _terrainLead;
+
   NSString* _cacheDir;
 }
 
@@ -230,6 +232,7 @@
   // jump, not a boresight reset. Use setViewCorrection(identity) to clear it.
   p.viewCorrection = _integrator->getActual().viewCorrection;
   _integrator->teleport(p);
+  reactnativecesium::noteTerrainSlew(*_integrator, _terrainLead);
   // Apply directly to the engine so the next render uses the teleported value
   // without one frame of "almost there" interpolation.
   _engine->camera().setParams(p);
@@ -382,32 +385,9 @@
     // The integrator owns its own clock now — see CameraIntegrator::step().
     // `nowSeconds` is still used below for the FPS-EMA dt only.
     auto actual = _integrator->step();
-
-    // ── Terrain floor following using integrator's alpha-beta smoothing ───
-    // Set demand altitude to terrain floor, let the integrator's alpha-beta
-    // tracker smoothly interpolate. The tracker already provides adaptive
-    // exponential easing (alpha=0.6, beta=0.05 in EngineTunables.hpp).
-    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 floorEllipsoid = static_cast<double>(_engine->terrainFloorEllipsoidMeters());
-      const double floorMsl = floorEllipsoid - geoidN;
-      const double minMsl = floorMsl + static_cast<double>(minAbove);
-
-      // Continuously update demand to follow terrain
-      const double demandAlt = _integrator->getDemand().altitude;
-      if (demandAlt <= 0.0) {
-        _integrator->setAltitude(minMsl);
-        actual = _integrator->getActual();
-      }
-      
-      // Safety floor: hard clamp if already below terrain (shouldn't happen with look-ahead)
-      if (actual.altitude < minMsl) {
-        _integrator->clampActualAltitude(minMsl);
-        actual = _integrator->getActual();
-      }
-    }
+    actual = reactnativecesium::applyTerrainFloor(
+        *_engine, *_integrator, actual, _terrainLead,
+        static_cast<double>(_engine->getConfig().minAltitudeAboveTerrain));
 
     _engine->camera().setParams(actual);
 

package/lib/typescript/src/specs/cesium-view.nitro.d.ts

@@ -84,12 +84,13 @@ export interface CesiumViewProps extends HybridViewProps {
      */
     taskProcessorThreads?: number;
     /**
-     * Minimum clearance above the loaded terrain surface, in metres (added on top of the
-     * terrain MSL height at the camera position). Default 0 (no constraint).
-     * Set to e.g. 2 to prevent the camera from going underground.
-     * The clamp runs only after terrain tiles have been sampled; until then the demand
-     * altitude is used as-is. The demand altitude is not modified — only the rendered
-     * (actual) camera may be raised to meet this minimum.
+     * Clearance above the rendered terrain surface, in metres, added on top of the
+     * terrain height at the camera position. The floor is always on. 0 means the
+     * camera may sit on the surface and may not go below it.
+     * Until a terrain tile has been sampled, the camera is held at or above the
+     * WGS84 ellipsoid. The demand altitude is not modified — only the rendered
+     * (actual) camera is held to this minimum, and it follows the surface down
+     * when the demand is at or below the floor.
      */
     minAltitudeAboveTerrain?: number;
     /** Maximum yaw rate (degrees per second). 0 = uncapped. */

package/lib/typescript/src/specs/cesium-view.nitro.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cesium-view.nitro.d.ts","sourceRoot":"","sources":["../../../../src/specs/cesium-view.nitro.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"cesium-view.nitro.d.ts","sourceRoot":"","sources":["../../../../src/specs/cesium-view.nitro.ts"],"names":[],"mappings":"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"}

package/nitrogen/generated/android/ReactNativeCesiumOnLoad.cpp

@@ -30,7 +30,7 @@ int initialize(JavaVM* vm) {
 }
 
 struct JHybridCesiumViewSpecImpl: public jni::JavaClass<JHybridCesiumViewSpecImpl, JHybridCesiumViewSpec::JavaPart> {
-  static constexpr auto kJavaDescriptor = "Lcom/reactnativecesium/HybridCesiumView;";
+  static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/reactnativecesium/HybridCesiumView;";
   static std::shared_ptr<JHybridCesiumViewSpec> create() {
     static const auto constructorFn = javaClassStatic()->getConstructor<JHybridCesiumViewSpecImpl::javaobject()>();
     jni::local_ref<JHybridCesiumViewSpec::JavaPart> javaPart = javaClassStatic()->newObject(constructorFn);

package/nitrogen/generated/android/c++/JCameraState.hpp

@@ -17,7 +17,7 @@ namespace margelo::nitro::reactnativecesium {
   using namespace facebook;
 
   /**
-   * The C++ JNI bridge between the C++ struct "CameraState" and the the Kotlin data class "CameraState".
+   * The C++ JNI bridge between the C++ struct "CameraState" and the Kotlin data class "CameraState".
    */
   struct JCameraState final: public jni::JavaClass<JCameraState> {
   public:

package/nitrogen/generated/android/c++/JCesiumMetrics.hpp

@@ -17,7 +17,7 @@ namespace margelo::nitro::reactnativecesium {
   using namespace facebook;
 
   /**
-   * The C++ JNI bridge between the C++ struct "CesiumMetrics" and the the Kotlin data class "CesiumMetrics".
+   * The C++ JNI bridge between the C++ struct "CesiumMetrics" and the Kotlin data class "CesiumMetrics".
    */
   struct JCesiumMetrics final: public jni::JavaClass<JCesiumMetrics> {
   public: