mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 16:22:20 +00:00
The head was a polyline entity whose positions were read each frame. Its draw-port line was redrawn at most every 100 ms while the aircraft flew, so its end lagged the icon. It is drawn each frame the aircraft moves, as the Flights trail head is; the trail still skips a head that has not moved.
1373 lines
46 KiB
JavaScript
1373 lines
46 KiB
JavaScript
import assert from 'node:assert/strict';
|
|
import test from 'node:test';
|
|
import * as Cesium from 'cesium';
|
|
|
|
import { CLASS_SCALE_2D } from '../../data/aircraftClass.js';
|
|
import { layerFeedState } from '../../data/feedState.js';
|
|
import { aircraftIcon } from '../../data/aircraftIcons.js';
|
|
import {
|
|
createLocalAdsbLayer,
|
|
HEARD_BY_RECEIVER,
|
|
localAdsbCardModel,
|
|
localAdsbReceiverLine,
|
|
localAdsbStatus,
|
|
} from './index.js';
|
|
import { createLocalAdsbModels } from './models.js';
|
|
import { entityRecord, readEntityRecord } from '../../data/entityRecords.js';
|
|
import { resolvePickId } from '../../data/pickRegistry.js';
|
|
import { fromDegrees, toLonLatH } from '../../geo/ellipsoid.js';
|
|
import { fakeInput } from '../../input/testDoubles.mjs';
|
|
import { hexColor } from '../../render/color.js';
|
|
import { fakeCameraPort } from '../../testSupport/fakeCameraPort.mjs';
|
|
import { bindFakeDraw } from '../../testSupport/fakeDrawPort.mjs';
|
|
|
|
const MAGENTA = hexColor('#ff4fd8');
|
|
|
|
/** The layer's live draw set whose id ends with `suffix`. */
|
|
function layerSet(draw, suffix) {
|
|
return [...draw.sets.values()].find(
|
|
(record) =>
|
|
!record.disposed &&
|
|
record.spec.id.startsWith('local-adsb:') &&
|
|
record.spec.id.endsWith(suffix),
|
|
);
|
|
}
|
|
|
|
/** The icon drawn for an aircraft, or undefined. */
|
|
const iconOf = (draw, id) => layerSet(draw, ':markers')?.items.get(id);
|
|
/** The 978 MHz ring drawn for an aircraft, or undefined. */
|
|
const ringOf = (draw, id) => layerSet(draw, ':rings')?.items.get(id);
|
|
/** Degrees of latitude where an aircraft's icon now is. */
|
|
const latitudeOf = (draw, id) => toLonLatH(iconOf(draw, id).pos).lat;
|
|
import { loadFleetModelSet } from '../../data/fleetModels.js';
|
|
import { aircraftLayerModelSpec } from '../flights/modelSpec.js';
|
|
import { fetchPublicFile } from '../../testSupport/fleetGlb.mjs';
|
|
|
|
// The layer draws models only once the fleet model set has loaded; load it from disk.
|
|
const realInfo = console.info;
|
|
console.info = () => {};
|
|
await loadFleetModelSet({ fetchImpl: fetchPublicFile });
|
|
console.info = realInfo;
|
|
|
|
function fakeReceiver(initial = {}) {
|
|
const state = {
|
|
webUsbSupported: true,
|
|
connected: false,
|
|
mode: 'fm',
|
|
status: 'idle',
|
|
message: 'Ready',
|
|
aircraft: [],
|
|
messagesPerSecond: null,
|
|
...initial,
|
|
};
|
|
const modeCalls = [];
|
|
const subscribers = new Set();
|
|
const snapshot = () => ({ ...state, aircraft: [...state.aircraft] });
|
|
return {
|
|
modeCalls,
|
|
getState: snapshot,
|
|
subscribe(listener) {
|
|
subscribers.add(listener);
|
|
return () => subscribers.delete(listener);
|
|
},
|
|
set(patch) {
|
|
Object.assign(state, patch);
|
|
for (const listener of subscribers) listener(snapshot());
|
|
},
|
|
async setMode(mode) {
|
|
modeCalls.push(mode);
|
|
state.mode = mode;
|
|
return true;
|
|
},
|
|
};
|
|
}
|
|
|
|
function fakeServices() {
|
|
const calls = {
|
|
registered: [],
|
|
selected: [],
|
|
cleared: [],
|
|
removed: [],
|
|
carriers: new Map(),
|
|
};
|
|
let selected = null;
|
|
return {
|
|
calls,
|
|
services: {
|
|
render: { governorRequestRender() {} },
|
|
context: {
|
|
registerEntityContext(entity, metadata) {
|
|
entityRecord(entity).contextId = metadata.id;
|
|
calls.registered.push(metadata);
|
|
calls.carriers.set(metadata.id, entity);
|
|
},
|
|
selectEntityContext(entity) {
|
|
selected = { id: readEntityRecord(entity)?.contextId, entity };
|
|
calls.selected.push(selected.id);
|
|
return selected;
|
|
},
|
|
clearSelectedEntityContextForLayer(layerId, options) {
|
|
calls.cleared.push({ layerId, ...options });
|
|
selected = null;
|
|
},
|
|
getSelectedEntityContext: () => selected,
|
|
removeEntityContextsForLayer(layerId, options) {
|
|
calls.removed.push({ layerId, retainIds: options?.retainIds });
|
|
},
|
|
},
|
|
picking: {
|
|
registerPickOwner() {},
|
|
unregisterPickOwner() {},
|
|
resolvePickId,
|
|
},
|
|
detection: { markSourcesChanged() {} },
|
|
overlays: { refreshReadout() {} },
|
|
},
|
|
};
|
|
}
|
|
|
|
/**
|
|
* A viewer with a fake draw port, a camera port whose screen axes are east
|
|
* and north at (0°, 0°), and a query port whose drill picks are the
|
|
* viewer's `drillHits`; `pose` sets the camera.
|
|
*/
|
|
function fakeViewer(viewer = { scene: {} }, pose = {}) {
|
|
const camera = fakeCameraPort({
|
|
pose: { right: { x: 0, y: 1, z: 0 }, up: { x: 0, y: 0, z: 1 }, ...pose },
|
|
});
|
|
const query = {
|
|
drillPick: (x, y, { limit } = {}) =>
|
|
(viewer.drillHits ?? []).slice(0, limit),
|
|
};
|
|
const { draw } = bindFakeDraw(viewer, { camera: camera.port, query });
|
|
const input = fakeInput(viewer);
|
|
return { draw, viewer, input, camera };
|
|
}
|
|
|
|
function record(overrides = {}) {
|
|
return {
|
|
icao: 'abc123',
|
|
callsign: 'LOCAL1',
|
|
lat: 0,
|
|
lon: 0,
|
|
altitudeFt: 10_000,
|
|
groundSpeedKt: 180,
|
|
trackDeg: 0,
|
|
verticalRateFpm: 0,
|
|
lastPositionAt: 100_000,
|
|
lastMessageAt: 100_000,
|
|
messageCount: 12,
|
|
rssiDbfs: null,
|
|
band: '1090',
|
|
source: 'webusb',
|
|
...overrides,
|
|
};
|
|
}
|
|
|
|
function fakeFeeds(initial = {}) {
|
|
let state = {
|
|
configured: null,
|
|
polling: false,
|
|
feeds: [],
|
|
records: [],
|
|
...initial,
|
|
};
|
|
const listeners = new Set();
|
|
const calls = [];
|
|
return {
|
|
calls,
|
|
getState: () => state,
|
|
subscribe(listener) {
|
|
listeners.add(listener);
|
|
return () => listeners.delete(listener);
|
|
},
|
|
set(patch) {
|
|
state = { ...state, ...patch };
|
|
for (const listener of listeners) listener(state);
|
|
},
|
|
start() {
|
|
calls.push('start');
|
|
state = { ...state, polling: true };
|
|
},
|
|
stop() {
|
|
calls.push('stop');
|
|
state = { ...state, polling: false };
|
|
},
|
|
};
|
|
}
|
|
|
|
/** A viewer whose camera looks down on (0°, 0°) from 50 km. */
|
|
function modelViewer() {
|
|
return fakeViewer(
|
|
{ scene: {} },
|
|
{
|
|
height: 50_000,
|
|
position: { x: 6_378_137 + 50_000, y: 0, z: 0 },
|
|
direction: { x: -1, y: 0, z: 0 },
|
|
},
|
|
);
|
|
}
|
|
|
|
async function enabledLayer(receiver, clock, feeds = null, options = {}) {
|
|
const { services, calls } = fakeServices();
|
|
const { draw, viewer } = options.viewer || fakeViewer();
|
|
const layer = createLocalAdsbLayer({
|
|
receiver,
|
|
feeds,
|
|
services: { ...services, ...options.services },
|
|
now: () => clock.now,
|
|
});
|
|
layer.init(viewer);
|
|
await layer.enable();
|
|
return { layer, calls, draw };
|
|
}
|
|
|
|
test('enabling Local ADS-B asks the shared tuner for 1090 MHz; disabling leaves it alone', async (t) => {
|
|
const receiver = fakeReceiver({ mode: 'fm' });
|
|
const clock = { now: 0 };
|
|
const { layer } = await enabledLayer(receiver, clock);
|
|
t.after(() => layer.destroy());
|
|
assert.equal(layer.id, 'local-adsb');
|
|
assert.equal(layer.name, 'Local ADS-B');
|
|
assert.deepEqual(receiver.modeCalls, ['adsb']);
|
|
assert.equal(await layer.disable(), true);
|
|
assert.deepEqual(
|
|
receiver.modeCalls,
|
|
['adsb'],
|
|
'turning the layer off never starts FM audio on its own',
|
|
);
|
|
});
|
|
|
|
test('local aircraft use their class silhouette and scale in magenta', async (t) => {
|
|
const receiver = fakeReceiver({ mode: 'adsb', connected: true });
|
|
const clock = { now: 100_000 };
|
|
const { layer, draw, calls } = await enabledLayer(receiver, clock);
|
|
t.after(() => layer.destroy());
|
|
receiver.set({
|
|
aircraft: [record(), record({ icao: 'a0b702', category: 'A7' })],
|
|
});
|
|
await layer.update();
|
|
|
|
const icon = iconOf(draw, 'local-adsb:abc123');
|
|
assert.ok(icon);
|
|
assert.equal(ringOf(draw, 'local-adsb:abc123'), undefined);
|
|
assert.equal(icon.image, aircraftIcon('airliner'));
|
|
assert.deepEqual(icon.size, [20, 20]);
|
|
assert.deepEqual(icon.color, MAGENTA);
|
|
assert.equal(icon.rotationMode, 'screen', 'upright on screen, turned');
|
|
assert.equal(icon.rotation, 0);
|
|
assert.deepEqual(icon.displayRange, [0, 2_000_000]);
|
|
assert.equal(icon.disableDepthTest, Number.POSITIVE_INFINITY);
|
|
assert.equal(layerSet(draw, ':markers').spec.horizonCull, true);
|
|
const carrier = calls.carriers.get('local-adsb:abc123');
|
|
assert.equal(icon.meta, carrier, 'a pick hands point-and-ask the carrier');
|
|
assert.equal(readEntityRecord(carrier)?.labelModel.title, 'LOCAL1');
|
|
assert.equal(typeof readEntityRecord(carrier)?.displayPosition, 'function');
|
|
|
|
const heli = () => iconOf(draw, 'local-adsb:a0b702');
|
|
assert.equal(heli().image, aircraftIcon('helicopter'));
|
|
assert.equal(heli().scale, CLASS_SCALE_2D.helicopter);
|
|
assert.deepEqual(
|
|
heli().color,
|
|
MAGENTA,
|
|
'the helicopter keeps the local magenta',
|
|
);
|
|
assert.equal(
|
|
readEntityRecord(calls.carriers.get('local-adsb:a0b702'))?.labelModel
|
|
.details[1],
|
|
'Helicopter · A7',
|
|
);
|
|
|
|
// On the ground the silhouette shrinks like a grounded public flight.
|
|
receiver.set({
|
|
aircraft: [
|
|
record({
|
|
icao: 'a0b702',
|
|
category: 'A7',
|
|
onGround: true,
|
|
lastPositionAt: 100_500,
|
|
}),
|
|
],
|
|
});
|
|
await layer.update();
|
|
assert.equal(heli().scale, CLASS_SCALE_2D.helicopter * 0.8);
|
|
|
|
const [detectable] = layer.getDetectableObjects();
|
|
assert.equal(detectable.sourceId, 'a0b702');
|
|
assert.equal(detectable.type, 'AIR');
|
|
});
|
|
|
|
test('the heading slews toward a new track instead of snapping', async (t) => {
|
|
const receiver = fakeReceiver({ mode: 'adsb', connected: true });
|
|
const clock = { now: 100_000 };
|
|
const { layer, draw } = await enabledLayer(receiver, clock);
|
|
t.after(() => layer.destroy());
|
|
receiver.set({ aircraft: [record()] });
|
|
await layer.update();
|
|
const rotation = () => iconOf(draw, 'local-adsb:abc123').rotation;
|
|
assert.equal(rotation(), 0);
|
|
|
|
clock.now = 101_000;
|
|
receiver.set({
|
|
aircraft: [
|
|
record({
|
|
lat: 0.0008,
|
|
trackDeg: 90,
|
|
lastPositionAt: 101_000,
|
|
lastMessageAt: 101_000,
|
|
}),
|
|
],
|
|
});
|
|
await layer.update();
|
|
const first = rotation();
|
|
assert.ok(
|
|
first > -Cesium.Math.PI_OVER_TWO && first <= 0,
|
|
'one frame does not swing the nose 90°',
|
|
);
|
|
for (let frame = 0; frame < 12; frame += 1) {
|
|
clock.now += 250;
|
|
await layer.update();
|
|
}
|
|
assert.ok(
|
|
Math.abs(rotation() + Cesium.Math.PI_OVER_TWO) < 1e-6,
|
|
'the nose settles on the new track',
|
|
);
|
|
});
|
|
|
|
test('markers move in real time between fixes and never jump on a new fix', async (t) => {
|
|
const receiver = fakeReceiver({ mode: 'adsb', connected: true });
|
|
const clock = { now: 100_000 };
|
|
const { layer, draw } = await enabledLayer(receiver, clock);
|
|
t.after(() => layer.destroy());
|
|
const latitude = () => latitudeOf(draw, 'local-adsb:abc123');
|
|
// 180 kt due north: 1 s covers 92.6 m, 0.000833° of latitude.
|
|
const degPerSecond = (180 * 1852) / 3600 / 111_195;
|
|
receiver.set({ aircraft: [record({ lastPositionAt: 99_000 })] });
|
|
await layer.update();
|
|
assert.ok(
|
|
Math.abs(latitude() - degPerSecond) < 1e-5,
|
|
'drawn where the aircraft is now, not at its last fix (no display delay)',
|
|
);
|
|
clock.now = 100_500;
|
|
await layer.update();
|
|
assert.ok(Math.abs(latitude() - 1.5 * degPerSecond) < 1e-5);
|
|
|
|
// The next fix is 150 m behind the extrapolation; the marker slides.
|
|
const before = latitude();
|
|
receiver.set({
|
|
aircraft: [
|
|
record({
|
|
lat: before - 150 / 111_195,
|
|
lastPositionAt: 100_500,
|
|
lastMessageAt: 100_500,
|
|
}),
|
|
],
|
|
});
|
|
await layer.update();
|
|
assert.ok(Math.abs(latitude() - before) < 1e-7, 'no jump at the new fix');
|
|
clock.now = 101_500;
|
|
await layer.update();
|
|
assert.ok(
|
|
Math.abs(latitude() - (before - 150 / 111_195 + degPerSecond)) < 1e-5,
|
|
'the correction has decayed onto the new fix',
|
|
);
|
|
});
|
|
|
|
test('an implausible jump in a feed record is ignored by the display', async (t) => {
|
|
const receiver = fakeReceiver({ mode: 'adsb', connected: true });
|
|
const clock = { now: 100_000 };
|
|
const { layer, draw } = await enabledLayer(receiver, clock);
|
|
t.after(() => layer.destroy());
|
|
receiver.set({ aircraft: [record({ groundSpeedKt: 120, trackDeg: 0 })] });
|
|
await layer.update();
|
|
clock.now = 101_000;
|
|
receiver.set({
|
|
aircraft: [
|
|
record({
|
|
lat: 0.05,
|
|
groundSpeedKt: 120,
|
|
lastPositionAt: 101_000,
|
|
lastMessageAt: 101_000,
|
|
}),
|
|
],
|
|
});
|
|
await layer.update();
|
|
const lat = latitudeOf(draw, 'local-adsb:abc123');
|
|
assert.ok(lat < 0.001, `stayed on its track (${lat})`);
|
|
assert.equal(layer.getStats().rejectedPositions, 1);
|
|
});
|
|
|
|
test('selecting an aircraft draws a magenta trail of the fixes the receiver heard', async (t) => {
|
|
const receiver = fakeReceiver({ mode: 'adsb', connected: true });
|
|
const clock = { now: 100_000 };
|
|
const trails = [];
|
|
const { layer } = await enabledLayer(receiver, clock, null, {
|
|
services: {
|
|
trails: {
|
|
createTrail(viewer, options) {
|
|
const trail = { options, positions: [], destroyed: false };
|
|
trails.push(trail);
|
|
return {
|
|
setPositions: (positions) => (trail.positions = positions),
|
|
destroy: () => (trail.destroyed = true),
|
|
};
|
|
},
|
|
},
|
|
},
|
|
});
|
|
t.after(() => layer.destroy());
|
|
for (let second = 0; second < 4; second += 1) {
|
|
clock.now = 100_000 + second * 1_000;
|
|
receiver.set({
|
|
aircraft: [
|
|
record({
|
|
lat: second * 0.0008,
|
|
lastPositionAt: clock.now,
|
|
lastMessageAt: clock.now,
|
|
}),
|
|
],
|
|
});
|
|
await layer.update();
|
|
if (second === 1) assert.equal(layer.selectAircraft('abc123'), true);
|
|
}
|
|
assert.equal(trails.length, 1);
|
|
assert.equal(trails[0].options.color, '#ff4fd8');
|
|
assert.equal(trails[0].options.width, 2.5);
|
|
assert.equal(trails[0].positions.length, 4, 'every heard fix, oldest first');
|
|
assert.ok(
|
|
Cesium.Cartographic.fromCartesian(trails[0].positions[0]).latitude <
|
|
Cesium.Cartographic.fromCartesian(trails[0].positions[3]).latitude,
|
|
);
|
|
clock.now = 200_000;
|
|
await layer.update();
|
|
assert.equal(trails[0].destroyed, true, 'the trail leaves with the aircraft');
|
|
});
|
|
|
|
test('the trail head runs from the last fix to the marker every frame, dimmed behind the surface', async (t) => {
|
|
const trails = await import('../../data/trailRenderer.js');
|
|
const receiver = fakeReceiver({ mode: 'adsb', connected: true });
|
|
const clock = { now: 100_000 };
|
|
const listeners = new Map();
|
|
const frame = {
|
|
on(event, callback) {
|
|
listeners.set(event, callback);
|
|
return () => listeners.delete(event);
|
|
},
|
|
};
|
|
const viewer = { scene: {} };
|
|
const camera = fakeCameraPort({
|
|
pose: { right: { x: 0, y: 1, z: 0 }, up: { x: 0, y: 0, z: 1 } },
|
|
});
|
|
const { draw } = bindFakeDraw(viewer, { camera: camera.port, frame });
|
|
const input = fakeInput(viewer);
|
|
const { layer } = await enabledLayer(receiver, clock, null, {
|
|
viewer: { draw, viewer, input },
|
|
services: { trails },
|
|
});
|
|
t.after(() => layer.destroy());
|
|
receiver.set({ aircraft: [record()] });
|
|
await layer.update();
|
|
assert.equal(layer.selectAircraft('abc123'), true);
|
|
// The head is the shared trail's head line.
|
|
const trailSet = () => draw.find('trail:');
|
|
const heads = () =>
|
|
[...(trailSet()?.items.values() ?? [])].filter(
|
|
(line) => line.id.endsWith(':head') && line.show !== false,
|
|
);
|
|
// Selected at its fix, the head has no length yet.
|
|
assert.equal(heads().length, 0);
|
|
clock.now = 100_500;
|
|
listeners.get('preRender')();
|
|
const [head] = heads();
|
|
assert.match(head.id, /^gev-trail:\d+:head$/);
|
|
assert.equal(head.mode, '3d');
|
|
assert.equal(head.widthPx, 2.5);
|
|
assert.deepEqual(head.style, {
|
|
kind: 'solid',
|
|
color: hexColor('#ff4fd8', 0.9),
|
|
});
|
|
assert.deepEqual(
|
|
head.depthFail,
|
|
{ kind: 'solid', color: hexColor('#ff4fd8', 0.45) },
|
|
'dimmed, not hidden, behind the surface',
|
|
);
|
|
assert.equal(head.positions.length, 2);
|
|
assert.deepEqual(
|
|
head.positions[1],
|
|
iconOf(draw, 'local-adsb:abc123').pos,
|
|
'it ends at the marker',
|
|
);
|
|
|
|
// A frame alone moves the marker, its icon and the head's end.
|
|
const before = latitudeOf(draw, 'local-adsb:abc123');
|
|
clock.now = 101_000;
|
|
listeners.get('preRender')();
|
|
const after = latitudeOf(draw, 'local-adsb:abc123');
|
|
assert.ok(after > before, `the marker flew north (${before} → ${after})`);
|
|
assert.ok(
|
|
Math.abs(toLonLatH(heads()[0].positions[1]).lat - after) < 1e-9,
|
|
'the head follows the marker',
|
|
);
|
|
// The next frame too, as the entity's head was rebuilt every frame.
|
|
clock.now = 101_016;
|
|
listeners.get('preRender')();
|
|
assert.deepEqual(
|
|
heads()[0].positions[1],
|
|
iconOf(draw, 'local-adsb:abc123').pos,
|
|
'the head ends on the icon a frame later',
|
|
);
|
|
|
|
// A frame where nothing moved leaves the head alone.
|
|
const writes = trailSet().writes;
|
|
listeners.get('preRender')();
|
|
assert.equal(trailSet().writes, writes);
|
|
|
|
await layer.disable();
|
|
assert.equal(listeners.has('preRender'), false, 'frames stop when off');
|
|
assert.equal(heads().length, 0, 'the head leaves with the selection');
|
|
});
|
|
|
|
test('adsbdb type, operator and route reach the card for the selected aircraft only', async (t) => {
|
|
const receiver = fakeReceiver({ mode: 'adsb', connected: true });
|
|
const clock = { now: 100_000 };
|
|
const queries = [];
|
|
const { layer, calls } = await enabledLayer(receiver, clock, null, {
|
|
services: {
|
|
enrichment: {
|
|
async getEnrichment(query) {
|
|
queries.push(`${query.kind}:${query.id}`);
|
|
if (query.kind === 'type')
|
|
return { found: true, typeCode: 'B407', typeName: 'Bell 407' };
|
|
return {
|
|
found: true,
|
|
airline: 'Air Evac',
|
|
origin: { code: 'AUS', lat: 0.1, lon: 0 },
|
|
destination: { code: 'SAT', lat: -0.1, lon: 0 },
|
|
};
|
|
},
|
|
},
|
|
},
|
|
});
|
|
t.after(() => layer.destroy());
|
|
receiver.set({
|
|
aircraft: [
|
|
record({ icao: 'a0b702', callsign: 'EVC145', category: 'A7' }),
|
|
record({ icao: 'def456', callsign: 'OTHER1' }),
|
|
],
|
|
});
|
|
await layer.update();
|
|
assert.deepEqual(queries, [], 'no request per contact');
|
|
assert.equal(layer.selectAircraft('a0b702'), true);
|
|
await new Promise((resolve) => setTimeout(resolve, 400));
|
|
assert.deepEqual([...queries].sort(), ['route:EVC145', 'type:a0b702']);
|
|
const entity = calls.carriers.get('local-adsb:a0b702');
|
|
assert.deepEqual(readEntityRecord(entity)?.labelModel.details.slice(0, 4), [
|
|
'ICAO A0B702 · EVC145',
|
|
'Helicopter · A7',
|
|
'Air Evac · Bell 407',
|
|
'AUS → SAT',
|
|
]);
|
|
assert.equal(
|
|
readEntityRecord(entity)?.labelModel.details.at(-1),
|
|
'Heard by your receiver · 1090 MHz · browser SDR',
|
|
);
|
|
layer.selectAircraft('a0b702');
|
|
await layer.update();
|
|
assert.equal(queries.length, 2, 'each key is asked for once');
|
|
});
|
|
|
|
test('the DISPLAY 3D toggle gives local aircraft magenta class models', async (t) => {
|
|
const receiver = fakeReceiver({ mode: 'adsb', connected: true });
|
|
const clock = { now: 100_000 };
|
|
const display = { models3d: true, models3dMode: 'proximity' };
|
|
const { layer, draw } = await enabledLayer(receiver, clock, null, {
|
|
services: { display: { getParams: () => display } },
|
|
viewer: modelViewer(),
|
|
});
|
|
t.after(() => layer.destroy());
|
|
receiver.set({ aircraft: [record({ icao: 'a0b702', category: 'A7' })] });
|
|
await layer.update();
|
|
const models = layerSet(draw, ':models');
|
|
const model = () => models.items.get('local-adsb:a0b702');
|
|
assert.ok(model(), 'admitted');
|
|
const spec = aircraftLayerModelSpec({ category: 'A7' });
|
|
assert.equal(
|
|
model().url,
|
|
'/models/fleet/helicopters/generic_heli.glb',
|
|
'the Flights rotorcraft model',
|
|
);
|
|
assert.ok(model().gltf instanceof Uint8Array, 'built from the loaded set');
|
|
assert.equal(model().scale, spec.scale, 'drawn life size');
|
|
assert.deepEqual(model().tint, MAGENTA);
|
|
assert.deepEqual(model().colorBlend, { mode: 'mix', amount: 0.94 });
|
|
assert.equal(model().environmentMap, false);
|
|
const heli = () => iconOf(draw, 'local-adsb:a0b702');
|
|
assert.equal(heli().show, true, 'the icon until the model is ready');
|
|
draw.ready(models.spec.id, 'local-adsb:a0b702');
|
|
await layer.update();
|
|
assert.equal(model().show, true);
|
|
assert.equal(heli().show, false, 'the model is the visual');
|
|
assert.ok(
|
|
Math.hypot(
|
|
model().pos.x - heli().pos.x,
|
|
model().pos.y - heli().pos.y,
|
|
model().pos.z - heli().pos.z,
|
|
) < 1,
|
|
'where its icon is',
|
|
);
|
|
const writes = models.writes;
|
|
await layer.update();
|
|
assert.ok(models.writes > writes, 'moved in place each frame');
|
|
|
|
display.models3d = false;
|
|
await layer.update();
|
|
assert.equal(models.items.size, 0, 'models dropped');
|
|
assert.equal(heli().show, true, 'the icon is back');
|
|
});
|
|
|
|
test('markers drop when the position is 60 s old and records when silent 60 s', async (t) => {
|
|
const receiver = fakeReceiver({ mode: 'adsb', connected: true });
|
|
const clock = { now: 100_000 };
|
|
const { layer, draw } = await enabledLayer(receiver, clock);
|
|
t.after(() => layer.destroy());
|
|
receiver.set({
|
|
aircraft: [
|
|
record(),
|
|
record({
|
|
icao: 'def456',
|
|
callsign: ' ',
|
|
lat: null,
|
|
lon: null,
|
|
lastPositionAt: null,
|
|
}),
|
|
],
|
|
});
|
|
await layer.update();
|
|
const entities = () => [...layerSet(draw, ':markers').items.keys()];
|
|
assert.deepEqual(
|
|
entities(),
|
|
['local-adsb:abc123'],
|
|
'only positioned aircraft draw',
|
|
);
|
|
assert.equal(layer.getStats().count, 1);
|
|
|
|
// Still transmitting (no position) but the last position is 60 s old.
|
|
receiver.set({ aircraft: [record({ lastMessageAt: 150_000 })] });
|
|
clock.now = 159_999;
|
|
await layer.update();
|
|
assert.deepEqual(entities(), ['local-adsb:abc123']);
|
|
clock.now = 160_000;
|
|
await layer.update();
|
|
assert.deepEqual(entities(), [], 'a stale position is not drawn');
|
|
assert.deepEqual(layer.getDetectableObjects(), []);
|
|
});
|
|
|
|
test('selecting a marker publishes the readout card and eviction clears it', async (t) => {
|
|
const receiver = fakeReceiver({ mode: 'adsb', connected: true });
|
|
const clock = { now: 100_000 };
|
|
const { layer, calls } = await enabledLayer(receiver, clock);
|
|
t.after(() => layer.destroy());
|
|
receiver.set({ aircraft: [record()] });
|
|
await layer.update();
|
|
const metadata = calls.registered.at(-1);
|
|
assert.equal(metadata.id, 'local-adsb:abc123');
|
|
assert.equal(metadata.layerId, 'local-adsb');
|
|
assert.equal(metadata.properties.icao, 'abc123');
|
|
assert.equal(layer.selectAircraft('abc123'), true);
|
|
assert.deepEqual(calls.selected, ['local-adsb:abc123']);
|
|
assert.equal(layer.selectAircraft('ffffff'), false);
|
|
|
|
clock.now = 200_000;
|
|
await layer.update();
|
|
assert.deepEqual(calls.cleared, [{ layerId: 'local-adsb', evicted: true }]);
|
|
assert.equal(calls.removed.at(-1).layerId, 'local-adsb');
|
|
assert.equal(calls.removed.at(-1).retainIds.size, 0);
|
|
});
|
|
|
|
test('the click card lists identity, kinematics, freshness and the receiver line', () => {
|
|
const card = localAdsbCardModel(
|
|
record({
|
|
icao: 'ae5d8a',
|
|
callsign: 'SHINR42',
|
|
altitudeFt: 1600,
|
|
groundSpeedKt: 129.9,
|
|
trackDeg: 330.5,
|
|
verticalRateFpm: 64,
|
|
lastPositionAt: 96_000,
|
|
messageCount: 48,
|
|
}),
|
|
100_000,
|
|
);
|
|
assert.equal(card.title, 'SHINR42');
|
|
assert.equal(card.accent, '#ff4fd8');
|
|
assert.deepEqual(card.details, [
|
|
'ICAO AE5D8A · SHINR42',
|
|
'ALT 1,600 FT · GS 130 KT · TRK 331°',
|
|
'V/S +64 FPM',
|
|
'POSITION 4 S AGO · 48 MSGS',
|
|
'Heard by your receiver · 1090 MHz · browser SDR',
|
|
]);
|
|
assert.equal(HEARD_BY_RECEIVER, 'Heard by your receiver');
|
|
const bare = localAdsbCardModel(
|
|
record({
|
|
callsign: null,
|
|
altitudeFt: null,
|
|
groundSpeedKt: null,
|
|
trackDeg: null,
|
|
verticalRateFpm: -1_280,
|
|
messageCount: 1,
|
|
}),
|
|
100_000,
|
|
);
|
|
assert.equal(bare.title, 'ABC123');
|
|
assert.deepEqual(bare.details.slice(0, 4), [
|
|
'ICAO ABC123 · NO CALLSIGN',
|
|
'ALT — FT · GS — KT · TRK —',
|
|
'V/S -1,280 FPM',
|
|
'POSITION 0 S AGO · 1 MSG',
|
|
]);
|
|
});
|
|
|
|
test('layer stats guide the operator to the Radio card until ADS-B is streaming', () => {
|
|
const clock = { now: 100_000 };
|
|
const { services } = fakeServices();
|
|
const receiver = fakeReceiver();
|
|
const layer = createLocalAdsbLayer({
|
|
receiver,
|
|
services,
|
|
now: () => clock.now,
|
|
});
|
|
assert.equal(layer.getStats().statusMessage, 'connect a receiver in Radio');
|
|
receiver.set({ connected: true, status: 'streaming', mode: 'fm' });
|
|
assert.equal(layer.getStats().statusMessage, 'receiver is in FM mode');
|
|
receiver.set({
|
|
mode: 'adsb',
|
|
messagesPerSecond: 3.5,
|
|
aircraft: [record(), record({ icao: 'def456', lat: null, lon: null })],
|
|
});
|
|
const stats = layer.getStats();
|
|
assert.equal(stats.count, 1);
|
|
assert.equal(stats.loadingLabel, '2 heard · 3.5 msg/s');
|
|
receiver.set({ status: 'error', message: 'RTL-SDR sample stream stopped' });
|
|
assert.equal(layer.getStats().error, 'RTL-SDR sample stream stopped');
|
|
receiver.set({ status: 'idle', webUsbSupported: false, connected: false });
|
|
assert.equal(
|
|
layer.getStats().statusMessage,
|
|
'WebUSB needs desktop Chrome or Edge',
|
|
);
|
|
});
|
|
|
|
test('the receiver line names every band and source that heard the aircraft', () => {
|
|
const line = (overrides) => localAdsbReceiverLine(record(overrides));
|
|
assert.equal(line({}), 'Heard by your receiver · 1090 MHz · browser SDR');
|
|
assert.equal(
|
|
line({ band: '1090', source: 'feed' }),
|
|
'Heard by your receiver · 1090 MHz · decoder feed',
|
|
);
|
|
assert.equal(
|
|
line({ band: '978', source: 'feed' }),
|
|
'Heard by your receiver · 978 MHz UAT · decoder feed',
|
|
);
|
|
assert.equal(
|
|
line({ bands: ['1090', '978'], sources: ['feed'] }),
|
|
'Heard by your receiver · 1090 MHz + 978 MHz UAT · decoder feed',
|
|
);
|
|
assert.equal(
|
|
line({ bands: ['1090'], sources: ['webusb', 'feed'] }),
|
|
'Heard by your receiver · 1090 MHz · browser SDR + decoder feed',
|
|
);
|
|
assert.equal(
|
|
line({ bands: ['1090', '978'], sources: ['webusb', 'feed'] }),
|
|
'Heard by your receiver · 1090 MHz + 978 MHz UAT · browser SDR + decoder feed',
|
|
);
|
|
assert.equal(
|
|
localAdsbReceiverLine({ icao: 'abc123' }),
|
|
HEARD_BY_RECEIVER,
|
|
'a record without band or source keeps the plain line',
|
|
);
|
|
});
|
|
|
|
test('feed records merge with browser SDR records by ICAO and UAT-only aircraft get a ring', async (t) => {
|
|
const receiver = fakeReceiver({ mode: 'adsb', connected: true });
|
|
const feeds = fakeFeeds();
|
|
const clock = { now: 100_000 };
|
|
const { layer, draw, calls } = await enabledLayer(receiver, clock, feeds);
|
|
t.after(() => layer.destroy());
|
|
assert.deepEqual(feeds.calls, ['start'], 'the feeds poll while enabled');
|
|
|
|
receiver.set({ aircraft: [record({ lastPositionAt: 98_000 })] });
|
|
feeds.set({
|
|
configured: true,
|
|
feeds: [{ band: '978', label: '978 MHz UAT', status: 'live' }],
|
|
records: [
|
|
record({ lat: 1, band: '978', source: 'feed', lastPositionAt: 99_000 }),
|
|
record({
|
|
icao: 'a1b2c3',
|
|
callsign: 'N978UA',
|
|
band: '978',
|
|
source: 'feed',
|
|
}),
|
|
],
|
|
});
|
|
await layer.update();
|
|
const shared = calls.carriers.get('local-adsb:abc123');
|
|
const uat = calls.carriers.get('local-adsb:a1b2c3');
|
|
assert.equal(layerSet(draw, ':markers').items.size, 2);
|
|
assert.ok(
|
|
Math.abs(latitudeOf(draw, 'local-adsb:abc123') - 1) < 0.002,
|
|
'the newer feed position wins',
|
|
);
|
|
assert.equal(
|
|
ringOf(draw, 'local-adsb:abc123'),
|
|
undefined,
|
|
'heard on 1090 too: no UAT ring',
|
|
);
|
|
assert.equal(
|
|
readEntityRecord(shared)?.labelModel.details.at(-1),
|
|
'Heard by your receiver · 1090 MHz + 978 MHz UAT · browser SDR + decoder feed',
|
|
);
|
|
const ring = ringOf(draw, 'local-adsb:a1b2c3');
|
|
assert.ok(ring, 'a UAT-only aircraft carries the ring');
|
|
assert.equal(ring.outlineWidth, 1.5);
|
|
assert.deepEqual(ring.color, [0, 0, 0, 0]);
|
|
assert.deepEqual(ring.outlineColor, hexColor('#ffb3ef'));
|
|
assert.deepEqual(
|
|
ring.displayRange,
|
|
[0, 2_000_000],
|
|
'shown within 2,000 km, as its aircraft is',
|
|
);
|
|
assert.deepEqual(ring.pos, iconOf(draw, 'local-adsb:a1b2c3').pos);
|
|
assert.equal(layerSet(draw, ':rings').spec.horizonCull, true);
|
|
assert.deepEqual(
|
|
iconOf(draw, 'local-adsb:a1b2c3').color,
|
|
MAGENTA,
|
|
'same magenta marker family',
|
|
);
|
|
assert.equal(
|
|
readEntityRecord(uat)?.labelModel.details.at(-1),
|
|
'Heard by your receiver · 978 MHz UAT · decoder feed',
|
|
);
|
|
const stats = layer.getStats();
|
|
assert.equal(stats.source, 'WebUSB + decoder feeds');
|
|
assert.equal(stats.loadingLabel, '1 feed live · 2 heard');
|
|
assert.equal(stats.count, 2);
|
|
|
|
// Heard on 1090 as well later: the ring goes.
|
|
feeds.set({
|
|
records: [
|
|
record({
|
|
icao: 'a1b2c3',
|
|
callsign: 'N978UA',
|
|
band: '1090',
|
|
source: 'feed',
|
|
}),
|
|
],
|
|
});
|
|
await layer.update();
|
|
assert.equal(ringOf(draw, 'local-adsb:a1b2c3'), undefined);
|
|
|
|
await layer.disable();
|
|
assert.deepEqual(feeds.calls, ['start', 'stop']);
|
|
assert.equal(layerSet(draw, ':markers').show, false, 'hidden with the layer');
|
|
});
|
|
|
|
test('the layer draws into sets of its own, shown while it is enabled and let go when destroyed', async (t) => {
|
|
const receiver = fakeReceiver({ mode: 'adsb', connected: true });
|
|
const feeds = fakeFeeds();
|
|
const clock = { now: 100_000 };
|
|
const first = fakeViewer();
|
|
const { layer, draw } = await enabledLayer(receiver, clock, feeds, {
|
|
viewer: first,
|
|
});
|
|
const other = await enabledLayer(fakeReceiver(), clock);
|
|
t.after(() => other.layer.destroy());
|
|
const ids = (port) =>
|
|
[...port.sets.values()]
|
|
.filter((record) => !record.disposed)
|
|
.map((record) => record.spec.id);
|
|
const mine = ids(draw);
|
|
assert.equal(mine.length, 3, 'markers, rings and models');
|
|
assert.ok(
|
|
ids(other.draw).every((id) => !mine.includes(id)),
|
|
'a second layer has ids of its own',
|
|
);
|
|
for (const id of mine) assert.equal(draw.set(id).show, true, id);
|
|
|
|
feeds.set({
|
|
configured: true,
|
|
records: [record({ icao: 'a1b2c3', band: '978', source: 'feed' })],
|
|
});
|
|
await layer.update();
|
|
assert.ok(ringOf(draw, 'local-adsb:a1b2c3'));
|
|
// Silent long enough to expire: its ring goes with it.
|
|
clock.now = 200_000;
|
|
await layer.update();
|
|
assert.equal(iconOf(draw, 'local-adsb:a1b2c3'), undefined);
|
|
assert.equal(ringOf(draw, 'local-adsb:a1b2c3'), undefined);
|
|
|
|
await layer.disable();
|
|
for (const id of mine) assert.equal(draw.set(id).show, false, id);
|
|
await layer.enable();
|
|
for (const id of mine) assert.equal(draw.set(id).show, true, id);
|
|
layer.destroy();
|
|
assert.deepEqual(ids(draw), [], 'every set disposed');
|
|
});
|
|
|
|
test('row status reflects decoder feeds and the browser SDR together', () => {
|
|
const idle = {
|
|
webUsbSupported: true,
|
|
connected: false,
|
|
mode: 'fm',
|
|
status: 'idle',
|
|
};
|
|
const usb = {
|
|
...idle,
|
|
connected: true,
|
|
mode: 'adsb',
|
|
status: 'streaming',
|
|
messagesPerSecond: 3.5,
|
|
};
|
|
const feedState = (...statuses) => ({
|
|
configured: true,
|
|
polling: true,
|
|
feeds: statuses.map(([band, status]) => ({
|
|
band,
|
|
label: band,
|
|
status,
|
|
})),
|
|
});
|
|
const status = (receiver, feeds, heard = 14) =>
|
|
localAdsbStatus({ receiver, feedState: feeds, heard });
|
|
|
|
// No feeds configured: the WebUSB statuses are unchanged.
|
|
assert.deepEqual(status(idle, null), {
|
|
source: 'RTL-SDR · WebUSB',
|
|
status: 'idle',
|
|
statusMessage: 'connect a receiver in Radio',
|
|
});
|
|
assert.deepEqual(
|
|
status(idle, { configured: false, feeds: [], polling: false }),
|
|
status(idle, null),
|
|
);
|
|
assert.equal(status(usb, null).loadingLabel, '14 heard · 3.5 msg/s');
|
|
assert.equal(
|
|
status(idle, { configured: null, polling: true, feeds: [] }).loadingLabel,
|
|
'checking decoder feeds',
|
|
);
|
|
|
|
let stats = status(idle, feedState(['1090', 'live'], ['978', 'live']));
|
|
assert.deepEqual(stats, {
|
|
source: 'Decoder feeds',
|
|
status: 'streaming',
|
|
loadingLabel: '2 feeds live · 14 heard',
|
|
});
|
|
stats = status(usb, feedState(['978', 'live']));
|
|
assert.equal(stats.source, 'WebUSB + decoder feeds');
|
|
assert.equal(stats.loadingLabel, '1 feed live · 14 heard · USB 3.5 msg/s');
|
|
|
|
// A live feed keeps the row nominal; the unreachable one is a trailing note.
|
|
stats = status(idle, feedState(['1090', 'live'], ['978', 'unreachable']), 9);
|
|
assert.deepEqual(stats, {
|
|
source: 'Decoder feeds',
|
|
status: 'streaming',
|
|
loadingLabel: '9 heard · feed 978 unreachable',
|
|
});
|
|
assert.equal(layerFeedState(stats), 'nominal');
|
|
|
|
stats = status(idle, feedState(['978', 'unreachable']), 0);
|
|
assert.equal(stats.status, 'error');
|
|
assert.equal(stats.error, 'feed 978 unreachable');
|
|
stats = status(
|
|
usb,
|
|
feedState(['1090', 'stale'], ['978', 'stale'], ['1090', 'invalid']),
|
|
);
|
|
assert.equal(stats.status, 'streaming');
|
|
assert.equal(stats.degraded, undefined);
|
|
assert.equal(layerFeedState(stats), 'nominal');
|
|
assert.equal(
|
|
stats.loadingLabel,
|
|
'14 heard · USB 3.5 msg/s · feeds 1090 #1, 978 stale · feed 1090 #2 invalid',
|
|
);
|
|
});
|
|
|
|
test('a stale decoder feed does not mark a streaming browser receiver degraded', () => {
|
|
// Owner field test: dump1090 stopped so the browser could take the dongle.
|
|
const stats = localAdsbStatus({
|
|
receiver: {
|
|
webUsbSupported: true,
|
|
connected: true,
|
|
mode: 'adsb',
|
|
status: 'streaming',
|
|
messagesPerSecond: 5.8,
|
|
},
|
|
feedState: {
|
|
configured: true,
|
|
polling: true,
|
|
feeds: [{ band: '1090', label: '1090 MHz', status: 'stale' }],
|
|
},
|
|
heard: 3,
|
|
});
|
|
assert.deepEqual(stats, {
|
|
source: 'WebUSB + decoder feeds',
|
|
status: 'streaming',
|
|
loadingLabel: '3 heard · USB 5.8 msg/s · feed 1090 stale',
|
|
});
|
|
assert.equal(layerFeedState(stats), 'nominal');
|
|
});
|
|
|
|
test('a browser receiver error beside a live feed is a note on a nominal row', () => {
|
|
const stats = localAdsbStatus({
|
|
receiver: {
|
|
webUsbSupported: true,
|
|
connected: true,
|
|
mode: 'adsb',
|
|
status: 'error',
|
|
message: 'RTL-SDR sample stream stopped',
|
|
},
|
|
feedState: {
|
|
configured: true,
|
|
polling: true,
|
|
feeds: [{ band: '978', label: '978 MHz UAT', status: 'live' }],
|
|
},
|
|
heard: 2,
|
|
});
|
|
assert.equal(stats.status, 'streaming');
|
|
assert.equal(layerFeedState(stats), 'nominal');
|
|
assert.equal(stats.loadingLabel, '2 heard · USB error');
|
|
});
|
|
|
|
test('every feed stale reads STALE, not an error; unreachable stays an error', () => {
|
|
const idle = {
|
|
webUsbSupported: true,
|
|
connected: false,
|
|
mode: 'fm',
|
|
status: 'idle',
|
|
};
|
|
const feedState = (...feeds) => ({
|
|
configured: true,
|
|
polling: true,
|
|
feeds: feeds.map(([band, status, label = band]) => ({
|
|
band,
|
|
label,
|
|
status,
|
|
})),
|
|
});
|
|
const status = (feeds, heard = 3) =>
|
|
localAdsbStatus({ receiver: idle, feedState: feeds, heard });
|
|
|
|
// A decoder that stopped but still serves its last aircraft.json.
|
|
let stats = status(feedState(['1090', 'stale'], ['978', 'stale']));
|
|
assert.equal(stats.status, 'stale');
|
|
assert.equal(stats.error, undefined);
|
|
assert.equal(layerFeedState(stats), 'stale');
|
|
assert.equal(stats.statusMessage, 'feeds 1090, 978 stale · 3 heard');
|
|
|
|
// An invalid entry is a configuration note, not a reason to fail the row.
|
|
stats = status(feedState(['1090', 'stale'], ['978', 'invalid']), 0);
|
|
assert.equal(layerFeedState(stats), 'stale');
|
|
|
|
stats = status(feedState(['1090', 'stale'], ['978', 'unreachable']), 0);
|
|
assert.equal(stats.status, 'error');
|
|
assert.equal(layerFeedState(stats), 'unavailable');
|
|
stats = status(feedState(['978', 'invalid']), 0);
|
|
assert.equal(stats.status, 'error');
|
|
});
|
|
|
|
test('row status names two same-band feeds by their ordinal labels', () => {
|
|
const stats = localAdsbStatus({
|
|
receiver: {
|
|
webUsbSupported: true,
|
|
connected: false,
|
|
mode: 'fm',
|
|
status: 'idle',
|
|
},
|
|
feedState: {
|
|
configured: true,
|
|
polling: true,
|
|
feeds: [
|
|
{ band: '978', label: '978 MHz UAT #1', status: 'live' },
|
|
{ band: '978', label: '978 MHz UAT #2', status: 'unreachable' },
|
|
{ band: '1090', label: '1090 MHz', status: 'unreachable' },
|
|
],
|
|
},
|
|
heard: 4,
|
|
});
|
|
assert.equal(
|
|
stats.loadingLabel,
|
|
'4 heard · feeds 978 MHz UAT #2, 1090 unreachable',
|
|
);
|
|
});
|
|
|
|
test('the last aircraft expiring removes its 3D model', async (t) => {
|
|
const receiver = fakeReceiver({ mode: 'adsb', connected: true });
|
|
const clock = { now: 100_000 };
|
|
const { layer, draw } = await enabledLayer(receiver, clock, null, {
|
|
services: {
|
|
display: {
|
|
getParams: () => ({ models3d: true, models3dMode: 'proximity' }),
|
|
},
|
|
},
|
|
viewer: modelViewer(),
|
|
});
|
|
t.after(() => layer.destroy());
|
|
receiver.set({ aircraft: [record({ category: 'A7' })] });
|
|
await layer.update();
|
|
const models = layerSet(draw, ':models');
|
|
assert.ok(models.items.has('local-adsb:abc123'));
|
|
|
|
// Its position ages out: no markers remain, so no per-frame model pass.
|
|
clock.now = 160_000;
|
|
await layer.update();
|
|
assert.equal(models.items.size, 0, 'no model left behind');
|
|
|
|
layer.destroy();
|
|
assert.equal(models.disposed, true, 'the set goes with the layer');
|
|
});
|
|
|
|
/** A pick on a draw-port icon of the layer's, as the renderer reports it. */
|
|
function iconPick(draw, id) {
|
|
return { primitive: {}, id: { set: layerSet(draw, ':markers').spec.id, id } };
|
|
}
|
|
|
|
/** A viewer with a canvas and scripted picks, plus the layer's click action. */
|
|
function clickHarness() {
|
|
const scene = {
|
|
canvas: {},
|
|
pickResult: null,
|
|
pick() {
|
|
return scene.pickResult;
|
|
},
|
|
};
|
|
const base = fakeViewer({ scene });
|
|
return {
|
|
scene,
|
|
viewer: base,
|
|
click() {
|
|
base.input.click(new Cesium.Cartesian2(10, 10));
|
|
},
|
|
};
|
|
}
|
|
|
|
test('clicking the selected aircraft keeps it selected and republishes its card', async (t) => {
|
|
const receiver = fakeReceiver({ mode: 'adsb', connected: true });
|
|
const clock = { now: 100_000 };
|
|
const harness = clickHarness();
|
|
const { layer, calls, draw } = await enabledLayer(receiver, clock, null, {
|
|
viewer: harness.viewer,
|
|
});
|
|
t.after(() => layer.destroy());
|
|
receiver.set({ aircraft: [record()] });
|
|
await layer.update();
|
|
harness.scene.pickResult = iconPick(draw, 'local-adsb:abc123');
|
|
harness.click();
|
|
assert.deepEqual(calls.selected, ['local-adsb:abc123']);
|
|
// Its card may have been displaced (another readout, a camera move): a
|
|
// second click on the same marker must show it again, never deselect it.
|
|
harness.click();
|
|
assert.deepEqual(calls.selected, ['local-adsb:abc123', 'local-adsb:abc123']);
|
|
assert.deepEqual(calls.cleared, []);
|
|
});
|
|
|
|
test('a click on a local aircraft under an unowned or trail pick still selects it', async (t) => {
|
|
const receiver = fakeReceiver({ mode: 'adsb', connected: true });
|
|
const clock = { now: 100_000 };
|
|
const harness = clickHarness();
|
|
const owners = new Map();
|
|
const { layer, calls, draw } = await enabledLayer(receiver, clock, null, {
|
|
viewer: harness.viewer,
|
|
services: {
|
|
picking: {
|
|
registerPickOwner: (id, predicate) => owners.set(id, predicate),
|
|
unregisterPickOwner: (id) => owners.delete(id),
|
|
resolvePickId,
|
|
isOwnedByOtherLayer: (layerId, pickedId) =>
|
|
[...owners].some(
|
|
([owner, predicate]) => owner !== layerId && predicate(pickedId),
|
|
),
|
|
},
|
|
},
|
|
});
|
|
owners.set('trails', (id) => String(id).startsWith('gev-trail:'));
|
|
owners.set('flights', (id) => id === 'abc123');
|
|
t.after(() => layer.destroy());
|
|
receiver.set({
|
|
aircraft: [record(), record({ icao: 'def456', lat: 0.01 })],
|
|
});
|
|
await layer.update();
|
|
const hit = (suffix, id) => ({
|
|
set: suffix.startsWith(':') ? layerSet(draw, suffix).spec.id : suffix,
|
|
id,
|
|
surface: false,
|
|
});
|
|
const second = hit(':markers', 'local-adsb:def456');
|
|
// A photoreal tile (no pick id) drawn over the 3D model at this pixel.
|
|
harness.scene.pickResult = { primitive: { tileset: true } };
|
|
harness.viewer.viewer.drillHits = [hit(':models', 'local-adsb:abc123')];
|
|
harness.click();
|
|
assert.deepEqual(calls.selected, ['local-adsb:abc123']);
|
|
|
|
// The selected aircraft's trail crosses another local aircraft's marker.
|
|
const trail = hit('trail:1', 'gev-trail:1:head');
|
|
harness.scene.pickResult = { primitive: {}, id: trail };
|
|
harness.viewer.viewer.drillHits = [trail, second];
|
|
harness.click();
|
|
assert.deepEqual(calls.selected, ['local-adsb:abc123', 'local-adsb:def456']);
|
|
|
|
// Another layer's own contact on top is that layer's click.
|
|
harness.scene.pickResult = { id: 'abc123', primitive: {} };
|
|
harness.viewer.viewer.drillHits = [hit(':markers', 'local-adsb:abc123')];
|
|
harness.click();
|
|
assert.equal(calls.selected.length, 2, 'the Flights contact is not taken');
|
|
});
|
|
|
|
test('a grounded aircraft changing type keeps its drawn model on its own belly offset until the new one is ready', () => {
|
|
const { draw, viewer, camera } = modelViewer();
|
|
const models = createLocalAdsbModels({
|
|
viewer,
|
|
draw,
|
|
camera: camera.port,
|
|
setId: 'test:models',
|
|
color: '#ff00ff',
|
|
resolveAsset: (url) => url,
|
|
groundSnap: { heightFor: () => 100, forget() {}, clear() {} },
|
|
});
|
|
const marker = {
|
|
position: fromDegrees(0, 0, 0),
|
|
courseDeg: 0,
|
|
typeCode: 'C172',
|
|
onGround: true,
|
|
};
|
|
const markers = new Map([['a', marker]]);
|
|
const display = { models3d: true, models3dMode: 'proximity' };
|
|
const light = 100 + aircraftLayerModelSpec({ typeCode: 'C172' }).bellyM;
|
|
const widebody = 100 + aircraftLayerModelSpec({ typeCode: 'B789' }).bellyM;
|
|
const height = () =>
|
|
toLonLatH(draw.sets.get('test:models').items.get('a').pos).height;
|
|
models.frame(markers, display, 100_000);
|
|
draw.ready('test:models', 'a');
|
|
models.frame(markers, display, 100_001);
|
|
assert.ok(Math.abs(height() - light) < 0.01, 'light: its belly offset');
|
|
marker.typeCode = 'B789';
|
|
models.frame(markers, display, 200_000);
|
|
assert.equal(
|
|
draw.sets.get('test:models').items.get('a').url,
|
|
'/models/fleet/aircraft/b789.glb',
|
|
);
|
|
assert.ok(Math.abs(height() - light) < 0.01, 'the light model still draws');
|
|
draw.ready('test:models', 'a');
|
|
models.frame(markers, display, 200_001);
|
|
assert.ok(Math.abs(height() - widebody) < 0.01, 'the widebody, on its own');
|
|
models.destroy();
|
|
});
|
|
|
|
test('a type change takes its belly offset with the new model, however soon it is ready; a scale-only change at once', () => {
|
|
const { draw, viewer, camera } = modelViewer();
|
|
const models = createLocalAdsbModels({
|
|
viewer,
|
|
draw,
|
|
camera: camera.port,
|
|
setId: 'test:models',
|
|
color: '#ff00ff',
|
|
resolveAsset: (url) => url,
|
|
groundSnap: { heightFor: () => 100, forget() {}, clear() {} },
|
|
});
|
|
const marker = {
|
|
position: fromDegrees(0, 0, 0),
|
|
courseDeg: 0,
|
|
typeCode: 'A320',
|
|
onGround: true,
|
|
};
|
|
const markers = new Map([['a', marker]]);
|
|
const display = { models3d: true, models3dMode: 'proximity' };
|
|
const bellyOf = (typeCode) =>
|
|
100 + aircraftLayerModelSpec({ typeCode }).bellyM;
|
|
const item = () => draw.sets.get('test:models').items.get('a');
|
|
const height = () => toLonLatH(item().pos).height;
|
|
models.frame(markers, display, 100_000);
|
|
draw.ready('test:models', 'a');
|
|
models.frame(markers, display, 100_001);
|
|
assert.ok(Math.abs(height() - bellyOf('A320')) < 0.01, 'A320');
|
|
// The same model at another length: no load, no ready.
|
|
marker.typeCode = 'A321';
|
|
models.frame(markers, display, 100_002);
|
|
assert.equal(item().url, '/models/fleet/aircraft/a320.glb');
|
|
assert.equal(
|
|
item().scale,
|
|
aircraftLayerModelSpec({ typeCode: 'A321' }).scale,
|
|
);
|
|
assert.ok(Math.abs(height() - bellyOf('A321')) < 0.01, 'at once');
|
|
// Another model, ready before the next eligibility pass.
|
|
marker.typeCode = 'B789';
|
|
models.frame(markers, display, 100_003);
|
|
assert.ok(Math.abs(height() - bellyOf('A321')) < 0.01, 'the old model draws');
|
|
draw.ready('test:models', 'a');
|
|
models.frame(markers, display, 100_004);
|
|
assert.ok(
|
|
Math.abs(height() - bellyOf('B789')) < 0.01,
|
|
'the widebody, on its own',
|
|
);
|
|
models.destroy();
|
|
});
|
|
|
|
test('a double-click follows a local aircraft with its card, until it goes, as its entity was', async (t) => {
|
|
const { bindRenderer } = await import('../../render/rendererOf.js');
|
|
const { createStubRenderer } = await import('../../render/stub/index.js');
|
|
const { followedOf } = await import('../../data/followed.js');
|
|
const renderer = createStubRenderer();
|
|
const viewer = { isDestroyed: () => false };
|
|
const unbind = bindRenderer(viewer, renderer);
|
|
const receiver = fakeReceiver({ mode: 'adsb', connected: true });
|
|
const clock = { now: 100_000 };
|
|
const { layer } = await enabledLayer(receiver, clock, null, {
|
|
viewer: { viewer, draw: renderer.draw },
|
|
});
|
|
t.after(() => {
|
|
layer.destroy();
|
|
unbind();
|
|
renderer.destroy();
|
|
});
|
|
receiver.set({ aircraft: [record()] });
|
|
await layer.update();
|
|
const set = renderer.testing.sets().find((id) => id.endsWith(':markers'));
|
|
renderer.testing.scriptPicks(() => [
|
|
{ set, id: 'local-adsb:abc123', surface: false },
|
|
]);
|
|
renderer.testing.pointer('dblclick', 10, 10);
|
|
const followed = followedOf(viewer);
|
|
assert.ok(followed, 'the aircraft is followed');
|
|
assert.equal(followed.key, 'local-adsb:abc123');
|
|
assert.ok(followed.entity, 'its entity record shows the tracked card');
|
|
assert.equal(typeof followed.displayPosition, 'function');
|
|
assert.ok(followed.labelModel?.title, 'with its card');
|
|
receiver.set({ aircraft: [] });
|
|
clock.now += 10 * 60_000;
|
|
await layer.update();
|
|
assert.equal(followedOf(viewer), null, 'gone, it is no longer followed');
|
|
});
|
|
|
|
test('a click on a UAT ring selects its aircraft, as the ring was a point on its entity', async (t) => {
|
|
const receiver = fakeReceiver({ mode: 'adsb', connected: true });
|
|
const feeds = fakeFeeds();
|
|
const clock = { now: 100_000 };
|
|
const harness = clickHarness();
|
|
const { layer, calls, draw } = await enabledLayer(receiver, clock, feeds, {
|
|
viewer: harness.viewer,
|
|
});
|
|
t.after(() => layer.destroy());
|
|
feeds.set({
|
|
configured: true,
|
|
feeds: [{ band: '978', label: '978 MHz UAT', status: 'live' }],
|
|
records: [record({ icao: 'a1b2c3', band: '978', source: 'feed' })],
|
|
});
|
|
await layer.update();
|
|
const rings = layerSet(draw, ':rings');
|
|
assert.notEqual(rings.spec.pickable, false, 'the rings are picked');
|
|
assert.notEqual(ringOf(draw, 'local-adsb:a1b2c3').pickable, false);
|
|
harness.scene.pickResult = {
|
|
primitive: {},
|
|
id: { set: rings.spec.id, id: 'local-adsb:a1b2c3' },
|
|
};
|
|
harness.click();
|
|
assert.deepEqual(calls.selected, ['local-adsb:a1b2c3']);
|
|
});
|