diff --git a/scripts/package-boundaries.json b/scripts/package-boundaries.json index 95f1b2f6c..6c86f5b60 100644 --- a/scripts/package-boundaries.json +++ b/scripts/package-boundaries.json @@ -1493,6 +1493,7 @@ "src/layers/flights/rendering.js", "src/layers/flights/icons.js", "src/data/aircraftIconLayer.js", + "src/render/motion/iconBook.js", "src/data/aircraftModelLayer.js", "src/data/aircraftMotionRegime.js", "src/data/iconSetPrimitive.js", @@ -1598,6 +1599,7 @@ "src/layers/military/rendering.js", "src/layers/military/icons.js", "src/data/aircraftIconLayer.js", + "src/render/motion/iconBook.js", "src/data/aircraftModelLayer.js", "src/data/aircraftMotionRegime.js", "src/data/iconSetPrimitive.js", diff --git a/src/data/aircraftEmergencyAnalyst.test.mjs b/src/data/aircraftEmergencyAnalyst.test.mjs index 59516787a..8530fd47b 100644 --- a/src/data/aircraftEmergencyAnalyst.test.mjs +++ b/src/data/aircraftEmergencyAnalyst.test.mjs @@ -4,10 +4,12 @@ import { createRendering as civilRendering } from '../layers/flights/rendering.j import { createRendering as militaryRendering } from '../layers/military/rendering.js'; import { createMilitarySnapshotRenderer } from '../layers/military/snapshotRenderer.js'; import { createIcons as createMilitaryIcons } from '../layers/military/icons.js'; -import { createIconSet } from './iconSet.js'; +import { createContactIcons } from './aircraftIconLayer.js'; import { aircraftMotionRegime, createMotionRegime, + fixEpochMs, + julianAt, } from './aircraftMotionRegime.js'; import { aircraftEmergency } from './aircraftEmergency.js'; // Source-to-voice provenance, status retention/clearing, contact-time contracts, @@ -471,7 +473,7 @@ test('tint priorities cover normal, priority, emergency, tracking and Cockpit do test('GERMAN: an existing untracked military icon repaints each poll without losing its fade', () => { const { flightState, rendering } = renderHarness(militaryRendering); Object.assign(flightState, { - _icons: createIconSet(), + _icons: createContactIcons(), _models: new Map(), _positionHistory: new Map(), _displayCourse: new Map(), @@ -500,6 +502,8 @@ test('GERMAN: an existing untracked military icon repaints each poll without los { speed: 'speedMps', track: 'track' }, createMotionRegime(), ), + _displayTimeAt: julianAt, + _fixEpochMs: fixEpochMs, }, }; const icons = createMilitaryIcons({ @@ -507,11 +511,13 @@ test('GERMAN: an existing untracked military icon repaints each poll without los services: { focus: { focusPassIsNeeded: () => false } }, parts, }); - const row = flightState._icons.add('abc123', { - layer: 'military', - id: 'abc123', + const row = 'abc123'; + flightState._icons.put({ + id: row, + pos: { x: 0, y: 0, z: 0 }, + meta: { layer: 'military', id: row }, }); - // The focus fade the fleet tick composes lives in its own column. + // The focus fade the fleet tick composes lives in its own field. flightState._icons.setFocus(row, 0.65); const apply = createMilitarySnapshotRenderer({ flightState, @@ -546,7 +552,7 @@ test('GERMAN: an existing untracked military icon repaints each poll without los { observedAtMs: NOW_MS }, ); apply(snapshot, {}); - assert.equal(flightState._icons.color(row).green < 0.5, red); + assert.equal(flightState._icons.item(row).color[1] < 0.5, red); assert.ok(Math.abs(flightState._icons.focus(row) - 0.65) < 1e-6); } }); diff --git a/src/data/aircraftIconLayer.js b/src/data/aircraftIconLayer.js index b098d783f..571b4ff4b 100644 --- a/src/data/aircraftIconLayer.js +++ b/src/data/aircraftIconLayer.js @@ -1,60 +1,224 @@ -import * as Cesium from 'cesium'; +import { COURSE_HOLD_SPEED_MPS, courseSlewCapDps } from './motionModel.js'; +import { norm180, distance, clone, copyInto } from '../geo/vector.js'; +import { horizonFrom, liftedForHorizon } from '../geo/horizon.js'; +import { createIconBook } from '../render/motion/iconBook.js'; +import { motionCourse } from '../render/motion/iconMotion.js'; import { - COURSE_HOLD_SPEED_MPS, - courseSlewCapDps, - norm180, -} from './motionModel.js'; -import { - createIconSet, - ICON_CULL_LIFT, - ICON_CULL_LIFT_BELOW_M, - ICON_RECEDES, - ICON_ROTATES, -} from './iconSet.js'; -import { - segmentCourse, - writeArcSegment, - writeCourseGlide, - writeHoldSegment, - writeLerpSegment, -} from './iconSegment.js'; -import { IconSetPrimitive } from './iconSetPrimitive.js'; -import { iconAtlas } from './iconAtlas.js'; + drawOf, + findCamera, + findQuery, + rendererOf, +} from '../render/rendererOf.js'; +import { nearImageSwitchPx } from './iconAtlas.js'; import { aircraftIcon, FLEET_ICON_PX, TRACKED_ICON_PX, } from './aircraftIcons.js'; import { cockpitContactDotImage } from './cockpitContactDot.js'; -import { horizonOccluder } from './iconOrientation.js'; /** Raster size of the cockpit contact pip (cockpitContactDot.js draws 16 px). */ const COCKPIT_DOT_PX = 16; /** Fleet glyphs keep the established close-range 3× scale. */ -const NORMAL_SCALE_BY_DISTANCE = new Cesium.NearFarScalar( - 1000, - 3.0, - 8000000, - 0.5, -); -const COCKPIT_SCALE_BY_DISTANCE = new Cesium.NearFarScalar( - 1000, - 1.15, - 8000000, - 0.65, -); +const NORMAL_SCALE_BY_DISTANCE = Object.freeze({ + near: 1000, + nearValue: 3.0, + far: 8000000, + farValue: 0.5, +}); +const COCKPIT_SCALE_BY_DISTANCE = Object.freeze({ + near: 1000, + nearValue: 1.15, + far: 8000000, + farValue: 0.65, +}); + +let cockpitDot = null; +/** + * The cockpit pip as an SVG of its own 16 px size around its PNG, so the + * draw port rasterises it at 16 px (as the icon set did) rather than at its + * few-pixel drawn size. + */ +function cockpitDotImage() { + if (cockpitDot) return cockpitDot; + const png = cockpitContactDotImage(); + const px = COCKPIT_DOT_PX; + cockpitDot = `data:image/svg+xml;charset=utf-8,${encodeURIComponent( + ``, + )}`; + return cockpitDot; +} + +/** A colour as the draw contract's `[r, g, b, a]`, from `{red, green, blue, alpha}`. */ +function rgba(color) { + if (!color || typeof color === 'string' || Array.isArray(color)) return color; + return [color.red, color.green, color.blue, color.alpha ?? 1]; +} + +/** Whether two plain values are the same, nested ones included. */ +function same(a, b) { + if (a === b) return true; + if (!a || !b || typeof a !== 'object' || typeof b !== 'object') return false; + const keys = Object.keys(a); + if (keys.length !== Object.keys(b).length) return false; + for (const key of keys) if (!same(a[key], b[key])) return false; + return true; +} /** - * An aircraft layer's contacts as one icon set: each row's motion segment - * mirrors the layer's dead reckoning for the delayed display time, so the GPU - * moves every untracked contact between polls with no per-frame CPU pass. + * An aircraft layer's contact icons as it last drew them, over one icon + * draw set: each contact's icon item by its id, until when its motion holds + * (`render/motion/iconBook`), read back where it is drawn now. Writes go to + * the draw set together once the current task ends, so restyling and + * replanning a contact in one pass writes its item once. + * @param {import('../render/contract/draw').DrawSet|null} [drawSet] + * Where the icons are drawn; none keeps them only here (tests). + * @param {{capabilities?: ReadonlySet|null}} [options] + */ +export function createContactIcons(drawSet = null, { capabilities } = {}) { + const book = createIconBook(null, { capabilities }); + const pending = new Map(); + const removed = new Set(); + // The ids the draw set holds. + const sent = new Set(); + let queued = false; + let disposed = false; + let shown = true; + + function flush() { + queued = false; + if (!drawSet || disposed) return; + if (pending.size) { + const items = [...pending.values()]; + pending.clear(); + // A write the set refuses throws here; what it holds stays as it was. + drawSet.upsert(items); + for (const item of items) sent.add(item.id); + } + if (removed.size) { + const ids = [...removed]; + removed.clear(); + for (const id of ids) sent.delete(id); + drawSet.remove(ids); + } + } + + function schedule() { + if (!drawSet || queued || disposed) return; + queued = true; + queueMicrotask(flush); + } + + const icons = { + /** The draw set's id, or null. */ + setId: drawSet?.id ?? null, + get count() { + return book.size; + }, + get show() { + return drawSet ? drawSet.show : shown; + }, + set show(value) { + if (drawSet) drawSet.show = value; + else shown = value; + }, + has: (id) => book.has(id), + /** The drawn ids, in the order first drawn. */ + ids: () => book.ids(), + item: (id) => book.item(id), + /** + * Until when (epoch ms on the display clock) an id's motion holds: + * Infinity when planned to hold, -Infinity while never planned. + */ + expires: (id) => book.expiresAt(id), + /** The ids whose motion ran out by `t`, to plan afresh. */ + due: (t) => book.due(t), + /** Where an id is drawn at `t` (into `result` when given), or null. */ + position(id, t, result) { + const p = book.position(id, t); + return p && result ? copyInto(p, result) : p; + }, + course: (id, t) => book.course(id, t), + shown: (id) => book.item(id)?.show !== false, + focus: (id) => book.focus(id), + alpha: (id) => book.item(id)?.alpha ?? 1, + scale: (id) => book.item(id)?.scale ?? 1, + /** Draw an item as given (see `iconBook.put`). */ + put(item, options) { + book.put(item, options); + removed.delete(item.id); + pending.set(item.id, item); + schedule(); + }, + /** + * Change some of an id's item; nothing is written when it already is + * so (and `expiresAt`, when given, is what it has). + * @returns {boolean} Whether anything was written. + */ + update(id, patch, options = {}) { + const item = book.item(id); + if (!item) return false; + let changed = + options.expiresAt !== undefined && + options.expiresAt !== book.expiresAt(id); + if (!changed) + for (const key of Object.keys(patch)) + if (!same(item[key], patch[key])) { + changed = true; + break; + } + if (!changed) return false; + icons.put({ ...item, ...patch }, options); + return true; + }, + setShown: (id, value) => icons.update(id, { show: value !== false }), + setFocus: (id, factor) => icons.update(id, { focus: factor }), + remove(id) { + if (!book.has(id)) return; + book.remove(id); + pending.delete(id); + if (sent.has(id)) { + removed.add(id); + schedule(); + } + }, + clear() { + for (const id of book.ids()) book.remove(id); + pending.clear(); + removed.clear(); + sent.clear(); + if (drawSet && !disposed) drawSet.clear(); + }, + /** Write what is waiting now. */ + flush, + dispose() { + for (const id of book.ids()) book.remove(id); + pending.clear(); + removed.clear(); + sent.clear(); + disposed = true; + drawSet?.dispose(); + }, + }; + return icons; +} + +let instances = 0; + +/** + * An aircraft layer's contacts as one icon draw set: each item's motion + * segment mirrors the layer's dead reckoning for the delayed display time, + * so the renderer moves every untracked contact between polls with no + * per-frame CPU pass. The layer keeps what it drew in `state._icons` + * (`createContactIcons`) and reads positions, courses, focus and expiry back + * from there. * - * The layer's state supplies `_icons`, `_iconPrimitive`, `_scratchIconRenderTime`, - * `_iconFocusActive`, `_positionHistory`, `_displayCourse`, `_groundSnap`, - * `_models`, `_trackedIcao`, `_viewer`, `_cockpitContactMode`, - * `_cockpitNearContacts` and `records` (`data`, `missingPolls`, `forget`). - * `parts.motion._motionRegime` picks the motion; `parts.rendering` supplies - * the icon kind, scale, colours and distance scalars, and `_releaseModel`. + * The layer's state supplies `_icons`, `_iconFocusActive`, + * `_positionHistory`, `_displayCourse`, `_groundSnap`, `_models`, + * `_trackedIcao`, `_viewer`, `_cockpitContactMode`, `_cockpitNearContacts` + * and `records` (`data`, `missingPolls`, `forget`). `parts.motion` supplies + * `_motionRegime`, `_displayTimeAt` and `_fixEpochMs`; `parts.rendering` + * the icon kind, scale, colours, and `_releaseModel`. * * @param {object} options * @param {object} options.state The layer's mutable state. @@ -86,209 +250,243 @@ export function createAircraftIcons({ onForget = () => {}, }) { const { focusPassIsNeeded } = services.focus; - const scratchTime = new Cesium.JulianDate(); - const scratchPosition = new Cesium.Cartesian3(); - const scratchCull = new Cesium.Cartesian3(); - const scratchScaleByDistance = new Cesium.NearFarScalar(); + const delayMs = renderDelaySec * 1000; + // The near-image switch the rows were last written with (CSS px). + let switchPx = nearImageSwitchPx(1); - /** The delayed instant every untracked contact is drawn at. */ - function _displayTime(result = scratchTime) { - return Cesium.JulianDate.addSeconds( - Cesium.JulianDate.now(result), - -renderDelaySec, - result, + /** The delayed instant (epoch ms) every untracked contact is drawn at. */ + const _displayMs = () => Date.now() - delayMs; + + /** + * Create the draw set for one layer lifetime, drawn over depth and culled + * at the horizon on the delayed live clock. + * @returns {string} The set's id, for the sprite order. + */ + function _createIcons(viewer) { + const set = drawOf(viewer).icons({ + id: `${layerId}-icons:${++instances}`, + horizonCull: true, + motionClock: { kind: 'live', delayMs }, + }); + // Columns of no rows put the set's host in the scene now, where the + // sprite order finds it, rather than with its first contact. + set.setColumns?.({ ids: [] }); + switchPx = _imageSwitchPx(viewer); + state._icons = createContactIcons(set, { + capabilities: rendererOf(viewer)?.capabilities ?? null, + }); + return set.id; + } + + /** Let the draw set go (the layer is destroyed). */ + function _disposeIcons() { + state._icons?.dispose(); + state._icons = null; + } + + /** The near-image switch in CSS px for the scene's pixel ratio. */ + function _imageSwitchPx(viewer = state._viewer) { + return nearImageSwitchPx( + rendererOf(viewer)?.quality?.get?.()?.pixelRatio ?? 1, ); } - function _displayTau() { - return state._icons.seconds(_displayTime()); + /** Rewrite every row's image switch when the scene's pixel ratio moved. */ + function _syncImageSwitch() { + const next = _imageSwitchPx(); + if (next === switchPx || !state._icons) return; + switchPx = next; + for (const id of state._icons.ids()) _applyIconPresentation(id); } - /** Create the set and its primitive for one layer lifetime. */ - function _createIcons(viewer) { - state._icons = createIconSet({ epoch: _displayTime() }); - state._iconPrimitive = new IconSetPrimitive({ - set: state._icons, - renderTime: () => _displayTime(state._scratchIconRenderTime), - }); - viewer.scene.primitives.add(state._iconPrimitive); - return state._iconPrimitive; - } - - /** Where a contact is drawn right now, or null when it has no row. */ - function _iconPosition(icao24, result = new Cesium.Cartesian3()) { - const set = state._icons; - const row = set?.row(icao24) ?? -1; - return row < 0 ? null : set.position(row, _displayTau(), result); + /** Where a contact is drawn right now (into `result`), or null. */ + function _iconPosition(icao24, result) { + return state._icons?.position(icao24, _displayMs(), result) ?? null; } /** The nose direction a contact is drawn with right now. */ function _iconCourse(icao24) { - const set = state._icons; - const row = set?.row(icao24) ?? -1; - return row < 0 ? null : set.course(row, _displayTau()); + return state._icons?.course(icao24, _displayMs()) ?? null; } /** Whether the layer draws this contact's icon (not tracked, not model-owned). */ function _iconShown(icao24) { - const set = state._icons; - const row = set?.row(icao24) ?? -1; - return row >= 0 && set.shown(row); + const icons = state._icons; + return Boolean(icons?.has(icao24) && icons.shown(icao24)); } - /** The camera's horizon test, or null when there is no placed camera. */ + /** Show or hide a contact's icon. */ + function _setIconShown(icao24, shown) { + state._icons?.setShown(icao24, shown); + } + + /** The ellipsoid's horizon from the eye, or null with no placed camera. */ function _occluder() { - const camera = state._viewer?.camera; - return camera?.positionWC ? horizonOccluder(camera) : null; - } - - /** Whether a drawn row at `position` clears the camera's horizon, judged - * exactly as the icon shader judges it. No camera, no horizon. */ - function _aboveHorizon(row, position, occluder) { - return ( - !occluder || - occluder.isPointVisible( - state._icons.cullPoint(row, position, scratchCull), - ) - ); + const pose = state._viewer ? findCamera(state._viewer)?.pose() : null; + return pose?.position ? horizonFrom(pose.position) : null; } /** - * Write the segment the layer's dead reckoning would follow from now on: + * Whether an icon drawn at `position` clears the camera's horizon, judged + * as the draw port's horizon cull judges it (lifted to the cull height + * when drawn below it). No camera, no horizon. + */ + function _aboveHorizon(position, occluder) { + return !occluder || occluder.isPointVisible(liftedForHorizon(position)); + } + + /** + * Write the motion the layer's dead reckoning would follow from now on: * interpolation between the bracketing fixes, the warm-up arc back from the * oldest fix, or the coast arc past the newest. The displayed nose glides * from where it is onto the new course at the fleet's slew cap; a hovering - * contact keeps its nose. The row expires when the regime would change. + * contact keeps its nose. The item expires when the regime would change. * @param {string} icao24 * @param {{fromCourseDeg?: number|null}} [options] Nose to glide from when - * the row's own segment is not what was on screen (tracking handoff). + * the row's own motion is not what was on screen (tracking handoff). */ function _planIcon(icao24, { fromCourseDeg } = {}) { - const set = state._icons; - const row = set?.row(icao24) ?? -1; - if (row < 0 || holdsPlan(icao24)) return; + const icons = state._icons; + if (!icons?.has(icao24) || holdsPlan(icao24)) return; const history = state._positionHistory.get(icao24); if (!history?.length) return; const info = state.records.data.get(icao24); - const renderTime = _displayTime(); - const tau = set.seconds(renderTime); - const seg = set.segments; + const t = _displayMs(); + const renderTime = parts.motion._displayTimeAt(t); + const fixMs = parts.motion._fixEpochMs; const shownCourse = fromCourseDeg ?? - (set.expires(row) === -Infinity ? null : set.course(row, tau)); + (icons.expires(icao24) === -Infinity ? null : icons.course(icao24, t)); const regime = parts.motion._motionRegime(history, info, renderTime); let speed; + let motion; + let pos; + let course; let expiresAt = Infinity; if (regime.kind === 'between') { const { a, b, span, trackFrom, trackTo, chordCourse } = regime; speed = regime.speed; const blend = chordCourse == null ? 0 : regime.blend; + pos = clone(b.position); if (span > 0) { - writeLerpSegment(seg, row, { - from: a.position, - to: b.position, - t0: set.seconds(a.time), - t1: set.seconds(b.time), - course0Deg: - trackFrom + blend * norm180((chordCourse ?? 0) - trackFrom), + course = trackFrom + blend * norm180((chordCourse ?? 0) - trackFrom); + motion = { + kind: 'lerp', + from: clone(a.position), + to: pos, + t0: fixMs(a), + t1: fixMs(b), + course0Deg: course, courseSlopeDeg: norm180(trackTo - trackFrom) * (1 - blend), - }); + }; } else { - writeHoldSegment( - seg, - row, - b.position, - trackTo + blend * norm180((chordCourse ?? 0) - trackTo), - ); + course = trackTo + blend * norm180((chordCourse ?? 0) - trackTo); + motion = { kind: 'hold', courseDeg: course }; } - expiresAt = set.seconds(b.time); + expiresAt = fixMs(b); } else { const { fix, heading } = regime; speed = regime.speed; - const t0 = set.seconds(fix.time); - if (speed === 0) { - writeHoldSegment(seg, row, fix.position, heading); - } else { - writeArcSegment(seg, row, { - fix: fix.position, - t0, - minDt: regime.minDt, - maxDt: regime.maxDt, - speedMps: speed, - trackDeg: heading, - turnRateDps: regime.turnRateDps, - }); - } + const t0 = fixMs(fix); + pos = clone(fix.position); + course = heading; + motion = + speed === 0 + ? { kind: 'hold', courseDeg: heading } + : { + kind: 'arc', + fix: pos, + t0, + minDtS: regime.minDt, + maxDtS: regime.maxDt, + speedMps: speed, + trackDeg: heading, + turnRateDps: regime.turnRateDps, + }; // A warm-up's arc ends at its fix; a coast's runs to its limit. if (regime.maxDt === 0) expiresAt = t0; } // Below hover speed the nose holds what is on screen (or, for a new row, - // where this segment starts); above it, it glides on at the slew cap. + // where this motion starts); above it, it glides on at the slew cap. const hold = speed < COURSE_HOLD_SPEED_MPS; + let courseGlide; if (hold || shownCourse != null) { - writeCourseGlide( - seg, - row, - shownCourse ?? segmentCourse(seg, row, tau), - tau, - hold ? 0 : courseSlewCapDps(speed, courseMaxDps), - ); + const rateDps = hold ? 0 : courseSlewCapDps(speed, courseMaxDps); + const prev = icons.item(icao24); + // The same motion at the same rate: the glide under way goes on, as + // one started now from the course on screen would. + courseGlide = + fromCourseDeg == null && + prev?.courseGlide?.rateDps === rateDps && + same(prev.motion, motion) + ? prev.courseGlide + : { + fromCourseDeg: shownCourse ?? motionCourse(motion, course, t), + t0: t, + rateDps, + }; } - set.segmentWritten(row, expiresAt); + icons.update(icao24, { pos, course, motion, courseGlide }, { expiresAt }); } - /** Re-plan every row whose regime ended before `tau`. */ - function _replanExpired(tau) { - const set = state._icons; - const due = []; - for (let row = 0; row < set.count; row++) - if (set.expires(row) <= tau) due.push(set.idAt(row)); - for (const icao24 of due) _planIcon(icao24); + /** Re-plan every row whose regime ended by `t` (epoch ms). */ + function _replanExpired(t) { + for (const icao24 of state._icons.due(t)) _planIcon(icao24); } /** * Advance focus de-emphasis for every drawn row (and every row a fleet model * draws for, whose alpha reads it), only while a focus target exists or some - * row is still relaxing back to full emphasis. + * row is still relaxing back to full emphasis. Each row whose emphasis moved + * is written as its item. */ - function _focusIcons(tau, scene, camera, nowMs, target) { + function _focusIcons(t, nowMs, target) { if (!focusPassIsNeeded(target, state._iconFocusActive)) return; - const { advanceProjectedSpriteFocus, nearFarScalarValueAtDistance } = - services.focus; - const set = state._icons; + const { + advanceSpriteFocus, + focusAlphaNeedsWrite, + nearFarScalarValueAtDistance, + spriteFocusAtRest, + } = services.focus; + const icons = state._icons; + const viewer = state._viewer; + const query = viewer ? findQuery(viewer) : null; + const eye = viewer ? findCamera(viewer)?.pose()?.position : null; let active = 0; - for (let row = 0; row < set.count; row++) { - if (!set.shown(row) && !state._models.has(set.idAt(row))) continue; - const position = set.position(row, tau, scratchPosition); + for (const id of icons.ids()) { + if (!icons.shown(id) && !state._models.has(id)) continue; + const item = icons.item(id); + const current = item.focus ?? 1; + // Nothing tracked and nothing pending: it stays at full emphasis. + if (!target && current === 1 && spriteFocusAtRest(item.meta)) continue; + const position = icons.position(id, t); + const cameraDistance = eye ? distance(eye, position) : Number.NaN; const distanceScale = nearFarScalarValueAtDistance( - set.scaleByDistance(row, scratchScaleByDistance), - Cesium.Cartesian3.distance(camera.positionWC, position), + item.scaleByDistance, + cameraDistance, ); - const half = set.scale(row) * distanceScale * 0.5; - const focus = advanceProjectedSpriteFocus( - set.metaAt(row), - position, - scene, - camera, + const half = (item.scale ?? 1) * distanceScale * 0.5; + const focus = advanceSpriteFocus(item.meta, { + screenPosition: query?.project(position) ?? null, + cameraDistance, nowMs, target, - undefined, - set.width(row) * half, - set.height(row) * half, - ); - set.setFocus(row, focus.factor); + spriteHalfWidthPx: item.size[0] * half, + spriteHalfHeightPx: item.size[1] * half, + }); if (focus.active || focus.transitioning) active++; + if (focusAlphaNeedsWrite(current, focus.factor)) + icons.setFocus(id, focus.factor); } state._iconFocusActive = active; } /** Image, size, scale, tint and freshness for one row under the current - * normal/cockpit contract. Motion and rotation stay with the segment. */ + * normal/cockpit contract. Motion and course stay with `_planIcon`. */ function _applyIconPresentation(icao24) { - const set = state._icons; - const row = set?.row(icao24) ?? -1; - if (row < 0) return; + const icons = state._icons; + if (!icons?.has(icao24)) return; const rendering = parts.rendering; const info = state.records.data.get(icao24); const tracked = icao24 === state._trackedIcao; @@ -296,54 +494,50 @@ export function createAircraftIcons({ state._cockpitContactMode && !tracked && !state._cockpitNearContacts.has(icao24); - if (cockpitDot) { - const dot = iconAtlas.slot(cockpitContactDotImage(), COCKPIT_DOT_PX); - set.setImage(row, dot, dot); - set.setSize(row, cockpitContactSizePx, cockpitContactSizePx); - set.setScale(row, 1); - set.setScaleByDistance(row, COCKPIT_SCALE_BY_DISTANCE); - set.setColor(row, rendering._cockpitContactColor(icao24, info)); - set.setFlag(row, ICON_ROTATES, false); - } else { - set.setImage( - row, - iconAtlas.slot( - aircraftIcon(rendering._iconKind(icao24, info?.klass)), - FLEET_ICON_PX, - ), - iconAtlas.slot( - aircraftIcon( + const look = cockpitDot + ? { + image: cockpitDotImage(), + imageLod: undefined, + size: [cockpitContactSizePx, cockpitContactSizePx], + scale: 1, + scaleByDistance: COCKPIT_SCALE_BY_DISTANCE, + color: rgba(rendering._cockpitContactColor(icao24, info)), + rotationMode: 'screen', + } + : { + image: aircraftIcon( rendering._iconKind(icao24, info?.klass), - TRACKED_ICON_PX, + FLEET_ICON_PX, ), - TRACKED_ICON_PX, - ), - ); - const size = tracked ? 24 : 20; - set.setSize(row, size, size); - set.setScale(row, rendering._fleetBillboardScale(icao24, info?.klass)); - set.setScaleByDistance(row, NORMAL_SCALE_BY_DISTANCE); - set.setColor(row, rendering._fleetBillboardColor(icao24, info)); - set.setFlag(row, ICON_ROTATES, true); - } - set.setFlag(row, ICON_RECEDES, true); - set.setFlag( - row, - ICON_CULL_LIFT, - Number.isFinite(info?.renderAltitudeM) && - info.renderAltitudeM < ICON_CULL_LIFT_BELOW_M, - ); - set.setAlpha(row, state.records.missingPolls.get(icao24) ? 0.45 : 1); + imageLod: { + near: aircraftIcon( + rendering._iconKind(icao24, info?.klass), + TRACKED_ICON_PX, + ), + switchPx, + }, + size: tracked ? [24, 24] : [20, 20], + scale: rendering._fleetBillboardScale(icao24, info?.klass), + scaleByDistance: NORMAL_SCALE_BY_DISTANCE, + color: rgba(rendering._fleetBillboardColor(icao24, info)), + rotationMode: 'course', + }; + look.alpha = state.records.missingPolls.get(icao24) ? 0.45 : 1; + icons.update(icao24, look); } /** Add a row for a new contact, hidden while it is the tracked one. */ function _addIcon(icao24) { - const set = state._icons; - const row = set.add(icao24, { layer: layerId, id: icao24 }); + state._icons.put(_baseItem(icao24, icao24 !== state._trackedIcao), { + expiresAt: -Infinity, + }); _applyIconPresentation(icao24); _settleIcon(icao24); - set.setShown(row, icao24 !== state._trackedIcao); - return row; + } + + /** A new contact's item before it is styled or planned: at the origin. */ + function _baseItem(icao24, show) { + return baseContactItem(layerId, icao24, show); } /** @@ -354,11 +548,10 @@ export function createAircraftIcons({ * @param {{fromCourseDeg?: number}} [options] The course on screen to glide from. */ function _settleIcon(icao24, options) { - const set = state._icons; - const row = set?.row(icao24) ?? -1; - if (row < 0) return; + const icons = state._icons; + if (!icons?.has(icao24)) return; beforeSettle(icao24); - if (set.focus(row) < 1) state._iconFocusActive += 1; + if (icons.focus(icao24) < 1) state._iconFocusActive += 1; _planIcon(icao24, options); afterSettle(icao24); } @@ -376,19 +569,18 @@ export function createAircraftIcons({ /** Icon ids, so ray samples never land on an aircraft instead of the ground. */ function _iconIds() { - const set = state._icons; - const ids = new Array(set?.count ?? 0); - for (let row = 0; row < ids.length; row++) ids[row] = set.idAt(row); - return ids; + return state._icons?.ids() ?? []; } return { - _displayTime, - _displayTau, + _displayMs, _createIcons, + _disposeIcons, + _syncImageSwitch, _iconPosition, _iconCourse, _iconShown, + _setIconShown, _occluder, _aboveHorizon, _planIcon, @@ -402,6 +594,28 @@ export function createAircraftIcons({ }; } +/** + * A contact's icon item before it is styled or planned: held at the origin + * (as a fresh row of the icon set was), always drawn over depth, receding + * toward the limb, picked as `{layer, id}`. Its image comes with its style + * (`_applyIconPresentation`), before the item is first written. + */ +function baseContactItem(layerId, icao24, show) { + return { + id: icao24, + pos: { x: 0, y: 0, z: 0 }, + motion: { kind: 'hold', courseDeg: 0 }, + course: 0, + size: [20, 20], + rotationMode: 'course', + recede: true, + disableDepthTest: Infinity, + focus: 1, + show, + meta: { layer: layerId, id: icao24 }, + }; +} + /** * Test seams over an aircraft layer's icon rows, shared by the flights and * military `testing` parts. @@ -410,15 +624,24 @@ export function createAircraftIcons({ * @param {string} layerId */ export function aircraftIconTestSeams(state, parts, layerId) { + /** A hold at `position` on course 0, planned to hold. */ + const held = (position) => ({ + pos: clone(position), + motion: { kind: 'hold', courseDeg: 0 }, + course: 0, + courseGlide: undefined, + }); + /** Give a test contact an icon row held at `icon.position`, shown as * `icon.show` says (hidden by default while tracked). */ function _seedIconForTest(icao24, icon, tracked) { - const set = state._icons; - const row = set.add(icao24, { layer: layerId, id: icao24 }); - if (icon?.position) writeHoldSegment(set.segments, row, icon.position, 0); - set.segmentWritten(row); - set.setShown(row, icon?.show ?? !tracked); - return row; + state._icons.put( + { + ...baseContactItem(layerId, icao24, icon?.show ?? !tracked), + ...(icon?.position ? held(icon.position) : null), + }, + { expiresAt: Infinity }, + ); } /** Where a contact's icon is drawn now and whether the layer shows it. */ @@ -435,14 +658,10 @@ export function aircraftIconTestSeams(state, parts, layerId) { /** Show or hide a contact's icon as a handoff would, or hold it somewhere. */ function _setIconForTest(icao24, { shown, position } = {}) { - const set = state._icons; - const row = set?.row(icao24) ?? -1; - if (row < 0) return; - if (shown !== undefined) set.setShown(row, shown); - if (position) { - writeHoldSegment(set.segments, row, position, 0); - set.segmentWritten(row); - } + const icons = state._icons; + if (!icons?.has(icao24)) return; + if (shown !== undefined) icons.setShown(icao24, shown); + if (position) icons.update(icao24, held(position), { expiresAt: Infinity }); } return { _seedIconForTest, _iconForTest, _setIconForTest }; diff --git a/src/data/aircraftModelLayer.js b/src/data/aircraftModelLayer.js index ef6160165..82abcf057 100644 --- a/src/data/aircraftModelLayer.js +++ b/src/data/aircraftModelLayer.js @@ -1,6 +1,5 @@ import * as Cesium from 'cesium'; import { selectModelEligible } from './modelEligibility.js'; -import { horizonOccluder } from './iconOrientation.js'; import { aircraftTreatmentAlpha } from './aircraftRecession.js'; import { AIRCRAFT_ENVIRONMENT_MAP_OPTIONS } from './aircraftModelLighting.js'; import { @@ -30,7 +29,7 @@ import { * including the tracked contact's. * @param {(icao24: string) => void} [options.onModelEligible] Runs when a * contact is about to render in 3D. - * @param {(renderTime: Cesium.JulianDate, tau: number, nowMs: number, + * @param {(renderTime: Cesium.JulianDate, t: number, nowMs: number, * camera: Cesium.Camera) => void} [options.afterReplan] The layer's own pass * in the fleet tick, after expired rows are re-planned. */ @@ -189,17 +188,10 @@ export function createAircraftModels({ * `beforeShow` runs only on the committing path — the per-tick model treatment * belongs to a model that is about to draw, not to one still waiting. */ - function _driveFleetModelHandoff( - icao24, - record, - row, - pos, - course, - beforeShow, - ) { + function _driveFleetModelHandoff(icao24, record, pos, course, beforeShow) { const icons = state._icons; if (!record) { - icons.setShown(row, true); + icons.setShown(icao24, true); return false; } const displayPos = _modelDisplayPosition( @@ -209,7 +201,7 @@ export function createAircraftModels({ ); if (!displayPos) { showModel(record, false); // no ground evidence → nothing safe to place a depth-tested model at - icons.setShown(row, true); + icons.setShown(icao24, true); return false; } // The matrix is written BEFORE the readiness test on purpose: a model can flip @@ -226,12 +218,12 @@ export function createAircraftModels({ ); if (!record.model.ready) { showModel(record, false); // not loaded yet → keep the 2D icon, no half-model flash - icons.setShown(row, true); + icons.setShown(icao24, true); return false; } beforeShow?.(); if (!record.show) showModel(record, true); - icons.setShown(row, false); // hand off ONLY once the model renders + icons.setShown(icao24, false); // hand off ONLY once the model renders return true; } @@ -509,8 +501,8 @@ export function createAircraftModels({ function _showReleasedIcon(icao24) { const icons = state._icons; - const row = icons?.row(icao24) ?? -1; - if (row >= 0 && icao24 !== state._trackedIcao) icons.setShown(row, true); + if (icons?.has(icao24) && icao24 !== state._trackedIcao) + icons.setShown(icao24, true); } /** Destroy the standalone tracked-aircraft model and invalidate any in-flight load. */ @@ -551,7 +543,7 @@ export function createAircraftModels({ // readout consumers then reuse that exact cached position. const pos = parts.motion._trackedDisplayPosition(state._trackedIcao) || - parts.icons._iconPosition(state._trackedIcao); + parts.icons._iconPosition(state._trackedIcao, new Cesium.Cartesian3()); if (!pos) { if (state._trackedModel) showModel(state._trackedModel, false); return; @@ -631,7 +623,10 @@ export function createAircraftModels({ // default here produces a one-frame jump to the Earth's center. const currentPos = parts.motion._trackedDisplayCached() || - parts.icons._iconPosition(state._trackedIcao); + parts.icons._iconPosition( + state._trackedIcao, + new Cesium.Cartesian3(), + ); if (currentPos) { const displayPos = _modelDisplayPosition( state._trackedIcao, @@ -710,33 +705,45 @@ export function createAircraftModels({ /** * ~12 Hz fleet pass. Motion, rotation, the horizon cull, limb recession and - * the two-tier glyph swap all run on the GPU from each row's segment, so this - * only re-plans rows whose regime ended, runs the layer's own pass after + * the two-tier glyph swap all run on the GPU from each icon's motion, so this + * only re-plans icons whose regime ended, runs the layer's own pass after * that (flights floors grounded contacts), advances focus de-emphasis while * a target exists, and drives the 3D-model handoff inside the model regime. - * Driven by scene.preRender. + * Driven by scene.preRender: what it writes is flushed to the draw set + * before the frame draws, as the 3D models it shows and hides are. * @returns {void} */ function _fleetTick() { + try { + _fleetPass(); + } finally { + state._icons?.flush(); + } + } + + function _fleetPass() { const icons = state._icons; if (!state._viewer || !icons || !icons.show) return; - const scene = state._viewer.scene; const camera = state._viewer.camera; const nowMs = focusNowMs(Date.now()); if (nowMs - state._lastFleetTickMs < policy.FLEET_DR_INTERVAL_MS) return; state._lastFleetTickMs = nowMs; // Every contact in this pass shares the same delayed display instant. - const renderTime = parts.icons._displayTime(state._scratchFleetRenderTime); - const tau = icons.seconds(renderTime); + const t = parts.icons._displayMs(); + const renderTime = parts.motion._displayTimeAt( + t, + state._scratchFleetRenderTime, + ); _drainIrReloadQueue(); // bounded per-tick slice of any pending boost-flip reload if (state._cockpitContactMode) parts.tracking._refreshCockpitNearContacts(); - parts.icons._replanExpired(tau); - afterReplan(renderTime, tau, nowMs, camera); + parts.icons._syncImageSwitch(); + parts.icons._replanExpired(t); + afterReplan(renderTime, t, nowMs, camera); const focusTarget = getFocusTarget(); - parts.icons._focusIcons(tau, scene, camera, nowMs, focusTarget); + parts.icons._focusIcons(t, nowMs, focusTarget); // 3D model regime: only when enabled AND the camera is zoomed in past the altitude ceiling. // Drop all models the moment we leave it (toggled off / zoomed out) so icons resume. @@ -769,8 +776,7 @@ export function createAircraftModels({ ); // Candidates = planes within the KEEP radius, nearest first, each tagged with on-screen-ness. const cand = []; - for (let row = 0; row < icons.count; row++) { - const icao = icons.idAt(row); + for (const icao of icons.ids()) { if (icao === state._trackedIcao) continue; // A converted TR-3B renders as an icon and can never take a model, so // it must not occupy a CAP SLOT either — excluded here at selection time, @@ -782,7 +788,7 @@ export function createAircraftModels({ // ground or in the air — no distinction"). The cap + nearest-first ordering // below already bound airport clusters; grounded placement is handled by the // one-shot ground snap in _modelDisplayPosition. - const position = icons.position(row, tau, state._scratchModelBS.center); + const position = icons.position(icao, t, state._scratchModelBS.center); const d2 = Cesium.Cartesian3.distanceSquared(camPos, position); if (d2 > keepDistSq) continue; // beyond the keep radius → never eligible cand.push([ @@ -816,13 +822,12 @@ export function createAircraftModels({ // modelless (the "planes vanish when 3D turns on" bug). Position the model every tick // regardless so it's framed the instant it becomes ready. Converted TR-3Bs stay 2D on // purpose: the Easter egg IS the triangle, and there is no GLB for it. - const occluder = horizonOccluder(camera); + const occluder = parts.icons._occluder(); for (const icao24 of modelEligible) { if (isTr3b(icao24)) continue; - const row = icons.row(icao24); - if (row < 0) continue; - const position = icons.position(row, tau, state._scratchFleetPos); - if (!parts.icons._aboveHorizon(row, position, occluder)) { + if (!icons.has(icao24)) continue; + const position = icons.position(icao24, t, state._scratchFleetPos); + if (!parts.icons._aboveHorizon(position, occluder)) { // A model that crossed the limb would keep rendering through the // hidden globe at its last matrix; the icon's own cull is on the GPU. const hidden = state._models.get(icao24); @@ -835,9 +840,8 @@ export function createAircraftModels({ _driveFleetModelHandoff( icao24, record, - row, position, - icons.course(row, tau), + icons.course(icao24, t), () => { applyAircraftModelTreatment({ model: record.model, @@ -852,8 +856,8 @@ export function createAircraftModels({ alpha: state._irBoost ? 1 : aircraftTreatmentAlpha({ - baseAlpha: icons.alpha(row), - focusFactor: icons.focus(row), + baseAlpha: icons.alpha(icao24), + focusFactor: icons.focus(icao24), cameraDistanceM, cameraHeightM: camera.positionCartographic?.height, }), diff --git a/src/data/aircraftMotionRegime.js b/src/data/aircraftMotionRegime.js index dcbe36e26..af1aa522f 100644 --- a/src/data/aircraftMotionRegime.js +++ b/src/data/aircraftMotionRegime.js @@ -25,6 +25,21 @@ export function fixTrackDeg(fix, info, fields) { : (info && info[fields.track]) || 0; } +/** + * The instant `epochMs` as a JulianDate (into `result` when given), for + * `aircraftMotionRegime`'s `renderTime`. + */ +export function julianAt(epochMs, result) { + return Cesium.JulianDate.fromDate(new Date(epochMs), result); +} + +/** A history fix's time in epoch ms: its `epochMs`, else its `time`'s. */ +export function fixEpochMs(fix) { + return Number.isFinite(fix.epochMs) + ? fix.epochMs + : Cesium.JulianDate.toDate(fix.time).getTime(); +} + /** A reusable result for `aircraftMotionRegime`. */ export function createMotionRegime() { return { diff --git a/src/data/cockpitModels.test.mjs b/src/data/cockpitModels.test.mjs index a39ae2954..336d29a03 100644 --- a/src/data/cockpitModels.test.mjs +++ b/src/data/cockpitModels.test.mjs @@ -84,25 +84,25 @@ for (const layer of LAYERS) { test(`${layer.name}: near AIR state is independent from model admission`, () => { assert.match(source, /nextCockpitNearContacts\(/, 'Cockpit derives a separate near-contact hysteresis set'); - assert.match(source, /!state\._cockpitNearContacts\.has\(icao24\);\s*if \(cockpitDot\) \{\s*const dot = iconAtlas\.slot\(cockpitContactDotImage\(\)/, + assert.match(source, /!state\._cockpitNearContacts\.has\(icao24\);\s*const look = cockpitDot\s*\?\s*\{\s*image: cockpitDotImage\(\)/, 'only out-of-range Cockpit contacts become dots'); // `_iconKind` is identity for every unconverted contact (see // tr3bRegistry.test.mjs) — it only swaps the glyph for a contact the // operator explicitly converted into a TR-3B. - assert.match(source, /aircraftIcon\(\s*(?:parts\.)?rendering\._iconKind\(icao24, info\?\.klass\),?\s*\)/, + assert.match(source, /aircraftIcon\(\s*(?:parts\.)?rendering\._iconKind\(icao24, info\?\.klass\),?\s*(?:FLEET_ICON_PX,?\s*)?\)/, 'near contacts and model fallbacks retain the class-derived aircraft silhouette'); - assert.match(source, /set\.setFlag\(row, ICON_ROTATES, false\);/, + assert.match(source, /color: rgba\(rendering\._cockpitContactColor\(icao24, info\)\),\s*rotationMode: 'screen',/, 'far dots are reset to a rotation-free presentation'); - assert.match(source, /set\.setFlag\(row, ICON_ROTATES, true\);/, + assert.match(source, /color: rgba\(rendering\._fleetBillboardColor\(icao24, info\)\),\s*rotationMode: 'course',/, 'near 2D silhouettes continue to receive projected course'); - assert.match(source, /icons\.setShown\(row, false\);\s*\/\/\s*hand\s*off\s*ONLY\s*once\s*the\s*model\s*renders/, + assert.match(source, /icons\.setShown\(icao24, false\);\s*\/\/\s*hand\s*off\s*ONLY\s*once\s*the\s*model\s*renders/, 'the gap-proof icon-to-model handoff remains intact'); }); test(`${layer.name}: Cockpit exit clears near state before restoring map presentation`, () => { const setMode = /^([ \t]*)function _setCockpitContactMode\b[\s\S]*?\n\1\}/m.exec(source)?.[0]; assert.match(setMode, /else\s*(?:(?:flightState|state)\.)?_cockpitNearContacts\s*=\s*new\s*Set\(\s*,?\s*\);/); - assert.match(setMode, /for \(let row = 0; row < \(icons\?\.count \?\? 0\); row\+\+\)\s*parts\.icons\._applyIconPresentation\(icons\.idAt\(row\)\);/); + assert.match(setMode, /for \(const icao24 of (?:flightState\._)?icons\?\.ids\(\) \?\? \[\]\)\s*parts\.icons\._applyIconPresentation\(icao24\);/); }); } diff --git a/src/data/modelScale.test.mjs b/src/data/modelScale.test.mjs index 39809abcf..7cfeddd09 100644 --- a/src/data/modelScale.test.mjs +++ b/src/data/modelScale.test.mjs @@ -372,8 +372,8 @@ function normalBillboardScaleByDistance(sourceFile) { const src = readLayerSource(path.join(ROOT, sourceFile)); const fn = src.match(/const NORMAL_SCALE_BY_DISTANCE = ([\s\S]*?\);)/); assert.ok(fn, `${sourceFile}: NORMAL_SCALE_BY_DISTANCE not found`); - const scalar = fn[1].match(/NearFarScalar\(\s*(\d+),\s*([\d.]+),\s*(\d+),\s*([\d.]+),?\s*\)/); - assert.ok(scalar, `${sourceFile}: billboard NearFarScalar not found`); + const scalar = fn[1].match(/near: (\d+),\s*nearValue: ([\d.]+),\s*far: (\d+),\s*farValue: ([\d.]+),?\s*\}/); + assert.ok(scalar, `${sourceFile}: icon scale-by-distance not found`); return scalar.slice(1).map(Number); } diff --git a/src/data/tr3bRegistry.test.mjs b/src/data/tr3bRegistry.test.mjs index f30b578fe..37c6aef45 100644 --- a/src/data/tr3bRegistry.test.mjs +++ b/src/data/tr3bRegistry.test.mjs @@ -245,7 +245,7 @@ test('both flight layers keep a converted contact 2D and visible (render invaria // 2. The icon is never hidden by that suppression — it must keep // satisfying the getNearby/getDetectableObjects visibility guards, so a // converted contact still works in Contacts and Cockpit. - assert.match(source, /if\s*\(\s*row >= 0\s*&&\s*id\s*!==\s*flightState\._trackedIcao\s*\)\s*flightState\._icons\.setShown\(row, true\);/, + assert.match(source, /if\s*\(\s*flightState\._icons\?\.has\(id\)\s*&&\s*id\s*!==\s*flightState\._trackedIcao\s*\)\s*flightState\._icons\.setShown\(id, true\);/, `${name}: converting restores the icon the model handoff had hidden`); // 3. Every aircraftIcon() CALL SITE routes through the kind resolver, so no @@ -411,7 +411,7 @@ test('a converted contact never consumes a 3D model CAP SLOT', async () => { const source = readLayerSource(new URL(`./${name}`, import.meta.url)); // Anchor on the MODEL-eligibility loop (keepDistSq), not the unrelated // ambient-enrichment candidate loop that also builds a `cand`. - const loop = /const\s*cand\s*=\s*\[\];\s*\n\s*for\s*\(let row = 0; row < icons\.count; row\+\+\)[\s\S]*?cand\.push\(\s*/.exec(source)?.[0]; + const loop = /const\s*cand\s*=\s*\[\];\s*\n\s*for\s*\(const icao of icons\.ids\(\)\)[\s\S]*?cand\.push\(\s*/.exec(source)?.[0]; assert.ok(loop, `${name}: the model-eligibility candidate loop is present`); assert.match(loop, /keepDistSq/, `${name}: matched the model-eligibility loop`); assert.match(loop, /if \(isTr3b\(icao\)\) continue;/, diff --git a/src/layers/flights/enrichment.js b/src/layers/flights/enrichment.js index b174591a0..96fc5ea16 100644 --- a/src/layers/flights/enrichment.js +++ b/src/layers/flights/enrichment.js @@ -193,15 +193,14 @@ export function createEnrichment({ ); const cand = []; const icons = flightState._icons; - const tau = parts.icons._displayTau(); - for (let row = 0; row < icons.count; row++) { - const icao24 = icons.idAt(row); + const t = parts.icons._displayMs(); + for (const icao24 of icons.ids()) { if (flightState._enrichSeen.has(`t:${icao24}`)) continue; // answered / queued / negative this session if (!/^[0-9a-f]{6}$/i.test(icao24)) continue; // adsbdb keys are 6-char hex only if (flightState.records.data.get(icao24)?.onGround) continue; // ground traffic never spends ambient budget (click-to-enrich still works) const position = icons.position( - row, - tau, + icao24, + t, flightState._scratchModelBS.center, ); if (!occluder.isPointVisible(position)) continue; // beyond the limb diff --git a/src/layers/flights/evidence.js b/src/layers/flights/evidence.js index 0e02411f1..e08749869 100644 --- a/src/layers/flights/evidence.js +++ b/src/layers/flights/evidence.js @@ -1,11 +1,9 @@ import * as Cesium from 'cesium'; import { FOCUS_EVIDENCE_DEV } from './policy.js'; -import { writeHoldSegment } from '../../data/iconSegment.js'; import { aircraftRecessionFactors, aircraftTreatmentAlpha, } from '../../data/aircraftRecession.js'; -import { horizonOccluder } from '../../data/iconOrientation.js'; export function createEvidence({ flightState, @@ -41,6 +39,16 @@ export function createEvidence({ ); } + /** An icon item's motion held at `position` on `courseDeg`. */ + function _heldAt(position, courseDeg) { + return { + pos: { x: position.x, y: position.y, z: position.z }, + course: courseDeg, + motion: { kind: 'hold', courseDeg }, + courseGlide: undefined, + }; + } + /** Replace the real fleet with deterministic explicit-position contacts. */ function _setFocusEvidenceAircraft(records = []) { @@ -85,9 +93,9 @@ export function createEvidence({ flightState.records.data.set(id, meta); flightState._focusEvidenceIds.add(id); parts.icons._addIcon(id); - const row = icons.row(id); - writeHoldSegment(icons.segments, row, position, meta.true_track); - icons.segmentWritten(row); + icons.update(id, _heldAt(position, meta.true_track), { + expiresAt: Infinity, + }); } flightState.feed._count = icons.count; flightState._lastFleetTickMs = 0; @@ -106,21 +114,16 @@ export function createEvidence({ .toLowerCase(); if (!flightState._focusEvidenceIds.has(id)) continue; const position = _focusEvidencePosition(record); - const row = flightState._icons?.row(id) ?? -1; - if (!position || row < 0) continue; + if (!position || !flightState._icons?.has(id)) continue; const meta = flightState.records.data.get(id); if (meta) { if (Number.isFinite(record.trackDeg)) meta.true_track = record.trackDeg; if (Number.isFinite(record.velocityMps)) meta.velocity = record.velocityMps; } - writeHoldSegment( - flightState._icons.segments, - row, - position, - meta?.true_track ?? 0, - ); - flightState._icons.segmentWritten(row); + flightState._icons.update(id, _heldAt(position, meta?.true_track ?? 0), { + expiresAt: Infinity, + }); moved += 1; } flightState._lastFleetTickMs = 0; @@ -134,11 +137,12 @@ export function createEvidence({ if (!FOCUS_EVIDENCE_DEV || !flightState._viewer) return []; const icons = flightState._icons; const { scene, camera } = flightState._viewer; - const occluder = horizonOccluder(camera); + const occluder = parts.icons._occluder(); const cameraHeightM = camera.positionCartographic?.height; return [...flightState._focusEvidenceIds].map((id) => { - const row = icons?.row(id) ?? -1; - const position = row < 0 ? null : parts.icons._iconPosition(id); + const position = icons?.has(id) + ? parts.icons._iconPosition(id, new Cesium.Cartesian3()) + : null; const cameraDistanceM = position ? Cesium.Cartesian3.distance(camera.positionWC, position) : null; @@ -154,13 +158,13 @@ export function createEvidence({ id, show: !!position && - icons.shown(row) && - parts.icons._aboveHorizon(row, position, occluder), - scale: factors ? icons.scale(row) * factors.scale : null, + icons.shown(id) && + parts.icons._aboveHorizon(position, occluder), + scale: factors ? icons.scale(id) * factors.scale : null, alpha: position ? aircraftTreatmentAlpha({ - baseAlpha: icons.alpha(row), - focusFactor: icons.focus(row), + baseAlpha: icons.alpha(id), + focusFactor: icons.focus(id), cameraDistanceM, cameraHeightM, }) diff --git a/src/layers/flights/icons.js b/src/layers/flights/icons.js index 10967dc73..af1a8d996 100644 --- a/src/layers/flights/icons.js +++ b/src/layers/flights/icons.js @@ -1,11 +1,7 @@ -import * as Cesium from 'cesium'; -import { courseSlewCapDps, norm180 } from '../../data/motionModel.js'; -import { - segmentTargetCourse, - writeCourseGlide, - writeHoldSegment, -} from '../../data/iconSegment.js'; +import { courseSlewCapDps } from '../../data/motionModel.js'; import { createAircraftIcons } from '../../data/aircraftIconLayer.js'; +import { motionCourse } from '../../render/motion/iconMotion.js'; +import { distanceSquared, norm180 } from '../../geo/vector.js'; import { COCKPIT_CONTACT_SIZE_PX, COURSE_MAX_DPS, @@ -24,7 +20,6 @@ const PIN_TURN_DEG = 0.1; * planned, and settling a grounded contact puts it straight onto the floor. */ export function createIcons({ flightState, services, parts }) { - const scratchPosition = new Cesium.Cartesian3(); const icons = createAircraftIcons({ state: flightState, services, @@ -42,13 +37,8 @@ export function createIcons({ flightState, services, parts }) { // until the next fleet tick raises it. afterSettle(icao24) { if (!flightState._grounded.has(icao24)) return; - const renderTime = icons._displayTime(); - _floorIcon( - icao24, - renderTime, - flightState._icons.seconds(renderTime), - Date.now(), - ); + const t = icons._displayMs(); + _floorIcon(icao24, parts.motion._displayTimeAt(t), t, Date.now()); }, onForget(icao24) { flightState._displayFloorState.delete(icao24); @@ -59,11 +49,16 @@ export function createIcons({ flightState, services, parts }) { /** * Grounded contacts stand on the floor under where they are DRAWN, which the - * GPU cannot sample. While the floor lifts one, the CPU pins its row to a - * hold at the floored dead-reckoned position each tick (rewritten only when - * it moved); once nothing lifts it the row goes back to its planned segment. + * renderer cannot sample. While the floor lifts one, the CPU pins its item + * to a hold at the floored dead-reckoned position each tick (rewritten only + * when it moved); once nothing lifts it the item goes back to its planned + * motion. + * @param {object} renderTime The display instant (the motion part's `_displayTimeAt`). + * @param {number} t The same instant, epoch ms. + * @param {number} nowMs + * @param {{x: number, y: number, z: number}|null} cameraPosition The eye. */ - function _floorGroundedIcons(renderTime, tau, nowMs, cameraPosition) { + function _floorGroundedIcons(renderTime, t, nowMs, cameraPosition) { const set = flightState._icons; // Past FLOOR_NEAR_M a taxiing contact moves well under a pixel per tick, // so far rows take turns: each refreshes every FLOOR_FAR_EVERY_TICKS. Their @@ -71,28 +66,25 @@ export function createIcons({ flightState, services, parts }) { // out there too — sub-pixel at that range, and full rate once near. const turn = flightState._floorTick++ % FLOOR_FAR_EVERY_TICKS; const nearSq = FLOOR_NEAR_M * FLOOR_NEAR_M; + let index = -1; for (const icao24 of flightState._grounded) { if (icao24 === flightState._trackedIcao) continue; - const row = set.row(icao24); - if (row < 0) continue; + if (!set.has(icao24)) continue; + index += 1; if ( - row % FLOOR_FAR_EVERY_TICKS !== turn && + index % FLOOR_FAR_EVERY_TICKS !== turn && cameraPosition && - Cesium.Cartesian3.distanceSquared( - cameraPosition, - set.position(row, tau, scratchPosition), - ) > nearSq + distanceSquared(cameraPosition, set.position(icao24, t)) > nearSq ) continue; - _floorIcon(icao24, renderTime, tau, nowMs); + _floorIcon(icao24, renderTime, t, nowMs); } } /** One grounded contact's floor pass (see `_floorGroundedIcons`). */ - function _floorIcon(icao24, renderTime, tau, nowMs) { + function _floorIcon(icao24, renderTime, t, nowMs) { const set = flightState._icons; - const row = set.row(icao24); - if (row < 0) return; + if (!set?.has(icao24)) return; const info = flightState.records.data.get(icao24); const raw = parts.motion._deadReckon( icao24, @@ -112,35 +104,40 @@ export function createIcons({ flightState, services, parts }) { ); if (!display || display === raw) { if (flightState._floorPinned.delete(icao24)) - icons._planIcon(icao24, { fromCourseDeg: set.course(row, tau) }); + icons._planIcon(icao24, { fromCourseDeg: set.course(icao24, t) }); return; } - const planned = set.expires(row) !== -Infinity; - const prev = planned ? set.course(row, tau) : null; - // The pin holds the position; the GPU glides the course onto the target, - // so the rate stays exact however seldom the pin is rewritten. + const planned = set.expires(icao24) !== -Infinity; + const prev = planned ? set.course(icao24, t) : null; + // The pin holds the position; the renderer glides the course onto the + // target, so the rate stays exact however seldom the pin is rewritten. const target = hold && prev != null ? prev : rawCourse; + const item = set.item(icao24); if ( flightState._floorPinned.has(icao24) && - Cesium.Cartesian3.distanceSquared( - display, - set.position(row, tau, scratchPosition), - ) <= PIN_MOVE_SQ_M && - Math.abs(norm180(target - segmentTargetCourse(set.segments, row, tau))) <= + distanceSquared(display, set.position(icao24, t)) <= PIN_MOVE_SQ_M && + Math.abs(norm180(target - motionCourse(item.motion, item.course, t))) <= PIN_TURN_DEG ) return; flightState._floorPinned.add(icao24); - writeHoldSegment(set.segments, row, display, target); - if (prev != null) - writeCourseGlide( - set.segments, - row, - prev, - tau, - courseSlewCapDps(speed, COURSE_MAX_DPS), - ); - set.segmentWritten(row); + set.update( + icao24, + { + pos: { x: display.x, y: display.y, z: display.z }, + course: target, + motion: { kind: 'hold', courseDeg: target }, + courseGlide: + prev == null + ? undefined + : { + fromCourseDeg: prev, + t0: t, + rateDps: courseSlewCapDps(speed, COURSE_MAX_DPS), + }, + }, + { expiresAt: Infinity }, + ); } return { ...icons, _floorGroundedIcons }; diff --git a/src/layers/flights/icons.test.mjs b/src/layers/flights/icons.test.mjs index 1357e93ac..ba7cdd209 100644 --- a/src/layers/flights/icons.test.mjs +++ b/src/layers/flights/icons.test.mjs @@ -3,12 +3,16 @@ import assert from 'node:assert/strict'; import * as Cesium from 'cesium'; import { createFlightState } from './state.js'; import { createIcons } from './icons.js'; -import { createIconSet } from '../../data/iconSet.js'; -import { writeHoldSegment } from '../../data/iconSegment.js'; +import { createContactIcons } from '../../data/aircraftIconLayer.js'; function services(focus = {}) { return { - focus: { focusPassIsNeeded: () => true, ...focus }, + focus: { + focusPassIsNeeded: () => true, + focusAlphaNeedsWrite: (a, b) => Math.abs(a - b) > 1e-3, + spriteFocusAtRest: () => false, + ...focus, + }, groundSnap: { createGroundSnap: () => ({ clear() {}, forget() {} }) }, }; } @@ -16,20 +20,35 @@ function services(focus = {}) { function setup({ focus, motion = {}, rendering = {} } = {}) { const svc = services(focus); const flightState = createFlightState({ services: svc }); - flightState._icons = createIconSet(); + flightState._icons = createContactIcons(); const parts = { - motion, + motion: { + _displayTimeAt: (ms) => Cesium.JulianDate.fromDate(new Date(ms)), + _fixEpochMs: (fix) => Cesium.JulianDate.toDate(fix.time).getTime(), + ...motion, + }, rendering: { _modelOwnsVisual: () => false, ...rendering }, }; const icons = createIcons({ flightState, services: svc, parts }); return { flightState, icons, set: flightState._icons }; } -function hold(set, id, position, course = 0) { - const row = set.add(id, { layer: 'flights', id }); - writeHoldSegment(set.segments, row, position, course); - set.segmentWritten(row); - return row; +function hold(set, id, position, course = 0, show = false) { + set.put( + { + id, + pos: { x: position.x, y: position.y, z: position.z }, + motion: { kind: 'hold', courseDeg: course }, + course, + size: [20, 20], + scale: 1, + show, + focus: 1, + meta: { layer: 'flights', id }, + }, + { expiresAt: Infinity }, + ); + return id; } const at = (lon, h = 1000) => Cesium.Cartesian3.fromDegrees(lon, 30, h); @@ -39,18 +58,18 @@ test('focus advances for drawn rows and for rows a fleet model draws for', () => const { flightState, icons, set } = setup({ focus: { nearFarScalarValueAtDistance: () => 1, - advanceProjectedSpriteFocus(meta) { + advanceSpriteFocus(meta) { advanced.push(meta.id); return { factor: 0.4, active: true }; }, }, }); - set.setShown(hold(set, 'drawn', at(0)), true); + hold(set, 'drawn', at(0), 0, true); const modeled = hold(set, 'modeled', at(0.1)); hold(set, 'hidden', at(0.2)); flightState._models.set('modeled', {}); - icons._focusIcons(0, {}, { positionWC: at(0, 50_000) }, 0, {}); + icons._focusIcons(0, 0, {}); assert.deepEqual(advanced, ['drawn', 'modeled']); assert.ok( Math.abs(set.focus(modeled) - 0.4) < 1e-6, @@ -90,9 +109,9 @@ test('settling a pinned grounded contact re-floors it where it is now, nose kept flightState._positionHistory.set('g', [{}]); icons._settleIcon('g', { fromCourseDeg: 123 }); - const tau = icons._displayTau(); - assert.ok(Cesium.Cartesian3.distance(set.position(row, tau), floored) < 0.01); - assert.ok(Math.abs(set.course(row, tau) - 123) < 1e-3, 'tracked nose kept'); + const t = icons._displayMs(); + assert.ok(Cesium.Cartesian3.distance(set.position(row, t), floored) < 0.01); + assert.ok(Math.abs(set.course(row, t) - 123) < 1e-3, 'tracked nose kept'); assert.ok(flightState._floorPinned.has('g'), 'pinned on the new floor'); }); @@ -102,7 +121,7 @@ test('a contact that comes back dimmed re-arms the idle focus pass', () => { focus: { focusPassIsNeeded: (target, active) => target != null || active > 0, nearFarScalarValueAtDistance: () => 1, - advanceProjectedSpriteFocus(meta) { + advanceSpriteFocus(meta) { advanced.push(meta.id); return { factor: 1, active: false, transitioning: false }; }, @@ -114,7 +133,7 @@ test('a contact that comes back dimmed re-arms the idle focus pass', () => { flightState._iconFocusActive = 0; icons._settleIcon('was-tracked'); set.setShown(row, true); - icons._focusIcons(0, {}, { positionWC: at(0, 50_000) }, 0, null); + icons._focusIcons(0, 0, null); assert.deepEqual(advanced, ['was-tracked']); assert.equal(set.focus(row), 1); }); diff --git a/src/layers/flights/lifecycle.js b/src/layers/flights/lifecycle.js index b30b153dc..34c421553 100644 --- a/src/layers/flights/lifecycle.js +++ b/src/layers/flights/lifecycle.js @@ -9,11 +9,8 @@ export function createLifecycle({ resolveAsset, }) { const { clearFocusTarget } = services.focus; - const { - registerSpriteCollection, - restoreSpriteOrder, - restoreSpriteOrderOnEnable, - } = services.sprites; + const { registerSpriteSet, restoreSpriteOrder, restoreSpriteOrderOnEnable } = + services.sprites; const { onMilitaryLayerActiveChange } = services.militaryRegistry; const { holdContinuousRender, releaseContinuousRender } = services.render; const { ensureGeoidReady } = services.geoid; @@ -48,7 +45,7 @@ export function createLifecycle({ clearFocusTarget('flights'); flightState._focusEvidenceIds.clear(); flightState._viewer = viewer; - registerSpriteCollection('flights', parts.icons._createIcons(viewer)); + registerSpriteSet('flights', parts.icons._createIcons(viewer)); flightState._modelCollection = new Cesium.PrimitiveCollection(); viewer.scene.primitives.add(flightState._modelCollection); // Warm the glTF cache so the tracked plane's model instantiates instantly when first needed @@ -267,12 +264,7 @@ export function createLifecycle({ flightState._moveEndRemove = null; } parts.rendering._releaseModels(); - if (flightState._iconPrimitive) { - viewer.scene.primitives.remove(flightState._iconPrimitive); // removing destroys it - flightState._iconPrimitive = null; - } - flightState._icons?.clear(); - flightState._icons = null; + parts.icons._disposeIcons(); if (flightState._modelCollection) { viewer.scene.primitives.remove(flightState._modelCollection); // removing destroys it + its models flightState._modelCollection = null; diff --git a/src/layers/flights/motion.js b/src/layers/flights/motion.js index 88e2d8240..db1161312 100644 --- a/src/layers/flights/motion.js +++ b/src/layers/flights/motion.js @@ -36,6 +36,8 @@ import { readEntityRecord } from '../../data/entityRecords.js'; import { aircraftMotionRegime, createMotionRegime, + fixEpochMs, + julianAt, fixSpeedMps, fixTrackDeg, } from '../../data/aircraftMotionRegime.js'; @@ -140,7 +142,10 @@ export function createMotion({ function _deadReckon(icao24, result, sampledRenderTime) { const info = flightState.records.data.get(icao24); if (FOCUS_EVIDENCE_DEV && flightState._focusEvidenceIds.has(icao24)) { - const position = parts.icons._iconPosition(icao24); + const position = parts.icons._iconPosition( + icao24, + new Cesium.Cartesian3(), + ); flightState._drCourseDeg = info?.true_track || 0; flightState._drSpeedMps = info?.velocity || 0; flightState._drCourseHold = @@ -1056,9 +1061,14 @@ export function createMotion({ out.push(cell); } } + /** The display instant `epochMs` as a JulianDate, for `_motionRegime`. */ + const _displayTimeAt = (epochMs, result) => julianAt(epochMs, result); + return { _refloorStaleGroundedContacts, _deadReckon, + _displayTimeAt, + _fixEpochMs: fixEpochMs, _motionRegime, _extrapolateFix, _isTrackWarmingUp, diff --git a/src/layers/flights/queries.js b/src/layers/flights/queries.js index c7668321f..e041613e6 100644 --- a/src/layers/flights/queries.js +++ b/src/layers/flights/queries.js @@ -135,7 +135,8 @@ export function createQueries({ // `_trackedDisplayPosition`). If that ever changes, floor this path too. const info = flightState.records.data.get(icao24); const basePos = - parts.motion._deadReckon(icao24) || parts.icons._iconPosition(icao24); + parts.motion._deadReckon(icao24) || + parts.icons._iconPosition(icao24, new Cesium.Cartesian3()); if (!basePos) return null; const displayed = displayedKinematics({ derivedSpeedMps: flightState._drSpeedMps, @@ -428,11 +429,12 @@ export function createQueries({ const stride = Math.max(1, Math.ceil(icons.count / maxCount)); const start = seed % stride; const occluder = parts.icons._occluder(); - const tau = parts.icons._displayTau(); + const t = parts.icons._displayMs(); const result = []; - for (let row = start; row < icons.count; row += stride) { - const icao24 = icons.idAt(row); + const ids = icons.ids(); + for (let i = start; i < ids.length; i += stride) { + const icao24 = ids[i]; if ( flightState._cockpitContactMode && icao24.toLowerCase() === flightState._cockpitSubjectId @@ -446,7 +448,7 @@ export function createQueries({ icao24, record, ); - if (!isTracked && !icons.shown(row) && !modelOwnsVisual) continue; + if (!isTracked && !icons.shown(icao24) && !modelOwnsVisual) continue; const info = flightState.records.data.get(icao24); let object = flightState._detectionObjects.get(icao24); if (!object) { @@ -471,7 +473,7 @@ export function createQueries({ : null; const pos = isTracked ? parts.motion._trackedVisualCached() || - icons.position(row, tau, object._iconPos) + icons.position(icao24, t, object._iconPos) : modelOwnsVisual ? modelVisualAnchor( record.matrix, @@ -481,13 +483,13 @@ export function createQueries({ : spec.scale, object._weldPos || (object._weldPos = new Cesium.Cartesian3()), ) - : icons.position(row, tau, object._iconPos); + : icons.position(icao24, t, object._iconPos); // An icon past the horizon is not drawn, so it is not detectable. if ( !pos || (!isTracked && !modelOwnsVisual && - !parts.icons._aboveHorizon(row, pos, occluder)) + !parts.icons._aboveHorizon(pos, occluder)) ) continue; object.position = pos; @@ -579,7 +581,7 @@ export function createQueries({ const icons = flightState._icons; if (!center || !icons || !icons.show) return []; const occluder = parts.icons._occluder(); - const tau = parts.icons._displayTau(); + const t = parts.icons._displayMs(); const scratch = flightState._scratchNearbyPos; const limit = Number.isFinite(maxCount) @@ -590,21 +592,19 @@ export function createQueries({ const nearby = []; - for (let row = 0; row < icons.count; row++) { - const icao24 = icons.idAt(row); + for (const icao24 of icons.ids()) { const isTracked = icao24 === flightState._trackedIcao; const trackedPos = isTracked ? parts.motion._trackedDisplayCached() : null; // cached, no recompute (anti-jitter) - const drawn = trackedPos || icons.position(row, tau, scratch); + const drawn = trackedPos || icons.position(icao24, t, scratch); // Keep planes rendered as a 3D model (icon hidden) so proximity counts // don't drop to zero on the 2D→3D handoff. if ( !aircraftIncludedInNearby({ isTracked, billboardShown: - icons.shown(row) && - parts.icons._aboveHorizon(row, drawn, occluder), + icons.shown(icao24) && parts.icons._aboveHorizon(drawn, occluder), modelRendering: parts.rendering._modelOwnsVisual(icao24), includeHidden, }) @@ -678,12 +678,11 @@ export function createQueries({ const limit = Number.isFinite(maxCount) ? Math.max(1, Math.floor(maxCount)) : 500; - const tau = parts.icons._displayTau(); + const t = parts.icons._displayMs(); const result = []; - for (let row = 0; row < icons.count; row++) { - const icao24 = icons.idAt(row); - const pos = icons.position(row, tau); + for (const icao24 of icons.ids()) { + const pos = icons.position(icao24, t, new Cesium.Cartesian3()); const carto = Cesium.Cartographic.fromCartesian( pos, Cesium.Ellipsoid.WGS84, diff --git a/src/layers/flights/queries.test.mjs b/src/layers/flights/queries.test.mjs index a0ab8c132..b4d2a696c 100644 --- a/src/layers/flights/queries.test.mjs +++ b/src/layers/flights/queries.test.mjs @@ -4,8 +4,7 @@ import * as Cesium from 'cesium'; import { createQueries } from './queries.js'; import { createRendering } from './rendering.js'; import { createIcons } from './icons.js'; -import { createIconSet } from '../../data/iconSet.js'; -import { writeHoldSegment } from '../../data/iconSegment.js'; +import { createContactIcons } from '../../data/aircraftIconLayer.js'; import { createModelRecord, placeModel, @@ -18,11 +17,10 @@ function fixture() { registration: ' N123 ', altitude: 1000, }; - const icons = createIconSet(); + const icons = createContactIcons(); const flightState = { feed: {}, _icons: icons, - _scratchIconRenderTime: new Cesium.JulianDate(), _models: new Map(), _detectionObjects: new Map(), records: { data: new Map([['abc123', info]]) }, @@ -49,15 +47,18 @@ function fixture() { parts.rendering = createRendering({ flightState, services, parts }); parts.icons = createIcons({ flightState, services, parts }); const queries = createQueries({ flightState, services, parts }).methods; - const row = () => icons.row('abc123'); /** Hold the contact's icon at `position`. */ - const place = (position) => { - writeHoldSegment(icons.segments, row(), position, 0); - icons.segmentWritten(row()); - }; - icons.add('abc123', { id: 'abc123' }); + const place = (position) => + icons.update( + 'abc123', + { + pos: { x: position.x, y: position.y, z: position.z }, + motion: { kind: 'hold', courseDeg: 0 }, + }, + { expiresAt: Infinity }, + ); + icons.put({ id: 'abc123', pos: { x: 0, y: 0, z: 0 }, show: true }); place(new Cesium.Cartesian3(1, 2, 3)); - icons.setShown(row(), true); return { flightState, info, @@ -65,8 +66,9 @@ function fixture() { queries, formats: () => formats, place, - show: (shown) => icons.setShown(row(), shown), - drawn: () => parts.icons._iconPosition('abc123'), + show: (shown) => icons.setShown('abc123', shown), + drawn: () => + parts.icons._iconPosition('abc123', new Cesium.Cartesian3()), }; } diff --git a/src/layers/flights/rendering.js b/src/layers/flights/rendering.js index 397f554c3..51594911b 100644 --- a/src/layers/flights/rendering.js +++ b/src/layers/flights/rendering.js @@ -94,13 +94,8 @@ export function createRendering({ // About to render in 3D: jump the ambient type-enrichment backlog. onModelEligible: (icao24) => parts.enrichment._requestTypeEnrichment(icao24, true), - afterReplan: (renderTime, tau, nowMs, camera) => - parts.icons._floorGroundedIcons( - renderTime, - tau, - nowMs, - camera.positionWC, - ), + afterReplan: (renderTime, t, nowMs, camera) => + parts.icons._floorGroundedIcons(renderTime, t, nowMs, camera.positionWC), }); return { diff --git a/src/layers/flights/snapshotRenderer.js b/src/layers/flights/snapshotRenderer.js index 4e8d9f751..b65ff93f4 100644 --- a/src/layers/flights/snapshotRenderer.js +++ b/src/layers/flights/snapshotRenderer.js @@ -178,8 +178,7 @@ export function createFlightSnapshotRenderer({ // LANDED_MISSING_POLL_LIMIT — their disappearance means "landed", not a // feed gap, and the full grace left phantom planes parked at airports. const absentIds = []; - for (let row = 0; row < flightState._icons.count; row++) { - const icao24 = flightState._icons.idAt(row); + for (const icao24 of flightState._icons.ids()) { if (!currentIcaos.has(icao24)) absentIds.push(icao24); } for (const icao24 of absentIds) { diff --git a/src/layers/flights/state.js b/src/layers/flights/state.js index efb20c03b..2562f92c6 100644 --- a/src/layers/flights/state.js +++ b/src/layers/flights/state.js @@ -96,16 +96,11 @@ export function createFlightState({ source, services }) { // Module-level state: billboard collection and per-aircraft lookup maps // --------------------------------------------------------------------------- - /** Every contact's icon row (see icons.js); null outside a layer lifetime. */ + /** Every contact's icon item as drawn (`createContactIcons`, see icons.js); + * null outside a layer lifetime. */ flightState._icons = null; - /** The primitive drawing `_icons`. */ - - flightState._iconPrimitive = null; - - flightState._scratchIconRenderTime = new Cesium.JulianDate(); - /** Contacts whose latest poll put them on the ground. */ flightState._grounded = new Set(); diff --git a/src/layers/flights/testing.js b/src/layers/flights/testing.js index efbdd1ce1..a9191d283 100644 --- a/src/layers/flights/testing.js +++ b/src/layers/flights/testing.js @@ -1,8 +1,10 @@ import * as Cesium from 'cesium'; import { CYAN_TRANSPARENT } from './policy.js'; import { createModelRecord } from '../../data/modelRecord.js'; -import { createIconSet } from '../../data/iconSet.js'; -import { aircraftIconTestSeams } from '../../data/aircraftIconLayer.js'; +import { + aircraftIconTestSeams, + createContactIcons, +} from '../../data/aircraftIconLayer.js'; export function createTesting({ flightState, @@ -73,9 +75,7 @@ export function createTesting({ }) { flightState._viewer = viewer; flightState._modelCollection = modelCollection; - flightState._icons = createIconSet({ - epoch: parts.icons._displayTime(new Cesium.JulianDate()), - }); + flightState._icons = createContactIcons(); flightState._icons.show = iconLayer?.show ?? true; flightState._grounded.clear(); flightState._floorPinned.clear(); @@ -195,7 +195,6 @@ export function createTesting({ return parts.rendering._driveFleetModelHandoff( icao24, flightState._models.get(icao24), - flightState._icons.row(icao24), position, course, ); @@ -210,10 +209,9 @@ export function createTesting({ /** Run the fleet tick's grounded floor pass once, at `renderTime`. */ function _floorGroundedIconsForTest(renderTime, cameraPosition) { - const icons = flightState._icons; parts.icons._floorGroundedIcons( renderTime, - icons.seconds(renderTime), + Cesium.JulianDate.toDate(renderTime).getTime(), Date.now(), cameraPosition, ); diff --git a/src/layers/flights/tracking.js b/src/layers/flights/tracking.js index 2e3a387a8..6679d9078 100644 --- a/src/layers/flights/tracking.js +++ b/src/layers/flights/tracking.js @@ -34,6 +34,18 @@ import { import { roundHeadingDegrees } from '../../data/headingDegrees.js'; import { entityRecord } from '../../data/entityRecords.js'; +/** + * The icao a pick carries: a draw-set item's id (the icon sets' rows), a + * string pick id, or a model primitive's id. + */ +function aircraftPickId(picked) { + const id = picked?.id; + if (typeof id === 'string') return id; + if (id && typeof id.set === 'string' && typeof id.id === 'string') + return id.id; + return picked?.primitive?.id; +} + export function createTracking({ flightState, services, @@ -70,7 +82,7 @@ export function createTracking({ } function _publishTrackedSelection(icao24, origin = 'programmatic') { - const position = parts.icons._iconPosition(icao24); + const position = parts.icons._iconPosition(icao24, new Cesium.Cartesian3()); const info = flightState.records.data.get(icao24); if (!position || !info) return false; if (flightState._trackedEntity) @@ -169,11 +181,14 @@ export function createTracking({ const previous = flightState._cockpitNearContacts; const distancesSquared = []; const icons = flightState._icons; - const tau = parts.icons._displayTau(); - for (let row = 0; row < (icons?.count ?? 0); row++) { - const icao24 = icons.idAt(row); + const t = parts.icons._displayMs(); + for (const icao24 of icons?.ids() ?? []) { if (icao24 === flightState._trackedIcao) continue; - const position = icons.position(row, tau, flightState._scratchCockpitPos); + const position = icons.position( + icao24, + t, + flightState._scratchCockpitPos, + ); distancesSquared.push([ icao24, Cesium.Cartesian3.distanceSquared( @@ -210,9 +225,8 @@ export function createTracking({ if (flightState._modelCollection) flightState._modelCollection.show = true; flightState._trail?.setVisible(!next); if (flightState._trailHeadEntity) flightState._trailHeadEntity.show = !next; - const icons = flightState._icons; - for (let row = 0; row < (icons?.count ?? 0); row++) - parts.icons._applyIconPresentation(icons.idAt(row)); + for (const icao24 of flightState._icons?.ids() ?? []) + parts.icons._applyIconPresentation(icao24); flightState._lastFleetTickMs = 0; } @@ -324,7 +338,10 @@ export function createTracking({ if (!flightState._trackedIcao || !flightState._viewer) return; const pos = parts.motion._trackedDisplayCached() || - parts.icons._iconPosition(flightState._trackedIcao); + parts.icons._iconPosition( + flightState._trackedIcao, + new Cesium.Cartesian3(), + ); if (!pos) return; const projected = screenProjectedRotation( flightState._viewer.scene, @@ -665,7 +682,7 @@ export function createTracking({ // contact, and while it still read as tracked its tracked model owned the // visual, so the floor would have stepped aside. if (flightState._icons?.has(clearedIcao)) { - flightState._icons.setShown(flightState._icons.row(clearedIcao), true); + flightState._icons.setShown(clearedIcao, true); parts.icons._settleIcon(clearedIcao, { fromCourseDeg: trackedCourseDeg }); } parts.icons._applyIconPresentation(clearedIcao); @@ -820,9 +837,8 @@ export function createTracking({ // an already-loaded model would otherwise linger with the billboard hidden. if (flightState._models.has(id) || flightState._modelPending.has(id)) parts.rendering._releaseModel(id); - const row = flightState._icons?.row(id) ?? -1; - if (row >= 0 && id !== flightState._trackedIcao) - flightState._icons.setShown(row, true); + if (flightState._icons?.has(id) && id !== flightState._trackedIcao) + flightState._icons.setShown(id, true); if (id === flightState._trackedIcao) { parts.rendering._releaseTrackedModel(); _syncTracked2dRotation(); @@ -852,7 +868,7 @@ export function createTracking({ function _routeIsPlausible(icao24, route) { const info = flightState.records.data.get(icao24); - const position = parts.icons._iconPosition(icao24); + const position = parts.icons._iconPosition(icao24, new Cesium.Cartesian3()); if (!info || !position) return true; const carto = Cesium.Cartographic.fromCartesian( position, @@ -891,15 +907,15 @@ export function createTracking({ _clearTracking(false, { origin }); // switching planes — the new follow-camera takes over const icons = flightState._icons; - const row = icons?.row(icao24) ?? -1; const info = flightState.records.data.get(icao24); - if (row < 0 || !info) return; + if (!icons?.has(icao24) || !info) return; // The tracked limiter continues from the nose the icon was drawn with, and // the entity starts with the rotation the icon had on screen. - const tau = parts.icons._displayTau(); - const iconPosition = icons.position(row, tau); - flightState._displayCourse.set(icao24, icons.course(row, tau)); + const t = parts.icons._displayMs(); + const iconPosition = icons.position(icao24, t, new Cesium.Cartesian3()); + const iconCourse = icons.course(icao24, t); + flightState._displayCourse.set(icao24, iconCourse); flightState._trackedIcao = icao24; _resetTrackedSelectionState(); // fresh selection: enter at the ENTER ceiling, full load-retry budget flightState._cachedDRFrame = -1; @@ -907,7 +923,7 @@ export function createTracking({ screenProjectedRotation( flightState._viewer.scene, iconPosition, - icons.course(row, tau), + iconCourse, 0, ) ?? 0; // Drop any fleet 3D model for this aircraft — the tracked entity now owns its visual (its @@ -916,7 +932,7 @@ export function createTracking({ parts.rendering._releaseModel(icao24); // Hide the icon — the tracked entity replaces it visually - icons.setShown(row, false); + icons.setShown(icao24, false); // Helper: smoothed, per-frame-cached tracked position (see _trackedDisplayPosition — // one computation shared by the position/alignedAxis/rotation/trail-head callbacks, @@ -924,7 +940,7 @@ export function createTracking({ // the aircraft has no fix. const getTrackedPosition = () => parts.motion._trackedDisplayPosition(icao24) || - parts.icons._iconPosition(icao24) || + parts.icons._iconPosition(icao24, new Cesium.Cartesian3()) || iconPosition; // Dead-reckoning position property — smooth continuous motion between API updates. @@ -1100,8 +1116,7 @@ export function createTracking({ if (!flightState._viewer || !icons) return; if (active) { const suppressed = []; - for (let row = 0; row < icons.count; row++) { - const icao24 = icons.idAt(row); + for (const icao24 of icons.ids()) { if (isMilitaryIcao(icao24) && icao24 !== flightState._trackedIcao) suppressed.push(icao24); } @@ -1185,8 +1200,7 @@ export function createTracking({ // above. H1: the model used to have no pick id, so this fell through to // "empty space" and deselected the very plane being tracked. if (flightState._trackedIcao) { - const rawPick = - typeof picked.id === 'string' ? picked.id : picked.primitive?.id; + const rawPick = aircraftPickId(picked); if ( (flightState._trackedModel && picked.primitive === flightState._trackedModel.model) || @@ -1195,9 +1209,7 @@ export function createTracking({ return; } - // Icon picks carry the icao on picked.id; models carry it on the primitive. - const pickedIcao = - typeof picked.id === 'string' ? picked.id : picked.primitive?.id; + const pickedIcao = aircraftPickId(picked); if (pickedIcao && flightState._icons?.has(pickedIcao)) { _cancelPendingTrackingRestore(); _trackFlight(pickedIcao, { origin: 'user' }); diff --git a/src/layers/military/lifecycle.js b/src/layers/military/lifecycle.js index de513502b..0aa49546b 100644 --- a/src/layers/military/lifecycle.js +++ b/src/layers/military/lifecycle.js @@ -9,7 +9,7 @@ export function createLifecycle({ resolveAsset, }) { const { clearFocusTarget } = services.focus; - const { registerSpriteCollection, restoreSpriteOrder } = services.sprites; + const { registerSpriteSet, restoreSpriteOrder } = services.sprites; const { holdContinuousRender, releaseContinuousRender } = services.render; const { ensureGeoidReady } = services.geoid; const { registerPickOwner, unregisterPickOwner } = services.picking; @@ -42,7 +42,7 @@ export function createLifecycle({ flightState.lifetime = new AbortController(); clearFocusTarget('militaryFlights'); flightState._viewer = viewer; - registerSpriteCollection('military', parts.icons._createIcons(viewer)); + registerSpriteSet('military', parts.icons._createIcons(viewer)); flightState._modelCollection = new Cesium.PrimitiveCollection(); viewer.scene.primitives.add(flightState._modelCollection); // Warm the glTF cache so the tracked plane's model instantiates instantly when first needed @@ -242,12 +242,7 @@ export function createLifecycle({ flightState._moveEndRemove = null; } parts.rendering._releaseModels(); - if (flightState._iconPrimitive) { - viewer.scene.primitives.remove(flightState._iconPrimitive); // removing destroys it - flightState._iconPrimitive = null; - } - flightState._icons?.clear(); - flightState._icons = null; + parts.icons._disposeIcons(); if (flightState._modelCollection) { viewer.scene.primitives.remove(flightState._modelCollection); // removing destroys it + its models flightState._modelCollection = null; diff --git a/src/layers/military/motion.js b/src/layers/military/motion.js index 5f48967bc..6d91e5786 100644 --- a/src/layers/military/motion.js +++ b/src/layers/military/motion.js @@ -25,6 +25,8 @@ import { readEntityRecord } from '../../data/entityRecords.js'; import { aircraftMotionRegime, createMotionRegime, + fixEpochMs, + julianAt, fixSpeedMps, fixTrackDeg, } from '../../data/aircraftMotionRegime.js'; @@ -467,9 +469,14 @@ export function createMotion({ flightState._cachedDRHold = false; flightState._trackedCourseMs = 0; } + /** The display instant `epochMs` as a JulianDate, for `_motionRegime`. */ + const _displayTimeAt = (epochMs, result) => julianAt(epochMs, result); + return { _deadReckon, _motionRegime, + _displayTimeAt, + _fixEpochMs: fixEpochMs, _extrapolateFix, _isTrackWarmingUp, _trackedFocusSizePx, diff --git a/src/layers/military/queries.js b/src/layers/military/queries.js index b20bd00fd..ec7527d09 100644 --- a/src/layers/military/queries.js +++ b/src/layers/military/queries.js @@ -96,7 +96,8 @@ export function createQueries({ function _describeFlight(icao24) { const info = flightState.records.data.get(icao24); const basePos = - parts.motion._deadReckon(icao24) || parts.icons._iconPosition(icao24); + parts.motion._deadReckon(icao24) || + parts.icons._iconPosition(icao24, new Cesium.Cartesian3()); if (!basePos) return null; const displayed = displayedKinematics({ derivedSpeedMps: flightState._drSpeedMps, @@ -352,7 +353,7 @@ export function createQueries({ const icons = flightState._icons; if (!center || !icons || !icons.show) return []; const occluder = parts.icons._occluder(); - const tau = parts.icons._displayTau(); + const t = parts.icons._displayMs(); const scratch = flightState._scratchNearbyPos; const limit = Number.isFinite(maxCount) @@ -363,21 +364,19 @@ export function createQueries({ const nearby = []; - for (let row = 0; row < icons.count; row++) { - const icao24 = icons.idAt(row); + for (const icao24 of icons.ids()) { const isTracked = icao24 === flightState._trackedIcao; const trackedPos = isTracked ? parts.motion._trackedDisplayCached() : null; // cached, no recompute (anti-jitter) - const drawn = trackedPos || icons.position(row, tau, scratch); + const drawn = trackedPos || icons.position(icao24, t, scratch); // Keep planes rendered as a 3D model (icon hidden) so proximity counts // don't drop to zero on the 2D→3D handoff. if ( !aircraftIncludedInNearby({ isTracked, billboardShown: - icons.shown(row) && - parts.icons._aboveHorizon(row, drawn, occluder), + icons.shown(icao24) && parts.icons._aboveHorizon(drawn, occluder), modelRendering: parts.rendering._modelOwnsVisual(icao24), includeHidden, }) @@ -437,11 +436,12 @@ export function createQueries({ const stride = Math.max(1, Math.ceil(icons.count / maxCount)); const start = seed % stride; const occluder = parts.icons._occluder(); - const tau = parts.icons._displayTau(); + const t = parts.icons._displayMs(); const result = []; - for (let row = start; row < icons.count; row += stride) { - const icao24 = icons.idAt(row); + const ids = icons.ids(); + for (let i = start; i < ids.length; i += stride) { + const icao24 = ids[i]; if ( flightState._cockpitContactMode && icao24.toLowerCase() === flightState._cockpitSubjectId @@ -452,7 +452,7 @@ export function createQueries({ // doesn't vanish on the 2D→3D handoff. const record = flightState._models.get(icao24); const modelOwnsVisual = parts.rendering._modelOwnsVisual(icao24); - if (!isTracked && !icons.shown(row) && !modelOwnsVisual) continue; + if (!isTracked && !icons.shown(icao24) && !modelOwnsVisual) continue; const info = flightState.records.data.get(icao24); const callsign = info?.callsign?.trim(); const registration = info?.registration?.trim(); @@ -476,7 +476,7 @@ export function createQueries({ : null; const pos = isTracked ? parts.motion._trackedVisualCached() || - icons.position(row, tau, object._iconPos) + icons.position(icao24, t, object._iconPos) : modelOwnsVisual ? modelVisualAnchor( record.matrix, @@ -486,13 +486,13 @@ export function createQueries({ : spec.scale, object._weldPos || (object._weldPos = new Cesium.Cartesian3()), ) - : icons.position(row, tau, object._iconPos); + : icons.position(icao24, t, object._iconPos); // An icon past the horizon is not drawn, so it is not detectable. if ( !pos || (!isTracked && !modelOwnsVisual && - !parts.icons._aboveHorizon(row, pos, occluder)) + !parts.icons._aboveHorizon(pos, occluder)) ) continue; object.position = pos; @@ -598,12 +598,11 @@ export function createQueries({ const limit = Number.isFinite(maxCount) ? Math.max(1, Math.floor(maxCount)) : 500; - const tau = parts.icons._displayTau(); + const t = parts.icons._displayMs(); const result = []; - for (let row = 0; row < icons.count; row++) { - const icao24 = icons.idAt(row); - const pos = icons.position(row, tau); + for (const icao24 of icons.ids()) { + const pos = icons.position(icao24, t, new Cesium.Cartesian3()); const carto = Cesium.Cartographic.fromCartesian( pos, Cesium.Ellipsoid.WGS84, diff --git a/src/layers/military/snapshotRenderer.js b/src/layers/military/snapshotRenderer.js index 442b4794e..21f3738fa 100644 --- a/src/layers/military/snapshotRenderer.js +++ b/src/layers/military/snapshotRenderer.js @@ -205,8 +205,7 @@ export function createMilitarySnapshotRenderer({ // LANDED_MISSING_POLL_LIMIT — their disappearance means "landed", not a // feed gap, and the full grace left phantom planes parked at airports. const absentIds = []; - for (let row = 0; row < flightState._icons.count; row++) { - const icao24 = flightState._icons.idAt(row); + for (const icao24 of flightState._icons.ids()) { if (!currentIcaos.has(icao24)) absentIds.push(icao24); } for (const icao24 of absentIds) { diff --git a/src/layers/military/state.js b/src/layers/military/state.js index 50cba4dc7..558702454 100644 --- a/src/layers/military/state.js +++ b/src/layers/military/state.js @@ -91,16 +91,11 @@ export function createFlightState({ source, services }) { // Module-level state // --------------------------------------------------------------------------- - /** Every contact's icon row (see icons.js); null outside a layer lifetime. */ + /** Every contact's icon item as drawn (`createContactIcons`, see icons.js); + * null outside a layer lifetime. */ flightState._icons = null; - /** The primitive drawing `_icons`. */ - - flightState._iconPrimitive = null; - - flightState._scratchIconRenderTime = new Cesium.JulianDate(); - /** Rows still away from full focus emphasis after the last focus pass. */ flightState._iconFocusActive = 0; diff --git a/src/layers/military/testing.js b/src/layers/military/testing.js index 02268cccb..45f7d2125 100644 --- a/src/layers/military/testing.js +++ b/src/layers/military/testing.js @@ -1,8 +1,10 @@ import * as Cesium from 'cesium'; import { AMBER_TRANSPARENT, TRACKED_ICON_COLOR } from './policy.js'; import { createModelRecord } from '../../data/modelRecord.js'; -import { createIconSet } from '../../data/iconSet.js'; -import { aircraftIconTestSeams } from '../../data/aircraftIconLayer.js'; +import { + aircraftIconTestSeams, + createContactIcons, +} from '../../data/aircraftIconLayer.js'; export function createTesting({ flightState, @@ -45,9 +47,7 @@ export function createTesting({ }) { flightState._viewer = viewer; flightState._modelCollection = modelCollection; - flightState._icons = createIconSet({ - epoch: parts.icons._displayTime(new Cesium.JulianDate()), - }); + flightState._icons = createContactIcons(); flightState._icons.show = iconLayer?.show ?? true; _seedIconForTest(icao24, icon, tracked); flightState._models.clear(); @@ -148,7 +148,6 @@ export function createTesting({ return parts.rendering._driveFleetModelHandoff( icao24, flightState._models.get(icao24), - flightState._icons.row(icao24), position, course, ); diff --git a/src/layers/military/tracking.js b/src/layers/military/tracking.js index add3b4c9f..090c24590 100644 --- a/src/layers/military/tracking.js +++ b/src/layers/military/tracking.js @@ -34,6 +34,18 @@ import { import { roundHeadingDegrees } from '../../data/headingDegrees.js'; import { entityRecord } from '../../data/entityRecords.js'; +/** + * The icao a pick carries: a draw-set item's id (the icon sets' rows), a + * string pick id, or a model primitive's id. + */ +function aircraftPickId(picked) { + const id = picked?.id; + if (typeof id === 'string') return id; + if (id && typeof id.set === 'string' && typeof id.id === 'string') + return id.id; + return picked?.primitive?.id; +} + export function createTracking({ flightState, services, @@ -68,7 +80,7 @@ export function createTracking({ } function _publishTrackedSelection(icao24, origin = 'programmatic') { - const position = parts.icons._iconPosition(icao24); + const position = parts.icons._iconPosition(icao24, new Cesium.Cartesian3()); const info = flightState.records.data.get(icao24); if (!position || !info) return false; if (flightState._trackedEntity) @@ -157,11 +169,14 @@ export function createTracking({ const previous = flightState._cockpitNearContacts; const distancesSquared = []; const icons = flightState._icons; - const tau = parts.icons._displayTau(); - for (let row = 0; row < (icons?.count ?? 0); row++) { - const icao24 = icons.idAt(row); + const t = parts.icons._displayMs(); + for (const icao24 of icons?.ids() ?? []) { if (icao24 === flightState._trackedIcao) continue; - const position = icons.position(row, tau, flightState._scratchCockpitPos); + const position = icons.position( + icao24, + t, + flightState._scratchCockpitPos, + ); distancesSquared.push([ icao24, Cesium.Cartesian3.distanceSquared( @@ -198,8 +213,8 @@ export function createTracking({ flightState._trail?.setVisible(!next); if (flightState._trailHeadEntity) flightState._trailHeadEntity.show = !next; const icons = flightState._icons; - for (let row = 0; row < (icons?.count ?? 0); row++) - parts.icons._applyIconPresentation(icons.idAt(row)); + for (const icao24 of icons?.ids() ?? []) + parts.icons._applyIconPresentation(icao24); flightState._lastFleetTickMs = 0; } @@ -301,9 +316,8 @@ export function createTracking({ if (isTr3b(id)) { if (flightState._models.has(id) || flightState._modelPending.has(id)) parts.rendering._releaseModel(id); - const row = flightState._icons?.row(id) ?? -1; - if (row >= 0 && id !== flightState._trackedIcao) - flightState._icons.setShown(row, true); + if (flightState._icons?.has(id) && id !== flightState._trackedIcao) + flightState._icons.setShown(id, true); if (id === flightState._trackedIcao) { parts.rendering._releaseTrackedModel(); _syncTracked2dRotation(); @@ -418,7 +432,10 @@ export function createTracking({ if (!flightState._trackedIcao || !flightState._viewer) return; const pos = parts.motion._trackedDisplayCached() || - parts.icons._iconPosition(flightState._trackedIcao); + parts.icons._iconPosition( + flightState._trackedIcao, + new Cesium.Cartesian3(), + ); if (!pos) return; const projected = screenProjectedRotation( flightState._viewer.scene, @@ -799,7 +816,7 @@ export function createTracking({ // Hand the contact back to its icon only now, once it no longer reads as // tracked (the settle plans it as a fleet contact). if (flightState._icons?.has(clearedIcao)) { - flightState._icons.setShown(flightState._icons.row(clearedIcao), true); + flightState._icons.setShown(clearedIcao, true); parts.icons._settleIcon(clearedIcao, { fromCourseDeg: trackedCourseDeg }); } parts.icons._applyIconPresentation(clearedIcao); @@ -847,15 +864,15 @@ export function createTracking({ _clearTracking(false, { origin }); // switching planes — the new follow-camera takes over const icons = flightState._icons; - const row = icons?.row(icao24) ?? -1; const info = flightState.records.data.get(icao24); - if (row < 0 || !info) return; + if (!icons?.has(icao24) || !info) return; // The tracked limiter continues from the nose the icon was drawn with, and // the entity starts with the rotation the icon had on screen. - const tau = parts.icons._displayTau(); - const iconPosition = icons.position(row, tau); - flightState._displayCourse.set(icao24, icons.course(row, tau)); + const t = parts.icons._displayMs(); + const iconPosition = icons.position(icao24, t, new Cesium.Cartesian3()); + const iconCourse = icons.course(icao24, t); + flightState._displayCourse.set(icao24, iconCourse); flightState._trackedIcao = icao24; _resetTrackedSelectionState(); // fresh selection: enter at the ENTER ceiling, full load-retry budget flightState._cachedDRFrame = -1; @@ -863,7 +880,7 @@ export function createTracking({ screenProjectedRotation( flightState._viewer.scene, iconPosition, - icons.course(row, tau), + iconCourse, 0, ) ?? 0; // Drop any fleet 3D model for this aircraft — the tracked entity now owns its visual (its @@ -872,7 +889,7 @@ export function createTracking({ parts.rendering._releaseModel(icao24); // Hide the icon -- the tracked entity replaces it visually - icons.setShown(row, false); + icons.setShown(icao24, false); // Helper: smoothed, per-frame-cached tracked position (see _trackedDisplayPosition — // one computation shared by the position/rotation/trail-head callbacks, with @@ -880,7 +897,7 @@ export function createTracking({ // aircraft has no fix. const getTrackedPosition = () => parts.motion._trackedDisplayPosition(icao24) || - parts.icons._iconPosition(icao24) || + parts.icons._iconPosition(icao24, new Cesium.Cartesian3()) || iconPosition; // Dead-reckoning position property evaluated every render frame. @@ -1092,8 +1109,7 @@ export function createTracking({ // above. H1: the model used to have no pick id, so this fell through to // "empty space" and deselected the very plane being tracked. if (flightState._trackedIcao) { - const rawPick = - typeof picked.id === 'string' ? picked.id : picked.primitive?.id; + const rawPick = aircraftPickId(picked); if ( (flightState._trackedModel && picked.primitive === flightState._trackedModel.model) || @@ -1102,9 +1118,7 @@ export function createTracking({ return; } - // Icon picks carry the icao on picked.id; models carry it on the primitive. - const pickedIcao = - typeof picked.id === 'string' ? picked.id : picked.primitive?.id; + const pickedIcao = aircraftPickId(picked); if (pickedIcao && flightState._icons?.has(pickedIcao)) { _cancelPendingTrackingRestore(); _trackFlight(pickedIcao, { origin: 'user' }); diff --git a/src/render/cesium/draw.test.mjs b/src/render/cesium/draw.test.mjs index d5de47753..a603c462c 100644 --- a/src/render/cesium/draw.test.mjs +++ b/src/render/cesium/draw.test.mjs @@ -1880,3 +1880,156 @@ test('vessels on a host with no sprite-set registry still draw, and say so once' layer.destroy(viewer); unbind(); }); + +test('an aircraft layer draws its contacts as one GPU icon set moving on the delayed live clock', async () => { + const { createAircraftIcons } = + await import('../../data/aircraftIconLayer.js'); + const { IconSetPrimitive } = await import('../../data/iconSetPrimitive.js'); + const { ICON_CULL_LIFT, ICON_RECEDES, ICON_ROTATES } = + await import('../../data/iconSet.js'); + const { iconAtlas, nearImageSwitchPx } = + await import('../../data/iconAtlas.js'); + const { aircraftIcon, FLEET_ICON_PX, TRACKED_ICON_PX } = + await import('../../data/aircraftIcons.js'); + const { aircraftMotionRegime, createMotionRegime, fixEpochMs, julianAt } = + await import('../../data/aircraftMotionRegime.js'); + const scene = fakeScene(); + const part = createCesiumDraw({ + scene, + report: (error) => assert.fail(error), + }); + const viewer = { scene }; + const unbind = bindRenderer(viewer, { + draw: part.port, + capabilities: new Set(['columns', 'motionSegments', 'courseGlide']), + quality: { get: () => ({ pixelRatio: 2 }) }, + }); + const now = Date.now(); + const delayMs = 30_000; + const fixAt = (lon, ms) => ({ + time: julianAt(ms), + epochMs: ms, + position: Cesium.Cartesian3.fromDegrees(lon, 30, 10_000), + velocity: 250, + track: 90, + }); + const state = { + _viewer: viewer, + _icons: null, + _iconFocusActive: 0, + _positionHistory: new Map([ + ['abc123', [fixAt(-97, now - 40_000), fixAt(-96.9, now - 20_000)]], + ]), + _displayCourse: new Map(), + _groundSnap: { forget() {} }, + _models: new Map(), + _trackedIcao: null, + _cockpitContactMode: false, + _cockpitNearContacts: new Set(), + records: { + data: new Map([['abc123', { klass: 'airliner', velocity: 250 }]]), + missingPolls: new Map(), + forget() {}, + }, + }; + const parts = { + motion: { + _motionRegime: (history, info, renderTime) => + aircraftMotionRegime( + history, + info, + renderTime, + { speed: 'velocity', track: 'true_track' }, + createMotionRegime(), + ), + _displayTimeAt: julianAt, + _fixEpochMs: fixEpochMs, + }, + rendering: { + _iconKind: (id, klass) => klass, + _fleetBillboardScale: () => 1.25, + _fleetBillboardColor: () => Cesium.Color.WHITE, + _cockpitContactColor: () => Cesium.Color.CYAN, + _releaseModel() {}, + }, + }; + const icons = createAircraftIcons({ + state, + services: { focus: { focusPassIsNeeded: () => false } }, + parts, + layerId: 'flights', + renderDelaySec: delayMs / 1000, + courseMaxDps: 3, + cockpitContactSizePx: 6, + }); + try { + const setId = icons._createIcons(viewer); + assert.match(setId, /^flights-icons:\d+$/); + icons._addIcon('abc123'); + // Written together once the task ends. + await Promise.resolve(); + const [host] = scene.added; + assert.ok(host instanceof IconSetPrimitive, 'one GPU icon set'); + assert.equal(host.drawSetId, setId); + const set = part.sets.get(setId).gpu.set; + assert.equal(set.count, 1); + const row = set.row('abc123'); + assert.equal( + set.imageFar(row), + iconAtlas.slot(aircraftIcon('airliner'), FLEET_ICON_PX), + 'the fleet glyph rasterised at 64 px', + ); + assert.equal( + set.imageNear(row), + iconAtlas.slot(aircraftIcon('airliner', TRACKED_ICON_PX), TRACKED_ICON_PX), + 'the near glyph at 192 px', + ); + assert.equal(set.imageSwitch(row), nearImageSwitchPx(2)); + assert.equal(set.width(row), 20); + assert.ok(Math.abs(set.scale(row) - 1.25) < 1e-6); + const flags = set.flags(row); + assert.equal(flags & ICON_ROTATES, ICON_ROTATES); + assert.equal(flags & ICON_RECEDES, ICON_RECEDES); + assert.equal(flags & ICON_CULL_LIFT, ICON_CULL_LIFT); + assert.ok(set.depthTestDistance(row) >= 1e30, 'over depth everywhere'); + + // Drawn where the layer reads it, between its two fixes. + const t = Date.now() - delayMs; + const tau = set.seconds(julianAt(t)); + const drawn = set.position(row, tau); + const read = icons._iconPosition('abc123'); + assert.ok(Cesium.Cartesian3.distance(drawn, read) < 0.5, 'same place'); + const lon = Cesium.Math.toDegrees( + Cesium.Cartographic.fromCartesian(drawn).longitude, + ); + assert.ok(lon > -97 && lon < -96.9, 'interpolating the fixes'); + assert.ok(Math.abs(set.course(row, tau) - icons._iconCourse('abc123')) < 0.01); + assert.equal(state._icons.expires('abc123'), now - 20_000); + assert.deepEqual( + drawHitOf(host._pickObject('abc123', null, { show: true })), + { + set: setId, + id: 'abc123', + meta: { layer: 'flights', id: 'abc123' }, + surface: false, + }, + ); + + // A restyle that changes nothing writes nothing; hiding it writes it. + const before = part.sets.get(setId).items.get('abc123'); + icons._applyIconPresentation('abc123'); + await Promise.resolve(); + assert.equal(part.sets.get(setId).items.get('abc123'), before); + icons._setIconShown('abc123', false); + await Promise.resolve(); + assert.equal(set.shown(row), false); + + icons._forgetContact('abc123'); + await Promise.resolve(); + assert.equal(set.count, 0); + icons._disposeIcons(); + assert.equal(scene.added.length, 0, 'disposed: the set goes'); + } finally { + unbind(); + } +}); diff --git a/src/render/cesiumAllowList.json b/src/render/cesiumAllowList.json index 2194a66ce..aa4d57446 100644 --- a/src/render/cesiumAllowList.json +++ b/src/render/cesiumAllowList.json @@ -10,7 +10,6 @@ "src/cockpitCloudEffects.js", "src/cyberSonarGpu.js", "src/cyberSonarScene.js", - "src/data/aircraftIconLayer.js", "src/data/aircraftModelLayer.js", "src/data/aircraftMotionRegime.js", "src/data/bhoteKoshiEmbeddedMedia.js", @@ -39,7 +38,6 @@ "src/layers/firms/rendering.js", "src/layers/flights/enrichment.js", "src/layers/flights/evidence.js", - "src/layers/flights/icons.js", "src/layers/flights/lifecycle.js", "src/layers/flights/motion.js", "src/layers/flights/policy.js",