mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 08:12:24 +00:00
Drops from the contract, the stub, the Cesium renderer and the conformance suite: agent paths, renderer-propagated orbits and celestial draws (orbits stay drawn as icons and inertial lines), scalar raster fields, lodGroup, volume classification, icon eye offsets, the dash gap colour, box shapes, courseBlendMs (courseGlide covers easing), relief surface shading, globe clouds and water, sky atmosphere tuning, heightmap and quantized-mesh terrain, WMTS and ArcGIS imagery, the batched cached height read, the quality benchmark and the animated-style and overlay pixel-ratio knobs. Capabilities clouds, water, celestial, agents, orbits and benchmark go with them. The lodGroup check becomes a displayRange check across two sets, the height-query check uses an extruded polygon in place of a box, the shape scenes draw extruded blocks where they drew boxes, and the fields scene draws a raster shell. The shape references are recorded again.
277 lines
9.3 KiB
JavaScript
277 lines
9.3 KiB
JavaScript
import assert from 'node:assert/strict';
|
|
import * as Cesium from 'cesium';
|
|
import test from 'node:test';
|
|
import { bindRenderer, drawOf, findQuery, queryOf } from '../rendererOf.js';
|
|
import './query.js';
|
|
|
|
/**
|
|
* A viewer's scene with what the draw and query ports touch: primitives,
|
|
* frame events, picks, and height samples that record what they see
|
|
* through.
|
|
*/
|
|
function fakeViewer() {
|
|
const added = [];
|
|
const sampled = [];
|
|
const scene = {
|
|
added,
|
|
sampled,
|
|
preRender: new Cesium.Event(),
|
|
postRender: new Cesium.Event(),
|
|
frameState: { mode: Cesium.SceneMode.SCENE3D },
|
|
camera: {
|
|
positionWC: new Cesium.Cartesian3(2e7, 0, 0),
|
|
pickEllipsoid: (s) =>
|
|
s.x === 50 && s.y === 50 ? new Cesium.Cartesian3(6378137, 0, 0) : null,
|
|
},
|
|
primitives: {
|
|
add: (primitive) => (added.push(primitive), primitive),
|
|
remove: (primitive) => {
|
|
const at = added.indexOf(primitive);
|
|
if (at >= 0) added.splice(at, 1);
|
|
return at >= 0;
|
|
},
|
|
length: 0,
|
|
},
|
|
picked: undefined,
|
|
pick() {
|
|
return this.picked;
|
|
},
|
|
drillPick() {
|
|
return this.picked ? [this.picked] : [];
|
|
},
|
|
sampleHeightSupported: true,
|
|
sampleHeight(carto, exclude) {
|
|
sampled.push(exclude);
|
|
return 12;
|
|
},
|
|
updateHeight: () => () => {},
|
|
getHeight: () => undefined,
|
|
requestRender() {},
|
|
isDestroyed: () => false,
|
|
};
|
|
return { scene };
|
|
}
|
|
|
|
test('a viewer of its own, with no renderer bound, is queried through a built port over its draw sets', () => {
|
|
const viewer = fakeViewer();
|
|
const { scene } = viewer;
|
|
const query = queryOf(viewer);
|
|
assert.equal(findQuery(viewer), query, 'one per viewer');
|
|
|
|
const ground = drawOf(viewer).points({
|
|
id: 'mine',
|
|
includeInHeightQueries: true,
|
|
});
|
|
ground.set([
|
|
{ id: 'a', pos: { lon: 0, lat: 0 }, pixelSize: 4, meta: { n: 1 } },
|
|
]);
|
|
const other = drawOf(viewer).points({ id: 'theirs' });
|
|
other.set([{ id: 'b', pos: { lon: 1, lat: 0 }, pixelSize: 4 }]);
|
|
const idsOf = (exclude) => exclude.map((id) => `${id.set}:${id.id}`).sort();
|
|
|
|
// Heights see through the sets not drawn as ground, and those excluded.
|
|
assert.equal(query.sampleHeightNow({ lon: 0, lat: 0 }), 12);
|
|
assert.deepEqual(idsOf(scene.sampled.at(-1)), ['theirs:b']);
|
|
query.sampleHeightNow({ lon: 0, lat: 0 }, { exclude: ['mine'] });
|
|
assert.deepEqual(idsOf(scene.sampled.at(-1)), ['mine:a', 'theirs:b']);
|
|
|
|
// Picks name the set's item.
|
|
scene.picked = { id: scene.added[0].get(0).id };
|
|
assert.deepEqual(query.pick(5, 5), {
|
|
set: 'mine',
|
|
id: 'a',
|
|
meta: { n: 1 },
|
|
surface: false,
|
|
});
|
|
|
|
// The screen centre's ellipsoid point, and the horizon from the eye.
|
|
assert.deepEqual(query.pickEllipsoid(50, 50), { x: 6378137, y: 0, z: 0 });
|
|
assert.equal(query.pickEllipsoid(0, 0), null);
|
|
assert.equal(query.isOccluded({ x: 6378137, y: 0, z: 0 }), false);
|
|
assert.equal(query.isOccluded({ x: -6378137, y: 0, z: 0 }), true);
|
|
// The horizon follows the eye.
|
|
Cesium.Cartesian3.fromElements(-2e7, 0, 0, scene.camera.positionWC);
|
|
assert.equal(query.isOccluded({ x: 6378137, y: 0, z: 0 }), true);
|
|
assert.equal(query.isOccluded({ x: -6378137, y: 0, z: 0 }), false);
|
|
Cesium.Cartesian3.fromElements(2e7, 0, 0, scene.camera.positionWC);
|
|
|
|
// A renderer bound later answers new callers.
|
|
const unbind = bindRenderer(viewer, { query: { id: 'renderer' } });
|
|
assert.equal(findQuery(viewer).id, 'renderer');
|
|
unbind();
|
|
assert.notEqual(findQuery(viewer), query, 'built again once unbound');
|
|
ground.dispose();
|
|
other.dispose();
|
|
});
|
|
|
|
test('terrain heights answer without depth textures; the drawn surface does not', () => {
|
|
const viewer = fakeViewer();
|
|
viewer.scene.sampleHeightSupported = false;
|
|
viewer.scene.globe = { getHeight: () => 2600 };
|
|
const query = queryOf(viewer);
|
|
const point = { lon: 1, lat: 2 };
|
|
assert.equal(query.sampleHeightNow(point, { against: 'terrain' }), 2600);
|
|
assert.equal(query.sampleHeightNow(point), null);
|
|
});
|
|
|
|
test('nothing to query, no port', () => {
|
|
assert.equal(findQuery({ scene: {} }), null);
|
|
assert.throws(() => queryOf({ scene: {} }), /no renderer to query/);
|
|
assert.throws(
|
|
() => queryOf({ scene: {}, isDestroyed: () => true }),
|
|
/destroyed/,
|
|
);
|
|
});
|
|
|
|
test('a query port built before its viewer can draw sees the sets drawn later, and goes with the viewer', () => {
|
|
const viewer = fakeViewer();
|
|
const { scene } = viewer;
|
|
const primitives = scene.primitives;
|
|
scene.primitives = undefined;
|
|
const query = queryOf(viewer);
|
|
assert.equal(query.pick(5, 5)?.set, undefined, 'nothing drawn yet');
|
|
scene.primitives = primitives;
|
|
const set = drawOf(viewer).points({ id: 'later' });
|
|
set.set([{ id: 'a', pos: { lon: 0, lat: 0 }, pixelSize: 4 }]);
|
|
scene.picked = { id: scene.added[0].get(0).id };
|
|
assert.equal(query.pick(5, 5)?.set, 'later', 'its sets are picked');
|
|
query.sampleHeightNow({ lon: 0, lat: 0 }, { exclude: ['later'] });
|
|
assert.deepEqual(
|
|
scene.sampled.at(-1).map((id) => id.set),
|
|
['later'],
|
|
'and seen through',
|
|
);
|
|
set.dispose();
|
|
viewer.isDestroyed = () => true;
|
|
assert.equal(findQuery(viewer), null, 'gone with its viewer');
|
|
});
|
|
|
|
test('a height sample hides the sets it sees through for that sample alone', () => {
|
|
const viewer = fakeViewer();
|
|
const { scene } = viewer;
|
|
const shownWhileSampling = [];
|
|
scene.sampleHeight = (carto, exclude) => {
|
|
scene.sampled.push(exclude);
|
|
shownWhileSampling.push(scene.added.map((host) => host.show));
|
|
return 12;
|
|
};
|
|
const query = queryOf(viewer);
|
|
const ground = drawOf(viewer).points({
|
|
id: 'ground',
|
|
includeInHeightQueries: true,
|
|
});
|
|
ground.set([{ id: 'a', pos: { lon: 0, lat: 0 }, pixelSize: 4 }]);
|
|
const markers = drawOf(viewer).points({ id: 'markers' });
|
|
markers.set([{ id: 'b', pos: { lon: 1, lat: 0 }, pixelSize: 4 }]);
|
|
const hidden = drawOf(viewer).points({ id: 'hidden' });
|
|
hidden.set([{ id: 'c', pos: { lon: 2, lat: 0 }, pixelSize: 4 }]);
|
|
hidden.show = false;
|
|
const [groundHost, markersHost, hiddenHost] = scene.added;
|
|
|
|
assert.equal(query.sampleHeightNow({ lon: 0, lat: 0 }), 12);
|
|
assert.deepEqual(
|
|
shownWhileSampling.at(-1),
|
|
[true, false, false],
|
|
'the markers are hidden while it samples, the ground is not',
|
|
);
|
|
assert.deepEqual(
|
|
scene.sampled
|
|
.at(-1)
|
|
.map((id) => id.set)
|
|
.sort(),
|
|
['hidden', 'markers'],
|
|
'and their items are still seen through',
|
|
);
|
|
assert.equal(groundHost.show, true);
|
|
assert.equal(markersHost.show, true, 'shown again after');
|
|
assert.equal(hiddenHost.show, false, 'a hidden set stays hidden');
|
|
|
|
query.sampleHeightNow({ lon: 0, lat: 0 }, { exclude: ['ground'] });
|
|
assert.deepEqual(shownWhileSampling.at(-1), [false, false, false]);
|
|
assert.deepEqual(
|
|
scene.added.map((host) => host.show),
|
|
[true, true, false],
|
|
);
|
|
|
|
const out = [
|
|
query.sampleHeightNow({ lon: 0, lat: 0 }),
|
|
query.sampleHeightNow({ lon: 1, lat: 0 }),
|
|
];
|
|
assert.deepEqual(out, [12, 12]);
|
|
assert.deepEqual(shownWhileSampling.slice(-2), [
|
|
[true, false, false],
|
|
[true, false, false],
|
|
]);
|
|
assert.deepEqual(
|
|
scene.added.map((host) => host.show),
|
|
[true, true, false],
|
|
);
|
|
|
|
// A sample that throws is a miss, and shows them again.
|
|
scene.sampleHeight = () => {
|
|
throw new Error('lost context');
|
|
};
|
|
assert.equal(query.sampleHeightNow({ lon: 0, lat: 0 }), null);
|
|
assert.deepEqual(
|
|
scene.added.map((host) => host.show),
|
|
[true, true, false],
|
|
);
|
|
|
|
// Terrain samples render nothing, so they hide nothing.
|
|
const before = shownWhileSampling.length;
|
|
scene.globe = { getHeight: () => 5 };
|
|
query.sampleHeightNow({ lon: 0, lat: 0 }, { against: 'terrain' });
|
|
assert.equal(shownWhileSampling.length, before);
|
|
ground.dispose();
|
|
markers.dispose();
|
|
hidden.dispose();
|
|
});
|
|
|
|
test('hiding the sets seen through answers as seeing through their items did, nested samples too', () => {
|
|
const viewer = fakeViewer();
|
|
const { scene } = viewer;
|
|
const query = queryOf(viewer);
|
|
const ground = drawOf(viewer).points({
|
|
id: 'ground',
|
|
includeInHeightQueries: true,
|
|
});
|
|
ground.set([{ id: 'a', pos: { lon: 0, lat: 0 }, pixelSize: 4 }]);
|
|
const markers = drawOf(viewer).points({ id: 'markers' });
|
|
markers.set([{ id: 'b', pos: { lon: 0, lat: 0 }, pixelSize: 4 }]);
|
|
const [groundHost, markersHost] = scene.added;
|
|
// The first thing drawn and not seen through answers: the markers at
|
|
// 100 m, the ground at 50 m, else the surface at 12 m.
|
|
const sees = (host, set, exclude) =>
|
|
host.show && !exclude.some((id) => id.set === set);
|
|
let nested = null;
|
|
scene.sampleHeight = (carto, exclude) => {
|
|
const inner = nested?.();
|
|
nested = null;
|
|
if (inner !== undefined) scene.inner = inner;
|
|
if (sees(markersHost, 'markers', exclude)) return 100;
|
|
if (sees(groundHost, 'ground', exclude)) return 50;
|
|
return 12;
|
|
};
|
|
|
|
assert.equal(query.sampleHeightNow({ lon: 0, lat: 0 }), 50);
|
|
assert.equal(
|
|
query.sampleHeightNow({ lon: 0, lat: 0 }, { exclude: ['ground'] }),
|
|
12,
|
|
);
|
|
// A sample inside one that hid the ground sees it, and leaves it hidden
|
|
// for the outer one.
|
|
nested = () => query.sampleHeightNow({ lon: 0, lat: 0 });
|
|
assert.equal(
|
|
query.sampleHeightNow({ lon: 0, lat: 0 }, { exclude: ['ground'] }),
|
|
12,
|
|
);
|
|
assert.equal(scene.inner, 50);
|
|
assert.deepEqual(
|
|
[groundHost.show, markersHost.show],
|
|
[true, true],
|
|
'all shown after',
|
|
);
|
|
ground.dispose();
|
|
markers.dispose();
|
|
});
|