Compare commits

..
Author SHA1 Message Date
Sameh Khamis 0a0c6a0e5b Vessel playback moves icons on the renderer's clock
While the timeline plays or is scrubbed, each vessel icon is handed to the
renderer as a motion segment along its track (a straight piece of at most
10 km between two fixes, on the scene clock), as aircraft already are. The
layer writes an icon again only when its segment runs out or the time
moves back before it, instead of moving every icon on the CPU every frame.

Behaviour is kept:
- Icons follow the same great-circle track between fixes (a 10 km chord
  stays within 2 m of it) with the same course.
- A vessel still appears TIMELINE_UNSEEN_MS before its first fix and
  hides again when the time moves back before that.
- Cards, the selected vessel, ship models and the vessel the bridge camera
  rides are read where they are every frame; the rest within
  HIDDEN_FOLLOW_MS, as before.
- Position reads (getAllPositions, getNearby, the focus pass, the
  detection overlay, single-vessel lookups) return where the icon is drawn
  at the world time.
- Going live, each icon holds where its segment last drew it, unless a
  live update has drawn it since.
- Trails are unchanged: they are built from the feed's fixes, not from the
  per-frame position.
- Live mode and renderers without the motionSegments capability take the
  previous path unchanged.
2026-11-15 23:56:03 -08:00
7 changed files with 746 additions and 21 deletions

No files matched your search

