mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-18 01:02:23 +00:00
Every Cesium read that a Navara page made was surveyed with the strict acceptance (GEV_QA_CESIUM_TRAP=record). Math on those paths now uses src/geo: screen annotations, weather and wind center readings, cyclone picks, scene data pack polygons and images (new navaraGeometry.js), the awareness subject, the orbit offset of camera verbs, voice frame_overhead, the agent world packet and Directions colours and ground picks. The celestial ring's Sun and Moon come from a bit-identical port of Cesium's Simon1994 model, JulianDate and TEME rotation (src/geo/simon1994.js, julianDate.js, transforms.js); a Cesium globe still applies its ICRF rotation once loaded. Traffic, Street Level, the Nepal event and locator and geo import build on Cesium's math or entity model on either globe; their enable (or the import) now loads the SDK first through src/app/loadCesium.js, synchronously when it is already there. A production page guards the global so a missed read is reported and starts the load. No module reads Cesium while it loads (scripts/check-cesium-load-time.mjs, run by npm test). Cesium.js is still loaded by index.html here.
358 lines
13 KiB
JavaScript
358 lines
13 KiB
JavaScript
import { observeTrafficSurface } from './surface.js';
|
|
import * as Cesium from 'cesium';
|
|
import { TRAFFIC_TIMING_ENABLED } from './policy.js';
|
|
import {
|
|
claimCameraSensitivity,
|
|
releaseCameraSensitivity,
|
|
} from '../../data/cameraSensitivity.js';
|
|
import { whenCesiumSdk } from '../../app/loadCesium.js';
|
|
|
|
export function createLifecycle({
|
|
state: layerState,
|
|
services,
|
|
parts,
|
|
source,
|
|
}) {
|
|
const { resetFlowTileCache } = source;
|
|
|
|
function readyForSurfaceWork() {
|
|
const resolve = layerState._sceneReady;
|
|
layerState._sceneReady = layerState._waitForScene = null;
|
|
resolve?.();
|
|
}
|
|
|
|
function bindScene() {
|
|
const viewer = layerState._viewer,
|
|
engine = layerState._engine;
|
|
const camera = engine?.camera ?? viewer.camera;
|
|
const frames = engine?.frames ?? viewer.scene;
|
|
if (viewer)
|
|
layerState._surfaceFrameRemover = observeTrafficSurface(viewer.scene);
|
|
layerState._pointCollection.show = true;
|
|
layerState._lastAnimTime = 0;
|
|
parts.animation.syncRenderDemand();
|
|
layerState._preRenderRemover = frames.preRender.addEventListener(() => {
|
|
parts.animation.animate();
|
|
layerState._native?.points.flush();
|
|
});
|
|
if (TRAFFIC_TIMING_ENABLED) {
|
|
parts.timing.clearTrafficTimingEntries();
|
|
layerState._trafficTimingCurrentAnchor = null;
|
|
layerState._trafficTimingPostRenderRemovers = new Set();
|
|
layerState._trafficTimingMoveEndRemover = camera.moveEnd.addEventListener(
|
|
parts.timing.markTrafficTimingMoveEnd,
|
|
);
|
|
}
|
|
layerState._cameraRemover = camera.changed.addEventListener(
|
|
parts.viewport.onCameraChanged,
|
|
);
|
|
layerState._arrivalRemover = camera.moveEnd.addEventListener(() =>
|
|
parts.viewport.onCameraChanged({ immediate: true }),
|
|
);
|
|
claimCameraSensitivity(engine ?? camera, 'traffic', 0.05);
|
|
}
|
|
|
|
function unbindScene() {
|
|
const camera = layerState._engine?.camera ?? layerState._viewer?.camera;
|
|
layerState._surfaceFrameRemover?.();
|
|
layerState._preRenderRemover?.();
|
|
layerState._trafficTimingMoveEndRemover?.();
|
|
for (const remove of layerState._trafficTimingPostRenderRemovers || [])
|
|
remove();
|
|
layerState._trafficTimingPostRenderRemovers = null;
|
|
layerState._trafficTimingCurrentAnchor = null;
|
|
layerState._cameraRemover?.();
|
|
// Some legacy camera events do not return a remover.
|
|
if (!layerState._cameraRemover)
|
|
camera?.changed?.removeEventListener?.(parts.viewport.onCameraChanged);
|
|
layerState._arrivalRemover?.();
|
|
layerState._surfaceFrameRemover =
|
|
layerState._preRenderRemover =
|
|
layerState._cameraRemover =
|
|
layerState._arrivalRemover =
|
|
layerState._trafficTimingMoveEndRemover =
|
|
null;
|
|
releaseCameraSensitivity(layerState._engine ?? camera, 'traffic');
|
|
}
|
|
|
|
const methods = {
|
|
/**
|
|
* One-time initialisation. Creates the PointPrimitiveCollection and adds it
|
|
* to the scene (hidden). The collection is never removed and re-added — only
|
|
* toggled via `.show` to avoid destroy-on-remove errors.
|
|
*
|
|
* @param {Cesium.Viewer} viewer - The Cesium viewer instance.
|
|
*/
|
|
init(viewer, options) {
|
|
this.attachRenderer(viewer, options);
|
|
layerState._dots = [];
|
|
layerState._roads = [];
|
|
layerState._count = 0;
|
|
layerState._lastUpdate = null;
|
|
layerState._lastBounds = null;
|
|
layerState._fetching = false;
|
|
layerState._loadGeneration = 0;
|
|
layerState._densityScale = 1.0;
|
|
layerState._speedScale = 1.0;
|
|
layerState._lastViewCenter = null;
|
|
layerState._flowRoads = null;
|
|
layerState._flowError = null;
|
|
layerState._flowStale = false;
|
|
layerState._flowOldestTileAt = null;
|
|
if (TRAFFIC_TIMING_ENABLED) {
|
|
layerState._trafficTimingCurrentAnchor = null;
|
|
layerState._trafficTimingSequence = 0;
|
|
layerState._trafficTimingTracesCreated = 0;
|
|
layerState._trafficTimingDroppedTraces = 0;
|
|
}
|
|
|
|
// Preset-aware dot styling: adopt the active post-FX style (persisted
|
|
// style restore may run before layer registration, so read the dataset)
|
|
// and follow StyleManager's gev:style-change event thereafter. Guarded
|
|
// for non-browser contexts; bound once per page (init survives layer
|
|
// destroy/re-register).
|
|
if (typeof window !== 'undefined') {
|
|
layerState._stylePreset =
|
|
document?.documentElement?.dataset?.gevStyle || 'normal';
|
|
if (!layerState._styleListenerBound) {
|
|
layerState._styleListener = (e) =>
|
|
parts.style.setStylePreset(e?.detail?.style);
|
|
window.addEventListener(
|
|
'gev:style-change',
|
|
layerState._styleListener,
|
|
);
|
|
layerState._styleListenerBound = true;
|
|
}
|
|
}
|
|
parts.style.refreshBucketColors();
|
|
console.log('[Data:Traffic] Initialized');
|
|
},
|
|
|
|
attachRenderer(
|
|
viewer,
|
|
{ engine = null, waitForCameraRestore = false } = {},
|
|
) {
|
|
layerState._restoringViewport = waitForCameraRestore;
|
|
layerState._viewer = viewer;
|
|
layerState._engine = engine;
|
|
layerState._native =
|
|
!viewer && engine ? services.nativeRenderer(engine) : null;
|
|
layerState._heatSupported = null;
|
|
const points =
|
|
layerState._native?.points ??
|
|
new Cesium.PointPrimitiveCollection({
|
|
blendOption: Cesium.BlendOption.TRANSLUCENT,
|
|
});
|
|
if (viewer) viewer.scene.primitives.add(points);
|
|
layerState._pointCollection = points;
|
|
for (const dot of layerState._dots) dot.point = points.add(dot.point);
|
|
points.show = layerState._enabled;
|
|
if (!waitForCameraRestore) readyForSurfaceWork();
|
|
if (layerState._enabled) {
|
|
bindScene();
|
|
parts.rendering.rebuildHeatLines(layerState._roads);
|
|
if (
|
|
layerState._dots.length &&
|
|
layerState._roads.some((r) => !r.directFlow)
|
|
)
|
|
services.credits?.showOsmCredit?.(engine ?? viewer, 'traffic', {
|
|
openMapTiles: true,
|
|
});
|
|
if (layerState._liveMode)
|
|
services.credits?.registerDynamicCredit?.(
|
|
engine ?? viewer,
|
|
services.credits.TOMTOM_CREDIT,
|
|
);
|
|
parts.viewport.onCameraChanged({ immediate: true });
|
|
}
|
|
},
|
|
resumeViewport() {
|
|
if (!layerState._restoringViewport) return;
|
|
layerState._restoringViewport = false;
|
|
readyForSurfaceWork();
|
|
if (!layerState._enabled) return;
|
|
if (layerState._populationPending) parts.retention.resume();
|
|
const previous = layerState._surfaceInput;
|
|
if (
|
|
previous &&
|
|
!layerState._fetching &&
|
|
layerState._lastBounds === previous.bounds
|
|
) {
|
|
// A completed pass, not a refinement: the incoming globe often still
|
|
// shows coarse tiles, so it samples provisionally and refines once its
|
|
// surface has loaded ('Handoff refined'). A refinement here never
|
|
// refined again and left vehicles on those coarse heights.
|
|
void parts.flow
|
|
.applyFlowThenRender(
|
|
previous.roads,
|
|
previous.bounds,
|
|
layerState._loadGeneration,
|
|
parts.viewport.getCameraAltitude(),
|
|
'Handoff',
|
|
)
|
|
.catch((error) => {
|
|
if (error?.name !== 'AbortError')
|
|
console.warn('[Data:Traffic] Surface refresh failed', error);
|
|
});
|
|
}
|
|
parts.viewport.onCameraChanged({ immediate: true });
|
|
},
|
|
detachRenderer() {
|
|
if (!layerState._pointCollection) return;
|
|
unbindScene();
|
|
clearTimeout(layerState._fetchTimeout);
|
|
layerState._surfaceRefineRemove?.();
|
|
layerState._surfaceRefineRemove = null;
|
|
layerState._surfaceRevision = (layerState._surfaceRevision || 0) + 1;
|
|
layerState._preparedRoads?.clear();
|
|
parts.rendering.removeHeatLines();
|
|
services.credits?.hideOsmCredit?.(
|
|
layerState._engine ?? layerState._viewer,
|
|
'traffic',
|
|
);
|
|
for (const dot of layerState._dots) {
|
|
const p = dot.point;
|
|
dot.point = {
|
|
position: Cesium.Cartesian3.clone(p.position),
|
|
pixelSize: p.pixelSize,
|
|
color: p.color,
|
|
show: p.show,
|
|
outlineColor: p.outlineColor,
|
|
outlineWidth: p.outlineWidth,
|
|
scaleByDistance: p.scaleByDistance,
|
|
translucencyByDistance: p.translucencyByDistance,
|
|
disableDepthTestDistance: 0,
|
|
};
|
|
}
|
|
layerState._viewer?.scene.primitives.remove(layerState._pointCollection);
|
|
layerState._native?.destroy();
|
|
if (layerState._renderHeld)
|
|
services.render.releaseContinuousRender('traffic');
|
|
layerState._renderHeld = false;
|
|
layerState._pointCollection =
|
|
layerState._viewer =
|
|
layerState._engine =
|
|
layerState._native =
|
|
null;
|
|
layerState._waitForScene ??= new Promise((resolve) => {
|
|
layerState._sceneReady = resolve;
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Enable the traffic layer. Shows the point collection, subscribes to the
|
|
* preRender animation loop and camera-change events, and kicks off an
|
|
* initial viewport check.
|
|
*
|
|
* @param {Cesium.Viewer} viewer - The Cesium viewer instance.
|
|
*/
|
|
enable(viewer, { signal } = {}) {
|
|
// The simulation's math is Cesium's on either globe: a Navara page
|
|
// loads the Cesium SDK first.
|
|
return whenCesiumSdk(() => {
|
|
if (layerState._enabled) return;
|
|
if (viewer) layerState._viewer = viewer;
|
|
layerState._enabled = true;
|
|
if (layerState._roadMode !== 'tomtom') source.prefetch?.();
|
|
bindScene();
|
|
// Enabling is explicit intent, not a camera gesture that needs settling.
|
|
parts.viewport.onCameraChanged({ immediate: true });
|
|
|
|
// Boot-order guard (field-test round 1: layer sat empty until the user
|
|
// moved): when the persisted layer state re-enables traffic during the
|
|
// intro flyTo, the initial check bails at high altitude — and a camera
|
|
// that then parks never re-fires camera.changed. Retry cheaply until the
|
|
// first load commits, then self-clear. Also acts as a safety kick if a
|
|
// failed first fetch left the viewport unloaded while parked.
|
|
clearInterval(layerState._enableKickTimer);
|
|
layerState._enableKickTimer = setInterval(() => {
|
|
if (
|
|
!layerState._enabled ||
|
|
layerState._lastUpdate ||
|
|
layerState._roadRetryStopped ||
|
|
layerState._retryAttempts >= 3
|
|
) {
|
|
clearInterval(layerState._enableKickTimer);
|
|
layerState._enableKickTimer = null;
|
|
return;
|
|
}
|
|
if (!layerState._fetching && !layerState._retryTimer)
|
|
parts.viewport.onCameraChanged();
|
|
}, 1500);
|
|
}, signal);
|
|
},
|
|
|
|
/**
|
|
* Disable the traffic layer. Cancels pending fetches, clears all dots,
|
|
* unsubscribes from events, and hides the point collection.
|
|
*
|
|
* @param {Cesium.Viewer} viewer - The Cesium viewer instance.
|
|
*/
|
|
disable(viewer) {
|
|
layerState._enabled = false;
|
|
layerState._surfaceInput = null;
|
|
services.credits?.hideOsmCredit?.(
|
|
layerState._engine ?? layerState._viewer,
|
|
'traffic',
|
|
);
|
|
parts.animation.syncRenderDemand();
|
|
clearTimeout(layerState._fetchTimeout);
|
|
clearInterval(layerState._enableKickTimer);
|
|
layerState._enableKickTimer = null;
|
|
clearTimeout(layerState._retryTimer);
|
|
layerState._retryTimer = null;
|
|
layerState._retryDelayMs = 1500;
|
|
parts.ingestion.cancelActiveFetch();
|
|
layerState._loadGeneration++;
|
|
layerState._fetching = false;
|
|
layerState._flowPending = 0;
|
|
layerState._roadError = null;
|
|
parts.animation.clearDots();
|
|
layerState._lastBounds = null;
|
|
layerState._lastViewCenter = null;
|
|
// A stale outage from the last session would misreport a fresh enable —
|
|
// the next load re-derives feed health from real evidence.
|
|
layerState._flowError = null;
|
|
layerState._flowStale = false;
|
|
layerState._flowOldestTileAt = null;
|
|
|
|
unbindScene();
|
|
if (layerState._pointCollection) layerState._pointCollection.show = false;
|
|
},
|
|
|
|
/**
|
|
* Permanently tear down the layer. Disables it, removes the point collection
|
|
* from the scene, and clears the tile cache.
|
|
*
|
|
* @param {Cesium.Viewer} viewer - The Cesium viewer instance.
|
|
*/
|
|
destroy(viewer) {
|
|
this.disable(viewer);
|
|
if (layerState._pointCollection) {
|
|
layerState._viewer?.scene.primitives.remove(
|
|
layerState._pointCollection,
|
|
);
|
|
layerState._native?.destroy();
|
|
layerState._native = null;
|
|
layerState._pointCollection = null;
|
|
}
|
|
parts.rendering.removeHeatLines();
|
|
layerState._tileCache.clear();
|
|
if (layerState._styleListenerBound && typeof window !== 'undefined') {
|
|
window.removeEventListener(
|
|
'gev:style-change',
|
|
layerState._styleListener,
|
|
);
|
|
layerState._styleListenerBound = false;
|
|
}
|
|
layerState._sceneReady?.();
|
|
layerState._waitForScene = layerState._sceneReady = null;
|
|
resetFlowTileCache();
|
|
layerState._count = 0;
|
|
layerState._lastUpdate = null;
|
|
},
|
|
};
|
|
|
|
return { methods };
|
|
}
|