mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 16:22:20 +00:00
The application shell keeps the page's globe engine and hands it to the navigation controller, location navigation (search, city and POI flights, orbit, globe reset), the tilt and north-up controls, share-link save and restore, share restoration's first-gesture listeners and the HUD. The viewer is passed only where entity tracking still lives on it (phase 1c) and to the HUD's basemap label context (voice); every such use is null-safe. Share links and captured shots write heading and roll as Cesium's camera reports them (src/cameraAngles.js): the contract's [0, 2π) pose maps an exact 0 back to Cesium's 2π, except the roll of a vertical view, so links stay byte-identical (heading=360, roll=360) on every engine. Source-reading tests follow the moved code with the same checks.
764 lines
27 KiB
JavaScript
764 lines
27 KiB
JavaScript
import assert from 'node:assert/strict';
|
|
import test from 'node:test';
|
|
import * as Cesium from 'cesium';
|
|
import {
|
|
OBLIQUE_PITCH,
|
|
STRAIGHT_DOWN_PITCH,
|
|
bindCameraOrientationControls,
|
|
createCameraOrientationAnimator,
|
|
pickViewTarget,
|
|
readCameraTargetFrame,
|
|
resetCameraNorth,
|
|
toggleCameraTilt,
|
|
} from './cameraOrientationControls.js';
|
|
import { NavigationController } from './navigationController.js';
|
|
import { createFakeEngine } from '../globe/testing/fakeEngine.js';
|
|
import { createCesiumEngine } from '../globe/cesium/createCesiumEngine.js';
|
|
import { registerViewerEngine } from '../globe/cesium/engineFromViewer.js';
|
|
|
|
// The controls run on the globe engine; these viewer doubles get the Cesium
|
|
// engine registered for them, as the app's scene engine is.
|
|
function withEngine(viewer) {
|
|
registerViewerEngine(viewer, createCesiumEngine(viewer));
|
|
return viewer;
|
|
}
|
|
|
|
/** Same Cartesian values (the engine hands out copies, never Cesium's own). */
|
|
const sameXYZ = (actual, expected, message) =>
|
|
assert.deepEqual(
|
|
[actual?.x, actual?.y, actual?.z],
|
|
[expected.x, expected.y, expected.z],
|
|
message,
|
|
);
|
|
|
|
function createViewer({ cameraPosition, target, pickPosition = null } = {}) {
|
|
const calls = [];
|
|
const changed = new Cesium.Event();
|
|
const surface = target || Cesium.Cartesian3.fromDegrees(0, 0, 0);
|
|
const position = cameraPosition || Cesium.Cartesian3.fromDegrees(0, 0, 1_000);
|
|
const camera = {
|
|
positionWC: position,
|
|
directionWC: new Cesium.Cartesian3(-1, 0, 0),
|
|
upWC: new Cesium.Cartesian3(0, 0, 1),
|
|
heading: Cesium.Math.toRadians(90),
|
|
pitch: Cesium.Math.toRadians(-90),
|
|
roll: 0,
|
|
frustum: { fovy: 1, aspectRatio: 1.5 },
|
|
changed,
|
|
moveStart: new Cesium.Event(),
|
|
moveEnd: new Cesium.Event(),
|
|
pickEllipsoid: () => surface,
|
|
getPickRay: () => ({}),
|
|
lookAt(targetValue, offset) {
|
|
calls.push({ type: 'lookAt', target: targetValue, offset });
|
|
},
|
|
lookAtTransform(transform) {
|
|
calls.push({ type: 'lookAtTransform', transform });
|
|
},
|
|
setView(view) {
|
|
calls.push({ type: 'setView', view });
|
|
},
|
|
};
|
|
const viewer = {
|
|
camera,
|
|
scene: {
|
|
canvas: { clientWidth: 1_200, clientHeight: 800 },
|
|
pickPositionSupported: Boolean(pickPosition),
|
|
pickPosition: pickPosition || (() => null),
|
|
globe: { pick: () => surface },
|
|
requestRender: () => calls.push({ type: 'requestRender' }),
|
|
preUpdate: new Cesium.Event(),
|
|
preRender: new Cesium.Event(),
|
|
postRender: new Cesium.Event(),
|
|
},
|
|
};
|
|
return { viewer: withEngine(viewer), calls, target: surface };
|
|
}
|
|
|
|
class FakeButton extends EventTarget {
|
|
constructor() {
|
|
super();
|
|
this.attributes = new Map();
|
|
this.style = {
|
|
setProperty: (name, value) => this.attributes.set(name, value),
|
|
};
|
|
}
|
|
setAttribute(name, value) {
|
|
this.attributes.set(name, String(value));
|
|
}
|
|
getAttribute(name) {
|
|
return this.attributes.get(name);
|
|
}
|
|
click() {
|
|
this.dispatchEvent(new Event('click'));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* A real Cesium camera attached to a minimal offscreen scene.
|
|
*
|
|
* The fake above records what lookAt was asked for but never moves, so it
|
|
* cannot show whether a frame written into the camera reads back as the same
|
|
* frame. These cases need the production math on both sides.
|
|
*/
|
|
function createRealCamera() {
|
|
const scene = {
|
|
canvas: { clientWidth: 1200, clientHeight: 800, width: 1200, height: 800 },
|
|
drawingBufferWidth: 1200,
|
|
drawingBufferHeight: 800,
|
|
mapProjection: new Cesium.GeographicProjection(Cesium.Ellipsoid.WGS84),
|
|
globe: { ellipsoid: Cesium.Ellipsoid.WGS84 },
|
|
mapMode2D: Cesium.MapMode2D.INFINITE_SCROLL,
|
|
// setView converts a world-space direction/up pair into the local frame
|
|
// only in 3D, and the camera derives heading/pitch the same way, so the
|
|
// scene mode is load-bearing here rather than decoration.
|
|
mode: Cesium.SceneMode.SCENE3D,
|
|
pixelRatio: 1,
|
|
};
|
|
const camera = new Cesium.Camera(scene);
|
|
scene.camera = camera;
|
|
return { camera, scene };
|
|
}
|
|
|
|
/** A viewer whose center pick is a fixed ground point and whose camera is real. */
|
|
function createRealViewer(target) {
|
|
const { camera, scene } = createRealCamera();
|
|
scene.pickPositionSupported = false;
|
|
scene.pickPosition = () => null;
|
|
scene.globe.pick = () => target;
|
|
scene.requestRender = () => {};
|
|
// The binding drives the needle from the scene's per-frame signal, not from
|
|
// `camera.changed`, so the fixture has to carry one.
|
|
scene.preRender = new Cesium.Event();
|
|
scene.preUpdate = new Cesium.Event();
|
|
scene.postRender = new Cesium.Event();
|
|
camera.getPickRay = () => ({});
|
|
return { viewer: withEngine({ camera, scene }), target };
|
|
}
|
|
|
|
/** Place a real camera in an orbit around `target` and release the frame. */
|
|
function orbit(viewer, target, headingDeg, pitchRad, range) {
|
|
viewer.camera.lookAt(
|
|
target,
|
|
new Cesium.HeadingPitchRange(
|
|
Cesium.Math.toRadians(headingDeg),
|
|
pitchRad,
|
|
range,
|
|
),
|
|
);
|
|
viewer.camera.lookAtTransform(Cesium.Matrix4.IDENTITY);
|
|
}
|
|
|
|
const AUSTIN_GROUND = Cesium.Cartesian3.fromDegrees(-97.7431, 30.2672, 0);
|
|
|
|
test('a heading written into a real camera reads back as the same heading', () => {
|
|
// One oblique heading per quadrant, plus the cardinals, at pitches a user
|
|
// reaches with the tilt control.
|
|
for (const headingDeg of [0, 30, 90, 135, 180, 225, 270, 315, 350]) {
|
|
for (const pitchDeg of [-25, -40, -65]) {
|
|
const { viewer } = createRealViewer(AUSTIN_GROUND);
|
|
viewer.camera.lookAt(
|
|
AUSTIN_GROUND,
|
|
new Cesium.HeadingPitchRange(
|
|
Cesium.Math.toRadians(headingDeg),
|
|
Cesium.Math.toRadians(pitchDeg),
|
|
4000,
|
|
),
|
|
);
|
|
viewer.camera.lookAtTransform(Cesium.Matrix4.IDENTITY);
|
|
|
|
const frame = readCameraTargetFrame(viewer);
|
|
assert.ok(frame, `no frame at ${headingDeg}/${pitchDeg}`);
|
|
const readDeg = Cesium.Math.toDegrees(frame.heading);
|
|
assert.ok(
|
|
Math.abs(((readDeg - headingDeg + 540) % 360) - 180) < 0.01,
|
|
`heading ${headingDeg} deg at pitch ${pitchDeg} read back as ${readDeg.toFixed(2)} deg`,
|
|
);
|
|
assert.ok(
|
|
Math.abs(Cesium.Math.toDegrees(frame.pitch) - pitchDeg) < 0.01,
|
|
`pitch ${pitchDeg} read back as ${Cesium.Math.toDegrees(frame.pitch).toFixed(2)}`,
|
|
);
|
|
assert.ok(Math.abs(frame.range - 4000) < 1, `range ${frame.range}`);
|
|
}
|
|
}
|
|
});
|
|
|
|
test('north-up really points a real camera north from every quadrant', () => {
|
|
for (const headingDeg of [30, 135, 225, 315]) {
|
|
const { viewer } = createRealViewer(AUSTIN_GROUND);
|
|
viewer.camera.lookAt(
|
|
AUSTIN_GROUND,
|
|
new Cesium.HeadingPitchRange(
|
|
Cesium.Math.toRadians(headingDeg),
|
|
Cesium.Math.toRadians(-40),
|
|
4000,
|
|
),
|
|
);
|
|
viewer.camera.lookAtTransform(Cesium.Matrix4.IDENTITY);
|
|
|
|
assert.equal(
|
|
resetCameraNorth(viewer),
|
|
true,
|
|
`reset failed at ${headingDeg}`,
|
|
);
|
|
const after = readCameraTargetFrame(viewer);
|
|
assert.ok(after, `no frame after reset at ${headingDeg}`);
|
|
const readDeg = Cesium.Math.toDegrees(after.heading);
|
|
assert.ok(
|
|
Math.min(readDeg, 360 - readDeg) < 0.01,
|
|
`north-up from ${headingDeg} deg left the camera at ${readDeg.toFixed(2)} deg`,
|
|
);
|
|
assert.ok(
|
|
Math.abs(Cesium.Math.toDegrees(after.pitch) + 40) < 0.01,
|
|
'north-up must not change the pitch',
|
|
);
|
|
assert.ok(
|
|
Math.abs(after.range - 4000) < 1,
|
|
'north-up must not change the range',
|
|
);
|
|
}
|
|
});
|
|
|
|
test('tilt moves a real camera between the two pitches and keeps target and range', () => {
|
|
const { viewer } = createRealViewer(AUSTIN_GROUND);
|
|
viewer.camera.lookAt(
|
|
AUSTIN_GROUND,
|
|
new Cesium.HeadingPitchRange(
|
|
Cesium.Math.toRadians(215),
|
|
STRAIGHT_DOWN_PITCH,
|
|
3000,
|
|
),
|
|
);
|
|
viewer.camera.lookAtTransform(Cesium.Matrix4.IDENTITY);
|
|
|
|
const first = toggleCameraTilt(viewer);
|
|
assert.deepEqual(first, { tilted: true, pitch: OBLIQUE_PITCH });
|
|
const tilted = readCameraTargetFrame(viewer);
|
|
assert.ok(Math.abs(tilted.pitch - OBLIQUE_PITCH) < 1e-6);
|
|
assert.ok(Math.abs(tilted.range - 3000) < 1, `range ${tilted.range}`);
|
|
assert.ok(
|
|
Math.abs(Cesium.Math.toDegrees(tilted.heading) - 215) < 0.01,
|
|
'tilt must not rotate the map',
|
|
);
|
|
|
|
// Releasing the orbit frame must leave the camera pointing at the same
|
|
// ground, not merely standing in the right place.
|
|
const toTarget = Cesium.Cartesian3.normalize(
|
|
Cesium.Cartesian3.subtract(
|
|
AUSTIN_GROUND,
|
|
viewer.camera.positionWC,
|
|
new Cesium.Cartesian3(),
|
|
),
|
|
new Cesium.Cartesian3(),
|
|
);
|
|
const offBy = Cesium.Math.toDegrees(
|
|
Math.acos(
|
|
Cesium.Math.clamp(
|
|
Cesium.Cartesian3.dot(viewer.camera.directionWC, toTarget),
|
|
-1,
|
|
1,
|
|
),
|
|
),
|
|
);
|
|
assert.ok(
|
|
offBy < 0.05,
|
|
`camera points ${offBy.toFixed(2)} deg away from its target`,
|
|
);
|
|
|
|
const second = toggleCameraTilt(viewer);
|
|
assert.deepEqual(second, { tilted: false, pitch: STRAIGHT_DOWN_PITCH });
|
|
const down = readCameraTargetFrame(viewer);
|
|
assert.ok(Math.abs(down.pitch - STRAIGHT_DOWN_PITCH) < 1e-6);
|
|
assert.ok(Math.abs(down.range - 3000) < 1);
|
|
});
|
|
|
|
test('tilt alternates at globe range, not only at map range', () => {
|
|
// The canonical full-globe view. The camera's own pitch here is tens of
|
|
// degrees away from the orbit pitch, so a control reading the camera would
|
|
// command oblique twice in a row and the map would never come back level.
|
|
for (const range of [3_000, 250_000, 18_000_000]) {
|
|
const { viewer } = createRealViewer(AUSTIN_GROUND);
|
|
orbit(viewer, AUSTIN_GROUND, 0, STRAIGHT_DOWN_PITCH, range);
|
|
|
|
const first = toggleCameraTilt(viewer);
|
|
assert.deepEqual(
|
|
first,
|
|
{ tilted: true, pitch: OBLIQUE_PITCH },
|
|
`first click at ${range} m must tilt`,
|
|
);
|
|
const second = toggleCameraTilt(viewer);
|
|
assert.deepEqual(
|
|
second,
|
|
{ tilted: false, pitch: STRAIGHT_DOWN_PITCH },
|
|
`second click at ${range} m must level (camera pitch reads ${Cesium.Math.toDegrees(viewer.camera.pitch).toFixed(1)} deg)`,
|
|
);
|
|
const third = toggleCameraTilt(viewer);
|
|
assert.deepEqual(
|
|
third,
|
|
{ tilted: true, pitch: OBLIQUE_PITCH },
|
|
`third click at ${range} m must tilt again`,
|
|
);
|
|
}
|
|
});
|
|
|
|
test('the button shows the state the next click will produce, at every range', () => {
|
|
for (const range of [3_000, 18_000_000]) {
|
|
const { viewer } = createRealViewer(AUSTIN_GROUND);
|
|
orbit(viewer, AUSTIN_GROUND, 0, STRAIGHT_DOWN_PITCH, range);
|
|
const tiltButton = new FakeButton();
|
|
const controls = bindCameraOrientationControls({
|
|
viewer,
|
|
elements: { tiltButton, northButton: new FakeButton() },
|
|
runNavigation: (_noun, navigate) => navigate(),
|
|
// No frame loop drives this fixture: apply each change at once.
|
|
animationMs: 0,
|
|
});
|
|
|
|
assert.equal(
|
|
tiltButton.getAttribute('aria-pressed'),
|
|
'false',
|
|
`straight down at ${range} m must not read as tilted`,
|
|
);
|
|
tiltButton.click();
|
|
assert.equal(
|
|
tiltButton.getAttribute('aria-pressed'),
|
|
'true',
|
|
`after one click at ${range} m the button must read tilted`,
|
|
);
|
|
// And the exact refresh that runs when the camera settles must agree.
|
|
controls.refreshTilt();
|
|
assert.equal(
|
|
tiltButton.getAttribute('aria-pressed'),
|
|
'true',
|
|
`the settled state at ${range} m must agree with the commanded one`,
|
|
);
|
|
controls.destroy();
|
|
}
|
|
});
|
|
|
|
test('the needle follows a rotation too small for the camera-changed threshold', () => {
|
|
const { viewer } = createRealViewer(AUSTIN_GROUND);
|
|
orbit(viewer, AUSTIN_GROUND, 0, Cesium.Math.toRadians(-80), 5_000);
|
|
const northButton = new FakeButton();
|
|
const controls = bindCameraOrientationControls({
|
|
viewer,
|
|
elements: { tiltButton: new FakeButton(), northButton },
|
|
runNavigation: (_noun, navigate) => navigate(),
|
|
});
|
|
assert.equal(northButton.getAttribute('--camera-heading'), '0deg');
|
|
|
|
// Ten degrees is far below Cesium's default percentageChanged, so
|
|
// `camera.changed` may never fire for it; the per-frame signal must.
|
|
let changedFired = 0;
|
|
viewer.camera.changed.addEventListener(() => {
|
|
changedFired += 1;
|
|
});
|
|
orbit(viewer, AUSTIN_GROUND, 10, Cesium.Math.toRadians(-80), 5_000);
|
|
viewer.scene.preRender.raiseEvent();
|
|
assert.equal(
|
|
northButton.getAttribute('--camera-heading'),
|
|
'10deg',
|
|
`needle must follow a 10 degree rotation (camera.changed fired ${changedFired} time(s))`,
|
|
);
|
|
|
|
orbit(viewer, AUSTIN_GROUND, 13, Cesium.Math.toRadians(-80), 5_000);
|
|
viewer.scene.preRender.raiseEvent();
|
|
assert.equal(northButton.getAttribute('--camera-heading'), '13deg');
|
|
controls.destroy();
|
|
});
|
|
|
|
test('north-up indicator follows real heading including the 360-degree seam', () => {
|
|
const { viewer } = createRealViewer(AUSTIN_GROUND);
|
|
const northButton = new FakeButton();
|
|
const controls = bindCameraOrientationControls({
|
|
viewer,
|
|
elements: { northButton },
|
|
runNavigation: (_noun, navigate) => navigate(),
|
|
});
|
|
for (const [heading, active] of [
|
|
[0, true],
|
|
[15, false],
|
|
[359.8, true],
|
|
[359, false],
|
|
[360, true],
|
|
[90, false],
|
|
]) {
|
|
orbit(viewer, AUSTIN_GROUND, heading, Cesium.Math.toRadians(-80), 5_000);
|
|
viewer.scene.preRender.raiseEvent();
|
|
assert.equal(
|
|
northButton.getAttribute('data-north-up'),
|
|
String(active),
|
|
`heading ${heading}`,
|
|
);
|
|
}
|
|
controls.destroy();
|
|
});
|
|
|
|
test('a settled camera writes nothing, and teardown releases every signal', () => {
|
|
const { viewer } = createRealViewer(AUSTIN_GROUND);
|
|
orbit(viewer, AUSTIN_GROUND, 0, Cesium.Math.toRadians(-80), 5_000);
|
|
const tiltButton = new FakeButton();
|
|
const northButton = new FakeButton();
|
|
let writes = 0;
|
|
const count = (element) => {
|
|
const setAttribute = element.setAttribute.bind(element);
|
|
const setProperty = element.style.setProperty.bind(element.style);
|
|
element.setAttribute = (name, value) => {
|
|
writes += 1;
|
|
setAttribute(name, value);
|
|
};
|
|
element.style.setProperty = (name, value) => {
|
|
writes += 1;
|
|
setProperty(name, value);
|
|
};
|
|
};
|
|
count(tiltButton);
|
|
count(northButton);
|
|
|
|
const preRenderBefore = viewer.scene.preRender.numberOfListeners;
|
|
const moveEndBefore = viewer.camera.moveEnd.numberOfListeners;
|
|
const controls = bindCameraOrientationControls({
|
|
viewer,
|
|
elements: { tiltButton, northButton },
|
|
runNavigation: (_noun, navigate) => navigate(),
|
|
});
|
|
assert.equal(viewer.scene.preRender.numberOfListeners, preRenderBefore + 1);
|
|
assert.equal(viewer.camera.moveEnd.numberOfListeners, moveEndBefore + 1);
|
|
|
|
writes = 0;
|
|
for (let i = 0; i < 60; i += 1) viewer.scene.preRender.raiseEvent();
|
|
assert.equal(writes, 0, '60 frames of a settled camera write nothing');
|
|
|
|
orbit(viewer, AUSTIN_GROUND, 47, Cesium.Math.toRadians(-80), 5_000);
|
|
viewer.scene.preRender.raiseEvent();
|
|
assert.ok(writes > 0, 'a rotated camera updates the needle');
|
|
writes = 0;
|
|
for (let i = 0; i < 20; i += 1) viewer.scene.preRender.raiseEvent();
|
|
assert.equal(writes, 0, 'and then goes quiet again');
|
|
|
|
controls.destroy();
|
|
assert.equal(viewer.scene.preRender.numberOfListeners, preRenderBefore);
|
|
assert.equal(viewer.camera.moveEnd.numberOfListeners, moveEndBefore);
|
|
writes = 0;
|
|
orbit(viewer, AUSTIN_GROUND, 120, Cesium.Math.toRadians(-80), 5_000);
|
|
viewer.scene.preRender.raiseEvent();
|
|
viewer.camera.moveEnd.raiseEvent();
|
|
tiltButton.click();
|
|
assert.equal(writes, 0, 'a destroyed binding writes nothing');
|
|
});
|
|
|
|
test('a sky-facing camera yields no frame and both actions decline', () => {
|
|
const { camera, scene } = createRealCamera();
|
|
scene.pickPositionSupported = false;
|
|
scene.pickPosition = () => null;
|
|
scene.globe.pick = () => undefined;
|
|
scene.requestRender = () => {};
|
|
camera.getPickRay = () => ({});
|
|
camera.pickEllipsoid = () => undefined;
|
|
const viewer = withEngine({ camera, scene });
|
|
|
|
assert.equal(readCameraTargetFrame(viewer), null);
|
|
assert.equal(toggleCameraTilt(viewer), false);
|
|
assert.equal(resetCameraNorth(viewer), false);
|
|
});
|
|
|
|
test('center picking prefers terrain over the ellipsoid and falls through an invalid depth hit', () => {
|
|
const invalid = new Cesium.Cartesian3(Number.NaN, 0, 0);
|
|
const terrain = Cesium.Cartesian3.fromDegrees(-97.74, 30.27, 400);
|
|
const sea = Cesium.Cartesian3.fromDegrees(-97.74, 30.27, 0);
|
|
const { viewer } = createViewer({ pickPosition: () => invalid });
|
|
viewer.scene.globe.pick = () => terrain;
|
|
viewer.camera.pickEllipsoid = () => sea;
|
|
sameXYZ(
|
|
pickViewTarget(viewer),
|
|
terrain,
|
|
'the rendered ground wins over sea level',
|
|
);
|
|
|
|
viewer.scene.globe.pick = () => null;
|
|
sameXYZ(
|
|
pickViewTarget(viewer),
|
|
sea,
|
|
'the ellipsoid still answers when nothing is under the cursor',
|
|
);
|
|
});
|
|
|
|
test('target frame identifies a straight-down camera in local ENU space', () => {
|
|
const { viewer } = createViewer();
|
|
const frame = readCameraTargetFrame(viewer);
|
|
assert.ok(frame);
|
|
assert.ok(Math.abs(frame.pitch - Cesium.Math.toRadians(-90)) < 0.001);
|
|
assert.ok(frame.range > 999 && frame.range < 1_001);
|
|
assert.equal(frame.heading, Cesium.Math.toRadians(90));
|
|
});
|
|
|
|
test('tilt preserves the picked target and range while choosing oblique pitch', () => {
|
|
const { viewer, calls, target } = createViewer();
|
|
const before = readCameraTargetFrame(viewer);
|
|
const result = toggleCameraTilt(viewer);
|
|
const lookAt = calls.find((call) => call.type === 'lookAt');
|
|
assert.deepEqual(result, { tilted: true, pitch: OBLIQUE_PITCH });
|
|
sameXYZ(lookAt.target, target);
|
|
assert.equal(lookAt.offset.range, before.range);
|
|
assert.equal(lookAt.offset.pitch, OBLIQUE_PITCH);
|
|
assert.ok(calls.some((call) => call.type === 'lookAtTransform'));
|
|
assert.ok(calls.some((call) => call.type === 'setView'));
|
|
});
|
|
|
|
test('north-up preserves target pitch and range', () => {
|
|
const { viewer, calls } = createViewer();
|
|
const before = readCameraTargetFrame(viewer);
|
|
assert.equal(resetCameraNorth(viewer), true);
|
|
const lookAt = calls.find((call) => call.type === 'lookAt');
|
|
assert.equal(lookAt.offset.heading, 0);
|
|
assert.equal(lookAt.offset.pitch, before.pitch);
|
|
assert.equal(lookAt.offset.range, before.range);
|
|
});
|
|
|
|
test('bindings route both controls and release every listener on destroy', () => {
|
|
const { viewer } = createViewer();
|
|
const tiltButton = new FakeButton();
|
|
const northButton = new FakeButton();
|
|
const navigations = [];
|
|
const toasts = [];
|
|
const controls = bindCameraOrientationControls({
|
|
viewer,
|
|
elements: { tiltButton, northButton },
|
|
runNavigation(noun, navigate) {
|
|
navigations.push(noun);
|
|
return navigate();
|
|
},
|
|
showToast: (message) => toasts.push(message),
|
|
});
|
|
|
|
tiltButton.click();
|
|
northButton.click();
|
|
assert.deepEqual(navigations, ['camera', 'camera']);
|
|
assert.deepEqual(toasts, ['Tilted view', 'North up']);
|
|
// The button shows the state the click just commanded, not a re-measurement.
|
|
assert.equal(tiltButton.getAttribute('aria-pressed'), 'true');
|
|
assert.equal(northButton.getAttribute('--camera-heading'), '90deg');
|
|
|
|
viewer.camera.heading = -1e-12;
|
|
controls.sync();
|
|
assert.equal(northButton.getAttribute('--camera-heading'), '0deg');
|
|
|
|
controls.destroy();
|
|
tiltButton.click();
|
|
assert.deepEqual(navigations, ['camera', 'camera']);
|
|
assert.equal(STRAIGHT_DOWN_PITCH, Cesium.Math.toRadians(-89));
|
|
});
|
|
|
|
for (const [label, altitude, range] of [
|
|
['aircraft', 10000, 1500],
|
|
['satellite', 400000, 1500000],
|
|
['high satellite', 35786000, 3000000],
|
|
]) {
|
|
test(`${label}: animated tilt and north retain a moving EntityView`, (t) => {
|
|
// Use Cesium's built-in TEME fallback without fetching Earth-orientation data.
|
|
t.mock.method(
|
|
Cesium.Transforms,
|
|
'computeFixedToIcrfMatrix',
|
|
() => undefined,
|
|
);
|
|
let target = Cesium.Cartesian3.fromDegrees(-97, 30, altitude);
|
|
const { viewer } = createRealViewer(target);
|
|
viewer.clock = { currentTime: Cesium.JulianDate.now() };
|
|
const entity = new Cesium.Entity({
|
|
position: new Cesium.CallbackPositionProperty(() => target, false),
|
|
trackingReferenceFrame: Cesium.TrackingReferenceFrame.ENU,
|
|
});
|
|
entity.gevDisplayPosition = () => target;
|
|
viewer.trackedEntity = entity;
|
|
const follow = new Cesium.EntityView(entity, viewer.scene);
|
|
follow.update(viewer.clock.currentTime);
|
|
viewer.camera.lookAt(
|
|
target,
|
|
new Cesium.HeadingPitchRange(
|
|
Cesium.Math.toRadians(350),
|
|
OBLIQUE_PITCH,
|
|
range,
|
|
),
|
|
);
|
|
let time = 0;
|
|
const animator = createCameraOrientationAnimator(viewer, {
|
|
now: () => time,
|
|
duration: 1000,
|
|
});
|
|
for (const pitch of [STRAIGHT_DOWN_PITCH, OBLIQUE_PITCH]) {
|
|
const frame = readCameraTargetFrame(viewer);
|
|
animator.animate(frame, { heading: 0, pitch });
|
|
for (const step of [0, 100, 500, 900, 1000]) {
|
|
time = (pitch === STRAIGHT_DOWN_PITCH ? 0 : 1000) + step;
|
|
target = Cesium.Cartesian3.fromDegrees(
|
|
-97 + time / 100000,
|
|
30,
|
|
altitude,
|
|
);
|
|
follow.update(viewer.clock.currentTime);
|
|
const transform = Cesium.Matrix4.clone(viewer.camera.transform);
|
|
viewer.scene.preUpdate.raiseEvent();
|
|
assert.equal(viewer.trackedEntity, entity);
|
|
assert.ok(
|
|
Cesium.Matrix4.equalsEpsilon(
|
|
viewer.camera.transform,
|
|
transform,
|
|
1e-8,
|
|
),
|
|
);
|
|
const actual = readCameraTargetFrame(viewer);
|
|
const eased = Cesium.EasingFunction.CUBIC_IN_OUT(step / 1000);
|
|
assert.ok(
|
|
Math.abs(actual.pitch - Cesium.Math.lerp(frame.pitch, pitch, eased)) <
|
|
1e-6,
|
|
);
|
|
assert.ok(Math.abs(actual.range - range) < 1e-5);
|
|
}
|
|
assert.equal(viewer.scene.preUpdate.numberOfListeners, 0);
|
|
}
|
|
target = Cesium.Cartesian3.fromDegrees(-96, 31, altitude);
|
|
follow.update(viewer.clock.currentTime);
|
|
assert.equal(viewer.trackedEntity, entity);
|
|
assert.ok(Math.abs(readCameraTargetFrame(viewer).range - range) < 1e-5);
|
|
});
|
|
}
|
|
|
|
test('orientation animation cancels on replacement and explicit cancellation', () => {
|
|
const { viewer } = createRealViewer(Cesium.Cartesian3.fromDegrees(0, 0));
|
|
orbit(viewer, Cesium.Cartesian3.fromDegrees(0, 0), 90, OBLIQUE_PITCH, 1000);
|
|
const animator = createCameraOrientationAnimator(viewer);
|
|
const frame = readCameraTargetFrame(viewer);
|
|
animator.animate(frame, { heading: 0, pitch: STRAIGHT_DOWN_PITCH });
|
|
animator.animate(frame, { heading: 0, pitch: OBLIQUE_PITCH });
|
|
assert.equal(viewer.scene.preUpdate.numberOfListeners, 1);
|
|
viewer.trackedEntity = {};
|
|
viewer.scene.preUpdate.raiseEvent();
|
|
assert.equal(viewer.scene.preUpdate.numberOfListeners, 0);
|
|
viewer.trackedEntity = undefined;
|
|
animator.animate(frame, { heading: 0, pitch: STRAIGHT_DOWN_PITCH });
|
|
animator.cancel();
|
|
assert.equal(viewer.scene.preUpdate.numberOfListeners, 0);
|
|
});
|
|
|
|
test('orientation navigation preserves follow and selection; new navigation cancels animation', () => {
|
|
const calls = [];
|
|
const entity = {};
|
|
const viewer = { trackedEntity: entity };
|
|
const engine = createFakeEngine();
|
|
const cancelFlight = engine.camera.cancelFlight;
|
|
engine.camera.cancelFlight = () => {
|
|
calls.push('cancel-flight');
|
|
cancelFlight();
|
|
};
|
|
let cockpit = false;
|
|
const navigation = new NavigationController({
|
|
viewer,
|
|
engine,
|
|
tracking: {},
|
|
isCockpitActive: () => cockpit,
|
|
cancelOrientation: () => calls.push('cancel-orientation'),
|
|
clearLocation: () => calls.push('clear-location'),
|
|
cancelShareSelection: () => calls.push('clear-selection'),
|
|
interruptCameraMotion: () => calls.push('interrupt-motion'),
|
|
stopOrbit: () => calls.push('stop-orbit'),
|
|
showToast: () => calls.push('toast'),
|
|
});
|
|
assert.equal(
|
|
navigation.runOrientation('camera', () => 'animated'),
|
|
'animated',
|
|
);
|
|
assert.equal(viewer.trackedEntity, entity);
|
|
assert.deepEqual(calls, [
|
|
'cancel-orientation',
|
|
'interrupt-motion',
|
|
'stop-orbit',
|
|
'cancel-flight',
|
|
]);
|
|
calls.length = 0;
|
|
navigation._stampNavigation({ cancelPendingSelection: false });
|
|
assert.deepEqual(calls, ['cancel-orientation', 'clear-location']);
|
|
calls.length = 0;
|
|
cockpit = true;
|
|
assert.equal(
|
|
navigation.runOrientation('camera', () =>
|
|
assert.fail('cockpit should refuse'),
|
|
),
|
|
false,
|
|
);
|
|
assert.deepEqual(calls, ['toast']);
|
|
});
|
|
|
|
test('rapid tilt presses reverse direction and north-up keeps the requested tilt', (t) => {
|
|
let time = 0;
|
|
t.mock.method(performance, 'now', () => time);
|
|
const target = Cesium.Cartesian3.fromDegrees(0, 0);
|
|
const { viewer } = createRealViewer(target);
|
|
orbit(viewer, target, 90, OBLIQUE_PITCH, 1000);
|
|
const tiltButton = new FakeButton();
|
|
const northButton = new FakeButton();
|
|
let controls;
|
|
controls = bindCameraOrientationControls({
|
|
viewer,
|
|
elements: { tiltButton, northButton },
|
|
runNavigation: (_noun, navigate) => {
|
|
controls.cancel();
|
|
return navigate();
|
|
},
|
|
});
|
|
tiltButton.click();
|
|
tiltButton.click();
|
|
assert.equal(tiltButton.getAttribute('aria-pressed'), 'true');
|
|
tiltButton.click();
|
|
northButton.click();
|
|
assert.equal(viewer.scene.preUpdate.numberOfListeners, 1);
|
|
time = 650;
|
|
viewer.scene.preUpdate.raiseEvent();
|
|
const frame = readCameraTargetFrame(viewer);
|
|
assert.ok(Math.abs(frame.pitch - STRAIGHT_DOWN_PITCH) < 1e-6);
|
|
assert.ok(Math.abs(frame.heading) < 1e-6);
|
|
controls.destroy();
|
|
assert.equal(viewer.scene.preUpdate.numberOfListeners, 0);
|
|
});
|
|
|
|
test('the controls run on a globe engine alone', (t) => {
|
|
let time = 0;
|
|
t.mock.method(performance, 'now', () => time);
|
|
const engine = createFakeEngine();
|
|
engine.fake.setPose({
|
|
position: Cesium.Cartesian3.fromDegrees(-97.7431, 30.2672, 3000),
|
|
heading: Cesium.Math.toRadians(70),
|
|
pitch: STRAIGHT_DOWN_PITCH,
|
|
roll: 0,
|
|
});
|
|
const tiltButton = new FakeButton();
|
|
const northButton = new FakeButton();
|
|
const controls = bindCameraOrientationControls({
|
|
engine,
|
|
elements: { tiltButton, northButton },
|
|
runNavigation: (_noun, navigate) => navigate(),
|
|
});
|
|
assert.equal(tiltButton.getAttribute('aria-pressed'), 'false');
|
|
assert.equal(northButton.getAttribute('--camera-heading'), '70deg');
|
|
tiltButton.click();
|
|
assert.equal(tiltButton.getAttribute('aria-pressed'), 'true');
|
|
// The animation runs on the engine's preUpdate frames.
|
|
time = 700;
|
|
engine.fake.frame(16);
|
|
const tilted = readCameraTargetFrame(engine);
|
|
assert.ok(Math.abs(tilted.pitch - OBLIQUE_PITCH) < 1e-6);
|
|
northButton.click();
|
|
time = 1400;
|
|
engine.fake.frame(16);
|
|
const north = readCameraTargetFrame(engine);
|
|
assert.ok(
|
|
Math.abs(north.heading) < 1e-6 ||
|
|
Math.abs(north.heading - 2 * Math.PI) < 1e-6,
|
|
);
|
|
assert.equal(northButton.getAttribute('--camera-heading'), '0deg');
|
|
assert.ok(engine.fake.renderRequests > 0);
|
|
controls.destroy();
|
|
assert.equal(engine.frames.preRender.numberOfListeners, 0);
|
|
assert.equal(engine.frames.preUpdate.numberOfListeners, 0);
|
|
assert.equal(engine.camera.moveEnd.numberOfListeners, 0);
|
|
});
|