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