mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-21 10:42:22 +00:00
Draw launch-pad zones as radial ground discs with the original fill, rim, transitions, emission and depth bias. Drape Transit history and its backing on ground corridors. Keep the current age bands and once-per-second updates; advance the active head with a reveal fraction and rebuild only at segment crossings. Its wider dark edge and colour core blend once, as on Cesium. Navara composes these looks after tone mapping. Build reveal corridors and dynamic Transit history synchronously once shared terrain bounds are loaded. Keep requesting frames until the visible globe tiles and committed primitives are ready: classification needs current surface depth after a camera move. Retain the reference radial material, its alpha envelope and the head's material-only reveal updates. Remove the empty Navara ground effect from the render chain when the last shown set is hidden or destroyed. It otherwise remains as the insertion anchor for later pulse effects after its packed textures have been disposed. Cover reveal, destruction and replacement with fresh-state comparisons for corridors, polygons, discs and cells. Cesium drawing is unchanged by this fix. Keep the radial pixel check at a 500 metre radius and 4 kilometre view, sample the brightest of six inner points around the native fill gap, and sample across the rim width. Restore its view during arrival flights and run it last among ground checks. Both suite launchers wait for the linked view to arrive before checking. Keep these checks with the radial look. Pass rectangular pick windows and drill limits through input subscriptions. Street Level uses its 9 pixel window and CCTV uses its 14 pixel window and six-result drill. Down picks stay synchronous, moves coalesce per frame and Navara clicks keep the GPU answer from their gesture. Add a projector ellipsoid option and use WGS84 radii reduced by 1,000 metres for Street Level. These changes restore the original Cesium pad fill and ground trail rather than the temporary ring and raised lines. Navara follows the same appearance and horizon policy, and now honours explicit CPU pick windows. Existing callers without these options retain their defaults. The four debts share the contract, suite and engine implementations, so keep them together. No coupling count grew or fell: renderer lines remain 0 and 189, external Cesium imports 3, external viewer lines 891, engine-kind checks 1, engine resolution calls 0, extension reads 3, ground passes 1, SDK loads 3, screen handler files 4 and engine-name lines 32. The contract and ground suites now wait until the camera has reached the view in their link before checking, because the app's restore flight could land in the middle of a check; that was also the cause of the intermittent camera-events failure. The radial check uses a launch pad's size and samples the fill at several inner points: Cesium's own old pad leaves the same gap in a small ground disc's fill. The pulse-band check takes its base frame once the surface has settled. Checked in the browser, keyless: the contract suite passes on both engines (84 and 85 checks), the ground suite passes on both, CCTV v2 passes 58 checks, and the space, transit, Street Level and CCTV engine switches pass. The transit and Street Level scripts fail as they do before this change.
471 lines
16 KiB
JavaScript
471 lines
16 KiB
JavaScript
import assert from 'node:assert/strict';
|
|
import test from 'node:test';
|
|
import * as geo from '../../geo/index.js';
|
|
import { createFakeEngine } from './fakeEngine.js';
|
|
|
|
const close = (actual, expected, tolerance, message) =>
|
|
assert.ok(
|
|
Math.abs(actual - expected) <= tolerance,
|
|
`${message ?? 'value'}: ${actual} is not within ${tolerance} of ${expected}`,
|
|
);
|
|
|
|
test('the fake pose is controllable and returned as fresh geo values', () => {
|
|
const engine = createFakeEngine({ width: 800, height: 600 });
|
|
engine.fake.setPose({
|
|
longitude: 0.5,
|
|
latitude: 0.25,
|
|
height: 2000,
|
|
heading: 1,
|
|
pitch: -0.4,
|
|
});
|
|
const pose = engine.camera.pose();
|
|
close(pose.cartographic.longitude, 0.5, 1e-12, 'longitude');
|
|
close(pose.cartographic.latitude, 0.25, 1e-12, 'latitude');
|
|
close(pose.cartographic.height, 2000, 1e-6, 'height');
|
|
close(pose.heading, 1, 1e-9, 'heading');
|
|
close(pose.pitch, -0.4, 1e-9, 'pitch');
|
|
close(pose.roll, 0, 1e-9, 'roll');
|
|
pose.position.x = 0;
|
|
assert.notEqual(engine.camera.pose().position.x, 0);
|
|
assert.deepEqual(engine.host.size(), { width: 800, height: 600 });
|
|
engine.fake.setSize(320, 200);
|
|
assert.deepEqual(engine.host.size(), { width: 320, height: 200 });
|
|
});
|
|
|
|
test('the fake records contract calls for shell-module tests', () => {
|
|
const engine = createFakeEngine();
|
|
const destination = geo.cartesian3.fromDegrees(10, 20, 3000);
|
|
engine.camera.setView({ destination });
|
|
engine.camera.flyTo({ destination, duration: 2 });
|
|
engine.camera.cancelFlight();
|
|
engine.render.request();
|
|
engine.render.request();
|
|
assert.deepEqual(
|
|
engine.fake.calls.map((call) => call.method),
|
|
[
|
|
'camera.setView',
|
|
'camera.flyTo',
|
|
'camera.cancelFlight',
|
|
'render.request',
|
|
'render.request',
|
|
],
|
|
);
|
|
assert.equal(engine.fake.callsOf('camera.flyTo')[0].args[0].duration, 2);
|
|
assert.equal(engine.fake.renderRequests, 2);
|
|
engine.fake.resetCalls();
|
|
assert.deepEqual(engine.fake.calls, []);
|
|
assert.equal(engine.fake.renderRequests, 0);
|
|
});
|
|
|
|
test('fake flights advance with frames and finish or cancel exactly once', () => {
|
|
const engine = createFakeEngine();
|
|
const destination = geo.cartesian3.fromDegrees(30, 40, 5000);
|
|
const outcomes = [];
|
|
engine.camera.flyTo({
|
|
destination,
|
|
duration: 1,
|
|
complete: () => outcomes.push('complete'),
|
|
cancel: () => outcomes.push('cancel'),
|
|
});
|
|
assert.equal(engine.camera.flightActive(), true);
|
|
engine.fake.frames(30, 16);
|
|
assert.deepEqual(outcomes, []);
|
|
engine.fake.frames(40, 16);
|
|
assert.deepEqual(outcomes, ['complete']);
|
|
assert.ok(
|
|
geo.cartesian3.distance(engine.camera.pose().position, destination) < 1e-6,
|
|
);
|
|
engine.camera.cancelFlight();
|
|
assert.deepEqual(outcomes, ['complete']);
|
|
|
|
engine.camera.flyTo({
|
|
destination: geo.cartesian3.fromDegrees(0, 0, 1e6),
|
|
cancel: () => outcomes.push('cancel'),
|
|
});
|
|
engine.camera.flyTo({
|
|
destination,
|
|
duration: 0,
|
|
complete: () => outcomes.push('second'),
|
|
});
|
|
// Duration 0 lands and completes before flyTo returns, as in Cesium.
|
|
assert.deepEqual(outcomes, ['complete', 'cancel', 'second']);
|
|
assert.equal(engine.camera.flightActive(), false);
|
|
});
|
|
|
|
test('fake events can be emitted by hand and frames fire in order', () => {
|
|
const engine = createFakeEngine();
|
|
const seen = [];
|
|
engine.camera.changed.addEventListener((value) =>
|
|
seen.push(['changed', value]),
|
|
);
|
|
engine.frames.preUpdate.addEventListener((time) =>
|
|
seen.push(['preUpdate', time]),
|
|
);
|
|
engine.frames.preRender.addEventListener((time) =>
|
|
seen.push(['preRender', time]),
|
|
);
|
|
engine.frames.postRender.addEventListener((time) =>
|
|
seen.push(['postRender', time]),
|
|
);
|
|
engine.fake.emit('camera.changed', 0.7);
|
|
engine.fake.frame(10);
|
|
assert.deepEqual(seen, [
|
|
['changed', 0.7],
|
|
['preUpdate', 10],
|
|
['preRender', 10],
|
|
['postRender', 10],
|
|
]);
|
|
assert.throws(() => engine.fake.emit('camera.nope'), /Unknown engine event/);
|
|
});
|
|
|
|
test('fake input dispatches to subscribers and off removes them', () => {
|
|
const engine = createFakeEngine();
|
|
const seen = [];
|
|
const off = engine.input.on('click', (event) => seen.push(event.position));
|
|
engine.fake.input('click', { position: geo.cartesian2.create(4, 5) });
|
|
off();
|
|
engine.fake.input('click', { position: geo.cartesian2.create(6, 7) });
|
|
assert.deepEqual(seen, [geo.cartesian2.create(4, 5)]);
|
|
assert.throws(() => engine.input.on('wheel', () => {}), /Unknown input type/);
|
|
engine.input.setCameraInputs(false);
|
|
assert.equal(engine.fake.cameraInputsEnabled, false);
|
|
engine.input.setCameraInputs(true);
|
|
const resume = engine.input.suspendCameraInputs();
|
|
const inner = engine.input.suspendCameraInputs();
|
|
assert.equal(engine.input.cameraInputsEnabled(), false);
|
|
inner();
|
|
resume();
|
|
resume();
|
|
assert.equal(engine.input.cameraInputsEnabled(), true);
|
|
});
|
|
|
|
test('pick, sampleHeight and worldToWindow results can be scripted', () => {
|
|
const engine = createFakeEngine();
|
|
const screen = geo.cartesian2.create(10, 10);
|
|
assert.equal(engine.picker.pick(screen), undefined);
|
|
engine.fake.script('pick', { id: 'aircraft', primitive: {} });
|
|
assert.equal(engine.picker.pick(screen).id, 'aircraft');
|
|
engine.fake.script('pick', (position) =>
|
|
position.x > 5 ? { id: 'x' } : undefined,
|
|
);
|
|
assert.equal(engine.picker.pick(screen).id, 'x');
|
|
engine.fake.script('sampleHeight', 123);
|
|
assert.equal(
|
|
engine.surface.sampleHeight(geo.cartographic.fromDegrees(0, 0)),
|
|
123,
|
|
);
|
|
engine.fake.script('worldToWindow', geo.cartesian2.create(1, 2));
|
|
const result = geo.cartesian2.create();
|
|
assert.equal(
|
|
engine.projector.worldToWindow(geo.cartesian3.UNIT_X, result),
|
|
result,
|
|
);
|
|
assert.deepEqual(result, geo.cartesian2.create(1, 2));
|
|
engine.fake.unscript('worldToWindow');
|
|
const { position, direction } = engine.camera.pose();
|
|
const behind = geo.cartesian3.subtract(
|
|
position,
|
|
geo.cartesian3.multiplyByScalar(direction, 1000, geo.cartesian3.create()),
|
|
geo.cartesian3.create(),
|
|
);
|
|
assert.equal(engine.projector.worldToWindow(behind), undefined);
|
|
assert.throws(
|
|
() => engine.fake.script('teleport', 1),
|
|
/Unknown scripted result/,
|
|
);
|
|
});
|
|
|
|
test('fake credits, maps and destroy keep inspectable state', () => {
|
|
const engine = createFakeEngine();
|
|
const remove = engine.credits.addStatic('<b>OSM</b>', { onScreen: true });
|
|
assert.deepEqual(engine.fake.credits, [
|
|
{ html: '<b>OSM</b>', onScreen: true },
|
|
]);
|
|
remove();
|
|
remove();
|
|
assert.deepEqual(engine.fake.credits, []);
|
|
engine.maps.setPhotorealTiles({ kind: 'google-3d' });
|
|
assert.equal(engine.maps.photorealActive(), true);
|
|
assert.deepEqual(engine.fake.maps.photoreal, { kind: 'google-3d' });
|
|
engine.maps.setPhotorealTiles(null);
|
|
assert.equal(engine.maps.photorealActive(), false);
|
|
engine.destroy();
|
|
assert.equal(engine.fake.destroyed, true);
|
|
});
|
|
|
|
test('fake lookAtTransform keeps the transform until release', () => {
|
|
const engine = createFakeEngine();
|
|
const target = geo.cartesian3.fromDegrees(10, 10, 0);
|
|
const frame = geo.transforms.eastNorthUpToFixedFrame(target);
|
|
engine.camera.lookAtTransform(frame, {
|
|
heading: 0,
|
|
pitch: -0.5,
|
|
range: 1000,
|
|
});
|
|
assert.deepEqual(engine.camera.transform(), [...frame]);
|
|
engine.camera.transform()[0] = 42;
|
|
assert.notEqual(engine.camera.transform()[0], 42);
|
|
engine.camera.release();
|
|
assert.deepEqual(engine.camera.transform(), [...geo.matrix4.IDENTITY]);
|
|
engine.camera.lookAt(target, { heading: 0, pitch: -0.5, range: 1000 });
|
|
assert.deepEqual(engine.camera.transform(), [...frame]);
|
|
assert.deepEqual(engine.fake.lookAtTarget(), target);
|
|
});
|
|
|
|
test('fake input honours modifiers like Cesium: unmodified listeners skip modified input', () => {
|
|
const engine = createFakeEngine();
|
|
const seen = [];
|
|
engine.input.on('click', () => seen.push('plain'));
|
|
engine.input.on('click', () => seen.push('ctrl'), { modifier: 'ctrl' });
|
|
engine.fake.input('click', { position: geo.cartesian2.create(1, 1) });
|
|
engine.fake.input('click', { position: geo.cartesian2.create(1, 1) }, 'ctrl');
|
|
engine.fake.input(
|
|
'click',
|
|
{ position: geo.cartesian2.create(1, 1) },
|
|
'shift',
|
|
);
|
|
assert.deepEqual(seen, ['plain', 'ctrl']);
|
|
assert.throws(
|
|
() => engine.input.on('click', () => {}, { modifier: 'meta' }),
|
|
/Unknown input modifier/,
|
|
);
|
|
});
|
|
|
|
test('fake terrain height and clamp results default to the bare ellipsoid and can be scripted', () => {
|
|
const engine = createFakeEngine();
|
|
const place = geo.cartographic.fromDegrees(1, 2, 0);
|
|
assert.equal(engine.surface.terrainHeight(place), 0);
|
|
assert.equal(
|
|
engine.surface.clampToHeight(geo.cartesian3.fromDegrees(1, 2, 50)),
|
|
undefined,
|
|
);
|
|
engine.fake.script('terrainHeight', 12);
|
|
engine.fake.script('clampToHeight', (position) => position);
|
|
assert.equal(engine.surface.terrainHeight(place), 12);
|
|
const position = geo.cartesian3.fromDegrees(1, 2, 50);
|
|
assert.equal(engine.surface.clampToHeight(position), position);
|
|
assert.equal(engine.surface.terrainHeightSupported, true);
|
|
assert.equal(engine.surface.clampToHeightSupported, true);
|
|
});
|
|
|
|
test('fake drillPick records width and height; maps return promises', async () => {
|
|
const engine = createFakeEngine();
|
|
engine.picker.drillPick(geo.cartesian2.create(1, 2), 3, 4, 5);
|
|
assert.deepEqual(
|
|
engine.fake.callsOf('picker.drillPick')[0].args.slice(1),
|
|
[3, 4, 5],
|
|
);
|
|
for (const call of [
|
|
engine.maps.setBaseImagery({ kind: 'osm' }),
|
|
engine.maps.setTerrain({ kind: 'ellipsoid' }),
|
|
engine.maps.setPhotorealTiles(null),
|
|
]) {
|
|
assert.ok(call instanceof Promise);
|
|
await call;
|
|
}
|
|
});
|
|
|
|
test('fake host elements can be supplied', () => {
|
|
const container = { id: 'globe' };
|
|
const canvas = { id: 'canvas' };
|
|
const engine = createFakeEngine({ container, canvas });
|
|
assert.equal(engine.host.container, container);
|
|
assert.equal(engine.host.canvas, canvas);
|
|
assert.deepEqual(createFakeEngine().host.container, {
|
|
kind: 'fake-container',
|
|
});
|
|
});
|
|
|
|
test('fake isDestroyed, commanded and pickGlobe are inspectable', () => {
|
|
const engine = createFakeEngine();
|
|
let commanded = 0;
|
|
engine.camera.commanded.addEventListener(() => commanded++);
|
|
engine.fake.emit('camera.commanded');
|
|
engine.camera.cancelFlight();
|
|
assert.equal(commanded, 2);
|
|
engine.fake.script('pickGlobe', { x: 1, y: 2, z: 3 });
|
|
assert.deepEqual(engine.picker.pickGlobe({ x: 0, y: 0 }), {
|
|
x: 1,
|
|
y: 2,
|
|
z: 3,
|
|
});
|
|
assert.equal(engine.fake.callsOf('picker.pickGlobe').length, 1);
|
|
assert.equal(engine.isDestroyed(), false);
|
|
engine.destroy();
|
|
assert.equal(engine.isDestroyed(), true);
|
|
});
|
|
|
|
test('the fake clock is the app clock the test controls, latched per frame', () => {
|
|
const start = Date.UTC(2026, 9, 16, 12);
|
|
const engine = createFakeEngine({ nowMs: start });
|
|
const seen = [];
|
|
for (const name of ['preUpdate', 'preRender', 'postRender'])
|
|
engine.frames[name].addEventListener(() =>
|
|
seen.push([name, engine.clock.frameTime()]),
|
|
);
|
|
assert.equal(engine.clock.now(), start);
|
|
engine.fake.frame(16);
|
|
assert.deepEqual(seen, [
|
|
['preUpdate', start + 16],
|
|
['preRender', start + 16],
|
|
['postRender', start + 16],
|
|
]);
|
|
// Time moves between frames; the frame time only at the next frame.
|
|
engine.fake.advanceTime(1000);
|
|
assert.equal(engine.clock.now(), start + 1016);
|
|
assert.equal(engine.clock.frameTime(), start + 16);
|
|
engine.fake.frame(16);
|
|
assert.equal(engine.clock.frameTime(), start + 1032);
|
|
// The app clock's controls work through engine.fake.appClock.
|
|
engine.fake.appClock.freeze(start);
|
|
engine.fake.frame(16);
|
|
assert.equal(engine.clock.frameTime(), start);
|
|
});
|
|
|
|
test('a fake engine can share an app clock', async () => {
|
|
const { createAppClock } = await import('../../time/clock.js');
|
|
let wall = 5000;
|
|
const appClock = createAppClock({ now: () => wall });
|
|
const engine = createFakeEngine({ appClock });
|
|
assert.equal(engine.fake.appClock, appClock);
|
|
wall = 6000;
|
|
assert.equal(engine.clock.now(), 6000);
|
|
engine.fake.frame();
|
|
assert.equal(appClock.frameTime(), 6000);
|
|
});
|
|
|
|
test('fake movers keep their sets and instances for layer tests', () => {
|
|
const engine = createFakeEngine();
|
|
const set = engine.movers.createSet({
|
|
id: 'flights',
|
|
kind: 'point',
|
|
capacity: 4,
|
|
point: { sizePx: 6 },
|
|
});
|
|
set.set(0, { position: { x: 1, y: 2, z: 3 }, color: [1, 0, 0, 1] });
|
|
set.setCount(1);
|
|
assert.deepEqual(engine.movers.list(), [
|
|
{ id: 'flights', kind: 'point', count: 1, capacity: 4 },
|
|
]);
|
|
const before = engine.fake.renderRequests;
|
|
set.commit();
|
|
assert.equal(engine.fake.renderRequests, before + 1);
|
|
const stored = engine.fake.moverSet('flights');
|
|
assert.equal(stored.commits, 1);
|
|
assert.deepEqual([...stored.store.colors.subarray(0, 4)], [1, 0, 0, 1]);
|
|
assert.throws(
|
|
() =>
|
|
engine.movers.createSet({
|
|
id: 'flights',
|
|
kind: 'point',
|
|
capacity: 1,
|
|
point: { sizePx: 1 },
|
|
}),
|
|
/already/,
|
|
);
|
|
set.destroy();
|
|
assert.deepEqual(engine.movers.list(), []);
|
|
assert.equal(engine.fake.moverSet('flights'), undefined);
|
|
});
|
|
|
|
test('fake lines keep their positions, colour, matrix and visibility', () => {
|
|
const engine = createFakeEngine();
|
|
const line = engine.lines.createLine({
|
|
id: 'trail',
|
|
widthPx: 2,
|
|
color: [1, 0, 0, 1],
|
|
});
|
|
line.setPositions([
|
|
{ x: 1, y: 2, z: 3 },
|
|
{ x: 4, y: 5, z: 6 },
|
|
]);
|
|
line.show(false);
|
|
const stored = engine.fake.line('trail');
|
|
assert.deepEqual([...stored.positions], [1, 2, 3, 4, 5, 6]);
|
|
assert.deepEqual(stored.color, [1, 0, 0, 1]);
|
|
assert.equal(stored.shown, false);
|
|
assert.deepEqual(engine.lines.list(), [
|
|
{ id: 'trail', points: 2, shown: false },
|
|
]);
|
|
line.destroy();
|
|
assert.equal(engine.fake.line('trail'), undefined);
|
|
});
|
|
|
|
test('input listeners asking for picks get the pick and the drill in the payload', () => {
|
|
const engine = createFakeEngine();
|
|
engine.fake.script('pick', (screen) =>
|
|
screen.x === 10
|
|
? { id: 'ae01ce', owner: 'flights', instance: 3 }
|
|
: undefined,
|
|
);
|
|
engine.fake.script('drillPick', (screen, limit) =>
|
|
[{ id: 'a' }, { id: 'b' }, { id: 'c' }].slice(0, limit),
|
|
);
|
|
const seen = [];
|
|
engine.input.on('click', (event) => seen.push(['plain', event]));
|
|
engine.input.on('click', (event) => seen.push(['pick', event]), {
|
|
pick: true,
|
|
drill: 2,
|
|
});
|
|
engine.input.on('move', (event) => seen.push(['hover', event]), {
|
|
pick: true,
|
|
});
|
|
engine.fake.input('click', { position: { x: 10, y: 5 } });
|
|
engine.fake.input('move', {
|
|
startPosition: { x: 0, y: 0 },
|
|
endPosition: { x: 10, y: 5 },
|
|
});
|
|
engine.fake.input('click', { position: { x: 99, y: 5 } });
|
|
assert.deepEqual(seen[0], ['plain', { position: { x: 10, y: 5 } }]);
|
|
assert.deepEqual(seen[1][1].picked, {
|
|
id: 'ae01ce',
|
|
owner: 'flights',
|
|
instance: 3,
|
|
});
|
|
assert.deepEqual(seen[1][1].drilled, [{ id: 'a' }, { id: 'b' }]);
|
|
assert.deepEqual(seen[2][1].picked.id, 'ae01ce');
|
|
assert.equal(seen[2][1].drilled, undefined, 'no drill unless asked');
|
|
assert.equal(seen[4][1].picked, undefined);
|
|
assert.throws(
|
|
() => engine.input.on('click', () => {}, { drill: -1 }),
|
|
TypeError,
|
|
);
|
|
assert.throws(
|
|
() => engine.input.on('up', () => {}, { pick: true }),
|
|
TypeError,
|
|
);
|
|
});
|
|
|
|
test('input rejects invalid pick windows and forwards copied windows on down and move', () => {
|
|
const engine = createFakeEngine();
|
|
for (const pickWindow of [
|
|
null,
|
|
{},
|
|
{ width: 0, height: 9 },
|
|
{ width: 9, height: 0.5 },
|
|
{ width: Infinity, height: 1 },
|
|
])
|
|
assert.throws(
|
|
() => engine.input.on('click', () => {}, { pick: true, pickWindow }),
|
|
TypeError,
|
|
);
|
|
assert.throws(
|
|
() =>
|
|
engine.input.on('click', () => {}, {
|
|
pickWindow: { width: 9, height: 9 },
|
|
}),
|
|
TypeError,
|
|
);
|
|
const picked = [];
|
|
engine.fake.script('pick', (at, w, h) => ({ id: `${w}:${h}` }));
|
|
const pickWindow = { width: 11, height: 7 };
|
|
engine.input.on('down', (event) => picked.push(event.picked.id), {
|
|
pick: true,
|
|
pickWindow,
|
|
});
|
|
pickWindow.width = 1;
|
|
engine.fake.input('down', { position: { x: 2, y: 3 } });
|
|
assert.deepEqual(picked, ['11:7']);
|
|
engine.destroy();
|
|
});
|