react-native-cesium 1.0.6 → 1.2.0

package/cpp/engine/EngineTunables.hpp

@@ -0,0 +1,79 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+
+namespace reactnativecesium {
+
+// Centralised default values that previously lived as anonymous magic numbers
+// scattered across the engine and platform backends. Keep this header tiny and
+// dependency-free so it is safe to include from any translation unit.
+namespace tunables {
+
+// CPU pipeline stages allowed to be in flight at once on the GPU. Both Metal
+// (triple-buffered MTLBuffer slots) and Vulkan (in-flight fences / command
+// buffers) use this constant as their core depth, so changing it here
+// propagates to every backend.
+inline constexpr int kMaxFramesInFlight = 3;
+
+// Upper bound on simultaneously live raster overlay textures held by the
+// Vulkan descriptor pool. Cesium can cache many hundreds of tiles at high
+// zoom; 2048 gives substantial headroom without exhausting GPU descriptor
+// state.
+inline constexpr int kMaxRasterTextures = 2048;
+
+// Cesium Native tileset cache (decoded geometry / textures kept in RAM).
+inline constexpr int64_t kDefaultMaxCachedBytes = 256LL * 1024LL * 1024LL;
+
+// SqliteCache row budget — number of cached HTTP responses Cesium keeps on
+// disk between sessions. 4k rows is a reasonable phone default; tablets can
+// happily go to 16k.
+inline constexpr int32_t kDefaultSqliteCacheMaxRows = 4096;
+
+// FrameResult initial reservations (CPU-side merged geometry buffer) used to
+// avoid reallocations during the first few frames of a session. The buffers
+// are then re-used (only re-grown if visible geometry exceeds capacity).
+inline constexpr std::size_t kFrameResultPositionFloatReserve = 512u * 1024u;
+inline constexpr std::size_t kFrameResultIndexUint32Reserve   = 3u * 1024u * 1024u;
+
+// Tileset selection knobs (mirrored to TilesetOptions defaults).
+inline constexpr double  kDefaultMaximumScreenSpaceError      = 32.0;
+inline constexpr int32_t kDefaultMaximumSimultaneousTileLoads = 12;
+inline constexpr int32_t kDefaultLoadingDescendantLimit       = 20;
+
+// Camera smoothing constants — shared between platform bridges so jank /
+// motion feel is identical on iOS and Android.
+inline constexpr double kSmoothAltitude     = 25.0;
+inline constexpr double kSmoothHeading      = 30.0;
+inline constexpr double kSmoothPitch        = 50.0;
+inline constexpr double kSmoothRoll         = 50.0;
+inline constexpr double kSmoothViewCorr     = 50.0;
+inline constexpr double kEpsLatLon          = 1e-7;
+inline constexpr double kEpsAltitudeMeters  = 0.1;
+inline constexpr double kEpsAngleDeg        = 0.05;
+inline constexpr double kEpsQuatDot         = 1e-8;
+
+// Lat/lon are smoothed adaptively: τ = clamp(α · ewmaInterval, τmin, τmax),
+// then per frame we apply 1 - exp(-dt/τ). α<1 means the camera converges
+// before the next sample lands. With ~60 Hz gestures the EWMA interval is
+// ~16 ms ⇒ τ at the floor (5 ms) ⇒ ≤1-frame trail (indistinguishable from
+// the previous snap). With a 1 Hz GPS feed τ ≈ 450 ms ⇒ ~95 % converged
+// before the next sample arrives, removing the per-second teleport.
+inline constexpr double kSmoothPositionAlpha   = 0.45;
+inline constexpr double kSmoothPositionTauMin  = 0.005;
+inline constexpr double kSmoothPositionTauMax  = 0.6;
+// Genuine teleports (e.g. setCamera(NewYork) → setCamera(Tokyo)) skip the
+// smoother — easing across the planet over 600 ms looks worse than a snap.
+inline constexpr double kPosSnapThroughDeg     = 0.5;
+// EWMA mixing factor for the inter-arrival interval of setCamera calls.
+inline constexpr double kEwmaIntervalAlpha     = 0.3;
+
+// Metrics throttle: emit telemetry every N rendered frames.
+inline constexpr int kMetricsEmitEveryFrames = 20;
+
+// Idle-probe interval (seconds): when the engine is idle, periodically tick
+// to catch late tile completions without redundant full draws.
+inline constexpr double kIdleProbeSeconds = 0.25;
+
+} // namespace tunables
+} // namespace reactnativecesium

