mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 00:02:25 +00:00
Merge remote-tracking branch 'origin/main' into flights/course-from-fixes
# Conflicts: # docs/CURRENT-STATE.md # scripts/package-boundaries.json
This commit is contained in:
commit
d49552af57
14 files changed
+429
-22
No files matched your search
@@ -0,0 +1,3 @@
|
||||
### Changed
|
||||
|
||||
- While anything moves (layers in motion, the camera, a followed contact), the globe now draws at the display's own refresh rate instead of a fixed 60 frames a second. A parked scene still ticks at most 60 times a second. Waits that counted frames (a followed contact's first position, a shared follow view, a trail's temporary copy) now count drawn time, so they last the same at any refresh rate. Screen marks over a followed contact fade out over the same time at any refresh rate.
|
||||
@@ -10,6 +10,19 @@ or an older position from another feed) and one reported slower than 2 m/s
|
||||
give no course and keep the last; an aircraft with no course at all faces
|
||||
north.
|
||||
|
||||
While anything moves (a layer in motion, the camera, a followed contact), the
|
||||
globe draws at the display's own refresh rate; there is no fixed 60 FPS cap.
|
||||
The idle render governor (`src/renderGovernor.js`) caps a parked scene at
|
||||
`IDLE_FRAME_RATE` (60) ticks a second, because Cesium still runs the clock,
|
||||
data sources and update listeners on every animation frame even when it skips
|
||||
the draw; the viewer starts at that cap until the governor is installed. The
|
||||
camera holds continuous render from `moveStart` to `moveEnd`, and samples its
|
||||
pose every 250 ms in between, so a camera drifting by rounding errors (no
|
||||
`moveEnd`) is released after half a second at rest and held again if it moves. Waits that used to count frames (a followed contact's first
|
||||
position, a shared follow view, a trail's temporary copy) count drawn time
|
||||
through `src/time/frameWait.js`, at most 100 ms a frame, so they last the same
|
||||
at any refresh rate and a background tab does not use them up.
|
||||
|
||||
Docker Compose mounts the checkout with the shared SELinux `:z` label so
|
||||
containers can read it on enforcing SELinux hosts. The separate image-owned
|
||||
`node_modules` volume and loopback-only port publishing remain unchanged.
|
||||
|
||||
@@ -32,6 +32,10 @@ hardware-rendered overlay scenes.
|
||||
| 3 | 558.527 ms | 1,809.592 ms | 438.8 ms | 60 / 60 FPS | 105.1 MiB |
|
||||
| Median | 604.849 ms | 1,855.836 ms | 439.5 ms | 60 / 60 FPS | 105.1 MiB |
|
||||
|
||||
These frame rates were measured when the globe was capped at 60 FPS. It now
|
||||
draws at the display's refresh rate while anything moves and ticks at most 60
|
||||
times a second when parked (`src/renderGovernor.js`).
|
||||
|
||||
The initial-settle measurement is the more useful launch reference because it
|
||||
includes the first visual and data settling window. All three samples reached
|
||||
the display ceiling during both motion and rest.
|
||||
|
||||
@@ -1354,7 +1354,8 @@
|
||||
"src/ui/views/panels/WildlifeSightingCard.vue",
|
||||
"src/ui/wildlifeSightingPlacement.js",
|
||||
"src/overlays/worldOverlayChrome.js",
|
||||
"src/layers/wildlifeSightings/photoText.js"
|
||||
"src/layers/wildlifeSightings/photoText.js",
|
||||
"src/time/frameWait.js"
|
||||
],
|
||||
"external": ["cesium", "vue", "pinia", "vue-i18n"]
|
||||
},
|
||||
@@ -3843,7 +3844,8 @@
|
||||
"src/layers/vessels/photos.js",
|
||||
"src/layers/flights/placed.js",
|
||||
"src/data/placementProvider.js",
|
||||
"src/data/courseFromFixes.js"
|
||||
"src/data/courseFromFixes.js",
|
||||
"src/time/frameWait.js"
|
||||
],
|
||||
"external": [
|
||||
"hls.js",
|
||||
@@ -4570,7 +4572,8 @@
|
||||
"src/data/openVesselPhoto.js",
|
||||
"src/layers/flights/placed.js",
|
||||
"src/data/placementProvider.js",
|
||||
"src/data/courseFromFixes.js"
|
||||
"src/data/courseFromFixes.js",
|
||||
"src/time/frameWait.js"
|
||||
],
|
||||
"external": [
|
||||
"hls.js",
|
||||
|
||||
@@ -399,7 +399,12 @@ export function createScreenAnnotationRenderer(
|
||||
// from the host's ACTUAL painted rectangle after final layout; the billboard extent
|
||||
// is unioned for aircraft/satellites that also own a native tracked graphic.
|
||||
const TRACKED_BBOX_MARGIN = 8; // px buffer added around the footprint
|
||||
const TRACKED_FADE_EASE = 0.22; // per-frame ease toward hidden(0) / visible(1)
|
||||
// Ease toward hidden(0) / visible(1): this share of the gap closes in one
|
||||
// 60 Hz frame (about 200 ms to settle), scaled by elapsed time so the fade
|
||||
// takes as long at any refresh rate.
|
||||
const TRACKED_FADE_EASE = 0.22;
|
||||
const TRACKED_FADE_FRAME_MS = 1000 / 60;
|
||||
let trackedFadeAtMs = -Infinity;
|
||||
const TRACKED_HYSTERESIS_PX = 18; // dead-band so the overlap test can't flip-flop
|
||||
const _scratchTrackedWin = new Cesium.Cartesian2();
|
||||
|
||||
@@ -677,6 +682,14 @@ export function createScreenAnnotationRenderer(
|
||||
// safe and not jarring.
|
||||
function fadeTracked(trackedRect) {
|
||||
if (!shown()) return;
|
||||
const nowMs = performance.now();
|
||||
// A gap longer than a slow frame means the fade was not running (nothing
|
||||
// followed): it starts again as from one 60 Hz frame.
|
||||
const gapMs = nowMs - trackedFadeAtMs;
|
||||
const stepMs = gapMs >= 0 && gapMs <= 100 ? gapMs : TRACKED_FADE_FRAME_MS;
|
||||
trackedFadeAtMs = nowMs;
|
||||
const ease =
|
||||
1 - Math.pow(1 - TRACKED_FADE_EASE, stepMs / TRACKED_FADE_FRAME_MS);
|
||||
let changed = false;
|
||||
for (const rec of records.values()) {
|
||||
const { anno, group } = rec;
|
||||
@@ -705,10 +718,10 @@ export function createScreenAnnotationRenderer(
|
||||
}
|
||||
}
|
||||
const target = overlapping ? 0 : 1;
|
||||
const next = cur + (target - cur) * TRACKED_FADE_EASE;
|
||||
const next = cur + (target - cur) * ease;
|
||||
rec._trackedFade = Math.abs(next - target) < 0.02 ? target : next;
|
||||
// The base alpha applies unless faded. (The CSS `transition: opacity` was
|
||||
// removed from .gev-anno so this per-frame JS ease is the ONLY easing —
|
||||
// removed from .gev-anno so this JS ease is the ONLY easing —
|
||||
// previously the two fought and produced an opacity oscillation.)
|
||||
const opacity = String(
|
||||
(anno.alpha ?? 1) * (rec._trackedFade !== 1 ? rec._trackedFade : 1),
|
||||
|
||||
+4
-1
@@ -1,4 +1,5 @@
|
||||
import * as Cesium from 'cesium';
|
||||
import { IDLE_FRAME_RATE } from '../renderGovernor.js';
|
||||
import { applyModelAtmosphereWorkaround } from './atmosphereCompat.js';
|
||||
import { StarrySky } from '../sky/starrySky.js';
|
||||
import {
|
||||
@@ -420,7 +421,9 @@ export function createApplicationViewer({
|
||||
applicationViewerOptions(creditContainer, { showRenderLoopErrors }),
|
||||
);
|
||||
try {
|
||||
viewer.targetFrameRate = 60;
|
||||
// Until the render governor takes over (app/tools.js), tick at the idle
|
||||
// rate so the startup load does not compete with drawing at 240 fps.
|
||||
viewer.targetFrameRate = IDLE_FRAME_RATE;
|
||||
// A phone pinch spans fewer screen pixels than desktop zoom gestures.
|
||||
// Keep Cesium's distance-aware zoom and collision limits, with less travel
|
||||
// required on touch-first screens. Mouse/trackpad sensitivity stays native.
|
||||
|
||||
@@ -1,6 +1,8 @@
|
||||
import * as Cesium from 'cesium';
|
||||
import { createFrameWait } from '../time/frameWait.js';
|
||||
|
||||
const MAX_FRAME_ATTEMPTS = 120;
|
||||
/** Drawn time (ms) to wait for the tracked entity's first position. */
|
||||
const MAX_POSITION_WAIT_MS = 2_000;
|
||||
const MIN_TRACKED_RANGE_M = 150;
|
||||
const ZOOM_INERTIA_STATES = new WeakMap();
|
||||
|
||||
@@ -154,7 +156,7 @@ export function clampTrackedCameraPosition(
|
||||
*/
|
||||
export function applyTrackedCameraFrame(viewer, entity, viewFrom) {
|
||||
if (!viewer || !entity || !viewFrom) return;
|
||||
let attempts = 0;
|
||||
const positionWait = createFrameWait(MAX_POSITION_WAIT_MS);
|
||||
const trackedTransform = new Cesium.Matrix4();
|
||||
const trackedPosition = new Cesium.Cartesian3();
|
||||
const resolvedViewFrom = new Cesium.Cartesian3();
|
||||
@@ -184,7 +186,6 @@ export function applyTrackedCameraFrame(viewer, entity, viewFrom) {
|
||||
stop();
|
||||
return;
|
||||
}
|
||||
attempts += framed ? 0 : 1;
|
||||
// Prefer the display cache exposed by the flight layer. Calling the
|
||||
// CallbackProperty from preUpdate can advance dead reckoning again while
|
||||
// Cesium's billboard/label still holds the prior visualizer sample. At a
|
||||
@@ -198,7 +199,7 @@ export function applyTrackedCameraFrame(viewer, entity, viewFrom) {
|
||||
trackedPosition,
|
||||
);
|
||||
if (!position) {
|
||||
if (attempts >= MAX_FRAME_ATTEMPTS) stop();
|
||||
if (positionWait.tick()) stop();
|
||||
return;
|
||||
}
|
||||
const transform = Cesium.Transforms.eastNorthUpToFixedFrame(
|
||||
|
||||
@@ -33,6 +33,7 @@
|
||||
*/
|
||||
import * as Cesium from 'cesium';
|
||||
import { registerPickOwner } from './pickRegistry.js';
|
||||
import { createFrameWait } from '../time/frameWait.js';
|
||||
|
||||
// Round 6: trail ENTITIES are pickable (the old Primitive had
|
||||
// allowPicking:false). A trail hugs its aircraft, so an unclaimed pick would
|
||||
@@ -58,9 +59,9 @@ const MIN_SEGMENT_DISTANCE_SQ = 0.01;
|
||||
const NO_POSITIONS = Object.freeze([]);
|
||||
/** @constant {number} Points per chunk; adjacent chunks share one point. */
|
||||
export const CHUNK_POINTS = 128;
|
||||
/** @constant {number} Visible frames a frozen chunk's stand-in waits for its
|
||||
* static geometry before it is dropped anyway. */
|
||||
const STAND_IN_MAX_FRAMES = 600;
|
||||
/** @constant {number} Drawn time (ms) a frozen chunk's stand-in waits for its
|
||||
* static geometry while the trail is shown before it is dropped anyway. */
|
||||
const STAND_IN_MAX_MS = 10_000;
|
||||
|
||||
/**
|
||||
* Create an always-visible polyline trail bound to a viewer.
|
||||
@@ -80,7 +81,7 @@ export function createTrail(viewer, { color, width = 2.5 }) {
|
||||
const depthFailMaterial = baseColor.withAlpha(TRAIL_OCCLUDED_ALPHA);
|
||||
let destroyed = false;
|
||||
let visible = true;
|
||||
/** @type {{positions: Cesium.Cartesian3[], entity: Cesium.Entity, standIn: boolean, frames: number}[]} */
|
||||
/** @type {{positions: Cesium.Cartesian3[], entity: Cesium.Entity, standIn: boolean, wait: {tick: () => boolean, pause: () => void}}[]} */
|
||||
let frozen = [];
|
||||
/** Newest chunk of the newest segment: the only part that changes. */
|
||||
let tail = NO_POSITIONS;
|
||||
@@ -152,9 +153,11 @@ export function createTrail(viewer, { color, width = 2.5 }) {
|
||||
function staticReady(chunk) {
|
||||
const display = viewer.dataSourceDisplay;
|
||||
if (typeof display?.getBoundingSphere !== 'function') return true;
|
||||
if (!visible) return false;
|
||||
chunk.frames += 1;
|
||||
if (chunk.frames > STAND_IN_MAX_FRAMES) return true;
|
||||
if (!visible) {
|
||||
chunk.wait.pause();
|
||||
return false;
|
||||
}
|
||||
if (chunk.wait.tick()) return true;
|
||||
try {
|
||||
return (
|
||||
display.getBoundingSphere(chunk.entity, false, scratchSphere) ===
|
||||
@@ -262,7 +265,7 @@ export function createTrail(viewer, { color, width = 2.5 }) {
|
||||
positions,
|
||||
entity: addEntity(positions),
|
||||
standIn: true,
|
||||
frames: 0,
|
||||
wait: createFrameWait(STAND_IN_MAX_MS),
|
||||
});
|
||||
i = end;
|
||||
}
|
||||
|
||||
@@ -287,3 +287,38 @@ test('replacing the newest point and removing points inside the trail draws exac
|
||||
for (const run of drawnRuns(viewer))
|
||||
for (let i = 1; i < run.length; i++) assert.equal(next.get(run[i - 1]), run[i]);
|
||||
});
|
||||
|
||||
test('a stand-in is dropped after ten seconds of drawn time, whatever the frame rate', () => {
|
||||
const viewer = fakeViewer();
|
||||
const trail = createTrail(viewer, { color: '#ffffff' });
|
||||
const realNow = performance.now;
|
||||
let clock = 1_000;
|
||||
performance.now = () => clock;
|
||||
try {
|
||||
trail.setPositions(line(CHUNK_POINTS + 5));
|
||||
// 2,000 frames at 240 Hz is about 8.3 s: still waiting for the geometry.
|
||||
for (let i = 0; i < 2_000; i++) {
|
||||
viewer.frame();
|
||||
clock += 1000 / 240;
|
||||
}
|
||||
assert.equal(trail._chunksForTest().frozen[0].standIn, true);
|
||||
// Hidden time does not count toward the wait.
|
||||
trail.setVisible(false);
|
||||
clock += 60_000;
|
||||
viewer.frame();
|
||||
trail.setVisible(true);
|
||||
viewer.frame();
|
||||
assert.equal(trail._chunksForTest().frozen[0].standIn, true);
|
||||
// A background tab draws nothing: a long gap adds at most one frame step.
|
||||
clock += 60_000;
|
||||
viewer.frame();
|
||||
assert.equal(trail._chunksForTest().frozen[0].standIn, true);
|
||||
for (let i = 0; i < 480 && trail._chunksForTest().frozen[0].standIn; i++) {
|
||||
clock += 1000 / 240;
|
||||
viewer.frame();
|
||||
}
|
||||
assert.equal(trail._chunksForTest().frozen[0].standIn, false);
|
||||
} finally {
|
||||
performance.now = realNow;
|
||||
}
|
||||
});
|
||||
+110
-1
@@ -28,12 +28,24 @@
|
||||
* short stable strings ('flights', 'traffic', 'style-anim', …) so the
|
||||
* diagnostics read like a story.
|
||||
*
|
||||
* Frame rate: in continuous mode the viewer draws at the display's own
|
||||
* refresh rate (no `targetFrameRate`). In idle mode it is capped at
|
||||
* IDLE_FRAME_RATE, because Cesium still ticks the clock, data sources and
|
||||
* every pre/post-update listener once per animation frame even when it skips
|
||||
* the draw. Camera movement takes a 'camera' hold from `moveStart` to
|
||||
* `moveEnd`, so drags and flights run at the full rate too.
|
||||
*
|
||||
* The governor is O(1) passive: no per-frame work of its own, ever.
|
||||
*/
|
||||
|
||||
/** Frames a second the viewer ticks while nothing moves. */
|
||||
export const IDLE_FRAME_RATE = 60;
|
||||
|
||||
let _viewer = null;
|
||||
let _installed = false;
|
||||
const _holds = new Set();
|
||||
/** Removes the camera move listeners added at install. */
|
||||
let _removeCameraListeners = null;
|
||||
|
||||
/** Debug trail of the most recent one-shot render requests (idle mode only). */
|
||||
const _recentRequests = [];
|
||||
@@ -43,6 +55,7 @@ function applyMode() {
|
||||
if (!_installed || !_viewer?.scene) return;
|
||||
const continuous = _holds.size > 0;
|
||||
const scene = _viewer.scene;
|
||||
_viewer.targetFrameRate = continuous ? undefined : IDLE_FRAME_RATE;
|
||||
if (scene.requestRenderMode === !continuous) return;
|
||||
scene.requestRenderMode = !continuous;
|
||||
if (!continuous) {
|
||||
@@ -52,15 +65,101 @@ function applyMode() {
|
||||
}
|
||||
}
|
||||
|
||||
/** Pose sampling while the camera moves (see watchCameraMotion). */
|
||||
const CAMERA_SAMPLE_MS = 250;
|
||||
const CAMERA_POSITION_TOLERANCE_M = 1e-3;
|
||||
const CAMERA_DIRECTION_TOLERANCE = 1e-9;
|
||||
|
||||
function near(a, b, tolerance) {
|
||||
return (
|
||||
Math.abs(a.x - b.x) <= tolerance &&
|
||||
Math.abs(a.y - b.y) <= tolerance &&
|
||||
Math.abs(a.z - b.z) <= tolerance
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Hold continuous render while the camera moves. Cesium's `moveStart` takes
|
||||
* the hold and `moveEnd` releases it. Cesium compares the pose with the last
|
||||
* frame's to the last rounding error, and at some poses the camera drifts by
|
||||
* a rounding error every frame, so `moveEnd` never comes (see
|
||||
* `installGlobeInViewRecovery` in app/viewer.js). So from `moveStart` until
|
||||
* `moveEnd` the pose is also sampled every 250 ms with a tolerance for that
|
||||
* drift: half a second at rest releases the hold and a later move takes it
|
||||
* again (Cesium raises no new `moveStart` under that drift). Sampling runs
|
||||
* until `moveEnd`, however long that takes; it costs four checks a second.
|
||||
* @returns {(() => void)|null} Removes the listeners and the sampling.
|
||||
*/
|
||||
function watchCameraMotion(camera, { schedule, unschedule }) {
|
||||
if (!camera?.moveStart || !camera?.moveEnd) return null;
|
||||
const last = { position: null, direction: null };
|
||||
let timer = null;
|
||||
let restingSamples = 0;
|
||||
const copy = (v) => (v ? { x: v.x, y: v.y, z: v.z } : null);
|
||||
const remember = () => {
|
||||
last.position = copy(camera.positionWC);
|
||||
last.direction = copy(camera.directionWC);
|
||||
};
|
||||
const stopSampling = () => {
|
||||
if (timer !== null) unschedule(timer);
|
||||
timer = null;
|
||||
};
|
||||
const sample = () => {
|
||||
timer = null;
|
||||
const position = camera.positionWC;
|
||||
const direction = camera.directionWC;
|
||||
const atRest =
|
||||
!position ||
|
||||
!direction ||
|
||||
!last.position ||
|
||||
(near(position, last.position, CAMERA_POSITION_TOLERANCE_M) &&
|
||||
near(direction, last.direction, CAMERA_DIRECTION_TOLERANCE));
|
||||
if (atRest) {
|
||||
restingSamples += 1;
|
||||
if (restingSamples >= 2) releaseContinuousRender('camera');
|
||||
} else {
|
||||
restingSamples = 0;
|
||||
holdContinuousRender('camera');
|
||||
}
|
||||
remember();
|
||||
timer = schedule(sample, CAMERA_SAMPLE_MS);
|
||||
};
|
||||
const removeStart = camera.moveStart.addEventListener(() => {
|
||||
holdContinuousRender('camera');
|
||||
stopSampling();
|
||||
restingSamples = 0;
|
||||
remember();
|
||||
timer = schedule(sample, CAMERA_SAMPLE_MS);
|
||||
});
|
||||
const removeEnd = camera.moveEnd.addEventListener(() => {
|
||||
stopSampling();
|
||||
releaseContinuousRender('camera');
|
||||
});
|
||||
return () => {
|
||||
stopSampling();
|
||||
removeStart();
|
||||
removeEnd();
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Install the governor on the viewer. Idempotent. Before install,
|
||||
* hold/release still record into the holds set (and apply at install time);
|
||||
* requests are safe no-ops — so modules can call all three unconditionally
|
||||
* in tests without a viewer.
|
||||
* @param {Cesium.Viewer} viewer
|
||||
* @param {{setTimeout?: Function, clearTimeout?: Function}} [timers] Injectable
|
||||
* timers for tests.
|
||||
* @returns {void}
|
||||
*/
|
||||
export function installRenderGovernor(viewer) {
|
||||
export function installRenderGovernor(
|
||||
viewer,
|
||||
{
|
||||
setTimeout: schedule = globalThis.setTimeout,
|
||||
clearTimeout: unschedule = globalThis.clearTimeout,
|
||||
} = {},
|
||||
) {
|
||||
const timers = { schedule, unschedule };
|
||||
if (!viewer?.scene)
|
||||
throw new TypeError('installRenderGovernor requires a Cesium viewer');
|
||||
_viewer = viewer;
|
||||
@@ -69,6 +168,12 @@ export function installRenderGovernor(viewer) {
|
||||
// idle means idle. All re-renders are camera/tiles (Cesium-native) or
|
||||
// explicit requests.
|
||||
viewer.scene.maximumRenderTimeChange = Infinity;
|
||||
_removeCameraListeners?.();
|
||||
_holds.delete('camera');
|
||||
_removeCameraListeners = watchCameraMotion(
|
||||
viewer.camera ?? viewer.scene.camera,
|
||||
timers,
|
||||
);
|
||||
applyMode();
|
||||
}
|
||||
|
||||
@@ -132,6 +237,8 @@ export function getRenderGovernorDiagnostics() {
|
||||
/** Release the installed viewer after its animation owners have stopped. */
|
||||
export function uninstallRenderGovernor(viewer) {
|
||||
if (_viewer !== viewer) return;
|
||||
_removeCameraListeners?.();
|
||||
_removeCameraListeners = null;
|
||||
_viewer = null;
|
||||
_installed = false;
|
||||
_holds.clear();
|
||||
@@ -140,6 +247,8 @@ export function uninstallRenderGovernor(viewer) {
|
||||
|
||||
/** Test seam: reset module state between unit tests. */
|
||||
export function _resetRenderGovernorForTest() {
|
||||
_removeCameraListeners?.();
|
||||
_removeCameraListeners = null;
|
||||
_viewer = null;
|
||||
_installed = false;
|
||||
_holds.clear();
|
||||
|
||||
@@ -7,6 +7,8 @@ import {
|
||||
governorRequestRender,
|
||||
getRenderGovernorDiagnostics,
|
||||
_resetRenderGovernorForTest,
|
||||
uninstallRenderGovernor,
|
||||
IDLE_FRAME_RATE,
|
||||
} from './renderGovernor.js';
|
||||
|
||||
function makeViewer() {
|
||||
@@ -98,3 +100,132 @@ test('holds registered before install apply at install time', () => {
|
||||
releaseContinuousRender('flights');
|
||||
assert.equal(scene.requestRenderMode, true);
|
||||
});
|
||||
|
||||
function makeEvent() {
|
||||
const listeners = new Set();
|
||||
return {
|
||||
addEventListener(fn) {
|
||||
listeners.add(fn);
|
||||
return () => listeners.delete(fn);
|
||||
},
|
||||
raise() {
|
||||
for (const fn of [...listeners]) fn();
|
||||
},
|
||||
get size() {
|
||||
return listeners.size;
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
test('idle caps the frame rate; anything moving draws at the display rate', () => {
|
||||
const { viewer } = makeViewer();
|
||||
installRenderGovernor(viewer);
|
||||
assert.equal(viewer.targetFrameRate, IDLE_FRAME_RATE);
|
||||
holdContinuousRender('flights');
|
||||
assert.equal(viewer.targetFrameRate, undefined);
|
||||
releaseContinuousRender('flights');
|
||||
assert.equal(viewer.targetFrameRate, IDLE_FRAME_RATE);
|
||||
});
|
||||
|
||||
test('a camera move holds continuous render from moveStart to moveEnd', () => {
|
||||
const { viewer, scene } = makeViewer();
|
||||
viewer.camera = { moveStart: makeEvent(), moveEnd: makeEvent() };
|
||||
installRenderGovernor(viewer);
|
||||
viewer.camera.moveStart.raise();
|
||||
assert.equal(scene.requestRenderMode, false);
|
||||
assert.equal(viewer.targetFrameRate, undefined);
|
||||
assert.deepEqual(getRenderGovernorDiagnostics().holds, ['camera']);
|
||||
viewer.camera.moveEnd.raise();
|
||||
assert.equal(scene.requestRenderMode, true);
|
||||
assert.equal(viewer.targetFrameRate, IDLE_FRAME_RATE);
|
||||
// Installing again does not double the listeners; uninstall removes them.
|
||||
installRenderGovernor(viewer);
|
||||
assert.equal(viewer.camera.moveStart.size, 1);
|
||||
uninstallRenderGovernor(viewer);
|
||||
assert.equal(viewer.camera.moveStart.size, 0);
|
||||
assert.equal(viewer.camera.moveEnd.size, 0);
|
||||
});
|
||||
|
||||
function fakeTimers() {
|
||||
const queue = new Map();
|
||||
let next = 1;
|
||||
return {
|
||||
setTimeout: (fn) => {
|
||||
queue.set(next, fn);
|
||||
return next++;
|
||||
},
|
||||
clearTimeout: (id) => queue.delete(id),
|
||||
run() {
|
||||
const due = [...queue.entries()];
|
||||
queue.clear();
|
||||
for (const [, fn] of due) fn();
|
||||
},
|
||||
get pending() {
|
||||
return queue.size;
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
test('a camera that drifts by rounding errors and never raises moveEnd still releases its hold', () => {
|
||||
const { viewer, scene } = makeViewer();
|
||||
const timers = fakeTimers();
|
||||
viewer.camera = {
|
||||
moveStart: makeEvent(),
|
||||
moveEnd: makeEvent(),
|
||||
positionWC: { x: 6_400_000, y: 0, z: 0 },
|
||||
directionWC: { x: -1, y: 0, z: 0 },
|
||||
};
|
||||
installRenderGovernor(viewer, timers);
|
||||
viewer.camera.moveStart.raise();
|
||||
assert.equal(scene.requestRenderMode, false);
|
||||
// Still moving: the hold stays.
|
||||
viewer.camera.positionWC = { x: 6_399_000, y: 0, z: 0 };
|
||||
timers.run();
|
||||
assert.equal(scene.requestRenderMode, false);
|
||||
// Drifting by far less than a millimetre: half a second of this is at rest.
|
||||
viewer.camera.positionWC = { x: 6_399_000 + 1e-7, y: 0, z: 0 };
|
||||
timers.run();
|
||||
timers.run();
|
||||
assert.equal(scene.requestRenderMode, true);
|
||||
assert.equal(viewer.targetFrameRate, IDLE_FRAME_RATE);
|
||||
// A later move with no new moveStart takes the hold again.
|
||||
viewer.camera.positionWC = { x: 6_000_000, y: 0, z: 0 };
|
||||
timers.run();
|
||||
assert.equal(scene.requestRenderMode, false);
|
||||
// moveEnd stops the sampling and releases.
|
||||
viewer.camera.moveEnd.raise();
|
||||
assert.equal(scene.requestRenderMode, true);
|
||||
assert.equal(timers.pending, 0);
|
||||
});
|
||||
|
||||
test('sampling keeps running until moveEnd, so a move after a long drift still takes the hold', () => {
|
||||
const { viewer, scene } = makeViewer();
|
||||
const timers = fakeTimers();
|
||||
viewer.camera = {
|
||||
moveStart: makeEvent(),
|
||||
moveEnd: makeEvent(),
|
||||
positionWC: { x: 1, y: 0, z: 0 },
|
||||
directionWC: { x: -1, y: 0, z: 0 },
|
||||
};
|
||||
installRenderGovernor(viewer, timers);
|
||||
viewer.camera.moveStart.raise();
|
||||
// Ten minutes at rest (2,400 samples): released, still sampling.
|
||||
for (let i = 0; i < 2_400; i++) timers.run();
|
||||
assert.equal(scene.requestRenderMode, true);
|
||||
assert.equal(timers.pending, 1);
|
||||
viewer.camera.positionWC = { x: 1_000, y: 0, z: 0 };
|
||||
timers.run();
|
||||
assert.equal(scene.requestRenderMode, false);
|
||||
});
|
||||
|
||||
test('installing again drops a camera hold the old listeners can no longer release', () => {
|
||||
const { viewer, scene } = makeViewer();
|
||||
const timers = fakeTimers();
|
||||
viewer.camera = { moveStart: makeEvent(), moveEnd: makeEvent() };
|
||||
installRenderGovernor(viewer, timers);
|
||||
viewer.camera.moveStart.raise();
|
||||
assert.equal(scene.requestRenderMode, false);
|
||||
installRenderGovernor(viewer, timers);
|
||||
assert.equal(scene.requestRenderMode, true);
|
||||
assert.equal(timers.pending, 0);
|
||||
});
|
||||
@@ -0,0 +1,37 @@
|
||||
/**
|
||||
* A wait measured in time spent drawing frames, the same at any display
|
||||
* refresh rate.
|
||||
*
|
||||
* Each call to `tick()` adds the time since the previous call, but at most
|
||||
* MAX_STEP_MS, so a background tab, a parked scene or a hidden owner (which
|
||||
* draw no frames for this wait) does not use the wait up while nothing is on
|
||||
* screen.
|
||||
*/
|
||||
|
||||
/** The most one frame may add to a wait, in milliseconds. */
|
||||
export const MAX_STEP_MS = 100;
|
||||
|
||||
/**
|
||||
* Start a wait of `limitMs` drawn time.
|
||||
* @param {number} limitMs How long to wait, in milliseconds.
|
||||
* @param {() => number} [now] Clock in milliseconds.
|
||||
* @returns {{tick: () => boolean, pause: () => void}} `tick()` counts one
|
||||
* drawn frame and answers whether the wait is over; `pause()` makes the
|
||||
* next tick count nothing for the gap since the last one.
|
||||
*/
|
||||
export function createFrameWait(limitMs, now = () => performance.now()) {
|
||||
let waitedMs = 0;
|
||||
let lastMs = NaN;
|
||||
return {
|
||||
tick() {
|
||||
const at = now();
|
||||
if (Number.isFinite(lastMs))
|
||||
waitedMs += Math.min(Math.max(at - lastMs, 0), MAX_STEP_MS);
|
||||
lastMs = at;
|
||||
return waitedMs >= limitMs;
|
||||
},
|
||||
pause() {
|
||||
lastMs = NaN;
|
||||
},
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,49 @@
|
||||
import { test } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import { createFrameWait, MAX_STEP_MS } from './frameWait.js';
|
||||
|
||||
function clock() {
|
||||
let at = 0;
|
||||
return { now: () => at, advance: (ms) => (at += ms) };
|
||||
}
|
||||
|
||||
test('the wait lasts the same time at 60 and 240 frames a second', () => {
|
||||
for (const hz of [60, 240]) {
|
||||
const c = clock();
|
||||
const wait = createFrameWait(2_000, c.now);
|
||||
let frames = 0;
|
||||
while (!wait.tick()) {
|
||||
c.advance(1000 / hz);
|
||||
frames += 1;
|
||||
}
|
||||
assert.ok(Math.abs(c.now() - 2_000) <= 1000 / hz + 1e-6, `${hz} Hz ended at ${c.now()}`);
|
||||
assert.ok(frames > 0);
|
||||
}
|
||||
});
|
||||
|
||||
test('a long gap between frames adds at most one step', () => {
|
||||
const c = clock();
|
||||
const wait = createFrameWait(2_000, c.now);
|
||||
wait.tick();
|
||||
c.advance(60_000);
|
||||
assert.equal(wait.tick(), false, 'a background tab does not use the wait up');
|
||||
let drawnMs = MAX_STEP_MS;
|
||||
while (!wait.tick()) {
|
||||
c.advance(16);
|
||||
drawnMs += 16;
|
||||
}
|
||||
assert.ok(drawnMs >= 2_000 && drawnMs < 2_000 + 16 + MAX_STEP_MS);
|
||||
});
|
||||
|
||||
test('after pause the next tick adds nothing', () => {
|
||||
const c = clock();
|
||||
const wait = createFrameWait(150, c.now);
|
||||
wait.tick();
|
||||
c.advance(90);
|
||||
wait.tick();
|
||||
wait.pause();
|
||||
c.advance(90);
|
||||
assert.equal(wait.tick(), false);
|
||||
c.advance(60);
|
||||
assert.equal(wait.tick(), true);
|
||||
});
|
||||
@@ -1,5 +1,6 @@
|
||||
import * as Cesium from 'cesium';
|
||||
import { trackedDisplayPositionForCamera } from '../data/trackedCamera.js';
|
||||
import { createFrameWait } from '../time/frameWait.js';
|
||||
import {
|
||||
SHARE_VIEW_ENTITY_KINDS,
|
||||
SHARE_VIEW_FOLLOW_RANGE_MAX_M,
|
||||
@@ -17,7 +18,8 @@ import {
|
||||
const KIND_BY_LAYER = new Map(
|
||||
SHARE_VIEW_ENTITY_KINDS.map((entry) => [entry.layerId, entry.kind]),
|
||||
);
|
||||
const MAX_FRAMES = 120;
|
||||
/** Drawn time (ms) to wait for the follow to frame the entity. */
|
||||
const MAX_FRAMING_WAIT_MS = 2_000;
|
||||
|
||||
/** `position`'s local east/north/up offset from `origin`, in metres. */
|
||||
function enuOffset(origin, position) {
|
||||
@@ -136,6 +138,7 @@ export function applyShareFollowOffset(viewer, entity, offset) {
|
||||
return () => {};
|
||||
const local = followOffsetToEnu(offset);
|
||||
let frames = 0;
|
||||
const framingWait = createFrameWait(MAX_FRAMING_WAIT_MS);
|
||||
let remove = null;
|
||||
const stop = () => {
|
||||
remove?.();
|
||||
@@ -160,7 +163,7 @@ export function applyShareFollowOffset(viewer, entity, offset) {
|
||||
)
|
||||
: null;
|
||||
if (!target) {
|
||||
if (frames >= MAX_FRAMES) stop();
|
||||
if (framingWait.tick()) stop();
|
||||
return;
|
||||
}
|
||||
// The offset is east/north/up at the entity; the follow's own frame may
|
||||
|
||||
Reference in new issue
Block a user