Files
gods-eye-view/src/data/followed.test.mjs
T
Sameh Khamis ae4fbb5053 Load the default renderer as the page starts, and follow through the camera port in tests
- The standalone page starts loading the default renderer as it starts
  (loadDefaultRenderer), so Cesium arrives beside the page's own setup,
  not after it; the scene takes a plugin or a promise of one.
- Where a follow target's layer has no display position yet, the followed
  position is the target's own position at the frame port's scene time.
- The globe engine's photoreal base that fails to come back is off again
  and the globe shown; a later switch tries again. The draped-imagery host
  asks the map engine whether the globe is shown where the renderer cannot
  say. The scene resizes the renderer with its container.
- Cockpit and voice tests follow through the camera port (followEntity),
  not by setting the viewer's tracked entity; the fake frame port has a
  scene time.
2026-11-10 17:44:29 -08:00

130 lines
4.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';
import { createStubRenderer } from '../render/stub/index.js';
/** 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('what the camera port follows is the target itself', (t) => {
const viewer = {};
assert.equal(followedOf(viewer), null, 'nothing without a renderer');
const camera = followingPort();
t.after(bindRenderer(viewer, { camera }));
assert.equal(followedOf(viewer), null);
assert.equal(isFollowing(viewer), false);
const target = { key: 'flights:abc', position: () => null };
camera.follow(target);
assert.equal(followedOf(viewer), target);
assert.equal(isFollowing(viewer), true);
});
test('onFollowChanged fires once per change', (t) => {
const viewer = {};
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' };
camera.follow(target);
camera.follow(target);
camera.follow(null);
off();
camera.follow({ key: 'after' });
assert.deepEqual(seen, ['flights:abc', null]);
});
test('stopFollowing ends a port follow', (t) => {
const viewer = {};
stopFollowing(viewer);
const camera = followingPort();
t.after(bindRenderer(viewer, { camera }));
camera.follow({ key: 'k' });
stopFollowing(viewer);
assert.equal(camera.followed, null);
stopFollowing(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', (t) => {
const viewer = {};
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 reads the display cache', () => {
const entity = new Cesium.Entity({ id: 'e' });
const view = entityFollowTarget(entity, {});
assert.equal(followedPosition({}, view), null, 'none without a cache');
entityRecord(entity).displayPosition = () => ({ x: 7, y: 8, z: 9 });
assert.deepEqual(followedPosition({}, view), { x: 7, y: 8, z: 9 });
assert.equal(followedPosition({}, null), null);
});
test('followedPosition falls back to the target position at scene time', () => {
const renderer = createStubRenderer();
const viewer = {};
bindRenderer(viewer, renderer);
renderer.frame.setTime(1234);
const seen = [];
const target = {
key: 't',
frame: 'enu',
viewFrom: { x: 0, y: 0, z: 1 },
position: (time) => (seen.push(time), { x: 1, y: 2, z: 3 }),
};
assert.deepEqual(followedPosition(viewer, target), { x: 1, y: 2, z: 3 });
assert.deepEqual(seen, [1234]);
target.displayPosition = () => ({ x: 4, y: 5, z: 6 });
assert.deepEqual(followedPosition(viewer, target), { x: 4, y: 5, z: 6 });
});