mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 08:12:24 +00:00
Follow through the camera port in the remaining tests
- The tests that faked a follow by setting the viewer's tracked entity, or by raising its change event, follow through the camera port (followEntity, or a port with follow and followChanged), and check followedOf: camera handoffs, globe rotation, tilt, ground guard, vessels, ALPR, CCTV, Contacts, radio, orientation, share links and follow offsets, the tracked readout and the shell's camera listeners. - The fake Cesium camera port delivers followChanged from the port itself. - A ride handed to another aircraft is adopted by the follow's change, as the application does, not by the test calling the adoption. - The unbound-factory record lists the scene, the map defaults, share restoration and the World Packet as entries whose caller loads the factories; the map startup test stubs the default renderer load.
This commit is contained in:
1 parent
9a13aeab48
commit
1fbe546531
21 files changed
+476
-148
No files matched your search
@@ -11,6 +11,7 @@ import { FREE_LOOK_MAX_HEIGHT_METERS } from '../globeInView.js';
|
||||
import * as globeInView from '../globeInView.js';
|
||||
import { createCesiumCamera } from '../render/cesium/camera.js';
|
||||
import { bindRenderer } from '../render/rendererOf.js';
|
||||
import { entityFollowTarget } from '../data/followed.js';
|
||||
|
||||
/** The camera port bound over each real Cesium camera a test makes. */
|
||||
const cameraPorts = new WeakMap();
|
||||
@@ -697,9 +698,15 @@ test('globe recovery leaves partial, low, locked and following views alone', ()
|
||||
assert.equal(globeOutOfFrame(locked.camera), true);
|
||||
assert.ok(moveEndKeepsView(locked.camera), 'locked camera');
|
||||
|
||||
// Tracking an entity that has no position yet keeps an identity transform.
|
||||
// Following an entity that has no position yet keeps an identity transform.
|
||||
const tracked = realCamera();
|
||||
tracked.viewer.trackedEntity = { id: 'pending-fix' };
|
||||
const pending = entityFollowTarget(
|
||||
{ id: 'pending-fix' },
|
||||
{ position: () => null },
|
||||
);
|
||||
Object.defineProperty(cameraPorts.get(tracked.camera), 'followed', {
|
||||
get: () => pending,
|
||||
});
|
||||
installGlobeInViewRecovery(tracked.viewer);
|
||||
aim(tracked.camera, reportedStuckView);
|
||||
assert.ok(moveEndKeepsView(tracked.camera), 'tracked camera');
|
||||
|
||||
@@ -1,4 +1,10 @@
|
||||
import { bindFakeCesiumCamera } from './testSupport/fakeCameraPort.mjs';
|
||||
import {
|
||||
bindFakeCesiumCamera,
|
||||
followEntity,
|
||||
followedEntity,
|
||||
} from './testSupport/fakeCameraPort.mjs';
|
||||
import { rendererOf } from './render/rendererOf.js';
|
||||
import { followedOf } from './data/followed.js';
|
||||
import {
|
||||
fakeSceneFrame,
|
||||
fakeSceneQuery,
|
||||
@@ -175,13 +181,34 @@ function harness(
|
||||
const double = {
|
||||
camera,
|
||||
scene,
|
||||
trackedEntity: undefined,
|
||||
// Cesium's entity tracking, without entities of its own: the camera
|
||||
// port follows on a tracking widget of the fake's.
|
||||
trackedEntityChanged: new Cesium.Event(),
|
||||
entities: {},
|
||||
};
|
||||
const viewer = bindFakeCesiumCamera(double, {
|
||||
query: fakeSceneQuery(double),
|
||||
frame: fakeSceneFrame(double),
|
||||
});
|
||||
// Count who listens for the port's follow changes.
|
||||
const renderer = rendererOf(viewer);
|
||||
const port = renderer.camera;
|
||||
let followListeners = 0;
|
||||
renderer.camera = Object.create(port, {
|
||||
on: {
|
||||
value(event, cb, options) {
|
||||
const off = port.on(event, cb, options);
|
||||
if (event !== 'followChanged') return off;
|
||||
followListeners += 1;
|
||||
let live = true;
|
||||
return () => {
|
||||
if (live) followListeners -= 1;
|
||||
live = false;
|
||||
off();
|
||||
};
|
||||
},
|
||||
},
|
||||
});
|
||||
const target = Cesium.Cartesian3.fromDegrees(
|
||||
longitudeDeg,
|
||||
latitude,
|
||||
@@ -201,7 +228,15 @@ function harness(
|
||||
for (let i = 0; i < 20 && getActiveCameraMotion(); i += 1) tick();
|
||||
assert.equal(getActiveCameraMotion(), null, 'once motion must finish');
|
||||
};
|
||||
return { viewer, camera, canvas, target, tick, finishOnce };
|
||||
return {
|
||||
viewer,
|
||||
camera,
|
||||
canvas,
|
||||
target,
|
||||
tick,
|
||||
finishOnce,
|
||||
followListeners: () => followListeners,
|
||||
};
|
||||
}
|
||||
|
||||
test('globe rotation yields to tracking acquired and cleared before the next tick', (t) => {
|
||||
@@ -212,15 +247,13 @@ test('globe rotation yields to tracking acquired and cleared before the next tic
|
||||
);
|
||||
const before = pose(camera);
|
||||
const entity = { id: 'cockpit-aircraft', position: {} };
|
||||
viewer.trackedEntity = entity;
|
||||
viewer.trackedEntityChanged.raiseEvent(entity);
|
||||
followEntity(viewer, entity);
|
||||
assert.equal(
|
||||
getActiveCameraMotion(),
|
||||
null,
|
||||
'tracking acquisition must synchronously yield',
|
||||
);
|
||||
viewer.trackedEntity = undefined;
|
||||
viewer.trackedEntityChanged.raiseEvent(undefined);
|
||||
followEntity(viewer, null);
|
||||
tick();
|
||||
samePose(camera, before);
|
||||
assert.equal(hasRenderHold(), false);
|
||||
@@ -233,36 +266,34 @@ test('tracking event keeps legacy yaw and an untracked globe rotation active', (
|
||||
true,
|
||||
);
|
||||
const yawId = activeCameraMotionId();
|
||||
viewer.trackedEntityChanged.raiseEvent({ id: 'aircraft' });
|
||||
followEntity(viewer, { id: 'aircraft' });
|
||||
assert.equal(activeCameraMotionId(), yawId);
|
||||
followEntity(viewer, null);
|
||||
assert.equal(
|
||||
moveCamera({ motion: 'rotate_globe', mode: 'continuous' }).ok,
|
||||
true,
|
||||
);
|
||||
const globeId = activeCameraMotionId();
|
||||
viewer.trackedEntityChanged.raiseEvent(undefined);
|
||||
followEntity(viewer, null);
|
||||
assert.equal(activeCameraMotionId(), globeId);
|
||||
});
|
||||
|
||||
test('replaced viewer releases the old tracking listener without duplicate subscriptions', (t) => {
|
||||
const first = harness(t);
|
||||
assert.equal(first.viewer.trackedEntityChanged.numberOfListeners, 1);
|
||||
assert.equal(first.followListeners(), 1);
|
||||
initCameraVerbs(first.viewer);
|
||||
assert.equal(first.viewer.trackedEntityChanged.numberOfListeners, 1);
|
||||
assert.equal(first.followListeners(), 1);
|
||||
const next = harness(t);
|
||||
assert.equal(first.viewer.trackedEntityChanged.numberOfListeners, 0);
|
||||
assert.equal(next.viewer.trackedEntityChanged.numberOfListeners, 1);
|
||||
assert.equal(first.followListeners(), 0);
|
||||
assert.equal(next.followListeners(), 1);
|
||||
assert.equal(
|
||||
moveCamera({ motion: 'rotate_globe', mode: 'continuous' }).ok,
|
||||
true,
|
||||
);
|
||||
const id = activeCameraMotionId();
|
||||
// As Cesium's setter does: the value changes, then the event fires.
|
||||
first.viewer.trackedEntity = { id: 'stale-aircraft' };
|
||||
first.viewer.trackedEntityChanged.raiseEvent(first.viewer.trackedEntity);
|
||||
followEntity(first.viewer, { id: 'stale-aircraft' });
|
||||
assert.equal(activeCameraMotionId(), id);
|
||||
next.viewer.trackedEntity = { id: 'new-aircraft' };
|
||||
next.viewer.trackedEntityChanged.raiseEvent(next.viewer.trackedEntity);
|
||||
followEntity(next.viewer, { id: 'new-aircraft' });
|
||||
assert.equal(getActiveCameraMotion(), null);
|
||||
assert.equal(hasRenderHold(), false);
|
||||
});
|
||||
@@ -545,7 +576,7 @@ for (const mode of ['once', 'continuous']) {
|
||||
tick();
|
||||
assert.equal(hasRenderHold(), true);
|
||||
const tracked = { id: 'new-tracked-aircraft' };
|
||||
if (acquisition === 'tracking') viewer.trackedEntity = tracked;
|
||||
if (acquisition === 'tracking') followEntity(viewer, tracked);
|
||||
else
|
||||
camera.lookAt(
|
||||
target,
|
||||
@@ -556,10 +587,9 @@ for (const mode of ['once', 'continuous']) {
|
||||
tick();
|
||||
assert.equal(getActiveCameraMotion(), null);
|
||||
assert.equal(hasRenderHold(), false);
|
||||
assert.equal(
|
||||
viewer.trackedEntity,
|
||||
acquisition === 'tracking' ? tracked : undefined,
|
||||
);
|
||||
if (acquisition === 'tracking')
|
||||
assert.equal(followedEntity(viewer), tracked);
|
||||
else assert.equal(followedOf(viewer), null);
|
||||
assert.equal(Cesium.Matrix4.equals(camera.transform, transform), true);
|
||||
samePose(camera, before);
|
||||
tick();
|
||||
@@ -570,7 +600,7 @@ for (const mode of ['once', 'continuous']) {
|
||||
|
||||
test('direct globe rotation refuses a tracked camera without disturbing its reference frame', (t) => {
|
||||
const { viewer, camera, target } = harness(t);
|
||||
viewer.trackedEntity = { id: 'tracked-aircraft', name: 'tracked-aircraft' };
|
||||
followEntity(viewer, { id: 'tracked-aircraft', name: 'tracked-aircraft' });
|
||||
camera.lookAt(target, new Cesium.HeadingPitchRange(0, radians(-40), 1_000));
|
||||
const before = pose(camera);
|
||||
const transform = Cesium.Matrix4.clone(camera.transform);
|
||||
@@ -641,18 +671,19 @@ test('close-up refusal preserves an inherited target frame', (t) => {
|
||||
});
|
||||
test('navigation callback never releases tracking for globe rotation', (t) => {
|
||||
const { viewer, camera } = harness(t);
|
||||
const tracked = (viewer.trackedEntity = { id: 'tracked-aircraft' });
|
||||
const tracked = { id: 'tracked-aircraft' };
|
||||
followEntity(viewer, tracked);
|
||||
const before = pose(camera);
|
||||
let calls = 0;
|
||||
assert.equal(
|
||||
moveCamera({ motion: 'rotate_globe' }, () => {
|
||||
calls++;
|
||||
viewer.trackedEntity = undefined;
|
||||
followEntity(viewer, null);
|
||||
}).ok,
|
||||
false,
|
||||
);
|
||||
assert.equal(calls, 0);
|
||||
assert.equal(viewer.trackedEntity, tracked);
|
||||
assert.equal(followedEntity(viewer), tracked);
|
||||
samePose(camera, before);
|
||||
});
|
||||
test('direct globe request refuses Cockpit before navigation mutation', (t) => {
|
||||
@@ -843,8 +874,8 @@ for (const owner of ['tracking', 'cockpit', 'close-up'])
|
||||
height: owner === 'close-up' ? 5000 : GLOBE_VIEW.heightM,
|
||||
});
|
||||
const before = pose(camera);
|
||||
if (owner === 'tracking') viewer.trackedEntity = { id: 'tracked-aircraft' };
|
||||
const tracked = viewer.trackedEntity;
|
||||
if (owner === 'tracking') followEntity(viewer, { id: 'tracked-aircraft' });
|
||||
const tracked = followedEntity(viewer);
|
||||
let releases = 0,
|
||||
stamps = 0;
|
||||
const styleManager = {
|
||||
@@ -858,7 +889,7 @@ for (const owner of ['tracking', 'cockpit', 'close-up'])
|
||||
},
|
||||
release() {
|
||||
releases++;
|
||||
viewer.trackedEntity = undefined;
|
||||
followEntity(viewer, null);
|
||||
},
|
||||
navigate,
|
||||
});
|
||||
@@ -880,7 +911,7 @@ for (const owner of ['tracking', 'cockpit', 'close-up'])
|
||||
assert.equal(result.ok, false);
|
||||
assert.equal(releases, 0);
|
||||
assert.equal(stamps, 0);
|
||||
assert.equal(viewer.trackedEntity, tracked);
|
||||
assert.equal(followedEntity(viewer), tracked);
|
||||
samePose(camera, before);
|
||||
if (owner === 'close-up') {
|
||||
assert.equal(result.reason, 'globe-view-required');
|
||||
@@ -1806,7 +1837,7 @@ test('a voice turn reported as done turns at least the half degree its check pro
|
||||
|
||||
/** Track an entity below `camera`, locking it into that entity's frame. */
|
||||
function trackFrom(viewer, camera) {
|
||||
viewer.trackedEntity = { id: 'high-satellite' };
|
||||
followEntity(viewer, { id: 'high-satellite' });
|
||||
const below = Cesium.Cartesian3.fromDegrees(10, 20, 400_000);
|
||||
camera.lookAtTransform(Cesium.Transforms.eastNorthUpToFixedFrame(below));
|
||||
}
|
||||
@@ -1832,7 +1863,7 @@ test('a voice turn that releases a tracked camera is checked as released', (t) =
|
||||
});
|
||||
trackFrom(viewer, camera);
|
||||
const releaseThenRun = (start) => {
|
||||
viewer.trackedEntity = undefined;
|
||||
followEntity(viewer, null);
|
||||
camera.lookAtTransform(Cesium.Matrix4.IDENTITY);
|
||||
return start();
|
||||
};
|
||||
@@ -1873,14 +1904,14 @@ test('a refused voice turn leaves a tracked camera tracking', (t) => {
|
||||
for (let j = 0; j < 600 && getActiveCameraMotion(); j += 1) tick(1 / 60);
|
||||
}
|
||||
trackFrom(viewer, camera);
|
||||
const tracked = viewer.trackedEntity;
|
||||
const tracked = followedEntity(viewer);
|
||||
const transform = Cesium.Matrix4.clone(camera.transform);
|
||||
let released = false;
|
||||
const result = moveCamera(
|
||||
{ motion: 'tilt', direction: 'up', mode: 'once' },
|
||||
(start) => {
|
||||
released = true;
|
||||
viewer.trackedEntity = undefined;
|
||||
followEntity(viewer, null);
|
||||
camera.lookAtTransform(Cesium.Matrix4.IDENTITY);
|
||||
return start();
|
||||
},
|
||||
@@ -1889,7 +1920,7 @@ test('a refused voice turn leaves a tracked camera tracking', (t) => {
|
||||
assert.equal(result.ok, false, label);
|
||||
assert.match(result.error, /globe out of view/, label);
|
||||
assert.equal(released, false, label);
|
||||
assert.equal(viewer.trackedEntity, tracked, label);
|
||||
assert.equal(followedEntity(viewer), tracked, label);
|
||||
assert.ok(Cesium.Matrix4.equals(camera.transform, transform), label);
|
||||
}
|
||||
});
|
||||
|
||||
@@ -3,7 +3,11 @@
|
||||
// Arrival framing is computed before the destination's tiles exist, so it
|
||||
// works from a predicted ground height. The guard measures the real surface
|
||||
// after arrival and lifts the eye; these tests pin when it acts.
|
||||
import { bindFakeCesiumCamera } from './testSupport/fakeCameraPort.mjs';
|
||||
import {
|
||||
bindFakeCesiumCamera,
|
||||
followEntity,
|
||||
} from './testSupport/fakeCameraPort.mjs';
|
||||
import { rendererOf } from './render/rendererOf.js';
|
||||
import { fakeSceneQuery } from './testSupport/fakeCesiumScene.mjs';
|
||||
import { test } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
@@ -49,7 +53,33 @@ test('the clearance frames a subject without turning into an overflight', () =>
|
||||
assert.ok(MIN_EYE_CLEARANCE_M <= 250);
|
||||
});
|
||||
|
||||
function fakeViewer({ cameraHeightM, surfaceM }) {
|
||||
/**
|
||||
* Count the listeners for `viewer`'s camera port follow changes, from now on.
|
||||
* @returns {() => number}
|
||||
*/
|
||||
function countFollowListeners(viewer) {
|
||||
const renderer = rendererOf(viewer);
|
||||
const port = renderer.camera;
|
||||
let listeners = 0;
|
||||
renderer.camera = Object.create(port, {
|
||||
on: {
|
||||
value(event, cb, options) {
|
||||
const off = port.on(event, cb, options);
|
||||
if (event !== 'followChanged') return off;
|
||||
listeners += 1;
|
||||
let live = true;
|
||||
return () => {
|
||||
if (live) listeners -= 1;
|
||||
live = false;
|
||||
off();
|
||||
};
|
||||
},
|
||||
},
|
||||
});
|
||||
return () => listeners;
|
||||
}
|
||||
|
||||
function fakeViewer({ cameraHeightM, surfaceM, tracks = false }) {
|
||||
const flights = [];
|
||||
const position = Cesium.Cartographic.fromDegrees(
|
||||
-97.7603,
|
||||
@@ -80,6 +110,13 @@ function fakeViewer({ cameraHeightM, surfaceM }) {
|
||||
},
|
||||
},
|
||||
};
|
||||
// Cesium's entity tracking, without entities of its own: the camera
|
||||
// port follows on a tracking widget of the fake's.
|
||||
if (tracks)
|
||||
Object.assign(viewer, {
|
||||
trackedEntityChanged: new Cesium.Event(),
|
||||
entities: {},
|
||||
});
|
||||
return bindFakeCesiumCamera(viewer, { query: fakeSceneQuery(viewer) });
|
||||
}
|
||||
|
||||
@@ -136,10 +173,14 @@ import { LayerLifecycle } from './data/lifecycle.js';
|
||||
|
||||
function handoffFixture(t) {
|
||||
t.mock.timers.enable({ apis: ['setTimeout'] });
|
||||
const viewer = fakeViewer({ cameraHeightM: 172, surfaceM: 171 });
|
||||
const viewer = fakeViewer({
|
||||
cameraHeightM: 172,
|
||||
surfaceM: 171,
|
||||
tracks: true,
|
||||
});
|
||||
const followListeners = countFollowListeners(viewer);
|
||||
viewer.scene.canvas = new EventTarget();
|
||||
viewer.scene.canvas.ownerDocument = new EventTarget();
|
||||
viewer.trackedEntityChanged = new Cesium.Event();
|
||||
viewer.camera.cancelFlight = () => {};
|
||||
viewer.camera.lookAtTransform = () => {};
|
||||
viewer.camera.flyToBoundingSphere = function () {
|
||||
@@ -175,7 +216,7 @@ function handoffFixture(t) {
|
||||
showToast() {},
|
||||
});
|
||||
guardCameraAboveGround(viewer, { lat: 30.3, lon: -97.7 });
|
||||
return { viewer, navigation, originalFly };
|
||||
return { viewer, navigation, originalFly, followListeners };
|
||||
}
|
||||
|
||||
for (const handoff of [
|
||||
@@ -192,7 +233,8 @@ for (const handoff of [
|
||||
'app-stop',
|
||||
]) {
|
||||
test(`arrival guard relinquishes and removes hooks on ${handoff}`, async (t) => {
|
||||
const { viewer, navigation, originalFly } = handoffFixture(t);
|
||||
const { viewer, navigation, originalFly, followListeners } =
|
||||
handoffFixture(t);
|
||||
const methods = [
|
||||
'flyTo',
|
||||
'flyToBoundingSphere',
|
||||
@@ -209,9 +251,7 @@ for (const handoff of [
|
||||
},
|
||||
});
|
||||
} else if (handoff === 'tracking') {
|
||||
// As Cesium's setter does: the value changes, then the event fires.
|
||||
viewer.trackedEntity = { id: 'contact' };
|
||||
viewer.trackedEntityChanged.raiseEvent(viewer.trackedEntity);
|
||||
followEntity(viewer, { id: 'contact' });
|
||||
} else if (handoff === 'follow' || handoff === 'UI') {
|
||||
navigation._stampNavigation({ cancelPendingSelection: false });
|
||||
} else if (handoff === 'keyboard') {
|
||||
@@ -247,7 +287,7 @@ for (const handoff of [
|
||||
methods,
|
||||
'the guard never replaces camera methods',
|
||||
);
|
||||
assert.equal(viewer.trackedEntityChanged.numberOfListeners, 0);
|
||||
assert.equal(followListeners(), 0);
|
||||
navigation.destroy();
|
||||
});
|
||||
}
|
||||
|
||||
@@ -282,11 +282,11 @@ test('a direct globe gesture retires delayed camera and selection restore only',
|
||||
);
|
||||
assert.match(
|
||||
ui,
|
||||
/viewer\?\.canvas\?\.addEventListener\(\s*'pointerdown',\s*this\._initialShareGestureHandler/,
|
||||
/canvasOf\(this\.viewer\)\?\.addEventListener\(\s*'pointerdown',\s*this\._initialShareGestureHandler/,
|
||||
);
|
||||
assert.match(
|
||||
ui,
|
||||
/viewer\?\.canvas\?\.addEventListener\(\s*'wheel',\s*this\._initialShareGestureHandler/,
|
||||
/canvasOf\(this\.viewer\)\?\.addEventListener\(\s*'wheel',\s*this\._initialShareGestureHandler/,
|
||||
);
|
||||
assert.match(
|
||||
ui,
|
||||
|
||||
+10
-7
@@ -9,7 +9,10 @@ import {
|
||||
moveCamera,
|
||||
} from './cameraVerbs.js';
|
||||
import { createGevActionRunner } from './voice/gevActions.js';
|
||||
import { bindFakeCesiumCamera } from './testSupport/fakeCameraPort.mjs';
|
||||
import {
|
||||
bindFakeCesiumCamera,
|
||||
followEntity,
|
||||
} from './testSupport/fakeCameraPort.mjs';
|
||||
import {
|
||||
fakeSceneFrame,
|
||||
fakeSceneQuery,
|
||||
@@ -56,8 +59,10 @@ function harness(
|
||||
const double = {
|
||||
camera,
|
||||
scene,
|
||||
trackedEntity: undefined,
|
||||
// Cesium's entity tracking, without entities of its own: the camera
|
||||
// port follows on a tracking widget of the fake's.
|
||||
trackedEntityChanged: new Cesium.Event(),
|
||||
entities: {},
|
||||
clock: { onTick: new Cesium.Event() },
|
||||
};
|
||||
// The Cesium renderer's own camera port over the real camera; frames from
|
||||
@@ -251,9 +256,7 @@ test('a pivoting tilt yields when tracking takes the camera', (t) => {
|
||||
const h = harness(t);
|
||||
assert.equal(moveCamera({ motion: 'tilt', pitchDeg: -45 }).ok, true);
|
||||
h.tick();
|
||||
const entity = { id: 'tracked' };
|
||||
h.viewer.trackedEntity = entity;
|
||||
h.viewer.trackedEntityChanged.raiseEvent(entity);
|
||||
followEntity(h.viewer, { id: 'tracked' });
|
||||
assert.equal(getActiveCameraMotion(), null);
|
||||
});
|
||||
|
||||
@@ -560,10 +563,10 @@ test('a regional tilt-up nudge goes to the camera horizon limit', (t) => {
|
||||
|
||||
test('a voice tilt from a tracked view judges its limit from the camera pitch', (t) => {
|
||||
const h = harness(t, { height: 20000, pitch: -5.2 });
|
||||
h.viewer.trackedEntity = { id: 'tracked' };
|
||||
followEntity(h.viewer, { id: 'tracked' });
|
||||
// Voice releases the follow camera before the motion starts.
|
||||
const release = (start) => {
|
||||
h.viewer.trackedEntity = undefined;
|
||||
followEntity(h.viewer, null);
|
||||
return start();
|
||||
};
|
||||
const result = moveCamera({ motion: 'tilt', direction: 'up' }, release);
|
||||
|
||||
@@ -42,6 +42,7 @@ import {
|
||||
} from '../hudReadouts.js';
|
||||
import { createVesselIconBook } from '../layers/vessels/iconBook.js';
|
||||
import { bindRenderer } from '../render/rendererOf.js';
|
||||
import { entityFollowTarget } from '../data/followed.js';
|
||||
|
||||
test('open feed with vessels is healthy (null)', () => {
|
||||
assert.equal(
|
||||
@@ -1045,13 +1046,31 @@ function installWireHarness(picked, stateOverrides = {}) {
|
||||
this.keydown?.(event);
|
||||
},
|
||||
};
|
||||
const trackedEntityChanged = makeCesiumEvent();
|
||||
const viewer = {
|
||||
scene: { pick: () => picked },
|
||||
trackedEntity: undefined,
|
||||
trackedEntityChanged,
|
||||
};
|
||||
const input = fakeInput(viewer);
|
||||
// The camera port other layers follow through, with no pose to read; its
|
||||
// followChanged event counts who listens.
|
||||
const followChanged = makeCesiumEvent();
|
||||
const camera = {
|
||||
pose: () => null,
|
||||
followed: null,
|
||||
follow(target) {
|
||||
this.followed = target;
|
||||
followChanged.raise();
|
||||
},
|
||||
on: (name, callback) =>
|
||||
name === 'followChanged'
|
||||
? followChanged.addEventListener(callback)
|
||||
: () => {},
|
||||
};
|
||||
const unbindRenderer = bindRenderer(viewer, {
|
||||
camera,
|
||||
get canvas() {
|
||||
return viewer.scene?.canvas;
|
||||
},
|
||||
});
|
||||
const handler = { click: (event) => input.click(event.position) };
|
||||
const record = makeRecord();
|
||||
const trail = makeTrailSpy();
|
||||
@@ -1088,11 +1107,14 @@ function installWireHarness(picked, stateOverrides = {}) {
|
||||
trail,
|
||||
hud,
|
||||
viewer,
|
||||
camera,
|
||||
followChanged,
|
||||
windowTarget,
|
||||
input: input.input,
|
||||
cleanup() {
|
||||
stopReadout();
|
||||
aisLiveVesselsLayer.destroy();
|
||||
unbindRenderer();
|
||||
if (hadWindow) globalThis.window = priorWindow;
|
||||
else delete globalThis.window;
|
||||
if (hadDocument) globalThis.document = priorDocument;
|
||||
@@ -1314,19 +1336,18 @@ test('vessel interaction wire: Escape deselects the selected vessel', () => {
|
||||
test('vessel interaction wire: trackedEntityChanged clears only with tracking and a selection', () => {
|
||||
const harness = installWireHarness(undefined);
|
||||
try {
|
||||
harness.viewer.trackedEntityChanged.raise();
|
||||
harness.followChanged.raise();
|
||||
assert.equal(
|
||||
aisLiveVesselsLayer.getSelectedInfo()?.mmsi,
|
||||
harness.record.mmsi,
|
||||
);
|
||||
assert.equal(harness.trail.clearCalls, 0);
|
||||
|
||||
harness.viewer.trackedEntity = { id: 'tracked-flight' };
|
||||
harness.viewer.trackedEntityChanged.raise();
|
||||
harness.camera.follow(entityFollowTarget({ id: 'tracked-flight' }, {}));
|
||||
assert.equal(aisLiveVesselsLayer.getSelectedInfo(), null);
|
||||
assert.equal(harness.trail.clearCalls, 1);
|
||||
|
||||
harness.viewer.trackedEntityChanged.raise();
|
||||
harness.followChanged.raise();
|
||||
assert.equal(harness.trail.clearCalls, 1);
|
||||
} finally {
|
||||
harness.cleanup();
|
||||
@@ -1344,8 +1365,8 @@ test('vessel interaction lifecycle: destroy removes the exact bound keydown list
|
||||
assert.equal(harness.keyTarget.removed[0].type, 'keydown');
|
||||
assert.strictEqual(harness.keyTarget.removed[0].callback, added.callback);
|
||||
assert.equal(harness.keyTarget.keydown, null);
|
||||
assert.equal(harness.viewer.trackedEntityChanged.removeCalls, 1);
|
||||
assert.equal(harness.viewer.trackedEntityChanged.listenerCount, 0);
|
||||
assert.equal(harness.followChanged.removeCalls, 1);
|
||||
assert.equal(harness.followChanged.listenerCount, 0);
|
||||
} finally {
|
||||
harness.cleanup();
|
||||
}
|
||||
@@ -1363,8 +1384,8 @@ test('vessel interaction lifecycle: disable detaches input and enable reinstalls
|
||||
assert.equal(harness.keyTarget.keydown, null);
|
||||
assert.equal(harness.keyTarget.removed.length, 1);
|
||||
assert.strictEqual(harness.keyTarget.removed[0].callback, disabledKeydown);
|
||||
assert.equal(harness.viewer.trackedEntityChanged.removeCalls, 1);
|
||||
assert.equal(harness.viewer.trackedEntityChanged.listenerCount, 0);
|
||||
assert.equal(harness.followChanged.removeCalls, 1);
|
||||
assert.equal(harness.followChanged.listenerCount, 0);
|
||||
|
||||
_setVesselStateForTest({
|
||||
records: [harness.record],
|
||||
@@ -1390,8 +1411,8 @@ test('vessel interaction lifecycle: disable detaches input and enable reinstalls
|
||||
|
||||
assert.equal(harness.input.subscriberCount(), 1);
|
||||
assert.equal(harness.keyTarget.added.length, 2);
|
||||
assert.equal(harness.viewer.trackedEntityChanged.addCalls, 2);
|
||||
assert.equal(harness.viewer.trackedEntityChanged.listenerCount, 1);
|
||||
assert.equal(harness.followChanged.addCalls, 2);
|
||||
assert.equal(harness.followChanged.listenerCount, 1);
|
||||
harness.handler.click({ position: { x: 10, y: 20 } });
|
||||
assert.equal(aisLiveVesselsLayer.getSelectedInfo(), null);
|
||||
|
||||
|
||||
@@ -3,7 +3,10 @@
|
||||
import { test } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import * as Cesium from 'cesium';
|
||||
import { bindFakeCesiumCamera } from '../testSupport/fakeCameraPort.mjs';
|
||||
import {
|
||||
bindFakeCesiumCamera,
|
||||
followEntity,
|
||||
} from '../testSupport/fakeCameraPort.mjs';
|
||||
import { fakeScenePorts } from '../testSupport/fakeCesiumScene.mjs';
|
||||
import alprCamerasLayer, {
|
||||
createAlprCamerasLayer,
|
||||
@@ -337,6 +340,10 @@ function cameraHarness(layer = alprCamerasLayer) {
|
||||
postRender: new Cesium.Event(),
|
||||
pick: () => picked,
|
||||
},
|
||||
// Cesium's entity tracking, without entities of its own: the camera
|
||||
// port follows on a tracking widget of the fake's.
|
||||
trackedEntityChanged: new Cesium.Event(),
|
||||
entities: {},
|
||||
};
|
||||
const ports = fakeScenePorts(viewer);
|
||||
bindFakeCesiumCamera(viewer, ports);
|
||||
@@ -1240,14 +1247,14 @@ test('nearby count and discovery control frame a real loaded camera without fetc
|
||||
);
|
||||
assert.equal(flights[0].options.offset.range, 800);
|
||||
assert.equal(h.requests.length, 1);
|
||||
h.viewer.trackedEntity = {};
|
||||
followEntity(h.viewer, {});
|
||||
assert.equal(alprCamerasLayer.getRowControls().chips[0].disabled, true);
|
||||
assert.equal(
|
||||
controls.chips[0].onClick(),
|
||||
false,
|
||||
'a stale button cannot steal the follow camera',
|
||||
);
|
||||
h.viewer.trackedEntity = undefined;
|
||||
followEntity(h.viewer, null);
|
||||
alprCamerasLayer.disable();
|
||||
assert.equal(alprCamerasLayer.getStats().countLabel, '');
|
||||
assert.equal(controls.chips[0].onClick(), false);
|
||||
|
||||
+17
-5
@@ -13,7 +13,11 @@
|
||||
//
|
||||
// computeFrustumGeometry is PURE (no viewer, no scene queries) so it runs under
|
||||
// plain node:test.
|
||||
import { bindFakeCesiumCamera } from '../testSupport/fakeCameraPort.mjs';
|
||||
import {
|
||||
bindFakeCesiumCamera,
|
||||
followEntity,
|
||||
} from '../testSupport/fakeCameraPort.mjs';
|
||||
import { entityFollowTarget, followedOf } from './followed.js';
|
||||
import { test } from 'node:test';
|
||||
// Preserve structural pins across component qualification and formatter wrapping.
|
||||
function componentFunctionSource(fn) {
|
||||
@@ -883,14 +887,18 @@ test('CCTV disable→enable defers the active-camera re-probe until its next act
|
||||
test('CCTV focus distinguishes tracking ownership from a missing active camera', () => {
|
||||
let flyCalls = 0;
|
||||
const viewer = {
|
||||
trackedEntity: { id: 'tracked-flight' },
|
||||
camera: {
|
||||
flyToBoundingSphere() {
|
||||
flyCalls += 1;
|
||||
},
|
||||
},
|
||||
// Cesium's entity tracking, without entities of its own: the camera
|
||||
// port follows on a tracking widget of the fake's.
|
||||
trackedEntityChanged: new Cesium.Event(),
|
||||
entities: {},
|
||||
};
|
||||
bindFakeCesiumCamera(viewer);
|
||||
followEntity(viewer, { id: 'tracked-flight' });
|
||||
const record = {
|
||||
camera: { rangeM: 210, headingDeg: 41 },
|
||||
position: { x: 1, y: 2, z: 3 },
|
||||
@@ -1021,7 +1029,6 @@ test('CCTV repeated in-world clicks dispatch focus only for the one real activat
|
||||
function makeDeselectViewer() {
|
||||
const viewer = {
|
||||
isDestroyed: () => false,
|
||||
trackedEntity: { id: 'sibling-track-owner' },
|
||||
camera: {
|
||||
positionWC: Cesium.Cartesian3.fromDegrees(-97.7431, 30.2672, 4_000),
|
||||
positionCartographic: Cesium.Cartographic.fromDegrees(
|
||||
@@ -1050,6 +1057,11 @@ function makeDeselectViewer() {
|
||||
camera: {
|
||||
pose: () => (viewer.eye ? { ...viewer.eye } : undefined),
|
||||
on: () => () => {},
|
||||
// A sibling layer's follow owns the camera.
|
||||
followed: entityFollowTarget({ id: 'sibling-track-owner' }, {}),
|
||||
follow(target) {
|
||||
this.followed = target;
|
||||
},
|
||||
},
|
||||
}).draw;
|
||||
return viewer;
|
||||
@@ -1263,7 +1275,7 @@ test('CCTV deselect publishes one null state and leaves the complete camera pose
|
||||
pitch: viewer.camera.pitch,
|
||||
roll: viewer.camera.roll,
|
||||
transform: Cesium.Matrix4.clone(viewer.camera.transform),
|
||||
trackedEntity: viewer.trackedEntity,
|
||||
followed: followedOf(viewer),
|
||||
};
|
||||
|
||||
assert.equal(deactivateActiveCamera(), true);
|
||||
@@ -1288,7 +1300,7 @@ test('CCTV deselect publishes one null state and leaves the complete camera pose
|
||||
assert.equal(viewer.camera.pitch, pose.pitch);
|
||||
assert.equal(viewer.camera.roll, pose.roll);
|
||||
assert.deepEqual(viewer.camera.transform, pose.transform);
|
||||
assert.equal(viewer.trackedEntity, pose.trackedEntity);
|
||||
assert.equal(followedOf(viewer), pose.followed);
|
||||
assert.equal(viewer.camera.flyCalls || 0, 0);
|
||||
unsubscribe();
|
||||
} finally {
|
||||
|
||||
@@ -50,7 +50,8 @@ import { withEntityRecord } from './entityRecords.js';
|
||||
import { framePortFor } from '../testSupport/fakeFramePort.mjs';
|
||||
import { bindFakeCesiumCamera } from '../testSupport/fakeCameraPort.mjs';
|
||||
import { fakeSceneFrame } from '../testSupport/fakeCesiumScene.mjs';
|
||||
import { bindRenderer } from '../render/rendererOf.js';
|
||||
import { bindRenderer, rendererOf } from '../render/rendererOf.js';
|
||||
import { entityFollowTarget, followedOf } from './followed.js';
|
||||
import { fakeDrawPort } from '../testSupport/fakeDrawPort.mjs';
|
||||
|
||||
const militaryAwarenessSource = readLayerSource(
|
||||
@@ -90,6 +91,46 @@ test('Contacts moves a distance that rounds to 1,000 m into kilometres', () => {
|
||||
assert.equal(presentAwarenessDistance(9960), '10\u00a0km');
|
||||
});
|
||||
|
||||
|
||||
/**
|
||||
* Give `viewer`'s bound camera port a follow of its own, as the renderer's
|
||||
* is: `follow(target)` sets `followed` and raises `followChanged`.
|
||||
*/
|
||||
function followable(viewer) {
|
||||
const renderer = rendererOf(viewer);
|
||||
const port = renderer.camera;
|
||||
const listeners = new Set();
|
||||
let followed = null;
|
||||
renderer.camera = Object.create(port, {
|
||||
followed: { get: () => followed },
|
||||
follow: {
|
||||
value(target) {
|
||||
followed = target;
|
||||
for (const cb of [...listeners]) cb();
|
||||
},
|
||||
},
|
||||
on: {
|
||||
value(event, cb, options) {
|
||||
if (event !== 'followChanged') return port.on(event, cb, options);
|
||||
listeners.add(cb);
|
||||
return () => listeners.delete(cb);
|
||||
},
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Follow `entity` (an entity holder) through `viewer`'s camera port, as a
|
||||
* layer does; null stops following.
|
||||
*/
|
||||
function followIn(viewer, entity) {
|
||||
rendererOf(viewer).camera.follow(
|
||||
entity ? entityFollowTarget(entity, {}) : null,
|
||||
);
|
||||
}
|
||||
|
||||
/** The entity holder `viewer`'s camera follows, if any. */
|
||||
const followedEntity = (viewer) => followedOf(viewer)?.entity;
|
||||
function installAwarenessRuntime({
|
||||
isEnabled = () => true,
|
||||
isEffectivelyEnabled = isEnabled,
|
||||
@@ -194,6 +235,7 @@ function installAwarenessRuntime({
|
||||
draw: fakeDrawPort(),
|
||||
frame: fakeSceneFrame(viewer),
|
||||
});
|
||||
followable(viewer);
|
||||
const layers = new Map(
|
||||
AWARENESS_DEPENDENCIES.map((layerId) => [
|
||||
layerId,
|
||||
@@ -889,7 +931,7 @@ for (const fixture of [
|
||||
{},
|
||||
{ trackedId: `${subject.layerId}:${subject.id}` },
|
||||
);
|
||||
runtime.viewer.trackedEntity = trackedEntity;
|
||||
followIn(runtime.viewer, trackedEntity);
|
||||
replaceMethod(
|
||||
fixture.layer,
|
||||
'getTrackedSubject',
|
||||
@@ -930,7 +972,7 @@ for (const fixture of [
|
||||
'adoption must not recreate the existing track',
|
||||
);
|
||||
assert.equal(
|
||||
runtime.viewer.trackedEntity,
|
||||
followedEntity(runtime.viewer),
|
||||
trackedEntity,
|
||||
'adoption must not replace the source-owned tracked entity',
|
||||
);
|
||||
@@ -990,9 +1032,9 @@ test('Contacts activation adopts the production military tracked-subject descrip
|
||||
),
|
||||
'mutating one accessor result must not alter the tracked source position',
|
||||
);
|
||||
runtime.viewer.trackedEntity = withEntityRecord(
|
||||
{},
|
||||
{ trackedId: `military:${id}` },
|
||||
followIn(
|
||||
runtime.viewer,
|
||||
withEntityRecord({}, { trackedId: `military:${id}` }),
|
||||
);
|
||||
replaceMethod(flightsLayer, 'getTrackedSubject', () => null, restores);
|
||||
replaceMethod(
|
||||
@@ -1098,9 +1140,9 @@ test('production military tracked-subject label falls back to registration befor
|
||||
'getAllPositions id stays the identity hex',
|
||||
);
|
||||
|
||||
runtime.viewer.trackedEntity = withEntityRecord(
|
||||
{},
|
||||
{ trackedId: `military:${id}` },
|
||||
followIn(
|
||||
runtime.viewer,
|
||||
withEntityRecord({}, { trackedId: `military:${id}` }),
|
||||
);
|
||||
replaceMethod(flightsLayer, 'getTrackedSubject', () => null, restores);
|
||||
replaceMethod(flightsLayer, 'trackById', () => true, restores);
|
||||
@@ -1173,9 +1215,9 @@ test('a cached Context subject re-reads its label when enrichment lands after se
|
||||
meta,
|
||||
});
|
||||
|
||||
runtime.viewer.trackedEntity = withEntityRecord(
|
||||
{},
|
||||
{ trackedId: `flights:${id}` },
|
||||
followIn(
|
||||
runtime.viewer,
|
||||
withEntityRecord({}, { trackedId: `flights:${id}` }),
|
||||
);
|
||||
replaceMethod(
|
||||
militaryFlightsLayer,
|
||||
@@ -1319,9 +1361,9 @@ test('Contacts activation adopts the production civilian tracked-subject descrip
|
||||
),
|
||||
'mutating one accessor result must not alter the tracked source position',
|
||||
);
|
||||
runtime.viewer.trackedEntity = withEntityRecord(
|
||||
{},
|
||||
{ trackedId: `flights:${id}` },
|
||||
followIn(
|
||||
runtime.viewer,
|
||||
withEntityRecord({}, { trackedId: `flights:${id}` }),
|
||||
);
|
||||
replaceMethod(
|
||||
militaryFlightsLayer,
|
||||
@@ -1409,9 +1451,9 @@ test('Contacts activation reconciles to a newer cross-layer tracked flight after
|
||||
const restores = [];
|
||||
|
||||
try {
|
||||
runtime.viewer.trackedEntity = withEntityRecord(
|
||||
{},
|
||||
{ trackedId: 'flights:first' },
|
||||
followIn(
|
||||
runtime.viewer,
|
||||
withEntityRecord({}, { trackedId: 'flights:first' }),
|
||||
);
|
||||
replaceMethod(
|
||||
flightsLayer,
|
||||
@@ -1435,9 +1477,9 @@ test('Contacts activation reconciles to a newer cross-layer tracked flight after
|
||||
|
||||
civilianTracked = null;
|
||||
militaryTracked = awarenessSubject('military', 'latest', positions.latest);
|
||||
runtime.viewer.trackedEntity = withEntityRecord(
|
||||
{},
|
||||
{ trackedId: 'military:latest' },
|
||||
followIn(
|
||||
runtime.viewer,
|
||||
withEntityRecord({}, { trackedId: 'military:latest' }),
|
||||
);
|
||||
releaseDependencies();
|
||||
await nextTurn();
|
||||
@@ -1482,9 +1524,9 @@ test('tracked flight cleared during Contacts activation suppresses fallback auto
|
||||
const focused = [];
|
||||
|
||||
try {
|
||||
runtime.viewer.trackedEntity = withEntityRecord(
|
||||
{},
|
||||
{ trackedId: 'flights:selected' },
|
||||
followIn(
|
||||
runtime.viewer,
|
||||
withEntityRecord({}, { trackedId: 'flights:selected' }),
|
||||
);
|
||||
replaceMethod(flightsLayer, 'getTrackedSubject', () => tracked, restores);
|
||||
replaceMethod(
|
||||
@@ -1508,7 +1550,7 @@ test('tracked flight cleared during Contacts activation suppresses fallback auto
|
||||
);
|
||||
|
||||
tracked = null;
|
||||
runtime.viewer.trackedEntity = undefined;
|
||||
followIn(runtime.viewer, null);
|
||||
// Deliberately untagged: this is the DESELECT case, and an untagged clear
|
||||
// must default to deliberate. An eviction (`reason: 'evicted'`) instead
|
||||
// keeps the subject as CONTACT LOST — see the eviction tests below — but
|
||||
|
||||
+12
-4
@@ -5,6 +5,7 @@ import {
|
||||
fakeCameraPort,
|
||||
} from '../testSupport/fakeCameraPort.mjs';
|
||||
import { bindRenderer } from '../render/rendererOf.js';
|
||||
import { entityFollowTarget, followedOf } from './followed.js';
|
||||
import { fakeDrawPort } from '../testSupport/fakeDrawPort.mjs';
|
||||
import {
|
||||
buildRadioTunerBand,
|
||||
@@ -1666,16 +1667,23 @@ test('Radio recovery preserves closer altitude and caps extreme full-globe zoom'
|
||||
|
||||
test('Radio camera navigation yields to every live tracked-entity owner', () => {
|
||||
const viewer = {};
|
||||
bindRenderer(viewer, { camera: fakeCameraPort().port });
|
||||
// A camera port that follows: the layers' tracked entities are followed
|
||||
// through it.
|
||||
const { port: camera } = fakeCameraPort();
|
||||
camera.followed = null;
|
||||
camera.follow = (target) => {
|
||||
camera.followed = target;
|
||||
};
|
||||
bindRenderer(viewer, { camera });
|
||||
assert.equal(radioCameraNavigationAllowed(viewer), true);
|
||||
assert.equal(radioCameraNavigationAllowed({}), false, 'no camera to move');
|
||||
for (const trackedId of ['flights:abc123', 'military:def456']) {
|
||||
const trackedEntity = withEntityRecord({}, { trackedId });
|
||||
viewer.trackedEntity = trackedEntity;
|
||||
camera.follow(entityFollowTarget(trackedEntity, {}));
|
||||
assert.equal(radioCameraNavigationAllowed(viewer), false, trackedId);
|
||||
assert.equal(viewer.trackedEntity, trackedEntity);
|
||||
assert.equal(followedOf(viewer)?.entity, trackedEntity);
|
||||
}
|
||||
viewer.trackedEntity = undefined;
|
||||
camera.follow(null);
|
||||
assert.equal(radioCameraNavigationAllowed(viewer), true);
|
||||
assert.equal(radioCameraNavigationAllowed({ trackedEntity: {} }), false);
|
||||
assert.equal(radioCameraNavigationAllowed(null), false);
|
||||
|
||||
@@ -14,6 +14,8 @@ import {
|
||||
trackedLabelModelFromText,
|
||||
} from './trackedReadout.js';
|
||||
import { entityRecord, readEntityRecord, withEntityRecord } from './entityRecords.js';
|
||||
import { entityFollowTarget } from './followed.js';
|
||||
import { bindRenderer } from '../render/rendererOf.js';
|
||||
|
||||
function makeCesiumEvent() {
|
||||
const listeners = new Set();
|
||||
@@ -27,6 +29,31 @@ function makeCesiumEvent() {
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* A viewer whose camera port follows `entity` (null: nothing), with
|
||||
* `follow(next)` to change it and announce the change on `changed`.
|
||||
*/
|
||||
function followingViewer(entity, changed) {
|
||||
const camera = {
|
||||
followed: null,
|
||||
on: (event, callback) =>
|
||||
event === 'followChanged' ? changed.addEventListener(callback) : () => {},
|
||||
};
|
||||
const viewer = {};
|
||||
bindRenderer(viewer, { camera });
|
||||
const follow = (next) => {
|
||||
camera.followed = next ? entityFollowTarget(next, {}) : null;
|
||||
};
|
||||
follow(entity);
|
||||
return {
|
||||
viewer,
|
||||
follow(next) {
|
||||
follow(next);
|
||||
changed.raise();
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
function makeHostRecorder() {
|
||||
const calls = [];
|
||||
return {
|
||||
@@ -130,7 +157,7 @@ test('tracked entity publishes a protected host entry backed by the frame cache'
|
||||
const changed = makeCesiumEvent();
|
||||
const display = { x: 10, y: 20, z: 30 };
|
||||
const entity = withEntityRecord({ id: 'generated' }, { trackedId: 'flights:abc123', displayPosition: () => display, labelModel: { title: 'UAL123', details: ['FL350 · 451 kts'], accent: '#39d0ff' } });
|
||||
const viewer = { trackedEntity: entity, trackedEntityChanged: changed };
|
||||
const { viewer, follow } = followingViewer(entity, changed);
|
||||
const recorder = makeHostRecorder();
|
||||
globalThis.window = fakeWindow;
|
||||
_setTrackedOverlayHostForTest(recorder.host);
|
||||
@@ -158,8 +185,7 @@ test('tracked entity publishes a protected host entry backed by the frame cache'
|
||||
'FL360 · 455 kts',
|
||||
]);
|
||||
|
||||
viewer.trackedEntity = null;
|
||||
changed.raise();
|
||||
follow(null);
|
||||
assert.equal(getActiveTrackedReadoutId(), null);
|
||||
assert.equal(recorder.calls.at(-1).op, 'clear');
|
||||
} finally {
|
||||
@@ -173,7 +199,7 @@ test('selection lifecycle leaves installations to their own entry and retains AL
|
||||
const originalWindow = globalThis.window;
|
||||
const fakeWindow = new EventTarget();
|
||||
const changed = makeCesiumEvent();
|
||||
const viewer = { trackedEntity: null, trackedEntityChanged: changed };
|
||||
const { viewer } = followingViewer(null, changed);
|
||||
const recorder = makeHostRecorder();
|
||||
const installation = withEntityRecord({}, { trackedId: 'installations:fort-test', displayPosition: () => ({ x: 1, y: 2, z: 3 }), labelModel: { title: 'FORT TEST', details: ['AIRFIELD'], accent: '#5aa9ff' } });
|
||||
globalThis.window = fakeWindow;
|
||||
@@ -218,7 +244,7 @@ test('selection lifecycle leaves installations to their own entry and retains AL
|
||||
const clearsBeforeDestroy = recorder.calls.filter(({ op }) => op === 'clear').length;
|
||||
destroyTrackedReadout();
|
||||
assert.ok(recorder.calls.filter(({ op }) => op === 'clear').length > clearsBeforeDestroy);
|
||||
assert.equal(changed.size, 0, 'trackedEntityChanged listener was removed');
|
||||
assert.equal(changed.size, 0, 'the followChanged listener was removed');
|
||||
assert.ok(recorder.calls.some(({ op, visible }) => op === 'visible' && visible === false));
|
||||
} finally {
|
||||
destroyTrackedReadout();
|
||||
|
||||
@@ -75,6 +75,8 @@ async function standaloneStartup(Cesium, credentials, fetchImpl) {
|
||||
createStandaloneCatalog: () => ({}),
|
||||
createGoogleTokenSource: () => createGoogleTokenSource({ fetchImpl }),
|
||||
selectMapStartupRoute,
|
||||
// The default renderer's load; the scene below draws with none.
|
||||
loadDefaultRenderer: () => null,
|
||||
// The real scene forwards these credentials to this same loader.
|
||||
createStandaloneScene: async (options) => ({
|
||||
...(await loadPhotorealisticTileset(Cesium, options)),
|
||||
|
||||
@@ -57,8 +57,7 @@ const INJECTED = {};
|
||||
|
||||
/**
|
||||
* Modules whose use of the bridge holds up without the factory: with no
|
||||
* port they read Cesium's `trackedEntity` instead, which is all an unbound
|
||||
* viewer can follow by.
|
||||
* camera port they report nothing followed.
|
||||
*/
|
||||
const FALLS_BACK = new Set(['src/data/followed.js']);
|
||||
|
||||
@@ -192,6 +191,18 @@ const CAMERA_FROM_CALLER = new Set([
|
||||
'./ui/visual-settings',
|
||||
'./application/controls',
|
||||
'./application/data',
|
||||
// The scene binds the renderer it creates (the default one loaded only
|
||||
// when it is given none), so its own viewer needs no factory.
|
||||
'./application/scene',
|
||||
// The map stacks switch through the renderer's map engine or its globe
|
||||
// port (`maps/globeEngine.js`), which a viewer of the caller's own gets
|
||||
// from `./render/cesium/unbound`.
|
||||
'./maps/defaults',
|
||||
// It restores a shared view through the camera, frame and canvas of the
|
||||
// renderer bound to the viewer it is given; it loads no factory.
|
||||
'./ui/share-restoration',
|
||||
// It reads the eye from the camera port's pose, and none without one.
|
||||
'./agent/world-packet',
|
||||
]);
|
||||
|
||||
const pkg = JSON.parse(readFileSync(path.join(root, 'package.json'), 'utf8'));
|
||||
|
||||
@@ -267,7 +267,9 @@ export function bindFakeCesiumCamera(viewer, ports = {}) {
|
||||
value: () => (fake.computeViewRectangle ? real.viewRectangle() : null),
|
||||
},
|
||||
on: {
|
||||
value(event, cb) {
|
||||
value(event, cb, options) {
|
||||
// What the port itself raises (a follow's change) comes from it.
|
||||
if (event === 'followChanged') return real.on(event, cb, options);
|
||||
const source = fake[event];
|
||||
const off = source?.addEventListener?.(cb);
|
||||
if (typeof off === 'function') return off;
|
||||
|
||||
@@ -17,7 +17,12 @@ import {
|
||||
createCesiumQuery,
|
||||
queryCapabilities,
|
||||
} from '../render/cesium/query.js';
|
||||
import { bindFakeCesiumCamera } from '../testSupport/fakeCameraPort.mjs';
|
||||
import {
|
||||
bindFakeCesiumCamera,
|
||||
followEntity,
|
||||
followedEntity,
|
||||
} from '../testSupport/fakeCameraPort.mjs';
|
||||
import { entityFollowTarget } from '../data/followed.js';
|
||||
import { fakeSceneFrame } from '../testSupport/fakeCesiumScene.mjs';
|
||||
import { entityRecord } from '../data/entityRecords.js';
|
||||
|
||||
@@ -139,7 +144,15 @@ function createRealViewer(target, { frames = true } = {}) {
|
||||
// `camera.changed`, so the fixture has to carry one.
|
||||
scene.preRender = new Cesium.Event();
|
||||
camera.getPickRay = () => new Cesium.Ray();
|
||||
return { viewer: withPorts({ camera, scene }, { frames }), target };
|
||||
// Cesium's entity tracking, without entities of its own: the camera port
|
||||
// follows on a tracking widget of the fake's.
|
||||
const viewer = {
|
||||
camera,
|
||||
scene,
|
||||
trackedEntityChanged: new Cesium.Event(),
|
||||
entities: {},
|
||||
};
|
||||
return { viewer: withPorts(viewer, { frames }), target };
|
||||
}
|
||||
|
||||
/** Place a real camera in an orbit around `target` and release the frame. */
|
||||
@@ -556,7 +569,7 @@ for (const [label, altitude, range] of [
|
||||
trackingReferenceFrame: Cesium.TrackingReferenceFrame.ENU,
|
||||
});
|
||||
entityRecord(entity).displayPosition = () => target;
|
||||
viewer.trackedEntity = entity;
|
||||
followEntity(viewer, entity);
|
||||
const follow = new Cesium.EntityView(entity, viewer.scene);
|
||||
follow.update(viewer.clock.currentTime);
|
||||
viewer.camera.lookAt(
|
||||
@@ -585,7 +598,7 @@ for (const [label, altitude, range] of [
|
||||
follow.update(viewer.clock.currentTime);
|
||||
const transform = Cesium.Matrix4.clone(viewer.camera.transform);
|
||||
viewer.scene.preUpdate.raiseEvent();
|
||||
assert.equal(viewer.trackedEntity, entity);
|
||||
assert.equal(followedEntity(viewer), entity);
|
||||
assert.ok(
|
||||
Cesium.Matrix4.equalsEpsilon(
|
||||
viewer.camera.transform,
|
||||
@@ -605,7 +618,7 @@ for (const [label, altitude, range] of [
|
||||
}
|
||||
target = Cesium.Cartesian3.fromDegrees(-96, 31, altitude);
|
||||
follow.update(viewer.clock.currentTime);
|
||||
assert.equal(viewer.trackedEntity, entity);
|
||||
assert.equal(followedEntity(viewer), entity);
|
||||
assert.ok(Math.abs(readCameraTargetFrame(viewer).range - range) < 1e-5);
|
||||
});
|
||||
}
|
||||
@@ -619,10 +632,10 @@ test('orientation animation cancels on replacement and explicit cancellation', (
|
||||
animator.animate(frame, { heading: 0, pitch: STRAIGHT_DOWN_PITCH });
|
||||
animator.animate(frame, { heading: 0, pitch: OBLIQUE_PITCH });
|
||||
assert.equal(viewer.scene.preUpdate.numberOfListeners, 1);
|
||||
viewer.trackedEntity = {};
|
||||
followEntity(viewer, {});
|
||||
viewer.scene.preUpdate.raiseEvent();
|
||||
assert.equal(viewer.scene.preUpdate.numberOfListeners, 0);
|
||||
viewer.trackedEntity = undefined;
|
||||
followEntity(viewer, null);
|
||||
animator.animate(frame, { heading: 0, pitch: STRAIGHT_DOWN_PITCH });
|
||||
animator.cancel();
|
||||
assert.equal(viewer.scene.preUpdate.numberOfListeners, 0);
|
||||
@@ -631,9 +644,17 @@ test('orientation animation cancels on replacement and explicit cancellation', (
|
||||
test('orientation navigation preserves follow and selection; new navigation cancels animation', () => {
|
||||
const calls = [];
|
||||
const entity = {};
|
||||
const viewer = { trackedEntity: entity };
|
||||
const viewer = {};
|
||||
bindRenderer(viewer, {
|
||||
camera: { cancelFlight: () => calls.push('cancel-flight') },
|
||||
camera: {
|
||||
cancelFlight: () => calls.push('cancel-flight'),
|
||||
// The camera follows `entity`.
|
||||
followed: entityFollowTarget(entity, {}),
|
||||
follow(target) {
|
||||
this.followed = target;
|
||||
},
|
||||
on: () => () => {},
|
||||
},
|
||||
});
|
||||
let cockpit = false;
|
||||
const navigation = new NavigationController({
|
||||
@@ -651,7 +672,7 @@ test('orientation navigation preserves follow and selection; new navigation canc
|
||||
navigation.runOrientation('camera', () => 'animated'),
|
||||
'animated',
|
||||
);
|
||||
assert.equal(viewer.trackedEntity, entity);
|
||||
assert.equal(followedEntity(viewer), entity);
|
||||
assert.deepEqual(calls, [
|
||||
'cancel-orientation',
|
||||
'interrupt-motion',
|
||||
|
||||
@@ -509,8 +509,8 @@ test('a ride handed to an aircraft on a layer Contacts turned on keeps that laye
|
||||
await settle();
|
||||
assert.equal(cockpit.enter(), true);
|
||||
// NEXT hands the view to a military aircraft; Contacts turned its layer on.
|
||||
// The follow's change adopts it as the ridden aircraft.
|
||||
retrack({ layerId: 'military', info: MILITARY });
|
||||
assert.equal(cockpit._adoptTrackedEntity(performance.now()), true);
|
||||
assert.equal(cockpit.readSubjectLayerId(), 'military');
|
||||
await manager.setEnabled('ais-live-vessels', false, { origin: 'user' });
|
||||
await settle();
|
||||
|
||||
@@ -15,8 +15,8 @@ import * as Cesium from 'cesium';
|
||||
import {
|
||||
bindFakeCesiumCamera,
|
||||
followEntity,
|
||||
followedEntity,
|
||||
} from '../testSupport/fakeCameraPort.mjs';
|
||||
import { followedOf } from '../data/followed.js';
|
||||
import { fakeScenePorts } from '../testSupport/fakeCesiumScene.mjs';
|
||||
import {
|
||||
FAKE_EVENT_TYPES,
|
||||
@@ -640,7 +640,7 @@ test('a double-click on a site focuses it and keeps the orbital view', async (t)
|
||||
const { cockpit, viewer, handler } = scene;
|
||||
scene.doubleClick(SITES.alpha.at);
|
||||
assert.equal(handler.stockDoubleClicks, 0, 'Cesium does not track the site');
|
||||
assert.equal(followedEntity(viewer), undefined);
|
||||
assert.equal(followedOf(viewer), null);
|
||||
scene.frame();
|
||||
assert.equal(cockpit.active, true, 'still in orbit');
|
||||
assert.equal(cockpit.orbital.focus.key, SITES.alpha.id);
|
||||
@@ -726,7 +726,7 @@ test('a satellite row rides it, staying in orbit; RETURN goes back', async (t) =
|
||||
assert.equal(newTrack.length, 1);
|
||||
assert.ok(newTrack[0].timestamp > firstTrack.timestamp, 'the new ride’s own time');
|
||||
assert.deepEqual(satellites.calls.slice(-2), [['track', 49260], ['subject', 49260]]);
|
||||
assert.equal(followedEntity(viewer), undefined, 'the Cockpit keeps the camera');
|
||||
assert.equal(followedOf(viewer), null, 'the Cockpit keeps the camera');
|
||||
assert.equal(cockpit.subjectId, 49260);
|
||||
assert.equal(cockpit.orbital.focus, null, 'the focus is reset');
|
||||
assert.equal(modeEvents.at(-1)?.active, true);
|
||||
|
||||
@@ -29,6 +29,7 @@ import {
|
||||
followEntity,
|
||||
followedEntity,
|
||||
} from '../testSupport/fakeCameraPort.mjs';
|
||||
import { followedOf } from '../data/followed.js';
|
||||
import { fakeScenePorts } from '../testSupport/fakeCesiumScene.mjs';
|
||||
import { fakeInput } from '../input/testDoubles.mjs';
|
||||
|
||||
@@ -412,7 +413,7 @@ test('entering takes the camera and shows only the orbital HUD', async (t) => {
|
||||
assert.equal(cockpit.subjectKind, 'satellite');
|
||||
assert.equal(cockpit.subjectId, ISS.noradId);
|
||||
assert.deepEqual(satellites.calls, [['subject', ISS.noradId]]);
|
||||
assert.equal(followedEntity(viewer), undefined);
|
||||
assert.equal(followedOf(viewer), null);
|
||||
assert.equal(viewer.scene.screenSpaceCameraController.enableInputs, false);
|
||||
assert.ok(document.body.classList.contains('cockpit-mode'));
|
||||
assert.ok(document.body.classList.contains('cockpit-orbit'));
|
||||
|
||||
@@ -7,9 +7,9 @@ import * as Cesium from 'cesium';
|
||||
import { applyShareFollowOffset, placeFollowEye } from './shareFollow.js';
|
||||
import { followOffsetToEnu } from '../share/viewCodec.js';
|
||||
import { withEntityRecord } from '../data/entityRecords.js';
|
||||
import { followedOf } from '../data/followed.js';
|
||||
import { entityFollowTarget, followedOf } from '../data/followed.js';
|
||||
import { bindFakeCesiumCamera } from '../testSupport/fakeCameraPort.mjs';
|
||||
import { findCamera } from '../render/rendererOf.js';
|
||||
import { findCamera, rendererOf } from '../render/rendererOf.js';
|
||||
|
||||
function realCamera() {
|
||||
const scene = {
|
||||
@@ -58,10 +58,6 @@ function following(start = START) {
|
||||
camera,
|
||||
scene,
|
||||
clock: { currentTime: Cesium.JulianDate.now() },
|
||||
trackedEntity: withEntityRecord(
|
||||
{},
|
||||
{ trackedId: 'satellites:25544', displayPosition: () => TARGET },
|
||||
),
|
||||
};
|
||||
bindFakeCesiumCamera(viewer, {
|
||||
frame: {
|
||||
@@ -69,6 +65,35 @@ function following(start = START) {
|
||||
phase === 'preUpdate' ? scene.preUpdate.addEventListener(cb) : () => {},
|
||||
},
|
||||
});
|
||||
// The port follows the satellite, already framed in its orbit frame; its
|
||||
// follow offset is the eye in that frame, as the Cesium follow's is.
|
||||
const renderer = rendererOf(viewer);
|
||||
const port = renderer.camera;
|
||||
const followed = entityFollowTarget(
|
||||
withEntityRecord(
|
||||
{},
|
||||
{ trackedId: 'satellites:25544', displayPosition: () => TARGET },
|
||||
),
|
||||
{ position: () => TARGET, frame: 'autodetect' },
|
||||
);
|
||||
renderer.camera = Object.create(port, {
|
||||
followed: { get: () => followed },
|
||||
followFramed: { get: () => true },
|
||||
followOffset: {
|
||||
value: Object.freeze({
|
||||
get() {
|
||||
const p = camera.position;
|
||||
return { x: p.x, y: p.y, z: p.z };
|
||||
},
|
||||
set(offset) {
|
||||
camera.lookAtTransform(
|
||||
camera.transform,
|
||||
new Cesium.Cartesian3(offset.x, offset.y, offset.z),
|
||||
);
|
||||
},
|
||||
}),
|
||||
},
|
||||
});
|
||||
return viewer;
|
||||
}
|
||||
|
||||
|
||||
@@ -20,7 +20,8 @@ import {
|
||||
} from '../share/viewCodec.js';
|
||||
import { entityRecord, withEntityRecord } from '../data/entityRecords.js';
|
||||
import { bindFakeCesiumCamera } from '../testSupport/fakeCameraPort.mjs';
|
||||
import { followedOf } from '../data/followed.js';
|
||||
import { entityFollowTarget, followedOf } from '../data/followed.js';
|
||||
import { rendererOf } from '../render/rendererOf.js';
|
||||
|
||||
const NOW_MS = Date.now();
|
||||
const FIX = { lat: 37.6213, lon: -122.379, alt: 3200 };
|
||||
@@ -131,6 +132,58 @@ const preUpdateFrame = (viewer) => ({
|
||||
: () => {},
|
||||
});
|
||||
|
||||
/**
|
||||
* Give `viewer`'s bound camera port a follow, as the Cesium renderer's is:
|
||||
* `follow(target)` sets `followed` and raises `followChanged`; a follow is
|
||||
* framed at once, and its offset is the fake camera's eye in its frame, set
|
||||
* by `lookAtTransform` in the frame it is in. Returns the port.
|
||||
*/
|
||||
function followingPort(viewer) {
|
||||
const renderer = rendererOf(viewer);
|
||||
const port = renderer.camera;
|
||||
const listeners = new Set();
|
||||
let followed = null;
|
||||
renderer.camera = Object.create(port, {
|
||||
followed: { get: () => followed },
|
||||
followFramed: { get: () => followed !== null },
|
||||
follow: {
|
||||
value(target) {
|
||||
followed = target;
|
||||
for (const cb of [...listeners]) cb();
|
||||
},
|
||||
},
|
||||
followOffset: {
|
||||
value: Object.freeze({
|
||||
get() {
|
||||
const p = followed ? viewer.camera.position : null;
|
||||
return p ? { x: p.x, y: p.y, z: p.z } : null;
|
||||
},
|
||||
set(offset) {
|
||||
if (!followed) return;
|
||||
viewer.camera.lookAtTransform(
|
||||
viewer.camera.transform,
|
||||
new Cesium.Cartesian3(offset.x, offset.y, offset.z),
|
||||
);
|
||||
},
|
||||
}),
|
||||
},
|
||||
on: {
|
||||
value(event, cb, options) {
|
||||
if (event !== 'followChanged') return port.on(event, cb, options);
|
||||
listeners.add(cb);
|
||||
return () => listeners.delete(cb);
|
||||
},
|
||||
},
|
||||
});
|
||||
return renderer.camera;
|
||||
}
|
||||
|
||||
/** Follow `entity` (an entity holder) through `viewer`'s camera port. */
|
||||
const followIn = (viewer, entity) =>
|
||||
rendererOf(viewer).camera.follow(
|
||||
entity ? entityFollowTarget(entity, {}) : null,
|
||||
);
|
||||
|
||||
/**
|
||||
* A Cesium-shaped camera in `transform` with its eye at `position` there:
|
||||
* a view set on it (a world pose) lands in that frame, and each eye it is
|
||||
@@ -159,6 +212,13 @@ function cameraInFrame(transform, position, looks) {
|
||||
looks.push(local);
|
||||
this.position = local;
|
||||
},
|
||||
// As the follow moves the eye: an eye in the frame.
|
||||
lookAtTransform(frame, offset) {
|
||||
this.transform = frame;
|
||||
const local = Cesium.Cartesian3.clone(offset);
|
||||
looks.push(local);
|
||||
this.position = local;
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
@@ -170,6 +230,7 @@ function openPage(t, href, { managerOptions = {}, tracking = null } = {}) {
|
||||
const restores = [];
|
||||
// Bound first with a frame port: the share follow runs on its preUpdate.
|
||||
bindFakeCesiumCamera(viewer, { frame: preUpdateFrame(viewer) });
|
||||
followingPort(viewer);
|
||||
const manager = new ShareLinkManager(bindFakeCesiumCamera(viewer), {
|
||||
onRestore: async (state) => restores.push(state),
|
||||
isNavigationCurrent: () => true,
|
||||
@@ -289,7 +350,7 @@ test('a thing view turns its layer on, follows by id and frames the shared offse
|
||||
const page = openPage(t, `http://localhost/share/${aircraftCode()}`, {
|
||||
tracking: (owner) => {
|
||||
// What the coordinator does when the aircraft is in the feed.
|
||||
owner.viewer.trackedEntity = entity;
|
||||
followIn(owner.viewer, entity);
|
||||
owner._handleShareTrackingRestoreStatus({
|
||||
layerId: 'flights',
|
||||
targetId: 'a1b2c3',
|
||||
@@ -498,11 +559,13 @@ test('the followed entity is read in the share format, and its offset round-trip
|
||||
const viewer = bindFakeCesiumCamera({
|
||||
camera: { positionWC: cameraPosition },
|
||||
clock: { currentTime: Cesium.JulianDate.now() },
|
||||
trackedEntity: withEntityRecord(
|
||||
{},
|
||||
{ trackedId: 'military:ae1234', displayPosition: () => target },
|
||||
),
|
||||
});
|
||||
followingPort(viewer);
|
||||
const entity = withEntityRecord(
|
||||
{},
|
||||
{ trackedId: 'military:ae1234', displayPosition: () => target },
|
||||
);
|
||||
followIn(viewer, entity);
|
||||
const subject = readShareFollowSubject({ viewer, nowMs: NOW_MS });
|
||||
assert.equal(subject.kind, 'military_aircraft');
|
||||
assert.equal(subject.id, 'ae1234');
|
||||
@@ -510,10 +573,10 @@ test('the followed entity is read in the share format, and its offset round-trip
|
||||
assert.ok(Math.abs(subject.lastKnown.lat - FIX.lat) < 1e-9);
|
||||
assert.ok(Math.abs(subject.lastKnown.alt - FIX.alt) < 1e-3);
|
||||
// A followed entity the share format has no kind for is not a thing view.
|
||||
entityRecord(viewer.trackedEntity).trackedId = 'local-adsb:abc';
|
||||
entityRecord(entity).trackedId = 'local-adsb:abc';
|
||||
assert.equal(readShareFollowSubject({ viewer }), null);
|
||||
// Nor is a camera that follows nothing (a selected vessel is not followed).
|
||||
viewer.trackedEntity = undefined;
|
||||
followIn(viewer, null);
|
||||
assert.equal(readShareFollowSubject({ viewer }), null);
|
||||
});
|
||||
|
||||
@@ -532,7 +595,6 @@ test('a shared offset on the far side swings round, never jumping through the en
|
||||
},
|
||||
},
|
||||
},
|
||||
trackedEntity: entity,
|
||||
camera: cameraInFrame(
|
||||
Cesium.Transforms.eastNorthUpToFixedFrame(target),
|
||||
new Cesium.Cartesian3(0, -4800, 3300),
|
||||
@@ -540,6 +602,8 @@ test('a shared offset on the far side swings round, never jumping through the en
|
||||
),
|
||||
};
|
||||
bindFakeCesiumCamera(viewer, { frame: preUpdateFrame(viewer) });
|
||||
followingPort(viewer);
|
||||
followIn(viewer, entity);
|
||||
// Looking south at the nose: the opposite side of the app's framing.
|
||||
const offset = { range: 5800, heading: 180, pitch: -35 };
|
||||
applyShareFollowOffset(viewer, followedOf(viewer), offset);
|
||||
|
||||
@@ -2,6 +2,7 @@ import assert from 'node:assert/strict';
|
||||
import test from 'node:test';
|
||||
import { LocationNavigation } from './locationNavigation.js';
|
||||
import { LayerBindings } from './layerBindings.js';
|
||||
import { bindRenderer } from '../render/rendererOf.js';
|
||||
|
||||
function replaceWindow(t, value) {
|
||||
const previous = Object.getOwnPropertyDescriptor(globalThis, 'window');
|
||||
@@ -128,12 +129,16 @@ test('camera-entry listeners are removed before any asynchronous layer cleanup',
|
||||
const { owner } = bindings(t);
|
||||
let changes = 0;
|
||||
let trackedCallback;
|
||||
owner.viewer = { trackedEntityChanged: {
|
||||
addEventListener(callback) {
|
||||
// What the camera follows changes through its port's followChanged.
|
||||
owner.viewer = {};
|
||||
bindRenderer(owner.viewer, { camera: {
|
||||
followed: null,
|
||||
on(event, callback) {
|
||||
if (event !== 'followChanged') return () => {};
|
||||
trackedCallback = callback;
|
||||
return () => { changes += 1; };
|
||||
},
|
||||
} };
|
||||
} });
|
||||
owner._stampNavigation = () => { changes += 100; };
|
||||
owner.observeCamera();
|
||||
owner.stop();
|
||||
|
||||
Reference in new issue
Block a user