Files
gods-eye-view/src/data/followed.test.mjs
T
Sameh Khamis 99f9a701d9 Read the followed target, not trackedEntity, in the follow readers
The tracked card, screen annotations, north-up, share links and Cockpit
ask data/followed.js what the camera follows, so they work the same when
a layer follows through the camera port. followed.js gains
entityFollowTarget (a FollowTarget whose presentation reads the drawn
entity's record), resumeFollowing and followedPosition.
2026-11-06 15:31:36 -08:00

176 lines
6.4 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 {
entityFollowTarget,
followedOf,
followedPosition,
isFollowing,
onFollowChanged,
resumeFollowing,
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]);
});
test('an entity follow target reads its entity record live', () => {
const entity = new Cesium.Entity({ id: 'drawn', name: 'N2' });
const position = () => ({ x: 1, y: 2, z: 3 });
const target = entityFollowTarget(entity, { position, minRange: 150 });
assert.equal(target.key, 'entity:drawn');
entityRecord(entity).trackedId = 'flights:abc';
entityRecord(entity).labelModel = { title: 'N2' };
assert.equal(target.key, 'flights:abc');
assert.equal(target.labelModel.title, 'N2');
assert.equal(target.entity, entity);
assert.equal(target.position, position);
assert.equal(target.minRange, 150);
const keyed = entityFollowTarget(entity, { key: 'flights:given' });
assert.equal(keyed.key, 'flights:given', 'a camera field takes the place');
assert.equal(keyed.labelModel.title, 'N2');
});
test('resumeFollowing follows a port target again, or re-tracks an entity', (t) => {
const viewer = trackingViewer();
const entity = new Cesium.Entity({ id: 'legacy' });
viewer.trackedEntity = entity;
const legacy = followedOf(viewer);
stopFollowing(viewer);
resumeFollowing(viewer, legacy);
assert.equal(viewer.trackedEntity, entity);
assert.equal(followedOf(viewer), legacy);
viewer.trackedEntity = undefined;
const camera = followingPort();
t.after(bindRenderer(viewer, { camera }));
const target = entityFollowTarget(new Cesium.Entity({ id: 'p' }), {});
camera.follow(target);
stopFollowing(viewer);
resumeFollowing(viewer, target);
assert.equal(camera.followed, target);
resumeFollowing(viewer, null);
assert.equal(camera.followed, target);
});
test('followedPosition prefers the display cache over the entity position', () => {
const at = new Cesium.Cartesian3(4, 5, 6);
const viewer = { clock: { currentTime: Cesium.JulianDate.now() } };
const entity = new Cesium.Entity({ id: 'e', position: at });
const view = entityFollowTarget(entity, {});
assert.deepEqual(followedPosition(viewer, view), at);
entityRecord(entity).displayPosition = () => ({ x: 7, y: 8, z: 9 });
assert.deepEqual(followedPosition(viewer, view), { x: 7, y: 8, z: 9 });
assert.equal(followedPosition(viewer, null), null);
});