mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-17 16:52:20 +00:00
perf(terrain): one shared, cached and budgeted terrain height reader for Transit, Rail, Bike Share and local data
globe.getHeight is a ray cast against the drawn tile's mesh and scene.sampleHeight a GPU depth render; several layers asked for them uncached and unbudgeted. The cache written for Transit moves to src/services/terrainSurface.js and is handed to every layer through the ground service, so layers share one cache and one read budget. - Rail reads each train on a ~4 m grid instead of every frame. - Local data layers read terrain floors through it and stop depth samples at 8 ms a frame. - Bike Share draws stations at once and finds their heights afterwards in 4 ms steps. Co-Authored-By: Claude Fable 5.2 <[email protected]>
This commit is contained in:
1 parent
d5f7926c7e
commit
0f4dda5cc6
22 files changed
+1257
-263
No files matched your search
@@ -0,0 +1,254 @@
|
||||
import * as Cesium from 'cesium';
|
||||
|
||||
/**
|
||||
* The height of the terrain globe's loaded surface at a point, kept per point
|
||||
* and read within a time budget.
|
||||
*
|
||||
* `globe.getHeight` casts a ray against the mesh of the tile drawn under the
|
||||
* point: geometry work, not a table lookup, and dearer the finer the tile. A
|
||||
* layer that asks for every vehicle, trail fix or site on every pass asks the
|
||||
* same few thousand points over and over, so the answers are kept and the
|
||||
* reads are rationed. One instance serves every layer of an application, so
|
||||
* the layers share one budget instead of each spending its own.
|
||||
*/
|
||||
|
||||
/**
|
||||
* While the camera moves or tiles load, a kept height is reused this long
|
||||
* before the point is read again.
|
||||
*/
|
||||
export const TERRAIN_HEIGHT_FRESH_MS = 2_000;
|
||||
/**
|
||||
* A height read once the camera has been still and the globe's tiles loaded
|
||||
* for this long is kept until either changes: the globe draws a point from
|
||||
* another tile only after one of them does.
|
||||
*/
|
||||
export const TERRAIN_SETTLE_MS = 5_000;
|
||||
/** Read budgets are counted over windows of this length. */
|
||||
export const TERRAIN_READ_WINDOW_MS = 200;
|
||||
/**
|
||||
* Milliseconds of terrain reads in one window. Past it a point never read
|
||||
* takes the last height read in its ~111 m floor cell, or waits for a later
|
||||
* request; a MARKER point is read regardless.
|
||||
*/
|
||||
export const TERRAIN_READ_BUDGET_MS = 16;
|
||||
/**
|
||||
* The share of that budget re-reads of kept points may use, the longest-kept
|
||||
* first, leaving the rest for points never read.
|
||||
*/
|
||||
export const TERRAIN_REFRESH_BUDGET_MS = 12;
|
||||
/**
|
||||
* How much a height matters to what is drawn, lowest first. BACKGROUND is a
|
||||
* point nobody is looking at (the undrawn trail history of a vehicle) and may
|
||||
* use a quarter of each budget; PATH is drawn geometry; MARKER is a thing's
|
||||
* own position, read even when the window's budget is spent, since a marker
|
||||
* without a height is not drawn.
|
||||
*/
|
||||
export const TERRAIN_NEED = Object.freeze({
|
||||
BACKGROUND: 0,
|
||||
PATH: 1,
|
||||
MARKER: 2,
|
||||
});
|
||||
/** Points kept; the oldest quarter is dropped past it. */
|
||||
export const TERRAIN_HEIGHT_CACHE_MAX = 60_000;
|
||||
|
||||
/** A number unique to a point on a `scale`-per-degree grid. */
|
||||
function gridKey(lat, lon, scale) {
|
||||
return (
|
||||
(Math.round(lat * scale) + 90 * scale) * (360 * scale + 1) +
|
||||
Math.round(lon * scale) +
|
||||
180 * scale
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* @returns {{
|
||||
* height: (viewer: object, lat: number, lon: number, need?: number) => number|undefined,
|
||||
* observe: (viewer: object) => void,
|
||||
* waitingCount: () => number,
|
||||
* stats: () => {reads: number, reused: number, deferred: number, borrowed: number, held: number},
|
||||
* clear: () => void,
|
||||
* }}
|
||||
*/
|
||||
export function createTerrainSurface() {
|
||||
const point = new Cesium.Cartographic();
|
||||
/** Point key → `{ h, at }`: the height read there and when. */
|
||||
const heights = new Map();
|
||||
/** Floor-cell key → the last height read anywhere in that cell. */
|
||||
const cells = new Map();
|
||||
let globeRead = null;
|
||||
let windowAt = -Infinity;
|
||||
let readMs = 0;
|
||||
let refreshMs = 0;
|
||||
// Per need (background, path): the oldest read among the points this window
|
||||
// left for later, and the bound the next window re-reads up to.
|
||||
const deferredAt = [Infinity, Infinity];
|
||||
const refreshUpTo = [Infinity, Infinity];
|
||||
let waiting = 0;
|
||||
/** When the camera last moved or the globe was last loading tiles. */
|
||||
let changedAt = -Infinity;
|
||||
let cameraLon = NaN,
|
||||
cameraLat = NaN,
|
||||
cameraHeight = NaN;
|
||||
const counters = { reads: 0, reused: 0, deferred: 0, borrowed: 0 };
|
||||
|
||||
function clear() {
|
||||
heights.clear();
|
||||
cells.clear();
|
||||
globeRead = null;
|
||||
windowAt = -Infinity;
|
||||
readMs = refreshMs = 0;
|
||||
deferredAt.fill(Infinity);
|
||||
refreshUpTo.fill(Infinity);
|
||||
changedAt = -Infinity;
|
||||
cameraLon = cameraLat = cameraHeight = NaN;
|
||||
}
|
||||
|
||||
/**
|
||||
* The globe redraws a point from another tile only after the camera moves
|
||||
* or a tile arrives: note when either was last seen.
|
||||
*/
|
||||
function noteChange(viewer, globe, now) {
|
||||
const camera = viewer.camera?.positionCartographic;
|
||||
if (
|
||||
globe.tilesLoaded === false ||
|
||||
camera?.longitude !== cameraLon ||
|
||||
camera?.latitude !== cameraLat ||
|
||||
camera?.height !== cameraHeight
|
||||
) {
|
||||
changedAt = now;
|
||||
cameraLon = camera?.longitude;
|
||||
cameraLat = camera?.latitude;
|
||||
cameraHeight = camera?.height;
|
||||
}
|
||||
}
|
||||
|
||||
/** The viewer's terrain globe, the one whose heights are held, or null. */
|
||||
function terrainGlobe(viewer) {
|
||||
const globe = viewer?.scene?.globe;
|
||||
if (globe?.show !== true || typeof globe.getHeight !== 'function')
|
||||
return null;
|
||||
// Another globe's surface is another surface.
|
||||
if (globe !== globeRead) {
|
||||
clear();
|
||||
globeRead = globe;
|
||||
}
|
||||
return globe;
|
||||
}
|
||||
|
||||
/**
|
||||
* Look at the camera and the globe's tile loading without asking for a
|
||||
* height. The surface only sees a change when it is asked something, so a
|
||||
* caller that asks nothing while tiles load (it waits for them) calls this
|
||||
* on its own walk; otherwise the load would pass unseen and the heights
|
||||
* kept from before it would never be read again.
|
||||
* @param {object} viewer
|
||||
*/
|
||||
function observe(viewer) {
|
||||
const globe = terrainGlobe(viewer);
|
||||
if (globe) noteChange(viewer, globe, performance.now());
|
||||
}
|
||||
|
||||
/**
|
||||
* The loaded terrain's height at a point, in metres above the ellipsoid, or
|
||||
* undefined when it is not known yet or the viewer has no terrain globe
|
||||
* showing. A point read within the reuse time answers from memory, and so
|
||||
* does one read after the camera and the globe's tiles had settled: the
|
||||
* surface under it cannot have changed since. Past the window's budget a
|
||||
* kept point keeps its last height and a new point borrows its floor
|
||||
* cell's. Requests tend to come in the same order every pass, so re-reads
|
||||
* go to the longest-kept points first: otherwise the first few would be
|
||||
* re-read forever and the rest never.
|
||||
* @param {object} viewer The Cesium viewer whose globe is read.
|
||||
* @param {number} lat Degrees.
|
||||
* @param {number} lon Degrees.
|
||||
* @param {number} [need] How much the answer matters; see TERRAIN_NEED.
|
||||
*/
|
||||
function height(viewer, lat, lon, need = TERRAIN_NEED.PATH) {
|
||||
const globe = terrainGlobe(viewer);
|
||||
if (!globe) return undefined;
|
||||
const now = performance.now();
|
||||
if (now - windowAt >= TERRAIN_READ_WINDOW_MS) {
|
||||
for (let i = 0; i < deferredAt.length; i++) {
|
||||
refreshUpTo[i] = deferredAt[i];
|
||||
deferredAt[i] = Infinity;
|
||||
}
|
||||
windowAt = now;
|
||||
readMs = refreshMs = 0;
|
||||
noteChange(viewer, globe, now);
|
||||
}
|
||||
const key = gridKey(lat, lon, 1e5);
|
||||
const held = heights.get(key);
|
||||
if (
|
||||
held &&
|
||||
(now - held.at < TERRAIN_HEIGHT_FRESH_MS ||
|
||||
held.at >= changedAt + TERRAIN_SETTLE_MS)
|
||||
) {
|
||||
counters.reused++;
|
||||
return held.h;
|
||||
}
|
||||
const cellKey = gridKey(lat, lon, 1e3);
|
||||
const marker = need === TERRAIN_NEED.MARKER;
|
||||
// Background may use a quarter of each budget; drawn geometry the rest.
|
||||
const share = need === TERRAIN_NEED.BACKGROUND ? 0.25 : 1;
|
||||
const affordable =
|
||||
marker && !held
|
||||
? true
|
||||
: readMs < TERRAIN_READ_BUDGET_MS * (marker ? 1 : share) &&
|
||||
(!held ||
|
||||
marker ||
|
||||
(refreshMs < TERRAIN_REFRESH_BUDGET_MS * share &&
|
||||
held.at <= refreshUpTo[need]));
|
||||
if (!affordable) {
|
||||
counters.deferred++;
|
||||
if (held) {
|
||||
if (!marker && held.at < deferredAt[need]) deferredAt[need] = held.at;
|
||||
waiting++;
|
||||
return held.h;
|
||||
}
|
||||
const borrowed = cells.get(cellKey);
|
||||
if (borrowed !== undefined) {
|
||||
counters.borrowed++;
|
||||
return borrowed;
|
||||
}
|
||||
waiting++;
|
||||
return undefined;
|
||||
}
|
||||
Cesium.Cartographic.fromDegrees(lon, lat, 0, point);
|
||||
const rendered = globe.getHeight(point);
|
||||
const spent = performance.now() - now;
|
||||
readMs += spent;
|
||||
if (held) refreshMs += spent;
|
||||
counters.reads++;
|
||||
// A tile that left the globe keeps the height it gave.
|
||||
if (!Number.isFinite(rendered)) return held?.h;
|
||||
if (held) {
|
||||
held.h = rendered;
|
||||
held.at = now;
|
||||
} else {
|
||||
if (heights.size >= TERRAIN_HEIGHT_CACHE_MAX) {
|
||||
let drop = TERRAIN_HEIGHT_CACHE_MAX >> 2;
|
||||
for (const old of heights.keys()) {
|
||||
heights.delete(old);
|
||||
if (--drop <= 0) break;
|
||||
}
|
||||
cells.clear();
|
||||
}
|
||||
heights.set(key, { h: rendered, at: now });
|
||||
}
|
||||
cells.set(cellKey, rendered);
|
||||
return rendered;
|
||||
}
|
||||
|
||||
return {
|
||||
height,
|
||||
observe,
|
||||
/**
|
||||
* Requests so far that were left unread or due a re-read. A caller that
|
||||
* reads it before and after its own pass learns whether to come back.
|
||||
*/
|
||||
waitingCount: () => waiting,
|
||||
/** Read counters since creation, for checks. */
|
||||
stats: () => ({ ...counters, held: heights.size }),
|
||||
clear,
|
||||
};
|
||||
}
|
||||
Reference in new issue
Block a user