package/cpp/engine/GeoidConverter.cpp

@@ -0,0 +1,36 @@
+#include "GeoidConverter.hpp"
+
+#include "../third_party/egm96/EGM96.h"
+
+#include <cmath>
+
+namespace reactnativecesium {
+
+namespace {
+
+double normalizeLongitudeDegrees(double longitudeDeg) {
+  if (!std::isfinite(longitudeDeg)) return 0.0;
+  double wrapped = std::fmod(longitudeDeg + 180.0, 360.0);
+  if (wrapped < 0.0) wrapped += 360.0;
+  return wrapped - 180.0;
+}
+
+} // namespace
+
+double mslToEllipsoidMeters(double latitudeDeg,
+                            double longitudeDeg,
+                            double mslMeters) {
+  if (!std::isfinite(latitudeDeg) || !std::isfinite(longitudeDeg) ||
+      !std::isfinite(mslMeters)) {
+    return mslMeters;
+  }
+
+  const double normalizedLon = normalizeLongitudeDegrees(longitudeDeg);
+  const double geoidOffset =
+      egm96_compute_altitude_offset(latitudeDeg, normalizedLon);
+
+  if (!std::isfinite(geoidOffset)) return mslMeters;
+  return mslMeters + geoidOffset;
+}
+
+} // namespace reactnativecesium

package/cpp/engine/GeoidConverter.hpp

@@ -0,0 +1,10 @@
+#pragma once
+
+namespace reactnativecesium {
+
+/// Converts orthometric height (MSL) to ellipsoidal height (HAE, WGS84).
+double mslToEllipsoidMeters(double latitudeDeg,
+                            double longitudeDeg,
+                            double mslMeters);
+
+} // namespace reactnativecesium

package/cpp/engine/GlobeCamera.cpp

@@ -1,4 +1,5 @@
 #include "GlobeCamera.hpp"
+#include "GeoidConverter.hpp"
 
 #include <CesiumGeospatial/GlobeTransforms.h>
 
@@ -43,9 +44,11 @@ void GlobeCamera::recompute() const {
   dirty_ = false;
 
   const auto& ellipsoid = CesiumGeospatial::Ellipsoid::WGS84;
+  const double ellipsoidAltitude =
+      mslToEllipsoidMeters(params_.latitude, params_.longitude, params_.altitude);
   CesiumGeospatial::Cartographic carto(glm::radians(params_.longitude),
                                        glm::radians(params_.latitude),
-                                       params_.altitude);
+                                       ellipsoidAltitude);
   ecefPosition_ = ellipsoid.cartographicToCartesian(carto);
 
   glm::dmat4 enuToECEF =
@@ -117,10 +120,12 @@ void GlobeCamera::computeHeadingPitchToward(double targetLatDeg,
   recompute();
 
   const auto& ellipsoid = CesiumGeospatial::Ellipsoid::WGS84;
+  const double targetEllipsoidAlt =
+      mslToEllipsoidMeters(targetLatDeg, targetLonDeg, targetAltMeters);
   CesiumGeospatial::Cartographic targetCarto(
       glm::radians(targetLonDeg),
       glm::radians(targetLatDeg),
-      targetAltMeters);
+      targetEllipsoidAlt);
   glm::dvec3 targetEcef = ellipsoid.cartographicToCartesian(targetCarto);
   glm::dvec3 dirEcef    = glm::normalize(targetEcef - ecefPosition_);
 

package/cpp/engine/MetricsAggregator.cpp

