react-native-cesium 1.0.1 → 1.0.3

package/ios/CesiumBridge.mm

@@ -4,6 +4,8 @@
 #include "engine/CesiumEngine.hpp"
 #include "metal/MetalBackend.h"
 
+#include <glm/gtc/quaternion.hpp>
+
 #include <atomic>
 #include <cmath>
 #include <memory>
@@ -46,9 +48,15 @@ static const double kSmoothAlt = 25.0;
 static const double kSmoothHdg = 30.0;
 static const double kSmoothRoll = 50.0;
 static const double kSmoothPitch = 50.0;
+static const double kSmoothViewCorr = 50.0;
 static const double kEpsLatLon = 1e-7;
 static const double kEpsAlt = 0.1;
 static const double kEpsAngleDeg = 0.05;
+static const double kEpsQuatDot = 1e-8;
+
+static double quatDotAbs(const glm::dquat& a, const glm::dquat& b) {
+  return std::abs(glm::dot(glm::normalize(a), glm::normalize(b)));
+}
 
 @implementation CesiumBridge {
   std::unique_ptr<reactnativecesium::MetalBackend> _metalBackend;
@@ -182,17 +190,12 @@ static const double kEpsAngleDeg = 0.05;
   // Water mask textures are identical MTLTexture objects — createRasterTexture
   // is reused.  On Metal, the binding slot (texture index 1) is set at draw
   // time so no separate factory is needed.
-  NSLog(@"[WM-BRIDGE] Wiring up water mask texture creator/deleter");
   _engine->getResourcePreparer()->setWaterMaskTextureCreator(
       [backendPtr](const uint8_t* pixels, int32_t w, int32_t h) -> void* {
-        NSLog(@"[WM-BRIDGE] waterMaskCreator called w=%d h=%d pixels=%p", w, h, pixels);
-        void* tex = backendPtr->createRasterTexture(pixels, w, h);
-        NSLog(@"[WM-BRIDGE] waterMaskCreator => tex=%p", tex);
-        return tex;
+        return backendPtr->createRasterTexture(pixels, w, h);
       });
   _engine->getResourcePreparer()->setWaterMaskTextureDeleter(
       [](void* tex) {
-        NSLog(@"[WM-BRIDGE] waterMaskDeleter called tex=%p", tex);
         if (tex) CFRelease(tex);
       });
 }
@@ -224,6 +227,36 @@ static const double kEpsAngleDeg = 0.05;
   _camTarget.heading   = heading;
   _camTarget.pitch     = pitch;
   _camTarget.roll      = roll;
+  // Intentionally does not modify `_camTarget.viewCorrection`.
+  _forceRenderNextFrame = YES;
+}
+
+- (void)updateCameraQuaternionLatitude:(double)lat
+                             longitude:(double)lon
+                              altitude:(double)alt
+                               heading:(double)heading
+                                 pitch:(double)pitch
+                                  roll:(double)roll
+                       viewCorrectionW:(double)qw
+                                     x:(double)qx
+                                     y:(double)qy
+                                     z:(double)qz {
+  if (!_initialized) return;
+  _camTarget.latitude  = lat;
+  _camTarget.longitude = lon;
+  _camTarget.altitude  = alt;
+  _camTarget.heading   = heading;
+  _camTarget.pitch     = pitch;
+  _camTarget.roll      = 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);
+  }
+  _camTarget.viewCorrection = q;
   _forceRenderNextFrame = YES;
 }
 
@@ -280,7 +313,8 @@ static const double kEpsAngleDeg = 0.05;
       std::abs(_camTarget.altitude - cur.altitude) > kEpsAlt ||
       angleDeltaAbsDeg(cur.heading, _camTarget.heading) > kEpsAngleDeg ||
       angleDeltaAbsDeg(cur.pitch, _camTarget.pitch) > kEpsAngleDeg ||
-      angleDeltaAbsDeg(cur.roll, _camTarget.roll) > kEpsAngleDeg;
+      angleDeltaAbsDeg(cur.roll, _camTarget.roll) > kEpsAngleDeg ||
+      (1.0 - quatDotAbs(cur.viewCorrection, _camTarget.viewCorrection)) > kEpsQuatDot;
 
   return _forceRenderNextFrame ||
          _frameResult.tilesLoading > 0 ||
@@ -303,11 +337,18 @@ static const double kEpsAngleDeg = 0.05;
     const double aHdg = 1.0 - std::exp(-kSmoothHdg * dt);
     const double aPitch = 1.0 - std::exp(-kSmoothPitch * dt);
     const double aRoll = 1.0 - std::exp(-kSmoothRoll * dt);
