Files
gods-eye-view/src/layers/transit/state.js
T
Sameh Khamis 725f2f2998 Moving transit allocates nothing per frame: reusable positions, kept lists, and the frame probe back in testing.js
- Scratch and marker positions are a Cesium-free Vec3 (src/geo/vector.js), so writing a coordinate does not allocate.
- The dirty set and the upsert lists are kept between frames instead of rebuilt; patchDrawnIcons reuses its lookup arrays.
- measureFrames and stopFrameProbe live in src/layers/transit/testing.js again.
- Tests: 3000 moving vehicles stay under 8 KiB per frame of layer allocation; moving 500 icons allocates under 256 B per upsert.
2026-11-15 18:27:10 -08:00

143 lines
5.5 KiB
JavaScript

import { createHistoryBudget } from '../../data/contactPlayback.js';
import { Vec3 } from '../../geo/vector.js';
import { worldTimeFor } from '../../time/worldClock.js';
/**
* One Transit layer's mutable scene state. Every field lives on the instance,
* so two layers built from this factory never share a viewer, a primitive
* collection, a request map or a height cache.
* @param {{services: object}} context
* @returns {object}
*/
export function createState({ services }) {
const { setOverlayEntries, setOverlaySourceVisible, clearOverlaySource } =
services.overlays;
const state = {};
state._historyBudget = createHistoryBudget();
/** The time vehicles play back behind by their display delay, in epoch ms. */
state.now = worldTimeFor('transit');
state.DEFAULT_OVERLAY_HOST = Object.freeze({
setEntries: setOverlayEntries,
setVisible: setOverlaySourceVisible,
clearSource: clearOverlaySource,
});
state._overlayHost = state.DEFAULT_OVERLAY_HOST;
/** The viewer the layer draws on, or null. */
state._viewer = null;
/** The still markers' icon draw set, and the moving ones', or null. */
state._stillIcons = null;
state._movingIcons = null;
/** Whether the markers are shown (the layer is on). */
state._markersShown = false;
state._visible = new Set();
state._visibilityTimer = null;
state._maintenanceTimer = null;
state._detectBuiltAt = -Infinity;
state._cameraRevision = 0;
state._rotationRevision = -1;
state._enabled = false;
state._generation = 0;
state._cameraChangedAttached = false;
/** Removes the camera port listener; null when not listening. */
state._cameraChangedOff = null;
/** Removes the one-shot look after the camera listener's first tick. */
state._cameraFirstTickOff = null;
state._cameraDebounceTimer = null;
state._altitudeGateOpen = false;
/** @type {(() => void)|null} */
state._preRenderRemove = null;
state._renderHeld = false;
/** @type {(() => void)|null} Unsubscribes the vehicle-selection click. */
state._clickSubscription = null;
/**
* The vehicles currently mid-glide. The per-frame pass walks THIS, not the
* whole fleet, and the render hold is derived from it together with the
* height queue — so both track work that exists rather than a window of time
* the layer hoped would contain some.
* @type {Set<object>}
*/
state._moving = new Set();
/** Vehicles whose sampled height landed after they were drawn. @type {Set<object>} */
state._heightDirty = new Set();
/**
* Inflated camera view bounds in degrees, or null before the first camera
* read. Decides which vehicles are worth animating frame by frame.
* @type {{south:number,north:number,west:number,east:number}|null}
*/
state._viewBounds = null;
/** How many vehicles are currently drawn, as opposed to held. */
state._shownCount = 0;
/** Deferred shown/hidden sweep bookkeeping. */
state._visibilityDirty = true;
state._visibilityAt = 0;
/** Throttle bookkeeping for the screen-space rotation pass. */
state._rotationAt = 0;
state._rotationPose = null;
state._rotationDirty = false;
/** @type {Map<string, object>} feedId → registry entry currently polled */
state._activeFeeds = new Map();
/** @type {Map<string, {count:number, lastUpdate:number|null, error:string|null, stale:boolean, pollSeq:number, loading:boolean}>} */
state._feedStatus = new Map();
/** @type {Map<string, {controller: AbortController, promise: Promise<void>}>} */
state._inFlight = new Map();
/** @type {Map<string, object>} vehicle key → runtime entry */
state._vehicles = new Map();
/** Timer for the floor re-read cycle, and how many it has spent. */
state._floorTimer = null;
state._floorAttempts = 0;
/** Where the next warm window starts among the cold cells: no cell waits for ever. */
state._floorCursor = 0;
/** @type {string|null} */
state._selectedKey = null;
/** When the user last selected a vehicle, even the selected one (ms). */
state._selectedAtMs = null;
/**
* The vehicle a first-person view holds (cockpitSubject.js), or null: its
* sprite, 3D model, card, trail and detection box are hidden, and it keeps
* moving out of the camera's view.
* @type {string|null}
*/
state._cockpitSubjectKey = null;
state._selectedCardAt = 0;
/** The card text last published, so an unchanged card is not re-sent. */
state._selectedCardText = null;
/**
* Bumped whenever the set of vehicles DETECT may see could have changed —
* a poll, a visibility sweep, a removal, a selection — so the candidate
* list is rebuilt on change rather than on every paint.
*/
state._detectRevision = 0;
/** The candidate list DETECT was last handed, and the revision it was built at. */
state._detectCache = null;
/**
* Active post-FX style the sprites are drawn for. Read from the document
* at init and followed through the style and cockpit-vision events; a
* cockpit override wins over the map style while it lasts.
*/
state._stylePreset = 'normal';
state._cockpitVision = false;
/** @type {Array<[string, EventListener]>} window listeners to remove on destroy. */
state._styleListeners = [];
/** @type {{ refreshLayerStats?: (layerId?: string) => void }|null} */
state._dataManager = null;
/** @type {number|null} */
state._lastUpdate = null;
/** @type {string|null} */
state._error = null;
state._limitWarned = false;
// Where `samplePosition` writes a marker's position, each frame, before
// it is copied into the marker: a `Vec3`, so the write allocates nothing.
state._scratchCartesian = new Vec3();
return state;
}