react-native-cesium 1.2.2 → 1.2.4

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

@@ -1,6 +1,5 @@
 #include "CesiumBridgeAndroid.h"
 
-#include "engine/CameraSmoother.hpp"
 #include "engine/EngineTunables.hpp"
 #include "engine/GeoidConverter.hpp"
 #include "vulkan/VulkanBackend.h"
@@ -11,12 +10,19 @@
 #include <glm/gtc/quaternion.hpp>
 
 #include <algorithm>
+#include <chrono>
 #include <cmath>
 
 #define LOG_TAG "CesiumBridge"
-#define LOGI(...) __android_log_print(ANDROID_LOG_INFO,  LOG_TAG, __VA_ARGS__)
 #define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)
 
+CesiumBridgeAndroid::~CesiumBridgeAndroid() {
+  // shutdown() is idempotent — calling it from the dtor in addition to the
+  // explicit nativeShutdown JNI path is safe and guarantees the
+  // ANativeWindow ref is released even if the lifecycle hooks misfire.
+  shutdown();
+}
+
 void CesiumBridgeAndroid::init(JNIEnv* env, jobject surface, int width, int height,
                                const std::string& cacheDir,
                                const std::string& cacertPath) {
@@ -25,29 +31,34 @@ void CesiumBridgeAndroid::init(JNIEnv* env, jobject surface, int width, int heig
   viewportWidth_  = width;
   viewportHeight_ = height;
 
-  ANativeWindow* window = ANativeWindow_fromSurface(env, surface);
-  if (!window) {
+  // ANativeWindow_fromSurface() acquires one strong reference on the
+  // returned window; we own it now and must call ANativeWindow_release() in
+  // shutdown() (or before re-acquiring) to avoid leaking it on every view
+  // remount.
+  nativeWindow_ = ANativeWindow_fromSurface(env, surface);
+  if (!nativeWindow_) {
     LOGE("Failed to get ANativeWindow from Surface");
     return;
   }
 
   vulkanBackend_ = std::make_unique<reactnativecesium::VulkanBackend>();
   vulkanBackend_->setCacheDir(cacheDir);
-  vulkanBackend_->initialize(window, width, height);
+  vulkanBackend_->initialize(nativeWindow_, width, height);
 
   frameResult_ = std::make_unique<reactnativecesium::FrameResult>();
   buildEngine();
   initialized_ = true;
-  target_.requestForceRender();
+  forceRender_.store(true, std::memory_order_release);
 }
 
 void CesiumBridgeAndroid::buildEngine() {
   engine_ = std::make_unique<reactnativecesium::CesiumEngine>();
   engine_->initialize(config_);
 
-  // Seed the demand target from the engine's initial camera so the first
-  // frame is not a "snap from default" jump.
-  target_.setAll(engine_->camera().getParams());
+  // Seed the integrator from the engine's initial camera so the first frame
+  // is not a "snap from default" jump.
+  integrator_ = std::make_unique<reactnativecesium::CameraIntegrator>(
+      engine_->camera().getParams());
 
   auto* backendPtr = vulkanBackend_.get();
   engine_->getResourcePreparer()->setGPUTextureCreator(
@@ -71,20 +82,42 @@ void CesiumBridgeAndroid::buildEngine() {
 void CesiumBridgeAndroid::applyEngineConfig() {
   if (!engine_) return;
   engine_->updateConfig(config_);
-  target_.requestForceRender();
+  forceRender_.store(true, std::memory_order_release);
 }
 
 void CesiumBridgeAndroid::shutdown() {
+  // Mark uninitialised up-front so any racing prop setters become no-ops
+  // instead of touching half-destroyed state.
+  initialized_ = false;
+
   if (engine_) engine_->shutdown();
   if (vulkanBackend_) vulkanBackend_->shutdown();
-  initialized_ = false;
+
+  // Release the engine (and therefore its SqliteCache) here rather than
+  // waiting for ~CesiumBridgeAndroid. During fast refresh the next
+  // CesiumView can mount and open the same cesium_cache.db file before
+  // this JNI peer is destroyed; freeing the unique_ptr now closes the
+  // SQLite handle synchronously and avoids "database is locked"
+  // warnings from the new engine's SqliteCache.
+  integrator_.reset();
+  engine_.reset();
+  vulkanBackend_.reset();
+  frameResult_.reset();
+
+  // Release the ANativeWindow ref acquired in init(). Order matters: the
+  // Vulkan backend's vkDestroySurfaceKHR must have run first (which it has,
+  // inside vulkanBackend_->shutdown() above) before we drop our reference.
+  if (nativeWindow_) {
+    ANativeWindow_release(nativeWindow_);
+    nativeWindow_ = nullptr;
+  }
 }
 
 void CesiumBridgeAndroid::resize(int width, int height) {
   viewportWidth_  = width;
   viewportHeight_ = height;
   if (vulkanBackend_) vulkanBackend_->resize(width, height);
-  target_.requestForceRender();
+  forceRender_.store(true, std::memory_order_release);
 }
 
 void CesiumBridgeAndroid::updateIonAccessToken(const std::string& token,
@@ -98,36 +131,77 @@ void CesiumBridgeAndroid::updateImageryAssetId(int64_t assetId) {
   config_.ionImageryAssetId = (assetId <= 0) ? 1 : assetId;
   if (initialized_ && engine_) {
     engine_->setImageryAssetId(config_.ionImageryAssetId);
-    target_.requestForceRender();
+    forceRender_.store(true, std::memory_order_release);
   }
 }
 
-void CesiumBridgeAndroid::updateCamera(double lat, double lon, double alt,
-                                       double heading, double pitch, double roll) {
-  if (!initialized_) return;
-  target_.setHpr(lat, lon, alt, heading, pitch, roll);
-}
-
-void CesiumBridgeAndroid::updateCameraQuaternion(
-    double lat, double lon, double alt, double heading, double pitch,
-    double roll, double qw, double qx, double qy, double qz) {
-  if (!initialized_) return;
-  target_.setHpr(lat, lon, alt, heading, pitch, roll);
-  const double ql2 = qw * qw + qx * qx + qy * qy + qz * qz;
-  glm::dquat q;
-  if (ql2 < 1e-20) {
-    q = glm::dquat(1.0, 0.0, 0.0, 0.0);
-  } else {
-    const double inv = 1.0 / std::sqrt(ql2);
-    q = glm::dquat(qw * inv, qx * inv, qy * inv, qz * inv);
-  }
-  target_.setViewCorrection(q);
+// ── Per-DoF camera demand setters ─────────────────────────────────────────
+
+void CesiumBridgeAndroid::setPosition(double lat, double lon) {
+  if (!initialized_ || !integrator_) return;
+  integrator_->setPosition(lat, lon);
+  forceRender_.store(true, std::memory_order_release);
+}
+
+void CesiumBridgeAndroid::setAltitude(double alt) {
+  if (!initialized_ || !integrator_) return;
+  integrator_->setAltitude(alt);
+  forceRender_.store(true, std::memory_order_release);
+}
+
+void CesiumBridgeAndroid::setHeading(double headingDeg) {
+  if (!initialized_ || !integrator_) return;
+  integrator_->setHeading(headingDeg);
+  forceRender_.store(true, std::memory_order_release);
+}
+
+void CesiumBridgeAndroid::setAttitude(double pitchDeg, double rollDeg) {
+  if (!initialized_ || !integrator_) return;
+  integrator_->setAttitude(pitchDeg, rollDeg);
+  forceRender_.store(true, std::memory_order_release);
+}
+
+void CesiumBridgeAndroid::setViewCorrection(double qw, double qx, double qy, double qz) {
+  if (!initialized_ || !integrator_) return;
+  integrator_->setViewCorrection(glm::dquat(qw, qx, qy, qz));
+  forceRender_.store(true, std::memory_order_release);
+}
+
+void CesiumBridgeAndroid::teleport(double lat, double lon, double alt,
+                                   double heading, double pitch, double roll,
+                                   double vfov) {
+  if (!initialized_ || !integrator_) return;
+  reactnativecesium::CameraParams p;
+  p.latitude       = lat;
+  p.longitude      = lon;
+  p.altitude       = alt;
+  p.heading        = heading;
+  p.pitch          = pitch;
+  p.roll           = roll;
+  p.verticalFov    = vfov;
+  p.viewCorrection = integrator_->getActual().viewCorrection;
+  integrator_->teleport(p);
+  engine_->camera().setParams(p);
+  forceRender_.store(true, std::memory_order_release);
 }
 
 void CesiumBridgeAndroid::setVerticalFovDeg(double degrees) {
-  if (!initialized_) return;
-  engine_->camera().setVerticalFovDegrees(degrees);
-  target_.requestForceRender();
+  if (!initialized_ || !integrator_) return;
+  integrator_->setVerticalFov(degrees);
+  forceRender_.store(true, std::memory_order_release);
+}
+
+void CesiumBridgeAndroid::setRateCaps(double yawDegSec, double pitchDegSec,
+                                      double rollDegSec, double climbMps,
+                                      double groundMps) {
+  if (!initialized_ || !integrator_) return;
+  reactnativecesium::CameraRateCaps caps;
+  caps.maxYawRateDegSec   = yawDegSec;
+  caps.maxPitchRateDegSec = pitchDegSec;
+  caps.maxRollRateDegSec  = rollDegSec;
+  caps.maxClimbRateMps    = climbMps;
+  caps.maxGroundSpeedMps  = groundMps;
+  integrator_->setRateCaps(caps);
 }
 
 void CesiumBridgeAndroid::setMaximumScreenSpaceError(double v) {
@@ -145,7 +219,7 @@ void CesiumBridgeAndroid::setLoadingDescendantLimit(int32_t v) {
 
 void CesiumBridgeAndroid::setMsaaSampleCount(int samples) {
   if (vulkanBackend_) vulkanBackend_->setMsaaSampleCount(samples);
-  target_.requestForceRender();
+  forceRender_.store(true, std::memory_order_release);
 }
 
 void CesiumBridgeAndroid::setMaximumCachedMiB(int32_t v) {
@@ -190,13 +264,9 @@ void CesiumBridgeAndroid::setLodTransitionLength(double v) {
   if (initialized_) applyEngineConfig();
 }
 void CesiumBridgeAndroid::setSqliteCacheMaxRows(int32_t v) {
-  // Re-creating SqliteCache requires a tileset rebuild, so we only honour the
-  // value on next init.
   config_.sqliteCacheMaxRows = std::max(64, v);
 }
 void CesiumBridgeAndroid::setTaskProcessorThreads(int32_t v) {
-  // Worker pool is sized once per CesiumEngine. We mirror it for the next
-  // initialize().
   config_.taskProcessorThreads = std::max(0, v);
 }
 void CesiumBridgeAndroid::setMinAltitudeAboveTerrain(float v) {
@@ -204,70 +274,55 @@ void CesiumBridgeAndroid::setMinAltitudeAboveTerrain(float v) {
   if (initialized_) applyEngineConfig();
 }
 
-void CesiumBridgeAndroid::markNeedsRender() { target_.requestForceRender(); }
+void CesiumBridgeAndroid::markNeedsRender() {
+  forceRender_.store(true, std::memory_order_release);
+}
 
 bool CesiumBridgeAndroid::shouldRenderNextFrame() {
-  if (!initialized_ || !engine_) return false;
-
-  if (target_.consumeForceRender()) {
-    // Force-render request observed: keep it sticky for one frame so we make
-    // it through to the actual GPU encode below.
-    target_.requestForceRender();
-    return true;
-  }
-  if (frameResult_->tilesLoading > 0 || !frameResult_->tilesetActive) {
-    return true;
-  }
+  if (!initialized_ || !engine_ || !frameResult_) return false;
+  if (forceRender_.load(std::memory_order_acquire))            return true;
+  if (frameResult_->tilesLoading > 0 || !frameResult_->tilesetActive) return true;
   // Keep rendering at full speed until we have actual terrain tiles loaded.
   // This ensures tiles start loading immediately instead of falling into idle
   // mode (250ms intervals) before any content appears.
-  if (frameResult_->tilesRendered < 5) {
-    return true;
-  }
-  if (target_.isDirty()) {
-    const auto cur = engine_->camera().getParams();
-    const auto tgt = target_.snapshot();
-    if (reactnativecesium::CameraTargetState::deltaExceedsEpsilon(cur, tgt)) {
-      return true;
-    }
-    target_.clearDirty();
-  }
+  if (frameResult_->tilesRendered < 5)                         return true;
+  if (integrator_ && integrator_->isActive())                  return true;
   return false;
 }
 
-void CesiumBridgeAndroid::renderFrame(double dt) {
-  if (!initialized_) return;
+void CesiumBridgeAndroid::renderFrame(double nowSeconds) {
+  if (!initialized_ || !integrator_) return;
+  if (!engine_ || !vulkanBackend_ || !frameResult_) return;
 
-  // Consume the force-render flag here (it may have been re-armed by
-  // shouldRenderNextFrame; either way we're rendering this frame).
-  (void)target_.consumeForceRender();
+  forceRender_.store(false, std::memory_order_release);
 
-  const auto cur    = engine_->camera().getParams();
-  const auto tgt    = target_.snapshot();
-  auto smooth = reactnativecesium::CameraSmoother::step(cur, tgt, dt);
+  // 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) {
     const double geoidOffset =
-        reactnativecesium::mslToEllipsoidMeters(smooth.latitude, smooth.longitude, 0.0);
+        reactnativecesium::mslToEllipsoidMeters(actual.latitude, actual.longitude, 0.0);
     const double camEllipsoid =
-        reactnativecesium::mslToEllipsoidMeters(smooth.latitude, smooth.longitude, smooth.altitude);
+        reactnativecesium::mslToEllipsoidMeters(actual.latitude, actual.longitude, actual.altitude);
     const double minEllipsoid =
         static_cast<double>(engine_->terrainFloorEllipsoidMeters()) + minAbove;
     if (camEllipsoid < minEllipsoid) {
-      smooth.altitude = minEllipsoid - geoidOffset;
+      const double clampedMsl = minEllipsoid - geoidOffset;
+      integrator_->clampActualAltitude(clampedMsl);
+      actual.altitude = clampedMsl;
     }
   }
 
-  engine_->camera().setParams(smooth);
-
-  // If we converged, clear the dirty flag so the next idle vsync can early-out.
-  if (!reactnativecesium::CameraTargetState::deltaExceedsEpsilon(smooth, tgt)) {
-    target_.clearDirty();
-  }
+  engine_->camera().setParams(actual);
 
   engine_->updateFrame(viewportWidth_, viewportHeight_, *frameResult_);
+  // Metrics-only dt; integrator already advanced by wall clock above.
+  double dt = (lastTickSeconds_ > 0.0) ? (nowSeconds - lastTickSeconds_) : (1.0 / 60.0);
+  lastTickSeconds_ = nowSeconds;
+  if (dt > 0.5 || dt <= 0.0) dt = 1.0 / 60.0;
   metrics_.tick(dt, *frameResult_, !config_.tlsCaBundlePath.empty());
 
   reactnativecesium::FrameParams params;
@@ -276,38 +331,65 @@ void CesiumBridgeAndroid::renderFrame(double dt) {
   vulkanBackend_->endFrame();
 }
 
-double CesiumBridgeAndroid::readCameraLatitude() {
-  return engine_ ? engine_->camera().getParams().latitude : 0.0;
+// ── Actual camera readback ─────────────────────────────────────────────────
+
+double CesiumBridgeAndroid::readActualLatitude() {
+  return integrator_ ? integrator_->getActual().latitude : 0.0;
+}
+double CesiumBridgeAndroid::readActualLongitude() {
+  return integrator_ ? integrator_->getActual().longitude : 0.0;
+}
+double CesiumBridgeAndroid::readActualAltitude() {
+  return integrator_ ? integrator_->getActual().altitude : 0.0;
+}
+double CesiumBridgeAndroid::readActualHeading() {
+  return integrator_ ? integrator_->getActual().heading : 0.0;
+}
+double CesiumBridgeAndroid::readActualPitch() {
+  return integrator_ ? integrator_->getActual().pitch : 0.0;
+}
+double CesiumBridgeAndroid::readActualRoll() {
+  return integrator_ ? integrator_->getActual().roll : 0.0;
+}
+double CesiumBridgeAndroid::readActualVerticalFovDeg() {
+  return integrator_ ? integrator_->getActual().verticalFov : 60.0;
+}
+
+// ── Demand camera readback ─────────────────────────────────────────────────
+
+double CesiumBridgeAndroid::readDemandLatitude() {
+  return integrator_ ? integrator_->getDemand().latitude : 0.0;
 }
-double CesiumBridgeAndroid::readCameraLongitude() {
-  return engine_ ? engine_->camera().getParams().longitude : 0.0;
+double CesiumBridgeAndroid::readDemandLongitude() {
+  return integrator_ ? integrator_->getDemand().longitude : 0.0;
 }
-double CesiumBridgeAndroid::readCameraAltitude() {
-  return engine_ ? engine_->camera().getParams().altitude : 0.0;
+double CesiumBridgeAndroid::readDemandAltitude() {
+  return integrator_ ? integrator_->getDemand().altitude : 0.0;
 }
-double CesiumBridgeAndroid::readCameraHeading() {
-  return engine_ ? engine_->camera().getParams().heading : 0.0;
+double CesiumBridgeAndroid::readDemandHeading() {
+  return integrator_ ? integrator_->getDemand().heading : 0.0;
 }
-double CesiumBridgeAndroid::readCameraPitch() {
-  return engine_ ? engine_->camera().getParams().pitch : 0.0;
+double CesiumBridgeAndroid::readDemandPitch() {
+  return integrator_ ? integrator_->getDemand().pitch : 0.0;
 }
-double CesiumBridgeAndroid::readCameraRoll() {
-  return engine_ ? engine_->camera().getParams().roll : 0.0;
+double CesiumBridgeAndroid::readDemandRoll() {
+  return integrator_ ? integrator_->getDemand().roll : 0.0;
 }
-double CesiumBridgeAndroid::readVerticalFovDeg() {
-  return engine_ ? engine_->camera().getVerticalFovDegrees() : 60.0;
+double CesiumBridgeAndroid::readDemandVerticalFovDeg() {
+  return integrator_ ? integrator_->getDemand().verticalFov : 60.0;
 }
+
 double CesiumBridgeAndroid::readViewCorrectionW() {
-  return engine_ ? engine_->camera().getParams().viewCorrection.w : 1.0;
+  return integrator_ ? integrator_->getActual().viewCorrection.w : 1.0;
 }
 double CesiumBridgeAndroid::readViewCorrectionX() {
-  return engine_ ? engine_->camera().getParams().viewCorrection.x : 0.0;
+  return integrator_ ? integrator_->getActual().viewCorrection.x : 0.0;
 }
 double CesiumBridgeAndroid::readViewCorrectionY() {
-  return engine_ ? engine_->camera().getParams().viewCorrection.y : 0.0;
+  return integrator_ ? integrator_->getActual().viewCorrection.y : 0.0;
 }
 double CesiumBridgeAndroid::readViewCorrectionZ() {
-  return engine_ ? engine_->camera().getParams().viewCorrection.z : 0.0;
+  return integrator_ ? integrator_->getActual().viewCorrection.z : 0.0;
 }
 
 // ── JNI native method implementations ──────────────────────────────────────────
@@ -363,19 +445,38 @@ Java_com_margelo_nitro_reactnativecesium_CesiumBridgeJNI_nativeUpdateImageryAsse
   getBridge(ptr)->updateImageryAssetId(assetId);
 }
 
+// ── Per-DoF camera setters ─────────────────────────────────────────────────
 JNIEXPORT void JNICALL
-Java_com_margelo_nitro_reactnativecesium_CesiumBridgeJNI_nativeUpdateCamera(
-    JNIEnv*, jobject, jlong ptr, jdouble lat, jdouble lon, jdouble alt,
-    jdouble heading, jdouble pitch, jdouble roll) {
-  getBridge(ptr)->updateCamera(lat, lon, alt, heading, pitch, roll);
+Java_com_margelo_nitro_reactnativecesium_CesiumBridgeJNI_nativeSetPosition(
+    JNIEnv*, jobject, jlong ptr, jdouble lat, jdouble lon) {
+  getBridge(ptr)->setPosition(lat, lon);
+}
+JNIEXPORT void JNICALL
+Java_com_margelo_nitro_reactnativecesium_CesiumBridgeJNI_nativeSetAltitude(
+    JNIEnv*, jobject, jlong ptr, jdouble alt) {
+  getBridge(ptr)->setAltitude(alt);
+}
+JNIEXPORT void JNICALL
+Java_com_margelo_nitro_reactnativecesium_CesiumBridgeJNI_nativeSetHeading(
+    JNIEnv*, jobject, jlong ptr, jdouble headingDeg) {
+  getBridge(ptr)->setHeading(headingDeg);
+}
+JNIEXPORT void JNICALL
+Java_com_margelo_nitro_reactnativecesium_CesiumBridgeJNI_nativeSetAttitude(
+    JNIEnv*, jobject, jlong ptr, jdouble pitchDeg, jdouble rollDeg) {
+  getBridge(ptr)->setAttitude(pitchDeg, rollDeg);
+}
+JNIEXPORT void JNICALL
+Java_com_margelo_nitro_reactnativecesium_CesiumBridgeJNI_nativeSetViewCorrection(
+    JNIEnv*, jobject, jlong ptr, jdouble qw, jdouble qx, jdouble qy, jdouble qz) {
+  getBridge(ptr)->setViewCorrection(qw, qx, qy, qz);
 }
-
 JNIEXPORT void JNICALL
-Java_com_margelo_nitro_reactnativecesium_CesiumBridgeJNI_nativeUpdateCameraQuaternion(
-    JNIEnv*, jobject, jlong ptr, jdouble lat, jdouble lon, jdouble alt,
-    jdouble heading, jdouble pitch, jdouble roll,
-    jdouble qw, jdouble qx, jdouble qy, jdouble qz) {
-  getBridge(ptr)->updateCameraQuaternion(lat, lon, alt, heading, pitch, roll, qw, qx, qy, qz);
+Java_com_margelo_nitro_reactnativecesium_CesiumBridgeJNI_nativeTeleport(
+    JNIEnv*, jobject, jlong ptr,
+    jdouble lat, jdouble lon, jdouble alt,
+    jdouble heading, jdouble pitch, jdouble roll, jdouble vfov) {
+  getBridge(ptr)->teleport(lat, lon, alt, heading, pitch, roll, vfov);
 }
 
 JNIEXPORT void JNICALL
@@ -384,6 +485,15 @@ Java_com_margelo_nitro_reactnativecesium_CesiumBridgeJNI_nativeSetVerticalFovDeg
   getBridge(ptr)->setVerticalFovDeg(deg);
 }
 
+JNIEXPORT void JNICALL
+Java_com_margelo_nitro_reactnativecesium_CesiumBridgeJNI_nativeSetRateCaps(
+    JNIEnv*, jobject, jlong ptr,
+    jdouble yawDegSec, jdouble pitchDegSec, jdouble rollDegSec,
+    jdouble climbMps, jdouble groundMps) {
+  getBridge(ptr)->setRateCaps(yawDegSec, pitchDegSec, rollDegSec,
+                              climbMps, groundMps);
+}
+
 JNIEXPORT void JNICALL
 Java_com_margelo_nitro_reactnativecesium_CesiumBridgeJNI_nativeSetMaxSSE(JNIEnv*, jobject, jlong ptr, jdouble v) {
   getBridge(ptr)->setMaximumScreenSpaceError(v);
@@ -415,43 +525,67 @@ Java_com_margelo_nitro_reactnativecesium_CesiumBridgeJNI_nativeShouldRenderNextF
 }
 
 JNIEXPORT void JNICALL
-Java_com_margelo_nitro_reactnativecesium_CesiumBridgeJNI_nativeRenderFrame(JNIEnv*, jobject, jlong ptr, jdouble dt) {
-  getBridge(ptr)->renderFrame(dt);
+Java_com_margelo_nitro_reactnativecesium_CesiumBridgeJNI_nativeRenderFrame(JNIEnv*, jobject, jlong ptr, jdouble nowSeconds) {
+  getBridge(ptr)->renderFrame(nowSeconds);
 }
 
+// ── Actual / demand readbacks ──────────────────────────────────────────────
 JNIEXPORT jdouble JNICALL
-Java_com_margelo_nitro_reactnativecesium_CesiumBridgeJNI_nativeGetCameraLat(JNIEnv*, jobject, jlong ptr) {
-  return getBridge(ptr)->readCameraLatitude();
+Java_com_margelo_nitro_reactnativecesium_CesiumBridgeJNI_nativeGetActualLatitude(JNIEnv*, jobject, jlong ptr) {
+  return getBridge(ptr)->readActualLatitude();
 }
-
 JNIEXPORT jdouble JNICALL
-Java_com_margelo_nitro_reactnativecesium_CesiumBridgeJNI_nativeGetCameraLon(JNIEnv*, jobject, jlong ptr) {
-  return getBridge(ptr)->readCameraLongitude();
+Java_com_margelo_nitro_reactnativecesium_CesiumBridgeJNI_nativeGetActualLongitude(JNIEnv*, jobject, jlong ptr) {
+  return getBridge(ptr)->readActualLongitude();
 }
-
 JNIEXPORT jdouble JNICALL
-Java_com_margelo_nitro_reactnativecesium_CesiumBridgeJNI_nativeGetCameraAlt(JNIEnv*, jobject, jlong ptr) {
-  return getBridge(ptr)->readCameraAltitude();
+Java_com_margelo_nitro_reactnativecesium_CesiumBridgeJNI_nativeGetActualAltitude(JNIEnv*, jobject, jlong ptr) {
+  return getBridge(ptr)->readActualAltitude();
 }
-
 JNIEXPORT jdouble JNICALL
-Java_com_margelo_nitro_reactnativecesium_CesiumBridgeJNI_nativeGetCameraHeading(JNIEnv*, jobject, jlong ptr) {
-  return getBridge(ptr)->readCameraHeading();
+Java_com_margelo_nitro_reactnativecesium_CesiumBridgeJNI_nativeGetActualHeading(JNIEnv*, jobject, jlong ptr) {
+  return getBridge(ptr)->readActualHeading();
 }
-
 JNIEXPORT jdouble JNICALL
-Java_com_margelo_nitro_reactnativecesium_CesiumBridgeJNI_nativeGetCameraPitch(JNIEnv*, jobject, jlong ptr) {
-  return getBridge(ptr)->readCameraPitch();
+Java_com_margelo_nitro_reactnativecesium_CesiumBridgeJNI_nativeGetActualPitch(JNIEnv*, jobject, jlong ptr) {
+  return getBridge(ptr)->readActualPitch();
 }
-
 JNIEXPORT jdouble JNICALL
-Java_com_margelo_nitro_reactnativecesium_CesiumBridgeJNI_nativeGetCameraRoll(JNIEnv*, jobject, jlong ptr) {
-  return getBridge(ptr)->readCameraRoll();
+Java_com_margelo_nitro_reactnativecesium_CesiumBridgeJNI_nativeGetActualRoll(JNIEnv*, jobject, jlong ptr) {
+  return getBridge(ptr)->readActualRoll();
+}
+JNIEXPORT jdouble JNICALL
+Java_com_margelo_nitro_reactnativecesium_CesiumBridgeJNI_nativeGetActualVerticalFovDeg(JNIEnv*, jobject, jlong ptr) {
+  return getBridge(ptr)->readActualVerticalFovDeg();
 }
 
 JNIEXPORT jdouble JNICALL
-Java_com_margelo_nitro_reactnativecesium_CesiumBridgeJNI_nativeGetVerticalFovDeg(JNIEnv*, jobject, jlong ptr) {
-  return getBridge(ptr)->readVerticalFovDeg();
+Java_com_margelo_nitro_reactnativecesium_CesiumBridgeJNI_nativeGetDemandLatitude(JNIEnv*, jobject, jlong ptr) {
+  return getBridge(ptr)->readDemandLatitude();
+}
+JNIEXPORT jdouble JNICALL
+Java_com_margelo_nitro_reactnativecesium_CesiumBridgeJNI_nativeGetDemandLongitude(JNIEnv*, jobject, jlong ptr) {
+  return getBridge(ptr)->readDemandLongitude();
+}
+JNIEXPORT jdouble JNICALL
+Java_com_margelo_nitro_reactnativecesium_CesiumBridgeJNI_nativeGetDemandAltitude(JNIEnv*, jobject, jlong ptr) {
+  return getBridge(ptr)->readDemandAltitude();
+}
+JNIEXPORT jdouble JNICALL
+Java_com_margelo_nitro_reactnativecesium_CesiumBridgeJNI_nativeGetDemandHeading(JNIEnv*, jobject, jlong ptr) {
+  return getBridge(ptr)->readDemandHeading();
+}
+JNIEXPORT jdouble JNICALL
+Java_com_margelo_nitro_reactnativecesium_CesiumBridgeJNI_nativeGetDemandPitch(JNIEnv*, jobject, jlong ptr) {
+  return getBridge(ptr)->readDemandPitch();
+}
+JNIEXPORT jdouble JNICALL
+Java_com_margelo_nitro_reactnativecesium_CesiumBridgeJNI_nativeGetDemandRoll(JNIEnv*, jobject, jlong ptr) {
+  return getBridge(ptr)->readDemandRoll();
+}
+JNIEXPORT jdouble JNICALL
+Java_com_margelo_nitro_reactnativecesium_CesiumBridgeJNI_nativeGetDemandVerticalFovDeg(JNIEnv*, jobject, jlong ptr) {
+  return getBridge(ptr)->readDemandVerticalFovDeg();
 }
 
 JNIEXPORT jdouble JNICALL