mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-19 01:32:19 +00:00
The far-zoom heatmap now uses the ½× grid (4096 × 2048, ≈10 km per pixel, one-pixel blur), so a lone fire's spot matches its marker at the 3,000 km hand-off. The spot size slider and its share option are gone. Markers and heatmap are both kept built at every zoom and cross-fade by camera height between 2,400 and 3,600 km on every frame, so a fast zoom never shows a beat with neither. The heatmap fades by imagery alpha: hiding a Cesium imagery layer unmaps it from the globe tiles, and showing it again re-mapped them late, which was the gap at the band edge. Under the markers the heatmap is built 150 ms after the data or filter changes.
220 lines
7.8 KiB
JavaScript
220 lines
7.8 KiB
JavaScript
import * as Cesium from 'cesium';
|
|
import {
|
|
LOD_LEVELS,
|
|
LOD_HYSTERESIS,
|
|
VIEW_PADDING,
|
|
LOD_CHECK_MS,
|
|
} from './policy.js';
|
|
|
|
export function createViewport({
|
|
layerState,
|
|
services,
|
|
components,
|
|
config,
|
|
feed,
|
|
}) {
|
|
const { governorRequestRender } = services.render;
|
|
|
|
/**
|
|
* Ambient labels are placed via screen-space projection, so they need a
|
|
* re-declutter after the camera settles — on moveEnd, never per frame.
|
|
*/
|
|
|
|
function installMoveEndWatcher() {
|
|
if (layerState._moveEndRemover || !layerState._viewer) return;
|
|
layerState._moveEndRemover =
|
|
layerState._viewer.camera.moveEnd.addEventListener(() => {
|
|
if (!layerState._enabled) return;
|
|
// Settled-camera exactness for the horizon pass (the throttled preRender
|
|
// watcher can last have run up to LOD_CHECK_MS before the camera
|
|
// stopped). Runs ahead of the `_loading` gate on purpose: the sprites on
|
|
// screen during a refresh are the ones that need culling.
|
|
components.rendering.refreshHorizonCulling();
|
|
if (layerState._loading) return;
|
|
components.cards.rebuildAmbientLabels();
|
|
});
|
|
}
|
|
|
|
function removeMoveEndWatcher() {
|
|
if (layerState._moveEndRemover) {
|
|
layerState._moveEndRemover();
|
|
layerState._moveEndRemover = null;
|
|
}
|
|
}
|
|
|
|
function cameraHeight() {
|
|
return (
|
|
layerState._viewer?.camera?.positionCartographic?.height ??
|
|
Number.POSITIVE_INFINITY
|
|
);
|
|
}
|
|
|
|
/** Raw LOD index for a camera height (0 = global ... 3 = close). */
|
|
|
|
function rawLodIndex(height) {
|
|
const index = LOD_LEVELS.findIndex((level) => height >= level.minHeight);
|
|
return index === -1 ? LOD_LEVELS.length - 1 : index;
|
|
}
|
|
|
|
/**
|
|
* LOD selection with ±10% hysteresis around band floors: a band switch
|
|
* only happens once the camera clears the boundary by the margin, so a
|
|
* slow zoom oscillating on an edge cannot trigger a rebuild every check.
|
|
* @param {number} height - Camera height in meters.
|
|
* @returns {number} LOD index to render.
|
|
*/
|
|
|
|
function selectLodIndex(height) {
|
|
const raw = rawLodIndex(height);
|
|
if (layerState._currentLodIndex < 0 || raw === layerState._currentLodIndex)
|
|
return raw;
|
|
let index = layerState._currentLodIndex;
|
|
// Zooming out: enter a coarser band only after clearing its floor by +10%.
|
|
while (
|
|
index > raw &&
|
|
height >= LOD_LEVELS[index - 1].minHeight * (1 + LOD_HYSTERESIS)
|
|
)
|
|
index -= 1;
|
|
// Zooming in: leave the current band only after dropping 10% below its floor.
|
|
while (
|
|
index < raw &&
|
|
height <= LOD_LEVELS[index].minHeight * (1 - LOD_HYSTERESIS)
|
|
)
|
|
index += 1;
|
|
return index;
|
|
}
|
|
|
|
/** Current camera view rectangle, or null when looking at sky/horizon. */
|
|
|
|
function computeViewRect() {
|
|
try {
|
|
const rect = layerState._viewer?.camera?.computeViewRectangle(
|
|
layerState._viewer?.scene?.globe?.ellipsoid,
|
|
layerState.scratchViewRect,
|
|
);
|
|
return rect || null;
|
|
} catch {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* True when the camera view rectangle drifted far enough from the last
|
|
* rendered one that the padding is at risk of being consumed (pan) or
|
|
* the footprint changed notably (zoom within a band).
|
|
* @param {?Cesium.Rectangle} viewRect - Current view rectangle.
|
|
* @returns {boolean}
|
|
*/
|
|
|
|
function viewChangedEnough(viewRect) {
|
|
if (!viewRect) return false; // sky/horizon — keep the current render
|
|
if (!layerState._lastViewRect) return true; // previous render was global fallback
|
|
const lastWidth = Cesium.Rectangle.computeWidth(layerState._lastViewRect);
|
|
const lastHeight = Cesium.Rectangle.computeHeight(layerState._lastViewRect);
|
|
const width = Cesium.Rectangle.computeWidth(viewRect);
|
|
const height = Cesium.Rectangle.computeHeight(viewRect);
|
|
if (width > lastWidth * 1.3 || width < lastWidth * 0.75) return true;
|
|
if (height > lastHeight * 1.3 || height < lastHeight * 0.75) return true;
|
|
const lastCenter = Cesium.Rectangle.center(
|
|
layerState._lastViewRect,
|
|
layerState.scratchCenterA,
|
|
);
|
|
const center = Cesium.Rectangle.center(viewRect, layerState.scratchCenterB);
|
|
const latShift = Math.abs(center.latitude - lastCenter.latitude);
|
|
let lonShift = Math.abs(center.longitude - lastCenter.longitude);
|
|
if (lonShift > Math.PI) lonShift = Cesium.Math.TWO_PI - lonShift;
|
|
return (
|
|
latShift > lastHeight * VIEW_PADDING * 0.6 ||
|
|
lonShift > lastWidth * VIEW_PADDING * 0.6
|
|
);
|
|
}
|
|
|
|
function installLodWatcher() {
|
|
if (layerState._preRenderRemover || !layerState._viewer) return;
|
|
// The LOD sweep is throttle-gated inside preRender. When the camera
|
|
// settles just inside the throttle window, the final rebuild would wait
|
|
// for a frame that idle mode never produces — schedule one. (perf wave 2)
|
|
if (!layerState._moveEndSettleRemover) {
|
|
layerState._moveEndSettleRemover =
|
|
layerState._viewer.camera.moveEnd.addEventListener(() => {
|
|
if (!layerState._enabled) return;
|
|
setTimeout(
|
|
() => governorRequestRender('firms-lod-settle'),
|
|
LOD_CHECK_MS + 40,
|
|
);
|
|
});
|
|
}
|
|
layerState._preRenderRemover =
|
|
layerState._viewer.scene.preRender.addEventListener(() => {
|
|
// NOTE: `_loading`/empty-data are deliberately NOT part of this guard.
|
|
// A refresh has no timeout, and sprites from the previous payload stay
|
|
// on screen throughout it — so the horizon pass below must keep running
|
|
// while a fetch is in flight. Only the rebuild is gated on fresh data.
|
|
if (!layerState._enabled) return;
|
|
// Every frame, ahead of the throttle: a fast zoom crosses the whole
|
|
// hand-off between two band checks.
|
|
components.rendering.applyHandoffFade();
|
|
const now = performance.now();
|
|
if (now - layerState._lastLodCheck < LOD_CHECK_MS) return;
|
|
layerState._lastLodCheck = now;
|
|
// Idle camera: two scratch compares and out — no view-rect math, no
|
|
// aggregation, no allocation while the user is parked.
|
|
const camera = layerState._viewer.camera;
|
|
if (
|
|
layerState._camSnapValid &&
|
|
Cesium.Cartesian3.equalsEpsilon(
|
|
camera.positionWC,
|
|
layerState._camPos,
|
|
0,
|
|
0.5,
|
|
) &&
|
|
Cesium.Cartesian3.equalsEpsilon(
|
|
camera.directionWC,
|
|
layerState._camDir,
|
|
0,
|
|
1e-7,
|
|
)
|
|
) {
|
|
return;
|
|
}
|
|
Cesium.Cartesian3.clone(camera.positionWC, layerState._camPos);
|
|
Cesium.Cartesian3.clone(camera.directionWC, layerState._camDir);
|
|
layerState._camSnapValid = true;
|
|
// The camera moved, so the horizon moved. A rebuild culls its own fresh
|
|
// sprites (renderDetections); an early-out — same LOD band and view
|
|
// rect, or a refresh in flight — does not, so cull here instead.
|
|
// Exactly ONE occlusion walk per tick either way, bounded by the
|
|
// idle-gate + LOD_CHECK_MS throttle above: a parked camera costs
|
|
// nothing, a moving one pays one ≤maxDetections show-flip walk at
|
|
// ~1.5 Hz.
|
|
const rebuilt =
|
|
layerState._fires.length && !layerState._loading
|
|
? components.rendering.renderCurrentLod(false)
|
|
: false;
|
|
if (!rebuilt) components.rendering.refreshHorizonCulling();
|
|
});
|
|
}
|
|
|
|
function removeLodWatcher() {
|
|
if (layerState._preRenderRemover) {
|
|
layerState._preRenderRemover();
|
|
layerState._preRenderRemover = null;
|
|
}
|
|
if (layerState._moveEndSettleRemover) {
|
|
layerState._moveEndSettleRemover();
|
|
layerState._moveEndSettleRemover = null;
|
|
}
|
|
}
|
|
return {
|
|
installMoveEndWatcher,
|
|
removeMoveEndWatcher,
|
|
cameraHeight,
|
|
rawLodIndex,
|
|
selectLodIndex,
|
|
computeViewRect,
|
|
viewChangedEnough,
|
|
installLodWatcher,
|
|
removeLodWatcher,
|
|
};
|
|
}
|