Files
gods-eye-view/src/globe/movers.test.mjs
T
German Khokhlov 4dfcba8989 feat(globe): mover sets report ready(); Navara scales by distance as Cesium
Task 10b foundation.
- MoverSet.ready(): whether what the set draws has loaded (Navara: the
  model set's glTF, a URL atlas; Cesium: every instance's Model, the cropped
  atlas; parts without it draw at once). The aircraft renderer keeps the 2D
  glyph until a model set is ready, as the Cesium path waits on Model.ready.
  Contract suite: a drawn model set is ready() (both engines); unit test of
  the neutral store.
- Navara sprites and points interpolate scaleByDistance as Cesium's
  NearFarScalar (over the squared camera distance, eased by ^0.2) instead
  of linearly in distance, so aircraft glyphs have Cesium's size at every
  range; the CPU pick radius follows (distanceScale, tested equal to
  focusDeemphasis' port of czm_nearFarScalar). The contract text says so.
2026-10-17 01:16:59 +04:00

239 lines
7.1 KiB
JavaScript

import assert from 'node:assert/strict';
import test from 'node:test';
import {
MOVER_KINDS,
createMoverRegistry,
createMoverSet,
createMoverStore,
normalizeMoverSetOptions,
} from './movers.js';
const atlas = {
canvas: { width: 64, height: 32 },
cells: { jet: [0, 0, 0.5, 1], heli: [0.5, 0, 1, 1] },
};
test('set options are normalised with the contract defaults', () => {
assert.deepEqual(MOVER_KINDS, ['sprite', 'point', 'model']);
const sprite = normalizeMoverSetOptions({
id: 'flights',
kind: 'sprite',
capacity: 10,
sprite: { atlas, sizePx: 24 },
});
assert.equal(sprite.id, 'flights');
assert.equal(sprite.order, 0);
assert.equal(sprite.depthTest, 'normal');
assert.equal(sprite.pickable, false);
assert.deepEqual(sprite.cellKeys, ['jet', 'heli']);
assert.equal(sprite.sprite.scaleByDistance, null);
const point = normalizeMoverSetOptions({
id: 'sats',
kind: 'point',
capacity: 3,
depthTest: { disableWithinM: 5000 },
point: { sizePx: 4 },
});
assert.equal(point.point.outlinePx, 0);
assert.deepEqual(point.depthTest, { disableWithinM: 5000 });
const model = normalizeMoverSetOptions({
id: 'models',
kind: 'model',
capacity: 2,
model: { url: '/models/airplane.glb' },
});
assert.equal(model.model.minimumPixelSize, 0);
assert.equal(model.model.maximumScale, Infinity);
assert.equal(model.model.colorBlend, null);
});
test('bad set options are refused with a TypeError', () => {
for (const options of [
{},
{ id: 'a', kind: 'cube', capacity: 1 },
{ id: 'a', kind: 'sprite', capacity: 0, sprite: { atlas, sizePx: 2 } },
{ id: 'a', kind: 'sprite', capacity: 1.5, sprite: { atlas, sizePx: 2 } },
{ id: 'a', kind: 'sprite', capacity: 1 },
{ id: 'a', kind: 'sprite', capacity: 1, sprite: { atlas, sizePx: -1 } },
{ id: 'a', kind: 'point', capacity: 1, point: {} },
{ id: 'a', kind: 'model', capacity: 1, model: {} },
{
id: 'a',
kind: 'point',
capacity: 1,
point: { sizePx: 2 },
depthTest: 'sometimes',
},
{
id: 'a',
kind: 'sprite',
capacity: 1,
sprite: { atlas, sizePx: 2, scaleByDistance: [1, 2] },
},
])
assert.throws(() => normalizeMoverSetOptions(options), TypeError);
});
test('the store keeps each instance in flat arrays with defaults', () => {
const store = createMoverStore(
normalizeMoverSetOptions({
id: 'f',
kind: 'sprite',
capacity: 3,
sprite: { atlas, sizePx: 16 },
}),
);
assert.equal(store.capacity, 3);
assert.equal(store.count, 0);
store.set(1, {
position: { x: 1, y: 2, z: 3 },
rotation: 0.5,
color: [1, 0, 0, 0.5],
scale: 2,
cell: 'heli',
show: false,
pickId: 'abc',
});
store.set(0, { position: { x: 4, y: 5, z: 6 } });
assert.deepEqual([...store.positions.subarray(0, 6)], [4, 5, 6, 1, 2, 3]);
assert.deepEqual(
[...store.colors.subarray(0, 8)],
[1, 1, 1, 1, 1, 0, 0, 0.5],
);
assert.equal(store.rotations[1], 0.5);
assert.equal(store.scales[0], 1);
assert.equal(store.scales[1], 2);
assert.equal(store.cells[0], 0);
assert.equal(store.cells[1], 1);
assert.equal(store.shows[0], 1);
assert.equal(store.shows[1], 0);
assert.equal(store.pickIds[1], 'abc');
assert.equal(store.pickIds[0], undefined);
// set() without a field keeps the stored value.
store.set(1, { position: { x: 7, y: 8, z: 9 } });
assert.equal(store.scales[1], 2);
assert.equal(store.shows[1], 0);
store.setCount(2);
assert.equal(store.count, 2);
assert.deepEqual([...store.positionsView()], [4, 5, 6, 7, 8, 9]);
assert.deepEqual(store.dirty(), { from: 0, to: 2 });
store.clean();
assert.equal(store.dirty(), null);
store.set(2, { position: { x: 0, y: 0, z: 1 } });
assert.deepEqual(store.dirty(), { from: 2, to: 3 });
});
test('bad instances are refused and leave the store unchanged', () => {
const store = createMoverStore(
normalizeMoverSetOptions({
id: 'f',
kind: 'point',
capacity: 2,
point: { sizePx: 4 },
}),
);
for (const [index, fields] of [
[2, { position: { x: 0, y: 0, z: 0 } }],
[-1, { position: { x: 0, y: 0, z: 0 } }],
[0, { position: { x: Number.NaN, y: 0, z: 0 } }],
[0, { color: [1, 1, 1] }],
[0, { cell: 'jet' }],
[0, { scale: -1 }],
])
assert.throws(() => store.set(index, fields), TypeError);
assert.throws(() => store.setCount(3), RangeError);
assert.equal(store.dirty(), null);
});
test('models take an orientation quaternion', () => {
const store = createMoverStore(
normalizeMoverSetOptions({
id: 'm',
kind: 'model',
capacity: 1,
model: { url: '/m.glb' },
}),
);
assert.deepEqual([...store.orientations], [0, 0, 0, 1]);
store.set(0, { orientation: { x: 0, y: 0, z: 1, w: 0 } });
assert.deepEqual([...store.orientations], [0, 0, 1, 0]);
assert.throws(() => store.set(0, { orientation: { x: 0, y: 0 } }), TypeError);
});
test('the set facade forwards to the store and an engine commit, once destroyed it refuses', () => {
const store = createMoverStore(
normalizeMoverSetOptions({
id: 'f',
kind: 'point',
capacity: 2,
point: { sizePx: 4 },
}),
);
const calls = [];
const set = createMoverSet(store, {
commit: () => calls.push(['commit', { ...store.dirty() }]),
destroy: () => calls.push(['destroy']),
});
set.set(0, { position: { x: 1, y: 2, z: 3 } });
set.setCount(1);
assert.equal(set.count(), 1);
assert.deepEqual([...set.positionsView()], [1, 2, 3]);
set.commit();
assert.deepEqual(calls, [['commit', { from: 0, to: 1 }]]);
assert.equal(store.dirty(), null, 'commit cleans the store');
set.destroy();
set.destroy();
assert.deepEqual(calls.at(-1), ['destroy']);
assert.equal(calls.length, 2);
assert.throws(() => set.set(0, {}), /destroyed/);
assert.throws(() => set.commit(), /destroyed/);
});
test('a destroyed set releases its instance arrays', () => {
const store = createMoverStore(
normalizeMoverSetOptions({
id: 'r',
kind: 'point',
capacity: 1000,
point: { sizePx: 2 },
}),
);
const set = createMoverSet(store, { commit() {}, destroy() {} });
set.set(0, { position: { x: 1, y: 2, z: 3 }, pickId: 'p' });
set.setCount(1);
set.destroy();
assert.equal(store.count, 0);
assert.equal(store.positions.length, 0);
assert.equal(store.pickIds.length, 0);
assert.equal(set.positionsView().length, 0);
assert.equal(store.dirty(), null);
});
test('a set is ready() once what it draws has loaded, never once destroyed', () => {
let loaded = false;
const registry = createMoverRegistry(() => ({
commit() {},
destroy() {},
ready: () => loaded,
}));
const set = registry.movers.createSet({
id: 'r',
kind: 'point',
capacity: 1,
point: { sizePx: 4 },
});
assert.equal(set.ready(), false);
loaded = true;
assert.equal(set.ready(), true);
set.destroy();
assert.equal(set.ready(), false);
const plain = createMoverRegistry(() => ({ commit() {}, destroy() {} }));
assert.equal(
plain.movers
.createSet({ id: 'p', kind: 'point', capacity: 1, point: { sizePx: 4 } })
.ready(),
true,
'an engine part without ready() draws at once',
);
});