mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 08:12:24 +00:00
Frame-phase and draw-set ready listeners now run in subscription order,
skip one removed during delivery, defer one added during it, and hand a
throw to the renderer's error listeners (or reportError) instead of into
Cesium's render loop. The renderer gains on('error' | 'contextLost' |
'contextRestored'); Cesium cannot restore a lost context, so it never sends
contextRestored. Dispose clears every list. renderer.listeners joins the
Cesium checks.
503 lines
16 KiB
JavaScript
503 lines
16 KiB
JavaScript
import assert from 'node:assert/strict';
|
||
import * as Cesium from 'cesium';
|
||
import test from 'node:test';
|
||
import {
|
||
cesiumCapabilities,
|
||
createCesiumPorts,
|
||
listenerList,
|
||
} from './ports.js';
|
||
|
||
test('capabilities follow what the scene supports', () => {
|
||
assert.deepEqual(cesiumCapabilities({}), ['models']);
|
||
assert.deepEqual(cesiumCapabilities({ pickPositionSupported: true }), [
|
||
'models',
|
||
'pickPosition',
|
||
]);
|
||
assert.deepEqual(
|
||
cesiumCapabilities({
|
||
pickPositionSupported: true,
|
||
sampleHeightSupported: true,
|
||
}),
|
||
['models', 'pickPosition', 'sampleHeight', 'finestHeights', 'rayCast'],
|
||
);
|
||
});
|
||
|
||
test('a caller can ask for fewer capabilities, never more', () => {
|
||
const scene = { pickPositionSupported: true, sampleHeightSupported: true };
|
||
assert.deepEqual(cesiumCapabilities(scene, ['models', 'rayCast']), [
|
||
'models',
|
||
'rayCast',
|
||
]);
|
||
assert.deepEqual(cesiumCapabilities({}, new Set(['sampleHeight'])), []);
|
||
});
|
||
|
||
test('a listener list keeps the listener rules', () => {
|
||
const errors = [];
|
||
const list = listenerList((error) => errors.push(error));
|
||
const seen = [];
|
||
let offB = () => {};
|
||
list.on(() => {
|
||
seen.push('a');
|
||
offB();
|
||
list.on(() => seen.push('late'));
|
||
});
|
||
offB = list.on(() => seen.push('b'));
|
||
list.on(() => {
|
||
throw new Error('listener');
|
||
});
|
||
const c = () => seen.push('c');
|
||
list.on(c);
|
||
const offC2 = list.on(c);
|
||
list.fire();
|
||
assert.deepEqual(seen, ['a', 'c', 'c']);
|
||
assert.equal(errors.length, 1);
|
||
offC2();
|
||
seen.length = 0;
|
||
list.fire();
|
||
assert.deepEqual(seen, ['a', 'c', 'late']);
|
||
list.clear();
|
||
assert.equal(list.size, 0);
|
||
});
|
||
|
||
test('a listener that clears its list stops the rest of the event', () => {
|
||
const list = listenerList((error) => {
|
||
throw error;
|
||
});
|
||
const seen = [];
|
||
list.on(() => {
|
||
seen.push('a');
|
||
list.clear();
|
||
});
|
||
list.on(() => seen.push('b'));
|
||
list.fire();
|
||
assert.deepEqual(seen, ['a']);
|
||
});
|
||
|
||
/** A widget whose scene records what the query port asks of it. */
|
||
function fakeWidget(overrides = {}) {
|
||
const listeners = new Set();
|
||
const event = () => ({
|
||
addEventListener(cb) {
|
||
listeners.add(cb);
|
||
return () => listeners.delete(cb);
|
||
},
|
||
});
|
||
const calls = [];
|
||
const primitives = [];
|
||
const scene = {
|
||
camera: {},
|
||
primitives: {
|
||
add: (p) => primitives.push(p),
|
||
remove: (p) => primitives.splice(primitives.indexOf(p), 1),
|
||
},
|
||
requestRender() {},
|
||
preUpdate: event(),
|
||
preRender: event(),
|
||
postRender: event(),
|
||
sampleHeightSupported: true,
|
||
pickPositionSupported: true,
|
||
globe: { show: true, getHeight: () => 0 },
|
||
sampleHeight(carto, exclude) {
|
||
calls.push({ exclude, globe: scene.globe.show });
|
||
return 10;
|
||
},
|
||
drillPick: () => [],
|
||
pick: () => undefined,
|
||
...overrides,
|
||
};
|
||
return { widget: { scene, clock: {} }, scene, calls };
|
||
}
|
||
|
||
const all = new Set(['models', 'pickPosition', 'sampleHeight', 'rayCast']);
|
||
const point = (id) => ({
|
||
id,
|
||
pos: { x: 6378137, y: 0, z: 0 },
|
||
pixelSize: 4,
|
||
color: '#fff',
|
||
});
|
||
|
||
test('height queries see through very large sets, built once per change', () => {
|
||
const { widget, calls } = fakeWidget();
|
||
const ports = createCesiumPorts(widget, { capabilities: all });
|
||
const big = ports.draw.points({ id: 'big' });
|
||
big.set(Array.from({ length: 150_000 }, (_, i) => point(String(i))));
|
||
assert.equal(ports.query.sampleHeightNow({ lon: 0, lat: 0 }), 10);
|
||
assert.equal(calls[0].exclude.length, 150_000, 'every item seen through');
|
||
const out = new Float64Array(3);
|
||
ports.query.sampleHeightNowMany(new Float64Array(6), out);
|
||
assert.ok(calls.slice(1).every((c) => c.exclude === calls[0].exclude));
|
||
big.setOptions({ includeInHeightQueries: true });
|
||
ports.query.sampleHeightNow({ lon: 0, lat: 0 });
|
||
assert.equal(calls.at(-1).exclude.length, 0, 'a ground set is not');
|
||
ports.query.sampleHeightNow({ lon: 0, lat: 0 }, { exclude: ['big'] });
|
||
assert.equal(calls.at(-1).exclude.length, 150_000, 'unless excluded');
|
||
ports.dispose();
|
||
});
|
||
|
||
test('tiles are sampled with the globe hidden, and the globe comes back', () => {
|
||
const { widget, scene, calls } = fakeWidget();
|
||
const ports = createCesiumPorts(widget, { capabilities: all });
|
||
ports.query.sampleHeightNow({ lon: 0, lat: 0 }, { against: 'tiles' });
|
||
assert.equal(calls[0].globe, false);
|
||
assert.equal(scene.globe.show, true);
|
||
ports.dispose();
|
||
});
|
||
|
||
test('drillPick: limit 0 is none, each item once, unpickable skipped', () => {
|
||
let picked = [];
|
||
const { widget } = fakeWidget({ drillPick: () => picked });
|
||
const ports = createCesiumPorts(widget, { capabilities: all });
|
||
const set = ports.draw.points({ id: 's' });
|
||
set.set([point('a'), point('b'), { ...point('c'), pickable: false }]);
|
||
const id = (item) => ({ id: { set: 's', id: item } });
|
||
picked = [id('a'), id('a'), id('c'), id('b')];
|
||
assert.deepEqual(ports.query.drillPick(1, 1, { limit: 0 }), []);
|
||
assert.deepEqual(
|
||
ports.query.drillPick(1, 1).map((h) => h.id),
|
||
['a', 'b'],
|
||
);
|
||
assert.deepEqual(
|
||
ports.query.drillPick(1, 1, { limit: 1 }).map((h) => h.id),
|
||
['a'],
|
||
);
|
||
ports.dispose();
|
||
});
|
||
|
||
test('pick under something unpickable stops at what hides the rest', () => {
|
||
let picked = [];
|
||
const { widget } = fakeWidget({
|
||
pick: () => picked[0],
|
||
drillPick: () => picked,
|
||
pickPosition: () => ({ x: 1, y: 2, z: 3 }),
|
||
});
|
||
const ports = createCesiumPorts(widget, { capabilities: all });
|
||
const set = ports.draw.points({ id: 's', pickable: false });
|
||
set.set([point('top')]);
|
||
const under = ports.draw.points({ id: 'u' });
|
||
under.set([point('under')]);
|
||
const top = { id: { set: 's', id: 'top' } };
|
||
picked = [top, { id: { set: 'u', id: 'under' } }];
|
||
assert.equal(ports.query.pick(1, 1).id, 'under');
|
||
picked = [top, { primitive: 'a tile' }, { id: { set: 'u', id: 'under' } }];
|
||
const hit = ports.query.pick(1, 1);
|
||
assert.equal(hit.surface, true, 'the tile hides it: the surface');
|
||
ports.dispose();
|
||
});
|
||
|
||
test('rayCast answers against the surface asked for', async () => {
|
||
const seen = [];
|
||
const { widget } = fakeWidget({
|
||
pickFromRay: () => {
|
||
seen.push(widget.scene.globe.show);
|
||
return { position: { x: 6378137, y: 0, z: 0 } };
|
||
},
|
||
});
|
||
widget.scene.globe.pick = () => ({ x: 6378000, y: 0, z: 0 });
|
||
const ports = createCesiumPorts(widget, { capabilities: all });
|
||
const ray = {
|
||
origin: { x: 7e6, y: 0, z: 0 },
|
||
direction: { x: -1, y: 0, z: 0 },
|
||
};
|
||
assert.equal(
|
||
(await ports.query.rayCast(ray, { against: 'terrain' })).x,
|
||
6378000,
|
||
);
|
||
assert.equal(
|
||
(await ports.query.rayCast(ray, { against: 'tiles' })).x,
|
||
6378137,
|
||
);
|
||
assert.deepEqual(seen, [false], 'tiles cast with the globe hidden');
|
||
assert.equal(
|
||
await ports.query.rayCast(ray, { maxDistance: 100 }),
|
||
null,
|
||
'beyond maxDistance',
|
||
);
|
||
ports.dispose();
|
||
});
|
||
|
||
test('clampToSurface misses a position it cannot read, not the batch', async () => {
|
||
const { widget } = fakeWidget({
|
||
sampleHeightMostDetailed: async (cartos) => {
|
||
for (const c of cartos) c.height = 5;
|
||
return cartos;
|
||
},
|
||
});
|
||
const ports = createCesiumPorts(widget, { capabilities: all });
|
||
const [bad, nan, good] = await ports.query.clampToSurface([
|
||
{ x: Infinity, y: 0, z: 0 },
|
||
{ x: NaN, y: 0, z: 0 },
|
||
{ x: 6378137, y: 0, z: 0 },
|
||
]);
|
||
assert.equal(bad, null);
|
||
assert.equal(nan, null);
|
||
assert.ok(Math.abs(Math.hypot(good.x, good.y, good.z) - 6378142) < 1e-6);
|
||
ports.dispose();
|
||
});
|
||
|
||
/** A widget whose scene events can be raised by hand. */
|
||
function tickingWidget() {
|
||
const events = {};
|
||
const event = (name) => {
|
||
const list = (events[name] = []);
|
||
return {
|
||
addEventListener(cb) {
|
||
list.push(cb);
|
||
return () => list.splice(list.indexOf(cb), 1);
|
||
},
|
||
};
|
||
};
|
||
const camera = new Cesium.Camera({
|
||
canvas: { clientWidth: 100, clientHeight: 100 },
|
||
drawingBufferWidth: 100,
|
||
drawingBufferHeight: 100,
|
||
mapProjection: new Cesium.GeographicProjection(),
|
||
});
|
||
const seen = Cesium.Camera.clone(camera);
|
||
let requested = 0;
|
||
const scene = {
|
||
camera,
|
||
_view: { _cameraClone: seen },
|
||
_frameState: { afterRender: [] },
|
||
requestRenderMode: true,
|
||
maximumRenderTimeChange: Infinity,
|
||
primitives: { add() {}, remove() {} },
|
||
requestRender() {
|
||
requested += 1;
|
||
scene._renderRequested = true;
|
||
},
|
||
preUpdate: event('preUpdate'),
|
||
preRender: event('preRender'),
|
||
postRender: event('postRender'),
|
||
};
|
||
const widget = {
|
||
scene,
|
||
clock: { currentTime: Cesium.JulianDate.now() },
|
||
useDefaultRenderLoop: true,
|
||
_renderLoopRunning: true,
|
||
};
|
||
const raise = (name) => {
|
||
// `end`: the tick empties its after-render queue, as Scene#render does.
|
||
if (name === 'end') {
|
||
for (const fn of scene._frameState.afterRender.splice(0)) fn();
|
||
return;
|
||
}
|
||
for (const cb of [...events[name]]) cb(scene, widget.clock.currentTime);
|
||
};
|
||
return { widget, scene, raise, requests: () => requested };
|
||
}
|
||
|
||
test('preUpdate says whether the tick draws, as Cesium decides it', () => {
|
||
const { widget, scene, raise } = tickingWidget();
|
||
const ports = createCesiumPorts(widget, { capabilities: all });
|
||
const seen = [];
|
||
ports.frame.on('preUpdate', (t) => seen.push(t.rendering));
|
||
raise('preUpdate');
|
||
ports.frame.requestRender('r');
|
||
raise('preUpdate');
|
||
scene._renderRequested = false;
|
||
scene.camera.position = new Cesium.Cartesian3(1, 2, 3);
|
||
raise('preUpdate');
|
||
scene.camera.position = Cesium.Cartesian3.clone(
|
||
scene._view._cameraClone.position,
|
||
);
|
||
scene.requestRenderMode = false;
|
||
raise('preUpdate');
|
||
assert.deepEqual(seen, [false, true, true, true]);
|
||
ports.dispose();
|
||
});
|
||
|
||
test('preUpdate counts what earlier listeners did this tick', () => {
|
||
const { widget, scene, raise } = tickingWidget();
|
||
const ports = createCesiumPorts(widget, { capabilities: all });
|
||
const seen = [];
|
||
ports.frame.on('preUpdate', (t) => seen.push(['before', t.rendering]));
|
||
ports.frame.on('preUpdate', () => {
|
||
scene.camera.position = new Cesium.Cartesian3(7, 8, 9);
|
||
});
|
||
ports.frame.on('preUpdate', (t) => seen.push(['after', t.rendering]));
|
||
raise('preUpdate');
|
||
assert.deepEqual(seen, [
|
||
['before', false],
|
||
['after', true],
|
||
]);
|
||
ports.dispose();
|
||
});
|
||
|
||
test('holds are counted per reason and switch the loop to every frame', () => {
|
||
const { widget, scene, raise } = tickingWidget();
|
||
const ports = createCesiumPorts(widget, { capabilities: all });
|
||
const a = ports.frame.holdContinuous('a');
|
||
const a2 = ports.frame.holdContinuous('a');
|
||
assert.equal(scene.requestRenderMode, false);
|
||
assert.deepEqual(ports.frame.diagnostics().holds, ['a', 'a']);
|
||
a();
|
||
a();
|
||
assert.equal(scene.requestRenderMode, false, 'one hold of a still out');
|
||
a2();
|
||
assert.equal(scene.requestRenderMode, true);
|
||
assert.deepEqual(ports.frame.diagnostics().holds, []);
|
||
ports.frame.requestRender('x');
|
||
ports.frame.requestRender('x');
|
||
assert.deepEqual(ports.frame.diagnostics().pendingReasons, ['x']);
|
||
raise('preUpdate');
|
||
raise('preRender');
|
||
raise('postRender');
|
||
const d = ports.frame.diagnostics();
|
||
assert.deepEqual(d.pendingReasons, [], 'a drawn frame answers them');
|
||
assert.equal(d.frames, 1);
|
||
assert.equal(d.rendered, 1);
|
||
assert.equal(ports.frame.mode(), 'demand');
|
||
ports.dispose();
|
||
});
|
||
|
||
test('suspend stops the loop at once and resumes it; target fps caps it', () => {
|
||
const { widget, requests } = tickingWidget();
|
||
const ports = createCesiumPorts(widget, { capabilities: all });
|
||
ports.frame.suspend(true);
|
||
assert.equal(widget.useDefaultRenderLoop, false);
|
||
assert.equal(
|
||
widget._renderLoopRunning,
|
||
true,
|
||
'the queued callback stops the loop itself',
|
||
);
|
||
assert.equal(ports.frame.diagnostics().suspended, true);
|
||
const before = requests();
|
||
ports.frame.suspend(false);
|
||
assert.equal(widget.useDefaultRenderLoop, true);
|
||
assert.equal(requests(), before + 1, 'a frame on resume');
|
||
ports.frame.setTargetFps(30);
|
||
assert.equal(widget.targetFrameRate, 30);
|
||
assert.equal(ports.frame.diagnostics().targetFps, 30);
|
||
ports.frame.setTargetFps(0);
|
||
assert.equal(widget.targetFrameRate, undefined, '0 is the display rate');
|
||
ports.dispose();
|
||
});
|
||
|
||
test('rendering holds the tick’s answer once the tick is over', () => {
|
||
const { widget, scene, raise } = tickingWidget();
|
||
const ports = createCesiumPorts(widget, { capabilities: all });
|
||
const kept = [];
|
||
ports.frame.on('preUpdate', (t) => kept.push(t));
|
||
ports.frame.requestRender('r');
|
||
raise('preUpdate');
|
||
raise('preRender');
|
||
scene._renderRequested = false;
|
||
raise('postRender');
|
||
raise('preUpdate');
|
||
scene.requestRenderMode = false;
|
||
raise('preUpdate');
|
||
assert.deepEqual(
|
||
kept.map((t) => t.rendering),
|
||
[true, false, true],
|
||
'drawn, not drawn, and the live tick',
|
||
);
|
||
ports.dispose();
|
||
});
|
||
|
||
test('a reason given while a frame draws waits for the next one', () => {
|
||
const { widget, raise } = tickingWidget();
|
||
const ports = createCesiumPorts(widget, { capabilities: all });
|
||
ports.frame.requestRender('before');
|
||
ports.frame.on('preRender', () => ports.frame.requestRender('during'));
|
||
raise('preUpdate');
|
||
raise('preRender');
|
||
raise('postRender');
|
||
assert.deepEqual(ports.frame.diagnostics().pendingReasons, ['during']);
|
||
ports.dispose();
|
||
});
|
||
|
||
test('the same reason given again while it is answered stays pending', () => {
|
||
const { widget, raise } = tickingWidget();
|
||
const ports = createCesiumPorts(widget, { capabilities: all });
|
||
ports.frame.requestRender('animation');
|
||
ports.frame.requestRender('animation');
|
||
assert.deepEqual(ports.frame.diagnostics().pendingReasons, ['animation']);
|
||
ports.frame.on('preRender', () => ports.frame.requestRender('animation'));
|
||
raise('preUpdate');
|
||
raise('preRender');
|
||
raise('postRender');
|
||
assert.deepEqual(ports.frame.diagnostics().pendingReasons, ['animation']);
|
||
ports.dispose();
|
||
});
|
||
|
||
test('scene time past maximumRenderTimeChange draws', () => {
|
||
const { widget, scene, raise } = tickingWidget();
|
||
const ports = createCesiumPorts(widget, { capabilities: all });
|
||
const seen = [];
|
||
ports.frame.on('preUpdate', (t) => seen.push(t.rendering));
|
||
scene.maximumRenderTimeChange = 1;
|
||
scene._lastRenderTime = Cesium.JulianDate.addSeconds(
|
||
widget.clock.currentTime,
|
||
-0.5,
|
||
new Cesium.JulianDate(),
|
||
);
|
||
raise('preUpdate');
|
||
scene._lastRenderTime = Cesium.JulianDate.addSeconds(
|
||
widget.clock.currentTime,
|
||
-2,
|
||
new Cesium.JulianDate(),
|
||
);
|
||
raise('preUpdate');
|
||
assert.deepEqual(seen, [false, true]);
|
||
ports.dispose();
|
||
});
|
||
|
||
test('holds work from a scene that already draws every frame', () => {
|
||
const { widget, scene } = tickingWidget();
|
||
scene.requestRenderMode = false;
|
||
const ports = createCesiumPorts(widget, { capabilities: all });
|
||
const release = ports.frame.holdContinuous('a');
|
||
ports.frame.holdContinuous('b');
|
||
ports.frame.holdContinuous('b');
|
||
assert.deepEqual(ports.frame.diagnostics().holds.sort(), ['a', 'b', 'b']);
|
||
release();
|
||
assert.equal(scene.requestRenderMode, false, 'b still holds');
|
||
ports.dispose();
|
||
});
|
||
|
||
test('a tick that did not draw says so once it is over', () => {
|
||
const { widget, scene, raise } = tickingWidget();
|
||
const ports = createCesiumPorts(widget, { capabilities: all });
|
||
let kept;
|
||
ports.frame.on('preUpdate', (t) => (kept = t));
|
||
raise('preUpdate');
|
||
raise('end');
|
||
assert.equal(kept.rendering, false);
|
||
scene.requestRender();
|
||
assert.equal(kept.rendering, false, 'a later request is the next tick’s');
|
||
raise('preUpdate');
|
||
assert.equal(kept.rendering, true, 'the request draws the next tick');
|
||
const live = kept;
|
||
ports.dispose();
|
||
// The port no longer sees the tick through, so it does not claim a draw.
|
||
assert.equal(live.rendering, false, 'disposal settles the tick under way');
|
||
});
|
||
|
||
test('releasing the last hold asks for one more frame', () => {
|
||
const { widget, scene, requests } = tickingWidget();
|
||
const ports = createCesiumPorts(widget, { capabilities: all });
|
||
const a = ports.frame.holdContinuous('a');
|
||
const b = ports.frame.holdContinuous('b');
|
||
const before = requests();
|
||
a();
|
||
assert.equal(requests(), before, 'a hold still out draws anyway');
|
||
b();
|
||
assert.equal(requests(), before + 1);
|
||
assert.equal(scene.requestRenderMode, true);
|
||
b();
|
||
assert.equal(requests(), before + 1, 'a second release does nothing');
|
||
ports.dispose();
|
||
});
|
||
|
||
test('the loop starts on demand and never draws for scene time alone', () => {
|
||
const { widget, scene } = tickingWidget();
|
||
scene.requestRenderMode = false;
|
||
scene.maximumRenderTimeChange = 0;
|
||
widget.targetFrameRate = 60;
|
||
const ports = createCesiumPorts(widget, { capabilities: all });
|
||
assert.equal(scene.requestRenderMode, true);
|
||
assert.equal(scene.maximumRenderTimeChange, Infinity);
|
||
assert.equal(ports.frame.diagnostics().targetFps, 60, 'the widget’s cap');
|
||
ports.dispose();
|
||
});
|