import { COAST_FLOOR_LIFT_M, COURSE_HOLD_SPEED_MPS, courseSlewCapDps, } from './motionModel.js'; import { norm180, distance, clone, copyInto, toDegrees, } from '../geo/vector.js'; import { fromRadians, toCartographicRadians } from '../geo/ellipsoid.js'; import { horizonFrom, liftedForHorizon } from '../geo/horizon.js'; import { createIconBook } from '../render/motion/iconBook.js'; import { motionCourse, motionPosition } from '../render/motion/iconMotion.js'; import { 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'; /** 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. */ /** A contact icon's size before its scale, CSS px. */ const FLEET_ICON_SIZE_PX = 20; 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 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; } /** How far ahead (ms) a coast's ground is read each time it is planned. */ export const COAST_FLOOR_LOOKAHEAD_MS = 10_000; /** How far apart (ms) the ground under a coast is read, and how long each * piece of a coast the ground lifts runs. */ export const COAST_FLOOR_STEP_MS = 1_000; /** A coast from above this height (m) never meets the ground: no terrain * is this high, and a level coast only rises off the ellipsoid. */ const COAST_ABOVE_TERRAIN_M = 9_000; /** * How far the ground lifts an icon at `position`: metres to raise it to * COAST_FLOOR_LIFT_M over the ground (0 or less: none), or null where the * ground is not known. */ function floorLift(position, cachedGroundFloor) { const carto = toCartographicRadians(position); if (!carto) return null; const ground = cachedGroundFloor(toDegrees(carto.lat), toDegrees(carto.lon)); if (!Number.isFinite(ground)) return null; return ground + COAST_FLOOR_LIFT_M - carto.height; } /** `position` raised by `lift` metres (a copy). */ function raised(position, lift) { if (!(lift > 0)) return clone(position); const carto = toCartographicRadians(position); return fromRadians(carto.lon, carto.lat, carto.height + lift); } /** * A coast arc kept above the ground, as the CPU dead reckoning keeps it * (`floorCoastedPosition`): past its fix an icon never draws lower than * COAST_FLOOR_LIFT_M over the ground the layer's floor cache knows. The * renderer cannot read that ground, so the coast is planned in pieces from * the ground read along it: * - clear of the ground for the lookahead, the arc as it is, planned again * when the lookahead runs out (or never, with the ground known to the * coast's end); * - meeting the ground further on, the arc until a step before it; * - where the ground lifts it within a step, a piece of the same arc from * where it is drawn now, lifted, climbing to where the ground puts it a * step on; * - with the coast over, held where it stopped, lifted. * Before its fix (a warm-up), an arc runs as it is until the fix. * @param {object} arc The coast's `arc` motion segment. * @param {number} t The display instant, epoch ms on the set's motion clock. * @param {(latDeg: number, lonDeg: number) => number|null} cachedGroundFloor * @returns {{motion?: object, pos?: object, course?: number, expiresAt: number}|null} * A replacement motion where the ground lifts the icon, and until when the * plan holds; null when the ground never matters to this arc. */ export function floorCoastArc(arc, t, cachedGroundFloor) { if (!(arc.maxDtS > 0) || typeof cachedGroundFloor !== 'function') return null; const fixCarto = toCartographicRadians(arc.fix); if ( fixCarto && fixCarto.height > COAST_ABOVE_TERRAIN_M && !((arc.climbMps ?? 0) < 0) ) return null; const end = arc.t0 + arc.maxDtS * 1000; if (t >= end) { // The coast is over: it holds where it stopped. const stopped = motionPosition(arc, null, end); const lift = floorLift(stopped, cachedGroundFloor); if (lift === null) return { expiresAt: t + COAST_FLOOR_LOOKAHEAD_MS }; if (!(lift > 0)) return { expiresAt: Infinity }; const courseDeg = motionCourse(arc, undefined, end); return { motion: { kind: 'hold', courseDeg }, pos: raised(stopped, lift), course: courseDeg, expiresAt: Infinity, }; } const start = Math.max(t, arc.t0); const horizon = Math.min(end, start + COAST_FLOOR_LOOKAHEAD_MS); let unknown = false; let belowAt = null; for (let at = start; ; at = Math.min(at + COAST_FLOOR_STEP_MS, horizon)) { const lift = floorLift(motionPosition(arc, null, at), cachedGroundFloor); if (lift === null) unknown = true; else if (lift > 0) { belowAt = at; break; } if (at >= horizon) break; } if (belowAt === null) return { expiresAt: horizon < end || unknown ? start + COAST_FLOOR_LOOKAHEAD_MS : Infinity, }; // A warm-up runs to its fix as it is; the coast is read again from there. if (t < arc.t0) return { expiresAt: Math.max(arc.t0, belowAt - COAST_FLOOR_STEP_MS) }; if (belowAt - COAST_FLOOR_STEP_MS > t) return { expiresAt: belowAt - COAST_FLOOR_STEP_MS }; // The ground lifts it within a step: a piece from here to a step on. const next = Math.min(t + COAST_FLOOR_STEP_MS, end); const here = motionPosition(arc, null, t); const there = motionPosition(arc, null, next); const from = raised(here, floorLift(here, cachedGroundFloor) ?? 0); const to = raised(there, floorLift(there, cachedGroundFloor) ?? 0); const seconds = (next - t) / 1000; const climbMps = seconds > 0 ? (toCartographicRadians(to).height - toCartographicRadians(from).height) / seconds : 0; const courseDeg = motionCourse(arc, undefined, t); return { motion: { kind: 'arc', fix: from, t0: t, minDtS: 0, // On to the coast's end, should the next piece come late. maxDtS: (end - t) / 1000, speedMps: arc.speedMps, trackDeg: courseDeg, turnRateDps: arc.turnRateDps, climbMps, }, pos: from, course: courseDeg, expiresAt: next, }; } 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`, `_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. * @param {object} options.services The layer's services (`focus`). * @param {object} options.parts The layer's parts (`motion`, `rendering`). * @param {string} options.layerId Pick and focus owner id. * @param {number} options.renderDelaySec How far behind real time contacts draw. * @param {() => boolean} [options.followsClock] True while the layer follows * the world clock: contacts draw at the world's time (`state.now()`, the * scene's time) with no delay. * @param {number} [options.staleAlpha] A contact's alpha after a missed update. * @param {number} options.courseMaxDps The fleet's course slew cap. * @param {number} options.cockpitContactSizePx Cockpit far-contact pip size. * @param {(icao24: string) => boolean} [options.holdsPlan] True while something * else writes this row's segment (it is not planned). * @param {(icao24: string) => void} [options.beforeSettle] Runs before a row is * planned afresh. * @param {(icao24: string) => void} [options.afterSettle] Runs after it. * @param {(icao24: string) => void} [options.onForget] Drops the layer's own * per-contact state when a contact goes. */ export function createAircraftIcons({ state, services, parts, layerId, renderDelaySec, followsClock = () => false, staleAlpha = 0.45, courseMaxDps, cockpitContactSizePx, holdsPlan = () => false, beforeSettle = () => {}, afterSettle = () => {}, onForget = () => {}, }) { const { focusPassIsNeeded } = services.focus; const delayMs = renderDelaySec * 1000; // The near-image switch the rows were last written with (CSS px). let switchPx = nearImageSwitchPx(1); /** The delayed instant (epoch ms) every untracked contact is drawn at. */ const _displayMs = () => followsClock() ? state.now() : Date.now() - delayMs; /** The live draw set, and whether its motion clock is the scene's. */ let liveSet = null; let sceneClock = false; /** The motion clock for whether the layer follows the world clock. */ const motionClock = (scene) => scene ? { kind: 'scene' } : { kind: 'live', delayMs }; /** * Put the set's motion on the scene's clock (the world's time) while the * layer follows the world clock, on the delayed live clock otherwise. */ function _syncMotionClock() { const scene = followsClock(); if (!liveSet || scene === sceneClock) return; sceneClock = scene; liveSet.setOptions({ motionClock: motionClock(scene) }); } /** * Create the draw set for one layer lifetime, drawn over depth and culled * at the horizon on the delayed live clock, stacked by the sprite order. * @returns {string} The set's id. */ function _createIcons(viewer) { const set = drawOf(viewer).icons({ id: `${layerId}-icons:${++instances}`, horizonCull: true, motionClock: motionClock(followsClock()), drawOrder: services.sprites?.spriteDrawOrder?.(layerId) ?? 0, }); // Columns of no rows put the set's host in the scene now, rather than // with its first contact. set.setColumns?.({ ids: [] }); liveSet = set; sceneClock = followsClock(); 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; liveSet = 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, ); } /** 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); } /** 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) { return state._icons?.course(icao24, _displayMs()) ?? null; } /** Whether the layer draws this contact's icon (not tracked, not model-owned). */ function _iconShown(icao24) { const icons = state._icons; return Boolean(icons?.has(icao24) && icons.shown(icao24)); } /** 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 pose = state._viewer ? findCamera(state._viewer)?.pose() : null; return pose?.position ? horizonFrom(pose.position) : null; } /** * 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 item expires when the regime would change. * @param {string} icao24 * @param {{fromCourseDeg?: number|null}} [options] Nose to glide from when * the row's own motion is not what was on screen (tracking handoff). */ function _planIcon(icao24, { fromCourseDeg } = {}) { 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 t = _displayMs(); const renderTime = parts.motion._displayTimeAt(t); const fixMs = parts.motion._fixEpochMs; const shownCourse = fromCourseDeg ?? (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) { 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 { course = trackTo + blend * norm180((chordCourse ?? 0) - trackTo); motion = { kind: 'hold', courseDeg: course }; } expiresAt = fixMs(b); } else { const { fix, heading } = regime; speed = regime.speed; 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, still ahead; a coast's runs to its // limit, and a report that holds stays put until the next one. if (regime.maxDt === 0 && t0 > t) expiresAt = t0; // Past its fix a coast never goes below the ground. if (motion.kind === 'arc') { const floored = floorCoastArc( motion, t, services.groundFloor?.cachedGroundFloor, ); if (floored) { if (floored.motion) { motion = floored.motion; pos = floored.pos; course = floored.course; } expiresAt = Math.min(expiresAt, floored.expiresAt); } } } // Below hover speed the nose holds what is on screen (or, for a new row, // 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) { 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, }; } icons.update(icao24, { pos, course, motion, courseGlide }, { expiresAt }); } /** 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. Each row whose emphasis moved * is written as its item. */ function _focusIcons(t, nowMs, target) { if (!focusPassIsNeeded(target, state._iconFocusActive)) return; 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 (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( item.scaleByDistance, cameraDistance, ); const half = (item.scale ?? 1) * distanceScale * 0.5; const focus = advanceSpriteFocus(item.meta, { screenPosition: query?.project(position) ?? null, cameraDistance, nowMs, target, 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; } /** * How a contact's icon is drawn outside Cockpit: its image (and the sharper * one it switches to up close), size, scale and scale by distance. The * tracked contact's own icon is drawn with this too, so selecting a contact * changes its colour and nothing else. * @param {string} icao24 * @param {object} [info] Its record. * @returns {{image: string, imageLod: {near: string, switchPx: number}, * size: [number, number], scale: number, scaleByDistance: object}} */ function _fleetLook(icao24, info = state.records.data.get(icao24)) { const rendering = parts.rendering; return { image: aircraftIcon( rendering._iconKind(icao24, info?.klass), FLEET_ICON_PX, ), imageLod: { near: aircraftIcon( rendering._iconKind(icao24, info?.klass), TRACKED_ICON_PX, ), switchPx, }, size: [FLEET_ICON_SIZE_PX, FLEET_ICON_SIZE_PX], scale: rendering._fleetBillboardScale(icao24, info?.klass), scaleByDistance: NORMAL_SCALE_BY_DISTANCE, }; } /** Image, size, scale, tint and freshness for one row under the current * normal/cockpit contract. Motion and course stay with `_planIcon`. */ function _applyIconPresentation(icao24) { 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; const cockpitDot = state._cockpitContactMode && !tracked && !state._cockpitNearContacts.has(icao24); 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', } : { ..._fleetLook(icao24, info), color: rgba(rendering._fleetBillboardColor(icao24, info)), rotationMode: 'course', }; look.alpha = state.records.missingPolls.get(icao24) ? staleAlpha : 1; icons.update(icao24, look); } /** Add a row for a new contact, hidden while it is the tracked one. */ function _addIcon(icao24) { state._icons.put(_baseItem(icao24, icao24 !== state._trackedIcao), { expiresAt: -Infinity, }); _applyIconPresentation(icao24); _settleIcon(icao24); } /** A new contact's item before it is styled or planned: at the origin. */ function _baseItem(icao24, show) { return baseContactItem(layerId, icao24, show); } /** * Plan a row afresh, with the layer's own settle work on either side, and * let a dimmed row relax: one that sat out the focus pass (tracked) may come * back dimmed after the pass went idle, so it is counted to run the pass. * @param {string} icao24 * @param {{fromCourseDeg?: number}} [options] The course on screen to glide from. */ function _settleIcon(icao24, options) { const icons = state._icons; if (!icons?.has(icao24)) return; beforeSettle(icao24); if (icons.focus(icao24) < 1) state._iconFocusActive += 1; _planIcon(icao24, options); afterSettle(icao24); } /** Drop a contact and everything the layer keeps for it. */ function _forgetContact(icao24) { state._icons?.remove(icao24); parts.rendering._releaseModel(icao24); state.records.forget(icao24); state._positionHistory.delete(icao24); state._displayCourse.delete(icao24); state._groundSnap.forget(icao24); onForget(icao24); } /** Icon ids, so ray samples never land on an aircraft instead of the ground. */ function _iconIds() { return state._icons?.ids() ?? []; } return { _displayMs, _syncMotionClock, _createIcons, _disposeIcons, _syncImageSwitch, _iconPosition, _iconCourse, _iconShown, _setIconShown, _occluder, _aboveHorizon, _planIcon, _settleIcon, _replanExpired, _focusIcons, _applyIconPresentation, _fleetLook, _addIcon, _forgetContact, _iconIds, }; } /** * 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: [FLEET_ICON_SIZE_PX, FLEET_ICON_SIZE_PX], 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. * @param {object} state The layer state holding `_icons`. * @param {{icons: ReturnType}} parts Read at call time. * @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) { 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. */ function _iconForTest(icao24) { const position = parts.icons._iconPosition(icao24); return position ? { position, shown: parts.icons._iconShown(icao24), course: parts.icons._iconCourse(icao24), } : null; } /** Show or hide a contact's icon as a handoff would, or hold it somewhere. */ function _setIconForTest(icao24, { shown, position } = {}) { 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 }; }