@@ -0,0 +1,71 @@
+#include "MetricsAggregator.hpp"
+
+#include "EngineTunables.hpp"
+
+#include <regex>
+
+namespace reactnativecesium {
+
+std::string MetricsAggregator::stripHtmlToPlain(const std::string& html) {
+  if (html.empty()) return "";
+  // The regexes are static so we pay the (very real) cost of compilation only
+  // once per process. std::regex matches behaviour previously implemented twice
+  // (NSRegularExpression on iOS, std::regex on Android) — both bridges now hit
+  // this path so we cannot drift.
+  static const std::regex tagRx("<[^>]+>");
+  static const std::regex wsRx("\\s+");
+  std::string plain = std::regex_replace(html, tagRx, " ");
+  plain = std::regex_replace(plain, wsRx, " ");
+  size_t start = plain.find_first_not_of(" \t\n\r");
+  size_t end   = plain.find_last_not_of(" \t\n\r");
+  if (start == std::string::npos) return "";
+  return plain.substr(start, end - start + 1);
+}
+
+std::optional<MetricsSnapshot>
+MetricsAggregator::tick(double dt, const FrameResult& frame, bool tlsConfigured) {
+  const double instFps = (dt > 1e-6) ? (1.0 / dt) : 0.0;
+  fpsEma_ = (fpsEma_ <= 1e-6) ? instFps : (fpsEma_ * 0.85 + instFps * 0.15);
+
+  if (++metricsTick_ < tunables::kMetricsEmitEveryFrames) {
+    return std::nullopt;
+  }
+  metricsTick_ = 0;
+
+  latest_.fps                = fpsEma_;
+  latest_.tilesRendered      = frame.tilesRendered;
+  latest_.tilesLoading       = frame.tilesLoading;
+  latest_.tilesVisited       = frame.tilesVisited;
+  latest_.ionTokenConfigured = frame.ionTokenConfigured;
+  latest_.tilesetReady       = frame.tilesetActive;
+  latest_.tlsConfigured      = tlsConfigured;
+
+  if (!frame.creditHtmlLines.empty()) {
+    std::string joined;
+    joined.reserve(256);
+    for (const auto& html : frame.creditHtmlLines) {
+      if (!joined.empty()) joined += "|";
+      joined += html;
+    }
+    if (joined != lastCreditHtmlJoined_) {
+      lastCreditHtmlJoined_ = std::move(joined);
+      std::string credits;
+      credits.reserve(256);
+      for (const auto& html : frame.creditHtmlLines) {
+        if (html.find("Error: Invalid Credit") != std::string::npos) continue;
+        std::string chunk = stripHtmlToPlain(html);
+        if (chunk.empty()) continue;
+        if (!credits.empty()) credits += " \xC2\xB7 "; // " · "
+        credits += chunk;
+      }
+      latest_.creditsPlainText = std::move(credits);
+    }
+  } else {
+    lastCreditHtmlJoined_.clear();
+    latest_.creditsPlainText.clear();
+  }
+
+  return latest_;
+}
+
+} // namespace reactnativecesium

package/cpp/engine/MetricsAggregator.hpp

@@ -0,0 +1,54 @@
+#pragma once
+
+#include "../renderer/RenderTypes.hpp"
+
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace reactnativecesium {
+
+// Per-frame snapshot the platform shells expose to JS via Nitro / JNI.
+struct MetricsSnapshot {
+  double fps;
+  int    tilesRendered;
+  int    tilesLoading;
+  int    tilesVisited;
+  bool   ionTokenConfigured;
+  bool   tilesetReady;
+  bool   tlsConfigured;
+  std::string creditsPlainText;
+};
+
+// Aggregates per-frame metrics on the render thread, throttling emission
+// (every kMetricsEmitEveryFrames frames) so we do not spam the JS bridge.
+//
+// Usage: call `tick(dt, frameResult, tlsConfigured)` once per rendered frame;
+// take the optional return value as the "publish to JS" signal. The internal
+// FPS EMA persists between ticks.
+class MetricsAggregator {
+public:
+  MetricsAggregator() = default;
+
+  // Returns std::nullopt on most frames; returns the latest values once the
+  // throttle counter wraps. Idempotent w.r.t. credit text — only re-strips
+  // HTML when the joined HTML lines actually change frame-to-frame.
+  std::optional<MetricsSnapshot>
+  tick(double dt, const FrameResult& frame, bool tlsConfigured);
+
+  // Returns the most recently *computed* snapshot (fps EMA + counters); used
+  // by the platform read-back accessors. Cheap.
+  const MetricsSnapshot& latest() const { return latest_; }
+
+  // Strips HTML tags + collapses whitespace + trims. Pure utility, exposed so
+  // platform shells that prefer to render their own credit lines can reuse it.
+  static std::string stripHtmlToPlain(const std::string& html);
+
+private:
+  double fpsEma_      = 0.0;
+  int    metricsTick_ = 0;
+  std::string lastCreditHtmlJoined_;
+  MetricsSnapshot latest_{};
+};
+
+} // namespace reactnativecesium

package/cpp/engine/TileLifecycleManager.cpp

