mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-17 08:42:21 +00:00
Move Cesium viewer, map, sky, projection, trail and sonar internals into its engine. Drive styles, bloom, sharpening and contact sonar through engine.render. Count camera-input suspensions across all three engines and migrate the feature callers. Preserve Cesium's effects and input behaviour; fix transit lens clicks on Cesium and make zero sharpening on Navara disable sharpening, as it does on Cesium. Parse imported files into plain records and draw them through movers, lines, ground and imagery on both engines. Follow Cesium's KML style precedence, preserve local KMZ images and frame the drawable records. Open overlays use imagery when the engine has no native map-overlay API. Run every imported-display case on fake and headless Cesium engines. The shared import path retains these known differences from Cesium's old DataSources: wall fills, extruded prisms and gx:LatLonQuad are undrawn; raised polygon fills drape while outlines retain altitude; GroundOverlay rotation, altitude and RGB tint are not applied; rhumb lines become great circles. Ground heights use the loaded surface synchronously instead of waiting for most-detailed sampling. Supported KMZ ground overlays now draw on Navara too. Document the limits rather than claiming full parity. Combine batches B and C because their disjoint path manifests cannot place the shared boundary and format files in a later commit while keeping B independently valid. This combined commit owns the shared docs, package boundaries, format scope, locale catalogs and coupling baseline. Remove five obsolete import strings from all eleven catalogs. Make the load-time source scan include new files and skip deleted paths so the same checks work before and after recording the moves. Coupling: Navara renderer lines fall from 1695 to 1294, Cesium import files from 25 to 9, viewer lines from 1177 to 1026, SDK loads from 4 to 3 and engine-name lines from 62 to 42. No count grows. The full unit suite and the boundary, format and coupling checks pass. Browser validation remains to be run. Browser checks to run GOOGLE_MAPS_API_KEY= CESIUM_ION_TOKEN= npm run dev -- --port 4291 node scripts/qa-contract-suite.mjs http://localhost:4291 node scripts/qa-navara-visual-styles.mjs http://localhost:4291 node scripts/qa-navara-bloom.mjs http://localhost:4291 node scripts/qa-navara-sonar.mjs http://localhost:4291 QA_BASE_URL=http://localhost:4291 node scripts/qa-visual-effects.mjs QA_BASE_URL=http://localhost:4291 node scripts/qa-zoom-out-guard.mjs node scripts/qa-sky-model-lighting.mjs --url http://localhost:4291 node scripts/qa-geo-import.mjs http://localhost:4291 node scripts/qa-geo-import-regressions.mjs http://localhost:4291 node scripts/qa-geo-import-large.mjs http://localhost:4291 node scripts/qa-navara-geo-import.mjs http://localhost:4291 Use the keyless server for every check. Photoreal-only cases remain unverified; do not enable paid tiles to run them.
399 lines
14 KiB
JavaScript
399 lines
14 KiB
JavaScript
import test from 'node:test';
|
||
import assert from 'node:assert/strict';
|
||
import * as Cesium from 'cesium';
|
||
import { MAP_STACKS } from '../../maps/catalog.js';
|
||
import { createDefaultMapSources } from '../../maps/defaultSources.js';
|
||
import { ESRI_ATTRIBUTION_HTML } from './mapImagery.js';
|
||
import { createCesiumMaps } from './maps.js';
|
||
import { createFakeViewer } from './testing/fakeViewer.mjs';
|
||
|
||
function setup(options = {}) {
|
||
const viewer = createFakeViewer();
|
||
const renders = [];
|
||
const { maps, destroy } = createCesiumMaps(viewer, {
|
||
requestRender: (reason) => renders.push(reason),
|
||
createImageryLayer: (provider) => ({ provider }),
|
||
...options,
|
||
});
|
||
return { viewer, maps, destroy, renders };
|
||
}
|
||
|
||
const tileset = (show = false) => ({
|
||
show,
|
||
destroyed: false,
|
||
isDestroyed() {
|
||
return this.destroyed;
|
||
},
|
||
destroy() {
|
||
this.destroyed = true;
|
||
},
|
||
});
|
||
|
||
test('creation leaves the viewer untouched', () => {
|
||
const { viewer, maps } = setup({ tilesetRef: { current: tileset(true) } });
|
||
assert.deepEqual(viewer.calls, []);
|
||
assert.equal(viewer.scene.globe.show, true);
|
||
assert.equal(maps.photorealActive(), true, 'reads the shown tileset');
|
||
});
|
||
|
||
test('setBaseImagery takes a registry source and puts its layer at the bottom', async () => {
|
||
const { viewer, maps, renders } = setup();
|
||
const provider = { name: 'esri' };
|
||
const source = {
|
||
descriptor: { id: 'esri-imagery', kind: 'esri-imagery' },
|
||
imagery: async () => provider,
|
||
credit: ESRI_ATTRIBUTION_HTML,
|
||
};
|
||
viewer.imageryList.push({ name: 'weather overlay' });
|
||
await maps.setBaseImagery(source);
|
||
assert.deepEqual(viewer.imageryList[0], { provider });
|
||
assert.equal(viewer.callsOf('imageryLayers.add')[0].args[1], 0);
|
||
assert.deepEqual(
|
||
viewer.staticCredits.map((credit) => credit.html),
|
||
[ESRI_ATTRIBUTION_HTML],
|
||
);
|
||
assert.ok(renders.length > 0);
|
||
|
||
const osmProvider = { name: 'osm' };
|
||
await maps.setBaseImagery({
|
||
descriptor: { id: 'osm', kind: 'osm' },
|
||
imagery: () => osmProvider,
|
||
});
|
||
const [removed, destroyLayer] = viewer.callsOf('imageryLayers.remove')[0]
|
||
.args;
|
||
assert.deepEqual(removed, { provider });
|
||
assert.equal(destroyLayer, true);
|
||
assert.deepEqual(
|
||
viewer.imageryList.map((layer) => layer.provider?.name ?? layer.name),
|
||
['osm', 'weather overlay'],
|
||
);
|
||
assert.deepEqual(viewer.staticCredits, [], 'the Esri credit leaves with it');
|
||
});
|
||
|
||
test('setBaseImagery builds providers from plain descriptions', async () => {
|
||
const { viewer, maps } = setup();
|
||
await maps.setBaseImagery({ kind: 'osm' });
|
||
assert.ok(
|
||
viewer.imageryList[0].provider instanceof
|
||
Cesium.OpenStreetMapImageryProvider,
|
||
);
|
||
await assert.rejects(
|
||
maps.setBaseImagery({ kind: 'ion', style: 2, accessToken: '' }),
|
||
/explicit token/,
|
||
);
|
||
assert.ok(
|
||
viewer.imageryList[0].provider instanceof
|
||
Cesium.OpenStreetMapImageryProvider,
|
||
'a failed switch keeps the current layer',
|
||
);
|
||
});
|
||
|
||
test('every catalog globe stack works as a registry source', async () => {
|
||
const { viewer, maps } = setup();
|
||
const registry = createDefaultMapSources();
|
||
const osm = registry.sources.find(
|
||
({ descriptor }) => descriptor.id === 'osm',
|
||
);
|
||
await maps.setBaseImagery(osm);
|
||
assert.ok(
|
||
viewer.imageryList[0].provider instanceof
|
||
Cesium.OpenStreetMapImageryProvider,
|
||
);
|
||
assert.ok(MAP_STACKS.some(({ id }) => id === 'osm'));
|
||
});
|
||
|
||
test('a superseded imagery switch is dropped', async () => {
|
||
const { viewer, maps, destroy } = setup();
|
||
let release;
|
||
const slow = new Promise((resolve) => (release = resolve));
|
||
const first = maps.setBaseImagery({
|
||
descriptor: { id: 'slow', kind: 'esri-imagery' },
|
||
imagery: () => slow,
|
||
});
|
||
await maps.setBaseImagery({
|
||
descriptor: { id: 'fast', kind: 'osm' },
|
||
imagery: () => ({ name: 'fast' }),
|
||
});
|
||
const stale = {
|
||
name: 'slow',
|
||
destroyed: false,
|
||
destroy() {
|
||
this.destroyed = true;
|
||
},
|
||
};
|
||
release(stale);
|
||
await first;
|
||
assert.deepEqual(
|
||
viewer.imageryList.map((layer) => layer.provider.name),
|
||
['fast'],
|
||
);
|
||
assert.equal(stale.destroyed, false, 'the stale provider stays cached');
|
||
destroy();
|
||
await new Promise((resolve) => setImmediate(resolve));
|
||
assert.equal(stale.destroyed, true, 'destroy disposes cached providers');
|
||
});
|
||
|
||
test('re-applying the same source keeps the live layer and its provider', async () => {
|
||
const { viewer, maps } = setup();
|
||
let built = 0;
|
||
const esri = {
|
||
descriptor: { id: 'esri-imagery', kind: 'esri-imagery' },
|
||
imagery: async () => ({ name: `esri ${++built}` }),
|
||
credit: ESRI_ATTRIBUTION_HTML,
|
||
};
|
||
await maps.setBaseImagery(esri);
|
||
const live = viewer.imageryList[0];
|
||
await maps.setBaseImagery(esri);
|
||
assert.equal(built, 1, 'the provider is cached per source');
|
||
assert.equal(viewer.imageryList[0], live, 'no bare-globe rebuild');
|
||
assert.equal(viewer.callsOf('imageryLayers.add').length, 1);
|
||
assert.equal(viewer.callsOf('imageryLayers.remove').length, 0);
|
||
await maps.setBaseImagery({
|
||
descriptor: { id: 'osm', kind: 'osm' },
|
||
imagery: () => ({ name: 'osm' }),
|
||
});
|
||
await maps.setBaseImagery(esri);
|
||
assert.equal(built, 1);
|
||
assert.equal(viewer.imageryList[0].provider.name, 'esri 1');
|
||
});
|
||
|
||
test('a failed provider keeps the current layer and can be retried', async () => {
|
||
const { viewer, maps } = setup();
|
||
await maps.setBaseImagery({
|
||
descriptor: { id: 'osm', kind: 'osm' },
|
||
imagery: () => ({ name: 'osm' }),
|
||
});
|
||
let attempts = 0;
|
||
const flaky = {
|
||
descriptor: { id: 'esri-imagery', kind: 'esri-imagery' },
|
||
imagery: async () => {
|
||
if (++attempts === 1) throw new Error('Esri metadata refused');
|
||
return { name: 'esri' };
|
||
},
|
||
credit: ESRI_ATTRIBUTION_HTML,
|
||
};
|
||
await assert.rejects(maps.setBaseImagery(flaky), /metadata refused/);
|
||
assert.deepEqual(
|
||
viewer.imageryList.map((layer) => layer.provider.name),
|
||
['osm'],
|
||
);
|
||
assert.deepEqual(viewer.staticCredits, []);
|
||
await maps.setBaseImagery(flaky);
|
||
assert.equal(attempts, 2, 'the failure was not cached');
|
||
assert.equal(viewer.imageryList[0].provider.name, 'esri');
|
||
});
|
||
|
||
test('setTerrain applies provider and terrain results', async () => {
|
||
const { viewer, maps } = setup();
|
||
await maps.setTerrain({ kind: 'ellipsoid' });
|
||
assert.ok(viewer.terrainProvider instanceof Cesium.EllipsoidTerrainProvider);
|
||
const provider = { name: 'keyless' };
|
||
await maps.setTerrain({ id: 'keyless', create: async () => ({ provider }) });
|
||
assert.equal(viewer.terrainProvider, provider);
|
||
const terrain = { name: 'terrain object' };
|
||
await maps.setTerrain({ id: 'world', create: async () => ({ terrain }) });
|
||
assert.equal(viewer.callsOf('scene.setTerrain')[0].args[0], terrain);
|
||
await assert.rejects(
|
||
maps.setTerrain({ kind: 'world', accessToken: ' ' }),
|
||
/explicit ion token/,
|
||
);
|
||
});
|
||
|
||
test('setPhotorealTiles shows a given tileset and hides the globe; null reverses it', async () => {
|
||
const { viewer, maps } = setup();
|
||
const google = tileset();
|
||
await maps.setPhotorealTiles({ tileset: google });
|
||
assert.equal(viewer.primitiveList.includes(google), true);
|
||
assert.equal(google.show, true);
|
||
assert.equal(viewer.scene.globe.show, false);
|
||
assert.equal(maps.photorealActive(), true);
|
||
await maps.setPhotorealTiles(null);
|
||
assert.equal(google.show, false);
|
||
assert.equal(viewer.scene.globe.show, true);
|
||
assert.equal(maps.photorealActive(), false);
|
||
await maps.setPhotorealTiles({ tileset: google });
|
||
assert.equal(viewer.callsOf('primitives.add').length, 1, 'added once');
|
||
});
|
||
|
||
test('setPhotorealTiles(null) also hides the startup tileset', async () => {
|
||
const startup = tileset(true);
|
||
const { viewer, maps } = setup({ tilesetRef: () => startup });
|
||
viewer.scene.globe.show = false;
|
||
await maps.setPhotorealTiles(null);
|
||
assert.equal(startup.show, false);
|
||
assert.equal(viewer.scene.globe.show, true);
|
||
assert.equal(maps.photorealActive(), false);
|
||
await maps.setPhotorealTiles({ tileset: startup });
|
||
assert.equal(startup.show, true);
|
||
assert.equal(maps.photorealActive(), true);
|
||
});
|
||
|
||
test('setPhotorealTiles loads from credentials and owns the result', async () => {
|
||
const loaded = tileset();
|
||
const requests = [];
|
||
const { viewer, maps, destroy } = setup({
|
||
loadPhotorealTileset: async (credentials) => {
|
||
requests.push(credentials);
|
||
return {
|
||
tileset: requests.length === 1 ? loaded : null,
|
||
errors: [new Error('refused')],
|
||
};
|
||
},
|
||
});
|
||
await maps.setPhotorealTiles({ googleApiKey: 'browser-key' });
|
||
assert.deepEqual(requests[0], { googleApiKey: 'browser-key' });
|
||
assert.equal(loaded.show, true);
|
||
assert.equal(maps.photorealActive(), true);
|
||
await assert.rejects(maps.setPhotorealTiles({ cesiumToken: 'x' }), /refused/);
|
||
assert.equal(loaded.show, true, 'a failed load keeps the current tiles');
|
||
destroy();
|
||
assert.equal(viewer.primitiveList.includes(loaded), false);
|
||
assert.equal(loaded.destroyed, true);
|
||
});
|
||
|
||
test('destroy removes the engine imagery layer and its credit', async () => {
|
||
const { viewer, maps, destroy } = setup();
|
||
await maps.setBaseImagery({
|
||
descriptor: { id: 'esri-imagery', kind: 'esri-imagery' },
|
||
imagery: () => ({ name: 'esri' }),
|
||
credit: ESRI_ATTRIBUTION_HTML,
|
||
});
|
||
destroy();
|
||
assert.deepEqual(viewer.imageryList, []);
|
||
assert.deepEqual(viewer.staticCredits, []);
|
||
});
|
||
|
||
const esriSource = (provider = { name: 'esri' }) => ({
|
||
descriptor: { id: 'esri-imagery', kind: 'esri-imagery' },
|
||
imagery: () => provider,
|
||
credit: ESRI_ATTRIBUTION_HTML,
|
||
});
|
||
const credits = (viewer) => viewer.staticCredits.map((credit) => credit.html);
|
||
|
||
test('setPhotorealTiles(null) clears the photoreal credit and restores the base imagery', async () => {
|
||
const { viewer, maps } = setup();
|
||
const provider = { name: 'esri' };
|
||
await maps.setBaseImagery(esriSource(provider));
|
||
await maps.setPhotorealTiles({ tileset: tileset(), credit: 'Google' });
|
||
assert.deepEqual(viewer.imageryList, []);
|
||
assert.deepEqual(credits(viewer), ['Google']);
|
||
await maps.setPhotorealTiles(null);
|
||
assert.deepEqual(viewer.imageryList, [{ provider }], 'base layer back');
|
||
assert.deepEqual(credits(viewer), [ESRI_ATTRIBUTION_HTML]);
|
||
assert.equal(viewer.scene.globe.show, true);
|
||
});
|
||
|
||
test('setPhotorealTiles(null) before any base imagery shows no credit', async () => {
|
||
const { viewer, maps } = setup();
|
||
await maps.setPhotorealTiles({ tileset: tileset(), credit: 'Google' });
|
||
await maps.setPhotorealTiles(null);
|
||
assert.deepEqual(credits(viewer), []);
|
||
assert.deepEqual(viewer.imageryList, []);
|
||
});
|
||
|
||
test('base imagery then setPhotorealTiles(null) keeps the base layer and its credit', async () => {
|
||
const { viewer, maps } = setup();
|
||
const provider = { name: 'esri' };
|
||
await maps.setPhotorealTiles({ tileset: tileset(), credit: 'Google' });
|
||
await maps.setBaseImagery(esriSource(provider));
|
||
await maps.setPhotorealTiles(null);
|
||
assert.deepEqual(viewer.imageryList, [{ provider }]);
|
||
assert.equal(viewer.callsOf('imageryLayers.add').length, 1, 'not rebuilt');
|
||
assert.deepEqual(credits(viewer), [ESRI_ATTRIBUTION_HTML]);
|
||
});
|
||
|
||
test('a newer photoreal switch supersedes a pending imagery switch', async () => {
|
||
const { viewer, maps } = setup();
|
||
let resolve;
|
||
const pending = maps.setBaseImagery({
|
||
descriptor: { id: 'slow', kind: 'osm' },
|
||
imagery: () => new Promise((done) => (resolve = done)),
|
||
credit: 'slow credit',
|
||
});
|
||
await maps.setPhotorealTiles({ tileset: tileset(), credit: 'Google' });
|
||
resolve({ name: 'slow' });
|
||
await pending;
|
||
assert.deepEqual(viewer.imageryList, []);
|
||
assert.deepEqual(credits(viewer), ['Google']);
|
||
assert.equal(viewer.scene.globe.show, false);
|
||
});
|
||
|
||
test('switching between two tilesets hides the one shown before', async () => {
|
||
const { maps } = setup();
|
||
const first = tileset();
|
||
const second = tileset();
|
||
await maps.setPhotorealTiles({ tileset: first });
|
||
await maps.setPhotorealTiles({ tileset: second });
|
||
assert.equal(first.show, false);
|
||
assert.equal(second.show, true);
|
||
await maps.setPhotorealTiles(null);
|
||
assert.equal(second.show, false);
|
||
});
|
||
|
||
test('a source with a ready provider is shown as is and stays its caller’s', async () => {
|
||
const { viewer, maps, destroy } = setup();
|
||
let destroyed = 0;
|
||
const provider = { name: 'owned', destroy: () => destroyed++ };
|
||
const source = {
|
||
descriptor: { id: 'osm', kind: 'osm' },
|
||
provider,
|
||
credit: 'c',
|
||
};
|
||
await maps.setBaseImagery(source);
|
||
assert.deepEqual(viewer.imageryList, [{ provider }]);
|
||
const other = { name: 'other' };
|
||
await maps.setBaseImagery({ ...source, provider: other });
|
||
assert.deepEqual(
|
||
viewer.imageryList,
|
||
[{ provider: other }],
|
||
'not cached by id',
|
||
);
|
||
destroy();
|
||
assert.equal(destroyed, 0, 'the engine does not dispose a caller provider');
|
||
});
|
||
|
||
test('releasePhotorealTiles forgets a tileset and removes it from the scene', async () => {
|
||
const { viewer, maps } = setup();
|
||
const owned = tileset();
|
||
await maps.setPhotorealTiles({ tileset: owned });
|
||
await maps.setPhotorealTiles(null);
|
||
maps.releasePhotorealTiles({ tileset: owned });
|
||
assert.equal(viewer.primitiveList.includes(owned), false);
|
||
assert.equal(maps.photorealActive(), false);
|
||
owned.show = true;
|
||
assert.equal(
|
||
maps.photorealActive(),
|
||
false,
|
||
'no longer one of the engine tilesets',
|
||
);
|
||
maps.releasePhotorealTiles({ tileset: owned });
|
||
assert.equal(viewer.callsOf('primitives.remove').length, 1, 'idempotent');
|
||
});
|
||
|
||
test('releasePhotorealTiles leaves a tileset the engine did not add in the scene', async () => {
|
||
const { viewer, maps } = setup();
|
||
const startup = tileset(true);
|
||
viewer.primitiveList.push(startup);
|
||
await maps.setPhotorealTiles({ tileset: startup });
|
||
maps.releasePhotorealTiles({ tileset: startup });
|
||
assert.equal(viewer.primitiveList.includes(startup), true);
|
||
});
|
||
|
||
test('current names the sources on screen as passed', async () => {
|
||
const { maps } = setup();
|
||
assert.deepEqual(maps.current(), { baseImagery: null, photoreal: null });
|
||
const esri = esriSource();
|
||
const tiles = { tileset: tileset(), credit: 'Google' };
|
||
await maps.setBaseImagery(esri);
|
||
assert.deepEqual(maps.current(), { baseImagery: esri, photoreal: null });
|
||
await maps.setPhotorealTiles(tiles);
|
||
assert.equal(maps.current().photoreal, tiles);
|
||
assert.equal(maps.current().baseImagery, null);
|
||
await maps.setPhotorealTiles(null);
|
||
assert.equal(maps.current().baseImagery, esri);
|
||
assert.equal(maps.current().photoreal, null);
|
||
await maps.setPhotorealTiles(tiles);
|
||
maps.releasePhotorealTiles(tiles);
|
||
assert.equal(maps.current().photoreal, null, 'a released source is gone');
|
||
});
|