refactor(flights): Cesium rendering behind a renderer interface

Task 10a. The flights logic no longer imports Cesium: every Cesium object it
built moved one for one into the shared aircraft renderer
(src/layers/aircraft/render/cesium.js; contract in render/contract.js), with
the flights' parameters in src/layers/flights/render/cesium.js, registered
for 'cesium' in the renderer registry and created at init(viewer, {engine}).

- Fleet: BillboardCollection + sprite-order slot; sprites stay Billboard
  handles (field vocabulary documented for the Navara renderer).
- Models: fleet/tracked/preload glTF loads (asynchronous:false, MIX tint, IR
  boost as `unlit` → the UNLIT CustomShader), the model collection, setPose
  (same HPR frame with airplane.glb's 180° offset).
- Tracked: the ENU billboard Entity with its position/colour/rotation
  callbacks, viewFrom, followed through viewer.trackedEntity + the one exact
  tracked frame (kept as is; engine.camera.follow on Cesium would also end
  the follow on any camera command, a behaviour change).
- Trail: the entity trail (data/trailRenderer, unchanged: its Primitive
  predecessor failed below the mesh) and the live head segment.
- View: camera/scene reads, frame number, frustum and horizon tests,
  projection, render requests, frame events, evidence render-loop hold.
- Clicks and Escape go through the engine's selection dispatcher (the
  ScreenSpaceEventHandler and keydown listener are gone); the cross-layer
  untrack watches the renderer's follow.
- Colours are engine-neutral Rgba (src/layers/shared/color.js), bit-equal to
  the Cesium.Color constants they replace; NearFarScalar → nearFarScale.
- Cesium math in the logic → src/geo.
- check-import-directions: cesium only in render/cesium*.js and three/Navara
  only in render/navara*.js for flights, aircraft and shared; a layer's
  Navara renderer only through navaraMode's import().

