Files
gods-eye-view/src/render/cesium/ports.test.mjs
T
Sameh Khamis 35a73b6fda Give the Cesium renderer the contract's listener rules and error channel
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.
2026-11-05 18:18:28 -08:00

503 lines
16 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
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();
});