mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-19 09:42:21 +00:00
Three fixes to how the globe draws and reports loading. **The idle frame rate is the app's rule.** The Cesium frame port capped the loop at `IDLE_FRAME_RATE` whenever nothing held it, so the rule lived inside the renderer. The render governor now sets the rate: the display's own while the loop is held, `IDLE_FRAME_RATE` while not. The frame port gains `onHeldChange(cb)`, which says when its first hold is taken and its last released (animated visual styles included), so the governor hears every hold. The quality setting's frame-rate cap is kept apart from the governor's rate, and the loop draws at the lower of the two, so neither overwrites the other. **Line batching is timed.** A line set waited 30 drawn frames before its unchanged lines settled into a static batch (300 for the long wait), so the batch built twice as fast at 120 Hz as at 60 Hz, and took seconds at the idle rate. It now waits `SETTLE_MS` (500 ms) and `LONG_SETTLE_MS` (5 s), and moved shapes go back into their batches on the same timing. **KEY REQUIRED.** A layer that cannot load without a provider key ended the global status chip LOAD FAILED. The chip now has a KEY REQUIRED outcome, ranked below a real failure: a layer whose stats say `keyRequired` ends KEY REQUIRED, any other failure still ends LOAD FAILED. Vessels report a missing AISStream key as `keyRequired` and name the key in the panel; a later outage clears it, as it is no longer the key that is missing. Checked: the full suite (new tests for `onHeldChange`, the quality cap against the governor's rate, timed settling, and the chip with and without a key), format, boundaries, build, the stub renderer boot and the Cesium conformance run; in the browser, the idle and held frame rates; and the first-run check now asserts that with no keys set the chip never says LOAD FAILED.
256 lines
8.4 KiB
JavaScript
256 lines
8.4 KiB
JavaScript
import assert from 'node:assert/strict';
|
||
import * as Cesium from 'cesium';
|
||
import test from 'node:test';
|
||
import { bindRenderer, findFrame, frameOf } from '../rendererOf.js';
|
||
import { renderNow } from './frame.js';
|
||
|
||
/** A viewer whose scene raises its phases when `tick` is called. */
|
||
function fakeViewer() {
|
||
// The camera, as Cesium saw it at its last frame: unmoved since.
|
||
const camera = {
|
||
position: new Cesium.Cartesian3(2e7, 0, 0),
|
||
direction: new Cesium.Cartesian3(-1, 0, 0),
|
||
up: new Cesium.Cartesian3(0, 0, 1),
|
||
right: new Cesium.Cartesian3(0, 1, 0),
|
||
transform: Cesium.Matrix4.IDENTITY,
|
||
frustum: { equalsEpsilon: () => true },
|
||
};
|
||
const scene = {
|
||
camera,
|
||
_view: { _cameraClone: camera },
|
||
maximumRenderTimeChange: Infinity,
|
||
preUpdate: new Cesium.Event(),
|
||
preRender: new Cesium.Event(),
|
||
postRender: new Cesium.Event(),
|
||
requestRenderMode: true,
|
||
requests: 0,
|
||
forced: 0,
|
||
requestRender() {
|
||
this.requests += 1;
|
||
this._renderRequested = true;
|
||
},
|
||
forceRender() {
|
||
this.forced += 1;
|
||
scene.preRender.raiseEvent(scene);
|
||
scene.postRender.raiseEvent(scene);
|
||
},
|
||
};
|
||
const clock = {
|
||
currentTime: Cesium.JulianDate.fromDate(new Date(Date.UTC(2026, 0, 1))),
|
||
};
|
||
const tick = () => {
|
||
scene._renderRequested = false;
|
||
scene.preUpdate.raiseEvent(scene, clock.currentTime);
|
||
scene.preRender.raiseEvent(scene, clock.currentTime);
|
||
scene.postRender.raiseEvent(scene, clock.currentTime);
|
||
};
|
||
return { scene, clock, tick, useDefaultRenderLoop: true };
|
||
}
|
||
|
||
test('a viewer of its own, with no renderer bound, runs frames through a built port over its loop', async () => {
|
||
const viewer = fakeViewer();
|
||
const frame = frameOf(viewer);
|
||
assert.equal(findFrame(viewer), frame, 'one per viewer');
|
||
assert.equal(viewer.scene.requestRenderMode, true, 'its loop left alone');
|
||
assert.equal(frame.mode(), 'demand');
|
||
|
||
const seen = [];
|
||
const offs = ['preUpdate', 'preRender', 'postRender'].map((phase) =>
|
||
frame.on(phase, (t) => seen.push([phase, t.frame, t.time])),
|
||
);
|
||
viewer.tick();
|
||
const t0 = Date.UTC(2026, 0, 1);
|
||
assert.deepEqual(seen, [
|
||
['preUpdate', 1, t0],
|
||
['preRender', 1, t0],
|
||
['postRender', 1, t0],
|
||
]);
|
||
assert.throws(() => frame.on('postUpdate', () => {}), TypeError);
|
||
|
||
frame.requestRender('mine');
|
||
assert.equal(viewer.scene.requests, 1);
|
||
assert.deepEqual(frame.diagnostics().pendingReasons, ['mine']);
|
||
viewer.tick();
|
||
assert.deepEqual(frame.diagnostics().pendingReasons, []);
|
||
|
||
// A hold asks for the next frame as each one ends, until released.
|
||
const release = frame.holdContinuous('spin');
|
||
const before = viewer.scene.requests;
|
||
viewer.tick();
|
||
assert.equal(viewer.scene.requests, before + 1, 'asked again after a frame');
|
||
assert.deepEqual(frame.diagnostics().holds, ['spin']);
|
||
release();
|
||
release();
|
||
const after = viewer.scene.requests;
|
||
viewer.tick();
|
||
assert.equal(viewer.scene.requests, after, 'released: no more asking');
|
||
|
||
const once = frame.renderOnce();
|
||
viewer.tick();
|
||
await once;
|
||
frame.renderNow();
|
||
assert.equal(viewer.scene.forced, 1);
|
||
frame.setTime(Date.UTC(2026, 5, 1));
|
||
assert.equal(frame.time(), Date.UTC(2026, 5, 1));
|
||
frame.suspend(true);
|
||
assert.equal(viewer.useDefaultRenderLoop, false);
|
||
assert.equal(frame.diagnostics().suspended, true);
|
||
frame.suspend(false);
|
||
frame.setTargetFps(30);
|
||
assert.equal(viewer.targetFrameRate, 30);
|
||
|
||
// A renderer bound later replaces it: its listeners hear nothing more.
|
||
const unbind = bindRenderer(viewer, { frame: { id: 'renderer' } });
|
||
assert.equal(findFrame(viewer).id, 'renderer');
|
||
seen.length = 0;
|
||
viewer.tick();
|
||
assert.deepEqual(seen, []);
|
||
unbind();
|
||
offs.forEach((off) => off());
|
||
});
|
||
|
||
test('nothing to run frames over, no port', () => {
|
||
assert.equal(findFrame({ scene: {} }), null);
|
||
assert.throws(() => frameOf({ scene: {} }), /no renderer to run frames/);
|
||
});
|
||
|
||
test('a built frame port says whether a tick draws as its listeners ask, keeps reasons asked mid-draw, and stops once replaced', async () => {
|
||
const viewer = fakeViewer();
|
||
const { scene } = viewer;
|
||
// Ticks that do not draw: preUpdate only.
|
||
const idle = () => {
|
||
scene._renderRequested = false;
|
||
scene.preUpdate.raiseEvent(scene, viewer.clock.currentTime);
|
||
};
|
||
const frame = frameOf(viewer);
|
||
const told = [];
|
||
let kept = null;
|
||
let ask = false;
|
||
frame.on('preUpdate', () => {
|
||
if (ask) frame.requestRender('first');
|
||
});
|
||
frame.on('preUpdate', (t) => {
|
||
told.push(t.rendering);
|
||
kept = t;
|
||
});
|
||
idle();
|
||
assert.deepEqual(told, [false], 'nothing asked: no draw');
|
||
ask = true;
|
||
scene._renderRequested = false;
|
||
scene.preUpdate.raiseEvent(scene, viewer.clock.currentTime);
|
||
assert.deepEqual(told, [false, true], 'an earlier listener asked');
|
||
scene.preRender.raiseEvent(scene);
|
||
assert.equal(kept.rendering, true, 'and it drew: settled');
|
||
ask = false;
|
||
|
||
// A reason given while a frame draws waits for the next.
|
||
const off = frame.on('preRender', () => frame.requestRender('later'));
|
||
scene.postRender.raiseEvent(scene);
|
||
frame.requestRender('first');
|
||
viewer.tick();
|
||
assert.deepEqual(frame.diagnostics().pendingReasons, ['later']);
|
||
off();
|
||
|
||
const unbind = bindRenderer(viewer, { frame: { id: 'renderer' } });
|
||
await frame.renderOnce();
|
||
const requests = scene.requests;
|
||
frame.requestRender('gone');
|
||
frame.holdContinuous('gone')();
|
||
assert.equal(scene.requests, requests, 'a replaced port asks for nothing');
|
||
unbind();
|
||
});
|
||
|
||
test('a built frame port counts holds per reason, times out a wait, and settles waits as it goes', async () => {
|
||
const viewer = fakeViewer();
|
||
const { scene } = viewer;
|
||
viewer.useDefaultRenderLoop = false;
|
||
const frame = frameOf(viewer);
|
||
const a = frame.holdContinuous('spin');
|
||
const b = frame.holdContinuous('spin');
|
||
a();
|
||
let requests = scene.requests;
|
||
viewer.tick();
|
||
assert.equal(scene.requests, requests + 1, 'one hold left: still held');
|
||
b();
|
||
requests = scene.requests;
|
||
viewer.tick();
|
||
assert.equal(scene.requests, requests, 'none left');
|
||
|
||
await assert.rejects(frame.renderOnce({ timeoutMs: 1 }), /timed out/);
|
||
// The owner's own loop: suspended and resumed, it stays theirs.
|
||
frame.suspend(true);
|
||
frame.suspend(false);
|
||
assert.equal(viewer.useDefaultRenderLoop, false);
|
||
frame.setTargetFps(0);
|
||
assert.equal(viewer.targetFrameRate, undefined);
|
||
|
||
const waiting = frame.renderOnce();
|
||
const unbind = bindRenderer(viewer, { frame: { id: 'renderer' } });
|
||
await waiting;
|
||
unbind();
|
||
});
|
||
|
||
test('a built frame port says when its first hold is taken and its last released', () => {
|
||
const viewer = fakeViewer();
|
||
viewer.useDefaultRenderLoop = false;
|
||
const frame = frameOf(viewer);
|
||
const heard = [];
|
||
const off = frame.onHeldChange((held) => heard.push(held));
|
||
const a = frame.holdContinuous('spin');
|
||
const b = frame.holdContinuous('glow');
|
||
a();
|
||
assert.deepEqual(heard, [true], 'once for the first hold');
|
||
b();
|
||
assert.deepEqual(heard, [true, false], 'once for the last release');
|
||
off();
|
||
frame.holdContinuous('spin')();
|
||
assert.deepEqual(heard, [true, false], 'nothing once off');
|
||
});
|
||
|
||
test('renderNow throws the error Cesium raises on renderError', () => {
|
||
const listeners = new Set();
|
||
const failure = new Error('worker failed');
|
||
let fail = false;
|
||
const scene = {
|
||
renderError: {
|
||
addEventListener: (cb) => (listeners.add(cb), () => listeners.delete(cb)),
|
||
},
|
||
forceRender() {
|
||
if (fail) for (const cb of listeners) cb(scene, failure);
|
||
},
|
||
};
|
||
const owner = { scene, clock: { currentTime: 'now' } };
|
||
renderNow(owner);
|
||
fail = true;
|
||
assert.throws(() => renderNow(owner), failure);
|
||
assert.equal(listeners.size, 0, 'it stops listening either way');
|
||
});
|
||
|
||
test('renderNow ifDue runs a frame of the widget’s own loop, as its render() does', () => {
|
||
const listeners = new Set();
|
||
const failure = new Error('worker failed');
|
||
const calls = [];
|
||
let fail = false;
|
||
const scene = {
|
||
renderError: {
|
||
addEventListener: (cb) => (listeners.add(cb), () => listeners.delete(cb)),
|
||
},
|
||
forceRender: () => calls.push('forceRender'),
|
||
};
|
||
// The widget's render(): the camera's flight and input, the clock's
|
||
// tick, then a draw if one is due.
|
||
const owner = {
|
||
scene,
|
||
clock: { currentTime: 'now' },
|
||
render() {
|
||
calls.push('render');
|
||
if (fail) for (const cb of listeners) cb(scene, failure);
|
||
},
|
||
};
|
||
renderNow(owner, { ifDue: true });
|
||
assert.deepEqual(calls, ['render']);
|
||
fail = true;
|
||
assert.throws(() => renderNow(owner, { ifDue: true }), failure);
|
||
assert.equal(listeners.size, 0);
|
||
});
|