Files
gods-eye-view/src/layers/transit/rendering.js
T
Sameh Khamis c073064507 Stack sprite layers by draw order, flights on top
Each sprite layer's icon or dot set is now made at a draw order taken
from SPRITE_LAYER_ORDER through the renderer's per-set drawOrder:
flights over military, vessels, directions, transit, bikeshare, FIRMS
and CCTV, whichever layer was turned on first. Picks name the topmost
first. The orders are negative, so selection highlights, route
endpoints, the tracked plane and every other set at the default order
still draw over all sprite layers, as they did before.

The raise-to-top restorer, the sprite registry and the primitive-name
lookups are gone, which takes spriteOrder.js off the viewer-access list.
Before, the restorer raised the layers to the bottom of the scene in the
order they were enabled, so flights usually ended up under the others.
2026-11-09 14:32:50 -08:00

1150 lines
37 KiB
JavaScript

import {
canvasOf,
drawOf,
findCamera,
findFrame,
findGlobe,
findQuery,
} from '../../render/rendererOf.js';
import { poseSignature } from '../../render/camera/poseSignature.js';
import { heightsOf } from '../../queries/heights.js';
import { fromDegreesInto } from '../../geo/ellipsoid.js';
import { frustumPlanes } from '../../geo/frustum.js';
import { perspectiveCourseRotation } from '../../data/screenRotation.js';
import {
updatePlayback,
applyDisplayCourse,
syncPlayback,
} from './movement.js';
import {
SELECTED_ICON_PX,
haloFrame,
transitIcon,
} from '../../data/transitIcons.js';
import {
presetSpriteOutlinePx,
presetSpriteRgba,
presetSpriteScale,
transitStyleProfile,
} from '../../data/transitPresetStyle.js';
import {
CAMERA_PERCENTAGE_CHANGED,
MARKER_PIXEL_SIZE,
ROTATION_REFRESH_MS,
VISIBILITY_REFRESH_MS,
SELECTED_PIXEL_SIZE,
TRANSIT_MODE_COLORS,
vehicleNearView,
} from './policy.js';
/** Layers built so far, so each one's draw sets have ids of their own. */
let instances = 0;
/** Radius, metres, of the sphere a vehicle is culled by. */
const CULL_RADIUS_M = 5;
/**
* Markers and the per-frame glide.
*
* Each vehicle's marker is a plain record (`entry.marker`: its position,
* whether it shows, its image, size, colour and screen rotation) drawn as
* an icon in one of two draw sets: the still one, or the moving one while
* it glides or turns, so a fleet at rest is not rewritten with the few
* that move. Changed markers are pushed to their sets once per frame (and
* once per visibility sweep), each with the one item object it keeps:
* a frame pass over a moving fleet allocates nothing per vehicle.
* @param {object} context
* @returns {object}
*/
export function createRendering({ state, services, parts }) {
const {
governorRequestRender,
holdContinuousRender,
releaseContinuousRender,
} = services.render;
// The application's rendered-mesh sampler. Optional so a layer built on a
// bare floor stub still runs; the application always supplies it.
const sampleMeshFloorCells = services.mesh?.sampleMeshFloorCells || null;
const instance = (instances += 1);
/** Markers changed since they were last pushed to their sets. */
const dirty = new Set();
// Kept between pushes, so a push allocates no lists.
const stillUpserts = [];
const movingUpserts = [];
const stillRemovals = [];
const movingRemovals = [];
/**
* The two icon sets, still and moving, hidden, in the scene now (with no
* items), each at its place in the shared sprite order. A viewer of the
* layer's own draws through `./render/cesium/unbound`, which its owner loads.
* @param {object} viewer
*/
function createMarkers(viewer) {
destroyMarkers(viewer);
const draw = drawOf(viewer);
const drawOrder = (layerId) =>
services.sprites?.spriteDrawOrder?.(layerId) ?? 0;
state._stillIcons = draw.icons({
id: `transit:${instance}:still`,
blend: 'translucent',
show: false,
drawOrder: drawOrder('transit'),
});
state._movingIcons = draw.icons({
id: `transit:${instance}:moving`,
blend: 'translucent',
show: false,
drawOrder: drawOrder('transit-motion'),
});
// Emptied, they are drawn now: in the scene at once.
state._stillIcons.set([]);
state._movingIcons.set([]);
state._markersShown = false;
}
/** Show both sets. */
function showMarkers() {
if (!state._stillIcons) return;
state._stillIcons.show = true;
state._movingIcons.show = true;
state._markersShown = true;
}
/** Drop every marker and hide both sets. */
function clearMarkers() {
dirty.clear();
stillRemovals.length = 0;
movingRemovals.length = 0;
state._stillIcons?.clear();
state._movingIcons?.clear();
if (state._movingIcons) state._movingIcons.show = false;
if (state._stillIcons) state._stillIcons.show = false;
state._markersShown = false;
}
/**
* Let both sets go.
* @param {object|null|undefined} _viewer
*/
function destroyMarkers(_viewer) {
dirty.clear();
stillRemovals.length = 0;
movingRemovals.length = 0;
if (state._stillIcons) {
state._stillIcons.dispose();
state._stillIcons = null;
}
if (state._movingIcons) {
state._movingIcons.dispose();
state._movingIcons = null;
}
state._markersShown = false;
}
/** The ids of both sets (for the frame probe and floor sampling). */
function setIds() {
return [state._stillIcons?.id, state._movingIcons?.id].filter(Boolean);
}
/** Whether `setId` is one of this layer's sets. */
function ownsSet(setId) {
return (
typeof setId === 'string' &&
(setId === state._stillIcons?.id || setId === state._movingIcons?.id)
);
}
/** Which of the sets a draw set id is: `'moving'`, `'still'` or null. */
function setNameOf(setId) {
if (setId && setId === state._movingIcons?.id) return 'moving';
if (setId && setId === state._stillIcons?.id) return 'still';
return null;
}
/** Whether a vehicle's marker is shown. */
function markerShown(entry) {
return entry.marker?.show === true;
}
/** Note that a marker changed, for the next push. */
function markDirty(entry) {
if (entry.marker) dirty.add(entry);
}
/** Show or hide a marker. */
function setShown(entry, shown) {
if (entry.marker.show === shown) return;
entry.marker.show = shown;
dirty.add(entry);
}
/**
* The icon item a marker draws as: the one item object the vehicle
* keeps, brought up to date. Its position is the marker's own, which the
* frame pass moves in place; the renderer reads positions as they are
* when pushed.
*/
function itemOf(entry) {
const marker = entry.marker;
const item = (entry.iconItem ||= {
id: entry.key,
pos: marker.position,
image: marker.image,
size: [0, 0],
color: marker.color,
rotationMode: 'screen',
rotation: 0,
show: false,
disableDepthTest: Infinity,
meta: { layer: 'transit', key: entry.key },
});
item.pos = marker.position;
item.image = marker.image;
item.size[0] = marker.width;
item.size[1] = marker.height;
item.color = marker.color;
item.rotation = marker.rotation;
item.show = marker.show;
return item;
}
/**
* Push the markers changed since the last push to their sets: a marker
* that changed set leaves the one it was in first.
*/
function flushMarkers() {
const still = state._stillIcons;
const moving = state._movingIcons;
if (!still || !moving) return;
if (!dirty.size && !stillRemovals.length && !movingRemovals.length) return;
for (const entry of dirty) {
if (!entry.marker) continue;
const target = entry.animated ? moving : still;
if (entry.drawnIn && entry.drawnIn !== target)
(entry.drawnIn === still ? stillRemovals : movingRemovals).push(
entry.key,
);
entry.drawnIn = target;
(target === still ? stillUpserts : movingUpserts).push(itemOf(entry));
}
dirty.clear();
if (stillRemovals.length) still.remove(stillRemovals);
if (movingRemovals.length) moving.remove(movingRemovals);
if (stillUpserts.length) still.upsert(stillUpserts);
if (movingUpserts.length) moving.upsert(movingUpserts);
stillRemovals.length = 0;
movingRemovals.length = 0;
stillUpserts.length = 0;
movingUpserts.length = 0;
}
/**
* Take a vehicle's marker out of the set it is drawn in: with the others
* taken out in this task, in one removal (a sweep drops many at once).
*/
let flushQueued = false;
function removeMarker(entry) {
dirty.delete(entry);
const set = entry.drawnIn;
entry.drawnIn = null;
if (!set) return;
if (set === state._stillIcons) stillRemovals.push(entry.key);
else if (set === state._movingIcons) movingRemovals.push(entry.key);
else return;
if (flushQueued) return;
flushQueued = true;
queueMicrotask(() => {
flushQueued = false;
flushMarkers();
});
}
/**
* Listen for the camera moving, at this layer's own threshold.
*
* The camera port measures `changed` per listener, so this layer's finer
* trigger (it needs to notice it has entered a feed's coverage) is its own
* and leaves every other listener's untouched.
* @param {object} viewer
* @param {() => void} onChanged
*/
function watchCamera(viewer, onChanged) {
unwatchCamera();
state._cameraChangedOff =
findCamera(viewer)?.on('changed', onChanged, {
threshold: CAMERA_PERCENTAGE_CHANGED,
}) ?? null;
// A new listener measures from the view at the next tick, so a move made
// before that tick never reaches it: look again once that tick is past.
if (!state._cameraChangedOff) return;
let ticks = 0;
state._cameraFirstTickOff =
findFrame(viewer)?.on('preUpdate', () => {
if (++ticks < 2) return;
state._cameraFirstTickOff?.();
state._cameraFirstTickOff = null;
onChanged();
}) ?? null;
}
/** Stop listening for the camera moving. */
function unwatchCamera() {
state._cameraChangedOff?.();
state._cameraChangedOff = null;
state._cameraFirstTickOff?.();
state._cameraFirstTickOff = null;
}
/** Run the per-frame glide before each render, once. */
function startFrames(viewer) {
if (!state._preRenderRemove)
state._preRenderRemove =
findFrame(viewer)?.on('preRender', onPreRender) ?? null;
}
/** Stop the per-frame glide. */
function stopFrames() {
if (state._preRenderRemove) {
state._preRenderRemove();
state._preRenderRemove = null;
}
}
// The camera's pose and the globe's surface version, read once in a task:
// a sweep, a frame or a poll asks for them per vehicle, and reading them
// walks the camera's frames and the scene's primitives. Forgotten when the
// task ends, and at the start of every frame and visibility sweep.
let viewMemo = null;
let viewMemoQueued = false;
function forgetView() {
viewMemo = null;
}
function viewOf() {
if (viewMemo) return viewMemo;
viewMemo = { pose: undefined, surface: undefined };
if (!viewMemoQueued) {
viewMemoQueued = true;
queueMicrotask(() => {
viewMemoQueued = false;
viewMemo = null;
});
}
return viewMemo;
}
/** The camera port's pose, or null without a camera. */
function cameraPose() {
const view = viewOf();
if (view.pose === undefined)
view.pose = findCamera(state._viewer)?.pose() ?? null;
return view.pose;
}
/**
* The camera's height above the ellipsoid, or Infinity when it has none.
* @returns {number}
*/
function cameraHeightM() {
const height = cameraPose()?.height;
return Number.isFinite(height) ? height : Infinity;
}
/** The camera's subpoint in degrees, for the sampler's proximity gate. */
function viewerSubpoint() {
const pose = cameraPose();
if (!pose) return { viewerLat: undefined, viewerLon: undefined };
return { viewerLat: pose.lat, viewerLon: pose.lon };
}
// Whether the globe's terrain is the bare ellipsoid, as the height service
// last said for the surface `surfaceVersion` names; asked again whenever
// that changes, keeping the last answer until the new one comes. A terrain
// height that is only the ellipsoid's is one the service counts as a miss
// when asked to, so the ellipsoid is the point answered plainly and missed
// that way.
let flatVersion = null;
let flatTerrain = false;
function askFlat(globe) {
const view = viewOf();
if (view.surface === undefined)
view.surface = globe.surfaceVersion?.() ?? 0;
const version = view.surface;
if (version === flatVersion) return;
flatVersion = version;
const pose = cameraPose();
const point = {
lon: Number.isFinite(pose?.lon) ? pose.lon : 0,
lat: Number.isFinite(pose?.lat) ? pose.lat : 0,
};
const heights = heightsOf(state._viewer);
Promise.all([
heights.batch([point], { against: 'terrain' }),
heights.batch([point], { against: 'terrain', ellipsoidMisses: true }),
]).then(
([[answered], [terrain]]) => {
if (flatVersion !== version) return;
const flat = answered !== null && terrain === null;
if (flat === flatTerrain) return;
flatTerrain = flat;
// Floors read under the last answer are read again under this one,
// in a fresh cycle (which replaces the one pending).
if (state._enabled) parts.height.anchorFloors?.();
},
() => {
// Asked again at the next read.
if (flatVersion === version) flatVersion = null;
},
);
}
/**
* What the globe draws under the fleet: `'none'` when it is hidden (the
* photoreal stack), `'flat'` on the ellipsoid, `'terrain'` otherwise.
* @returns {'none'|'flat'|'terrain'}
*/
function globeSurface() {
const globe = findGlobe(state._viewer);
if (globe?.isGlobeVisible?.() !== true) return 'none';
askFlat(globe);
return flatTerrain ? 'flat' : 'terrain';
}
/**
* Sample the rendered mesh under floor cells, seeing through this layer's
* own sets.
* @param {object[]} cells
*/
function sampleMeshFloors(cells) {
if (!sampleMeshFloorCells) return;
const sets = setIds();
for (let i = 0; i < cells.length; i += 8)
sampleMeshFloorCells(state._viewer, cells.slice(i, i + 8), {
sets,
...viewerSubpoint(),
});
}
/**
* ECEF position for a lat/lon at a height. Called on POLL, not per frame:
* the conversion runs trigonometry, and doing that for every vehicle on
* every frame was most of what made this layer heavy.
*/
function cartesianFor(lat, lon, heightM, out = { x: 0, y: 0, z: 0 }) {
// `heightM` already carries the shared floor's own lift, so nothing is
// added here: two lifts stacked is a vehicle hovering.
return fromDegreesInto(lon, lat, heightM || 0, out);
}
/** Heights are aligned to work with Google 3D tiles. Rebuild both ends. */
function refreshEndpoints(entry) {
if (!entry.sample || entry.sample.fromSeq < 0) return;
entry.from = entry.segment.from;
entry.to = entry.segment.to;
entry.fromCart = cartesianFor(
entry.from.lat,
entry.from.lon,
entry.from.h,
entry.fromCart || { x: 0, y: 0, z: 0 },
);
entry.toCart = cartesianFor(
entry.to.lat,
entry.to.lon,
entry.to.h,
entry.toCart || { x: 0, y: 0, z: 0 },
);
entry.endpointRevision = entry.sample.revision;
entry.endpointFromSeq = entry.sample.fromSeq;
entry.endpointToSeq = entry.sample.toSeq;
}
function placeSample(entry, nearGround = parts.height.nearGround()) {
if (
entry.endpointRevision !== entry.sample.revision ||
entry.endpointFromSeq !== entry.sample.fromSeq ||
entry.endpointToSeq !== entry.sample.toSeq
)
refreshEndpoints(entry);
const known = parts.trails.samplePosition(
entry,
entry.sample,
state._scratchCartesian,
nearGround,
);
entry.surfaceReady = !!known;
entry.heightPending = !known;
setShown(entry, !!known && vehicleInView(entry));
if (known) {
const p = entry.marker.position;
const s = state._scratchCartesian;
if (p.x !== s.x || p.y !== s.y || p.z !== s.z) {
p.x = s.x;
p.y = s.y;
p.z = s.z;
dirty.add(entry);
}
entry.hasRendered = true;
}
}
function sampleIdle(entry) {
if (!state._moving.has(entry)) {
updatePlayback(entry, Date.now(), performance.now());
placeSample(entry);
}
}
function cancelWake(entry) {
if (entry.wakeTimer != null) clearTimeout(entry.wakeTimer);
entry.wakeTimer = null;
}
/** Draw a marker in the moving set, or the still one. */
function migrateMarker(entry, animated) {
if (!entry.marker || entry.animated === animated) return;
entry.animated = animated;
entry.markerRevision = (entry.markerRevision || 0) + 1;
dirty.add(entry);
}
function schedulePlayback(entry) {
cancelWake(entry);
if (!entry.marker || !vehicleInView(entry)) {
state._moving.delete(entry);
migrateMarker(entry, false);
return;
}
const sample = entry.sample;
if (!sample || entry.heightPending || entry.surfaceReady === false) {
state._moving.delete(entry);
migrateMarker(entry, false);
return;
}
const positional = sample.phase === 'playing' && sample.segmentSpeedMps > 0;
const turning =
Number.isFinite(sample.segmentCourseDeg) &&
Number.isFinite(entry.courseDeg) &&
Math.abs(
((sample.segmentCourseDeg - entry.courseDeg + 540) % 360) - 180,
) > 0.01;
if (positional || turning) {
state._moving.add(entry);
migrateMarker(entry, true);
} else {
state._moving.delete(entry);
migrateMarker(entry, false);
if (Number.isFinite(sample.nextWakeMonoMs)) {
entry.wakeTimer = setTimeout(
() => {
entry.wakeTimer = null;
if (!state._enabled || !state._vehicles.has(entry.key)) return;
updatePlayback(entry, Date.now(), performance.now());
placeSample(entry);
schedulePlayback(entry);
flushMarkers();
syncRenderHold();
governorRequestRender('transit-motion-boundary');
},
Math.max(1, sample.nextWakeMonoMs - performance.now()),
);
}
}
}
/**
* Whether either end of the segment being drawn is near the view — the
* test visibility, animation and rotation all share.
* @param {object} entry
* @returns {boolean}
*/
function vehicleInView(entry) {
return state._visible.has(entry);
}
/** A preset tuple as a colour (0..1 channels), cached per profile+mode. */
const _presetColors = new Map();
function presetColor(style, mode) {
const rgba = presetSpriteRgba(style, mode);
if (!rgba) return null;
const key = `${transitStyleProfile(style)}:${mode}`;
let color = _presetColors.get(key);
if (!color) {
color = Object.freeze([
rgba[0] / 255,
rgba[1] / 255,
rgba[2] / 255,
rgba[3],
]);
_presetColors.set(key, color);
}
return color;
}
/**
* The ONE place a sprite's look is decided: creation, a mode change, select,
* deselect and a preset change all come here, so no path can undo another.
* Under a mono preset (NVG, FLIR, noir) the sprite is white-hot with a dark
* halo sized in screen pixels; under CRT a saturated mode colour with a
* thinner halo; otherwise the shipped mode colour and hairline. Selection
* grows the glyph and retains the mode colour; sensors use opaque white.
* @param {object} entry
*/
function applySpriteStyle(entry) {
const marker = entry.marker;
if (!marker) return;
const style = state._stylePreset;
const selected = state._selectedKey === entry.key;
const basePx = selected ? SELECTED_PIXEL_SIZE : MARKER_PIXEL_SIZE;
const halo = presetSpriteOutlinePx(style, selected);
const displayPx = basePx * presetSpriteScale(style, selected);
const frame = haloFrame(halo, displayPx);
const px = displayPx * frame.ratio;
marker.image = transitIcon(
entry.mode,
selected ? SELECTED_ICON_PX : undefined,
{
style,
},
);
marker.width = px;
marker.height = px;
if (entry.detectContact) {
entry.detectContact.bracketHalfWidth = Math.ceil(px / 2) + 2;
entry.detectContact.bracketHalfHeight = Math.ceil(px / 2) + 2;
}
marker.color =
presetColor(style, entry.mode) ||
TRANSIT_MODE_COLORS[entry.mode] ||
TRANSIT_MODE_COLORS.unknown;
dirty.add(entry);
}
function addMarker(key, entry) {
const at = entry.toCart;
const marker = {
position: { x: at?.x ?? 0, y: at?.y ?? 0, z: at?.z ?? 0 },
show: false,
image: transitIcon(entry.mode),
width: MARKER_PIXEL_SIZE,
height: MARKER_PIXEL_SIZE,
color: TRANSIT_MODE_COLORS[entry.mode],
rotation: 0,
};
entry.marker = marker;
entry.animated = false;
entry.drawnIn = null;
applySpriteStyle(entry);
return marker;
}
function paintMode(entry, mode) {
entry.mode = mode;
if (entry.key === state._selectedKey) {
parts.trails.style();
parts.selection.refreshSelectedCard(true);
}
state._detectRevision += 1;
applySpriteStyle(entry);
}
/**
* Adopt a post-FX style. One pass over the fleet, on the event, never per
* frame; a style already applied is a no-op.
* @param {string|null|undefined} styleName
*/
function setStylePreset(styleName) {
const next = styleName || 'normal';
if (next === state._stylePreset) return;
state._stylePreset = next;
for (const entry of state._vehicles.values()) applySpriteStyle(entry);
flushMarkers();
parts.trails.style();
governorRequestRender('transit-style');
}
/**
* The screen rotation that points a marker along `course`, projected
* exactly through the query port (see `perspectiveCourseRotation`).
*/
function courseRotation(query, pose, position, course, previous) {
return perspectiveCourseRotation(
query.project,
pose,
position,
course,
previous,
);
}
/**
* Point every glyph along its reported course.
*
* Icons are camera-facing quads, so a course has to be projected into
* screen space — which depends on where the camera is, not only on the
* vehicle. Doing that for the whole fleet on every frame is exactly the kind
* of cost that made this layer heavy, and it buys nothing: a bus icon whose
* rotation is a fifth of a second stale is indistinguishable. So the pass is
* throttled, and runs only when the camera has actually moved or a poll
* changed somebody's heading.
*/
function refreshRotations(now) {
if (now - state._rotationAt < ROTATION_REFRESH_MS) return;
const pose = cameraPose();
const query = findQuery(state._viewer);
if (!pose?.position || !query) return;
state._rotationAt = now;
const signature = poseSignature(pose);
const cameraChanged =
state._rotationPose !== signature ||
state._rotationRevision !== state._cameraRevision;
if (!cameraChanged && !state._rotationDirty && state._moving.size === 0)
return;
state._rotationPose = signature;
state._rotationRevision = state._cameraRevision;
state._rotationDirty = false;
const monoNow = performance.now();
for (const entry of state._visible) {
// Idle contacts still need a course when their first usable bearing arrives.
if (!state._moving.has(entry)) applyDisplayCourse(entry, monoNow);
if (entry.key === state._selectedKey) continue;
const marker = entry.marker;
const course = entry.courseDeg;
if (!Number.isFinite(course)) {
if (marker.rotation !== 0) dirty.add(entry);
marker.rotation = 0;
entry.rotationCourse = null;
continue;
}
const position = marker.position;
if (
!cameraChanged &&
entry.rotationCourse === course &&
Math.abs(position.x - entry.rotationX) +
Math.abs(position.y - entry.rotationY) +
Math.abs(position.z - entry.rotationZ) <
10
)
continue;
entry.rotationCourse = course;
entry.rotationX = position.x;
entry.rotationY = position.y;
entry.rotationZ = position.z;
// Exact projection, perspective division included. The shared
// camera-basis helper aircraft use is orthographic — fine at altitude,
// and wrong by twenty-odd degrees for a street-level contact away from
// the centre of an obliquely pitched view, which is most of them.
const rotation = courseRotation(
query,
pose,
position,
course,
marker.rotation,
);
if (rotation !== marker.rotation) {
marker.rotation = rotation;
dirty.add(entry);
}
}
}
/** Publish final motion wording when the selected contact settles. */
function settleSelectedCard(entry) {
if (state._selectedKey && state._selectedKey === entry.key) {
parts.selection.refreshSelectedCard(true);
}
}
/** Hold only for visible position or orientation animation. */
function syncRenderHold() {
// Held for motion only. Ground resolution runs on its own timer off the
// render path, so a fleet waiting for floors is not a fleet worth burning
// frames on — it is not moving.
const working = state._enabled && state._moving.size > 0;
if (working && !state._renderHeld) {
holdContinuousRender('transit');
state._renderHeld = true;
} else if (!working && state._renderHeld) {
releaseContinuousRender('transit');
state._renderHeld = false;
governorRequestRender('transit-settled');
}
}
function onPreRender() {
if (
typeof document !== 'undefined' &&
document.visibilityState === 'hidden'
)
return;
if (!state._enabled) return;
forgetView();
const now = Date.now();
if (state._vehicles.size === 0) {
state._moving.clear();
syncRenderHold();
return;
}
const monoNow = performance.now();
const nearGround = parts.height.nearGround();
let dirtyCount = 0;
for (const entry of state._heightDirty) {
if (dirtyCount++ >= 64) break;
state._heightDirty.delete(entry);
if (!entry.marker) continue;
updatePlayback(entry, now, monoNow);
placeSample(entry, nearGround);
schedulePlayback(entry);
}
for (const entry of state._moving) {
if (!entry.marker || !vehicleInView(entry)) {
state._moving.delete(entry);
continue;
}
updatePlayback(entry, now, monoNow);
placeSample(entry, nearGround);
if (applyDisplayCourse(entry, monoNow)) state._rotationDirty = true;
if (
!entry.surfaceReady ||
entry.sample.phase !== 'playing' ||
entry.sample.segmentSpeedMps === 0
)
schedulePlayback(entry);
if (!state._moving.has(entry)) settleSelectedCard(entry);
}
parts.trails.update();
refreshRotations(now);
const selected = state._vehicles.get(state._selectedKey);
if (selected && state._visible.has(selected)) {
const marker = selected.marker;
const pose = Number.isFinite(selected.courseDeg) ? cameraPose() : null;
const query = pose?.position ? findQuery(state._viewer) : null;
const rotation = query
? courseRotation(
query,
pose,
marker.position,
selected.courseDeg,
marker.rotation,
)
: Number.isFinite(selected.courseDeg)
? marker.rotation
: 0;
if (rotation !== marker.rotation) {
marker.rotation = rotation;
dirty.add(selected);
}
}
flushMarkers();
if (state._heightDirty.size) governorRequestRender('transit-height-batch');
syncRenderHold();
}
const candidatePosition = { x: 0, y: 0, z: 0 };
/** Visibility work runs off the frame path, coalesced at four sweeps/second. */
function requestVisibility() {
state._visibilityDirty = true;
if (!state._enabled || state._visibilityTimer !== null) return;
state._visibilityTimer = setTimeout(
() => {
state._visibilityTimer = null;
refreshVisibility();
},
Math.max(0, VISIBILITY_REFRESH_MS - (Date.now() - state._visibilityAt)),
);
}
/**
* The planes of the frustum the camera looks through, as the default
* renderer culls with them, or null when the pose does not describe one.
*/
function viewPlanes(pose) {
if (
!pose?.position ||
!pose.direction ||
!pose.up ||
!Number.isFinite(pose.fovy) ||
!Number.isFinite(pose.aspectRatio) ||
!Number.isFinite(pose.near)
)
return null;
return frustumPlanes(pose);
}
function refreshVisibility() {
if (!state._enabled) return 0;
const now = Date.now();
if (now - state._visibilityAt < VISIBILITY_REFRESH_MS) {
requestVisibility();
return state._shownCount;
}
state._visibilityAt = now;
state._visibilityDirty = false;
forgetView();
const pose = cameraPose();
if (!pose) return 0;
const query = findQuery(state._viewer);
const planes = viewPlanes(pose);
let changed = false;
for (const entry of state._vehicles.values()) {
if (!entry.marker) continue;
// Refresh hidden clocks before testing admission, even if no frame has
// ever sampled them. Do not write the marker until it is admitted.
const noSample = !entry.sample || !Number.isFinite(entry.sample.lat);
if (entry.track?.count && (!state._visible.has(entry) || noSample)) {
entry.sample ||= {};
updatePlayback(entry, now, performance.now());
}
const center =
state._visible.has(entry) || !entry.sample
? entry.marker.position
: cartesianFor(
entry.sample.lat,
entry.sample.lon,
entry.heightM,
candidatePosition,
);
// A settled geographic rectangle can lag setView or miss an oblique
// view. The current frustum is authoritative; the horizon still rejects
// the far side when the rectangle is missing or stale.
const bounds = vehicleNearView(state._viewBounds, entry);
const horizon = !(query?.isOccluded(center) ?? false);
let inFrustum = true;
if (planes) {
for (let i = 0; i < planes.length; i++) {
const { normal: n, w } = planes[i];
if (
n.x * center.x + n.y * center.y + n.z * center.z + w <
-CULL_RADIUS_M
) {
inFrustum = false;
break;
}
}
}
const visible = (planes || bounds) && horizon && inFrustum;
const visibility = (entry.visibility ||= {});
visibility.bounds = bounds;
visibility.boundsApplied = !planes;
visibility.occluder = horizon;
visibility.frustum = inFrustum;
visibility.noSample = noSample;
const wasShown = entry.marker.show;
const wasVisible = state._visible.has(entry);
if (visible) state._visible.add(entry);
else state._visible.delete(entry);
if (visible && entry.track?.count) {
if (!wasVisible && !entry.qaFixture) syncPlayback(entry, now);
// Re-entry can advance into an unprepared corridor; loaded tiles can
// also resolve a cold path without a poll or a render-loop wakeup.
if (!wasVisible || entry.surfaceReady === false || entry.heightPending)
parts.trails.prepareEntry(entry);
// Surface completion must recover while requestRenderMode is idle.
// Otherwise surfaceReady=false prevents the very frame that clears it.
if (!state._moving.has(entry)) {
updatePlayback(entry, now, performance.now());
placeSample(entry);
}
}
setShown(
entry,
Boolean(
visible && !entry.heightPending && entry.surfaceReady !== false,
),
);
visibility.heightPending = !!entry.heightPending;
visibility.surfaceReady = entry.surfaceReady ?? null;
schedulePlayback(entry);
changed ||= visible !== wasVisible || wasShown !== entry.marker.show;
}
flushMarkers();
state._shownCount = state._visible.size;
if (changed) state._detectRevision++;
syncRenderHold();
governorRequestRender('transit-visibility');
return state._shownCount;
}
function resumePlayback() {
if (!state._enabled) return;
const now = Date.now(),
mono = performance.now();
const entries = new Set(state._visible);
const selected = state._vehicles.get(state._selectedKey);
if (selected) entries.add(selected);
for (const entry of entries) {
if (!entry.track?.count) continue;
syncPlayback(entry, now, mono);
parts.trails.prepareEntry(entry);
placeSample(entry);
schedulePlayback(entry);
}
flushMarkers();
parts.trails.update();
parts.selection.refreshSelectedCard(true);
state._detectRevision++;
syncRenderHold();
governorRequestRender('transit-re-entry');
}
// Text and membership refreshes are bounded timer work, never paint work.
function maintainPresentation() {
if (!state._enabled) return;
if (state._moving.size) requestVisibility();
parts.queries.refreshDetectCache();
parts.selection.refreshSelectedCard(false);
}
/** Grow the selected glyph (or shrink it back) through the one styling path. */
function paintSelected(entry, selected) {
void selected; // decided from state._selectedKey, which the caller has set
applySpriteStyle(entry);
flushMarkers();
}
let stopProbe = null;
/** Stop a running frame probe, resolving it with what it has. */
function stopFrameProbe() {
stopProbe?.();
}
/**
* Measure inside the renderer's frames with fixed typed storage; no sample
* objects per frame. `uploads`, when given, counts the bytes the
* renderer uploads for this layer's sets each frame (the Cesium one's is
* `src/render/cesium/uploadProbe.js`, which QA hands in): `reset()` at
* each frame's start, `bytes()` at its end, `stop()` when done.
* @param {number} [durationMs]
* @param {{reset: () => void, bytes: () => number, stop: () => void}|null} [uploads]
*/
function measureFrames(durationMs = 12000, uploads = null) {
stopProbe?.();
const frame = findFrame(state._viewer);
const canvas = canvasOf(state._viewer);
const capacity = 20000,
stride = 12,
data = new Float64Array(capacity * stride);
const previousPositions = new Float64Array(state._vehicles.size * 3);
let cpu = 0,
count = 0,
previous = 0;
const wasRunning = state._preRenderRemove !== null;
stopFrames();
const removePre = frame.on('preRender', () => {
uploads?.reset();
const start = performance.now();
onPreRender();
cpu = performance.now() - start;
});
let removePost, timer;
return new Promise((resolve) => {
const finish = () => {
clearTimeout(timer);
removePre();
removePost?.();
uploads?.stop();
if (wasRunning && state._enabled) startFrames(state._viewer);
stopProbe = null;
const rows = [];
for (let i = 1; i < count; i++) {
const k = i * stride;
rows.push({
intervalMs: data[k],
cpuMs: data[k + 1],
uploadBytes: data[k + 2],
moving: data[k + 3],
x: data[k + 4],
y: data[k + 5],
z: data[k + 6],
displayT: data[k + 7],
expectedMps: data[k + 8],
segment: data[k + 9],
});
}
resolve({
rows,
dpr: devicePixelRatio,
width: canvas?.clientWidth,
height: canvas?.clientHeight,
});
};
stopProbe = finish;
removePost = frame.on('postRender', () => {
const now = performance.now();
if (count >= capacity) return;
const k = count++ * stride;
const entry = state._vehicles.get('mbta:qa-0');
data[k] = previous ? now - previous : 0;
previous = now;
data[k + 1] = cpu;
data[k + 2] = uploads ? uploads.bytes() : 0;
let actuallyMoved = 0;
for (const vehicle of state._visible) {
const p = vehicle.marker.position,
index = vehicle.qaIndex * 3;
if (
count > 1 &&
Math.hypot(
p.x - previousPositions[index],
p.y - previousPositions[index + 1],
p.z - previousPositions[index + 2],
) > 0.00001
)
actuallyMoved++;
previousPositions[index] = p.x;
previousPositions[index + 1] = p.y;
previousPositions[index + 2] = p.z;
}
data[k + 3] = actuallyMoved;
if (entry?.marker) {
const p = entry.marker.position;
data[k + 4] = p.x;
data[k + 5] = p.y;
data[k + 6] = p.z;
data[k + 7] = entry.sample.displayT;
data[k + 8] = entry.sample.segmentSpeedMps;
data[k + 9] = entry.sample.fromSeq;
}
});
timer = setTimeout(finish, durationMs);
});
}
return {
createMarkers,
showMarkers,
clearMarkers,
destroyMarkers,
setIds,
ownsSet,
setNameOf,
markerShown,
markDirty,
flushMarkers,
removeMarker,
watchCamera,
unwatchCamera,
startFrames,
stopFrames,
cameraHeightM,
globeSurface,
sampleMeshFloors,
measureFrames,
stopFrameProbe,
resumePlayback,
maintainPresentation,
requestVisibility,
sampleIdle,
cancelWake,
schedulePlayback,
placeSample,
cartesianFor,
refreshEndpoints,
refreshVisibility,
vehicleInView,
addMarker,
paintMode,
paintSelected,
applySpriteStyle,
setStylePreset,
onPreRender,
syncRenderHold,
};
}