mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 08:12:24 +00:00
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.
176 lines
6.4 KiB
JavaScript
176 lines
6.4 KiB
JavaScript
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);
|
||
});
|