diff --git a/src/layers/vessels/motion.js b/src/layers/vessels/motion.js index 60c8038b1..564b0aa05 100644 --- a/src/layers/vessels/motion.js +++ b/src/layers/vessels/motion.js @@ -54,10 +54,94 @@ export function vesselPositionAt(record, tMs) { } 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 * 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 lambda1 = lon1 * RAD; const phi2 = lat2 * RAD; diff --git a/src/layers/vessels/motion.test.mjs b/src/layers/vessels/motion.test.mjs index 79378853f..58d2509c4 100644 --- a/src/layers/vessels/motion.test.mjs +++ b/src/layers/vessels/motion.test.mjs @@ -1,6 +1,11 @@ import test from 'node:test'; import assert from 'node:assert/strict'; -import { fixesMove, vesselPositionAt } from './motion.js'; +import { + fixesMove, + greatCircleAt, + vesselPositionAt, + vesselSpanAt, +} from './motion.js'; const record = { lat: 1, @@ -61,3 +66,76 @@ test('fixes that stay in one place do not move a vessel', () => { ); 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); + } +}); diff --git a/src/layers/vessels/motionSegments.test.mjs b/src/layers/vessels/motionSegments.test.mjs new file mode 100644 index 000000000..bc199a4f4 --- /dev/null +++ b/src/layers/vessels/motionSegments.test.mjs @@ -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); + } +}); diff --git a/src/layers/vessels/queries.js b/src/layers/vessels/queries.js index 0e98e8c2b..38bf0f5b7 100644 --- a/src/layers/vessels/queries.js +++ b/src/layers/vessels/queries.js @@ -366,7 +366,7 @@ export function createQueries({ for (const record of records) { if (!Number.isFinite(record.lat) || !Number.isFinite(record.lon)) continue; - const position = components.rendering.iconPosition(record); + const position = components.rendering.drawnPositionNow(record); if (!position) continue; const distanceM = distance(centerCartesian, position); if (!Number.isFinite(distanceM) || distanceM > range) continue; @@ -471,7 +471,7 @@ export function createQueries({ for (const record of records) { if (result.length >= cap) break; - const position = components.rendering.iconPosition(record); + const position = components.rendering.drawnPositionNow(record); if (!position) continue; result.push({ id: record.id, @@ -664,6 +664,7 @@ export function createQueries({ !visual.modelOwnsVisual ) continue; + components.rendering.readVesselNow(record); const position = visual.position; if (!position) continue; result.push({ diff --git a/src/layers/vessels/rendering.js b/src/layers/vessels/rendering.js index f3b4025e8..221306c83 100644 --- a/src/layers/vessels/rendering.js +++ b/src/layers/vessels/rendering.js @@ -16,6 +16,7 @@ import { findCamera, findFrame, findQuery, + rendererOf, } from '../../render/rendererOf.js'; import { poseSignature } from '../../render/camera/poseSignature.js'; import { createVesselIconBook } from './iconBook.js'; @@ -29,7 +30,12 @@ import { CARD_MIN_SEP_PX, followsClock, } 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 { fleetModelSet, @@ -68,6 +74,11 @@ const CAMERA_STEP_FLOOR_M = 100; /** Scratch for where a moved vessel was drawn. */ 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({ vesselState, services, @@ -83,11 +94,27 @@ export function createRendering({ 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) { + readVesselNow(record); 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) { let visual = visualRecords.get(record); if (!visual) { @@ -172,7 +199,9 @@ export function createRendering({ fromDegreesInto(lon, lat, heightM - VESSEL_LIFT_M, visual.waterline); visual.drawnLat = lat; 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. @@ -226,6 +255,9 @@ export function createRendering({ function ensureCollections(viewer) { ensureModels(viewer); if (!viewer || state.icons) return; + const capabilities = rendererOf(viewer)?.capabilities ?? null; + iconMotion = capabilities?.has('motionSegments') === true; + segmentsWere = segmentsOn(); const set = drawOf(viewer).icons({ id: `ais-vessels:${++instances}`, // Translucent, as its billboards were: overlapping chevrons keep @@ -233,18 +265,118 @@ export function createRendering({ blend: 'translucent', horizonCull: true, drawOrder: spriteDrawOrder?.('ais') ?? 0, + ...(iconMotion ? { motionClock: motionClock(segmentsWere) } : null), }); // Columns of no rows put the set's host in the scene now, rather than // with its first vessel. set.setColumns?.({ ids: [] }); - state.icons = createVesselIconBook(set); + iconSet = set; + state.icons = createVesselIconBook(set, { capabilities }); 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). */ function disposeCollections() { state.icons?.dispose(); state.icons = null; + iconSet = null; + iconRecords.clear(); + planFrom.clear(); + replannedAtMs = -Infinity; } /** Whether the Cockpit's bridge camera rides this record's ship. */ @@ -276,20 +408,25 @@ export function createRendering({ const courseDeg = vesselCourseDeg(record); // Following the clock, not there yet at the time drawn. visual.seen = seenYet(record); + const plan = segmentsOn() + ? planMotion(record, vesselState.worldNow()) + : null; + visual.plan = plan; return { id: visual.iconId, // Hidden while the bridge camera rides it, its model draws it, or it // is not there yet. show: !isCockpitSubject(record) && !visual.modelOwnsVisual && visual.seen, - pos: visual.position, + pos: plan?.pos ?? visual.position, image: shipIcon(record, selected), size: [SHIP_ICON_PX, SHIP_ICON_PX], // Selection changes the colour only, never the size. scale: shipScale(record), 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, - motion: { kind: 'hold', courseDeg }, + motion: plan?.motion ?? { kind: 'hold', courseDeg }, focus: state.icons?.focus(visual.iconId) ?? 1, disableDepthTest: Infinity, meta: visual.meta, @@ -308,7 +445,8 @@ export function createRendering({ const visual = getVisual(record); // The pick meta, and the key of the vessel's focus emphasis. 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) visual.cullPosition = liftedForHorizon(visual.position); visual.visible = isVisible(visual.cullPosition, occluder, record); @@ -325,10 +463,23 @@ export function createRendering({ function syncRecordIcon(record) { const visual = getVisual(record); 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); } + /** 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. * @param {Object} record - Vessel record to tear down. @@ -341,6 +492,8 @@ export function createRendering({ if (!icons?.has(visual.iconId)) return; forgetSpriteFocus(icons.item(visual.iconId).meta); icons.remove(visual.iconId); + iconRecords.delete(visual.iconId); + planFrom.delete(visual.iconId); } function shipScale(record) { @@ -548,7 +701,8 @@ export function createRendering({ state.preRenderRemover = findFrame(viewer)?.on('preRender', () => { if (state.feed.enabled) { - if (followsClock(vesselState)) followClockPositions(); + syncSegments(); + if (followsClock(vesselState)) followClock(); else if (services.placement) followPlacements(); } updateVisibility(); @@ -569,6 +723,102 @@ export function createRendering({ let clockPassAtMs = null; // Whether the last pass left drawn vessels short of its world time. 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() { const atMs = vesselState.worldNow(); const wallMs = performance.now(); @@ -1039,7 +1289,7 @@ export function createRendering({ const visual = getVisual(record); const id = visual?.iconId; const item = icons?.item(id); - const position = visual?.position; + const position = item ? drawnPositionNow(record) : visual?.position; if (!item || !position) continue; const sprite = item.meta; // Most of a worldwide feed sits behind the horizon. A hidden icon with @@ -1121,6 +1371,8 @@ export function createRendering({ ? [components.cards.buildSelectedVesselCard(selected)] : []; const maxLabels = labelRowLimit(); + carded.clear(); + if (selectedCarded) carded.add(selected); if (!query || !records.length || maxLabels <= 0) { state.activeLabelCount = entries.length; @@ -1183,6 +1435,7 @@ export function createRendering({ continue; accepted.push({ x: candidate.x, y: candidate.y }); entries.push(components.cards.buildVesselCard(candidate.record)); + carded.add(candidate.record); } state.activeLabelCount = entries.length; publishVesselOverlayEntries(entries); @@ -1273,6 +1526,7 @@ export function createRendering({ return { getVisual, iconPosition, + drawnPositionNow, forgetClockStep, prepareRecordVisual, anchorPosition, @@ -1292,7 +1546,10 @@ export function createRendering({ cancelTrailingVisibilityPass, cancelPlacementFrame, followPlacements, + followClock, followClockPositions, + readVesselNow, + syncSegments, applyVesselFocusDeemphasis, makeOccluder, isVisible, diff --git a/src/layers/vessels/testing.js b/src/layers/vessels/testing.js index 531554dfd..fcfff1dc0 100644 --- a/src/layers/vessels/testing.js +++ b/src/layers/vessels/testing.js @@ -182,18 +182,32 @@ export function createTesting({ 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. */ function _runClockPassForTest(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) { - vesselState.timeline = { active: () => true }; - vesselState.worldNow = () => atMs; + vesselState.timeline = { active: () => atMs !== null }; + vesselState.worldNow = () => atMs ?? 0; } /** True while a trailing visibility frame is scheduled. Test-only seam. */ @@ -240,6 +254,7 @@ export function createTesting({ _vesselVisualForTest, _runPlacementPassForTest, _runClockPassForTest, + _runLiveFrameForTest, _hasTrailingVisibilityPassForTest, }; } diff --git a/src/testSupport/fakeCesiumScene.mjs b/src/testSupport/fakeCesiumScene.mjs index 77fd2f80b..35f7e605f 100644 --- a/src/testSupport/fakeCesiumScene.mjs +++ b/src/testSupport/fakeCesiumScene.mjs @@ -208,10 +208,14 @@ export function fakeScenePorts(viewer) { /** * Bind the ports to `viewer`. * @param {object} viewer - * @param {{draw?: object}} [options] + * @param {{draw?: object, capabilities?: ReadonlySet}} [options] + * `capabilities`: what the renderer reports it can draw (none by default). * @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 camera = { pose() { @@ -277,6 +281,8 @@ export function bindFakeCesiumScene(viewer, { draw = fakeDrawPort() } = {}) { camera, query, frame, + // What the renderer can draw, when a test gives it (none otherwise). + ...(capabilities ? { capabilities } : null), }); return { draw, camera, query, frame, unbind }; }