Files
gods-eye-view/src/data/followed.test.mjs
T
Sameh Khamis 2adec097de Read what the camera follows through one Core module
src/data/followed.js answers what the camera follows: the camera port's
target, or the entity a layer still tracks itself, seen through the same
fields. Ownership checks, render holds, guards, voice actions, the CCTV
pacing and the navigation release paths read it instead of Cesium's
trackedEntity, so they keep working when layers follow through the port.
The release paths stop following, cancel the flight and release the
camera through the port. The rotate refusal names the followed target by
its name or label title.
2026-11-06 12:27:23 -08:00

124 lines
4.2 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import assert from 'node:assert/strict';
import test from 'node:test';
import * as Cesium from 'cesium';
import { entityRecord } from './entityRecords.js';
import {
followedOf,
isFollowing,
onFollowChanged,
stopFollowing,
} from './followed.js';
import { bindRenderer } from '../render/rendererOf.js';
import { createCameraEvents } from '../render/camera/events.js';
/** A viewer whose `trackedEntity` behaves as Cesium's setter does. */
function trackingViewer() {
const trackedEntityChanged = new Cesium.Event();
let tracked;
return {
trackedEntityChanged,
get trackedEntity() {
return tracked;
},
set trackedEntity(value) {
if (tracked === value) return;
tracked = value;
trackedEntityChanged.raiseEvent(value);
},
};
}
/** A camera port that follows, for a viewer bound to a renderer. */
function followingPort() {
const events = createCameraEvents({ pose: () => ({}), report: () => {} });
let followed = null;
return {
on: (event, cb) => events.on(event, cb),
get followed() {
return followed;
},
follow(target) {
if (followed === target) return;
followed = target;
events.emit('followChanged');
},
};
}
test('a layer’s own tracked entity is seen through its entity record', () => {
const viewer = trackingViewer();
assert.equal(followedOf(viewer), null);
assert.equal(isFollowing(viewer), false);
const entity = new Cesium.Entity({ id: 'e1', name: 'N1' });
const record = entityRecord(entity);
record.trackedId = 'flights:abc';
record.displayPosition = () => ({ x: 1, y: 2, z: 3 });
record.sprite = { width: 28 };
viewer.trackedEntity = entity;
const followed = followedOf(viewer);
assert.equal(followed, followedOf(viewer), 'the same view each time');
assert.equal(followed.key, 'flights:abc');
assert.equal(followed.name, 'N1');
assert.deepEqual(followed.displayPosition(), { x: 1, y: 2, z: 3 });
assert.equal(followed.sprite.width, 28);
assert.equal(followed.entity, entity);
viewer.trackedEntity = new Cesium.Entity({ id: 'plain' });
assert.equal(followedOf(viewer).key, 'entity:plain', 'no tracked id');
});
test('a port follow comes before any tracked entity, and is the target itself', (t) => {
const viewer = trackingViewer();
const camera = followingPort();
t.after(bindRenderer(viewer, { camera }));
viewer.trackedEntity = new Cesium.Entity({ id: 'helper' });
const target = { key: 'flights:abc', position: () => null };
camera.follow(target);
assert.equal(followedOf(viewer), target);
});
test('onFollowChanged fires once per change, from either source', (t) => {
const viewer = trackingViewer();
const camera = followingPort();
t.after(bindRenderer(viewer, { camera }));
const seen = [];
const off = onFollowChanged(viewer, (f) => seen.push(f?.key ?? null));
const target = { key: 'flights:abc' };
// A port follow on Cesium sets trackedEntity too: still one change.
camera.follow(target);
// Ending it, Cesium clears its tracking before the port announces.
viewer.trackedEntity = undefined;
camera.follow(null);
const entity = new Cesium.Entity({ id: 'legacy' });
viewer.trackedEntity = entity;
viewer.trackedEntity = entity;
off();
viewer.trackedEntity = undefined;
assert.deepEqual(seen, ['flights:abc', null, 'entity:legacy']);
});
test('stopFollowing ends a port follow, or a layer’s own tracking', (t) => {
const viewer = trackingViewer();
viewer.trackedEntity = new Cesium.Entity({ id: 'legacy' });
stopFollowing(viewer);
assert.equal(viewer.trackedEntity, undefined);
const camera = followingPort();
t.after(bindRenderer(viewer, { camera }));
camera.follow({ key: 'k' });
stopFollowing(viewer);
assert.equal(camera.followed, null);
stopFollowing(null);
});
test('a renderer bound after subscribing is still heard', (t) => {
const viewer = { trackedEntityChanged: new Cesium.Event() };
const seen = [];
onFollowChanged(viewer, (f) => seen.push(f?.key ?? null));
const camera = followingPort();
t.after(bindRenderer(viewer, { camera }));
// Any change re-resolves the port; a Cesium follow raises one.
viewer.trackedEntityChanged.raiseEvent();
camera.follow({ key: 'k' });
camera.follow(null);
assert.deepEqual(seen, ['k', null]);
});