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, }; }