mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 16:22:20 +00:00
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.
239 lines
7.1 KiB
JavaScript
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',
|
|
);
|
|
});
|