Fly layer focus flights through the camera port

flyToBounds takes an easing, as flyTo does: in the contract, the Cesium
port and the reference recorder, pinned by a new conformance trace.

The flights of radio, awareness, CCTV, submarine cables, cyclones, the
launch preview, installations, ALPR, street-level framing, recent
imagery, weather and world focus now go through the renderer's camera
port. Street-level framing cancels its own flight handle rather than
whatever flight is current. worldFocus.js no longer reaches Cesium and
leaves the allow-list.

Layer pose reads stay for each layer's own slice. The local GeoJSON
flight stays on Cesium: gods-eye-view/infrastructure is used with plain
Cesium viewers that have no renderer bound.
This commit is contained in:
Sameh Khamis committed 2026-11-05 20:46:58 -08:00
1 parent 46a53bb49c
commit c5b716b107
31 files changed
+2349 -871

No files matched your search

+124 -30
View File
@@ -3,6 +3,7 @@
import { test } from 'node:test';
import assert from 'node:assert/strict';
import * as Cesium from 'cesium';
import { bindFakeCesiumCamera } from './testSupport/fakeCameraPort.mjs';
import {
WORLD_CLICK_FOCUS_DURATION_SEC,
WORLD_FOCUS_FRAMING,
@@ -21,16 +22,28 @@ function stubCamera() {
return {
calls,
heading: Cesium.Math.toRadians(45),
cancelFlight() { calls.cancelFlight += 1; },
flyToBoundingSphere(sphere, options) { calls.flights.push({ sphere, options }); },
cancelFlight() {
calls.cancelFlight += 1;
},
flyToBoundingSphere(sphere, options) {
calls.flights.push({ sphere, options });
},
};
}
test('a focus request carries the clicked target to any registered listener', () => {
const target = new EventTarget();
const seen = [];
const dispose = registerWorldFocusRequestListener(target, (event) => seen.push(event.detail));
assert.equal(requestWorldFocus({ kind: 'vessel', position: POSITION, id: '123' }, target), true);
const dispose = registerWorldFocusRequestListener(target, (event) =>
seen.push(event.detail),
);
assert.equal(
requestWorldFocus(
{ kind: 'vessel', position: POSITION, id: '123' },
target,
),
true,
);
assert.equal(seen.length, 1);
assert.equal(seen[0].kind, 'vessel');
assert.equal(seen[0].id, '123');
@@ -44,7 +57,9 @@ test('a focus request carries the clicked target to any registered listener', ()
test('requests without a kind or a position are dropped, never dispatched', () => {
const target = new EventTarget();
let count = 0;
target.addEventListener(WORLD_FOCUS_REQUEST_EVENT, () => { count += 1; });
target.addEventListener(WORLD_FOCUS_REQUEST_EVENT, () => {
count += 1;
});
assert.equal(requestWorldFocus({ position: POSITION }, target), false);
assert.equal(requestWorldFocus({ kind: 'vessel' }, target), false);
assert.equal(requestWorldFocus(null, target), false);
@@ -74,51 +89,95 @@ test('a refusing policy (cockpit owns the camera) never reaches the flight', ()
const result = routeWorldFocusRequest(
{ detail: { kind: 'vessel', id: '123', position: POSITION } },
() => false,
() => { flights += 1; },
() => {
flights += 1;
},
);
assert.equal(result, false);
assert.equal(flights, 0);
});
test('malformed requests are inert', () => {
assert.equal(routeWorldFocusRequest(null, () => 'x', () => 'y'), false);
assert.equal(routeWorldFocusRequest({ detail: { kind: 'vessel' } }, () => 'x', () => 'y'), false);
assert.equal(
routeWorldFocusRequest(
null,
() => 'x',
() => 'y',
),
false,
);
assert.equal(
routeWorldFocusRequest(
{ detail: { kind: 'vessel' } },
() => 'x',
() => 'y',
),
false,
);
});
// A request that cannot fly must never cost the user their tracking: the UI
// policy releases the follow camera, so validation happens BEFORE it runs.
test('an unflyable request never reaches the release policy', () => {
const unflyable = [
{ kind: 'plane', position: POSITION }, // no framing for this kind
{ kind: 'vessel', position: { x: NaN, y: 0, z: 0 } }, // malformed position
{ kind: 'vessel', position: { x: 0, y: 0 } }, // truthy but incomplete
{ kind: 'plane', position: POSITION }, // no framing for this kind
{ kind: 'vessel', position: { x: NaN, y: 0, z: 0 } }, // malformed position
{ kind: 'vessel', position: { x: 0, y: 0 } }, // truthy but incomplete
{ kind: 'vessel', id: '123', position: { x: 0, y: 0, z: 0 } }, // ECEF origin
{ kind: 'fire', id: 'fire-1', position: { x: 1, y: 1, z: 1 } }, // finite but inside Earth
{ kind: 'vessel', position: 'somewhere' },
{ kind: 'vessel', position: POSITION }, // missing owner id
{ kind: 'vessel', position: POSITION }, // missing owner id
{ position: POSITION },
];
for (const detail of unflyable) {
assert.equal(isValidWorldFocusTarget(detail), false, JSON.stringify(detail));
assert.equal(
isValidWorldFocusTarget(detail),
false,
JSON.stringify(detail),
);
let policyRuns = 0;
const result = routeWorldFocusRequest(
{ detail },
() => { policyRuns += 1; return 'released'; },
() => {
policyRuns += 1;
return 'released';
},
() => 'flew',
);
assert.equal(result, false, JSON.stringify(detail));
assert.equal(policyRuns, 0, `the policy must not run for ${JSON.stringify(detail)}`);
assert.equal(
policyRuns,
0,
`the policy must not run for ${JSON.stringify(detail)}`,
);
// Nor may such a request be dispatched in the first place.
assert.equal(requestWorldFocus(detail, new EventTarget()), false);
}
assert.equal(isValidWorldFocusTarget({ kind: 'vessel', id: '123', position: POSITION }), true);
assert.equal(isValidWorldFocusTarget({ kind: 'fire', id: 'fire-1', position: POSITION }), true);
assert.equal(
isValidWorldFocusTarget({ kind: 'vessel', id: '123', position: POSITION }),
true,
);
assert.equal(
isValidWorldFocusTarget({ kind: 'fire', id: 'fire-1', position: POSITION }),
true,
);
});
test('the transfer flight supersedes any flight in progress and keeps the operator heading', () => {
const camera = stubCamera();
assert.equal(flyToWorldTarget({ camera }, { kind: 'vessel', id: '123', position: POSITION }), true);
assert.equal(camera.calls.cancelFlight, 1, 'a prior flight must be cancelled, not queued');
assert.equal(
flyToWorldTarget(bindFakeCesiumCamera({ camera }), {
kind: 'vessel',
id: '123',
position: POSITION,
}),
true,
);
assert.equal(
camera.calls.cancelFlight,
1,
'a prior flight must be cancelled, not queued',
);
assert.equal(camera.calls.flights.length, 1);
const { sphere, options } = camera.calls.flights[0];
assert.equal(sphere.radius, WORLD_FOCUS_FRAMING.vessel.radiusM);
@@ -131,12 +190,20 @@ test('the transfer flight supersedes any flight in progress and keeps the operat
test('fires frame wider than vessels — a fire is read by its surroundings', () => {
const camera = stubCamera();
flyToWorldTarget({ camera }, { kind: 'fire', id: 'fire-1', position: POSITION });
flyToWorldTarget(bindFakeCesiumCamera({ camera }), {
kind: 'fire',
id: 'fire-1',
position: POSITION,
});
const { sphere, options } = camera.calls.flights[0];
assert.equal(sphere.radius, WORLD_FOCUS_FRAMING.fire.radiusM);
assert.equal(options.offset.range, WORLD_FOCUS_FRAMING.fire.rangeM);
assert.ok(WORLD_FOCUS_FRAMING.fire.rangeM > WORLD_FOCUS_FRAMING.vessel.rangeM);
assert.ok(WORLD_FOCUS_FRAMING.fire.radiusM > WORLD_FOCUS_FRAMING.vessel.radiusM);
assert.ok(
WORLD_FOCUS_FRAMING.fire.rangeM > WORLD_FOCUS_FRAMING.vessel.rangeM,
);
assert.ok(
WORLD_FOCUS_FRAMING.fire.radiusM > WORLD_FOCUS_FRAMING.vessel.radiusM,
);
});
test('every framing is a real oblique standoff, not a nadir or an inside-out sphere', () => {
@@ -145,25 +212,52 @@ test('every framing is a real oblique standoff, not a nadir or an inside-out sph
for (const kind of kinds) {
const framing = WORLD_FOCUS_FRAMING[kind];
// Looking DOWN at the target, but obliquely — a nadir drop reads as a map.
assert.ok(framing.pitchDeg < 0, `${kind}: pitch must look down, got ${framing.pitchDeg}`);
assert.ok(framing.pitchDeg > -80, `${kind}: pitch must stay oblique, got ${framing.pitchDeg}`);
assert.ok(
framing.pitchDeg < 0,
`${kind}: pitch must look down, got ${framing.pitchDeg}`,
);
assert.ok(
framing.pitchDeg > -80,
`${kind}: pitch must stay oblique, got ${framing.pitchDeg}`,
);
// Standing off outside the framed sphere, at a human-readable distance.
assert.ok(framing.radiusM > 0, `${kind}: radius must be positive`);
assert.ok(
framing.rangeM > framing.radiusM,
`${kind}: range ${framing.rangeM} must stand off outside radius ${framing.radiusM}`,
);
assert.ok(framing.rangeM <= 10000, `${kind}: range must stay close-in, got ${framing.rangeM}`);
assert.ok(
framing.rangeM <= 10000,
`${kind}: range must stay close-in, got ${framing.rangeM}`,
);
}
// Exact shipped values — a silent retune must show up as a failing test.
assert.deepEqual({ ...WORLD_FOCUS_FRAMING.vessel }, { radiusM: 150, rangeM: 1200, pitchDeg: -30 });
assert.deepEqual({ ...WORLD_FOCUS_FRAMING.fire }, { radiusM: 400, rangeM: 3000, pitchDeg: -35 });
assert.deepEqual(
{ ...WORLD_FOCUS_FRAMING.vessel },
{ radiusM: 150, rangeM: 1200, pitchDeg: -30 },
);
assert.deepEqual(
{ ...WORLD_FOCUS_FRAMING.fire },
{ radiusM: 400, rangeM: 3000, pitchDeg: -35 },
);
});
test('unknown kinds and missing viewers issue no flight', () => {
const camera = stubCamera();
assert.equal(flyToWorldTarget({ camera }, { kind: 'plane', position: POSITION }), false);
assert.equal(flyToWorldTarget({ camera }, { kind: 'vessel' }), false);
assert.equal(flyToWorldTarget(null, { kind: 'vessel', position: POSITION }), false);
assert.equal(
flyToWorldTarget(bindFakeCesiumCamera({ camera }), {
kind: 'plane',
position: POSITION,
}),
false,
);
assert.equal(
flyToWorldTarget(bindFakeCesiumCamera({ camera }), { kind: 'vessel' }),
false,
);
assert.equal(
flyToWorldTarget(null, { kind: 'vessel', position: POSITION }),
false,
);
assert.equal(camera.calls.flights.length, 0);
});