+85 -1
View File
@@ -54,10 +54,94 @@ export function vesselPositionAt(record, tMs) {
} }
const RAD = Math.PI / 180; const RAD = Math.PI / 180;
/** The mean Earth radius (metres) a span's length is judged on. */
const EARTH_RADIUS_M = 6371008.8;
/**
* The stretch of a vessel's track around world time `tMs`, as
* vesselPositionAt draws it: between the last fix at or before the time and
* the next one (`move`, which always ends after `tMs`), or where it holds
* still (`hold`) before its first fix, after its last, or around a record's
* one move; from when (`fromMs`) until when (`untilMs`) the answer holds.
* Null for a vessel the clock never moves (no fixes and no move).
* @param {object} record
* @param {number} tMs
* @returns {{kind: 'move', lat0: number, lon0: number, t0: number,
* lat1: number, lon1: number, t1: number, metres: number}|
* {kind: 'hold', lat: number, lon: number, fromMs: number,
* untilMs: number}|null}
*/
export function vesselSpanAt(record, tMs) {
if (!Number.isFinite(tMs)) return null;
const fixes = record?.fixes;
if (fixes?.length >= 2) {
const first = fixes[0];
const last = fixes[fixes.length - 1];
if (tMs < first.atMs)
return hold(first.lat, first.lon, -Infinity, first.atMs);
if (tMs >= last.atMs) return hold(last.lat, last.lon, last.atMs, Infinity);
// The first fix after the time: the one before it is at or before it.
let low = 1;
let high = fixes.length - 1;
while (low < high) {
const mid = (low + high) >> 1;
if (fixes[mid].atMs <= tMs) low = mid + 1;
else high = mid;
}
const a = fixes[low - 1];
const b = fixes[low];
return move(a.lat, a.lon, a.atMs, b.lat, b.lon, b.atMs);
}
const motion = record?.motion;
if (!motion || !(motion.toMs > motion.fromMs)) return null;
if (tMs < motion.fromMs)
return hold(motion.fromLat, motion.fromLon, -Infinity, motion.fromMs);
if (tMs >= motion.toMs)
return hold(record.lat, record.lon, motion.toMs, Infinity);
return move(
motion.fromLat,
motion.fromLon,
motion.fromMs,
motion.toLat,
motion.toLon,
motion.toMs,
);
}
const hold = (lat, lon, fromMs, untilMs) => ({
kind: 'hold',
lat,
lon,
fromMs,
untilMs,
});
function move(lat0, lon0, t0, lat1, lon1, t1) {
return {
kind: 'move',
lat0,
lon0,
t0,
lat1,
lon1,
t1,
metres: greatCircleAngle(lat0, lon0, lat1, lon1) * EARTH_RADIUS_M,
};
}
/** The angle (radians) between two positions, seen from the Earth's centre. */
function greatCircleAngle(lat1, lon1, lat2, lon2) {
const phi1 = lat1 * RAD;
const phi2 = lat2 * RAD;
const s =
Math.sin((phi2 - phi1) / 2) ** 2 +
Math.cos(phi1) * Math.cos(phi2) * Math.sin(((lon2 - lon1) * RAD) / 2) ** 2;
return 2 * Math.asin(Math.min(1, Math.sqrt(s)));
}
/** The point `fraction` of the way from one position to another. It runs /** The point `fraction` of the way from one position to another. It runs
* for every drawn vessel as the clock plays, so it builds no arrays. */ * for every drawn vessel as the clock plays, so it builds no arrays. */
function greatCircleAt(lat1, lon1, lat2, lon2, fraction) { export function greatCircleAt(lat1, lon1, lat2, lon2, fraction) {
const phi1 = lat1 * RAD; const phi1 = lat1 * RAD;
const lambda1 = lon1 * RAD; const lambda1 = lon1 * RAD;
const phi2 = lat2 * RAD; const phi2 = lat2 * RAD;
+79 -1
View File
@@ -1,6 +1,11 @@
import test from 'node:test'; import test from 'node:test';
import assert from 'node:assert/strict'; import assert from 'node:assert/strict';
import { fixesMove, vesselPositionAt } from './motion.js'; import {
fixesMove,
greatCircleAt,
vesselPositionAt,
vesselSpanAt,
} from './motion.js';
const record = { const record = {
lat: 1, lat: 1,
@@ -61,3 +66,76 @@ test('fixes that stay in one place do not move a vessel', () => {
); );
assert.equal(fixesMove(null), false); assert.equal(fixesMove(null), false);
}); });
const fixes = [
{ atMs: 1_000, lat: 0, lon: 0 },
{ atMs: 2_000, lat: 0, lon: 1 },
{ atMs: 3_000, lat: 1, lon: 1 },
];
test('vesselSpanAt holds at the first fix before it, until it', () => {
assert.deepEqual(vesselSpanAt({ fixes }, 500), {
kind: 'hold',
lat: 0,
lon: 0,
fromMs: -Infinity,
untilMs: 1_000,
});
});
test('vesselSpanAt runs from the fix at or before the time to the next, ending after it', () => {
for (const [atMs, t0, t1] of [
[1_000, 1_000, 2_000],
[1_999, 1_000, 2_000],
[2_000, 2_000, 3_000],
[2_500, 2_000, 3_000],
]) {
const span = vesselSpanAt({ fixes }, atMs);
assert.equal(span.kind, 'move');
assert.deepEqual([span.t0, span.t1], [t0, t1], `at ${atMs}`);
assert.ok(span.t1 > atMs);
}
// A degree of longitude on the equator.
assert.ok(Math.abs(vesselSpanAt({ fixes }, 1_500).metres - 111_195) < 10);
});
test('vesselSpanAt holds at the last fix from it on', () => {
assert.deepEqual(vesselSpanAt({ fixes }, 3_000), {
kind: 'hold',
lat: 1,
lon: 1,
fromMs: 3_000,
untilMs: Infinity,
});
});
test("vesselSpanAt follows a record's one move, and nothing for none", () => {
assert.equal(vesselSpanAt(record, 500).untilMs, 1_000);
const span = vesselSpanAt(record, 1_500);
assert.equal(span.kind, 'move');
assert.deepEqual([span.lat0, span.lat1], [0, 1]);
assert.deepEqual(vesselSpanAt(record, 9_000), {
kind: 'hold',
lat: 1,
lon: 1,
fromMs: record.motion.toMs,
untilMs: Infinity,
});
assert.equal(vesselSpanAt({ lat: 1, lon: 1 }, 1_500), null);
});
test('vesselSpanAt agrees with vesselPositionAt along the span', () => {
for (const atMs of [1_000, 1_250, 2_000, 2_750]) {
const span = vesselSpanAt({ fixes }, atMs);
const at = greatCircleAt(
span.lat0,
span.lon0,
span.lat1,
span.lon1,
(atMs - span.t0) / (span.t1 - span.t0),
);
const expected = vesselPositionAt({ fixes }, atMs);
assert.ok(Math.abs(at.lat - expected.lat) < 1e-9);
assert.ok(Math.abs(at.lon - expected.lon) < 1e-9);
}
});
+284
View File
@@ -0,0 +1,284 @@
import test from 'node:test';
import assert from 'node:assert/strict';
import * as Cesium from 'cesium';
import { createVesselLayer } from './index.js';
import { bindFakeCesiumScene } from '../../testSupport/fakeCesiumScene.mjs';
// Following the world clock on a renderer that moves icons along motion
// segments on its own clock, each vessel's icon is drawn along its track
// between two fixes, and the layer draws it again only when that runs out.
const noop = () => {};
function setup(t, { capabilities = new Set(['motionSegments']) } = {}) {
const originalDocument = globalThis.document;
globalThis.document = { getElementById: () => null };
t.after(() => {
if (originalDocument === undefined) delete globalThis.document;
else globalThis.document = originalDocument;
});
const layer = createVesselLayer({
source: { getSnapshot: async () => ({ records: [] }) },
services: {
context: {
clearSelectedEntityContextForLayer: noop,
registerEntityContext: () => null,
},
trails: {
createTrail: () => ({ setPositions: noop, clear: noop, destroy: noop }),
},
labels: { formatKnots: (knots) => `${knots} kt` },
picking: { unregisterPickOwner: noop },
overlay: {
setOverlayEntries: noop,
setOverlaySourceVisible: noop,
clearOverlaySource: noop,
},
geoid: {},
sprites: {},
focus: {
focusNowMs: () => 0,
getFocusTarget: () => null,
focusPassIsNeeded: () => false,
forgetSpriteFocus: noop,
},
worldFocus: {},
render: {
holdContinuousRender: noop,
releaseContinuousRender: noop,
governorRequestRender: noop,
},
},
});
const camera = {
positionWC: { x: 0, y: 0, z: 7_000_000 },
heading: 0,
pitch: -1.2,
roll: 0,
};
const viewer = { camera, scene: {} };
const { draw } = bindFakeCesiumScene(viewer, { capabilities });
layer.testing._setVesselStateForTest({ viewer, icons: null });
layer.testing._setAisRuntimeForTest({
now: () => 0,
setTimeout: () => 0,
clearTimeout: noop,
});
const icons = () =>
[...draw.sets.values()].find(
(record) => record.kind === 'icons' && !record.disposed,
);
return { layer, viewer, icons };
}
const T = 1_000_000;
/** Northbound off Rotterdam, a fix a minute (about 1.1 km apart). */
const row = (fixes) => ({
mmsi: '111',
lat: fixes.at(-1).lat,
lon: fixes.at(-1).lon,
last_position_epoch: fixes.at(-1).atMs / 1000,
fixes,
});
const minuteFixes = [
{ atMs: T, lat: 51.93, lon: 4.05 },
{ atMs: T + 60_000, lat: 51.94, lon: 4.05 },
{ atMs: T + 120_000, lat: 51.95, lon: 4.05 },
];
test('following the clock, an icon moves along its fixes on the scene clock and is drawn again only when that runs out', (t) => {
const { layer, viewer, icons } = setup(t);
layer.testing._followClockForTest(T + 10_000);
layer.testing._reconcileVesselsForTest(viewer, [row(minuteFixes)]);
layer.testing._runClockPassForTest(T + 10_000);
const set = icons();
assert.deepEqual(set.spec.motionClock, { kind: 'scene' });
let item = set.items.get('111');
assert.equal(item.motion.kind, 'lerp');
assert.deepEqual([item.motion.t0, item.motion.t1], [T, T + 60_000]);
const writes = set.writes;
// Within the stretch: the renderer moves it, the layer writes nothing.
for (let atMs = T + 11_000; atMs < T + 60_000; atMs += 1_000)
layer.testing._runClockPassForTest(atMs);
assert.equal(set.writes, writes);
// The stretch runs out: the next one is drawn, once.
layer.testing._runClockPassForTest(T + 60_000);
item = set.items.get('111');
assert.deepEqual([item.motion.t0, item.motion.t1], [T + 60_000, T + 120_000]);
assert.equal(set.writes, writes + 1);
// Past the last fix, it holds there for good.
layer.testing._runClockPassForTest(T + 200_000);
assert.equal(set.items.get('111').motion.kind, 'hold');
const held = set.writes;
layer.testing._runClockPassForTest(T + 900_000);
assert.equal(set.writes, held);
});
test('a time moved back before the stretch drawn draws the one it is in', (t) => {
const { layer, viewer, icons } = setup(t);
layer.testing._followClockForTest(T + 90_000);
layer.testing._reconcileVesselsForTest(viewer, [row(minuteFixes)]);
layer.testing._runClockPassForTest(T + 90_000);
assert.equal(icons().items.get('111').motion.t0, T + 60_000);
layer.testing._runClockPassForTest(T + 30_000);
const item = icons().items.get('111');
assert.deepEqual([item.motion.t0, item.motion.t1], [T, T + 60_000]);
});
test('a long stretch between fixes is drawn a piece of at most 10 km at a time', (t) => {
const { layer, viewer, icons } = setup(t);
// About 55.6 km in an hour: six pieces of ten minutes.
const fixes = [
{ atMs: T, lat: 51.5, lon: 4.05 },
{ atMs: T + 3_600_000, lat: 52.0, lon: 4.05 },
];
layer.testing._followClockForTest(T + 700_000);
layer.testing._reconcileVesselsForTest(viewer, [row(fixes)]);
layer.testing._runClockPassForTest(T + 700_000);
const { motion } = icons().items.get('111');
assert.deepEqual([motion.t0, motion.t1], [T + 600_000, T + 1_200_000]);
});
test('going live, every icon holds again on the live clock', (t) => {
const { layer, viewer, icons } = setup(t);
layer.testing._followClockForTest(T + 10_000);
layer.testing._reconcileVesselsForTest(viewer, [row(minuteFixes)]);
layer.testing._runClockPassForTest(T + 10_000);
assert.equal(icons().items.get('111').motion.kind, 'lerp');
layer.testing._followClockForTest(null);
layer.testing._runLiveFrameForTest();
assert.equal(icons().items.get('111').motion.kind, 'hold');
assert.equal(icons().spec.motionClock.kind, 'live');
});
test('a renderer without motion segments has the layer move each icon, as before', (t) => {
const { layer, viewer, icons } = setup(t, { capabilities: new Set() });
layer.testing._followClockForTest(T + 10_000);
layer.testing._reconcileVesselsForTest(viewer, [row(minuteFixes)]);
layer.testing._runClockPassForTest(T + 10_000);
assert.equal(icons().items.get('111').motion.kind, 'hold');
assert.equal(icons().spec.motionClock, undefined);
});
test('a vessel shows a minute before its first fix, and hides again when the time moves back before that', (t) => {
const { layer, viewer, icons } = setup(t);
layer.testing._followClockForTest(T - 120_000);
layer.testing._reconcileVesselsForTest(viewer, [row(minuteFixes)]);
layer.testing._runClockPassForTest(T - 120_000);
assert.equal(icons().items.get('111').show, false);
layer.testing._runClockPassForTest(T - 60_000);
assert.equal(icons().items.get('111').show, true);
layer.testing._runClockPassForTest(T - 30_000);
assert.equal(icons().items.get('111').show, true);
layer.testing._runClockPassForTest(T - 90_000);
assert.equal(icons().items.get('111').show, false);
});
test('the detection overlay reads a vessel where it is at the time drawn', (t) => {
const { layer, viewer } = setup(t);
layer.testing._followClockForTest(T + 10_000);
layer.testing._reconcileVesselsForTest(viewer, [row(minuteFixes)]);
layer.testing._runClockPassForTest(T + 10_000);
const record = layer.testing._vesselRecordForTest('111');
const visual = layer.testing._vesselVisualForTest(record);
visual.visible = true;
// Mid-stretch, with no pass reading this vessel since.
layer.testing._followClockForTest(T + 40_000);
const [object] = layer.getDetectableObjects();
assert.equal(object.sourceId, '111');
assert.ok(Math.abs(visual.drawnLat - (51.93 + 0.01 * (40 / 60))) < 1e-6);
});
/** Three vessels a little apart, each on the minute fixes. */
const fleet = () =>
['111', '222', '333'].map((mmsi, i) => ({
...row(minuteFixes.map((fix) => ({ ...fix, lon: fix.lon + i * 0.01 }))),
mmsi,
}));
const latAt = (atMs) => 51.93 + (0.01 * (atMs - T)) / 60_000;
test('positions asked of the layer are where the vessels are drawn at the time drawn', (t) => {
const { layer, viewer } = setup(t);
layer.testing._followClockForTest(T + 10_000);
layer.testing._reconcileVesselsForTest(viewer, fleet());
layer.testing._runClockPassForTest(T + 10_000);
// Mid-stretch, with no pass since.
layer.testing._followClockForTest(T + 40_000);
const latOf = (position) =>
Cesium.Math.toDegrees(
Cesium.Cartographic.fromCartesian(
new Cesium.Cartesian3(position.x, position.y, position.z),
).latitude,
);
const rows = layer.getAllPositions();
assert.equal(rows.length, 3);
for (const { id, position } of rows)
assert.ok(Math.abs(latOf(position) - latAt(T + 40_000)) < 1e-5, id);
// One vessel asked of by itself is brought there too.
const record = layer.testing._vesselRecordForTest('222');
const visual = layer.testing._vesselVisualForTest(record);
layer.findByQuery('222');
assert.ok(Math.abs(visual.drawnLat - latAt(T + 40_000)) < 1e-6);
});
test('going live, every icon holds where its segment last drew it', (t) => {
const { layer, viewer, icons } = setup(t);
layer.testing._followClockForTest(T + 10_000);
layer.testing._reconcileVesselsForTest(viewer, fleet());
layer.testing._runClockPassForTest(T + 10_000);
layer.testing._runClockPassForTest(T + 40_000);
layer.testing._followClockForTest(null);
layer.testing._runLiveFrameForTest();
for (const id of ['111', '222', '333']) {
const record = layer.testing._vesselRecordForTest(id);
const visual = layer.testing._vesselVisualForTest(record);
assert.ok(Math.abs(visual.drawnLat - latAt(T + 40_000)) < 1e-6, id);
assert.deepEqual(icons().items.get(id).pos, visual.position);
assert.equal(icons().items.get(id).motion.kind, 'hold');
}
});
test('a time on the end of a piece draws the next piece', (t) => {
const { layer, viewer, icons } = setup(t);
// About 55.6 km in a little under an hour: six pieces, the first of whose
// ends rounds into the piece before it.
const fixes = [
{ atMs: T, lat: 51.5, lon: 4.05 },
{ atMs: T + 3_599_002, lat: 52.0, lon: 4.05 },
];
layer.testing._followClockForTest(T);
layer.testing._reconcileVesselsForTest(viewer, [row(fixes)]);
for (let k = 1; k < 6; k += 1) {
const atMs = T + (3_599_002 * k) / 6;
layer.testing._runClockPassForTest(atMs);
const { motion } = icons().items.get('111');
assert.ok(motion.t0 <= atMs && atMs < motion.t1, `piece ${k}`);
}
});
test('going live, a vessel a live update has drawn since stays where that drew it', (t) => {
const { layer, viewer, icons } = setup(t);
layer.testing._followClockForTest(T + 10_000);
layer.testing._reconcileVesselsForTest(viewer, fleet());
// A later fix while following: each record keeps the move to it.
const later = { atMs: T + 180_000, lat: 51.96, lon: 4.05 };
layer.testing._reconcileVesselsForTest(
viewer,
fleet()
.map((r) => row([...r.fixes, { ...later, lon: r.lon }]))
.map((r, i) => ({ ...r, mmsi: ['111', '222', '333'][i] })),
);
layer.testing._runClockPassForTest(T + 10_000);
layer.testing._runClockPassForTest(T + 40_000);
layer.testing._followClockForTest(null);
// The live feed lands before the next frame, the ship further north.
const live = fleet().map((row) => ({ ...row, lat: 52.1 }));
layer.testing._reconcileVesselsForTest(viewer, live);
layer.testing._runLiveFrameForTest();
for (const id of ['111', '222', '333']) {
const record = layer.testing._vesselRecordForTest(id);
const visual = layer.testing._vesselVisualForTest(record);
assert.equal(visual.drawnLat, 52.1, id);
assert.deepEqual(icons().items.get(id).pos, visual.position);
}
});
+3 -2
View File
@@ -366,7 +366,7 @@ export function createQueries({
for (const record of records) { for (const record of records) {
if (!Number.isFinite(record.lat) || !Number.isFinite(record.lon)) if (!Number.isFinite(record.lat) || !Number.isFinite(record.lon))
continue; continue;
const position = components.rendering.iconPosition(record); const position = components.rendering.drawnPositionNow(record);
if (!position) continue; if (!position) continue;
const distanceM = distance(centerCartesian, position); const distanceM = distance(centerCartesian, position);
if (!Number.isFinite(distanceM) || distanceM > range) continue; if (!Number.isFinite(distanceM) || distanceM > range) continue;
@@ -471,7 +471,7 @@ export function createQueries({
for (const record of records) { for (const record of records) {
if (result.length >= cap) break; if (result.length >= cap) break;
const position = components.rendering.iconPosition(record); const position = components.rendering.drawnPositionNow(record);
if (!position) continue; if (!position) continue;
result.push({ result.push({
id: record.id, id: record.id,
@@ -664,6 +664,7 @@ export function createQueries({
!visual.modelOwnsVisual !visual.modelOwnsVisual
) )
continue; continue;
components.rendering.readVesselNow(record);
const position = visual.position; const position = visual.position;
if (!position) continue; if (!position) continue;
result.push({ result.push({
+268 -11
View File
@@ -16,6 +16,7 @@ import {
findCamera, findCamera,
findFrame, findFrame,
findQuery, findQuery,
rendererOf,
} from '../../render/rendererOf.js'; } from '../../render/rendererOf.js';
import { poseSignature } from '../../render/camera/poseSignature.js'; import { poseSignature } from '../../render/camera/poseSignature.js';
import { createVesselIconBook } from './iconBook.js'; import { createVesselIconBook } from './iconBook.js';
@@ -29,7 +30,12 @@ import {
CARD_MIN_SEP_PX, CARD_MIN_SEP_PX,
followsClock, followsClock,
} from './policy.js'; } from './policy.js';
import { fixesMove, vesselPositionAt } from './motion.js'; import {
fixesMove,
greatCircleAt,
vesselPositionAt,
vesselSpanAt,
} from './motion.js';
import { TIMELINE_UNSEEN_MS } from '../../time/timelineFixes.js'; import { TIMELINE_UNSEEN_MS } from '../../time/timelineFixes.js';
import { import {
fleetModelSet, fleetModelSet,
@@ -68,6 +74,11 @@ const CAMERA_STEP_FLOOR_M = 100;
/** Scratch for where a moved vessel was drawn. */ /** Scratch for where a moved vessel was drawn. */
const _movedFrom = vec(); const _movedFrom = vec();
/** The longest piece (metres) of the track between two fixes an icon is
* drawn along as one straight line on the renderer's clock: at 10 km the
* line runs under 2 m inside the great circle the layer reads it on. */
const SEGMENT_PIECE_M = 10000;
export function createRendering({ export function createRendering({
vesselState, vesselState,
services, services,
@@ -83,11 +94,27 @@ export function createRendering({
return visualRecords.get(record) || record; return visualRecords.get(record) || record;
} }
/** Where a record's icon is drawn: its row holds at the visual position. */ /** Where a record's icon is drawn: its row holds at the visual position
* (brought up to the time drawn while the renderer moves the icons). */
function iconPosition(record) { function iconPosition(record) {
readVesselNow(record);
return getVisual(record).position; return getVisual(record).position;
} }
/**
* Where a record's icon is drawn now, for a reader of many vessels at
* once: while the renderer moves the icons, its segment at the world time
* (a new position each call); else the visual position, as iconPosition.
*/
function drawnPositionNow(record) {
const visual = getVisual(record);
if (!segmentsOn() || !visual.position) return visual.position;
return (
state.icons?.position(visual.iconId, vesselState.worldNow()) ??
visual.position
);
}
function prepareRecordVisual(record) { function prepareRecordVisual(record) {
let visual = visualRecords.get(record); let visual = visualRecords.get(record);
if (!visual) { if (!visual) {
@@ -172,7 +199,9 @@ export function createRendering({
fromDegreesInto(lon, lat, heightM - VESSEL_LIFT_M, visual.waterline); fromDegreesInto(lon, lat, heightM - VESSEL_LIFT_M, visual.waterline);
visual.drawnLat = lat; visual.drawnLat = lat;
visual.drawnLon = lon; visual.drawnLon = lon;
syncRecordIcon(record); // Moving on the renderer's clock, its icon is where it is already.
if (segmentsOn()) visual.cullPosition = liftedForHorizon(visual.position);
else syncRecordIcon(record);
} }
// Reused projection buffers for the card pass, grown to the candidates. // Reused projection buffers for the card pass, grown to the candidates.
@@ -226,6 +255,9 @@ export function createRendering({
function ensureCollections(viewer) { function ensureCollections(viewer) {
ensureModels(viewer); ensureModels(viewer);
if (!viewer || state.icons) return; if (!viewer || state.icons) return;
const capabilities = rendererOf(viewer)?.capabilities ?? null;
iconMotion = capabilities?.has('motionSegments') === true;
segmentsWere = segmentsOn();
const set = drawOf(viewer).icons({ const set = drawOf(viewer).icons({
id: `ais-vessels:${++instances}`, id: `ais-vessels:${++instances}`,
// Translucent, as its billboards were: overlapping chevrons keep // Translucent, as its billboards were: overlapping chevrons keep
@@ -233,18 +265,118 @@ export function createRendering({
blend: 'translucent', blend: 'translucent',
horizonCull: true, horizonCull: true,
drawOrder: spriteDrawOrder?.('ais') ?? 0, drawOrder: spriteDrawOrder?.('ais') ?? 0,
...(iconMotion ? { motionClock: motionClock(segmentsWere) } : null),
}); });
// Columns of no rows put the set's host in the scene now, rather than // Columns of no rows put the set's host in the scene now, rather than
// with its first vessel. // with its first vessel.
set.setColumns?.({ ids: [] }); set.setColumns?.({ ids: [] });
state.icons = createVesselIconBook(set); iconSet = set;
state.icons = createVesselIconBook(set, { capabilities });
state.icons.show = state.feed.enabled; state.icons.show = state.feed.enabled;
} }
// The icon draw set, and whether its renderer moves icons along motion
// segments on its own clock.
let iconSet = null;
let iconMotion = false;
// Whether the icons last moved on the renderer's clock.
let segmentsWere = false;
// The record drawn under each icon id, for replanning an id.
const iconRecords = new Map();
// From when (world ms) each planned icon's motion holds: one planned
// after the time drawn is planned again when the time moves back.
const planFrom = new Map();
// The world time the icons were last checked against.
let replannedAtMs = -Infinity;
/**
* Whether vessel icons move on the renderer's clock: following the world
* clock, each is drawn along its track between two fixes as a segment the
* renderer moves every frame on the scene's time, and the layer writes an
* icon only when its segment runs out, rather than moving every drawn
* icon each frame. Live, a host placement moves them as before.
*/
function segmentsOn() {
return iconMotion && followsClock(vesselState);
}
/** The set's motion clock: the scene's time while following the clock. */
const motionClock = (scene) =>
scene ? { kind: 'scene' } : { kind: 'live', delayMs: 0 };
/**
* The segment a vessel's icon moves along at world time `atMs`: the piece
* of its track between two fixes the time is in (at most SEGMENT_PIECE_M
* long), or where it holds; with when it runs out and from when it holds.
* Null for a vessel the clock does not move: it holds where it is drawn.
*/
function planMotion(record, atMs) {
if (!record.motion && !fixesMove(record.fixes)) return null;
const span = vesselSpanAt(record, atMs);
if (!span) return null;
if (span.kind === 'hold') {
// Before its first fix it is drawn from TIMELINE_UNSEEN_MS ahead of
// it (seenYet): drawn again when the time crosses that.
let { fromMs, untilMs } = span;
const shownFromMs = record.fixes?.[0]?.atMs - TIMELINE_UNSEEN_MS;
if (fromMs === -Infinity && shownFromMs < untilMs) {
if (atMs < shownFromMs) untilMs = shownFromMs;
else fromMs = shownFromMs;
}
return {
motion: null,
pos: anchorAt(span.lat, span.lon),
expiresAt: untilMs,
validFrom: fromMs,
};
}
const n = Math.max(1, Math.ceil(span.metres / SEGMENT_PIECE_M));
const spanMs = span.t1 - span.t0;
const pieceEnd = (i) => (i === n ? span.t1 : span.t0 + (spanMs * i) / n);
let k = Math.min(
n - 1,
Math.max(0, Math.floor(((atMs - span.t0) / spanMs) * n)),
);
// A time on a piece's end belongs to the next piece, whatever rounding
// says, so a segment is never drawn already run out.
while (k < n - 1 && pieceEnd(k + 1) <= atMs) k += 1;
while (k > 0 && pieceEnd(k) > atMs) k -= 1;
const t0 = pieceEnd(k);
const t1 = pieceEnd(k + 1);
const at = (i) =>
i === 0
? { lat: span.lat0, lon: span.lon0 }
: i === n
? { lat: span.lat1, lon: span.lon1 }
: greatCircleAt(span.lat0, span.lon0, span.lat1, span.lon1, i / n);
const a = at(k);
const b = at(k + 1);
const to = anchorAt(b.lat, b.lon);
const courseDeg = vesselCourseDeg(record);
return {
motion: {
kind: 'lerp',
from: anchorAt(a.lat, a.lon),
to,
t0,
t1,
course0Deg: courseDeg,
courseSlopeDeg: 0,
},
pos: to,
expiresAt: t1,
validFrom: t0,
};
}
/** Let the icon draw set go (the layer is destroyed). */ /** Let the icon draw set go (the layer is destroyed). */
function disposeCollections() { function disposeCollections() {
state.icons?.dispose(); state.icons?.dispose();
state.icons = null; state.icons = null;
iconSet = null;
iconRecords.clear();
planFrom.clear();
replannedAtMs = -Infinity;
} }
/** Whether the Cockpit's bridge camera rides this record's ship. */ /** Whether the Cockpit's bridge camera rides this record's ship. */
@@ -276,20 +408,25 @@ export function createRendering({
const courseDeg = vesselCourseDeg(record); const courseDeg = vesselCourseDeg(record);
// Following the clock, not there yet at the time drawn. // Following the clock, not there yet at the time drawn.
visual.seen = seenYet(record); visual.seen = seenYet(record);
const plan = segmentsOn()
? planMotion(record, vesselState.worldNow())
: null;
visual.plan = plan;
return { return {
id: visual.iconId, id: visual.iconId,
// Hidden while the bridge camera rides it, its model draws it, or it // Hidden while the bridge camera rides it, its model draws it, or it
// is not there yet. // is not there yet.
show: !isCockpitSubject(record) && !visual.modelOwnsVisual && visual.seen, show: !isCockpitSubject(record) && !visual.modelOwnsVisual && visual.seen,
pos: visual.position, pos: plan?.pos ?? visual.position,
image: shipIcon(record, selected), image: shipIcon(record, selected),
size: [SHIP_ICON_PX, SHIP_ICON_PX], size: [SHIP_ICON_PX, SHIP_ICON_PX],
// Selection changes the colour only, never the size. // Selection changes the colour only, never the size.
scale: shipScale(record), scale: shipScale(record),
rotationMode: 'course', rotationMode: 'course',
// Held on course; `course` for renderers without motion segments. // Held on course, or along its track on the renderer's clock;
// `course` for renderers without motion segments.
course: courseDeg, course: courseDeg,
motion: { kind: 'hold', courseDeg }, motion: plan?.motion ?? { kind: 'hold', courseDeg },
focus: state.icons?.focus(visual.iconId) ?? 1, focus: state.icons?.focus(visual.iconId) ?? 1,
disableDepthTest: Infinity, disableDepthTest: Infinity,
meta: visual.meta, meta: visual.meta,
@@ -308,7 +445,8 @@ export function createRendering({
const visual = getVisual(record); const visual = getVisual(record);
// The pick meta, and the key of the vessel's focus emphasis. // The pick meta, and the key of the vessel's focus emphasis.
visual.meta = { layer: 'ais-live-vessels', id: visual.iconId }; visual.meta = { layer: 'ais-live-vessels', id: visual.iconId };
state.icons.put({ ...iconItem(record, visual), focus: 1 }); iconRecords.set(visual.iconId, record);
putIcon(visual, { ...iconItem(record, visual), focus: 1 });
if (visual.position) if (visual.position)
visual.cullPosition = liftedForHorizon(visual.position); visual.cullPosition = liftedForHorizon(visual.position);
visual.visible = isVisible(visual.cullPosition, occluder, record); visual.visible = isVisible(visual.cullPosition, occluder, record);
@@ -325,10 +463,23 @@ export function createRendering({
function syncRecordIcon(record) { function syncRecordIcon(record) {
const visual = getVisual(record); const visual = getVisual(record);
if (!state.icons?.has(visual.iconId) || !visual.position) return; if (!state.icons?.has(visual.iconId) || !visual.position) return;
state.icons.put(iconItem(record, visual)); putIcon(visual, iconItem(record, visual));
visual.cullPosition = liftedForHorizon(visual.position); visual.cullPosition = liftedForHorizon(visual.position);
} }
/** Draw a vessel's icon item, with when its segment runs out while the
* icons move on the renderer's clock. */
function putIcon(visual, item) {
if (!segmentsOn()) {
planFrom.delete(item.id);
state.icons.put(item, { expiresAt: null });
return;
}
const plan = visual.plan;
planFrom.set(item.id, plan?.validFrom ?? -Infinity);
state.icons.put(item, { expiresAt: plan?.expiresAt ?? Infinity });
}
/** /**
* Remove a record's icon row. * Remove a record's icon row.
* @param {Object} record - Vessel record to tear down. * @param {Object} record - Vessel record to tear down.
@@ -341,6 +492,8 @@ export function createRendering({
if (!icons?.has(visual.iconId)) return; if (!icons?.has(visual.iconId)) return;
forgetSpriteFocus(icons.item(visual.iconId).meta); forgetSpriteFocus(icons.item(visual.iconId).meta);
icons.remove(visual.iconId); icons.remove(visual.iconId);
iconRecords.delete(visual.iconId);
planFrom.delete(visual.iconId);
} }
function shipScale(record) { function shipScale(record) {
@@ -548,7 +701,8 @@ export function createRendering({
state.preRenderRemover = state.preRenderRemover =
findFrame(viewer)?.on('preRender', () => { findFrame(viewer)?.on('preRender', () => {
if (state.feed.enabled) { if (state.feed.enabled) {
if (followsClock(vesselState)) followClockPositions(); syncSegments();
if (followsClock(vesselState)) followClock();
else if (services.placement) followPlacements(); else if (services.placement) followPlacements();
} }
updateVisibility(); updateVisibility();
@@ -569,6 +723,102 @@ export function createRendering({
let clockPassAtMs = null; let clockPassAtMs = null;
// Whether the last pass left drawn vessels short of its world time. // Whether the last pass left drawn vessels short of its world time.
let drawnBehind = false; let drawnBehind = false;
/** One world-clock pass: icons on the renderer's clock when it moves
* them, else moved by the layer. */
function followClock() {
syncSegments();
if (segmentsOn()) followClockSegments();
else followClockPositions();
}
/**
* Once a frame: when the icons start or stop moving on the renderer's
* clock (the layer starts or stops following the world clock), put the
* set on that clock and draw every icon again, along its segment or held.
*/
function syncSegments() {
const on = segmentsOn();
if (on === segmentsWere) return;
segmentsWere = on;
iconSet?.setOptions?.({ motionClock: motionClock(on) });
// Leaving the clock, each icon holds where its segment last drew it;
// one a live update has drawn since (no world time drawn) stays there.
const lastAtMs = on ? -Infinity : replannedAtMs;
replannedAtMs = -Infinity;
for (const record of state.records.all) {
const drawnAtMs = visualRecords.get(record)?.drawnAtMs;
if (
lastAtMs > -Infinity &&
Number.isFinite(drawnAtMs) &&
catchUpVisual(record, lastAtMs)
)
continue;
syncRecordIcon(record);
}
}
// The vessels drawn with a card (and the selected one): their cards are
// anchored at where the layer reads them, so it reads them every frame.
const carded = new Set();
/**
* As the world clock plays with the icons on the renderer's clock: the
* renderer moves each icon along its segment, and the layer draws again
* only those whose segment ran out (or, the time moved back, started after
* it). Where the layer reads a vessel (its cards, picks, the horizon, its
* model) moves on by itself: every frame for the vessels drawn with a
* card or a model and the one the bridge camera rides, and for the rest a
* share of them each pass, so each moves at least every HIDDEN_FOLLOW_MS.
*/
function followClockSegments() {
const atMs = vesselState.worldNow();
if (atMs < replannedAtMs)
for (const [id, from] of planFrom) if (from > atMs) replanIcon(id, atMs);
replannedAtMs = atMs;
for (const id of state.icons?.due(atMs) ?? []) replanIcon(id, atMs);
for (const record of carded) catchUpVisual(record, atMs);
for (const item of modelItems.values()) catchUpVisual(item.record, atMs);
const ridden = state.cockpitSubjectId
? state.records.byId.get(state.cockpitSubjectId)
: null;
if (ridden) catchUpVisual(ridden, atMs);
const all = state.records.all;
const wallMs = performance.now();
const sinceMs =
hiddenFollowedAtWallMs === null
? HIDDEN_FOLLOW_MS
: wallMs - hiddenFollowedAtWallMs;
const share = Math.min(
all.length,
Math.ceil((all.length * Math.max(0, sinceMs)) / HIDDEN_FOLLOW_MS),
);
if (share > 0) hiddenFollowedAtWallMs = wallMs;
for (let k = 0; k < share; k += 1) {
if (hiddenCursor >= all.length) hiddenCursor = 0;
const record = all[hiddenCursor];
if (visualRecords.get(record)?.position) catchUpVisual(record, atMs);
else followRecord(record, atMs, false, motionPass);
hiddenCursor += 1;
}
}
/**
* Bring where the layer reads a vessel up to the world time, for a reader
* that needs it where it is drawn now (the detection overlay): while the
* icons move on the renderer's clock, only some are read every frame.
*/
function readVesselNow(record) {
if (segmentsOn()) catchUpVisual(record, vesselState.worldNow());
}
/** Draw an icon's vessel again where it is at `atMs`. */
function replanIcon(id, atMs) {
const record = iconRecords.get(id);
if (!record) return;
catchUpVisual(record, atMs);
syncRecordIcon(record);
}
function followClockPositions() { function followClockPositions() {
const atMs = vesselState.worldNow(); const atMs = vesselState.worldNow();
const wallMs = performance.now(); const wallMs = performance.now();
@@ -1039,7 +1289,7 @@ export function createRendering({
const visual = getVisual(record); const visual = getVisual(record);
const id = visual?.iconId; const id = visual?.iconId;
const item = icons?.item(id); const item = icons?.item(id);
const position = visual?.position; const position = item ? drawnPositionNow(record) : visual?.position;
if (!item || !position) continue; if (!item || !position) continue;
const sprite = item.meta; const sprite = item.meta;
// Most of a worldwide feed sits behind the horizon. A hidden icon with // Most of a worldwide feed sits behind the horizon. A hidden icon with
@@ -1121,6 +1371,8 @@ export function createRendering({
? [components.cards.buildSelectedVesselCard(selected)] ? [components.cards.buildSelectedVesselCard(selected)]
: []; : [];
const maxLabels = labelRowLimit(); const maxLabels = labelRowLimit();
carded.clear();
if (selectedCarded) carded.add(selected);
if (!query || !records.length || maxLabels <= 0) { if (!query || !records.length || maxLabels <= 0) {
state.activeLabelCount = entries.length; state.activeLabelCount = entries.length;
@@ -1183,6 +1435,7 @@ export function createRendering({
continue; continue;
accepted.push({ x: candidate.x, y: candidate.y }); accepted.push({ x: candidate.x, y: candidate.y });
entries.push(components.cards.buildVesselCard(candidate.record)); entries.push(components.cards.buildVesselCard(candidate.record));
carded.add(candidate.record);
} }
state.activeLabelCount = entries.length; state.activeLabelCount = entries.length;
publishVesselOverlayEntries(entries); publishVesselOverlayEntries(entries);
@@ -1273,6 +1526,7 @@ export function createRendering({
return { return {
getVisual, getVisual,
iconPosition, iconPosition,
drawnPositionNow,
forgetClockStep, forgetClockStep,
prepareRecordVisual, prepareRecordVisual,
anchorPosition, anchorPosition,
@@ -1292,7 +1546,10 @@ export function createRendering({
cancelTrailingVisibilityPass, cancelTrailingVisibilityPass,
cancelPlacementFrame, cancelPlacementFrame,
followPlacements, followPlacements,
followClock,
followClockPositions, followClockPositions,
readVesselNow,
syncSegments,
applyVesselFocusDeemphasis, applyVesselFocusDeemphasis,
makeOccluder, makeOccluder,
isVisible, isVisible,
+19 -4
View File
@@ -182,18 +182,32 @@ export function createTesting({
components.rendering.followPlacements(); components.rendering.followPlacements();
} }
/**
* Run what one live frame runs (not following the clock): settle whether
* icons move on the renderer's clock, then the placement pass. Test-only
* seam.
*/
function _runLiveFrameForTest() {
components.rendering.syncSegments();
components.rendering.followPlacements();
}
/** Run one world-clock pass at world time `atMs`. Test-only seam. */ /** Run one world-clock pass at world time `atMs`. Test-only seam. */
function _runClockPassForTest(atMs) { function _runClockPassForTest(atMs) {
vesselState.worldNow = () => atMs; vesselState.worldNow = () => atMs;
components.rendering.followClockPositions(); components.rendering.followClock();
} }
/** Follow the world clock, standing at world time `atMs`. Test-only seam. */ /**
* Follow the world clock, standing at world time `atMs`; `null` goes back
* to live. Test-only seam.
*/
function _followClockForTest(atMs) { function _followClockForTest(atMs) {
vesselState.timeline = { active: () => true }; vesselState.timeline = { active: () => atMs !== null };
vesselState.worldNow = () => atMs; vesselState.worldNow = () => atMs ?? 0;
} }
/** True while a trailing visibility frame is scheduled. Test-only seam. */ /** True while a trailing visibility frame is scheduled. Test-only seam. */
@@ -240,6 +254,7 @@ export function createTesting({
_vesselVisualForTest, _vesselVisualForTest,
_runPlacementPassForTest, _runPlacementPassForTest,
_runClockPassForTest, _runClockPassForTest,
_runLiveFrameForTest,
_hasTrailingVisibilityPassForTest, _hasTrailingVisibilityPassForTest,
}; };
} }
+8 -2
View File
@@ -208,10 +208,14 @@ export function fakeScenePorts(viewer) {
/** /**
* Bind the ports to `viewer`. * Bind the ports to `viewer`.
* @param {object} viewer * @param {object} viewer
* @param {{draw?: object}} [options] * @param {{draw?: object, capabilities?: ReadonlySet<string>}} [options]
* `capabilities`: what the renderer reports it can draw (none by default).
* @returns {{draw: object, camera: object, query: object, frame: object, unbind: () => void}} * @returns {{draw: object, camera: object, query: object, frame: object, unbind: () => void}}
*/ */
export function bindFakeCesiumScene(viewer, { draw = fakeDrawPort() } = {}) { export function bindFakeCesiumScene(
viewer,
{ draw = fakeDrawPort(), capabilities } = {},
) {
const cam = () => cameraOfDouble(viewer); const cam = () => cameraOfDouble(viewer);
const camera = { const camera = {
pose() { pose() {
@@ -277,6 +281,8 @@ export function bindFakeCesiumScene(viewer, { draw = fakeDrawPort() } = {}) {
camera, camera,
query, query,
frame, frame,
// What the renderer can draw, when a test gives it (none otherwise).
...(capabilities ? { capabilities } : null),
}); });
return { draw, camera, query, frame, unbind }; return { draw, camera, query, frame, unbind };
} }