From 4a781f04805a89cc726678ecfe2c829f22f62f01 Mon Sep 17 00:00:00 2001 From: Sameh Khamis Date: Sat, 14 Nov 2026 01:45:27 -0800 Subject: [PATCH] fix(cockpit): the orbital view gives the field of view back on exit Cesium's fov was saved and put back when the orbital view closed, so a later resize or rotation kept Cesium's own behaviour. The exit held the saved vertical angle through setFov instead, which the camera port kept for the rest of the session: rotated to portrait, the view stayed zoomed in. setFov(null) gives the field of view back: Cesium's fov as it was before the first hold, the stub's own angle. --- src/render/cesium/camera.js | 16 +++++++++++++++- src/render/cesium/cameraPort.test.mjs | 20 ++++++++++++++++++++ src/render/conformance/checks/camera.js | 5 ++++- src/render/contract/camera.d.ts | 7 ++++++- src/render/stub/camera.js | 5 +++-- src/ui/cockpitOrbitalView.js | 11 ++++------- 6 files changed, 52 insertions(+), 12 deletions(-) diff --git a/src/render/cesium/camera.js b/src/render/cesium/camera.js index ffe67ef7e..521da8cbb 100644 --- a/src/render/cesium/camera.js +++ b/src/render/cesium/camera.js @@ -240,6 +240,8 @@ export function createCesiumCamera({ * view, it waits. */ let heldFovy = null; + /** Cesium's own `fov` before the first hold, put back on release. */ + let ownFov = null; function applyFov() { const frustum = camera.frustum; const aspect = frustum?.aspectRatio; @@ -388,10 +390,22 @@ export function createCesiumCamera({ camera.lookAtTransform(Cesium.Matrix4.IDENTITY); scene.requestRender(); }, - setFov({ vertical }) { + setFov(fov) { + const frustum = camera.frustum; + if (fov === null) { + // Given back: Cesium's own angle again, kept as it keeps it. + if (heldFovy !== null && ownFov !== null && 'fov' in frustum) + frustum.fov = ownFov; + heldFovy = null; + ownFov = null; + scene.requestRender(); + return; + } + const { vertical } = fov; // Cesium would take a bad angle and draw a garbage projection. if (!(vertical > 0 && vertical < Math.PI)) throw new RangeError(`no vertical field of view of ${vertical}`); + if (heldFovy === null && 'fov' in frustum) ownFov = frustum.fov; heldFovy = vertical; applyFov(); scene.requestRender(); diff --git a/src/render/cesium/cameraPort.test.mjs b/src/render/cesium/cameraPort.test.mjs index 30fe8fd1e..c65484035 100644 --- a/src/render/cesium/cameraPort.test.mjs +++ b/src/render/cesium/cameraPort.test.mjs @@ -305,6 +305,26 @@ test('setFov holds the vertical angle across resizes, and waits for a first one' assert.throws(() => port.setFov({ vertical: NaN }), RangeError); }); +test('setFov(null) gives the angle back: Cesium’s own fov again, kept as Cesium keeps it', () => { + const { scene, camera } = headlessCamera(); + scene.postUpdate = new Cesium.Event(); + scene.requestRender = () => {}; + camera.frustum.aspectRatio = 16 / 9; + const own = camera.frustum.fov; + const { port } = createCesiumCamera({ scene, camera, report: () => {} }); + port.setFov({ vertical: 0.5 }); + port.setFov({ vertical: 0.3 }); + scene.postUpdate.raiseEvent(scene); + port.setFov(null); + assert.equal(camera.frustum.fov, own, 'the fov it had before the first hold'); + // Rotated to portrait: Cesium keeps its fov, which is now the vertical + // angle, rather than the held one. + camera.frustum.aspectRatio = 9 / 16; + scene.postUpdate.raiseEvent(scene); + assert.equal(camera.frustum.fov, own); + assert.ok(Math.abs(camera.frustum.fovy - own) < 1e-12); +}); + test('a pose measures heading, pitch and roll as Cesium does, and leaves the camera as it was', () => { const { camera, port } = headlessPort(); const bits = () => diff --git a/src/render/conformance/checks/camera.js b/src/render/conformance/checks/camera.js index 52d0532df..00e380315 100644 --- a/src/render/conformance/checks/camera.js +++ b/src/render/conformance/checks/camera.js @@ -917,9 +917,10 @@ export function cameraChecks() { { id: 'camera.fov', port: 'camera', - title: 'setFov sets the vertical field of view', + title: 'setFov sets the vertical field of view; null gives it back', async run(h) { const r = await fresh(h); + const own = r.camera.pose().fovy; r.camera.setFov({ vertical: 0.5 }); near(r.camera.pose().fovy, 0.5, 1e-12, 'fovy'); near( @@ -928,6 +929,8 @@ export function cameraChecks() { 1e-9, 'aspect', ); + r.camera.setFov(null); + near(r.camera.pose().fovy, own, 1e-9, 'the renderer’s own again'); r.destroy(); }, }, diff --git a/src/render/contract/camera.d.ts b/src/render/contract/camera.d.ts index 7e30a495a..ee144fc25 100644 --- a/src/render/contract/camera.d.ts +++ b/src/render/contract/camera.d.ts @@ -240,7 +240,12 @@ export interface CameraPort { * sent many times over. */ setView(view: ViewSpec): void; - setFov(fov: { vertical: number }): void; + /** + * Hold the vertical field of view, across resizes, until `null` gives the + * field of view back to the renderer: it is then as it was before the + * first hold, and follows the view's shape as the renderer's own does. + */ + setFov(fov: { vertical: number } | null): void; /** * The geodetic rectangle in view: the bounds of the canvas corners on the * ellipsoid, a corner that misses it taken where the horizon is, and the diff --git a/src/render/stub/camera.js b/src/render/stub/camera.js index bb5b2d5d6..657402f7f 100644 --- a/src/render/stub/camera.js +++ b/src/render/stub/camera.js @@ -798,8 +798,9 @@ export function createStubCamera({ const port = { pose, setView, - setFov({ vertical }) { - fovy = vertical; + setFov(fov) { + // null: the stub's own angle again, the wider one kept as it was. + fovy = fov === null ? null : fov.vertical; requestRender('camera'); }, viewRectangle: () => null, diff --git a/src/ui/cockpitOrbitalView.js b/src/ui/cockpitOrbitalView.js index 347ea14d4..039e6aca0 100644 --- a/src/ui/cockpitOrbitalView.js +++ b/src/ui/cockpitOrbitalView.js @@ -72,11 +72,10 @@ const IDLE_TRANSITION = Object.freeze({ const NADIR_LOOK = Object.freeze({ yawDeg: 0, pitchDeg: 0 }); /** - * Start an orbital session's state. Keeps the camera's own field of view so - * the exit can put it back exactly. + * Start an orbital session's state. The exit gives the field of view back + * to the renderer, as it was before the session. */ export function beginOrbital() { - const fovy = cameraOf(this.viewer).pose().fovy; const state = { imagery: acquireOrbitImagery(this.services), zoom: ORBITAL_DEFAULT_ZOOM, @@ -85,8 +84,6 @@ export function beginOrbital() { // A zoom step in flight: the magnification it started from and when. transition: null, previousUp: null, - // The vertical field of view the camera had, put back on exit. - savedFov: Number.isFinite(fovy) ? fovy : null, altitudeM: null, verticalFov: null, lastBriefMs: 0, @@ -116,8 +113,8 @@ export function endOrbital() { if (!state) return; this.orbital = null; state.placeTracker?.reset(); - if (state.savedFov !== null) - cameraOf(this.viewer).setFov({ vertical: state.savedFov }); + // The renderer's own field of view again, following the view's shape. + cameraOf(this.viewer).setFov(null); // Back to the map the operator had, unless they picked another meanwhile. state.imagery?.release?.()?.catch?.(() => {}); this.publishOrbital(null);