Draw the aircraft fleet icons through the draw port

The civil flights and military layers now draw their contacts as one GPU
icon set each from the renderer's draw port instead of a custom primitive.
Each contact is an icon item whose motion is the dead reckoning the layer
plans (interpolation between fixes, warm-up and coast arcs, or a hold),
with its nose gliding onto a new course at the fleet's slew cap. A
contact's item is replanned when its motion runs out, grounded contacts
are pinned with held motion, and focus de-emphasis is written per item.
The near/far image switch follows the renderer's pixel ratio, and writes
made during a fleet tick reach the set before that frame draws.

The aircraft icon layer and the flights icon part no longer touch Cesium
and leave the allow-list. Clicks resolve the draw port's pick ids as well
as the ones the tracked model and entities still carry, so selection,
follow and share-follow work as before.
This commit is contained in:
Sameh Khamis committed 2026-11-07 04:25:24 -08:00
1 parent e94b7ffb01
commit dbd6363e43
30 files changed
+977 -551

No files matched your search

+2
View File
@@ -1493,6 +1493,7 @@
"src/layers/flights/rendering.js", "src/layers/flights/rendering.js",
"src/layers/flights/icons.js", "src/layers/flights/icons.js",
"src/data/aircraftIconLayer.js", "src/data/aircraftIconLayer.js",
"src/render/motion/iconBook.js",
"src/data/aircraftModelLayer.js", "src/data/aircraftModelLayer.js",
"src/data/aircraftMotionRegime.js", "src/data/aircraftMotionRegime.js",
"src/data/iconSetPrimitive.js", "src/data/iconSetPrimitive.js",
@@ -1598,6 +1599,7 @@
"src/layers/military/rendering.js", "src/layers/military/rendering.js",
"src/layers/military/icons.js", "src/layers/military/icons.js",
"src/data/aircraftIconLayer.js", "src/data/aircraftIconLayer.js",
"src/render/motion/iconBook.js",
"src/data/aircraftModelLayer.js", "src/data/aircraftModelLayer.js",
"src/data/aircraftMotionRegime.js", "src/data/aircraftMotionRegime.js",
"src/data/iconSetPrimitive.js", "src/data/iconSetPrimitive.js",
+13 -7
View File
@@ -4,10 +4,12 @@ import { createRendering as civilRendering } from '../layers/flights/rendering.j
import { createRendering as militaryRendering } from '../layers/military/rendering.js'; import { createRendering as militaryRendering } from '../layers/military/rendering.js';
import { createMilitarySnapshotRenderer } from '../layers/military/snapshotRenderer.js'; import { createMilitarySnapshotRenderer } from '../layers/military/snapshotRenderer.js';
import { createIcons as createMilitaryIcons } from '../layers/military/icons.js'; import { createIcons as createMilitaryIcons } from '../layers/military/icons.js';
import { createIconSet } from './iconSet.js'; import { createContactIcons } from './aircraftIconLayer.js';
import { import {
aircraftMotionRegime, aircraftMotionRegime,
createMotionRegime, createMotionRegime,
fixEpochMs,
julianAt,
} from './aircraftMotionRegime.js'; } from './aircraftMotionRegime.js';
import { aircraftEmergency } from './aircraftEmergency.js'; import { aircraftEmergency } from './aircraftEmergency.js';
// Source-to-voice provenance, status retention/clearing, contact-time contracts, // 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', () => { test('GERMAN: an existing untracked military icon repaints each poll without losing its fade', () => {
const { flightState, rendering } = renderHarness(militaryRendering); const { flightState, rendering } = renderHarness(militaryRendering);
Object.assign(flightState, { Object.assign(flightState, {
_icons: createIconSet(), _icons: createContactIcons(),
_models: new Map(), _models: new Map(),
_positionHistory: new Map(), _positionHistory: new Map(),
_displayCourse: 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' }, { speed: 'speedMps', track: 'track' },
createMotionRegime(), createMotionRegime(),
), ),
_displayTimeAt: julianAt,
_fixEpochMs: fixEpochMs,
}, },
}; };
const icons = createMilitaryIcons({ const icons = createMilitaryIcons({
@@ -507,11 +511,13 @@ test('GERMAN: an existing untracked military icon repaints each poll without los
services: { focus: { focusPassIsNeeded: () => false } }, services: { focus: { focusPassIsNeeded: () => false } },
parts, parts,
}); });
const row = flightState._icons.add('abc123', { const row = 'abc123';
layer: 'military', flightState._icons.put({
id: 'abc123', 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); flightState._icons.setFocus(row, 0.65);
const apply = createMilitarySnapshotRenderer({ const apply = createMilitarySnapshotRenderer({
flightState, flightState,
@@ -546,7 +552,7 @@ test('GERMAN: an existing untracked military icon repaints each poll without los
{ observedAtMs: NOW_MS }, { observedAtMs: NOW_MS },
); );
apply(snapshot, {}); 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); assert.ok(Math.abs(flightState._icons.focus(row) - 0.65) < 1e-6);
} }
}); });
+454 -235
View File
@@ -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 { import {
COURSE_HOLD_SPEED_MPS, drawOf,
courseSlewCapDps, findCamera,
norm180, findQuery,
} from './motionModel.js'; rendererOf,
import { } from '../render/rendererOf.js';
createIconSet, import { nearImageSwitchPx } from './iconAtlas.js';
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';
import { import {
aircraftIcon, aircraftIcon,
FLEET_ICON_PX, FLEET_ICON_PX,
TRACKED_ICON_PX, TRACKED_ICON_PX,
} from './aircraftIcons.js'; } from './aircraftIcons.js';
import { cockpitContactDotImage } from './cockpitContactDot.js'; import { cockpitContactDotImage } from './cockpitContactDot.js';
import { horizonOccluder } from './iconOrientation.js';
/** Raster size of the cockpit contact pip (cockpitContactDot.js draws 16 px). */ /** Raster size of the cockpit contact pip (cockpitContactDot.js draws 16 px). */
const COCKPIT_DOT_PX = 16; const COCKPIT_DOT_PX = 16;
/** Fleet glyphs keep the established close-range 3× scale. */ /** Fleet glyphs keep the established close-range 3× scale. */
const NORMAL_SCALE_BY_DISTANCE = new Cesium.NearFarScalar( const NORMAL_SCALE_BY_DISTANCE = Object.freeze({
1000, near: 1000,
3.0, nearValue: 3.0,
8000000, far: 8000000,
0.5, farValue: 0.5,
); });
const COCKPIT_SCALE_BY_DISTANCE = new Cesium.NearFarScalar( const COCKPIT_SCALE_BY_DISTANCE = Object.freeze({
1000, near: 1000,
1.15, nearValue: 1.15,
8000000, far: 8000000,
0.65, 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(
`<svg xmlns="http://www.w3.org/2000/svg" width="${px}" height="${px}" viewBox="0 0 ${px} ${px}"><image width="${px}" height="${px}" href="${png}"/></svg>`,
)}`;
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 * An aircraft layer's contact icons as it last drew them, over one icon
* mirrors the layer's dead reckoning for the delayed display time, so the GPU * draw set: each contact's icon item by its id, until when its motion holds
* moves every untracked contact between polls with no per-frame CPU pass. * (`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<object>|null} [drawSet]
* Where the icons are drawn; none keeps them only here (tests).
* @param {{capabilities?: ReadonlySet<string>|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`, * The layer's state supplies `_icons`, `_iconFocusActive`,
* `_iconFocusActive`, `_positionHistory`, `_displayCourse`, `_groundSnap`, * `_positionHistory`, `_displayCourse`, `_groundSnap`, `_models`,
* `_models`, `_trackedIcao`, `_viewer`, `_cockpitContactMode`, * `_trackedIcao`, `_viewer`, `_cockpitContactMode`, `_cockpitNearContacts`
* `_cockpitNearContacts` and `records` (`data`, `missingPolls`, `forget`). * and `records` (`data`, `missingPolls`, `forget`). `parts.motion` supplies
* `parts.motion._motionRegime` picks the motion; `parts.rendering` supplies * `_motionRegime`, `_displayTimeAt` and `_fixEpochMs`; `parts.rendering`
* the icon kind, scale, colours and distance scalars, and `_releaseModel`. * the icon kind, scale, colours, and `_releaseModel`.
* *
* @param {object} options * @param {object} options
* @param {object} options.state The layer's mutable state. * @param {object} options.state The layer's mutable state.
@@ -86,209 +250,243 @@ export function createAircraftIcons({
onForget = () => {}, onForget = () => {},
}) { }) {
const { focusPassIsNeeded } = services.focus; const { focusPassIsNeeded } = services.focus;
const scratchTime = new Cesium.JulianDate(); const delayMs = renderDelaySec * 1000;
const scratchPosition = new Cesium.Cartesian3(); // The near-image switch the rows were last written with (CSS px).
const scratchCull = new Cesium.Cartesian3(); let switchPx = nearImageSwitchPx(1);
const scratchScaleByDistance = new Cesium.NearFarScalar();
/** The delayed instant every untracked contact is drawn at. */ /** The delayed instant (epoch ms) every untracked contact is drawn at. */
function _displayTime(result = scratchTime) { const _displayMs = () => Date.now() - delayMs;
return Cesium.JulianDate.addSeconds(
Cesium.JulianDate.now(result), /**
-renderDelaySec, * Create the draw set for one layer lifetime, drawn over depth and culled
result, * 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() { /** Rewrite every row's image switch when the scene's pixel ratio moved. */
return state._icons.seconds(_displayTime()); 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. */ /** Where a contact is drawn right now (into `result`), or null. */
function _createIcons(viewer) { function _iconPosition(icao24, result) {
state._icons = createIconSet({ epoch: _displayTime() }); return state._icons?.position(icao24, _displayMs(), result) ?? null;
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);
} }
/** The nose direction a contact is drawn with right now. */ /** The nose direction a contact is drawn with right now. */
function _iconCourse(icao24) { function _iconCourse(icao24) {
const set = state._icons; return state._icons?.course(icao24, _displayMs()) ?? null;
const row = set?.row(icao24) ?? -1;
return row < 0 ? null : set.course(row, _displayTau());
} }
/** Whether the layer draws this contact's icon (not tracked, not model-owned). */ /** Whether the layer draws this contact's icon (not tracked, not model-owned). */
function _iconShown(icao24) { function _iconShown(icao24) {
const set = state._icons; const icons = state._icons;
const row = set?.row(icao24) ?? -1; return Boolean(icons?.has(icao24) && icons.shown(icao24));
return row >= 0 && set.shown(row);
} }
/** 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() { function _occluder() {
const camera = state._viewer?.camera; const pose = state._viewer ? findCamera(state._viewer)?.pose() : null;
return camera?.positionWC ? horizonOccluder(camera) : null; return pose?.position ? horizonFrom(pose.position) : 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),
)
);
} }
/** /**
* 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 * 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 * 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 * 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 {string} icao24
* @param {{fromCourseDeg?: number|null}} [options] Nose to glide from when * @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 } = {}) { function _planIcon(icao24, { fromCourseDeg } = {}) {
const set = state._icons; const icons = state._icons;
const row = set?.row(icao24) ?? -1; if (!icons?.has(icao24) || holdsPlan(icao24)) return;
if (row < 0 || holdsPlan(icao24)) return;
const history = state._positionHistory.get(icao24); const history = state._positionHistory.get(icao24);
if (!history?.length) return; if (!history?.length) return;
const info = state.records.data.get(icao24); const info = state.records.data.get(icao24);
const renderTime = _displayTime(); const t = _displayMs();
const tau = set.seconds(renderTime); const renderTime = parts.motion._displayTimeAt(t);
const seg = set.segments; const fixMs = parts.motion._fixEpochMs;
const shownCourse = const shownCourse =
fromCourseDeg ?? 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); const regime = parts.motion._motionRegime(history, info, renderTime);
let speed; let speed;
let motion;
let pos;
let course;
let expiresAt = Infinity; let expiresAt = Infinity;
if (regime.kind === 'between') { if (regime.kind === 'between') {
const { a, b, span, trackFrom, trackTo, chordCourse } = regime; const { a, b, span, trackFrom, trackTo, chordCourse } = regime;
speed = regime.speed; speed = regime.speed;
const blend = chordCourse == null ? 0 : regime.blend; const blend = chordCourse == null ? 0 : regime.blend;
pos = clone(b.position);
if (span > 0) { if (span > 0) {
writeLerpSegment(seg, row, { course = trackFrom + blend * norm180((chordCourse ?? 0) - trackFrom);
from: a.position, motion = {
to: b.position, kind: 'lerp',
t0: set.seconds(a.time), from: clone(a.position),
t1: set.seconds(b.time), to: pos,
course0Deg: t0: fixMs(a),
trackFrom + blend * norm180((chordCourse ?? 0) - trackFrom), t1: fixMs(b),
course0Deg: course,
courseSlopeDeg: norm180(trackTo - trackFrom) * (1 - blend), courseSlopeDeg: norm180(trackTo - trackFrom) * (1 - blend),
}); };
} else { } else {
writeHoldSegment( course = trackTo + blend * norm180((chordCourse ?? 0) - trackTo);
seg, motion = { kind: 'hold', courseDeg: course };
row,
b.position,
trackTo + blend * norm180((chordCourse ?? 0) - trackTo),
);
} }
expiresAt = set.seconds(b.time); expiresAt = fixMs(b);
} else { } else {
const { fix, heading } = regime; const { fix, heading } = regime;
speed = regime.speed; speed = regime.speed;
const t0 = set.seconds(fix.time); const t0 = fixMs(fix);
if (speed === 0) { pos = clone(fix.position);
writeHoldSegment(seg, row, fix.position, heading); course = heading;
} else { motion =
writeArcSegment(seg, row, { speed === 0
fix: fix.position, ? { kind: 'hold', courseDeg: heading }
t0, : {
minDt: regime.minDt, kind: 'arc',
maxDt: regime.maxDt, fix: pos,
speedMps: speed, t0,
trackDeg: heading, minDtS: regime.minDt,
turnRateDps: regime.turnRateDps, 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. // A warm-up's arc ends at its fix; a coast's runs to its limit.
if (regime.maxDt === 0) expiresAt = t0; if (regime.maxDt === 0) expiresAt = t0;
} }
// Below hover speed the nose holds what is on screen (or, for a new row, // 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; const hold = speed < COURSE_HOLD_SPEED_MPS;
let courseGlide;
if (hold || shownCourse != null) { if (hold || shownCourse != null) {
writeCourseGlide( const rateDps = hold ? 0 : courseSlewCapDps(speed, courseMaxDps);
seg, const prev = icons.item(icao24);
row, // The same motion at the same rate: the glide under way goes on, as
shownCourse ?? segmentCourse(seg, row, tau), // one started now from the course on screen would.
tau, courseGlide =
hold ? 0 : courseSlewCapDps(speed, courseMaxDps), 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`. */ /** Re-plan every row whose regime ended by `t` (epoch ms). */
function _replanExpired(tau) { function _replanExpired(t) {
const set = state._icons; for (const icao24 of state._icons.due(t)) _planIcon(icao24);
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);
} }
/** /**
* Advance focus de-emphasis for every drawn row (and every row a fleet model * 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 * 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; if (!focusPassIsNeeded(target, state._iconFocusActive)) return;
const { advanceProjectedSpriteFocus, nearFarScalarValueAtDistance } = const {
services.focus; advanceSpriteFocus,
const set = state._icons; 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; let active = 0;
for (let row = 0; row < set.count; row++) { for (const id of icons.ids()) {
if (!set.shown(row) && !state._models.has(set.idAt(row))) continue; if (!icons.shown(id) && !state._models.has(id)) continue;
const position = set.position(row, tau, scratchPosition); 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( const distanceScale = nearFarScalarValueAtDistance(
set.scaleByDistance(row, scratchScaleByDistance), item.scaleByDistance,
Cesium.Cartesian3.distance(camera.positionWC, position), cameraDistance,
); );
const half = set.scale(row) * distanceScale * 0.5; const half = (item.scale ?? 1) * distanceScale * 0.5;
const focus = advanceProjectedSpriteFocus( const focus = advanceSpriteFocus(item.meta, {
set.metaAt(row), screenPosition: query?.project(position) ?? null,
position, cameraDistance,
scene,
camera,
nowMs, nowMs,
target, target,
undefined, spriteHalfWidthPx: item.size[0] * half,
set.width(row) * half, spriteHalfHeightPx: item.size[1] * half,
set.height(row) * half, });
);
set.setFocus(row, focus.factor);
if (focus.active || focus.transitioning) active++; if (focus.active || focus.transitioning) active++;
if (focusAlphaNeedsWrite(current, focus.factor))
icons.setFocus(id, focus.factor);
} }
state._iconFocusActive = active; state._iconFocusActive = active;
} }
/** Image, size, scale, tint and freshness for one row under the current /** 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) { function _applyIconPresentation(icao24) {
const set = state._icons; const icons = state._icons;
const row = set?.row(icao24) ?? -1; if (!icons?.has(icao24)) return;
if (row < 0) return;
const rendering = parts.rendering; const rendering = parts.rendering;
const info = state.records.data.get(icao24); const info = state.records.data.get(icao24);
const tracked = icao24 === state._trackedIcao; const tracked = icao24 === state._trackedIcao;
@@ -296,54 +494,50 @@ export function createAircraftIcons({
state._cockpitContactMode && state._cockpitContactMode &&
!tracked && !tracked &&
!state._cockpitNearContacts.has(icao24); !state._cockpitNearContacts.has(icao24);
if (cockpitDot) { const look = cockpitDot
const dot = iconAtlas.slot(cockpitContactDotImage(), COCKPIT_DOT_PX); ? {
set.setImage(row, dot, dot); image: cockpitDotImage(),
set.setSize(row, cockpitContactSizePx, cockpitContactSizePx); imageLod: undefined,
set.setScale(row, 1); size: [cockpitContactSizePx, cockpitContactSizePx],
set.setScaleByDistance(row, COCKPIT_SCALE_BY_DISTANCE); scale: 1,
set.setColor(row, rendering._cockpitContactColor(icao24, info)); scaleByDistance: COCKPIT_SCALE_BY_DISTANCE,
set.setFlag(row, ICON_ROTATES, false); color: rgba(rendering._cockpitContactColor(icao24, info)),
} else { rotationMode: 'screen',
set.setImage( }
row, : {
iconAtlas.slot( image: aircraftIcon(
aircraftIcon(rendering._iconKind(icao24, info?.klass)),
FLEET_ICON_PX,
),
iconAtlas.slot(
aircraftIcon(
rendering._iconKind(icao24, info?.klass), rendering._iconKind(icao24, info?.klass),
TRACKED_ICON_PX, FLEET_ICON_PX,
), ),
TRACKED_ICON_PX, imageLod: {
), near: aircraftIcon(
); rendering._iconKind(icao24, info?.klass),
const size = tracked ? 24 : 20; TRACKED_ICON_PX,
set.setSize(row, size, size); ),
set.setScale(row, rendering._fleetBillboardScale(icao24, info?.klass)); switchPx,
set.setScaleByDistance(row, NORMAL_SCALE_BY_DISTANCE); },
set.setColor(row, rendering._fleetBillboardColor(icao24, info)); size: tracked ? [24, 24] : [20, 20],
set.setFlag(row, ICON_ROTATES, true); scale: rendering._fleetBillboardScale(icao24, info?.klass),
} scaleByDistance: NORMAL_SCALE_BY_DISTANCE,
set.setFlag(row, ICON_RECEDES, true); color: rgba(rendering._fleetBillboardColor(icao24, info)),
set.setFlag( rotationMode: 'course',
row, };
ICON_CULL_LIFT, look.alpha = state.records.missingPolls.get(icao24) ? 0.45 : 1;
Number.isFinite(info?.renderAltitudeM) && icons.update(icao24, look);
info.renderAltitudeM < ICON_CULL_LIFT_BELOW_M,
);
set.setAlpha(row, state.records.missingPolls.get(icao24) ? 0.45 : 1);
} }
/** Add a row for a new contact, hidden while it is the tracked one. */ /** Add a row for a new contact, hidden while it is the tracked one. */
function _addIcon(icao24) { function _addIcon(icao24) {
const set = state._icons; state._icons.put(_baseItem(icao24, icao24 !== state._trackedIcao), {
const row = set.add(icao24, { layer: layerId, id: icao24 }); expiresAt: -Infinity,
});
_applyIconPresentation(icao24); _applyIconPresentation(icao24);
_settleIcon(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. * @param {{fromCourseDeg?: number}} [options] The course on screen to glide from.
*/ */
function _settleIcon(icao24, options) { function _settleIcon(icao24, options) {
const set = state._icons; const icons = state._icons;
const row = set?.row(icao24) ?? -1; if (!icons?.has(icao24)) return;
if (row < 0) return;
beforeSettle(icao24); beforeSettle(icao24);
if (set.focus(row) < 1) state._iconFocusActive += 1; if (icons.focus(icao24) < 1) state._iconFocusActive += 1;
_planIcon(icao24, options); _planIcon(icao24, options);
afterSettle(icao24); afterSettle(icao24);
} }
@@ -376,19 +569,18 @@ export function createAircraftIcons({
/** Icon ids, so ray samples never land on an aircraft instead of the ground. */ /** Icon ids, so ray samples never land on an aircraft instead of the ground. */
function _iconIds() { function _iconIds() {
const set = state._icons; return state._icons?.ids() ?? [];
const ids = new Array(set?.count ?? 0);
for (let row = 0; row < ids.length; row++) ids[row] = set.idAt(row);
return ids;
} }
return { return {
_displayTime, _displayMs,
_displayTau,
_createIcons, _createIcons,
_disposeIcons,
_syncImageSwitch,
_iconPosition, _iconPosition,
_iconCourse, _iconCourse,
_iconShown, _iconShown,
_setIconShown,
_occluder, _occluder,
_aboveHorizon, _aboveHorizon,
_planIcon, _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 * Test seams over an aircraft layer's icon rows, shared by the flights and
* military `testing` parts. * military `testing` parts.
@@ -410,15 +624,24 @@ export function createAircraftIcons({
* @param {string} layerId * @param {string} layerId
*/ */
export function aircraftIconTestSeams(state, parts, 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 /** Give a test contact an icon row held at `icon.position`, shown as
* `icon.show` says (hidden by default while tracked). */ * `icon.show` says (hidden by default while tracked). */
function _seedIconForTest(icao24, icon, tracked) { function _seedIconForTest(icao24, icon, tracked) {
const set = state._icons; state._icons.put(
const row = set.add(icao24, { layer: layerId, id: icao24 }); {
if (icon?.position) writeHoldSegment(set.segments, row, icon.position, 0); ...baseContactItem(layerId, icao24, icon?.show ?? !tracked),
set.segmentWritten(row); ...(icon?.position ? held(icon.position) : null),
set.setShown(row, icon?.show ?? !tracked); },
return row; { expiresAt: Infinity },
);
} }
/** Where a contact's icon is drawn now and whether the layer shows it. */ /** 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. */ /** Show or hide a contact's icon as a handoff would, or hold it somewhere. */
function _setIconForTest(icao24, { shown, position } = {}) { function _setIconForTest(icao24, { shown, position } = {}) {
const set = state._icons; const icons = state._icons;
const row = set?.row(icao24) ?? -1; if (!icons?.has(icao24)) return;
if (row < 0) return; if (shown !== undefined) icons.setShown(icao24, shown);
if (shown !== undefined) set.setShown(row, shown); if (position) icons.update(icao24, held(position), { expiresAt: Infinity });
if (position) {
writeHoldSegment(set.segments, row, position, 0);
set.segmentWritten(row);
}
} }
return { _seedIconForTest, _iconForTest, _setIconForTest }; return { _seedIconForTest, _iconForTest, _setIconForTest };
+43 -39
View File
@@ -1,6 +1,5 @@
import * as Cesium from 'cesium'; import * as Cesium from 'cesium';
import { selectModelEligible } from './modelEligibility.js'; import { selectModelEligible } from './modelEligibility.js';
import { horizonOccluder } from './iconOrientation.js';
import { aircraftTreatmentAlpha } from './aircraftRecession.js'; import { aircraftTreatmentAlpha } from './aircraftRecession.js';
import { AIRCRAFT_ENVIRONMENT_MAP_OPTIONS } from './aircraftModelLighting.js'; import { AIRCRAFT_ENVIRONMENT_MAP_OPTIONS } from './aircraftModelLighting.js';
import { import {
@@ -30,7 +29,7 @@ import {
* including the tracked contact's. * including the tracked contact's.
* @param {(icao24: string) => void} [options.onModelEligible] Runs when a * @param {(icao24: string) => void} [options.onModelEligible] Runs when a
* contact is about to render in 3D. * 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 * camera: Cesium.Camera) => void} [options.afterReplan] The layer's own pass
* in the fleet tick, after expired rows are re-planned. * 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 * `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. */ * belongs to a model that is about to draw, not to one still waiting. */
function _driveFleetModelHandoff( function _driveFleetModelHandoff(icao24, record, pos, course, beforeShow) {
icao24,
record,
row,
pos,
course,
beforeShow,
) {
const icons = state._icons; const icons = state._icons;
if (!record) { if (!record) {
icons.setShown(row, true); icons.setShown(icao24, true);
return false; return false;
} }
const displayPos = _modelDisplayPosition( const displayPos = _modelDisplayPosition(
@@ -209,7 +201,7 @@ export function createAircraftModels({
); );
if (!displayPos) { if (!displayPos) {
showModel(record, false); // no ground evidence → nothing safe to place a depth-tested model at 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; return false;
} }
// The matrix is written BEFORE the readiness test on purpose: a model can flip // 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) { if (!record.model.ready) {
showModel(record, false); // not loaded yet → keep the 2D icon, no half-model flash showModel(record, false); // not loaded yet → keep the 2D icon, no half-model flash
icons.setShown(row, true); icons.setShown(icao24, true);
return false; return false;
} }
beforeShow?.(); beforeShow?.();
if (!record.show) showModel(record, true); 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; return true;
} }
@@ -509,8 +501,8 @@ export function createAircraftModels({
function _showReleasedIcon(icao24) { function _showReleasedIcon(icao24) {
const icons = state._icons; const icons = state._icons;
const row = icons?.row(icao24) ?? -1; if (icons?.has(icao24) && icao24 !== state._trackedIcao)
if (row >= 0 && icao24 !== state._trackedIcao) icons.setShown(row, true); icons.setShown(icao24, true);
} }
/** Destroy the standalone tracked-aircraft model and invalidate any in-flight load. */ /** 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. // readout consumers then reuse that exact cached position.
const pos = const pos =
parts.motion._trackedDisplayPosition(state._trackedIcao) || parts.motion._trackedDisplayPosition(state._trackedIcao) ||
parts.icons._iconPosition(state._trackedIcao); parts.icons._iconPosition(state._trackedIcao, new Cesium.Cartesian3());
if (!pos) { if (!pos) {
if (state._trackedModel) showModel(state._trackedModel, false); if (state._trackedModel) showModel(state._trackedModel, false);
return; return;
@@ -631,7 +623,10 @@ export function createAircraftModels({
// default here produces a one-frame jump to the Earth's center. // default here produces a one-frame jump to the Earth's center.
const currentPos = const currentPos =
parts.motion._trackedDisplayCached() || parts.motion._trackedDisplayCached() ||
parts.icons._iconPosition(state._trackedIcao); parts.icons._iconPosition(
state._trackedIcao,
new Cesium.Cartesian3(),
);
if (currentPos) { if (currentPos) {
const displayPos = _modelDisplayPosition( const displayPos = _modelDisplayPosition(
state._trackedIcao, state._trackedIcao,
@@ -710,33 +705,45 @@ export function createAircraftModels({
/** /**
* ~12 Hz fleet pass. Motion, rotation, the horizon cull, limb recession and * ~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 * the two-tier glyph swap all run on the GPU from each icon's motion, so this
* only re-plans rows whose regime ended, runs the layer's own pass after * only re-plans icons whose regime ended, runs the layer's own pass after
* that (flights floors grounded contacts), advances focus de-emphasis while * that (flights floors grounded contacts), advances focus de-emphasis while
* a target exists, and drives the 3D-model handoff inside the model regime. * 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} * @returns {void}
*/ */
function _fleetTick() { function _fleetTick() {
try {
_fleetPass();
} finally {
state._icons?.flush();
}
}
function _fleetPass() {
const icons = state._icons; const icons = state._icons;
if (!state._viewer || !icons || !icons.show) return; if (!state._viewer || !icons || !icons.show) return;
const scene = state._viewer.scene;
const camera = state._viewer.camera; const camera = state._viewer.camera;
const nowMs = focusNowMs(Date.now()); const nowMs = focusNowMs(Date.now());
if (nowMs - state._lastFleetTickMs < policy.FLEET_DR_INTERVAL_MS) return; if (nowMs - state._lastFleetTickMs < policy.FLEET_DR_INTERVAL_MS) return;
state._lastFleetTickMs = nowMs; state._lastFleetTickMs = nowMs;
// Every contact in this pass shares the same delayed display instant. // Every contact in this pass shares the same delayed display instant.
const renderTime = parts.icons._displayTime(state._scratchFleetRenderTime); const t = parts.icons._displayMs();
const tau = icons.seconds(renderTime); const renderTime = parts.motion._displayTimeAt(
t,
state._scratchFleetRenderTime,
);
_drainIrReloadQueue(); // bounded per-tick slice of any pending boost-flip reload _drainIrReloadQueue(); // bounded per-tick slice of any pending boost-flip reload
if (state._cockpitContactMode) parts.tracking._refreshCockpitNearContacts(); if (state._cockpitContactMode) parts.tracking._refreshCockpitNearContacts();
parts.icons._replanExpired(tau); parts.icons._syncImageSwitch();
afterReplan(renderTime, tau, nowMs, camera); parts.icons._replanExpired(t);
afterReplan(renderTime, t, nowMs, camera);
const focusTarget = getFocusTarget(); 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. // 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. // 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. // Candidates = planes within the KEEP radius, nearest first, each tagged with on-screen-ness.
const cand = []; const cand = [];
for (let row = 0; row < icons.count; row++) { for (const icao of icons.ids()) {
const icao = icons.idAt(row);
if (icao === state._trackedIcao) continue; if (icao === state._trackedIcao) continue;
// A converted TR-3B renders as an icon and can never take a model, so // 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, // 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 // ground or in the air — no distinction"). The cap + nearest-first ordering
// below already bound airport clusters; grounded placement is handled by the // below already bound airport clusters; grounded placement is handled by the
// one-shot ground snap in _modelDisplayPosition. // 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); const d2 = Cesium.Cartesian3.distanceSquared(camPos, position);
if (d2 > keepDistSq) continue; // beyond the keep radius → never eligible if (d2 > keepDistSq) continue; // beyond the keep radius → never eligible
cand.push([ cand.push([
@@ -816,13 +822,12 @@ export function createAircraftModels({
// modelless (the "planes vanish when 3D turns on" bug). Position the model every tick // 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 // 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. // 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) { for (const icao24 of modelEligible) {
if (isTr3b(icao24)) continue; if (isTr3b(icao24)) continue;
const row = icons.row(icao24); if (!icons.has(icao24)) continue;
if (row < 0) continue; const position = icons.position(icao24, t, state._scratchFleetPos);
const position = icons.position(row, tau, state._scratchFleetPos); if (!parts.icons._aboveHorizon(position, occluder)) {
if (!parts.icons._aboveHorizon(row, position, occluder)) {
// A model that crossed the limb would keep rendering through the // 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. // hidden globe at its last matrix; the icon's own cull is on the GPU.
const hidden = state._models.get(icao24); const hidden = state._models.get(icao24);
@@ -835,9 +840,8 @@ export function createAircraftModels({
_driveFleetModelHandoff( _driveFleetModelHandoff(
icao24, icao24,
record, record,
row,
position, position,
icons.course(row, tau), icons.course(icao24, t),
() => { () => {
applyAircraftModelTreatment({ applyAircraftModelTreatment({
model: record.model, model: record.model,
@@ -852,8 +856,8 @@ export function createAircraftModels({
alpha: state._irBoost alpha: state._irBoost
? 1 ? 1
: aircraftTreatmentAlpha({ : aircraftTreatmentAlpha({
baseAlpha: icons.alpha(row), baseAlpha: icons.alpha(icao24),
focusFactor: icons.focus(row), focusFactor: icons.focus(icao24),
cameraDistanceM, cameraDistanceM,
cameraHeightM: camera.positionCartographic?.height, cameraHeightM: camera.positionCartographic?.height,
}), }),
+15
View File
@@ -25,6 +25,21 @@ export function fixTrackDeg(fix, info, fields) {
: (info && info[fields.track]) || 0; : (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`. */ /** A reusable result for `aircraftMotionRegime`. */
export function createMotionRegime() { export function createMotionRegime() {
return { return {
+6 -6
View File
@@ -84,25 +84,25 @@ for (const layer of LAYERS) {
test(`${layer.name}: near AIR state is independent from model admission`, () => { test(`${layer.name}: near AIR state is independent from model admission`, () => {
assert.match(source, /nextCockpitNearContacts\(/, assert.match(source, /nextCockpitNearContacts\(/,
'Cockpit derives a separate near-contact hysteresis set'); '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'); 'only out-of-range Cockpit contacts become dots');
// `_iconKind` is identity for every unconverted contact (see // `_iconKind` is identity for every unconverted contact (see
// tr3bRegistry.test.mjs) — it only swaps the glyph for a contact the // tr3bRegistry.test.mjs) — it only swaps the glyph for a contact the
// operator explicitly converted into a TR-3B. // 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'); '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'); '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'); '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'); 'the gap-proof icon-to-model handoff remains intact');
}); });
test(`${layer.name}: Cockpit exit clears near state before restoring map presentation`, () => { 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]; 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, /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\);/);
}); });
} }
+2 -2
View File
@@ -372,8 +372,8 @@ function normalBillboardScaleByDistance(sourceFile) {
const src = readLayerSource(path.join(ROOT, sourceFile)); const src = readLayerSource(path.join(ROOT, sourceFile));
const fn = src.match(/const NORMAL_SCALE_BY_DISTANCE = ([\s\S]*?\);)/); const fn = src.match(/const NORMAL_SCALE_BY_DISTANCE = ([\s\S]*?\);)/);
assert.ok(fn, `${sourceFile}: NORMAL_SCALE_BY_DISTANCE not found`); 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*\)/); const scalar = fn[1].match(/near: (\d+),\s*nearValue: ([\d.]+),\s*far: (\d+),\s*farValue: ([\d.]+),?\s*\}/);
assert.ok(scalar, `${sourceFile}: billboard NearFarScalar not found`); assert.ok(scalar, `${sourceFile}: icon scale-by-distance not found`);
return scalar.slice(1).map(Number); return scalar.slice(1).map(Number);
} }
+2 -2
View File
@@ -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 // 2. The icon is never hidden by that suppression — it must keep
// satisfying the getNearby/getDetectableObjects visibility guards, so a // satisfying the getNearby/getDetectableObjects visibility guards, so a
// converted contact still works in Contacts and Cockpit. // 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`); `${name}: converting restores the icon the model handoff had hidden`);
// 3. Every aircraftIcon() CALL SITE routes through the kind resolver, so no // 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)); const source = readLayerSource(new URL(`./${name}`, import.meta.url));
// Anchor on the MODEL-eligibility loop (keepDistSq), not the unrelated // Anchor on the MODEL-eligibility loop (keepDistSq), not the unrelated
// ambient-enrichment candidate loop that also builds a `cand`. // 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.ok(loop, `${name}: the model-eligibility candidate loop is present`);
assert.match(loop, /keepDistSq/, `${name}: matched the model-eligibility loop`); assert.match(loop, /keepDistSq/, `${name}: matched the model-eligibility loop`);
assert.match(loop, /if \(isTr3b\(icao\)\) continue;/, assert.match(loop, /if \(isTr3b\(icao\)\) continue;/,
+4 -5
View File
@@ -193,15 +193,14 @@ export function createEnrichment({
); );
const cand = []; const cand = [];
const icons = flightState._icons; const icons = flightState._icons;
const tau = parts.icons._displayTau(); const t = parts.icons._displayMs();
for (let row = 0; row < icons.count; row++) { for (const icao24 of icons.ids()) {
const icao24 = icons.idAt(row);
if (flightState._enrichSeen.has(`t:${icao24}`)) continue; // answered / queued / negative this session 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 (!/^[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) if (flightState.records.data.get(icao24)?.onGround) continue; // ground traffic never spends ambient budget (click-to-enrich still works)
const position = icons.position( const position = icons.position(
row, icao24,
tau, t,
flightState._scratchModelBS.center, flightState._scratchModelBS.center,
); );
if (!occluder.isPointVisible(position)) continue; // beyond the limb if (!occluder.isPointVisible(position)) continue; // beyond the limb
+26 -22
View File
@@ -1,11 +1,9 @@
import * as Cesium from 'cesium'; import * as Cesium from 'cesium';
import { FOCUS_EVIDENCE_DEV } from './policy.js'; import { FOCUS_EVIDENCE_DEV } from './policy.js';
import { writeHoldSegment } from '../../data/iconSegment.js';
import { import {
aircraftRecessionFactors, aircraftRecessionFactors,
aircraftTreatmentAlpha, aircraftTreatmentAlpha,
} from '../../data/aircraftRecession.js'; } from '../../data/aircraftRecession.js';
import { horizonOccluder } from '../../data/iconOrientation.js';
export function createEvidence({ export function createEvidence({
flightState, 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. */ /** Replace the real fleet with deterministic explicit-position contacts. */
function _setFocusEvidenceAircraft(records = []) { function _setFocusEvidenceAircraft(records = []) {
@@ -85,9 +93,9 @@ export function createEvidence({
flightState.records.data.set(id, meta); flightState.records.data.set(id, meta);
flightState._focusEvidenceIds.add(id); flightState._focusEvidenceIds.add(id);
parts.icons._addIcon(id); parts.icons._addIcon(id);
const row = icons.row(id); icons.update(id, _heldAt(position, meta.true_track), {
writeHoldSegment(icons.segments, row, position, meta.true_track); expiresAt: Infinity,
icons.segmentWritten(row); });
} }
flightState.feed._count = icons.count; flightState.feed._count = icons.count;
flightState._lastFleetTickMs = 0; flightState._lastFleetTickMs = 0;
@@ -106,21 +114,16 @@ export function createEvidence({
.toLowerCase(); .toLowerCase();
if (!flightState._focusEvidenceIds.has(id)) continue; if (!flightState._focusEvidenceIds.has(id)) continue;
const position = _focusEvidencePosition(record); const position = _focusEvidencePosition(record);
const row = flightState._icons?.row(id) ?? -1; if (!position || !flightState._icons?.has(id)) continue;
if (!position || row < 0) continue;
const meta = flightState.records.data.get(id); const meta = flightState.records.data.get(id);
if (meta) { if (meta) {
if (Number.isFinite(record.trackDeg)) meta.true_track = record.trackDeg; if (Number.isFinite(record.trackDeg)) meta.true_track = record.trackDeg;
if (Number.isFinite(record.velocityMps)) if (Number.isFinite(record.velocityMps))
meta.velocity = record.velocityMps; meta.velocity = record.velocityMps;
} }
writeHoldSegment( flightState._icons.update(id, _heldAt(position, meta?.true_track ?? 0), {
flightState._icons.segments, expiresAt: Infinity,
row, });
position,
meta?.true_track ?? 0,
);
flightState._icons.segmentWritten(row);
moved += 1; moved += 1;
} }
flightState._lastFleetTickMs = 0; flightState._lastFleetTickMs = 0;
@@ -134,11 +137,12 @@ export function createEvidence({
if (!FOCUS_EVIDENCE_DEV || !flightState._viewer) return []; if (!FOCUS_EVIDENCE_DEV || !flightState._viewer) return [];
const icons = flightState._icons; const icons = flightState._icons;
const { scene, camera } = flightState._viewer; const { scene, camera } = flightState._viewer;
const occluder = horizonOccluder(camera); const occluder = parts.icons._occluder();
const cameraHeightM = camera.positionCartographic?.height; const cameraHeightM = camera.positionCartographic?.height;
return [...flightState._focusEvidenceIds].map((id) => { return [...flightState._focusEvidenceIds].map((id) => {
const row = icons?.row(id) ?? -1; const position = icons?.has(id)
const position = row < 0 ? null : parts.icons._iconPosition(id); ? parts.icons._iconPosition(id, new Cesium.Cartesian3())
: null;
const cameraDistanceM = position const cameraDistanceM = position
? Cesium.Cartesian3.distance(camera.positionWC, position) ? Cesium.Cartesian3.distance(camera.positionWC, position)
: null; : null;
@@ -154,13 +158,13 @@ export function createEvidence({
id, id,
show: show:
!!position && !!position &&
icons.shown(row) && icons.shown(id) &&
parts.icons._aboveHorizon(row, position, occluder), parts.icons._aboveHorizon(position, occluder),
scale: factors ? icons.scale(row) * factors.scale : null, scale: factors ? icons.scale(id) * factors.scale : null,
alpha: position alpha: position
? aircraftTreatmentAlpha({ ? aircraftTreatmentAlpha({
baseAlpha: icons.alpha(row), baseAlpha: icons.alpha(id),
focusFactor: icons.focus(row), focusFactor: icons.focus(id),
cameraDistanceM, cameraDistanceM,
cameraHeightM, cameraHeightM,
}) })
+47 -50
View File
@@ -1,11 +1,7 @@
import * as Cesium from 'cesium'; import { courseSlewCapDps } from '../../data/motionModel.js';
import { courseSlewCapDps, norm180 } from '../../data/motionModel.js';
import {
segmentTargetCourse,
writeCourseGlide,
writeHoldSegment,
} from '../../data/iconSegment.js';
import { createAircraftIcons } from '../../data/aircraftIconLayer.js'; import { createAircraftIcons } from '../../data/aircraftIconLayer.js';
import { motionCourse } from '../../render/motion/iconMotion.js';
import { distanceSquared, norm180 } from '../../geo/vector.js';
import { import {
COCKPIT_CONTACT_SIZE_PX, COCKPIT_CONTACT_SIZE_PX,
COURSE_MAX_DPS, 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. * planned, and settling a grounded contact puts it straight onto the floor.
*/ */
export function createIcons({ flightState, services, parts }) { export function createIcons({ flightState, services, parts }) {
const scratchPosition = new Cesium.Cartesian3();
const icons = createAircraftIcons({ const icons = createAircraftIcons({
state: flightState, state: flightState,
services, services,
@@ -42,13 +37,8 @@ export function createIcons({ flightState, services, parts }) {
// until the next fleet tick raises it. // until the next fleet tick raises it.
afterSettle(icao24) { afterSettle(icao24) {
if (!flightState._grounded.has(icao24)) return; if (!flightState._grounded.has(icao24)) return;
const renderTime = icons._displayTime(); const t = icons._displayMs();
_floorIcon( _floorIcon(icao24, parts.motion._displayTimeAt(t), t, Date.now());
icao24,
renderTime,
flightState._icons.seconds(renderTime),
Date.now(),
);
}, },
onForget(icao24) { onForget(icao24) {
flightState._displayFloorState.delete(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 * 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 * renderer cannot sample. While the floor lifts one, the CPU pins its item
* hold at the floored dead-reckoned position each tick (rewritten only when * to a hold at the floored dead-reckoned position each tick (rewritten only
* it moved); once nothing lifts it the row goes back to its planned segment. * 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; const set = flightState._icons;
// Past FLOOR_NEAR_M a taxiing contact moves well under a pixel per tick, // 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 // 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. // out there too — sub-pixel at that range, and full rate once near.
const turn = flightState._floorTick++ % FLOOR_FAR_EVERY_TICKS; const turn = flightState._floorTick++ % FLOOR_FAR_EVERY_TICKS;
const nearSq = FLOOR_NEAR_M * FLOOR_NEAR_M; const nearSq = FLOOR_NEAR_M * FLOOR_NEAR_M;
let index = -1;
for (const icao24 of flightState._grounded) { for (const icao24 of flightState._grounded) {
if (icao24 === flightState._trackedIcao) continue; if (icao24 === flightState._trackedIcao) continue;
const row = set.row(icao24); if (!set.has(icao24)) continue;
if (row < 0) continue; index += 1;
if ( if (
row % FLOOR_FAR_EVERY_TICKS !== turn && index % FLOOR_FAR_EVERY_TICKS !== turn &&
cameraPosition && cameraPosition &&
Cesium.Cartesian3.distanceSquared( distanceSquared(cameraPosition, set.position(icao24, t)) > nearSq
cameraPosition,
set.position(row, tau, scratchPosition),
) > nearSq
) )
continue; continue;
_floorIcon(icao24, renderTime, tau, nowMs); _floorIcon(icao24, renderTime, t, nowMs);
} }
} }
/** One grounded contact's floor pass (see `_floorGroundedIcons`). */ /** 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 set = flightState._icons;
const row = set.row(icao24); if (!set?.has(icao24)) return;
if (row < 0) return;
const info = flightState.records.data.get(icao24); const info = flightState.records.data.get(icao24);
const raw = parts.motion._deadReckon( const raw = parts.motion._deadReckon(
icao24, icao24,
@@ -112,35 +104,40 @@ export function createIcons({ flightState, services, parts }) {
); );
if (!display || display === raw) { if (!display || display === raw) {
if (flightState._floorPinned.delete(icao24)) if (flightState._floorPinned.delete(icao24))
icons._planIcon(icao24, { fromCourseDeg: set.course(row, tau) }); icons._planIcon(icao24, { fromCourseDeg: set.course(icao24, t) });
return; return;
} }
const planned = set.expires(row) !== -Infinity; const planned = set.expires(icao24) !== -Infinity;
const prev = planned ? set.course(row, tau) : null; const prev = planned ? set.course(icao24, t) : null;
// The pin holds the position; the GPU glides the course onto the target, // The pin holds the position; the renderer glides the course onto the
// so the rate stays exact however seldom the pin is rewritten. // target, so the rate stays exact however seldom the pin is rewritten.
const target = hold && prev != null ? prev : rawCourse; const target = hold && prev != null ? prev : rawCourse;
const item = set.item(icao24);
if ( if (
flightState._floorPinned.has(icao24) && flightState._floorPinned.has(icao24) &&
Cesium.Cartesian3.distanceSquared( distanceSquared(display, set.position(icao24, t)) <= PIN_MOVE_SQ_M &&
display, Math.abs(norm180(target - motionCourse(item.motion, item.course, t))) <=
set.position(row, tau, scratchPosition),
) <= PIN_MOVE_SQ_M &&
Math.abs(norm180(target - segmentTargetCourse(set.segments, row, tau))) <=
PIN_TURN_DEG PIN_TURN_DEG
) )
return; return;
flightState._floorPinned.add(icao24); flightState._floorPinned.add(icao24);
writeHoldSegment(set.segments, row, display, target); set.update(
if (prev != null) icao24,
writeCourseGlide( {
set.segments, pos: { x: display.x, y: display.y, z: display.z },
row, course: target,
prev, motion: { kind: 'hold', courseDeg: target },
tau, courseGlide:
courseSlewCapDps(speed, COURSE_MAX_DPS), prev == null
); ? undefined
set.segmentWritten(row); : {
fromCourseDeg: prev,
t0: t,
rateDps: courseSlewCapDps(speed, COURSE_MAX_DPS),
},
},
{ expiresAt: Infinity },
);
} }
return { ...icons, _floorGroundedIcons }; return { ...icons, _floorGroundedIcons };
+37 -18
View File
@@ -3,12 +3,16 @@ import assert from 'node:assert/strict';
import * as Cesium from 'cesium'; import * as Cesium from 'cesium';
import { createFlightState } from './state.js'; import { createFlightState } from './state.js';
import { createIcons } from './icons.js'; import { createIcons } from './icons.js';
import { createIconSet } from '../../data/iconSet.js'; import { createContactIcons } from '../../data/aircraftIconLayer.js';
import { writeHoldSegment } from '../../data/iconSegment.js';
function services(focus = {}) { function services(focus = {}) {
return { return {
focus: { focusPassIsNeeded: () => true, ...focus }, focus: {
focusPassIsNeeded: () => true,
focusAlphaNeedsWrite: (a, b) => Math.abs(a - b) > 1e-3,
spriteFocusAtRest: () => false,
...focus,
},
groundSnap: { createGroundSnap: () => ({ clear() {}, forget() {} }) }, groundSnap: { createGroundSnap: () => ({ clear() {}, forget() {} }) },
}; };
} }
@@ -16,20 +20,35 @@ function services(focus = {}) {
function setup({ focus, motion = {}, rendering = {} } = {}) { function setup({ focus, motion = {}, rendering = {} } = {}) {
const svc = services(focus); const svc = services(focus);
const flightState = createFlightState({ services: svc }); const flightState = createFlightState({ services: svc });
flightState._icons = createIconSet(); flightState._icons = createContactIcons();
const parts = { 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 }, rendering: { _modelOwnsVisual: () => false, ...rendering },
}; };
const icons = createIcons({ flightState, services: svc, parts }); const icons = createIcons({ flightState, services: svc, parts });
return { flightState, icons, set: flightState._icons }; return { flightState, icons, set: flightState._icons };
} }
function hold(set, id, position, course = 0) { function hold(set, id, position, course = 0, show = false) {
const row = set.add(id, { layer: 'flights', id }); set.put(
writeHoldSegment(set.segments, row, position, course); {
set.segmentWritten(row); id,
return row; 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); 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({ const { flightState, icons, set } = setup({
focus: { focus: {
nearFarScalarValueAtDistance: () => 1, nearFarScalarValueAtDistance: () => 1,
advanceProjectedSpriteFocus(meta) { advanceSpriteFocus(meta) {
advanced.push(meta.id); advanced.push(meta.id);
return { factor: 0.4, active: true }; 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)); const modeled = hold(set, 'modeled', at(0.1));
hold(set, 'hidden', at(0.2)); hold(set, 'hidden', at(0.2));
flightState._models.set('modeled', {}); flightState._models.set('modeled', {});
icons._focusIcons(0, {}, { positionWC: at(0, 50_000) }, 0, {}); icons._focusIcons(0, 0, {});
assert.deepEqual(advanced, ['drawn', 'modeled']); assert.deepEqual(advanced, ['drawn', 'modeled']);
assert.ok( assert.ok(
Math.abs(set.focus(modeled) - 0.4) < 1e-6, 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', [{}]); flightState._positionHistory.set('g', [{}]);
icons._settleIcon('g', { fromCourseDeg: 123 }); icons._settleIcon('g', { fromCourseDeg: 123 });
const tau = icons._displayTau(); const t = icons._displayMs();
assert.ok(Cesium.Cartesian3.distance(set.position(row, tau), floored) < 0.01); assert.ok(Cesium.Cartesian3.distance(set.position(row, t), floored) < 0.01);
assert.ok(Math.abs(set.course(row, tau) - 123) < 1e-3, 'tracked nose kept'); 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'); 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: { focus: {
focusPassIsNeeded: (target, active) => target != null || active > 0, focusPassIsNeeded: (target, active) => target != null || active > 0,
nearFarScalarValueAtDistance: () => 1, nearFarScalarValueAtDistance: () => 1,
advanceProjectedSpriteFocus(meta) { advanceSpriteFocus(meta) {
advanced.push(meta.id); advanced.push(meta.id);
return { factor: 1, active: false, transitioning: false }; 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; flightState._iconFocusActive = 0;
icons._settleIcon('was-tracked'); icons._settleIcon('was-tracked');
set.setShown(row, true); 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.deepEqual(advanced, ['was-tracked']);
assert.equal(set.focus(row), 1); assert.equal(set.focus(row), 1);
}); });
+4 -12
View File
@@ -9,11 +9,8 @@ export function createLifecycle({
resolveAsset, resolveAsset,
}) { }) {
const { clearFocusTarget } = services.focus; const { clearFocusTarget } = services.focus;
const { const { registerSpriteSet, restoreSpriteOrder, restoreSpriteOrderOnEnable } =
registerSpriteCollection, services.sprites;
restoreSpriteOrder,
restoreSpriteOrderOnEnable,
} = services.sprites;
const { onMilitaryLayerActiveChange } = services.militaryRegistry; const { onMilitaryLayerActiveChange } = services.militaryRegistry;
const { holdContinuousRender, releaseContinuousRender } = services.render; const { holdContinuousRender, releaseContinuousRender } = services.render;
const { ensureGeoidReady } = services.geoid; const { ensureGeoidReady } = services.geoid;
@@ -48,7 +45,7 @@ export function createLifecycle({
clearFocusTarget('flights'); clearFocusTarget('flights');
flightState._focusEvidenceIds.clear(); flightState._focusEvidenceIds.clear();
flightState._viewer = viewer; flightState._viewer = viewer;
registerSpriteCollection('flights', parts.icons._createIcons(viewer)); registerSpriteSet('flights', parts.icons._createIcons(viewer));
flightState._modelCollection = new Cesium.PrimitiveCollection(); flightState._modelCollection = new Cesium.PrimitiveCollection();
viewer.scene.primitives.add(flightState._modelCollection); viewer.scene.primitives.add(flightState._modelCollection);
// Warm the glTF cache so the tracked plane's model instantiates instantly when first needed // 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; flightState._moveEndRemove = null;
} }
parts.rendering._releaseModels(); parts.rendering._releaseModels();
if (flightState._iconPrimitive) { parts.icons._disposeIcons();
viewer.scene.primitives.remove(flightState._iconPrimitive); // removing destroys it
flightState._iconPrimitive = null;
}
flightState._icons?.clear();
flightState._icons = null;
if (flightState._modelCollection) { if (flightState._modelCollection) {
viewer.scene.primitives.remove(flightState._modelCollection); // removing destroys it + its models viewer.scene.primitives.remove(flightState._modelCollection); // removing destroys it + its models
flightState._modelCollection = null; flightState._modelCollection = null;
+11 -1
View File
@@ -36,6 +36,8 @@ import { readEntityRecord } from '../../data/entityRecords.js';
import { import {
aircraftMotionRegime, aircraftMotionRegime,
createMotionRegime, createMotionRegime,
fixEpochMs,
julianAt,
fixSpeedMps, fixSpeedMps,
fixTrackDeg, fixTrackDeg,
} from '../../data/aircraftMotionRegime.js'; } from '../../data/aircraftMotionRegime.js';
@@ -140,7 +142,10 @@ export function createMotion({
function _deadReckon(icao24, result, sampledRenderTime) { function _deadReckon(icao24, result, sampledRenderTime) {
const info = flightState.records.data.get(icao24); const info = flightState.records.data.get(icao24);
if (FOCUS_EVIDENCE_DEV && flightState._focusEvidenceIds.has(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._drCourseDeg = info?.true_track || 0;
flightState._drSpeedMps = info?.velocity || 0; flightState._drSpeedMps = info?.velocity || 0;
flightState._drCourseHold = flightState._drCourseHold =
@@ -1056,9 +1061,14 @@ export function createMotion({
out.push(cell); out.push(cell);
} }
} }
/** The display instant `epochMs` as a JulianDate, for `_motionRegime`. */
const _displayTimeAt = (epochMs, result) => julianAt(epochMs, result);
return { return {
_refloorStaleGroundedContacts, _refloorStaleGroundedContacts,
_deadReckon, _deadReckon,
_displayTimeAt,
_fixEpochMs: fixEpochMs,
_motionRegime, _motionRegime,
_extrapolateFix, _extrapolateFix,
_isTrackWarmingUp, _isTrackWarmingUp,
+17 -18
View File
@@ -135,7 +135,8 @@ export function createQueries({
// `_trackedDisplayPosition`). If that ever changes, floor this path too. // `_trackedDisplayPosition`). If that ever changes, floor this path too.
const info = flightState.records.data.get(icao24); const info = flightState.records.data.get(icao24);
const basePos = 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; if (!basePos) return null;
const displayed = displayedKinematics({ const displayed = displayedKinematics({
derivedSpeedMps: flightState._drSpeedMps, derivedSpeedMps: flightState._drSpeedMps,
@@ -428,11 +429,12 @@ export function createQueries({
const stride = Math.max(1, Math.ceil(icons.count / maxCount)); const stride = Math.max(1, Math.ceil(icons.count / maxCount));
const start = seed % stride; const start = seed % stride;
const occluder = parts.icons._occluder(); const occluder = parts.icons._occluder();
const tau = parts.icons._displayTau(); const t = parts.icons._displayMs();
const result = []; const result = [];
for (let row = start; row < icons.count; row += stride) { const ids = icons.ids();
const icao24 = icons.idAt(row); for (let i = start; i < ids.length; i += stride) {
const icao24 = ids[i];
if ( if (
flightState._cockpitContactMode && flightState._cockpitContactMode &&
icao24.toLowerCase() === flightState._cockpitSubjectId icao24.toLowerCase() === flightState._cockpitSubjectId
@@ -446,7 +448,7 @@ export function createQueries({
icao24, icao24,
record, record,
); );
if (!isTracked && !icons.shown(row) && !modelOwnsVisual) continue; if (!isTracked && !icons.shown(icao24) && !modelOwnsVisual) continue;
const info = flightState.records.data.get(icao24); const info = flightState.records.data.get(icao24);
let object = flightState._detectionObjects.get(icao24); let object = flightState._detectionObjects.get(icao24);
if (!object) { if (!object) {
@@ -471,7 +473,7 @@ export function createQueries({
: null; : null;
const pos = isTracked const pos = isTracked
? parts.motion._trackedVisualCached() || ? parts.motion._trackedVisualCached() ||
icons.position(row, tau, object._iconPos) icons.position(icao24, t, object._iconPos)
: modelOwnsVisual : modelOwnsVisual
? modelVisualAnchor( ? modelVisualAnchor(
record.matrix, record.matrix,
@@ -481,13 +483,13 @@ export function createQueries({
: spec.scale, : spec.scale,
object._weldPos || (object._weldPos = new Cesium.Cartesian3()), 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. // An icon past the horizon is not drawn, so it is not detectable.
if ( if (
!pos || !pos ||
(!isTracked && (!isTracked &&
!modelOwnsVisual && !modelOwnsVisual &&
!parts.icons._aboveHorizon(row, pos, occluder)) !parts.icons._aboveHorizon(pos, occluder))
) )
continue; continue;
object.position = pos; object.position = pos;
@@ -579,7 +581,7 @@ export function createQueries({
const icons = flightState._icons; const icons = flightState._icons;
if (!center || !icons || !icons.show) return []; if (!center || !icons || !icons.show) return [];
const occluder = parts.icons._occluder(); const occluder = parts.icons._occluder();
const tau = parts.icons._displayTau(); const t = parts.icons._displayMs();
const scratch = flightState._scratchNearbyPos; const scratch = flightState._scratchNearbyPos;
const limit = Number.isFinite(maxCount) const limit = Number.isFinite(maxCount)
@@ -590,21 +592,19 @@ export function createQueries({
const nearby = []; const nearby = [];
for (let row = 0; row < icons.count; row++) { for (const icao24 of icons.ids()) {
const icao24 = icons.idAt(row);
const isTracked = icao24 === flightState._trackedIcao; const isTracked = icao24 === flightState._trackedIcao;
const trackedPos = isTracked const trackedPos = isTracked
? parts.motion._trackedDisplayCached() ? parts.motion._trackedDisplayCached()
: null; // cached, no recompute (anti-jitter) : 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 // Keep planes rendered as a 3D model (icon hidden) so proximity counts
// don't drop to zero on the 2D→3D handoff. // don't drop to zero on the 2D→3D handoff.
if ( if (
!aircraftIncludedInNearby({ !aircraftIncludedInNearby({
isTracked, isTracked,
billboardShown: billboardShown:
icons.shown(row) && icons.shown(icao24) && parts.icons._aboveHorizon(drawn, occluder),
parts.icons._aboveHorizon(row, drawn, occluder),
modelRendering: parts.rendering._modelOwnsVisual(icao24), modelRendering: parts.rendering._modelOwnsVisual(icao24),
includeHidden, includeHidden,
}) })
@@ -678,12 +678,11 @@ export function createQueries({
const limit = Number.isFinite(maxCount) const limit = Number.isFinite(maxCount)
? Math.max(1, Math.floor(maxCount)) ? Math.max(1, Math.floor(maxCount))
: 500; : 500;
const tau = parts.icons._displayTau(); const t = parts.icons._displayMs();
const result = []; const result = [];
for (let row = 0; row < icons.count; row++) { for (const icao24 of icons.ids()) {
const icao24 = icons.idAt(row); const pos = icons.position(icao24, t, new Cesium.Cartesian3());
const pos = icons.position(row, tau);
const carto = Cesium.Cartographic.fromCartesian( const carto = Cesium.Cartographic.fromCartesian(
pos, pos,
Cesium.Ellipsoid.WGS84, Cesium.Ellipsoid.WGS84,
+15 -13
View File
@@ -4,8 +4,7 @@ import * as Cesium from 'cesium';
import { createQueries } from './queries.js'; import { createQueries } from './queries.js';
import { createRendering } from './rendering.js'; import { createRendering } from './rendering.js';
import { createIcons } from './icons.js'; import { createIcons } from './icons.js';
import { createIconSet } from '../../data/iconSet.js'; import { createContactIcons } from '../../data/aircraftIconLayer.js';
import { writeHoldSegment } from '../../data/iconSegment.js';
import { import {
createModelRecord, createModelRecord,
placeModel, placeModel,
@@ -18,11 +17,10 @@ function fixture() {
registration: ' N123 ', registration: ' N123 ',
altitude: 1000, altitude: 1000,
}; };
const icons = createIconSet(); const icons = createContactIcons();
const flightState = { const flightState = {
feed: {}, feed: {},
_icons: icons, _icons: icons,
_scratchIconRenderTime: new Cesium.JulianDate(),
_models: new Map(), _models: new Map(),
_detectionObjects: new Map(), _detectionObjects: new Map(),
records: { data: new Map([['abc123', info]]) }, records: { data: new Map([['abc123', info]]) },
@@ -49,15 +47,18 @@ function fixture() {
parts.rendering = createRendering({ flightState, services, parts }); parts.rendering = createRendering({ flightState, services, parts });
parts.icons = createIcons({ flightState, services, parts }); parts.icons = createIcons({ flightState, services, parts });
const queries = createQueries({ flightState, services, parts }).methods; const queries = createQueries({ flightState, services, parts }).methods;
const row = () => icons.row('abc123');
/** Hold the contact's icon at `position`. */ /** Hold the contact's icon at `position`. */
const place = (position) => { const place = (position) =>
writeHoldSegment(icons.segments, row(), position, 0); icons.update(
icons.segmentWritten(row()); 'abc123',
}; {
icons.add('abc123', { id: '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)); place(new Cesium.Cartesian3(1, 2, 3));
icons.setShown(row(), true);
return { return {
flightState, flightState,
info, info,
@@ -65,8 +66,9 @@ function fixture() {
queries, queries,
formats: () => formats, formats: () => formats,
place, place,
show: (shown) => icons.setShown(row(), shown), show: (shown) => icons.setShown('abc123', shown),
drawn: () => parts.icons._iconPosition('abc123'), drawn: () =>
parts.icons._iconPosition('abc123', new Cesium.Cartesian3()),
}; };
} }
+2 -7
View File
@@ -94,13 +94,8 @@ export function createRendering({
// About to render in 3D: jump the ambient type-enrichment backlog. // About to render in 3D: jump the ambient type-enrichment backlog.
onModelEligible: (icao24) => onModelEligible: (icao24) =>
parts.enrichment._requestTypeEnrichment(icao24, true), parts.enrichment._requestTypeEnrichment(icao24, true),
afterReplan: (renderTime, tau, nowMs, camera) => afterReplan: (renderTime, t, nowMs, camera) =>
parts.icons._floorGroundedIcons( parts.icons._floorGroundedIcons(renderTime, t, nowMs, camera.positionWC),
renderTime,
tau,
nowMs,
camera.positionWC,
),
}); });
return { return {
+1 -2
View File
@@ -178,8 +178,7 @@ export function createFlightSnapshotRenderer({
// LANDED_MISSING_POLL_LIMIT — their disappearance means "landed", not a // LANDED_MISSING_POLL_LIMIT — their disappearance means "landed", not a
// feed gap, and the full grace left phantom planes parked at airports. // feed gap, and the full grace left phantom planes parked at airports.
const absentIds = []; const absentIds = [];
for (let row = 0; row < flightState._icons.count; row++) { for (const icao24 of flightState._icons.ids()) {
const icao24 = flightState._icons.idAt(row);
if (!currentIcaos.has(icao24)) absentIds.push(icao24); if (!currentIcaos.has(icao24)) absentIds.push(icao24);
} }
for (const icao24 of absentIds) { for (const icao24 of absentIds) {
+2 -7
View File
@@ -96,16 +96,11 @@ export function createFlightState({ source, services }) {
// Module-level state: billboard collection and per-aircraft lookup maps // 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; flightState._icons = null;
/** The primitive drawing `_icons`. */
flightState._iconPrimitive = null;
flightState._scratchIconRenderTime = new Cesium.JulianDate();
/** Contacts whose latest poll put them on the ground. */ /** Contacts whose latest poll put them on the ground. */
flightState._grounded = new Set(); flightState._grounded = new Set();
+6 -8
View File
@@ -1,8 +1,10 @@
import * as Cesium from 'cesium'; import * as Cesium from 'cesium';
import { CYAN_TRANSPARENT } from './policy.js'; import { CYAN_TRANSPARENT } from './policy.js';
import { createModelRecord } from '../../data/modelRecord.js'; import { createModelRecord } from '../../data/modelRecord.js';
import { createIconSet } from '../../data/iconSet.js'; import {
import { aircraftIconTestSeams } from '../../data/aircraftIconLayer.js'; aircraftIconTestSeams,
createContactIcons,
} from '../../data/aircraftIconLayer.js';
export function createTesting({ export function createTesting({
flightState, flightState,
@@ -73,9 +75,7 @@ export function createTesting({
}) { }) {
flightState._viewer = viewer; flightState._viewer = viewer;
flightState._modelCollection = modelCollection; flightState._modelCollection = modelCollection;
flightState._icons = createIconSet({ flightState._icons = createContactIcons();
epoch: parts.icons._displayTime(new Cesium.JulianDate()),
});
flightState._icons.show = iconLayer?.show ?? true; flightState._icons.show = iconLayer?.show ?? true;
flightState._grounded.clear(); flightState._grounded.clear();
flightState._floorPinned.clear(); flightState._floorPinned.clear();
@@ -195,7 +195,6 @@ export function createTesting({
return parts.rendering._driveFleetModelHandoff( return parts.rendering._driveFleetModelHandoff(
icao24, icao24,
flightState._models.get(icao24), flightState._models.get(icao24),
flightState._icons.row(icao24),
position, position,
course, course,
); );
@@ -210,10 +209,9 @@ export function createTesting({
/** Run the fleet tick's grounded floor pass once, at `renderTime`. */ /** Run the fleet tick's grounded floor pass once, at `renderTime`. */
function _floorGroundedIconsForTest(renderTime, cameraPosition) { function _floorGroundedIconsForTest(renderTime, cameraPosition) {
const icons = flightState._icons;
parts.icons._floorGroundedIcons( parts.icons._floorGroundedIcons(
renderTime, renderTime,
icons.seconds(renderTime), Cesium.JulianDate.toDate(renderTime).getTime(),
Date.now(), Date.now(),
cameraPosition, cameraPosition,
); );
+41 -29
View File
@@ -34,6 +34,18 @@ import {
import { roundHeadingDegrees } from '../../data/headingDegrees.js'; import { roundHeadingDegrees } from '../../data/headingDegrees.js';
import { entityRecord } from '../../data/entityRecords.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({ export function createTracking({
flightState, flightState,
services, services,
@@ -70,7 +82,7 @@ export function createTracking({
} }
function _publishTrackedSelection(icao24, origin = 'programmatic') { 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); const info = flightState.records.data.get(icao24);
if (!position || !info) return false; if (!position || !info) return false;
if (flightState._trackedEntity) if (flightState._trackedEntity)
@@ -169,11 +181,14 @@ export function createTracking({
const previous = flightState._cockpitNearContacts; const previous = flightState._cockpitNearContacts;
const distancesSquared = []; const distancesSquared = [];
const icons = flightState._icons; const icons = flightState._icons;
const tau = parts.icons._displayTau(); const t = parts.icons._displayMs();
for (let row = 0; row < (icons?.count ?? 0); row++) { for (const icao24 of icons?.ids() ?? []) {
const icao24 = icons.idAt(row);
if (icao24 === flightState._trackedIcao) continue; if (icao24 === flightState._trackedIcao) continue;
const position = icons.position(row, tau, flightState._scratchCockpitPos); const position = icons.position(
icao24,
t,
flightState._scratchCockpitPos,
);
distancesSquared.push([ distancesSquared.push([
icao24, icao24,
Cesium.Cartesian3.distanceSquared( Cesium.Cartesian3.distanceSquared(
@@ -210,9 +225,8 @@ export function createTracking({
if (flightState._modelCollection) flightState._modelCollection.show = true; if (flightState._modelCollection) flightState._modelCollection.show = true;
flightState._trail?.setVisible(!next); flightState._trail?.setVisible(!next);
if (flightState._trailHeadEntity) flightState._trailHeadEntity.show = !next; if (flightState._trailHeadEntity) flightState._trailHeadEntity.show = !next;
const icons = flightState._icons; for (const icao24 of flightState._icons?.ids() ?? [])
for (let row = 0; row < (icons?.count ?? 0); row++) parts.icons._applyIconPresentation(icao24);
parts.icons._applyIconPresentation(icons.idAt(row));
flightState._lastFleetTickMs = 0; flightState._lastFleetTickMs = 0;
} }
@@ -324,7 +338,10 @@ export function createTracking({
if (!flightState._trackedIcao || !flightState._viewer) return; if (!flightState._trackedIcao || !flightState._viewer) return;
const pos = const pos =
parts.motion._trackedDisplayCached() || parts.motion._trackedDisplayCached() ||
parts.icons._iconPosition(flightState._trackedIcao); parts.icons._iconPosition(
flightState._trackedIcao,
new Cesium.Cartesian3(),
);
if (!pos) return; if (!pos) return;
const projected = screenProjectedRotation( const projected = screenProjectedRotation(
flightState._viewer.scene, flightState._viewer.scene,
@@ -665,7 +682,7 @@ export function createTracking({
// contact, and while it still read as tracked its tracked model owned the // contact, and while it still read as tracked its tracked model owned the
// visual, so the floor would have stepped aside. // visual, so the floor would have stepped aside.
if (flightState._icons?.has(clearedIcao)) { 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._settleIcon(clearedIcao, { fromCourseDeg: trackedCourseDeg });
} }
parts.icons._applyIconPresentation(clearedIcao); parts.icons._applyIconPresentation(clearedIcao);
@@ -820,9 +837,8 @@ export function createTracking({
// an already-loaded model would otherwise linger with the billboard hidden. // an already-loaded model would otherwise linger with the billboard hidden.
if (flightState._models.has(id) || flightState._modelPending.has(id)) if (flightState._models.has(id) || flightState._modelPending.has(id))
parts.rendering._releaseModel(id); parts.rendering._releaseModel(id);
const row = flightState._icons?.row(id) ?? -1; if (flightState._icons?.has(id) && id !== flightState._trackedIcao)
if (row >= 0 && id !== flightState._trackedIcao) flightState._icons.setShown(id, true);
flightState._icons.setShown(row, true);
if (id === flightState._trackedIcao) { if (id === flightState._trackedIcao) {
parts.rendering._releaseTrackedModel(); parts.rendering._releaseTrackedModel();
_syncTracked2dRotation(); _syncTracked2dRotation();
@@ -852,7 +868,7 @@ export function createTracking({
function _routeIsPlausible(icao24, route) { function _routeIsPlausible(icao24, route) {
const info = flightState.records.data.get(icao24); 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; if (!info || !position) return true;
const carto = Cesium.Cartographic.fromCartesian( const carto = Cesium.Cartographic.fromCartesian(
position, position,
@@ -891,15 +907,15 @@ export function createTracking({
_clearTracking(false, { origin }); // switching planes — the new follow-camera takes over _clearTracking(false, { origin }); // switching planes — the new follow-camera takes over
const icons = flightState._icons; const icons = flightState._icons;
const row = icons?.row(icao24) ?? -1;
const info = flightState.records.data.get(icao24); 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 tracked limiter continues from the nose the icon was drawn with, and
// the entity starts with the rotation the icon had on screen. // the entity starts with the rotation the icon had on screen.
const tau = parts.icons._displayTau(); const t = parts.icons._displayMs();
const iconPosition = icons.position(row, tau); const iconPosition = icons.position(icao24, t, new Cesium.Cartesian3());
flightState._displayCourse.set(icao24, icons.course(row, tau)); const iconCourse = icons.course(icao24, t);
flightState._displayCourse.set(icao24, iconCourse);
flightState._trackedIcao = icao24; flightState._trackedIcao = icao24;
_resetTrackedSelectionState(); // fresh selection: enter at the ENTER ceiling, full load-retry budget _resetTrackedSelectionState(); // fresh selection: enter at the ENTER ceiling, full load-retry budget
flightState._cachedDRFrame = -1; flightState._cachedDRFrame = -1;
@@ -907,7 +923,7 @@ export function createTracking({
screenProjectedRotation( screenProjectedRotation(
flightState._viewer.scene, flightState._viewer.scene,
iconPosition, iconPosition,
icons.course(row, tau), iconCourse,
0, 0,
) ?? 0; ) ?? 0;
// Drop any fleet 3D model for this aircraft — the tracked entity now owns its visual (its // 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); parts.rendering._releaseModel(icao24);
// Hide the icon — the tracked entity replaces it visually // 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 — // Helper: smoothed, per-frame-cached tracked position (see _trackedDisplayPosition —
// one computation shared by the position/alignedAxis/rotation/trail-head callbacks, // one computation shared by the position/alignedAxis/rotation/trail-head callbacks,
@@ -924,7 +940,7 @@ export function createTracking({
// the aircraft has no fix. // the aircraft has no fix.
const getTrackedPosition = () => const getTrackedPosition = () =>
parts.motion._trackedDisplayPosition(icao24) || parts.motion._trackedDisplayPosition(icao24) ||
parts.icons._iconPosition(icao24) || parts.icons._iconPosition(icao24, new Cesium.Cartesian3()) ||
iconPosition; iconPosition;
// Dead-reckoning position property — smooth continuous motion between API updates. // Dead-reckoning position property — smooth continuous motion between API updates.
@@ -1100,8 +1116,7 @@ export function createTracking({
if (!flightState._viewer || !icons) return; if (!flightState._viewer || !icons) return;
if (active) { if (active) {
const suppressed = []; const suppressed = [];
for (let row = 0; row < icons.count; row++) { for (const icao24 of icons.ids()) {
const icao24 = icons.idAt(row);
if (isMilitaryIcao(icao24) && icao24 !== flightState._trackedIcao) if (isMilitaryIcao(icao24) && icao24 !== flightState._trackedIcao)
suppressed.push(icao24); 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 // above. H1: the model used to have no pick id, so this fell through to
// "empty space" and deselected the very plane being tracked. // "empty space" and deselected the very plane being tracked.
if (flightState._trackedIcao) { if (flightState._trackedIcao) {
const rawPick = const rawPick = aircraftPickId(picked);
typeof picked.id === 'string' ? picked.id : picked.primitive?.id;
if ( if (
(flightState._trackedModel && (flightState._trackedModel &&
picked.primitive === flightState._trackedModel.model) || picked.primitive === flightState._trackedModel.model) ||
@@ -1195,9 +1209,7 @@ export function createTracking({
return; return;
} }
// Icon picks carry the icao on picked.id; models carry it on the primitive. const pickedIcao = aircraftPickId(picked);
const pickedIcao =
typeof picked.id === 'string' ? picked.id : picked.primitive?.id;
if (pickedIcao && flightState._icons?.has(pickedIcao)) { if (pickedIcao && flightState._icons?.has(pickedIcao)) {
_cancelPendingTrackingRestore(); _cancelPendingTrackingRestore();
_trackFlight(pickedIcao, { origin: 'user' }); _trackFlight(pickedIcao, { origin: 'user' });
+3 -8
View File
@@ -9,7 +9,7 @@ export function createLifecycle({
resolveAsset, resolveAsset,
}) { }) {
const { clearFocusTarget } = services.focus; const { clearFocusTarget } = services.focus;
const { registerSpriteCollection, restoreSpriteOrder } = services.sprites; const { registerSpriteSet, restoreSpriteOrder } = services.sprites;
const { holdContinuousRender, releaseContinuousRender } = services.render; const { holdContinuousRender, releaseContinuousRender } = services.render;
const { ensureGeoidReady } = services.geoid; const { ensureGeoidReady } = services.geoid;
const { registerPickOwner, unregisterPickOwner } = services.picking; const { registerPickOwner, unregisterPickOwner } = services.picking;
@@ -42,7 +42,7 @@ export function createLifecycle({
flightState.lifetime = new AbortController(); flightState.lifetime = new AbortController();
clearFocusTarget('militaryFlights'); clearFocusTarget('militaryFlights');
flightState._viewer = viewer; flightState._viewer = viewer;
registerSpriteCollection('military', parts.icons._createIcons(viewer)); registerSpriteSet('military', parts.icons._createIcons(viewer));
flightState._modelCollection = new Cesium.PrimitiveCollection(); flightState._modelCollection = new Cesium.PrimitiveCollection();
viewer.scene.primitives.add(flightState._modelCollection); viewer.scene.primitives.add(flightState._modelCollection);
// Warm the glTF cache so the tracked plane's model instantiates instantly when first needed // 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; flightState._moveEndRemove = null;
} }
parts.rendering._releaseModels(); parts.rendering._releaseModels();
if (flightState._iconPrimitive) { parts.icons._disposeIcons();
viewer.scene.primitives.remove(flightState._iconPrimitive); // removing destroys it
flightState._iconPrimitive = null;
}
flightState._icons?.clear();
flightState._icons = null;
if (flightState._modelCollection) { if (flightState._modelCollection) {
viewer.scene.primitives.remove(flightState._modelCollection); // removing destroys it + its models viewer.scene.primitives.remove(flightState._modelCollection); // removing destroys it + its models
flightState._modelCollection = null; flightState._modelCollection = null;
+7
View File
@@ -25,6 +25,8 @@ import { readEntityRecord } from '../../data/entityRecords.js';
import { import {
aircraftMotionRegime, aircraftMotionRegime,
createMotionRegime, createMotionRegime,
fixEpochMs,
julianAt,
fixSpeedMps, fixSpeedMps,
fixTrackDeg, fixTrackDeg,
} from '../../data/aircraftMotionRegime.js'; } from '../../data/aircraftMotionRegime.js';
@@ -467,9 +469,14 @@ export function createMotion({
flightState._cachedDRHold = false; flightState._cachedDRHold = false;
flightState._trackedCourseMs = 0; flightState._trackedCourseMs = 0;
} }
/** The display instant `epochMs` as a JulianDate, for `_motionRegime`. */
const _displayTimeAt = (epochMs, result) => julianAt(epochMs, result);
return { return {
_deadReckon, _deadReckon,
_motionRegime, _motionRegime,
_displayTimeAt,
_fixEpochMs: fixEpochMs,
_extrapolateFix, _extrapolateFix,
_isTrackWarmingUp, _isTrackWarmingUp,
_trackedFocusSizePx, _trackedFocusSizePx,
+17 -18
View File
@@ -96,7 +96,8 @@ export function createQueries({
function _describeFlight(icao24) { function _describeFlight(icao24) {
const info = flightState.records.data.get(icao24); const info = flightState.records.data.get(icao24);
const basePos = 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; if (!basePos) return null;
const displayed = displayedKinematics({ const displayed = displayedKinematics({
derivedSpeedMps: flightState._drSpeedMps, derivedSpeedMps: flightState._drSpeedMps,
@@ -352,7 +353,7 @@ export function createQueries({
const icons = flightState._icons; const icons = flightState._icons;
if (!center || !icons || !icons.show) return []; if (!center || !icons || !icons.show) return [];
const occluder = parts.icons._occluder(); const occluder = parts.icons._occluder();
const tau = parts.icons._displayTau(); const t = parts.icons._displayMs();
const scratch = flightState._scratchNearbyPos; const scratch = flightState._scratchNearbyPos;
const limit = Number.isFinite(maxCount) const limit = Number.isFinite(maxCount)
@@ -363,21 +364,19 @@ export function createQueries({
const nearby = []; const nearby = [];
for (let row = 0; row < icons.count; row++) { for (const icao24 of icons.ids()) {
const icao24 = icons.idAt(row);
const isTracked = icao24 === flightState._trackedIcao; const isTracked = icao24 === flightState._trackedIcao;
const trackedPos = isTracked const trackedPos = isTracked
? parts.motion._trackedDisplayCached() ? parts.motion._trackedDisplayCached()
: null; // cached, no recompute (anti-jitter) : 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 // Keep planes rendered as a 3D model (icon hidden) so proximity counts
// don't drop to zero on the 2D→3D handoff. // don't drop to zero on the 2D→3D handoff.
if ( if (
!aircraftIncludedInNearby({ !aircraftIncludedInNearby({
isTracked, isTracked,
billboardShown: billboardShown:
icons.shown(row) && icons.shown(icao24) && parts.icons._aboveHorizon(drawn, occluder),
parts.icons._aboveHorizon(row, drawn, occluder),
modelRendering: parts.rendering._modelOwnsVisual(icao24), modelRendering: parts.rendering._modelOwnsVisual(icao24),
includeHidden, includeHidden,
}) })
@@ -437,11 +436,12 @@ export function createQueries({
const stride = Math.max(1, Math.ceil(icons.count / maxCount)); const stride = Math.max(1, Math.ceil(icons.count / maxCount));
const start = seed % stride; const start = seed % stride;
const occluder = parts.icons._occluder(); const occluder = parts.icons._occluder();
const tau = parts.icons._displayTau(); const t = parts.icons._displayMs();
const result = []; const result = [];
for (let row = start; row < icons.count; row += stride) { const ids = icons.ids();
const icao24 = icons.idAt(row); for (let i = start; i < ids.length; i += stride) {
const icao24 = ids[i];
if ( if (
flightState._cockpitContactMode && flightState._cockpitContactMode &&
icao24.toLowerCase() === flightState._cockpitSubjectId icao24.toLowerCase() === flightState._cockpitSubjectId
@@ -452,7 +452,7 @@ export function createQueries({
// doesn't vanish on the 2D→3D handoff. // doesn't vanish on the 2D→3D handoff.
const record = flightState._models.get(icao24); const record = flightState._models.get(icao24);
const modelOwnsVisual = parts.rendering._modelOwnsVisual(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 info = flightState.records.data.get(icao24);
const callsign = info?.callsign?.trim(); const callsign = info?.callsign?.trim();
const registration = info?.registration?.trim(); const registration = info?.registration?.trim();
@@ -476,7 +476,7 @@ export function createQueries({
: null; : null;
const pos = isTracked const pos = isTracked
? parts.motion._trackedVisualCached() || ? parts.motion._trackedVisualCached() ||
icons.position(row, tau, object._iconPos) icons.position(icao24, t, object._iconPos)
: modelOwnsVisual : modelOwnsVisual
? modelVisualAnchor( ? modelVisualAnchor(
record.matrix, record.matrix,
@@ -486,13 +486,13 @@ export function createQueries({
: spec.scale, : spec.scale,
object._weldPos || (object._weldPos = new Cesium.Cartesian3()), 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. // An icon past the horizon is not drawn, so it is not detectable.
if ( if (
!pos || !pos ||
(!isTracked && (!isTracked &&
!modelOwnsVisual && !modelOwnsVisual &&
!parts.icons._aboveHorizon(row, pos, occluder)) !parts.icons._aboveHorizon(pos, occluder))
) )
continue; continue;
object.position = pos; object.position = pos;
@@ -598,12 +598,11 @@ export function createQueries({
const limit = Number.isFinite(maxCount) const limit = Number.isFinite(maxCount)
? Math.max(1, Math.floor(maxCount)) ? Math.max(1, Math.floor(maxCount))
: 500; : 500;
const tau = parts.icons._displayTau(); const t = parts.icons._displayMs();
const result = []; const result = [];
for (let row = 0; row < icons.count; row++) { for (const icao24 of icons.ids()) {
const icao24 = icons.idAt(row); const pos = icons.position(icao24, t, new Cesium.Cartesian3());
const pos = icons.position(row, tau);
const carto = Cesium.Cartographic.fromCartesian( const carto = Cesium.Cartographic.fromCartesian(
pos, pos,
Cesium.Ellipsoid.WGS84, Cesium.Ellipsoid.WGS84,
+1 -2
View File
@@ -205,8 +205,7 @@ export function createMilitarySnapshotRenderer({
// LANDED_MISSING_POLL_LIMIT — their disappearance means "landed", not a // LANDED_MISSING_POLL_LIMIT — their disappearance means "landed", not a
// feed gap, and the full grace left phantom planes parked at airports. // feed gap, and the full grace left phantom planes parked at airports.
const absentIds = []; const absentIds = [];
for (let row = 0; row < flightState._icons.count; row++) { for (const icao24 of flightState._icons.ids()) {
const icao24 = flightState._icons.idAt(row);
if (!currentIcaos.has(icao24)) absentIds.push(icao24); if (!currentIcaos.has(icao24)) absentIds.push(icao24);
} }
for (const icao24 of absentIds) { for (const icao24 of absentIds) {
+2 -7
View File
@@ -91,16 +91,11 @@ export function createFlightState({ source, services }) {
// Module-level state // 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; 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. */ /** Rows still away from full focus emphasis after the last focus pass. */
flightState._iconFocusActive = 0; flightState._iconFocusActive = 0;
+5 -6
View File
@@ -1,8 +1,10 @@
import * as Cesium from 'cesium'; import * as Cesium from 'cesium';
import { AMBER_TRANSPARENT, TRACKED_ICON_COLOR } from './policy.js'; import { AMBER_TRANSPARENT, TRACKED_ICON_COLOR } from './policy.js';
import { createModelRecord } from '../../data/modelRecord.js'; import { createModelRecord } from '../../data/modelRecord.js';
import { createIconSet } from '../../data/iconSet.js'; import {
import { aircraftIconTestSeams } from '../../data/aircraftIconLayer.js'; aircraftIconTestSeams,
createContactIcons,
} from '../../data/aircraftIconLayer.js';
export function createTesting({ export function createTesting({
flightState, flightState,
@@ -45,9 +47,7 @@ export function createTesting({
}) { }) {
flightState._viewer = viewer; flightState._viewer = viewer;
flightState._modelCollection = modelCollection; flightState._modelCollection = modelCollection;
flightState._icons = createIconSet({ flightState._icons = createContactIcons();
epoch: parts.icons._displayTime(new Cesium.JulianDate()),
});
flightState._icons.show = iconLayer?.show ?? true; flightState._icons.show = iconLayer?.show ?? true;
_seedIconForTest(icao24, icon, tracked); _seedIconForTest(icao24, icon, tracked);
flightState._models.clear(); flightState._models.clear();
@@ -148,7 +148,6 @@ export function createTesting({
return parts.rendering._driveFleetModelHandoff( return parts.rendering._driveFleetModelHandoff(
icao24, icao24,
flightState._models.get(icao24), flightState._models.get(icao24),
flightState._icons.row(icao24),
position, position,
course, course,
); );
+39 -25
View File
@@ -34,6 +34,18 @@ import {
import { roundHeadingDegrees } from '../../data/headingDegrees.js'; import { roundHeadingDegrees } from '../../data/headingDegrees.js';
import { entityRecord } from '../../data/entityRecords.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({ export function createTracking({
flightState, flightState,
services, services,
@@ -68,7 +80,7 @@ export function createTracking({
} }
function _publishTrackedSelection(icao24, origin = 'programmatic') { 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); const info = flightState.records.data.get(icao24);
if (!position || !info) return false; if (!position || !info) return false;
if (flightState._trackedEntity) if (flightState._trackedEntity)
@@ -157,11 +169,14 @@ export function createTracking({
const previous = flightState._cockpitNearContacts; const previous = flightState._cockpitNearContacts;
const distancesSquared = []; const distancesSquared = [];
const icons = flightState._icons; const icons = flightState._icons;
const tau = parts.icons._displayTau(); const t = parts.icons._displayMs();
for (let row = 0; row < (icons?.count ?? 0); row++) { for (const icao24 of icons?.ids() ?? []) {
const icao24 = icons.idAt(row);
if (icao24 === flightState._trackedIcao) continue; if (icao24 === flightState._trackedIcao) continue;
const position = icons.position(row, tau, flightState._scratchCockpitPos); const position = icons.position(
icao24,
t,
flightState._scratchCockpitPos,
);
distancesSquared.push([ distancesSquared.push([
icao24, icao24,
Cesium.Cartesian3.distanceSquared( Cesium.Cartesian3.distanceSquared(
@@ -198,8 +213,8 @@ export function createTracking({
flightState._trail?.setVisible(!next); flightState._trail?.setVisible(!next);
if (flightState._trailHeadEntity) flightState._trailHeadEntity.show = !next; if (flightState._trailHeadEntity) flightState._trailHeadEntity.show = !next;
const icons = flightState._icons; const icons = flightState._icons;
for (let row = 0; row < (icons?.count ?? 0); row++) for (const icao24 of icons?.ids() ?? [])
parts.icons._applyIconPresentation(icons.idAt(row)); parts.icons._applyIconPresentation(icao24);
flightState._lastFleetTickMs = 0; flightState._lastFleetTickMs = 0;
} }
@@ -301,9 +316,8 @@ export function createTracking({
if (isTr3b(id)) { if (isTr3b(id)) {
if (flightState._models.has(id) || flightState._modelPending.has(id)) if (flightState._models.has(id) || flightState._modelPending.has(id))
parts.rendering._releaseModel(id); parts.rendering._releaseModel(id);
const row = flightState._icons?.row(id) ?? -1; if (flightState._icons?.has(id) && id !== flightState._trackedIcao)
if (row >= 0 && id !== flightState._trackedIcao) flightState._icons.setShown(id, true);
flightState._icons.setShown(row, true);
if (id === flightState._trackedIcao) { if (id === flightState._trackedIcao) {
parts.rendering._releaseTrackedModel(); parts.rendering._releaseTrackedModel();
_syncTracked2dRotation(); _syncTracked2dRotation();
@@ -418,7 +432,10 @@ export function createTracking({
if (!flightState._trackedIcao || !flightState._viewer) return; if (!flightState._trackedIcao || !flightState._viewer) return;
const pos = const pos =
parts.motion._trackedDisplayCached() || parts.motion._trackedDisplayCached() ||
parts.icons._iconPosition(flightState._trackedIcao); parts.icons._iconPosition(
flightState._trackedIcao,
new Cesium.Cartesian3(),
);
if (!pos) return; if (!pos) return;
const projected = screenProjectedRotation( const projected = screenProjectedRotation(
flightState._viewer.scene, 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 // Hand the contact back to its icon only now, once it no longer reads as
// tracked (the settle plans it as a fleet contact). // tracked (the settle plans it as a fleet contact).
if (flightState._icons?.has(clearedIcao)) { 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._settleIcon(clearedIcao, { fromCourseDeg: trackedCourseDeg });
} }
parts.icons._applyIconPresentation(clearedIcao); parts.icons._applyIconPresentation(clearedIcao);
@@ -847,15 +864,15 @@ export function createTracking({
_clearTracking(false, { origin }); // switching planes — the new follow-camera takes over _clearTracking(false, { origin }); // switching planes — the new follow-camera takes over
const icons = flightState._icons; const icons = flightState._icons;
const row = icons?.row(icao24) ?? -1;
const info = flightState.records.data.get(icao24); 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 tracked limiter continues from the nose the icon was drawn with, and
// the entity starts with the rotation the icon had on screen. // the entity starts with the rotation the icon had on screen.
const tau = parts.icons._displayTau(); const t = parts.icons._displayMs();
const iconPosition = icons.position(row, tau); const iconPosition = icons.position(icao24, t, new Cesium.Cartesian3());
flightState._displayCourse.set(icao24, icons.course(row, tau)); const iconCourse = icons.course(icao24, t);
flightState._displayCourse.set(icao24, iconCourse);
flightState._trackedIcao = icao24; flightState._trackedIcao = icao24;
_resetTrackedSelectionState(); // fresh selection: enter at the ENTER ceiling, full load-retry budget _resetTrackedSelectionState(); // fresh selection: enter at the ENTER ceiling, full load-retry budget
flightState._cachedDRFrame = -1; flightState._cachedDRFrame = -1;
@@ -863,7 +880,7 @@ export function createTracking({
screenProjectedRotation( screenProjectedRotation(
flightState._viewer.scene, flightState._viewer.scene,
iconPosition, iconPosition,
icons.course(row, tau), iconCourse,
0, 0,
) ?? 0; ) ?? 0;
// Drop any fleet 3D model for this aircraft — the tracked entity now owns its visual (its // 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); parts.rendering._releaseModel(icao24);
// Hide the icon -- the tracked entity replaces it visually // 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 — // Helper: smoothed, per-frame-cached tracked position (see _trackedDisplayPosition —
// one computation shared by the position/rotation/trail-head callbacks, with // one computation shared by the position/rotation/trail-head callbacks, with
@@ -880,7 +897,7 @@ export function createTracking({
// aircraft has no fix. // aircraft has no fix.
const getTrackedPosition = () => const getTrackedPosition = () =>
parts.motion._trackedDisplayPosition(icao24) || parts.motion._trackedDisplayPosition(icao24) ||
parts.icons._iconPosition(icao24) || parts.icons._iconPosition(icao24, new Cesium.Cartesian3()) ||
iconPosition; iconPosition;
// Dead-reckoning position property evaluated every render frame. // 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 // above. H1: the model used to have no pick id, so this fell through to
// "empty space" and deselected the very plane being tracked. // "empty space" and deselected the very plane being tracked.
if (flightState._trackedIcao) { if (flightState._trackedIcao) {
const rawPick = const rawPick = aircraftPickId(picked);
typeof picked.id === 'string' ? picked.id : picked.primitive?.id;
if ( if (
(flightState._trackedModel && (flightState._trackedModel &&
picked.primitive === flightState._trackedModel.model) || picked.primitive === flightState._trackedModel.model) ||
@@ -1102,9 +1118,7 @@ export function createTracking({
return; return;
} }
// Icon picks carry the icao on picked.id; models carry it on the primitive. const pickedIcao = aircraftPickId(picked);
const pickedIcao =
typeof picked.id === 'string' ? picked.id : picked.primitive?.id;
if (pickedIcao && flightState._icons?.has(pickedIcao)) { if (pickedIcao && flightState._icons?.has(pickedIcao)) {
_cancelPendingTrackingRestore(); _cancelPendingTrackingRestore();
_trackFlight(pickedIcao, { origin: 'user' }); _trackFlight(pickedIcao, { origin: 'user' });
+153
View File
@@ -1880,3 +1880,156 @@ test('vessels on a host with no sprite-set registry still draw, and say so once'
layer.destroy(viewer); layer.destroy(viewer);
unbind(); 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();
}
});
-2
View File
@@ -10,7 +10,6 @@
"src/cockpitCloudEffects.js", "src/cockpitCloudEffects.js",
"src/cyberSonarGpu.js", "src/cyberSonarGpu.js",
"src/cyberSonarScene.js", "src/cyberSonarScene.js",
"src/data/aircraftIconLayer.js",
"src/data/aircraftModelLayer.js", "src/data/aircraftModelLayer.js",
"src/data/aircraftMotionRegime.js", "src/data/aircraftMotionRegime.js",
"src/data/bhoteKoshiEmbeddedMedia.js", "src/data/bhoteKoshiEmbeddedMedia.js",
@@ -39,7 +38,6 @@
"src/layers/firms/rendering.js", "src/layers/firms/rendering.js",
"src/layers/flights/enrichment.js", "src/layers/flights/enrichment.js",
"src/layers/flights/evidence.js", "src/layers/flights/evidence.js",
"src/layers/flights/icons.js",
"src/layers/flights/lifecycle.js", "src/layers/flights/lifecycle.js",
"src/layers/flights/motion.js", "src/layers/flights/motion.js",
"src/layers/flights/policy.js", "src/layers/flights/policy.js",