import { readLayerSource } from '../testSupport/readLayerSource.mjs'; // src/data/trackedModelForm.test.mjs // // The TRACKED contact's form and size: selecting an aircraft changes its // colour, never its size or form. The tracked model draws exactly when the // fleet's own model rule would draw the contact (3D on, below the ceiling, a // place in the nearest-first cap), at the fleet's scale and minimum pixel // size; otherwise the tracked icon carries it, drawn as its fleet icon is. // Both flight layers are pinned, with cockpit and TR-3B suppression, the // load-failure budget and the grounded snap. import test from 'node:test'; import assert from 'node:assert/strict'; import * as Cesium from 'cesium'; import flightsLayer, { _setTrackedFlightRefreshStateForTest, _trackedModelRegimeActiveForTest as flightsRegimeActive, _updateTrackedModelForTest as flightsDriveTrackedModel, _trackedBillboardColorForTest as flightsTrackedBillboardColor, _driveFleetModelHandoffForTest as flightsDriveFleetModel, _ensureFleetModelForTest as flightsEnsureFleetModel, _trackedModelForTest as flightsTrackedModel, _trackedIconLookForTest as flightsTrackedIconLook, _modelSetIdsForTest as flightsModelSetIds, _iconForTest as flightsIcon, _setIconForTest as flightsSetIcon, } from './flights.js'; import militaryFlightsLayer, { _setTrackedMilitaryRefreshStateForTest, _trackedModelRegimeActiveForTest as militaryRegimeActive, _updateTrackedModelForTest as militaryDriveTrackedModel, _trackedBillboardColorForTest as militaryTrackedBillboardColor, _driveFleetModelHandoffForTest as militaryDriveFleetModel, _ensureFleetModelForTest as militaryEnsureFleetModel, _trackedModelForTest as militaryTrackedModel, _trackedIconLookForTest as militaryTrackedIconLook, _modelSetIdsForTest as militaryModelSetIds, _iconForTest as militaryIcon, _setIconForTest as militarySetIcon, } from './militaryFlights.js'; import { clearTr3bRegistry, setTr3b } from './tr3bRegistry.js'; import { reportMeshFloorCell, _clearMeshFloorCellsForTest, } from './groundFloor.js'; import { bindFakeCesiumCamera } from '../testSupport/fakeCameraPort.mjs'; import { fakeDrawPort } from '../testSupport/fakeDrawPort.mjs'; import { loadFleetModelSet } from './fleetModels.js'; import { aircraftLayerModelSpec } from '../layers/flights/modelSpec.js'; import { fetchPublicFile } from '../testSupport/fleetGlb.mjs'; // The layers draw only once the fleet model set has loaded; load it from disk. const _silentInfo = console.info; console.info = () => {}; await loadFleetModelSet({ fetchImpl: fetchPublicFile }); console.info = _silentInfo; const FLIGHTS_META = Object.freeze({ typeCode: 'A320', klass: 'airliner' }); const MILITARY_META = Object.freeze({ typeCode: 'F16', klass: 'fastjet' }); // --------------------------------------------------------------------------- // Both flight layers // --------------------------------------------------------------------------- const ICAO = 'abc123'; /** `stopTracking()` is the real deselect path, and it announces the clear on * `window`. Give it somewhere to land so the test drives production code * rather than a stand-in. */ if (typeof globalThis.window === 'undefined') { globalThis.window = { dispatchEvent() { return true; }, addEventListener() {}, removeEventListener() {}, }; } /** A viewer stub whose camera altitude the test can move between evaluations. * Its renderer has a fake draw port (`viewer.draw`) the layer's model sets * are made on, a globe whose drawn tiles settle as `viewer.tileset` says, and * a query port whose height samples are `sampleHeight`'s. */ function viewerAtHeight( height, { tilesLoaded = true, sampleHeight = () => undefined, eye } = {}, ) { const tileset = { show: true, tilesLoaded }; const draw = fakeDrawPort(); const viewer = { camera: { positionCartographic: { height }, positionWC: eye ?? Cesium.Cartesian3.fromDegrees(-97.71, 30.21, 5000), frustum: { fovy: Cesium.Math.toRadians(60) }, }, scene: { canvas: { clientHeight: 900 }, frameState: { frameNumber: 1 }, sampleHeight, }, tileset, draw, trackedEntity: undefined, entities: { remove() {} }, }; return bindFakeCesiumCamera(viewer, { draw, globe: { isSettled: (kind) => kind !== 'tiles' || tileset.tilesLoaded }, query: { sampleHeightNow: () => sampleHeight() }, canvas: viewer.scene.canvas, }); } /** The layer's fleet or tracked models set in the viewer's fake draw port. */ function modelSet(fixture, viewer, which) { return viewer.draw.set(fixture.modelSetIds()[which]); } /** Where a model record places its model (its placement's translation). */ function placedAt(record) { return new Cesium.Cartesian3( record.matrix[12], record.matrix[13], record.matrix[14], ); } /** A billboard with a real position, so the tracked-model driver has somewhere * to put a model when it gets one (dead reckoning yields nothing without a * fix history, and the driver falls back to this). */ function contactBillboard() { return { position: Cesium.Cartesian3.fromDegrees(-97.71, 30.21, 10_668), color: null, show: true, rotation: 0, }; } /** A contact's icon row, read and written the way these tests read a * billboard: where it is drawn and whether the layer shows it. */ function iconView(icao24, readIcon, setIcon) { return { get position() { return readIcon(icao24)?.position; }, set position(position) { setIcon(icao24, { position }); }, get show() { return readIcon(icao24)?.shown === true; }, set show(shown) { setIcon(icao24, { shown }); }, }; } const LAYERS = [ { name: 'flights', layer: flightsLayer, regimeActive: flightsRegimeActive, driveTrackedModel: flightsDriveTrackedModel, driveFleetModel: flightsDriveFleetModel, ensureFleetModel: flightsEnsureFleetModel, trackedModel: flightsTrackedModel, modelSetIds: flightsModelSetIds, trackedBillboardColor: flightsTrackedBillboardColor, trackedIconLook: flightsTrackedIconLook, /** How far a grounded A320 stands its origin above the ground (scaled wheel clearance). */ bellyM: aircraftLayerModelSpec(FLIGHTS_META).bellyM, seed({ viewer, tracked = true, icao24 = ICAO, onGround = false, models = [], trackedModelEligible = true, }) { const billboard = contactBillboard(); _setTrackedFlightRefreshStateForTest({ icao24, entity: null, icon: billboard, iconLayer: { show: true, remove() {} }, viewer, tracked, models, draw: viewer.draw, trackedModelEligible, meta: { callsign: 'TEST123 ', altitude: 10_668, ...FLIGHTS_META, onGround, }, }); return iconView(icao24, flightsIcon, flightsSetIcon); }, }, { name: 'militaryFlights', layer: militaryFlightsLayer, regimeActive: militaryRegimeActive, driveTrackedModel: militaryDriveTrackedModel, driveFleetModel: militaryDriveFleetModel, ensureFleetModel: militaryEnsureFleetModel, trackedModel: militaryTrackedModel, modelSetIds: militaryModelSetIds, trackedBillboardColor: militaryTrackedBillboardColor, trackedIconLook: militaryTrackedIconLook, bellyM: aircraftLayerModelSpec(MILITARY_META).bellyM, seed({ viewer, tracked = true, icao24 = ICAO, onGround = false, models = [], trackedModelEligible = true, }) { const billboard = contactBillboard(); _setTrackedMilitaryRefreshStateForTest({ icao24, entity: null, icon: billboard, iconLayer: { show: true, remove() {} }, viewer, tracked, models, draw: viewer.draw, trackedModelEligible, meta: { callsign: 'TEST123 ', altitudeFt: 35_000, ...MILITARY_META, onGround, }, }); return iconView(icao24, militaryIcon, militarySetIcon); }, }, ]; for (const fixture of LAYERS) { test(`${fixture.name}: production fleet admission keeps the model HIDDEN until it is ready and placed`, () => { clearTr3bRegistry(); fixture.layer.stopTracking(); fixture.layer.setParams({ models3d: true }); const viewer = viewerAtHeight(30_000, { tilesLoaded: false }); const position = Cesium.Cartesian3.fromDegrees(-97.71, 30.21, 10_668); try { const loadingIcao = fixture.name === 'flights' ? 'a0f201' : 'b0f201'; const billboard = fixture.seed({ viewer, tracked: false, icao24: loadingIcao, onGround: true, }); const admitted = fixture.ensureFleetModel(loadingIcao); assert.ok(admitted, 'the production fleet admission records a model'); assert.equal(admitted.ready, false, 'nothing has loaded yet'); assert.equal( admitted.show, false, 'admission records the model hidden until it is placed', ); assert.equal( billboard.show, true, 'the 2D billboard owns the cold loading state', ); const nearby = fixture.layer .getNearby(billboard.position, 1_000, 50) .find((object) => object.icao24 === loadingIcao); assert.ok( nearby, 'fleet proximity retains the billboard-owned loading contact', ); assert.ok( Cesium.Cartesian3.equalsEpsilon( nearby.position, billboard.position, 0, 1e-6, ), 'fleet proximity stays at the billboard rather than the unplaced model', ); fixture.driveFleetModel({ icao24: loadingIcao, position, course: 92 }); const fleet = modelSet(fixture, viewer, 'fleet'); const item = fleet.items.get(loadingIcao); assert.ok(item, 'the model set loads the contact from its first write'); assert.equal( item.show, false, 'and draws nothing while there is no safe placement', ); assert.equal(admitted.show, false); assert.equal( billboard.show, true, 'cold terrain preserves the same visible 2D owner', ); // A load that never finishes (a missing or broken GLB) never fires // `ready`, so the billboard stays the visual for as long as it lasts. viewer.draw.ready(fleet.spec.id, 'someone-else'); assert.equal( admitted.ready, false, 'another item loading does not ready this one', ); fixture.driveFleetModel({ icao24: loadingIcao, position, course: 92 }); assert.equal( billboard.show, true, 'an unready model leaves the 2D owner visible', ); assert.ok( fixture.layer .getNearby(billboard.position, 1_000, 50) .some((object) => object.icao24 === loadingIcao), 'an unready model leaves the contact in the billboard proximity cohort', ); viewer.draw.ready(fleet.spec.id, loadingIcao); assert.equal( admitted.ready, true, "the set's ready marks the contact's model loaded", ); } finally { fixture.layer.setParams({ models3d: false }); fixture.layer.stopTracking(); } }); test(`${fixture.name}: a tracked model that fails to load is retried within a per-selection budget`, () => { clearTr3bRegistry(); fixture.layer.stopTracking(); fixture.layer.setParams({ models3d: true }); const realNow = Date.now; const realWarn = console.warn; const warnings = []; let now = 7_000_000; Date.now = () => now; console.warn = (...args) => warnings.push(args.join(' ')); const viewer = viewerAtHeight(30_000); const icao24 = fixture.name === 'flights' ? 'a0f401' : 'b0f401'; try { fixture.seed({ viewer, icao24 }); fixture.driveTrackedModel(); let tracked = modelSet(fixture, viewer, 'tracked'); const fail = () => viewer.draw.loadFailed(tracked.spec.id, icao24, '404'); assert.ok(tracked.items.has(icao24), 'the tracked model loads'); for (let attempt = 1; attempt <= 3; attempt++) { fail(); fixture.driveTrackedModel(); assert.equal( tracked.items.has(icao24), false, `failure ${attempt}: let go`, ); assert.equal(fixture.trackedModel(), null); assert.equal( fixture.trackedBillboardColor()[3], 1, 'the icon carries the contact', ); now += 1499; fixture.driveTrackedModel(); assert.equal( tracked.items.has(icao24), false, 'not before the backoff', ); now += 1; fixture.driveTrackedModel(); assert.equal( tracked.items.has(icao24), attempt < 3, attempt < 3 ? 'loaded again after the backoff' : 'given up after the third failure', ); } assert.equal(warnings.length, 1, 'giving up is said once'); now += 60_000; fixture.driveTrackedModel(); assert.equal(tracked.items.has(icao24), false, 'the selection stays 2D'); // A new selection of the same contact starts with a full budget. fixture.layer.stopTracking(); fixture.seed({ viewer, icao24 }); fixture.driveTrackedModel(); tracked = modelSet(fixture, viewer, 'tracked'); assert.ok(tracked.items.has(icao24), 'reselected, it loads again'); // A failure the renderer recovers from before the driver runs keeps it. const recovered = fixture.trackedModel(); fail(); viewer.draw.ready(tracked.spec.id, icao24); fixture.driveTrackedModel(); assert.equal( fixture.trackedModel(), recovered, 'a model that loaded after all is kept', ); assert.ok(tracked.items.has(icao24)); fixture.layer.stopTracking(); fixture.seed({ viewer, icao24 }); fixture.driveTrackedModel(); tracked = modelSet(fixture, viewer, 'tracked'); // And a good load retires the failures counted so far. fail(); fixture.driveTrackedModel(); now += 1500; fixture.driveTrackedModel(); viewer.draw.ready(tracked.spec.id, icao24); fixture.driveTrackedModel(); assert.equal(fixture.trackedModel()?.ready, true); fail(); fixture.driveTrackedModel(); now += 1500; fixture.driveTrackedModel(); fail(); fixture.driveTrackedModel(); now += 1500; fixture.driveTrackedModel(); assert.ok( tracked.items.has(icao24), 'two failures after a good load are under the budget', ); } finally { Date.now = realNow; console.warn = realWarn; fixture.layer.setParams({ models3d: false }); fixture.layer.stopTracking(); } }); test(`${fixture.name}: the IR boost restyles a drawn model in place, flat white and unlit`, () => { clearTr3bRegistry(); fixture.layer.stopTracking(); fixture.layer.setParams({ models3d: true, irBoost: false }); const viewer = viewerAtHeight(30_000); const position = Cesium.Cartesian3.fromDegrees(-97.71, 30.21, 10_668); const icao24 = fixture.name === 'flights' ? 'a0f301' : 'b0f301'; try { fixture.seed({ viewer, tracked: false, icao24 }); const record = fixture.ensureFleetModel(icao24); const fleet = modelSet(fixture, viewer, 'fleet'); viewer.draw.ready(fleet.spec.id, icao24); fixture.driveFleetModel({ icao24, position, course: 92 }); const normal = fleet.items.get(icao24); assert.equal(normal.shading, 'pbr'); assert.equal(normal.show, true); assert.ok( normal.colorBlend.amount < 1, 'the asset keeps a hint of its own colour', ); fixture.layer.setParams({ irBoost: true }); fixture.driveFleetModel({ icao24, position, course: 92 }); const boosted = fleet.items.get(icao24); assert.notEqual(boosted, normal, 'the boost writes the item again'); assert.equal(boosted.shading, 'unlit'); assert.deepEqual(boosted.tint, [1, 1, 1, 1]); assert.deepEqual(boosted.colorBlend, { mode: 'mix', amount: 1 }); assert.equal( fixture.ensureFleetModel(icao24), record, 'the same model restyles; nothing reloads', ); assert.equal(boosted.url, normal.url); } finally { fixture.layer.setParams({ models3d: false, irBoost: false }); fixture.layer.stopTracking(); } }); test(`${fixture.name}: grounded fleet handoff waits through terrain load and keeps one visual owner`, () => { clearTr3bRegistry(); fixture.layer.stopTracking(); const realNow = Date.now; let now = 4_000_000; Date.now = () => now; let sampleCalls = 0; const sampledHeight = 187.5; const viewer = viewerAtHeight(30_000, { tilesLoaded: false, sampleHeight: () => { sampleCalls++; return sampledHeight; }, }); const icao24 = fixture.name === 'flights' ? 'a0f101' : 'b0f101'; const model = { modelMatrix: Cesium.Matrix4.clone(Cesium.Matrix4.IDENTITY), ready: true, show: true, }; const position = Cesium.Cartesian3.fromDegrees(-97.71, 30.21, 10_668); try { const billboard = fixture.seed({ viewer, tracked: false, icao24, onGround: true, models: [[icao24, model]], }); billboard.show = false; let ownsVisual = fixture.driveFleetModel({ icao24, position, course: 92, }); assert.equal( ownsVisual, false, 'cold terrain cannot transfer ownership to 3D', ); assert.equal( model.show, false, 'the ready primitive is hidden until ground resolves', ); assert.equal( billboard.show, true, 'the 2D contact returns in the same handoff turn', ); assert.ok( model.show || billboard.show, 'the contact never has both visuals hidden', ); assert.equal(sampleCalls, 0, 'cold tiles do not force sampleHeight'); now += 1000; viewer.tileset.tilesLoaded = true; ownsVisual = fixture.driveFleetModel({ icao24, position, course: 92 }); assert.equal( ownsVisual, false, 'the miss backoff remains in force before two seconds', ); assert.equal( sampleCalls, 0, 'backoff prevents an early synchronous sample', ); assert.ok( model.show || billboard.show, 'backoff still leaves a visible owner', ); now += 1500; ownsVisual = fixture.driveFleetModel({ icao24, position, course: 92 }); assert.equal( ownsVisual, true, 'the model takes over after a valid terrain sample', ); assert.equal( sampleCalls, 1, 'the settled terrain is sampled exactly once', ); assert.equal(model.show, true); assert.equal(billboard.show, false); assert.ok( model.show || billboard.show, 'successful handoff keeps a visible owner', ); const placed = placedAt(model); const placedHeight = Cesium.Cartographic.fromCartesian(placed).height; assert.ok( Math.abs(placedHeight - (sampledHeight + fixture.bellyM)) < 0.001, `placement uses the exact ${fixture.bellyM} m asset-measured belly offset`, ); viewer.tileset.tilesLoaded = false; const datumShifted = Cesium.Cartesian3.fromDegrees(-97.71, 30.21, -500); ownsVisual = fixture.driveFleetModel({ icao24, position: datumShifted, course: 92, }); assert.equal( ownsVisual, true, 'a poll-time vertical datum change does not invalidate a stationary snap', ); assert.equal( sampleCalls, 1, 'the height-normalized cache does not resample vertically', ); assert.ok( model.show || billboard.show, 'datum transition keeps a visible owner', ); // Taxi past the 50 m resample threshold while the tiles are gone. The old // snap stops being the direct answer, but it is still a MEASUREMENT of // ground this contact was standing on ~96 m ago, so it is held: hiding the // model here would pop a taxiing aircraft from 3D to 2D for a whole retry // backoff (2–30 s), which is the one thing the gate must not introduce. const taxied = Cesium.Cartesian3.fromDegrees(-97.709, 30.21, -500); ownsVisual = fixture.driveFleetModel({ icao24, position: taxied, course: 92, }); assert.equal( ownsVisual, true, 'a taxi-invalidated snap is HELD through the resample outage, not dropped', ); assert.equal( model.show, true, 'no 3D→2D pop while the resample is backing off', ); assert.equal(billboard.show, false); assert.equal( sampleCalls, 1, 'and the hold costs no extra synchronous sample', ); const held = placedAt(model); assert.ok( Math.abs( Cesium.Cartographic.fromCartesian(held).height - (sampledHeight + fixture.bellyM), ) < 0.001, 'the hold places the model on the last MEASURED floor, not on the feed altitude', ); // Past the drift bound the memory stops describing anywhere this contact // has been, so it is dropped rather than stretched and the gate takes over. const farTaxied = Cesium.Cartesian3.fromDegrees(-97.707, 30.21, -500); // ~289 m out ownsVisual = fixture.driveFleetModel({ icao24, position: farTaxied, course: 92, }); assert.equal( ownsVisual, false, 'past HELD_SNAP_MAX_DRIFT_M the hold is released and the model is withheld', ); assert.equal(model.show, false); assert.equal(billboard.show, true); assert.ok( model.show || billboard.show, 'release returns atomically to 2D', ); const failedIcao = fixture.name === 'flights' ? 'a0f102' : 'b0f102'; const failedBillboard = fixture.seed({ viewer, tracked: false, icao24: failedIcao, onGround: true, models: [], }); failedBillboard.show = false; ownsVisual = fixture.driveFleetModel({ icao24: failedIcao, position, course: 92, }); assert.equal( ownsVisual, false, 'a missing/failed model never claims ownership', ); assert.equal( failedBillboard.show, true, 'load failure keeps the billboard visible', ); } finally { Date.now = realNow; fixture.layer.stopTracking(); } }); test(`${fixture.name}: a held snap is dropped when measured ground contradicts it`, () => { // Adversarial review 2026-08-23, reproduced verbatim. The drift bound asks // "how far has the contact travelled", which is only a PROXY for "does this // value still describe the ground here" — and 202 m of taxi onto a surface // 30 m higher fits inside it. Because a miss PRESERVES the hold, nothing in // the retry path corrects that: the model stays buried for as long as the // resample keeps missing, which on the OSM fallback is forever. // // A at 120 m → taxi 202 m to B, whose measured skin is 150 m → resample // misses. The held 120 m must NOT be used to place a model at B. clearTr3bRegistry(); fixture.layer.stopTracking(); fixture.layer.setParams({ models3d: false }); _clearMeshFloorCellsForTest(); const realNow = Date.now; let now = 5_000_000; Date.now = () => now; let sampleCalls = 0; let sampled = 120; const viewer = viewerAtHeight(30_000, { tilesLoaded: true, sampleHeight: () => { sampleCalls++; return sampled; }, }); const icao24 = fixture.name === 'flights' ? 'a0f103' : 'b0f103'; const model = { modelMatrix: Cesium.Matrix4.clone(Cesium.Matrix4.IDENTITY), ready: true, show: true, }; /** Height (m) the model's matrix currently places it at. */ const placedHeightM = () => Cesium.Cartographic.fromCartesian(placedAt(model)).height; const LAT = 30.21; const A_LON = -97.71; // ~202 m east at this latitude: past MOVE_INVALIDATE_M (50 m) so the snap is // demoted, and INSIDE HELD_SNAP_MAX_DRIFT_M (250 m) so the bound alone does // not catch it — that is the whole point of the repro. const B_LON = -97.7079; const B_GROUND_M = 150; try { const billboard = fixture.seed({ viewer, tracked: false, icao24, onGround: true, models: [[icao24, model]], }); billboard.show = false; const atA = Cesium.Cartesian3.fromDegrees(A_LON, LAT, 0); const atB = Cesium.Cartesian3.fromDegrees(B_LON, LAT, 0); const taxiM = Cesium.Cartesian3.distance( Cesium.Ellipsoid.WGS84.scaleToGeodeticSurface( atA, new Cesium.Cartesian3(), ), Cesium.Ellipsoid.WGS84.scaleToGeodeticSurface( atB, new Cesium.Cartesian3(), ), ); assert.ok( taxiM > 50 && taxiM < 250, `the repro must sit INSIDE the drift bound to be a repro (taxi ${taxiM.toFixed(1)} m)`, ); // A: the snap resolves and the model takes the visual. let ownsVisual = fixture.driveFleetModel({ icao24, position: atA, course: 92, }); assert.equal( ownsVisual, true, 'a measured snap at A hands the visual to the model', ); assert.equal(sampleCalls, 1); assert.ok( Math.abs(placedHeightM() - (sampled + fixture.bellyM)) < 0.001, 'the model stands on the measured 120 m at A', ); // Something measures B's surface — the mesh-floor cells the billboard // chain and meshFloorSampler share. This is the fresh evidence. reportMeshFloorCell(LAT, B_LON, B_GROUND_M); // B, with the resample missing: tiles gone, so no sample can land. viewer.tileset.tilesLoaded = false; now += 60_000; ownsVisual = fixture.driveFleetModel({ icao24, position: atB, course: 92, }); assert.equal(sampleCalls, 1, 'the missing resample fires no new sample'); assert.equal( ownsVisual, false, 'a held measurement contradicted by measured ground must not place the model', ); assert.equal(model.show, false, 'nothing is drawn 30 m under the apron'); assert.equal( billboard.show, true, 'the floored 2D billboard is the honest fallback', ); assert.ok( model.show || billboard.show, 'the release is atomic — never both hidden', ); // "If the contact remains at B, misses can preserve that burial forever." // They cannot: the hold is gone, so every later miss re-answers COLD. for (let i = 0; i < 5; i++) { now += 60_000; assert.equal( fixture.driveFleetModel({ icao24, position: atB, course: 92 }), false, 'repeated misses must not resurrect the dropped hold', ); assert.equal(model.show, false); } // And when evidence does arrive, it is B's ground the model stands on. sampled = B_GROUND_M; viewer.tileset.tilesLoaded = true; now += 60_000; ownsVisual = fixture.driveFleetModel({ icao24, position: atB, course: 92, }); assert.equal(ownsVisual, true, 'a fresh sample at B restores the model'); assert.equal(sampleCalls, 2); assert.ok( Math.abs(placedHeightM() - (B_GROUND_M + fixture.bellyM)) < 0.001, "the restored model stands on B's 150 m, not on the stale 120 m", ); // The rule is ONE-SIDED, and this is the half that keeps it useful. Roll // on to C, where the measured cell reads BELOW the held value, and let the // resample miss again. A cell under a real sample is the floor chain's // expected error — cells latch once over ~111 m, borrowed neighbours lean // lowest, the display clamp only ever raises — so it is not evidence of // burial and must NOT cost the contact its model. A two-sided rule fails // here, and did: on the track-regression rig a planted cell sat 66.7 m // below a real sample at the same spot. const C_LON = -97.7064; // ~144 m further on, still inside the drift bound const atC = Cesium.Cartesian3.fromDegrees(C_LON, LAT, 0); const rollM = Cesium.Cartesian3.distance( Cesium.Ellipsoid.WGS84.scaleToGeodeticSurface( atB, new Cesium.Cartesian3(), ), Cesium.Ellipsoid.WGS84.scaleToGeodeticSurface( atC, new Cesium.Cartesian3(), ), ); assert.ok( rollM > 50 && rollM < 250, `the downhill leg must also sit inside the bound (roll ${rollM.toFixed(1)} m)`, ); reportMeshFloorCell(LAT, C_LON, B_GROUND_M - 50); // measured LOWER than the hold viewer.tileset.tilesLoaded = false; now += 60_000; ownsVisual = fixture.driveFleetModel({ icao24, position: atC, course: 92, }); assert.equal( ownsVisual, true, 'a cell reading BELOW the hold is the floor chain under-reading, not burial — the hold stands', ); assert.equal( model.show, true, 'the contact keeps its model through a downhill taxi', ); assert.ok( Math.abs(placedHeightM() - (B_GROUND_M + fixture.bellyM)) < 0.001, 'and it keeps standing on the measurement it actually has', ); } finally { Date.now = realNow; fixture.layer.stopTracking(); _clearMeshFloorCellsForTest(); } }); test(`${fixture.name}: grounded tracked model waits for a valid terrain snap with no visual gap`, () => { clearTr3bRegistry(); fixture.layer.stopTracking(); fixture.layer.setParams({ models3d: true }); const realNow = Date.now; let now = 3_000_000; Date.now = () => now; let sampleCalls = 0; let sampledHeight = undefined; const viewer = viewerAtHeight(30_000, { tilesLoaded: false, sampleHeight: () => { sampleCalls++; return sampledHeight; }, }); const icao24 = fixture.name === 'flights' ? 'a0f001' : 'b0f001'; try { const billboard = fixture.seed({ viewer, onGround: true, icao24, }); fixture.driveTrackedModel(); const model = fixture.trackedModel(); const tracked = modelSet(fixture, viewer, 'tracked'); assert.ok(model, 'the driver records the tracked model'); assert.deepEqual( [...tracked.items.keys()], [icao24], 'the tracked set loads the one model for the contact', ); assert.equal(model.ready, false, 'the model is still loading'); assert.equal( model.show, false, 'the loading model is drawn hidden, not zero-scaled', ); assert.equal(tracked.items.get(icao24).show, false); const baseScale = model.scale; assert.equal( fixture.trackedBillboardColor()[3], 1, 'the tracked billboard remains opaque while the model lacks safe placement', ); assert.equal( sampleCalls, 0, 'cold tiles do not force a synchronous sample', ); const loadingDetection = fixture.layer .getDetectableObjects({ maxCount: 50 }) .find( (object) => object.sourceId === (fixture.name === 'flights' ? 'a0f001' : 'b0f001'), ); assert.ok( loadingDetection, 'the tracked billboard remains detectable while its model loads', ); assert.ok( Cesium.Cartesian3.equalsEpsilon( loadingDetection.position, billboard.position, 0, 1e-6, ), 'a hidden tracked model cannot steal the detection anchor', ); billboard.show = false; // tracking hides the fleet sprite; the tracked entity remains the 2D owner const loadingNearby = fixture.layer .getNearby(billboard.position, 1_000, 50) .find( (object) => object.icao24 === (fixture.name === 'flights' ? 'a0f001' : 'b0f001'), ); assert.ok( loadingNearby, 'the tracked contact remains in proximity while its model loads', ); assert.ok( Cesium.Cartesian3.equalsEpsilon( loadingNearby.position, billboard.position, 0, 1e-6, ), 'a hidden tracked model cannot steal the proximity position', ); now += 1000; viewer.tileset.tilesLoaded = true; sampledHeight = 187.5; fixture.driveTrackedModel(); assert.equal( sampleCalls, 0, 'the tracked path honors the same retry backoff before sampling', ); assert.equal( model.show, false, 'retry backoff keeps the unplaced primitive hidden', ); assert.equal( fixture.trackedBillboardColor()[3], 1, 'retry backoff leaves the tracked billboard opaque', ); now += 1500; fixture.driveTrackedModel(); assert.equal(sampleCalls, 1, 'the first settled turn samples once'); assert.equal( model.show, false, 'terrain alone does not reveal an unready model', ); assert.equal( fixture.trackedBillboardColor()[3], 1, 'the billboard retains ownership until GPU readiness too', ); assert.equal( model.scale, baseScale, 'its scale is left to the pixel-cap driver', ); viewer.draw.ready(tracked.spec.id, icao24); fixture.driveTrackedModel(); assert.equal( model.show, true, 'the model appears only after its snapped matrix is written', ); assert.equal(tracked.items.get(icao24).show, true); assert.equal( fixture.trackedBillboardColor()[3], 0, 'the billboard becomes transparent only when the model actually owns the visual', ); const placed = placedAt(model); const placedHeight = Cesium.Cartographic.fromCartesian(placed).height; assert.ok( Math.abs(placedHeight - (sampledHeight + fixture.bellyM)) < 0.001, `tracked placement uses the exact ${fixture.bellyM} m asset-measured belly offset`, ); viewer.tileset.tilesLoaded = false; sampledHeight = undefined; billboard.position = Cesium.Cartesian3.fromDegrees(-97.71, 30.21, -500); fixture.driveTrackedModel(); assert.equal( model.show, true, 'a successful cached snap survives a poll-time vertical datum change', ); assert.equal( sampleCalls, 1, 'a stationary vertical-only change does not consume another terrain sample', ); // Taxi past the resample threshold with the tiles gone: the tracked model // holds its last measured floor rather than handing the operator's own // selection back to a 2D glyph for a retry backoff. billboard.position = Cesium.Cartesian3.fromDegrees(-97.709, 30.21, -500); fixture.driveTrackedModel(); assert.equal( model.show, true, 'a taxi-invalidated tracked snap is HELD through the resample outage', ); assert.equal( fixture.trackedBillboardColor()[3], 0, 'the model still owns the visual, so the billboard stays transparent', ); assert.equal( sampleCalls, 1, 'the hold costs no extra synchronous sample', ); // Past the drift bound the memory is released and the gate takes over. billboard.position = Cesium.Cartesian3.fromDegrees(-97.707, 30.21, -500); fixture.driveTrackedModel(); assert.equal( model.show, false, 'past HELD_SNAP_MAX_DRIFT_M the hold is released and the model is withheld', ); assert.equal( fixture.trackedBillboardColor()[3], 1, 'there is no invisible-owner gap while the replacement snap is unavailable', ); } finally { Date.now = realNow; fixture.layer.stopTracking(); } }); test(`${fixture.name}: the tracked contact draws as a model exactly when the fleet would`, () => { clearTr3bRegistry(); try { fixture.layer.setParams({ models3d: true }); const viewer = viewerAtHeight(30_000); fixture.seed({ viewer, trackedModelEligible: true }); assert.equal( fixture.regimeActive(), true, 'a place in the fleet cap: a model', ); fixture.seed({ viewer, trackedModelEligible: false }); assert.equal( fixture.regimeActive(), false, 'no place in the fleet cap: its icon, however close the camera', ); // The fleet's own regime: 3D on and the camera below the ceiling. fixture.seed({ viewer: viewerAtHeight(900_000), trackedModelEligible: true, }); assert.equal( fixture.regimeActive(), false, 'above the fleet ceiling: its icon', ); fixture.layer.setParams({ models3d: false }); fixture.seed({ viewer, trackedModelEligible: true }); assert.equal( fixture.regimeActive(), false, 'with 3D off the fleet draws icons, and so does the selected contact', ); } finally { fixture.layer.setParams({ models3d: false }); fixture.layer.stopTracking(); } }); test(`${fixture.name}: selecting a contact keeps the form its fleet visual had`, () => { clearTr3bRegistry(); try { fixture.layer.setParams({ models3d: true }); const viewer = viewerAtHeight(30_000); // A contact the fleet drew as a model stays a model... fixture.seed({ viewer, models: [[ICAO, { ready: true }]], trackedModelEligible: null, }); assert.equal( fixture.regimeActive(), true, 'a fleet model: the tracked model', ); // ...and one it drew as an icon stays an icon. fixture.layer.stopTracking(); fixture.seed({ viewer, models: [], trackedModelEligible: null }); assert.equal( fixture.regimeActive(), false, 'a fleet icon: the tracked icon', ); } finally { fixture.layer.setParams({ models3d: false }); fixture.layer.stopTracking(); } }); test(`${fixture.name}: the fleet model keeps drawing the selected contact until its tracked model draws`, () => { clearTr3bRegistry(); try { fixture.layer.setParams({ models3d: true }); const viewer = viewerAtHeight(30_000); const position = Cesium.Cartesian3.fromDegrees(-97.71, 30.21, 10_668); fixture.seed({ viewer, models: [ [ ICAO, { ready: true, show: true, modelMatrix: Cesium.Matrix4.fromTranslation(position), }, ], ], trackedModelEligible: null, }); fixture.driveTrackedModel(); const tracked = fixture.trackedModel(); assert.ok(tracked, 'the tracked model loads'); assert.equal(tracked.ready, false); assert.ok( fixture.ensureFleetModel(ICAO), 'the fleet model is kept while it loads', ); assert.equal( fixture.trackedBillboardColor()[3], 0, 'and it is the visual: the tracked icon stays clear, no icon flash', ); viewer.draw.ready(modelSet(fixture, viewer, 'tracked').spec.id, ICAO); fixture.driveTrackedModel(); assert.equal( fixture.ensureFleetModel(ICAO), null, 'once the tracked model draws, the fleet model lets go', ); assert.equal( fixture.trackedBillboardColor()[3], 0, 'the tracked model is the visual', ); } finally { fixture.layer.setParams({ models3d: false }); fixture.layer.stopTracking(); } }); test(`${fixture.name}: the tracked model draws at the fleet's scale and minimum pixel size, even up close`, () => { clearTr3bRegistry(); try { fixture.layer.setParams({ models3d: true }); const position = Cesium.Cartesian3.fromDegrees(-97.71, 30.21, 10_668); // The eye 120 m off the aircraft: the old tracked pixel cap shrank it here. const viewer = viewerAtHeight(30_000, { eye: Cesium.Cartesian3.fromDegrees(-97.71, 30.211, 10_668), }); const icao24 = fixture.name === 'flights' ? 'a0f501' : 'b0f501'; // The fleet's model of the contact, unselected. fixture.seed({ viewer, tracked: false, icao24 }); const fleetRecord = fixture.ensureFleetModel(icao24); fixture.driveFleetModel({ icao24, position }); const fleetSet = modelSet(fixture, viewer, 'fleet'); viewer.draw.ready(fleetSet.spec.id, icao24); fixture.driveFleetModel({ icao24, position }); const fleetItem = fleetSet.items.get(icao24); assert.ok(fleetRecord && fleetItem); // The same contact selected. fixture.seed({ viewer, icao24 }); fixture.driveTrackedModel(); const trackedSet = modelSet(fixture, viewer, 'tracked'); viewer.draw.ready(trackedSet.spec.id, icao24); fixture.driveTrackedModel(); const trackedItem = trackedSet.items.get(icao24); assert.equal(fixture.trackedModel().ready, true); assert.equal(trackedItem.show, true); assert.equal(trackedItem.url, fleetItem.url, 'the same model'); assert.equal(trackedItem.scale, fleetItem.scale, 'the same scale'); assert.equal( trackedItem.minPixelSize, fleetItem.minPixelSize, 'the same minimum pixel size', ); assert.notDeepEqual( trackedItem.tint, fleetItem.tint, 'only the colour differs', ); } finally { fixture.layer.setParams({ models3d: false }); fixture.layer.stopTracking(); } }); test(`${fixture.name}: the tracked icon is drawn as its fleet icon is`, () => { clearTr3bRegistry(); try { const viewer = viewerAtHeight(30_000); fixture.seed({ viewer }); const { tracked, fleet } = fixture.trackedIconLook(ICAO); assert.equal(tracked.image, fleet.image, 'the same glyph'); assert.deepEqual( tracked.imageLod, fleet.imageLod, 'the same close-up glyph', ); assert.deepEqual( [tracked.sprite.width, tracked.sprite.height], fleet.size, 'the same size', ); assert.equal(tracked.sprite.scale, fleet.scale, 'the same scale'); assert.deepEqual( tracked.sprite.scaleByDistance, fleet.scaleByDistance, 'the same scale by distance', ); // A landing changes the fleet icon's scale, and the tracked one's with it. fixture.seed({ viewer, onGround: true }); const grounded = fixture.trackedIconLook(ICAO); assert.notEqual(grounded.fleet.scale, fleet.scale); assert.equal(grounded.tracked.sprite.scale, grounded.fleet.scale); } finally { fixture.layer.stopTracking(); } }); test(`${fixture.name}: a converted TR-3B never takes the model`, () => { clearTr3bRegistry(); try { fixture.layer.setParams({ models3d: true }); const viewer = viewerAtHeight(1); // as zoomed in as it gets fixture.seed({ viewer }); assert.equal( fixture.regimeActive(), true, 'control: an unconverted contact does model', ); setTr3b(ICAO, true); fixture.seed({ viewer }); assert.equal( fixture.regimeActive(), false, 'there is no TR-3B GLB — the triangle billboard stays the visual all the way in', ); setTr3b(ICAO, false); fixture.seed({ viewer }); assert.equal( fixture.regimeActive(), true, 'un-converting restores the handoff', ); } finally { clearTr3bRegistry(); fixture.layer.setParams({ models3d: false }); fixture.layer.stopTracking(); } }); test(`${fixture.name}: deselecting drops the tracked model`, () => { clearTr3bRegistry(); try { fixture.layer.setParams({ models3d: true }); const viewer = viewerAtHeight(1); fixture.seed({ viewer }); assert.equal(fixture.regimeActive(), true); fixture.seed({ viewer, tracked: false }); // nothing selected assert.equal( fixture.regimeActive(), false, 'with no selection there is no tracked model to own the visual', ); } finally { fixture.layer.setParams({ models3d: false }); fixture.layer.stopTracking(); } }); } test('both layers reset the per-selection tracked-model state', async () => { for (const name of ['flights.js', 'militaryFlights.js']) { const source = readLayerSource(new URL(`./${name}`, import.meta.url)); // The reset must be reachable from the real teardown, not only a test seam. assert.match( source, /(?:parts\.\w+\.)?_releaseTrackedModel\(\s*,?\s*\);\n\s*(?:parts\.\w+\.)?_resetTrackedSelectionState\(\s*,?\s*\);/, `${name}: deselect clears the per-selection state in the production path`, ); assert.match( source, /(?:(?:flightState|state)\.)?_trackedIcao\s*=\s*icao24;\n\s*(?:parts\.\w+\.)?_resetTrackedSelectionState\(\s*,?\s*\);/, `${name}: selecting a contact starts from a clean per-selection state`, ); } }); test('the tracked model follows the fleet model rule, and the fleet the 3D toggle', async () => { for (const name of ['flights.js', 'militaryFlights.js']) { const source = readLayerSource(new URL(`./${name}`, import.meta.url)); const regime = /^([ \t]*)function _trackedModelRegimeActive\b[\s\S]*?\n\1\}/m.exec( source, )?.[0]; assert.ok(regime, `${name}: _trackedModelRegimeActive is defined`); assert.match( regime, /_trackedModelEligible === true/, `${name}: the tracked contact takes its place in the fleet cap`, ); assert.match( regime, /(?:parts\.\w+\.)?_modelRegimeActive\(\s*\)/, `${name}: and the fleet's regime`, ); const fleet = /^([ \t]*)function _modelRegimeActive\b[\s\S]*?\n\1\}/m.exec( source, )?.[0]; assert.match( fleet, /if\s*\(\s*!(?:(?:flightState|state)\.)?_models3dEnabled,?\s*\)\s*return\s*false;/, `${name}: the fleet regime still obeys the DISPLAY-rail 3D toggle`, ); } });