Files
gods-eye-view/src/app/navaraMode.js
T

499 lines
17 KiB
JavaScript

import { t } from '../i18n/index.js';
// The experimental Navara mode (?engine=navara) of the application: its
// scene and its viewerless tools. src/app/scene.js and src/app/tools.js load
// this module with import() only in that mode, and it loads the Navara globe
// the same way, so the Cesium-mode bundle carries none of it.
import { DATA_CREDITS, registerDataCredits } from '../data/dataCredits.js';
import { isEmbeddedInline } from './embed.js';
import {
createLayerAvailability,
layerAvailableOn,
registerLayerRenderers,
} from './layers/renderers.js';
import {
governorRequestRender,
installRenderGovernor,
uninstallRenderGovernor,
} from '../renderGovernor.js';
import { attachSessionVoice } from './sessionVoice.js';
import { initNavaraImageryBoxTool } from '../ui/imageryBoxNavara.js';
import {
attachNavaraAnnotations,
attachNavaraDraw,
attachNavaraGeoImport,
} from './navaraTools.js';
import { createRecentImageryPanel } from '../ui/recentImagery.js';
// Native mesh capability stays at the composition boundary.
const navaraViews = new WeakMap();
/** The Navara globe module, loaded on demand. */
const loadNavaraGlobeModule = async () =>
(await import('../globe/navara/index.js')).createNavaraGlobe;
/**
* The shell's notice in the experimental Navara mode (label and detail): the
* data layers this engine shows (its catalog, from the renderer registry)
* and what it does not have.
* @param {import('./layers/renderers.js').LayerAvailability} availability
*/
export function navaraModeNotice(availability) {
const names = availability.available().map(({ name }) => name);
return Object.freeze({
label: t('Experimental Navara engine'),
detail: names.length
? `Data layers: ${names.join(', ')}`
: 'No registered data layers',
});
}
/** Static attribution for the shell and the layers available on Navara. */
const NAVARA_CREDIT_KEYS = new Set([
'photon-geocoder',
'openstreetmap',
'reearth-terrain',
'opensky',
'adsblol',
'adsbdb',
'aisstream',
'celestrak',
'launch-library-2',
'usgs',
'eccc-aqhi',
'wfigs',
's2-ghostmaps',
'telegeography',
'wind-gfs',
'ecmwf-ifs',
'weather-noaa',
'weather-lightning',
'weather-cyclones',
'dams',
'firms',
'gbfs',
'overture-military-names',
'radio-browser',
]);
/**
* Registers the Navara layer renderers (once per page). Each loads only
* here, through import(), so Cesium mode never fetches them.
*/
export async function registerNavaraLayerRenderers() {
const loaders = {
'recent-imagery': async () => {
const { createRecentImageryNavaraRenderer } =
await import('../layers/recentImagery/render/navara.js');
return (engine, options) =>
createRecentImageryNavaraRenderer(engine, {
...options,
...navaraViews.get(engine),
});
},
transit: async () => {
const { createTransitNavaraRenderer } =
await import('../layers/transit/render/navara.js');
return (engine, options) =>
createTransitNavaraRenderer(engine, {
...options,
...navaraViews.get(engine),
});
},
cctv: async () => {
const { createCctvNavaraRenderer } =
await import('../layers/cctv/render/navara.js');
return (engine, options) =>
createCctvNavaraRenderer(engine, {
...options,
...navaraViews.get(engine),
});
},
'alpr-cameras': async () =>
(await import('../layers/alpr/render/navara.js'))
.createAlprNavaraRenderer,
radio: async () =>
(await import('../layers/radio/render/navara.js'))
.createRadioNavaraRenderer,
bikeshare: async () =>
(await import('../layers/bikeshare/render/navara.js'))
.createBikeshareNavaraRenderer,
...Object.fromEntries(
['weather-radar', 'weather-satellite', 'weather-lightning'].map((id) => [
id,
async () => {
const { createWeatherNavaraRenderer } =
await import('../layers/weather/render/navara.js');
return (engine, options) =>
createWeatherNavaraRenderer(
engine,
navaraViews.get(engine),
options,
);
},
]),
),
'bhote-koshi-2026': async () => {
const { createNepalEventDisplay } =
await import('../layers/bhoteKoshi/render/navara.js');
return (engine) =>
createNepalEventDisplay(engine, navaraViews.get(engine));
},
'bhote-koshi-locator': async () => {
const { drawStorySource } =
await import('../layers/shared/render/navaraStory.js');
return (engine, { data }) =>
drawStorySource(engine, navaraViews.get(engine), data);
},
'street-level': async () => {
const { createStreetMap } =
await import('../layers/streetLevel/render/navara.js');
return (engine) => createStreetMap(engine, navaraViews.get(engine));
},
traffic: async () => {
const { createTrafficNavaraRenderer } =
await import('../layers/traffic/render/navara.js');
return (engine) =>
createTrafficNavaraRenderer(engine, navaraViews.get(engine));
},
directions: async () => {
const { createDirectionsNavaraRenderer } =
await import('../layers/directions/render/navara.js');
return (engine) =>
createDirectionsNavaraRenderer(engine, navaraViews.get(engine));
},
'telegeography-submarine-cables': async () => {
const { createNavaraCables } =
await import('../layers/submarineCables/render/navara.js');
return (engine, { overlayHost }) =>
createNavaraCables(engine, navaraViews.get(engine), overlayHost);
},
wind: async () => {
const { createWindNavaraRenderer } =
await import('../layers/wind/render/navara.js');
return (engine) =>
createWindNavaraRenderer(engine, navaraViews.get(engine));
},
'weather-cyclones': async () => {
const { createCyclonesNavaraRenderer } =
await import('../layers/cyclones/render/navara.js');
return (engine, options) =>
createCyclonesNavaraRenderer(
engine,
navaraViews.get(engine).view,
options,
);
},
...Object.fromEntries(
['local-datacenters', 'local-dams'].map((id) => [
id,
async () => {
const { createInfrastructureNavaraRenderer } =
await import('../layers/infrastructure/render/navara.js');
return (engine, { config, services }) =>
createInfrastructureNavaraRenderer(
engine,
navaraViews.get(engine),
config,
services,
);
},
]),
),
's2-ghostmaps': async () => {
const { createGhostMapsNavaraRenderer } =
await import('../layers/ghostMaps/render/navara.js');
return (engine) =>
createGhostMapsNavaraRenderer(engine, navaraViews.get(engine).view);
},
'military-awareness': async () =>
(await import('../layers/awareness/render/navara.js'))
.createAwarenessNavaraRenderer,
'military-installations': async () => {
const { createInstallationsNavaraRenderer } =
await import('../layers/installations/render/navara.js');
return (engine, options) =>
createInstallationsNavaraRenderer(engine, {
...options,
...navaraViews.get(engine),
});
},
'local-firms': async () => {
const { createFirmsNavaraRenderer } =
await import('../layers/firms/render/navara.js');
return (engine, options) =>
createFirmsNavaraRenderer(engine, {
...options,
...navaraViews.get(engine),
});
},
'fire-perimeters': async () => {
const { createPerimetersNavaraRenderer } =
await import('../layers/perimeters/render/navara.js');
return (engine) =>
createPerimetersNavaraRenderer(engine, navaraViews.get(engine));
},
'gnss-integrity': async () => {
const { createGnssNavaraRenderer } =
await import('../layers/gnss/render/navara.js');
return (engine) =>
createGnssNavaraRenderer(engine, navaraViews.get(engine));
},
'air-quality': async () => {
const { createAirQualityNavaraRenderer } =
await import('../layers/airQuality/render/navara.js');
return (engine) =>
createAirQualityNavaraRenderer(engine, navaraViews.get(engine));
},
earthquakes: async () => {
const { createEarthquakesNavaraRenderer } =
await import('../layers/earthquakes/render/navara.js');
return (engine, options) =>
createEarthquakesNavaraRenderer(engine, {
...options,
...navaraViews.get(engine),
});
},
'rocket-launches': async () => {
const { createLaunchesNavaraRenderer } =
await import('../layers/launches/render/navara.js');
return (engine, options) =>
createLaunchesNavaraRenderer(engine, {
...options,
...navaraViews.get(engine),
});
},
satellites: async () =>
(await import('../layers/satellites/render/navara.js'))
.createSatellitesNavaraRenderer,
flights: async () =>
(await import('../layers/flights/render/navara.js'))
.createFlightsNavaraRenderer,
military: async () =>
(await import('../layers/military/render/navara.js'))
.createMilitaryNavaraRenderer,
'local-adsb': async () =>
(await import('../layers/localAdsb/render/navara.js'))
.createLocalAdsbNavaraRenderer,
'ais-live-vessels': async () =>
(await import('../layers/vessels/render/navara.js'))
.createVesselsNavaraRenderer,
};
const missing = Object.keys(loaders).filter(
(id) => !layerAvailableOn(id, 'navara'),
);
if (!missing.length) return;
const factories = await Promise.all(missing.map((id) => loaders[id]()));
// A concurrent call may have registered some meanwhile.
const fresh = Object.fromEntries(
missing
.map((id, index) => [id, factories[index]])
.filter(([id]) => !layerAvailableOn(id, 'navara')),
);
if (Object.keys(fresh).length) registerLayerRenderers('navara', fresh);
}
/**
* The scene on the experimental Navara engine: no viewer and no Cesium
* objects. Navara builds the map sources from the controller's descriptions
* (Google 3D tiles from the browser key, else base imagery) and shows their
* credits in its own attribution UI.
*/
export async function createNavaraScene({
container = document.getElementById('cesiumContainer'),
cesiumToken,
credits,
MapController,
mapOptions,
loaderStatus,
loadNavaraGlobe = loadNavaraGlobeModule,
signal,
defer,
}) {
loaderStatus.textContent = t('Loading the experimental Navara engine...');
const createNavaraGlobe = await loadNavaraGlobe();
signal.throwIfAborted();
const globe = await createNavaraGlobe({
container,
// The cinematic look unless `?look=photoreal|minimal` asks otherwise.
search: globalThis.location?.search ?? '',
});
defer(() => globe.destroy());
const { engine } = globe;
navaraViews.set(engine, {
view: globe.view,
alignDaylightToRestoredView: globe.alignDaylightToRestoredView,
MeshDesc: globe.MeshDesc,
NavaraColor: globe.NavaraColor,
EffectDesc: globe.LayerEffectDesc,
NavaraEffect: globe.NavaraEffect,
DrapedMesh: globe.DrapedMesh,
setupMaterialForDrape: globe.setupMaterialForDrape,
});
defer(() => navaraViews.delete(engine));
// The layers drawn on Navara (their render/navara.js), before the catalog
// asks the registry which layers this engine shows.
await registerNavaraLayerRenderers();
signal.throwIfAborted();
// The tools install the governor on this engine; it goes before the engine.
defer(() => uninstallRenderGovernor(engine));
signal.throwIfAborted();
loaderStatus.textContent = t('Initializing systems...');
const mapStackController = new MapController(null, {
requestRender: governorRequestRender,
engine,
...mapOptions,
cesiumToken,
onChange: (state) => {
window.dispatchEvent(
new CustomEvent('gev:map-stack-changed', { detail: state }),
);
},
onError: (message) => console.warn('[MapStack]', message),
});
defer(() => mapStackController.destroy());
await mapStackController.setStack(mapStackController.getActiveId(), {
silent: true,
});
signal.throwIfAborted();
// After the map's own credits, so Google's copyright lines come first in
// Navara's attribution card.
registerDataCredits(
engine,
(credits ?? DATA_CREDITS).filter(({ key }) => NAVARA_CREDIT_KEYS.has(key)),
);
let packRenderer;
const { createNavaraPackRenderer } =
await import('../scenes/dataPacks/navara.js');
const packGraphics = () =>
(packRenderer ??= createNavaraPackRenderer(
engine,
navaraViews.get(engine),
));
return {
viewer: null,
engine,
packRenderer: {
geometry: (...args) => packGraphics().geometry(...args),
image: (...args) => packGraphics().image(...args),
media: (...args) => packGraphics().media(...args),
},
tileset: null,
suspend() {
uninstallRenderGovernor(engine);
engine.camera.cancelFlight();
engine.render.setContinuous(false);
globe.setRenderLoop(false);
},
resume() {
globe.setRenderLoop(true);
},
mapStackController,
};
}
/**
* The tools without a viewer (the experimental Navara engine), attached to
* one Navara scene: the render governor on the engine, hidden-tab handling,
* the imagery box, the engine notice and voice on the engine. The shell
* shows which features are unavailable. Returns its annotations (none) and
* voice.
*/
export function attachViewerlessTools(
{ engine },
{
data,
operations,
placeSearch,
voice = {},
sceneDirector,
layerSession = null,
styleManager,
},
{ signal, defer },
) {
const { dataManager } = data;
void styleManager.initialRestorePromise?.then(() => {
if (!signal.aborted)
navaraViews.get(engine)?.alignDaylightToRestoredView?.();
});
const recentImagery = dataManager.layers.get('recent-imagery')?.module;
if (recentImagery) {
const tool = initNavaraImageryBoxTool({
engine,
onBox: (box) => recentImagery.setBox(box),
onPreview: (box) => recentImagery.setBoxPreview(box),
onCancel: (reason, message, box) => {
if (message) recentImagery.reportBoxRefusal(message, box);
},
onActive: (active) => recentImagery.setToolActive(active),
onEscape: () => recentImagery.clearPreview(),
});
data.presentation.attachRecentImagery((container) =>
createRecentImageryPanel({
container,
engine,
layer: recentImagery,
tool,
}),
);
const handle = { layer: recentImagery, tool };
window.__gevRecentImagery = handle;
defer(() => {
if (window.__gevRecentImagery === handle)
delete window.__gevRecentImagery;
data.presentation.attachRecentImagery(null);
tool.destroy();
});
}
// Holds drive engine.render.setContinuous; requests go to the engine. A
// parked engine uninstalls it (createNavaraScene suspend).
installRenderGovernor(engine);
const syncVisibility = () => {
if (document.hidden && !isEmbeddedInline()) return;
data.presentation.flushVisible();
governorRequestRender('visibility-restore');
};
document.addEventListener('visibilitychange', syncVisibility);
defer(() => document.removeEventListener('visibilitychange', syncVisibility));
const notice = navaraModeNotice(
data.catalog?.availability ?? createLayerAvailability('navara'),
);
styleManager._showGlobalStatusNotice?.(notice.label, {
state: 'retry',
detail: notice.detail,
persistent: true,
});
// The notice is this engine's: it goes when the engine does.
defer(() => styleManager._clearPersistentStatusNotice?.());
// The page session's annotation board, Draw and Import on this engine
// (src/app/navaraTools.js).
const tools = { engine, view: navaraViews.get(engine) };
const context = { operations, placeSearch, layerSession, styleManager };
const annotations = attachNavaraAnnotations(tools, context, {
signal,
defer,
});
attachNavaraDraw(tools, { ...context, annotations }, { signal, defer });
attachNavaraGeoImport(tools, context, { signal, defer });
// Voice on the engine (phase 3, Task 9): the W1 tools drive the engine;
// the Director uses the shared session; viewer-only tools declare availability.
const voiceCommands = attachSessionVoice({
layerSession,
voice,
operations,
placeSearch,
dataManager,
scene: {
viewer: null,
engine,
styleManager,
sceneDirector,
annotations,
},
signal,
defer,
});
return { annotations, voiceCommands };
}