+    const double aViewQ = 1.0 - std::exp(-kSmoothViewCorr * dt);
     cur.altitude = cur.altitude + aAlt * (_camTarget.altitude - cur.altitude);
     cur.heading  = lerpAngleDeg(cur.heading, _camTarget.heading, aHdg);
     cur.pitch  = lerpAngleDeg(cur.pitch, _camTarget.pitch, aPitch);
     cur.roll  = lerpAngleDeg(cur.roll, _camTarget.roll, aRoll);
 
+    glm::dquat cq = glm::normalize(cur.viewCorrection);
+    glm::dquat tq = glm::normalize(_camTarget.viewCorrection);
+    if (glm::dot(cq, tq) < 0.0)
+      tq = -tq;
+    cur.viewCorrection = glm::normalize(glm::slerp(cq, tq, aViewQ));
+
     if (std::abs(_camTarget.altitude - cur.altitude) <= kEpsAlt) {
       cur.altitude = _camTarget.altitude;
     }
@@ -320,6 +361,9 @@ static const double kEpsAngleDeg = 0.05;
     if (angleDeltaAbsDeg(cur.roll, _camTarget.roll) <= kEpsAngleDeg) {
       cur.roll = _camTarget.roll;
     }
+    if ((1.0 - quatDotAbs(cur.viewCorrection, _camTarget.viewCorrection)) <= kEpsQuatDot) {
+      cur.viewCorrection = _camTarget.viewCorrection;
+    }
     _engine->camera().setParams(cur);
 
     _engine->updateFrame(_viewportWidth, _viewportHeight, _frameResult);
@@ -383,6 +427,23 @@ static const double kEpsAngleDeg = 0.05;
 - (double)readCameraRoll      { return _engine ? _engine->camera().getParams().roll      : 0.0; }
 - (double)readVerticalFovDeg  { return _engine ? _engine->camera().getVerticalFovDegrees() : 60.0; }
 