@@ -1,8 +1,5 @@
 #include "TileLifecycleManager.hpp"
 
-#include <Cesium3DTilesSelection/TileContent.h>
-#include <Cesium3DTilesSelection/TileSelectionState.h>
-
 namespace reactnativecesium {
 
 void TileLifecycleManager::stampTileUsed(TileGPUResources* resources) {
@@ -18,13 +15,4 @@ bool TileLifecycleManager::shouldDeferFree(
   return resources->lastUsedFrame >= frameNumber_;
 }
 
-bool TileLifecycleManager::isRefinementLocked(
-    const Cesium3DTilesSelection::Tile& /*tile*/) const {
-  // Cesium Native guarantees that free() is not called on tiles that are
-  // currently needed for rendering (including refined parent tiles whose
-  // children are loading). Therefore, explicit refinement locking is not
-  // required here.
-  return false;
-}
-
 } // namespace reactnativecesium

package/cpp/engine/TileLifecycleManager.hpp

@@ -2,8 +2,6 @@
 
 #include "../renderer/RenderTypes.hpp"
 
-#include <Cesium3DTilesSelection/Tile.h>
-
 #include <cstdint>
 
 namespace reactnativecesium {
@@ -16,7 +14,6 @@ public:
   void stampTileUsed(TileGPUResources* resources);
 
   bool shouldDeferFree(const TileGPUResources* resources) const;
-  bool isRefinementLocked(const Cesium3DTilesSelection::Tile& tile) const;
 
 private:
   uint64_t frameNumber_ = 0;

package/cpp/third_party/egm96/EGM96.c

@@ -0,0 +1,289 @@
+/*
+ * Copyright (c) 2006 D.Ineiev <ineiev@yahoo.co.uk>
+ * Copyright (c) 2020 Emeric Grange <emeric.grange@gmail.com>
+ *
+ * This software is provided 'as-is', without any express or implied warranty.
+ * In no event will the authors be held liable for any damages arising from
+ * the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+/*
+ * This program is designed for the calculation of a geoid undulation at a point
+ * whose latitude and longitude is specified.
+ *
+ * This program is designed to be used with the constants of EGM96 and those of
+ * the WGS84(g873) system. The undulation will refer to the WGS84 ellipsoid.
+ *
+ * It's designed to use the potential coefficient model EGM96 and a set of
+ * spherical harmonic coefficients of a correction term.
+ * The correction term is composed of several different components, the primary
+ * one being the conversion of a height anomaly to a geoid undulation.
+ * The principles of this procedure were initially described in the paper:
+ * - use of potential coefficient models for geoid undulation determination using
+ *   a spherical harmonic representation of the height anomaly/geoid undulation
+ *   difference by R.H. Rapp, Journal of Geodesy, 1996.
+ *
+ * This program is a modification of the program described in the following report:
+ * - a fortran program for the computation of gravimetric quantities from high
+ * degree spherical harmonic expansions, Richard H. Rapp, report 334, Department
+ * of Geodetic Science and Surveying, the Ohio State University, Columbus, 1982
+ */
+
+#include "EGM96.h"
+#include "EGM96_data.h"
+
+#include <math.h>
+#include <stdlib.h>
+#if __STDC_VERSION__ >= 201112L && !defined(__STDC_NO_THREADS__)
+#include <threads.h>
+#else
+#ifndef thread_local
+#define thread_local _Thread_local
+#endif
+#endif
+
+/* ************************************************************************** */
+
+#define _coeffs (65341) //!< Size of correction and harmonic coefficients arrays (361*181)
+#define _nmax   (360)   //!< Maximum degree and orders of harmonic coefficients.
+#define _361    (361)
+
+/* ************************************************************************** */
+
+double hundu(const double p[_coeffs+1],
+             const double sinml[_361+1], const double cosml[_361+1],
+             const double gr, const double re)
+{
+    // WGS84 gravitational constant in m³/s² (mass of Earth’s atmosphere included)
+    const double GM = 0.3986004418e15;
+    // WGS84 datum surface equatorial radius
+    const double ae = 6378137.0;
+
+    const double ar = ae / re;
+    double arn = ar;
+    double ac = 0;
+    double a = 0;
+
+    unsigned k = 3;
+    for (unsigned n = 2; n <= _nmax; n++)
+    {
+        arn *= ar;
+        k++;
+        double sumc = p[k] * egm96_data[k][0];
+        double sum  = p[k] * egm96_data[k][2];
+
+        for (unsigned m = 1; m <= n; m++)
+        {
+            k++;
+            double tempc = (egm96_data[k][0] * cosml[m]) + (egm96_data[k][1] * sinml[m]);
+            double temp  = (egm96_data[k][2] * cosml[m]) + (egm96_data[k][3] * sinml[m]);
+            sumc += p[k] * tempc;
+            sum  += p[k] * temp;
+        }
+        ac += sumc;
+        a += sum * arn;
+    }
+    ac += egm96_data[1][0] + (p[2] * egm96_data[2][0]) + (p[3] * ((egm96_data[3][0] * cosml[1]) + (egm96_data[3][1] * sinml[1])));
+
+    // Add haco = ac/100 to convert height anomaly on the ellipsoid to the undulation
+    // Add -0.53m to make undulation refer to the WGS84 ellipsoid
+
+    return ((a * GM) / (gr * re)) + (ac / 100.0) - 0.53;
+}
+
+void dscml(const double rlon, double sinml[_361+1], double cosml[_361+1])
+{
+    const double a = sin(rlon);
+    const double b = cos(rlon);
+
+    sinml[1] = a;
+    cosml[1] = b;
+    sinml[2] = (2 * b * a);
+    cosml[2] = (2 * b * b) - 1;
+
+    for (unsigned m = 3; m <= _nmax; m++)
+    {
+        sinml[m] = (2 * b * sinml[m-1]) - sinml[m-2];
+        cosml[m] = (2 * b * cosml[m-1]) - cosml[m-2];
+    }
+}
+
+/*!
+ * \param m: order.
+ * \param theta: Colatitude (in radians).
+ * \param rleg: Normalized legendre function.
+ *
+ * This subroutine computes all normalized legendre function in 'rleg'.
+ * The dimensions of array 'rleg' must be at least equal to nmax+1.
+ * All calculations are in double precision.
+ *
+ * Original programmer: Oscar L. Colombo, Dept. of Geodetic Science the Ohio State University, August 1980.
+ * ineiev: I removed the derivatives, for they are never computed here.
+ */
+void legfdn(const unsigned m, const double theta, double rleg[_361+1])
+{
+    static thread_local double drts[1301], dirt[1301];
+    static thread_local int ir = 0;
+
+    const unsigned nmax1 = _nmax + 1;
+    const unsigned nmax2p = (2 * _nmax) + 1;
+    const unsigned m1 = m + 1;
+    const unsigned m2 = m + 2;
+    const unsigned m3 = m + 3;
+
+    unsigned n, n1, n2;
+
+    if (ir == 0)
+    {
+        ir = 1;
+        for (n = 1; n <= nmax2p; n++)
+        {
+            drts[n] = sqrt(n);
+            dirt[n] = 1 / drts[n];
+        }
+    }
+
+    const double cothet = cos(theta);
+    const double sithet = sin(theta);
+
+    // compute the legendre functions
+    double rlnn[_361+1];
+    rlnn[1] = 1;
+    rlnn[2] = sithet * drts[3];
+    for (n1 = 3; n1 <= m1; n1++)
+    {
+        n = n1 - 1;
+        n2 = 2 * n;
+        rlnn[n1] = drts[n2 + 1] * dirt[n2] * sithet * rlnn[n];
+    }
+
+    switch (m)
+    {
+        case 1:
+            rleg[2] = rlnn[2];
+            rleg[3] = drts[5] * cothet * rleg[2];
+            break;
+        case 0:
+            rleg[1] = 1;
+            rleg[2] = cothet * drts[3];
+            break;
+    }
+    rleg[m1] = rlnn[m1];
+
+    if (m2 <= nmax1)
+    {
+        rleg[m2] = drts[(2 * m1) + 1] * cothet * rleg[m1];
+        if (m3 <= nmax1)
+        {
+            for (n1 = m3; n1 <= nmax1; n1++)
+            {
+                n = n1 - 1;
+                if ((!m && n < 2) || (m == 1 && n < 3)) continue;
+                n2 = 2 * n;
+                rleg[n1] = drts[n2+1] * dirt[n+m] * dirt[n-m] * ((drts[n2-1] * cothet * rleg[n1-1]) - (drts[n+m-1] * drts[n-m-1] * dirt[n2-3] * rleg[n1-2]));
+            }
+        }
+    }
+}
+
+/*!
+ * \param lat: Latitude (in radians).
+ * \param lon: Longitude (in radians).
+ * \param re: Geocentric radius.
+ * \param rlat: Geocentric latitude.
+ * \param gr: Normal gravity (m/sec²).
+ *
+ * This subroutine computes geocentric distance to the point, the geocentric
+ * latitude, and an approximate value of normal gravity at the point based the
+ * constants of the WGS84(g873) system are used.
+ */
+void radgra(const double lat, const double lon, double *rlat, double *gr, double *re)
+{
+    const double a = 6378137.0;
+    const double e2 = 0.00669437999013;
+    const double geqt = 9.7803253359;
+    const double k = 0.00193185265246;
+    const double t1 = sin(lat) * sin(lat);
+    const double n = a / sqrt(1.0 - (e2 * t1));
+    const double t2 = n * cos(lat);
+    const double x = t2 * cos(lon);
+    const double y = t2 * sin(lon);
+    const double z = (n * (1 - e2)) * sin(lat);
+
+    *re = sqrt((x * x) + (y * y) + (z * z));            // compute the geocentric radius
+    *rlat = atan(z / sqrt((x * x) + (y * y)));          // compute the geocentric latitude
+    *gr = geqt * (1 + (k * t1)) / sqrt(1 - (e2 * t1));  // compute normal gravity (m/sec²)
+}
+
+/*!
+ * \brief Compute the geoid undulation from the EGM96 potential coefficient model, for a given latitude and longitude.
+ * \param lat: Latitude (in radians).
+ * \param lon: Longitude (in radians).
+ * \return The geoid undulation / altitude offset (in meters).
+ */
+double undulation(const double lat, const double lon)
+{
+    // Allocate large arrays on heap instead of stack to avoid stack overflow
+    // on threads with limited stack size (e.g., iOS DispatchQueue threads)
+    double* p = (double*)malloc((_coeffs+1) * sizeof(double));
+    double* sinml = (double*)malloc((_361+1) * sizeof(double));
+    double* cosml = (double*)malloc((_361+1) * sizeof(double));
+    double* rleg = (double*)malloc((_361+1) * sizeof(double));
+    
+    if (!p || !sinml || !cosml || !rleg) {
+        free(p);
+        free(sinml);
+        free(cosml);
+        free(rleg);
+        return 0.0;
+    }
+    
+    double rlat, gr, re;
+
+    // compute the geocentric latitude, geocentric radius, normal gravity
+    radgra(lat, lon, &rlat, &gr, &re);
+    rlat = (M_PI / 2) - rlat;
+
+    const unsigned nmax1 = _nmax + 1;
+    for (unsigned j = 1; j <= nmax1; j++)
+    {
+        unsigned m = j - 1;
+        legfdn(m, rlat, rleg);
+        for (unsigned i = j ; i <= nmax1; i++)
+        {
+            p[(((i - 1) * i) / 2) + m + 1] = rleg[i];
+        }
+    }
+    dscml(lon, sinml, cosml);
+
+    double result = hundu(p, sinml, cosml, gr, re);
+    
+    free(p);
+    free(sinml);
+    free(cosml);
+    free(rleg);
+    
+    return result;
+}
+
+/* ************************************************************************** */
+
+double egm96_compute_altitude_offset(const double latitude, const double longitude)
+{
+    const double rad = (180.0 / M_PI);
+    return undulation(latitude / rad, longitude / rad);
+}
+
+/* ************************************************************************** */

package/cpp/third_party/egm96/EGM96.h

@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2006 D.Ineiev <ineiev@yahoo.co.uk>
+ * Copyright (c) 2020 Emeric Grange <emeric.grange@gmail.com>
+ *
+ * This software is provided 'as-is', without any express or implied warranty.
+ * In no event will the authors be held liable for any damages arising from
+ * the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+#ifndef EGM96_H
+#define EGM96_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* ************************************************************************** */
+
+/*!
+ * \brief Compute the geoid undulation from the EGM96 potential coefficient model, for a given latitude and longitude.
+ * \param latitude: Latitude (in degrees).
+ * \param longitude: Longitude (in degrees).
+ * \return The geoid undulation / altitude offset (in meters).
+ */
+double egm96_compute_altitude_offset(double latitude, double longitude);
+
+/* ************************************************************************** */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // EGM96_H