mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 16:22:20 +00:00
The trail no longer joins a day of history into one line. It lifts the pen across a gap of more than 48 minutes, an implied speed over 1,500 kt, or a report without altitude (a parked aircraft within 0.1 nm for under 3 h stays joined), and every history point is kept as its own segment. History never gets an invented altitude. The live end is the path the aircraft was drawn along, thinned to its shape, so it no longer cuts corners through turns; a late report trims what was drawn after it. Old segments are frozen in chunks, so a 2,000-point trail costs about 0.1 ms a frame. A tracked aircraft that misses an update shows STALE and is dimmed. It keeps flying on its last speed and heading for five minutes (at most 1,500 kt), then stops, dimmed, labelled SIGNAL LOST with the time since its last report, and is kept for ten minutes after that report so the camera keeps its target. Aircraft on or near known ground hold at their last report instead of coasting. Military flights follow the same rules.
322 lines
14 KiB
JavaScript
322 lines
14 KiB
JavaScript
import * as Cesium from 'cesium';
|
|
import { cyberSonarBaseAlpha } from '../../cyberSonar.js';
|
|
import { CLASS_SCALE_2D } from '../../data/aircraftClass.js';
|
|
import {
|
|
turnRateFromFixHistory,
|
|
liftRepeatedGroundFix,
|
|
staleHoldsForFix,
|
|
synthesizeForwardKinematicsFix,
|
|
} from '../../data/motionModel.js';
|
|
import { aircraftIcon } from '../../data/aircraftIcons.js';
|
|
import { POSITION_HISTORY_LIMIT } from './recordPolicy.js';
|
|
import { BILLBOARD_SCALE, GROUND_SCALE, TRACKED_ICON_COLOR } from './policy.js';
|
|
|
|
/** Apply military record changes to Cesium resources and existing follow operations. */
|
|
export function createMilitarySnapshotRenderer({
|
|
flightState,
|
|
records,
|
|
groundFloor,
|
|
meshFloor,
|
|
militaryRegistry,
|
|
rendering,
|
|
tracking,
|
|
motion,
|
|
queries,
|
|
}) {
|
|
const { warmGroundFloor, cachedGroundFloor, GROUND_FLOOR_LIFT_M } =
|
|
groundFloor;
|
|
const { sampleMeshFloorCells } = meshFloor;
|
|
const { registerMilitaryIcaos } = militaryRegistry;
|
|
return function applySnapshot(snapshot, viewer) {
|
|
const currentIcaos = new Set();
|
|
const receiptNowMs = snapshot.observedAtMs;
|
|
records.beginSnapshot(snapshot.observedAtMs);
|
|
// Field-test fix (RS46): coarse floor cells to warm for the below-ground
|
|
// clamp — collected during the loop (low airborne contacts only),
|
|
// batch-resolved once after it. Never a fetch inside the loop.
|
|
const _floorWarmPoints = [];
|
|
|
|
for (const aircraft of snapshot.records) {
|
|
const icao24 = aircraft.id;
|
|
|
|
currentIcaos.add(icao24);
|
|
const { prevMeta, meta, groundFlipped, fixEpochMs } = records.receive(
|
|
aircraft,
|
|
{
|
|
observedAtMs: receiptNowMs,
|
|
floorWarmPoints: _floorWarmPoints,
|
|
modelOwnsVisual: aircraft.onGround
|
|
? rendering._modelOwnsVisual(icao24)
|
|
: false,
|
|
},
|
|
);
|
|
const position = Cesium.Cartesian3.fromDegrees(
|
|
meta.rawLon,
|
|
meta.rawLat,
|
|
meta.renderAltitudeM,
|
|
);
|
|
if (groundFlipped) flightState._groundSnap.forget(icao24);
|
|
flightState._cullPositions.set(
|
|
icao24,
|
|
meta.renderAltitudeM < 10
|
|
? Cesium.Cartesian3.fromDegrees(meta.rawLon, meta.rawLat, 12)
|
|
: null,
|
|
);
|
|
const isTracked = icao24 === flightState._trackedIcao;
|
|
|
|
// Append to position history stamped with the FEED's fix epoch.
|
|
// adsb.lol's seen_pos is the AGE in seconds of the last position
|
|
// report, so the fix epoch is receipt time minus that age. Only
|
|
// append when the fix actually advances, so stale repeats don't
|
|
// create zero-dt segments.
|
|
const fixTime = Cesium.JulianDate.fromDate(new Date(fixEpochMs));
|
|
if (!flightState._positionHistory.has(icao24)) {
|
|
flightState._positionHistory.set(icao24, []);
|
|
}
|
|
const history = flightState._positionHistory.get(icao24);
|
|
const newest = history[history.length - 1];
|
|
if (!newest || Cesium.JulianDate.greaterThan(fixTime, newest.time)) {
|
|
// Per-fix kinematics: the fix's own velocity/track ride along so the
|
|
// extrapolation paths use the values that BELONG to the fix they
|
|
// extend, not whatever the latest poll reported.
|
|
history.push({
|
|
time: fixTime,
|
|
epochMs: fixEpochMs,
|
|
position: position.clone(),
|
|
velocity: meta.speedMps,
|
|
track: meta.track,
|
|
// Drawn at an invented height: a trail seeded from history keeps no
|
|
// position for it.
|
|
inventedHeight: meta.renderAltitudeInvented === true,
|
|
});
|
|
if (history.length > POSITION_HISTORY_LIMIT) {
|
|
history.shift();
|
|
}
|
|
// Turn rate from the fix-track history — computed once per new fix
|
|
// (≤5 samples), consumed by the extrapolation paths at tick rate.
|
|
meta.turnRateDps = turnRateFromFixHistory(history);
|
|
// Trail accumulation is separate from the 5-fix DR history (PRD F2)
|
|
// so the visible trail keeps growing while tracked. Round 2
|
|
// (owner): ground traffic appends too — taxi history stays live
|
|
// after touchdown; _appendTrailFix floors grounded positions at
|
|
// the surface so the ground leg drapes instead of diving.
|
|
if (isTracked)
|
|
tracking._appendTrailFix(position.clone(), fixEpochMs, {
|
|
nullAltitude: meta.renderAltitudeInvented === true,
|
|
});
|
|
} else {
|
|
const modelOwnsGroundVisual = rendering._modelOwnsVisual(icao24);
|
|
if (!modelOwnsGroundVisual) {
|
|
liftRepeatedGroundFix(newest, position, meta.onGround);
|
|
}
|
|
// A forward synthetic fix follows the stale rules (none while the
|
|
// contact holds at its report, a coast capped from the real report,
|
|
// never below the ground) and is a motion aid, never a trail report.
|
|
const kinematicsChanged =
|
|
newest.velocity !== meta.speedMps || newest.track !== meta.track;
|
|
const holds = staleHoldsForFix(newest, {
|
|
onGround: meta.onGround,
|
|
cachedGroundFloor,
|
|
});
|
|
if (kinematicsChanged && !holds) {
|
|
const synthetic = synthesizeForwardKinematicsFix(newest, {
|
|
epochMs: Date.now(),
|
|
velocity: meta.speedMps,
|
|
track: meta.track,
|
|
turnRateDps: meta.turnRateDps,
|
|
cachedGroundFloor,
|
|
});
|
|
if (synthetic) {
|
|
history.push(synthetic);
|
|
if (history.length > POSITION_HISTORY_LIMIT) history.shift();
|
|
meta.turnRateDps = turnRateFromFixHistory(history);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (flightState._billboards.has(icao24)) {
|
|
const bb = flightState._billboards.get(icao24);
|
|
if (!isTracked) {
|
|
bb.color = rendering
|
|
._fleetBillboardColor(icao24, meta)
|
|
.withAlpha(cyberSonarBaseAlpha(bb));
|
|
}
|
|
// Position AND rotation are owned by the fleet pass (_fleetTick);
|
|
// course changes land on the next rotation pass (forced below).
|
|
// Ground flips (landing/takeoff) restyle this SAME billboard in
|
|
// place — the transition is never a removal.
|
|
if (
|
|
prevMeta?.klass !== meta.klass ||
|
|
groundFlipped ||
|
|
flightState._cockpitContactMode
|
|
) {
|
|
rendering._applyFleetBillboardPresentation(icao24, bb);
|
|
}
|
|
// Per-class GLBs: a class change can mean a different asset OR scale —
|
|
// resync the live model, any in-flight load, and the tracked
|
|
// standalone (mirror of flights.js).
|
|
if (prevMeta?.klass !== meta.klass) rendering._syncModelToClass(icao24);
|
|
// Round 5: depth policy is uniform (always depth-test-free, see
|
|
// _groundDepthDistance) — nothing to flip on landing/takeoff.
|
|
} else {
|
|
// Start where the fleet pass will draw it: the fleet renders behind
|
|
// real time, so a fresh contact's displayed position is its fix
|
|
// projected back to that delayed time. Creating it at the raw fix drew
|
|
// it ahead until the next fleet tick snapped it back.
|
|
const displayed =
|
|
motion._deadReckon(icao24, new Cesium.Cartesian3()) || position;
|
|
const bb = flightState._billboardCollection.add({
|
|
position: displayed,
|
|
image: aircraftIcon(rendering._iconKind(icao24, meta.klass)),
|
|
width: isTracked ? 24 : 20,
|
|
height: isTracked ? 24 : 20,
|
|
scale:
|
|
BILLBOARD_SCALE *
|
|
(CLASS_SCALE_2D[meta.klass] || 1) *
|
|
(meta.onGround ? GROUND_SCALE : 1),
|
|
// Screen-projected rotation lands on the next fleet tick.
|
|
rotation: 0,
|
|
alignedAxis: Cesium.Cartesian3.ZERO,
|
|
color: isTracked
|
|
? TRACKED_ICON_COLOR
|
|
: rendering._fleetBillboardColor(icao24, meta),
|
|
sizeInMeters: false,
|
|
scaleByDistance: rendering._normalBillboardScaleByDistance(),
|
|
// Grounded/near-surface planes sit at/below the photoreal tile
|
|
// surface — render them depth-test-free so they never vanish up
|
|
// close (_groundDepthDistance).
|
|
disableDepthTestDistance: rendering._groundDepthDistance(),
|
|
id: icao24,
|
|
show: !isTracked, // hidden if currently tracked (entity replaces it)
|
|
});
|
|
flightState._billboards.set(icao24, bb);
|
|
rendering._applyFleetBillboardPresentation(icao24, bb);
|
|
}
|
|
|
|
// Takeoff while TRACKED: ground traffic drew no trail, so start one
|
|
// from the fresh airborne history (touchdown needs no action — the
|
|
// append gate above simply freezes the existing trail).
|
|
if (isTracked && groundFlipped && !meta.onGround)
|
|
tracking._startTrail(icao24);
|
|
|
|
// If this is the tracked aircraft, update label text
|
|
// (position updates automatically via dead-reckoning CallbackProperty)
|
|
if (isTracked && flightState._trackedEntity) {
|
|
tracking._updateTrackedLabelModel(icao24);
|
|
}
|
|
}
|
|
|
|
// Field-test fix (RS46): one batch warm of the low-airborne floor cells
|
|
// collected above — fire-and-forget, single-flight, results read
|
|
// synchronously by NEXT poll's clamp (same contract as flights.js's
|
|
// grounded-surface warm).
|
|
warmGroundFloor(_floorWarmPoints);
|
|
// Round 6: re-floor STALE grounded contacts (mirror of flights.js) —
|
|
// a parked contact whose feed went quiet froze at its pre-warm height.
|
|
// The model-ownership gate matches the live grounded-clamp path (a
|
|
// tileset-snapped model owns its visual; moving its billboard would
|
|
// disturb groundSnap's input — the T7 one-shot invariant).
|
|
for (const [icao24, info] of flightState.records.data) {
|
|
if (!info?.onGround || currentIcaos.has(icao24)) continue;
|
|
if (rendering._modelOwnsVisual(icao24)) continue;
|
|
if (!Number.isFinite(info.rawLat) || !Number.isFinite(info.rawLon))
|
|
continue;
|
|
const floor = cachedGroundFloor(info.rawLat, info.rawLon);
|
|
if (!Number.isFinite(floor)) continue;
|
|
const lifted = floor + GROUND_FLOOR_LIFT_M;
|
|
if (
|
|
Number.isFinite(info.renderAltitudeM) &&
|
|
info.renderAltitudeM >= floor - 1
|
|
)
|
|
continue;
|
|
info.renderAltitudeM = lifted;
|
|
flightState._cullPositions.delete(icao24);
|
|
const liftedPos = Cesium.Cartesian3.fromDegrees(
|
|
info.rawLon,
|
|
info.rawLat,
|
|
lifted,
|
|
);
|
|
const hist = flightState._positionHistory.get(icao24);
|
|
const newest = hist?.[hist.length - 1];
|
|
if (newest)
|
|
newest.position = Cesium.Cartesian3.clone(liftedPos, newest.position);
|
|
const bbStale = flightState._billboards.get(icao24);
|
|
if (bbStale) bbStale.position = liftedPos;
|
|
}
|
|
// Round 4: sample the RENDERED mesh for those cells (a few probes per
|
|
// cell, budget-capped, viewer-proximate, google-3d regime only), excluding
|
|
// this layer's own billboards/models from the probe.
|
|
{
|
|
const viewerCarto =
|
|
flightState._viewer?.camera?.positionCartographic || null;
|
|
sampleMeshFloorCells(flightState._viewer?.scene, _floorWarmPoints, {
|
|
excludeObjects: [
|
|
...flightState._billboards.values(),
|
|
...flightState._models.values(),
|
|
flightState._trackedModel,
|
|
].filter(Boolean),
|
|
viewerLat: viewerCarto
|
|
? Cesium.Math.toDegrees(viewerCarto.latitude)
|
|
: undefined,
|
|
viewerLon: viewerCarto
|
|
? Cesium.Math.toDegrees(viewerCarto.longitude)
|
|
: undefined,
|
|
});
|
|
}
|
|
|
|
// Remove aircraft only after MISSING_POLL_LIMIT consecutive absences.
|
|
// adsb.lol routinely drops aircraft for a single poll; immediate removal
|
|
// made icons blink and yanked the camera off actively tracked flights.
|
|
// EXCEPTION: likely-landed planes (last fix low + slow) get only
|
|
// LANDED_MISSING_POLL_LIMIT — their disappearance means "landed", not a
|
|
// feed gap, and the full grace left phantom planes parked at airports.
|
|
for (const [icao24, bb] of flightState._billboards) {
|
|
if (currentIcaos.has(icao24)) continue;
|
|
const absence = records.absence(icao24, {
|
|
complete: snapshot.complete,
|
|
retainIds: snapshot.retainIds,
|
|
likelyLanded: queries._likelyLanded(icao24),
|
|
tracked: icao24 === flightState._trackedIcao,
|
|
});
|
|
if (absence === 'retain') continue;
|
|
if (absence === 'stale') {
|
|
if (icao24 === flightState._trackedIcao && flightState._trackedEntity) {
|
|
// Honest readout: the tracked plane has no faded billboard (its
|
|
// entity owns the visual), so refresh the label — with icao24 now
|
|
// in _missingPolls, _buildTrackedLabel appends the STALE cue so
|
|
// last-known altitude/speed aren't presented as live.
|
|
tracking._updateTrackedLabelModel(icao24);
|
|
}
|
|
continue;
|
|
}
|
|
|
|
// If the tracked flight is truly gone, clear tracking BEFORE deleting
|
|
// its state (M3 ordering, keep it): teardown reads the maps this loop
|
|
// is about to delete (billboard restore, DR cache reset), and we must
|
|
// never leave the camera mid-follow with stale tracking state. The
|
|
// camera is then RELEASED IN PLACE — it stays where the follow left
|
|
// it, fully free (owner decision 2026-07-02: no overview flyTo).
|
|
if (icao24 === flightState._trackedIcao) {
|
|
tracking._clearTracking(false, { evicted: true });
|
|
}
|
|
|
|
flightState._billboardCollection.remove(bb);
|
|
flightState._billboards.delete(icao24);
|
|
rendering._releaseModel(icao24); // aged-out aircraft: drop its 3D model (no orphan / cap leak)
|
|
records.forget(icao24);
|
|
flightState._cullPositions.delete(icao24);
|
|
flightState._positionHistory.delete(icao24);
|
|
flightState._displayCourse.delete(icao24);
|
|
flightState._groundSnap.forget(icao24);
|
|
}
|
|
|
|
// Fresh courses arrived — force a rotation pass on the next fleet tick
|
|
flightState._lastCamPoseSig = '';
|
|
|
|
// Feed the shared registry so the flights layer can classify/suppress
|
|
registerMilitaryIcaos(currentIcaos);
|
|
|
|
return { count: flightState._billboards.size, ids: currentIcaos };
|
|
};
|
|
}
|