react-native-cesium 1.2.3 → 1.2.5

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

@@ -1,5 +1,8 @@
 import type { HybridView, HybridViewProps, HybridViewMethods } from 'react-native-nitro-modules';
-/** Snapshot of the native camera for persistence / sync with React state. */
+/**
+ * Snapshot of the native camera for persistence / sync with React state.
+ * Returned by `getActualCamera()` and `getDemandCamera()`.
+ */
 export interface CameraState {
     latitude: number;
     longitude: number;
@@ -10,8 +13,9 @@ export interface CameraState {
     verticalFovDeg: number;
 }
 /**
- * Unit quaternion (w + xi + yj + zk). Used for camera-space view correction.
- * Non-unit values are normalized on the native side.
+ * Unit quaternion (w + xi + yj + zk). Used for camera-space view correction
+ * applied after HPR (boresight / HUD alignment). Non-unit values are
+ * normalised on the native side.
  */
 export interface Quaternion {
     w: number;
@@ -34,7 +38,11 @@ export interface CesiumMetrics {
 export interface CesiumViewProps extends HybridViewProps {
     ionAccessToken: string;
     ionAssetId: number;
-    /** Construction-time seed camera. Use `setCamera()` for runtime updates. */
+    /**
+     * Initial camera applied via `teleport(...)` once when the native bridge is
+     * created. Subsequent prop writes are ignored — use the per-DoF setters or
+     * `teleport(...)` for runtime updates.
+     */
     initialCamera: CameraState;
     pauseRendering: boolean;
     maximumScreenSpaceError: number;
@@ -74,22 +82,86 @@ export interface CesiumViewProps extends HybridViewProps {
      * terrain mesh vertex to the camera nadir.
      */
     minAltitudeAboveTerrain?: number;
+    /** Maximum yaw rate (degrees per second). 0 = uncapped. */
+    maxYawRateDegSec?: number;
+    /** Maximum pitch rate (degrees per second). 0 = uncapped. */
+    maxPitchRateDegSec?: number;
+    /** Maximum roll rate (degrees per second). 0 = uncapped. */
+    maxRollRateDegSec?: number;
+    /** Maximum climb / descent rate (metres per second). 0 = uncapped. */
+    maxClimbRateMps?: number;
+    /** Maximum horizontal ground speed (metres per second). 0 = uncapped. */
+    maxGroundSpeedMps?: number;
     onMetrics?: (metrics: CesiumMetrics) => void;
+    /**
+     * Called at ~5 Hz with the post-integration actual camera — the same state
+     * returned by `getActualCamera()`. Only fires when at least one field has
+     * changed beyond its epsilon threshold since the last emission, so a
+     * stationary camera produces no bridge traffic. Use this to keep HUD overlay
+     * symbology aligned with the rendered view without polling from JS.
+     */
+    onActualCamera?: (camera: CameraState) => void;
 }
+/**
+ * Per-DoF camera control. Every setter records the measurement with the
+ * native steady_clock time of arrival and feeds it into an α-β tracker
+ * (constant-velocity predictor) that owns both demand and actual state.
+ *
+ * All setters are synchronous and thread-safe. Calling them from a
+ * Reanimated worklet via a Nitro `hybridRef` is the supported path for
+ * high-frequency updates; the worklet thread takes the integrator's mutex
+ * briefly and returns immediately.
+ *
+ * Getters return Promises and should be called from the JS thread (e.g. a
+ * `useEffect` or a throttled HUD update), not from a worklet.
+ */
 export interface CesiumViewMethods extends HybridViewMethods {
-    /** Returns the current native camera state. */
-    getCameraState(): Promise<CameraState>;
     /**
-     * Runtime camera control (heading/pitch/roll + position + VFOV).
-     * Does not change the view-correction quaternion; use `setCameraQuaternion` to set that.
+     * New geographic position demand (latitude / longitude in degrees). Use
+     * for GPS or scripted position updates. Latitude is clamped to ±90 by the
+     * integrator; longitude is continuous (no wrap normalisation) so the
+     * shortest-arc residual maths stays correct across the antimeridian.
+     */
+    setPosition(latitude: number, longitude: number): void;
+    /** New altitude demand (metres above mean sea level). */
+    setAltitude(altitudeMeters: number): void;
+    /** New heading demand (degrees, 0 = north, increasing clockwise). */
+    setHeading(headingDeg: number): void;
+    /**
+     * New attitude demand (pitch and roll in degrees). Bundled because almost
+     * every IMU emits them together — but you can pass the previous value for
+     * either axis if you only have one of them.
+     */
+    setAttitude(pitchDeg: number, rollDeg: number): void;
+    /**
+     * New camera-space rotation applied after HPR (unit quaternion). Use for
+     * boresight calibration or screen-fixed HUD alignment. SLERPed toward the
+     * latest demand each frame.
+     */
+    setViewCorrection(q: Quaternion): void;
+    /** New vertical field-of-view demand (degrees). Clamped to 20..100. */
+    setVerticalFov(deg: number): void;
+    /**
+     * Atomically reset every DoF to the given camera state (value, velocity
+     * and demand all snap to the target). Bypasses the integrator entirely;
+     * use for `Fly to coordinate` actions or initial seeding from saved
+     * state.
+     */
+    teleport(camera: CameraState): void;
+    /**
+     * Most recent camera that was rendered (post-integration). This is what
+     * the user is currently looking at and is what a HUD overlay should
+     * mirror. Differs from `getDemandCamera()` while a glide is in progress
+     * or when the terrain-floor clamp has raised the altitude.
      */
-    setCamera(camera: CameraState): void;
+    getActualCamera(): Promise<CameraState>;
     /**
-     * Same fields as `setCamera`, plus a camera-space rotation applied after HPR
-     * (e.g. boresight / HUD alignment). See README.
+     * What the consumer last asked for (per-DoF demand). Useful for
+     * diagnostics or for showing the requested camera alongside the rendered
+     * one.
      */
-    setCameraQuaternion(camera: CameraState, viewCorrection: Quaternion): void;
-    /** Current view-correction quaternion (identity if never set via `setCameraQuaternion`). */
+    getDemandCamera(): Promise<CameraState>;
+    /** Current view-correction quaternion (smoothed toward the latest demand). */
     getViewCorrection(): Promise<Quaternion>;
 }
 export type CesiumView = HybridView<CesiumViewProps, CesiumViewMethods>;

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":"AAAA,OAAO,KAAK,EACV,UAAU,EACV,eAAe,EACf,iBAAiB,EAClB,MAAM,4BAA4B,CAAA;AAEnC,6EAA6E;AAC7E,MAAM,WAAW,WAAW;IAC1B,QAAQ,EAAE,MAAM,CAAA;IAChB,SAAS,EAAE,MAAM,CAAA;IACjB,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,MAAM,CAAA;IACZ,cAAc,EAAE,MAAM,CAAA;CACvB;AAED;;;GAGG;AACH,MAAM,WAAW,UAAU;IACzB,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;CACV;AAED,iEAAiE;AACjE,MAAM,WAAW,aAAa;IAC5B,GAAG,EAAE,MAAM,CAAA;IACX,aAAa,EAAE,MAAM,CAAA;IACrB,YAAY,EAAE,MAAM,CAAA;IACpB,YAAY,EAAE,MAAM,CAAA;IACpB,kBAAkB,EAAE,OAAO,CAAA;IAC3B,+DAA+D;IAC/D,aAAa,EAAE,OAAO,CAAA;IACtB,YAAY,EAAE,OAAO,CAAA;IACrB,gBAAgB,EAAE,MAAM,CAAA;CACzB;AAED,MAAM,WAAW,eAAgB,SAAQ,eAAe;IACtD,cAAc,EAAE,MAAM,CAAA;IACtB,UAAU,EAAE,MAAM,CAAA;IAClB,4EAA4E;IAC5E,aAAa,EAAE,WAAW,CAAA;IAC1B,cAAc,EAAE,OAAO,CAAA;IACvB,uBAAuB,EAAE,MAAM,CAAA;IAC/B,4BAA4B,EAAE,MAAM,CAAA;IACpC,sBAAsB,EAAE,MAAM,CAAA;IAC9B,6CAA6C;IAC7C,eAAe,EAAE,MAAM,CAAA;IACvB,iBAAiB,EAAE,MAAM,CAAA;IAGzB,8DAA8D;IAC9D,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,mGAAmG;IACnG,gBAAgB,CAAC,EAAE,OAAO,CAAA;IAC1B,mEAAmE;IACnE,eAAe,CAAC,EAAE,OAAO,CAAA;IACzB,gFAAgF;IAChF,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,oEAAoE;IACpE,eAAe,CAAC,EAAE,OAAO,CAAA;IACzB,6DAA6D;IAC7D,gBAAgB,CAAC,EAAE,OAAO,CAAA;IAC1B,2EAA2E;IAC3E,6BAA6B,CAAC,EAAE,OAAO,CAAA;IACvC,4FAA4F;IAC5F,sBAAsB,CAAC,EAAE,MAAM,CAAA;IAC/B,8EAA8E;IAC9E,yBAAyB,CAAC,EAAE,OAAO,CAAA;IACnC,mDAAmD;IACnD,mBAAmB,CAAC,EAAE,MAAM,CAAA;IAC5B,mDAAmD;IACnD,kBAAkB,CAAC,EAAE,MAAM,CAAA;IAC3B,4EAA4E;IAC5E,oBAAoB,CAAC,EAAE,MAAM,CAAA;IAC7B;;;;;OAKG;IACH,uBAAuB,CAAC,EAAE,MAAM,CAAA;IAEhC,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,aAAa,KAAK,IAAI,CAAA;CAC7C;AAED,MAAM,WAAW,iBAAkB,SAAQ,iBAAiB;IAC1D,+CAA+C;IAC/C,cAAc,IAAI,OAAO,CAAC,WAAW,CAAC,CAAA;IACtC;;;OAGG;IACH,SAAS,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI,CAAA;IACpC;;;OAGG;IACH,mBAAmB,CAAC,MAAM,EAAE,WAAW,EAAE,cAAc,EAAE,UAAU,GAAG,IAAI,CAAA;IAC1E,4FAA4F;IAC5F,iBAAiB,IAAI,OAAO,CAAC,UAAU,CAAC,CAAA;CACzC;AAED,MAAM,MAAM,UAAU,GAAG,UAAU,CAAC,eAAe,EAAE,iBAAiB,CAAC,CAAA"}
+{"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

@@ -17,6 +17,7 @@
 
 #include "JHybridCesiumViewSpec.hpp"
 #include "JFunc_void_CesiumMetrics.hpp"
+#include "JFunc_void_CameraState.hpp"
 #include "views/JHybridCesiumViewStateUpdater.hpp"
 #include <NitroModules/DefaultConstructableObject.hpp>
 
@@ -44,6 +45,7 @@ void registerAllNatives() {
   // Register native JNI methods
   margelo::nitro::reactnativecesium::JHybridCesiumViewSpec::CxxPart::registerNatives();
   margelo::nitro::reactnativecesium::JFunc_void_CesiumMetrics_cxx::registerNatives();
+  margelo::nitro::reactnativecesium::JFunc_void_CameraState_cxx::registerNatives();
   margelo::nitro::reactnativecesium::views::JHybridCesiumViewStateUpdater::registerNatives();
 
   // Register Nitro Hybrid Objects

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

@@ -0,0 +1,77 @@
+///
+/// JFunc_void_CameraState.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include "CameraState.hpp"
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JCameraState.hpp"
+
+namespace margelo::nitro::reactnativecesium {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(camera: CameraState) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_CameraState: public jni::JavaClass<JFunc_void_CameraState> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/reactnativecesium/Func_void_CameraState;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_CameraState` instance holds through JNI.
+     */
+    void invoke(const CameraState& camera) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JCameraState> /* camera */)>("invoke");
+      method(self(), JCameraState::fromCpp(camera));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_CameraState that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_CameraState_cxx final: public jni::HybridClass<JFunc_void_CameraState_cxx, JFunc_void_CameraState> {
+  public:
+    static jni::local_ref<JFunc_void_CameraState::javaobject> fromCpp(const std::function<void(const CameraState& /* camera */)>& func) {
+      return JFunc_void_CameraState_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_CameraState_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JCameraState> camera) {
+      _func(camera->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const CameraState& /* camera */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/reactnativecesium/Func_void_CameraState_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_CameraState_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_CameraState_cxx(const std::function<void(const CameraState& /* camera */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const CameraState& /* camera */)> _func;
+  };
+
+} // namespace margelo::nitro::reactnativecesium

package/nitrogen/generated/android/c++/JHybridCesiumViewSpec.cpp

@@ -23,6 +23,7 @@ namespace margelo::nitro::reactnativecesium { struct Quaternion; }
 #include "JFunc_void_CesiumMetrics.hpp"
 #include <NitroModules/JNICallable.hpp>
 #include "JCesiumMetrics.hpp"
+#include "JFunc_void_CameraState.hpp"
 #include <NitroModules/Promise.hpp>
 #include <NitroModules/JPromise.hpp>
 #include "Quaternion.hpp"
@@ -256,6 +257,51 @@ namespace margelo::nitro::reactnativecesium {
     static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* minAltitudeAboveTerrain */)>("setMinAltitudeAboveTerrain");
     method(_javaPart, minAltitudeAboveTerrain.has_value() ? jni::JDouble::valueOf(minAltitudeAboveTerrain.value()) : nullptr);
   }
+  std::optional<double> JHybridCesiumViewSpec::getMaxYawRateDegSec() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getMaxYawRateDegSec");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->value()) : std::nullopt;
+  }
+  void JHybridCesiumViewSpec::setMaxYawRateDegSec(std::optional<double> maxYawRateDegSec) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* maxYawRateDegSec */)>("setMaxYawRateDegSec");
+    method(_javaPart, maxYawRateDegSec.has_value() ? jni::JDouble::valueOf(maxYawRateDegSec.value()) : nullptr);
+  }
+  std::optional<double> JHybridCesiumViewSpec::getMaxPitchRateDegSec() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getMaxPitchRateDegSec");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->value()) : std::nullopt;
+  }
+  void JHybridCesiumViewSpec::setMaxPitchRateDegSec(std::optional<double> maxPitchRateDegSec) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* maxPitchRateDegSec */)>("setMaxPitchRateDegSec");
+    method(_javaPart, maxPitchRateDegSec.has_value() ? jni::JDouble::valueOf(maxPitchRateDegSec.value()) : nullptr);
+  }
+  std::optional<double> JHybridCesiumViewSpec::getMaxRollRateDegSec() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getMaxRollRateDegSec");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->value()) : std::nullopt;
+  }
+  void JHybridCesiumViewSpec::setMaxRollRateDegSec(std::optional<double> maxRollRateDegSec) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* maxRollRateDegSec */)>("setMaxRollRateDegSec");
+    method(_javaPart, maxRollRateDegSec.has_value() ? jni::JDouble::valueOf(maxRollRateDegSec.value()) : nullptr);
+  }
+  std::optional<double> JHybridCesiumViewSpec::getMaxClimbRateMps() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getMaxClimbRateMps");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->value()) : std::nullopt;
+  }
+  void JHybridCesiumViewSpec::setMaxClimbRateMps(std::optional<double> maxClimbRateMps) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* maxClimbRateMps */)>("setMaxClimbRateMps");
+    method(_javaPart, maxClimbRateMps.has_value() ? jni::JDouble::valueOf(maxClimbRateMps.value()) : nullptr);
+  }
+  std::optional<double> JHybridCesiumViewSpec::getMaxGroundSpeedMps() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getMaxGroundSpeedMps");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->value()) : std::nullopt;
+  }
+  void JHybridCesiumViewSpec::setMaxGroundSpeedMps(std::optional<double> maxGroundSpeedMps) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* maxGroundSpeedMps */)>("setMaxGroundSpeedMps");
+    method(_javaPart, maxGroundSpeedMps.has_value() ? jni::JDouble::valueOf(maxGroundSpeedMps.value()) : nullptr);
+  }
   std::optional<std::function<void(const CesiumMetrics& /* metrics */)>> JHybridCesiumViewSpec::getOnMetrics() {
     static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFunc_void_CesiumMetrics::javaobject>()>("getOnMetrics_cxx");
     auto __result = method(_javaPart);
@@ -273,10 +319,55 @@ namespace margelo::nitro::reactnativecesium {
     static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_CesiumMetrics::javaobject> /* onMetrics */)>("setOnMetrics_cxx");
     method(_javaPart, onMetrics.has_value() ? JFunc_void_CesiumMetrics_cxx::fromCpp(onMetrics.value()) : nullptr);
   }
+  std::optional<std::function<void(const CameraState& /* camera */)>> JHybridCesiumViewSpec::getOnActualCamera() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFunc_void_CameraState::javaobject>()>("getOnActualCamera_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void(const CameraState& /* camera */)> {
+      if (__result->isInstanceOf(JFunc_void_CameraState_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_CameraState_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return JNICallable<JFunc_void_CameraState, void(CameraState)>(std::move(__resultRef));
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridCesiumViewSpec::setOnActualCamera(const std::optional<std::function<void(const CameraState& /* camera */)>>& onActualCamera) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_CameraState::javaobject> /* onActualCamera */)>("setOnActualCamera_cxx");
+    method(_javaPart, onActualCamera.has_value() ? JFunc_void_CameraState_cxx::fromCpp(onActualCamera.value()) : nullptr);
+  }
 
   // Methods
-  std::shared_ptr<Promise<CameraState>> JHybridCesiumViewSpec::getCameraState() {
-    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("getCameraState");
+  void JHybridCesiumViewSpec::setPosition(double latitude, double longitude) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(double /* latitude */, double /* longitude */)>("setPosition");
+    method(_javaPart, latitude, longitude);
+  }
+  void JHybridCesiumViewSpec::setAltitude(double altitudeMeters) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(double /* altitudeMeters */)>("setAltitude");
+    method(_javaPart, altitudeMeters);
+  }
+  void JHybridCesiumViewSpec::setHeading(double headingDeg) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(double /* headingDeg */)>("setHeading");
+    method(_javaPart, headingDeg);
+  }
+  void JHybridCesiumViewSpec::setAttitude(double pitchDeg, double rollDeg) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(double /* pitchDeg */, double /* rollDeg */)>("setAttitude");
+    method(_javaPart, pitchDeg, rollDeg);
+  }
+  void JHybridCesiumViewSpec::setViewCorrection(const Quaternion& q) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JQuaternion> /* q */)>("setViewCorrection");
+    method(_javaPart, JQuaternion::fromCpp(q));
+  }
+  void JHybridCesiumViewSpec::setVerticalFov(double deg) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(double /* deg */)>("setVerticalFov");
+    method(_javaPart, deg);
+  }
+  void JHybridCesiumViewSpec::teleport(const CameraState& camera) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JCameraState> /* camera */)>("teleport");
+    method(_javaPart, JCameraState::fromCpp(camera));
+  }
+  std::shared_ptr<Promise<CameraState>> JHybridCesiumViewSpec::getActualCamera() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("getActualCamera");
     auto __result = method(_javaPart);
     return [&]() {
       auto __promise = Promise<CameraState>::create();
@@ -291,13 +382,21 @@ namespace margelo::nitro::reactnativecesium {
       return __promise;
     }();
   }
-  void JHybridCesiumViewSpec::setCamera(const CameraState& camera) {
-    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JCameraState> /* camera */)>("setCamera");
-    method(_javaPart, JCameraState::fromCpp(camera));
-  }
-  void JHybridCesiumViewSpec::setCameraQuaternion(const CameraState& camera, const Quaternion& viewCorrection) {
-    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JCameraState> /* camera */, jni::alias_ref<JQuaternion> /* viewCorrection */)>("setCameraQuaternion");
-    method(_javaPart, JCameraState::fromCpp(camera), JQuaternion::fromCpp(viewCorrection));
+  std::shared_ptr<Promise<CameraState>> JHybridCesiumViewSpec::getDemandCamera() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("getDemandCamera");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<CameraState>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<JCameraState>(__boxedResult);
+        __promise->resolve(__result->toCpp());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
   }
   std::shared_ptr<Promise<Quaternion>> JHybridCesiumViewSpec::getViewCorrection() {
     static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("getViewCorrection");

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

@@ -94,14 +94,32 @@ namespace margelo::nitro::reactnativecesium {
     void setTaskProcessorThreads(std::optional<double> taskProcessorThreads) override;
     std::optional<double> getMinAltitudeAboveTerrain() override;
     void setMinAltitudeAboveTerrain(std::optional<double> minAltitudeAboveTerrain) override;
+    std::optional<double> getMaxYawRateDegSec() override;
+    void setMaxYawRateDegSec(std::optional<double> maxYawRateDegSec) override;
+    std::optional<double> getMaxPitchRateDegSec() override;
+    void setMaxPitchRateDegSec(std::optional<double> maxPitchRateDegSec) override;
+    std::optional<double> getMaxRollRateDegSec() override;
+    void setMaxRollRateDegSec(std::optional<double> maxRollRateDegSec) override;
+    std::optional<double> getMaxClimbRateMps() override;
+    void setMaxClimbRateMps(std::optional<double> maxClimbRateMps) override;
+    std::optional<double> getMaxGroundSpeedMps() override;
+    void setMaxGroundSpeedMps(std::optional<double> maxGroundSpeedMps) override;
     std::optional<std::function<void(const CesiumMetrics& /* metrics */)>> getOnMetrics() override;
     void setOnMetrics(const std::optional<std::function<void(const CesiumMetrics& /* metrics */)>>& onMetrics) override;
+    std::optional<std::function<void(const CameraState& /* camera */)>> getOnActualCamera() override;
+    void setOnActualCamera(const std::optional<std::function<void(const CameraState& /* camera */)>>& onActualCamera) override;
 
   public:
     // Methods
-    std::shared_ptr<Promise<CameraState>> getCameraState() override;
-    void setCamera(const CameraState& camera) override;
-    void setCameraQuaternion(const CameraState& camera, const Quaternion& viewCorrection) override;
+    void setPosition(double latitude, double longitude) override;
+    void setAltitude(double altitudeMeters) override;
+    void setHeading(double headingDeg) override;
+    void setAttitude(double pitchDeg, double rollDeg) override;
+    void setViewCorrection(const Quaternion& q) override;
+    void setVerticalFov(double deg) override;
+    void teleport(const CameraState& camera) override;
+    std::shared_ptr<Promise<CameraState>> getActualCamera() override;
+    std::shared_ptr<Promise<CameraState>> getDemandCamera() override;
     std::shared_ptr<Promise<Quaternion>> getViewCorrection() override;
 
   private:

package/nitrogen/generated/android/c++/views/JHybridCesiumViewStateUpdater.cpp

@@ -125,10 +125,34 @@ void JHybridCesiumViewStateUpdater::updateViewProps(jni::alias_ref<jni::JClass>
     hybridView->setMinAltitudeAboveTerrain(props->minAltitudeAboveTerrain.value);
     props->minAltitudeAboveTerrain.isDirty = false;
   }
+  if (props->maxYawRateDegSec.isDirty) {
+    hybridView->setMaxYawRateDegSec(props->maxYawRateDegSec.value);
+    props->maxYawRateDegSec.isDirty = false;
+  }
+  if (props->maxPitchRateDegSec.isDirty) {
+    hybridView->setMaxPitchRateDegSec(props->maxPitchRateDegSec.value);
+    props->maxPitchRateDegSec.isDirty = false;
+  }
+  if (props->maxRollRateDegSec.isDirty) {
+    hybridView->setMaxRollRateDegSec(props->maxRollRateDegSec.value);
+    props->maxRollRateDegSec.isDirty = false;
+  }
+  if (props->maxClimbRateMps.isDirty) {
+    hybridView->setMaxClimbRateMps(props->maxClimbRateMps.value);
+    props->maxClimbRateMps.isDirty = false;
+  }
+  if (props->maxGroundSpeedMps.isDirty) {
+    hybridView->setMaxGroundSpeedMps(props->maxGroundSpeedMps.value);
+    props->maxGroundSpeedMps.isDirty = false;
+  }
   if (props->onMetrics.isDirty) {
     hybridView->setOnMetrics(props->onMetrics.value);
     props->onMetrics.isDirty = false;
   }
+  if (props->onActualCamera.isDirty) {
+    hybridView->setOnActualCamera(props->onActualCamera.value);
+    props->onActualCamera.isDirty = false;
+  }
 
   // Update hybridRef if it changed
   if (props->hybridRef.isDirty) {

package/nitrogen/generated/android/kotlin/com/margelo/nitro/reactnativecesium/Func_void_CameraState.kt

@@ -0,0 +1,80 @@
+///
+/// Func_void_CameraState.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.reactnativecesium
+
+import androidx.annotation.Keep
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+import dalvik.annotation.optimization.FastNative
+
+
+/**
+ * Represents the JavaScript callback `(camera: struct) => void`.
+ * This can be either implemented in C++ (in which case it might be a callback coming from JS),
+ * or in Kotlin/Java (in which case it is a native callback).
+ */
+@DoNotStrip
+@Keep
+@Suppress("ClassName", "RedundantUnitReturnType")
+fun interface Func_void_CameraState: (CameraState) -> Unit {
+  /**
+   * Call the given JS callback.
+   * @throws Throwable if the JS function itself throws an error, or if the JS function/runtime has already been deleted.
+   */
+  @DoNotStrip
+  @Keep
+  override fun invoke(camera: CameraState): Unit
+}
+
+/**
+ * Represents the JavaScript callback `(camera: struct) => void`.
+ * This is implemented in C++, via a `std::function<...>`.
+ * The callback might be coming from JS.
+ */
+@DoNotStrip
+@Keep
+@Suppress(
+  "KotlinJniMissingFunction", "unused",
+  "RedundantSuppression", "RedundantUnitReturnType", "FunctionName",
+  "ConvertSecondaryConstructorToPrimary", "ClassName", "LocalVariableName",
+)
+class Func_void_CameraState_cxx: Func_void_CameraState {
+  @DoNotStrip
+  @Keep
+  private val mHybridData: HybridData
+
+  @DoNotStrip
+  @Keep
+  private constructor(hybridData: HybridData) {
+    mHybridData = hybridData
+  }
+
+  @DoNotStrip
+  @Keep
+  override fun invoke(camera: CameraState): Unit
+    = invoke_cxx(camera)
+
+  @FastNative
+  private external fun invoke_cxx(camera: CameraState): Unit
+}
+
+/**
+ * Represents the JavaScript callback `(camera: struct) => void`.
+ * This is implemented in Java/Kotlin, via a `(CameraState) -> Unit`.
+ * The callback is always coming from native.
+ */
+@DoNotStrip
+@Keep
+@Suppress("ClassName", "RedundantUnitReturnType", "unused")
+class Func_void_CameraState_java(private val function: (CameraState) -> Unit): Func_void_CameraState {
+  @DoNotStrip
+  @Keep
+  override fun invoke(camera: CameraState): Unit {
+    return this.function(camera)
+  }
+}

package/nitrogen/generated/android/kotlin/com/margelo/nitro/reactnativecesium/HybridCesiumViewSpec.kt

@@ -159,6 +159,36 @@ abstract class HybridCesiumViewSpec: HybridView() {
   @set:Keep
   abstract var minAltitudeAboveTerrain: Double?
   
+  @get:DoNotStrip
+  @get:Keep
+  @set:DoNotStrip
+  @set:Keep
+  abstract var maxYawRateDegSec: Double?
+  
+  @get:DoNotStrip
+  @get:Keep
+  @set:DoNotStrip
+  @set:Keep
+  abstract var maxPitchRateDegSec: Double?
+  
+  @get:DoNotStrip
+  @get:Keep
+  @set:DoNotStrip
+  @set:Keep
+  abstract var maxRollRateDegSec: Double?
+  
+  @get:DoNotStrip
+  @get:Keep
+  @set:DoNotStrip
+  @set:Keep
+  abstract var maxClimbRateMps: Double?
+  
+  @get:DoNotStrip
+  @get:Keep
+  @set:DoNotStrip
+  @set:Keep
+  abstract var maxGroundSpeedMps: Double?
+  
   abstract var onMetrics: ((metrics: CesiumMetrics) -> Unit)?
   
   private var onMetrics_cxx: Func_void_CesiumMetrics?
@@ -172,19 +202,57 @@ abstract class HybridCesiumViewSpec: HybridView() {
     set(value) {
       onMetrics = value?.let { it }
     }
+  
+  abstract var onActualCamera: ((camera: CameraState) -> Unit)?
+  
+  private var onActualCamera_cxx: Func_void_CameraState?
+    @Keep
+    @DoNotStrip
+    get() {
+      return onActualCamera?.let { Func_void_CameraState_java(it) }
+    }
+    @Keep
+    @DoNotStrip
+    set(value) {
+      onActualCamera = value?.let { it }
+    }
 
   // Methods
   @DoNotStrip
   @Keep
-  abstract fun getCameraState(): Promise<CameraState>
+  abstract fun setPosition(latitude: Double, longitude: Double): Unit
+  
+  @DoNotStrip
+  @Keep
+  abstract fun setAltitude(altitudeMeters: Double): Unit
+  
+  @DoNotStrip
+  @Keep
+  abstract fun setHeading(headingDeg: Double): Unit
+  
+  @DoNotStrip
+  @Keep
+  abstract fun setAttitude(pitchDeg: Double, rollDeg: Double): Unit
+  
+  @DoNotStrip
+  @Keep
+  abstract fun setViewCorrection(q: Quaternion): Unit
+  
+  @DoNotStrip
+  @Keep
+  abstract fun setVerticalFov(deg: Double): Unit
+  
+  @DoNotStrip
+  @Keep
+  abstract fun teleport(camera: CameraState): Unit
   
   @DoNotStrip
   @Keep
-  abstract fun setCamera(camera: CameraState): Unit
+  abstract fun getActualCamera(): Promise<CameraState>
   
   @DoNotStrip
   @Keep
-  abstract fun setCameraQuaternion(camera: CameraState, viewCorrection: Quaternion): Unit
+  abstract fun getDemandCamera(): Promise<CameraState>
   
   @DoNotStrip
   @Keep

package/nitrogen/generated/ios/ReactNativeCesium-Swift-Cxx-Bridge.cpp

@@ -22,11 +22,11 @@ namespace margelo::nitro::reactnativecesium::bridge::swift {
     };
   }
   
-  // pragma MARK: std::function<void(const CameraState& /* result */)>
+  // pragma MARK: std::function<void(const CameraState& /* camera */)>
   Func_void_CameraState create_Func_void_CameraState(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = ReactNativeCesium::Func_void_CameraState::fromUnsafe(swiftClosureWrapper);
-    return [swiftClosure = std::move(swiftClosure)](const CameraState& result) mutable -> void {
-      swiftClosure.call(result);
+    return [swiftClosure = std::move(swiftClosure)](const CameraState& camera) mutable -> void {
+      swiftClosure.call(camera);
     };
   }