+- (double)readViewCorrectionW {
+  if (!_engine) return 1.0;
+  return _engine->camera().getParams().viewCorrection.w;
+}
+- (double)readViewCorrectionX {
+  if (!_engine) return 0.0;
+  return _engine->camera().getParams().viewCorrection.x;
+}
+- (double)readViewCorrectionY {
+  if (!_engine) return 0.0;
+  return _engine->camera().getParams().viewCorrection.y;
+}
+- (double)readViewCorrectionZ {
+  if (!_engine) return 0.0;
+  return _engine->camera().getParams().viewCorrection.z;
+}
+
 - (void)shutdown {
   [[NSNotificationCenter defaultCenter] removeObserver:self];
   if (_engine) _engine->shutdown();

package/ios/HybridCesiumView.swift

@@ -87,6 +87,26 @@ class HybridCesiumView: HybridCesiumViewSpec {
     pushCameraStateIfChanged(camera)
   }
 
+  func setCameraQuaternion(camera: CameraState, viewCorrection: Quaternion) throws {
+    initialCamera = camera
+    pushCameraQuaternionIfChanged(camera, viewCorrection: viewCorrection)
+  }
+
+  func getViewCorrection() throws -> Promise<Quaternion> {
+    guard let b = bridge else {
+      return Promise.resolved(
+        withResult: Quaternion(w: 1, x: 0, y: 0, z: 0)
+      )
+    }
+    let q = Quaternion(
+      w: b.readViewCorrectionW(),
+      x: b.readViewCorrectionX(),
+      y: b.readViewCorrectionY(),
+      z: b.readViewCorrectionZ()
+    )
+    return Promise.resolved(withResult: q)
+  }
+
   // MARK: - View
 
   private let metalView: MTKView
@@ -98,6 +118,8 @@ class HybridCesiumView: HybridCesiumViewSpec {
   private var usingLowRefreshRate = false
   private var hasConfiguredFrameRate = false
   private var lastPushedCameraState: CameraState?
+  /// Last quaternion pushed via `setCameraQuaternion`; `nil` if only `setCamera` has been used.
+  private var lastPushedViewCorrection: Quaternion?
   private var lastBridgePixelSize: CGSize = .zero
 
   var view: UIView { metalView }
@@ -220,6 +242,40 @@ class HybridCesiumView: HybridCesiumViewSpec {
     bridge?.setVerticalFovDeg(camera.verticalFovDeg)
   }
 
+  private func pushCameraQuaternionIfChanged(_ camera: CameraState, viewCorrection: Quaternion) {
+    guard bridge != nil else { return }
+    if let lastCam = lastPushedCameraState,
+       let lastQ = lastPushedViewCorrection,
+       lastCam.latitude == camera.latitude,
+       lastCam.longitude == camera.longitude,
+       lastCam.altitude == camera.altitude,
+       lastCam.heading == camera.heading,
+       lastCam.pitch == camera.pitch,
+       lastCam.roll == camera.roll,
+       lastCam.verticalFovDeg == camera.verticalFovDeg,
+       lastQ.w == viewCorrection.w,
+       lastQ.x == viewCorrection.x,
+       lastQ.y == viewCorrection.y,
+       lastQ.z == viewCorrection.z {
+      return
+    }
+    lastPushedCameraState = camera
+    lastPushedViewCorrection = viewCorrection
+    bridge?.updateCameraQuaternionLatitude(
+      camera.latitude,
+      longitude: camera.longitude,
+      altitude: camera.altitude,
+      heading: camera.heading,
+      pitch: camera.pitch,
+      roll: camera.roll,
+      viewCorrectionW: viewCorrection.w,
+      x: viewCorrection.x,
+      y: viewCorrection.y,
+      z: viewCorrection.z
+    )
+    bridge?.setVerticalFovDeg(camera.verticalFovDeg)
+  }
+
   // MARK: - Render Loop
 
   private func startRenderLoop() {

package/lib/typescript/src/index.d.ts

@@ -1,3 +1,3 @@
 export { CesiumView } from './CesiumView';
-export type { CameraState, CesiumMetrics, CesiumViewProps, CesiumViewMethods, } from './specs/cesium-view.nitro';
+export type { CameraState, CesiumMetrics, CesiumViewProps, CesiumViewMethods, Quaternion, } from './specs/cesium-view.nitro';
 //# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AACzC,YAAY,EACV,WAAW,EACX,aAAa,EACb,eAAe,EACf,iBAAiB,GAClB,MAAM,2BAA2B,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AACzC,YAAY,EACV,WAAW,EACX,aAAa,EACb,eAAe,EACf,iBAAiB,EACjB,UAAU,GACX,MAAM,2BAA2B,CAAA"}

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

@@ -9,6 +9,16 @@ export interface CameraState {
     roll: number;
     verticalFovDeg: number;
 }
+/**
+ * Unit quaternion (w + xi + yj + zk). Used for camera-space view correction.
+ * Non-unit values are normalized on the native side.
+ */
+export interface Quaternion {
+    w: number;
+    x: number;
+    y: number;
+    z: number;
+}
 /** Throttled telemetry for dashboards (see `onMetrics` prop). */
 export interface CesiumMetrics {
     fps: number;
@@ -36,8 +46,18 @@ export interface CesiumViewProps extends HybridViewProps {
 export interface CesiumViewMethods extends HybridViewMethods {
     /** Returns the current native camera state. */
     getCameraState(): Promise<CameraState>;
-    /** Runtime camera control path after the view has been created. */
+    /**
+     * Runtime camera control (heading/pitch/roll + position + VFOV).
+     * Does not change the view-correction quaternion; use `setCameraQuaternion` to set that.
+     */
     setCamera(camera: CameraState): void;
+    /**
+     * Same fields as `setCamera`, plus a camera-space rotation applied after HPR
+     * (e.g. boresight / HUD alignment). See README.
+     */
+    setCameraQuaternion(camera: CameraState, viewCorrection: Quaternion): void;
+    /** Current view-correction quaternion (identity if never set via `setCameraQuaternion`). */
+    getViewCorrection(): Promise<Quaternion>;
 }
 export type CesiumView = HybridView<CesiumViewProps, CesiumViewMethods>;
 //# sourceMappingURL=cesium-view.nitro.d.ts.map

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,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,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;IACzB,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,mEAAmE;IACnE,SAAS,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI,CAAA;CACrC;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":"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,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;IACzB,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"}

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

@@ -11,6 +11,8 @@
 namespace margelo::nitro::reactnativecesium { struct CameraState; }
 // Forward declaration of `CesiumMetrics` to properly resolve imports.
 namespace margelo::nitro::reactnativecesium { struct CesiumMetrics; }
+// Forward declaration of `Quaternion` to properly resolve imports.
+namespace margelo::nitro::reactnativecesium { struct Quaternion; }
 
 #include <string>
 #include "CameraState.hpp"
@@ -23,6 +25,8 @@ namespace margelo::nitro::reactnativecesium { struct CesiumMetrics; }
 #include "JCesiumMetrics.hpp"
 #include <NitroModules/Promise.hpp>
 #include <NitroModules/JPromise.hpp>
+#include "Quaternion.hpp"
+#include "JQuaternion.hpp"
 
 namespace margelo::nitro::reactnativecesium {
 
@@ -174,5 +178,25 @@ namespace margelo::nitro::reactnativecesium {
     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<Quaternion>> JHybridCesiumViewSpec::getViewCorrection() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("getViewCorrection");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<Quaternion>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<JQuaternion>(__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;
+    }();
+  }
 
 } // namespace margelo::nitro::reactnativecesium

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

@@ -75,6 +75,8 @@ namespace margelo::nitro::reactnativecesium {
     // Methods
     std::shared_ptr<Promise<CameraState>> getCameraState() override;
     void setCamera(const CameraState& camera) override;
+    void setCameraQuaternion(const CameraState& camera, const Quaternion& viewCorrection) override;
+    std::shared_ptr<Promise<Quaternion>> getViewCorrection() override;
 
   private:
     jni::global_ref<JHybridCesiumViewSpec::JavaPart> _javaPart;

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

@@ -0,0 +1,69 @@
+///
+/// JQuaternion.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 "Quaternion.hpp"
+
+
+
+namespace margelo::nitro::reactnativecesium {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "Quaternion" and the the Kotlin data class "Quaternion".
+   */
+  struct JQuaternion final: public jni::JavaClass<JQuaternion> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/reactnativecesium/Quaternion;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct Quaternion by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    Quaternion toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldW = clazz->getField<double>("w");
+      double w = this->getFieldValue(fieldW);
+      static const auto fieldX = clazz->getField<double>("x");
+      double x = this->getFieldValue(fieldX);
+      static const auto fieldY = clazz->getField<double>("y");
+      double y = this->getFieldValue(fieldY);
+      static const auto fieldZ = clazz->getField<double>("z");
+      double z = this->getFieldValue(fieldZ);
+      return Quaternion(
+        w,
+        x,
+        y,
+        z
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JQuaternion::javaobject> fromCpp(const Quaternion& value) {
+      using JSignature = JQuaternion(double, double, double, double);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.w,
+        value.x,
+        value.y,
+        value.z
+      );
+    }
+  };
+
+} // namespace margelo::nitro::reactnativecesium

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

@@ -103,6 +103,14 @@ abstract class HybridCesiumViewSpec: HybridView() {
   @DoNotStrip
   @Keep
   abstract fun setCamera(camera: CameraState): Unit
+  
+  @DoNotStrip
+  @Keep
+  abstract fun setCameraQuaternion(camera: CameraState, viewCorrection: Quaternion): Unit
+  
+  @DoNotStrip
+  @Keep
+  abstract fun getViewCorrection(): Promise<Quaternion>
 
   // Default implementation of `HybridObject.toString()`
   override fun toString(): String {

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

@@ -0,0 +1,47 @@
+///
+/// Quaternion.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.proguard.annotations.DoNotStrip
+
+
+/**
+ * Represents the JavaScript object/struct "Quaternion".
+ */
+@DoNotStrip
+@Keep
+data class Quaternion(
+  @DoNotStrip
+  @Keep
+  val w: Double,
+  @DoNotStrip
+  @Keep
+  val x: Double,
+  @DoNotStrip
+  @Keep
+  val y: Double,
+  @DoNotStrip
+  @Keep
+  val z: Double
+) {
+  /* primary constructor */
+
+  companion object {
+    /**
+     * Constructor called from C++
+     */
+    @DoNotStrip
+    @Keep
+    @Suppress("unused")
+    @JvmStatic
+    private fun fromCpp(w: Double, x: Double, y: Double, z: Double): Quaternion {
+      return Quaternion(w, x, y, z)
+    }
+  }
+}

package/nitrogen/generated/ios/ReactNativeCesium+autolinking.rb

@@ -56,5 +56,7 @@ def add_nitrogen_files(spec)
     "SWIFT_OBJC_INTEROP_MODE" => "objcxx",
     # Enables stricter modular headers
     "DEFINES_MODULE" => "YES",
+    # Disable auto-generated ObjC header for Swift (Static linkage on Xcode 26.4 breaks here)
+    "SWIFT_INSTALL_OBJC_HEADER" => "NO",
   })
 end

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

@@ -38,6 +38,14 @@ namespace margelo::nitro::reactnativecesium::bridge::swift {
     };
   }
   
+  // pragma MARK: std::function<void(const Quaternion& /* result */)>
+  Func_void_Quaternion create_Func_void_Quaternion(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = ReactNativeCesium::Func_void_Quaternion::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](const Quaternion& result) mutable -> void {
+      swiftClosure.call(result);
+    };
+  }
+  
   // pragma MARK: std::shared_ptr<HybridCesiumViewSpec>
   std::shared_ptr<HybridCesiumViewSpec> create_std__shared_ptr_HybridCesiumViewSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
     ReactNativeCesium::HybridCesiumViewSpec_cxx swiftPart = ReactNativeCesium::HybridCesiumViewSpec_cxx::fromUnsafe(swiftUnsafePointer);

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

@@ -14,6 +14,8 @@ namespace margelo::nitro::reactnativecesium { struct CameraState; }
 namespace margelo::nitro::reactnativecesium { struct CesiumMetrics; }
 // Forward declaration of `HybridCesiumViewSpec` to properly resolve imports.
 namespace margelo::nitro::reactnativecesium { class HybridCesiumViewSpec; }
+// Forward declaration of `Quaternion` to properly resolve imports.
+namespace margelo::nitro::reactnativecesium { struct Quaternion; }
 
 // Forward declarations of Swift defined types
 // Forward declaration of `HybridCesiumViewSpec_cxx` to properly resolve imports.
@@ -23,6 +25,7 @@ namespace ReactNativeCesium { class HybridCesiumViewSpec_cxx; }
 #include "CameraState.hpp"
 #include "CesiumMetrics.hpp"
 #include "HybridCesiumViewSpec.hpp"
+#include "Quaternion.hpp"
 #include <NitroModules/Promise.hpp>
 #include <NitroModules/PromiseHolder.hpp>
 #include <NitroModules/Result.hpp>
@@ -131,6 +134,40 @@ namespace margelo::nitro::reactnativecesium::bridge::swift {
     return Func_void_std__exception_ptr_Wrapper(std::move(value));
   }
   
+  // pragma MARK: std::shared_ptr<Promise<Quaternion>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<Quaternion>>`.
+   */
+  using std__shared_ptr_Promise_Quaternion__ = std::shared_ptr<Promise<Quaternion>>;
+  inline std::shared_ptr<Promise<Quaternion>> create_std__shared_ptr_Promise_Quaternion__() noexcept {
+    return Promise<Quaternion>::create();
+  }
+  inline PromiseHolder<Quaternion> wrap_std__shared_ptr_Promise_Quaternion__(std::shared_ptr<Promise<Quaternion>> promise) noexcept {
+    return PromiseHolder<Quaternion>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const Quaternion& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const Quaternion&)>`.
+   */
+  using Func_void_Quaternion = std::function<void(const Quaternion& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const Quaternion& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_Quaternion_Wrapper final {
+  public:
+    explicit Func_void_Quaternion_Wrapper(std::function<void(const Quaternion& /* result */)>&& func): _function(std::make_unique<std::function<void(const Quaternion& /* result */)>>(std::move(func))) {}
+    inline void call(Quaternion result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const Quaternion& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_Quaternion create_Func_void_Quaternion(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_Quaternion_Wrapper wrap_Func_void_Quaternion(Func_void_Quaternion value) noexcept {
+    return Func_void_Quaternion_Wrapper(std::move(value));
+  }
+  
   // pragma MARK: std::shared_ptr<HybridCesiumViewSpec>
   /**
    * Specialized version of `std::shared_ptr<HybridCesiumViewSpec>`.
@@ -160,5 +197,14 @@ namespace margelo::nitro::reactnativecesium::bridge::swift {
   inline Result_void_ create_Result_void_(const std::exception_ptr& error) noexcept {
     return Result<void>::withError(error);
   }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<Quaternion>>>
+  using Result_std__shared_ptr_Promise_Quaternion___ = Result<std::shared_ptr<Promise<Quaternion>>>;
+  inline Result_std__shared_ptr_Promise_Quaternion___ create_Result_std__shared_ptr_Promise_Quaternion___(const std::shared_ptr<Promise<Quaternion>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<Quaternion>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_Quaternion___ create_Result_std__shared_ptr_Promise_Quaternion___(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<Quaternion>>>::withError(error);
+  }
 
 } // namespace margelo::nitro::reactnativecesium::bridge::swift

package/nitrogen/generated/ios/ReactNativeCesium-Swift-Cxx-Umbrella.hpp

@@ -14,11 +14,14 @@ namespace margelo::nitro::reactnativecesium { struct CameraState; }
 namespace margelo::nitro::reactnativecesium { struct CesiumMetrics; }
 // Forward declaration of `HybridCesiumViewSpec` to properly resolve imports.
 namespace margelo::nitro::reactnativecesium { class HybridCesiumViewSpec; }
+// Forward declaration of `Quaternion` to properly resolve imports.
+namespace margelo::nitro::reactnativecesium { struct Quaternion; }
 
 // Include C++ defined types
 #include "CameraState.hpp"
 #include "CesiumMetrics.hpp"
 #include "HybridCesiumViewSpec.hpp"
+#include "Quaternion.hpp"
 #include <NitroModules/Promise.hpp>
 #include <NitroModules/Result.hpp>
 #include <exception>

package/nitrogen/generated/ios/c++/HybridCesiumViewSpecSwift.hpp

@@ -16,6 +16,8 @@ namespace ReactNativeCesium { class HybridCesiumViewSpec_cxx; }
 namespace margelo::nitro::reactnativecesium { struct CameraState; }
 // Forward declaration of `CesiumMetrics` to properly resolve imports.
 namespace margelo::nitro::reactnativecesium { struct CesiumMetrics; }
+// Forward declaration of `Quaternion` to properly resolve imports.
+namespace margelo::nitro::reactnativecesium { struct Quaternion; }
 
 #include <string>
 #include "CameraState.hpp"
@@ -23,6 +25,7 @@ namespace margelo::nitro::reactnativecesium { struct CesiumMetrics; }
 #include <functional>
 #include <optional>
 #include <NitroModules/Promise.hpp>
+#include "Quaternion.hpp"
 
 #include "ReactNativeCesium-Swift-Cxx-Umbrella.hpp"
 
@@ -149,6 +152,20 @@ namespace margelo::nitro::reactnativecesium {
         std::rethrow_exception(__result.error());
       }
     }
+    inline void setCameraQuaternion(const CameraState& camera, const Quaternion& viewCorrection) override {
+      auto __result = _swiftPart.setCameraQuaternion(std::forward<decltype(camera)>(camera), std::forward<decltype(viewCorrection)>(viewCorrection));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline std::shared_ptr<Promise<Quaternion>> getViewCorrection() override {
+      auto __result = _swiftPart.getViewCorrection();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
 
   private:
     ReactNativeCesium::HybridCesiumViewSpec_cxx _swiftPart;

package/nitrogen/generated/ios/swift/Func_void_Quaternion.swift

@@ -0,0 +1,46 @@
+///
+/// Func_void_Quaternion.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/**
+ * Wraps a Swift `(_ value: Quaternion) -> Void` as a class.
+ * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`.
+ */
+public final class Func_void_Quaternion {
+  public typealias bridge = margelo.nitro.reactnativecesium.bridge.swift
+
+  private let closure: (_ value: Quaternion) -> Void
+
+  public init(_ closure: @escaping (_ value: Quaternion) -> Void) {
+    self.closure = closure
+  }
+
+  @inline(__always)
+  public func call(value: Quaternion) -> Void {
+    self.closure(value)
+  }
+
+  /**
+   * Casts this instance to a retained unsafe raw pointer.
+   * This acquires one additional strong reference on the object!
+   */
+  @inline(__always)
+  public func toUnsafe() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(self).toOpaque()
+  }
+
+  /**
+   * Casts an unsafe pointer to a `Func_void_Quaternion`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void_Quaternion>`.
+   * This removes one strong reference from the object!
+   */
+  @inline(__always)
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_Quaternion {
+    return Unmanaged<Func_void_Quaternion>.fromOpaque(pointer).takeRetainedValue()
+  }
+}

package/nitrogen/generated/ios/swift/HybridCesiumViewSpec.swift

@@ -24,6 +24,8 @@ public protocol HybridCesiumViewSpec_protocol: HybridObject, HybridView {
   // Methods
   func getCameraState() throws -> Promise<CameraState>
   func setCamera(camera: CameraState) throws -> Void
+  func setCameraQuaternion(camera: CameraState, viewCorrection: Quaternion) throws -> Void
+  func getViewCorrection() throws -> Promise<Quaternion>
 }
 
 public extension HybridCesiumViewSpec_protocol {