Source-text tests updated with the moved code, same meaning:
- readLayerSource reads a layer's render/*.js and, for the aircraft layers,
  aircraft/render/*.js (GLB-load, tracked-entity, CallbackProperty checks).
- modelScale.test: _normalBillboardScaleByDistance reads nearFarScale(...).
- spriteOrder.test: flights' enable calls fleet.restoreOrderOnEnable(); the
  renderer wires it to restoreSpriteOrderOnEnable('flights', viewer).
- trackingClickGesture.test: the flights gesture rules are the dispatcher's
  (selection gesture before select, click classifier before the empty-space
  clear); flights answers the empty click with a user-origin clear.
- militaryAwareness.test: flights' hasContact guard reads fleet.visible().
- ownership.test: the services fixture names selection and renderer.

New tests: color, the Cesium aircraft renderer (contract, collections, pose,
loads, frustum/horizon, tracked entity, follow, trail head, adopted
collections), the flights logic over a plain-data renderer and a fake engine
(fleet, click-select, no-op on the tracked visual, empty-click release), the
boundary rule.

W1 replay vs 7c7422e2: counts, known objects, screen points (0 px), tracking
poses (0 m), requests and shots (same sha256) identical. Main chunk
2,890,982 B (+6.2 KB, +0.21 %: the renderer indirection).
This commit is contained in:
German Khokhlov committed 2026-10-17 01:04:25 +04:00
1 parent 8e702f0c3b
commit 7f13ef4a87
33 files changed
+1974 -748

No files matched your search

+249
View File
@@ -0,0 +1,249 @@
// The flights logic draws only through its renderer (phase 3 Task 10a): with
// a renderer that is plain data (no Cesium), the layer builds its fleet,
// selects a contact on a click through the engine's selection dispatcher,
// tracks and follows it, and releases it on an empty click. This is the seam
// the Navara renderer (Task 10b) plugs into.
import test from 'node:test';
import assert from 'node:assert/strict';
import * as geo from '../../geo/index.js';
import { createFakeEngine } from '../../globe/testing/fakeEngine.js';
import { createApplicationFlights } from '../../app/layers/flights.js';
import { defaultSurface } from '../../data/surfaceServices.js';
import * as militaryRegistry from '../../data/militaryRegistry.js';
import { openSkySnapshot } from '../../sources/live/aircraft.js';
import { missingAircraftRendererMembers } from '../aircraft/render/contract.js';
import { Rgba } from '../shared/color.js';
globalThis.window ||= {};
globalThis.window.dispatchEvent ||= () => true;
globalThis.window.addEventListener ||= () => {};
globalThis.window.removeEventListener ||= () => {};
globalThis.CustomEvent ||= class CustomEvent extends Event {
constructor(type, init) {
super(type);
this.detail = init?.detail;
}
};
globalThis.document ||= {
body: { classList: { contains: () => false } },
addEventListener() {},
removeEventListener() {},
};
/** A renderer of plain records, for the logic alone. */
function recordingRenderer(engine) {
const calls = [];
const sprites = new Set();
const camera = {
positionWC: geo.cartesian3.fromDegrees(-97.7, 30.2, 400_000),
positionCartographic: geo.cartographic.fromDegrees(-97.7, 30.2, 400_000),
rightWC: geo.cartesian3.create(1, 0, 0),
upWC: geo.cartesian3.create(0, 0, 1),
directionWC: geo.cartesian3.create(0, -1, 0),
heading: 0,
pitch: -Math.PI / 2,
roll: 0,
frustum: { fovy: 1 },
};
const scene = {
camera,
canvas: { clientHeight: 768 },
frameState: { frameNumber: 1 },
};
let trackedSeq = 0;
let following;
const renderer = {
kind: 'record',
engine,
calls,
sprites,
view: {
camera,
scene,
surfaceOwner: engine,
surfaceScene: engine,
frameNumber: () => 1,
viewportHeightPx: () => 768,
frustumTester: () => () => true,
horizon: () => ({ isPointVisible: () => true }),
worldToWindow: () => ({ x: 0, y: 0 }),
requestRender: () => calls.push(['requestRender']),
on: () => () => {},
holdFrames() {},
closeFrameLatch() {},
releaseFrames() {},
},
fleet: {
shown: false,
attach: () => calls.push(['attach']),
detach: () => calls.push(['detach']),
attached: () => true,
visible: () => renderer.fleet.shown,
setVisible(visible) {
renderer.fleet.shown = visible;
},
add(spec) {
const sprite = { ...spec };
sprites.add(sprite);
return sprite;
},
remove: (sprite) => sprites.delete(sprite),
restoreOrder() {},
restoreOrderOnEnable() {},
},
models: {
live: () => true,
setVisible() {},
loadFleet: () => Promise.reject(new Error('no models here')),
loadTracked: () => Promise.reject(new Error('no models here')),
preload: () => Promise.reject(new Error('no models here')),
add() {},
remove() {},
destroy() {},
setPose() {},
},
tracked: {
create(spec) {
const handle = { id: `tracked-${++trackedSeq}`, spec };
calls.push(['tracked.create', handle.id]);
return handle;
},
remove: (handle) => calls.push(['tracked.remove', handle.id]),
isLive: () => true,
setImage() {},
setViewFrom(handle, offset) {
handle.viewFrom = offset;
},
billboardSize: () => null,
},
follow: {
start(handle) {
following = handle;
calls.push(['follow.start', handle.id]);
return () => calls.push(['follow.frameStop']);
},
refocus: (handle) => renderer.follow.start(handle),
release() {
following = undefined;
calls.push(['follow.release']);
},
isFollowing: (handle) => following === handle,
current: () => following,
onChanged: () => () => {},
},
trails: {
create: () => ({
setPositions() {},
setVisible() {},
clear() {},
destroy() {},
}),
createHead: ({ id }) => ({ id, show: true }),
removeHead() {},
},
surfaceExclusions: () => [],
destroy: () => calls.push(['destroy']),
};
return renderer;
}
function snapshotOf(ids) {
const nowSec = Math.floor(Date.now() / 1000);
return openSkySnapshot({
time: nowSec,
states: ids.map((id, index) => [
id,
`TST${index} `,
'United States',
nowSec,
nowSec,
-97.6 + index * 0.1,
30.3,
10_668,
false,
250,
95,
5,
null,
10_700,
null,
null,
null,
5,
]),
});
}
test('the flights logic draws, selects and follows only through its renderer', async () => {
const engine = createFakeEngine();
let renderer = null;
const layer = createApplicationFlights({
surface: defaultSurface,
source: {
label: 'Fixture aircraft',
getSnapshot: async () => snapshotOf(['abc123', 'def456']),
},
militaryRegistry,
renderer: {
create: ({ viewer, engine: given }) => {
assert.equal(viewer, null, 'no viewer on an engine without one');
renderer = recordingRenderer(given);
return renderer;
},
},
});
layer.init(null, { engine });
assert.deepEqual(missingAircraftRendererMembers(renderer), []);
layer.enable();
try {
await layer.update(null);
assert.equal(renderer.sprites.size, 2, 'one sprite per contact');
const [sprite] = renderer.sprites;
assert.ok(sprite.color instanceof Rgba, 'colours are engine-neutral');
assert.equal(sprite.id, 'abc123');
assert.equal(layer.getAllPositions().length, 2);
// A click on a contact: the engine's pick, through the dispatcher.
engine.fake.script('pick', () => ({ id: 'def456' }));
engine.fake.script('drillPick', () => [{ id: 'def456' }]);
const click = () => {
engine.fake.input('down', { position: { x: 10, y: 10 } });
engine.fake.input('up', { position: { x: 10, y: 10 } });
engine.fake.input('click', { position: { x: 10, y: 10 } });
};
click();
assert.equal(layer.getTrackedInfo()?.icao24, 'def456');
assert.deepEqual(
renderer.calls.filter(
([name]) => name.startsWith('tracked') || name.startsWith('follow'),
),
[
['tracked.create', 'tracked-1'],
['follow.start', 'tracked-1'],
],
);
// Clicking the tracked visual itself is a no-op.
engine.fake.script('pick', () => ({ id: 'tracked-1' }));
engine.fake.script('drillPick', () => [{ id: 'tracked-1' }]);
click();
assert.equal(layer.getTrackedInfo()?.icao24, 'def456');
// Empty space releases the follow and removes the tracked visual.
engine.fake.script('pick', () => undefined);
engine.fake.script('drillPick', () => []);
click();
assert.equal(layer.getTrackedInfo(), null);
assert.ok(
renderer.calls.some(([name]) => name === 'follow.release') &&
renderer.calls.some(
([name, id]) => name === 'tracked.remove' && id === 'tracked-1',
),
);
} finally {
layer.disable();
layer.destroy(null);
}
assert.ok(renderer.calls.some(([name]) => name === 'destroy'));
});