mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 08:12:24 +00:00
Read what the camera follows through one 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.
This commit is contained in:
1 parent
6c215f93a9
commit
7eec2f828c
29 files changed
+404
-97
No files matched your search
@@ -378,7 +378,7 @@ test('camera icons are violet for video feeds, cyan for stills, amber when activ
|
||||
test('geometry drain pacing yields to tracked and cockpit camera ownership', () => {
|
||||
assert.deepEqual(cctvGeometryDrainPacing(), { batchSize: 4, delayMs: 120 });
|
||||
assert.deepEqual(
|
||||
cctvGeometryDrainPacing({ trackedEntity: { id: 'flight-1' } }),
|
||||
cctvGeometryDrainPacing({ followed: { key: 'flights:1' } }),
|
||||
{ batchSize: 2, delayMs: 250 },
|
||||
);
|
||||
assert.deepEqual(cctvGeometryDrainPacing({ cockpitActive: true }), {
|
||||
@@ -393,13 +393,13 @@ test('geometry drain pacing yields to tracked and cockpit camera ownership', ()
|
||||
});
|
||||
|
||||
test('geometry drain rechecks pacing when tracking releases between batches', () => {
|
||||
let trackedEntity = { id: 'flight-1' };
|
||||
let followed = { key: 'flights:1' };
|
||||
const queue = Array.from({ length: 10 }, (_, index) => index + 1);
|
||||
const visited = [];
|
||||
const runBatch = () =>
|
||||
processCctvGeometryDrainBatch({
|
||||
queue,
|
||||
readOwnership: () => ({ trackedEntity, cockpitActive: false }),
|
||||
readOwnership: () => ({ followed, cockpitActive: false }),
|
||||
visit: (record) => visited.push(record),
|
||||
progress: () => {},
|
||||
complete: () => {},
|
||||
@@ -409,7 +409,7 @@ test('geometry drain rechecks pacing when tracking releases between batches', ()
|
||||
assert.deepEqual(trackedBatch, { hasMore: true, batchSize: 2, delayMs: 250 });
|
||||
assert.deepEqual(visited, [1, 2]);
|
||||
|
||||
trackedEntity = null;
|
||||
followed = null;
|
||||
const untrackedBatch = runBatch();
|
||||
assert.deepEqual(untrackedBatch, {
|
||||
hasMore: true,
|
||||
|
||||
@@ -0,0 +1,127 @@
|
||||
/**
|
||||
* @module data/followed
|
||||
* @description What the camera follows, for the code that reads it.
|
||||
*
|
||||
* A layer follows through the camera port with a FollowTarget that also
|
||||
* carries what the app shows about it (key, display position, sprite, label).
|
||||
* Until every layer does, a layer may still track an entity of its own
|
||||
* through Cesium's `trackedEntity`; that entity is seen here through the
|
||||
* same fields, read from its entity record. Readers ask this module, never
|
||||
* `trackedEntity`, so they work either way.
|
||||
*/
|
||||
import { findCamera } from '../render/rendererOf.js';
|
||||
import { readEntityRecord } from './entityRecords.js';
|
||||
|
||||
/**
|
||||
* @typedef {object} Followed
|
||||
* @property {string|null} key Stable id, e.g. `'flights:a1b2c3'`.
|
||||
* @property {string} [name] Display name, when the target has one.
|
||||
* @property {() => object|null} [displayPosition] Where the follow camera
|
||||
* frames the target this frame (the layer's display cache).
|
||||
* @property {() => object|null} [visualPosition] Where the target is drawn.
|
||||
* @property {object} [sprite] Size of the drawn billboard.
|
||||
* @property {object} [labelModel]
|
||||
* @property {string} [selectionOrigin]
|
||||
* @property {object} [entity] The tracked entity, for a layer that still
|
||||
* tracks one itself.
|
||||
*/
|
||||
|
||||
/** @type {WeakMap<object, Followed>} */
|
||||
const entityViews = new WeakMap();
|
||||
|
||||
function entityView(entity) {
|
||||
let view = entityViews.get(entity);
|
||||
if (!view) {
|
||||
const id = String(entity.id ?? '').trim();
|
||||
view = {
|
||||
entity,
|
||||
get key() {
|
||||
const explicit = String(readEntityRecord(entity)?.trackedId ?? '');
|
||||
return explicit.trim() || (id ? `entity:${id}` : null);
|
||||
},
|
||||
get name() {
|
||||
return entity.name;
|
||||
},
|
||||
get displayPosition() {
|
||||
return readEntityRecord(entity)?.displayPosition;
|
||||
},
|
||||
get visualPosition() {
|
||||
return readEntityRecord(entity)?.visualPosition;
|
||||
},
|
||||
get sprite() {
|
||||
return readEntityRecord(entity)?.sprite;
|
||||
},
|
||||
get labelModel() {
|
||||
return readEntityRecord(entity)?.labelModel;
|
||||
},
|
||||
get selectionOrigin() {
|
||||
return readEntityRecord(entity)?.selectionOrigin;
|
||||
},
|
||||
};
|
||||
entityViews.set(entity, view);
|
||||
}
|
||||
return view;
|
||||
}
|
||||
|
||||
/**
|
||||
* What `viewer`'s camera follows, or null. The same object comes back for
|
||||
* as long as the same thing is followed.
|
||||
* @param {object|null|undefined} viewer
|
||||
* @returns {Followed|null}
|
||||
*/
|
||||
export function followedOf(viewer) {
|
||||
if (!viewer) return null;
|
||||
const target = findCamera(viewer)?.followed;
|
||||
if (target) return target;
|
||||
const entity = viewer.trackedEntity;
|
||||
return entity ? entityView(entity) : null;
|
||||
}
|
||||
|
||||
/** Whether `viewer`'s camera follows anything. */
|
||||
export function isFollowing(viewer) {
|
||||
return followedOf(viewer) !== null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Run `cb` whenever what `viewer`'s camera follows changes.
|
||||
* @param {object} viewer
|
||||
* @param {(followed: Followed|null) => void} cb
|
||||
* @returns {() => void} Off.
|
||||
*/
|
||||
export function onFollowChanged(viewer, cb) {
|
||||
let last = followedOf(viewer);
|
||||
let port = null;
|
||||
let offPort = null;
|
||||
// The port is looked up again on every change: a renderer bound after
|
||||
// this subscribed replaces the one it listened to. A Cesium port's follow
|
||||
// also sets `trackedEntity`, so the change still arrives through it.
|
||||
const listenToPort = () => {
|
||||
const current = findCamera(viewer);
|
||||
if (current === port) return;
|
||||
offPort?.();
|
||||
port = current;
|
||||
offPort = port?.on('followChanged', check) ?? null;
|
||||
};
|
||||
function check() {
|
||||
listenToPort();
|
||||
const now = followedOf(viewer);
|
||||
if (now === last) return;
|
||||
last = now;
|
||||
cb(now);
|
||||
}
|
||||
listenToPort();
|
||||
const offTracking = viewer.trackedEntityChanged?.addEventListener(check);
|
||||
return () => {
|
||||
offPort?.();
|
||||
offPort = null;
|
||||
offTracking?.();
|
||||
};
|
||||
}
|
||||
|
||||
/** Stop the camera following anything, a layer's own tracking included. */
|
||||
export function stopFollowing(viewer) {
|
||||
if (!viewer) return;
|
||||
const camera = findCamera(viewer);
|
||||
if (camera?.followed) camera.follow(null);
|
||||
else if (viewer.trackedEntity) viewer.trackedEntity = undefined;
|
||||
}
|
||||
@@ -0,0 +1,123 @@
|
||||
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]);
|
||||
});
|
||||
@@ -1,3 +1,4 @@
|
||||
import { followedOf, stopFollowing } from './followed.js';
|
||||
import * as Cesium from 'cesium';
|
||||
|
||||
const STYLE = [
|
||||
@@ -113,8 +114,9 @@ export function createImportedPins(dataSource, viewer) {
|
||||
destroy() {
|
||||
if (destroyed) return;
|
||||
destroyed = true;
|
||||
if (viewer.trackedEntity && pins.includes(viewer.trackedEntity))
|
||||
viewer.trackedEntity = undefined;
|
||||
const followedEntity = followedOf(viewer)?.entity;
|
||||
if (followedEntity && pins.includes(followedEntity))
|
||||
stopFollowing(viewer);
|
||||
if (viewer.selectedEntity && pins.includes(viewer.selectedEntity))
|
||||
viewer.selectedEntity = undefined;
|
||||
if (mounted && !viewer.scene.primitives?.isDestroyed?.())
|
||||
|
||||
Reference in new issue
Block a user