mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-17 08:42:21 +00:00
- KML/KMZ import: a per-file canvas budget and cache for ground overlays, limits on rings and vertices of raised polygons, overlays across 360° and near the poles, degenerate holes, polar and single-latitude fills, absolute overlays at their altitude, overlay order by drawOrder as on Cesium, and pins on tiles keep their measured height. - Points on the surface: OSM Places and Street Level cones share the surface sampler and sit on the terrain before they are measured, within a sampling budget per pass; Cockpit's contact-dot bank keeps the dot atlas, and a failed fleet model loads again after a pause. - Startup: the loading screen lifts after the share-link view is restored, the retry screen names the failed engine and takes focus, and the fallback toast stays for 6 s. - Engines: an engine switch lands a running camera flight at its destination (camera.completeFlight on both engines), the sighting card leaves focus on the engine picker after a switch, and a Cesium model error stays with the instance that failed. - The MCP panel builds again: its wind-mesh alias resolves to the stub. - QA: the wildlife switch waits for the camera to rest, GBFS --w2 says it needs the dev server, and test fixtures are shared instead of copied.
304 lines
11 KiB
JavaScript
304 lines
11 KiB
JavaScript
import {
|
|
createStandaloneApplication,
|
|
pageEngineKind,
|
|
} from './standalone/application.js';
|
|
import { createRendererCache } from './standalone/rendererCache.js';
|
|
import { describeError } from './standalone/errors.js';
|
|
import { createEngineAddress } from './standalone/engineSwitch.js';
|
|
import {
|
|
DEFAULT_ENGINE_CHOICE,
|
|
ENGINE_NAMES,
|
|
ENGINE_STORAGE_KEY,
|
|
engineOfChoice,
|
|
resolveEngineKind,
|
|
} from './app/engineChoice.js';
|
|
import { createSceneSwitcher } from './standalone/sceneSwitcher.js';
|
|
import { createLayerSession } from './app/layerSession.js';
|
|
import { createSessionDiagnostics } from './app/sessionDiagnostics.js';
|
|
import { useDisplayStore } from './ui/stores/display.js';
|
|
import { applicationPinia } from './ui/vueRuntime.js';
|
|
import { t } from './i18n/index.js';
|
|
import { guardCesiumGlobal } from './app/loadCesium.js';
|
|
|
|
// Cesium.js loads with the first Cesium globe (src/app/loadCesium.js).
|
|
guardCesiumGlobal();
|
|
|
|
// The Vite boundary exposes only undefined, null, or a validated URL.
|
|
const photonSetting = import.meta.env.PHOTON_URL;
|
|
// Every engine start composes the same place-search endpoints.
|
|
const geospatial =
|
|
photonSetting === undefined ? {} : { endpoints: { photon: photonSetting } };
|
|
|
|
const display = useDisplayStore(applicationPinia());
|
|
const loading = document.getElementById('loading-screen');
|
|
let showingStartFailure = false;
|
|
let application;
|
|
let engineSwitch = null;
|
|
// ?parkedMs= shortens how long a parked globe waits before it is released,
|
|
// so a QA scenario can switch back to a released one.
|
|
const renderers = createRendererCache({
|
|
// Navara and Navara HD are one engine: only one of them stays parked.
|
|
engineOf: engineOfChoice,
|
|
parkedMs:
|
|
Number(new URLSearchParams(location.search).get('parkedMs')) || undefined,
|
|
});
|
|
const layerSession = createLayerSession();
|
|
const { signal } = layerSession.lifetime;
|
|
// Which session objects this page holds now (scripts/qa-app-once.mjs).
|
|
const session = createSessionDiagnostics(() => {
|
|
const components = application?.getComponents?.() ?? {};
|
|
const style = components.controls?.styleManager;
|
|
return {
|
|
application,
|
|
shell: style,
|
|
shareLink: style?.shareLinkManager,
|
|
hud: style?.hud,
|
|
navigation: style?._navigation,
|
|
placeSearch: style?.placeSearch,
|
|
dataManager: components.data?.dataManager,
|
|
voice: layerSession.voice?.commands ?? components.tools?.voiceCommands,
|
|
annotations: layerSession.annotations ?? components.tools?.annotations,
|
|
geoImport: window.__gevGeoImport,
|
|
drawTool: window.__gevDrawTool,
|
|
};
|
|
});
|
|
window.__gevSession = session;
|
|
window.addEventListener('pagehide', (event) => {
|
|
if (event.persisted) return;
|
|
layerSession.lifetime.abort();
|
|
void application
|
|
?.destroy()
|
|
.catch(report)
|
|
.finally(() => renderers.clear());
|
|
});
|
|
|
|
// Registered before any engine starts, so it runs ahead of the session's own
|
|
// share-link listeners. A history visit that changes the engine belongs to
|
|
// the switch: the outgoing engine's share link neither restores that entry
|
|
// (releasing the followed subject just before the handoff) nor writes its
|
|
// own view onto it. The incoming engine reads the entry as it starts, and
|
|
// settle() hands the address back to whichever engine then runs.
|
|
window.addEventListener('popstate', () => {
|
|
if (!engineSwitch) return;
|
|
if (requestedEngineKind() !== engineSwitch.state().engine)
|
|
application
|
|
?.getComponents()
|
|
.controls?.styleManager?.shareLinkManager?.holdNavigation?.();
|
|
void engineSwitch.reconcile();
|
|
});
|
|
|
|
function createApplication(kind, engineSwitch, transition) {
|
|
session.count('applications');
|
|
layerSession.restoringView = engineSwitch;
|
|
application = createStandaloneApplication({
|
|
googleApiKey: import.meta.env.GOOGLE_MAPS_API_KEY,
|
|
cesiumToken: import.meta.env.CESIUM_ION_TOKEN,
|
|
geospatial,
|
|
allowQaRegistration: import.meta.env.DEV,
|
|
engineKind: kind,
|
|
rendererCache: renderers,
|
|
layerSession,
|
|
engineSwitch,
|
|
transition,
|
|
});
|
|
return application;
|
|
}
|
|
|
|
// The running application while a globe is attached to it; null while the
|
|
// page has no engine (between engines, or after a failed recovery).
|
|
function liveComponents() {
|
|
if (application?.getState().status !== 'ready') return null;
|
|
const components = application.getComponents();
|
|
return components.scene?.engine ? components : null;
|
|
}
|
|
|
|
// The page's application is created once; a switch detaches and attaches
|
|
// only its engine-bound parts.
|
|
|
|
// Voice calls made while the engines switch wait for the next engine
|
|
// (src/voice/sceneRunner.js); a settled switch lets them look again.
|
|
layerSession.switching = () => engineSwitch?.state().busy === true;
|
|
|
|
function present() {
|
|
const { kind, busy } = engineSwitch.state();
|
|
if (!busy) layerSession.voice?.runner.wake();
|
|
display.presentGlobeEngine({ kind, busy, select });
|
|
for (const button of loading.querySelectorAll('.engine-switch-retry button'))
|
|
button.disabled = busy;
|
|
}
|
|
|
|
// No engine runs after a failed recovery. The error stays on the loading
|
|
// screen with an engine picker, so a new attempt needs no reload.
|
|
function offerEngineRetry() {
|
|
const content = loading.querySelector('.loader-content') ?? loading;
|
|
const existing = content.querySelector('.engine-switch-retry');
|
|
if (existing) {
|
|
existing.querySelector('button')?.focus();
|
|
return;
|
|
}
|
|
const group = document.createElement('div');
|
|
group.className = 'engine-switch-retry';
|
|
group.setAttribute('role', 'group');
|
|
const label = document.createElement('p');
|
|
label.id = 'engine-switch-retry-label';
|
|
label.textContent = t('Choose an engine to try again.');
|
|
group.setAttribute('aria-labelledby', label.id);
|
|
group.append(label);
|
|
for (const [kind, name] of Object.entries(ENGINE_NAMES)) {
|
|
const button = document.createElement('button');
|
|
button.type = 'button';
|
|
button.dataset.engine = kind;
|
|
button.textContent = name;
|
|
button.setAttribute('translate', 'no');
|
|
button.addEventListener('click', () => {
|
|
// The retry's progress replaces the error: no longer an alert.
|
|
loading.querySelector('.loader-status').removeAttribute('role');
|
|
select(kind);
|
|
});
|
|
group.append(button);
|
|
}
|
|
content.append(group);
|
|
group.querySelector('button').focus();
|
|
}
|
|
|
|
function withdrawEngineRetry() {
|
|
loading.querySelector('.engine-switch-retry')?.remove();
|
|
if (!showingStartFailure) return;
|
|
showingStartFailure = false;
|
|
loading.classList.add('hidden');
|
|
}
|
|
|
|
function report(error, kind) {
|
|
showingStartFailure = true;
|
|
console.error("God's Eye View initialization failed:", error);
|
|
const status = loading.querySelector('.loader-status');
|
|
status.setAttribute('role', 'alert');
|
|
status.textContent = kind
|
|
? t('Could not start {engine}: {message}', {
|
|
engine: ENGINE_NAMES[kind] ?? kind,
|
|
message: describeError(error),
|
|
})
|
|
: t('Error: {message}', { message: describeError(error) });
|
|
loading.classList.remove('hidden');
|
|
}
|
|
|
|
// A globe that failed to start while another runs: say which one runs.
|
|
function showStartFailure(error, running) {
|
|
const style = liveComponents()?.controls.styleManager;
|
|
if (!style) return false;
|
|
void Promise.resolve(style.initialRestorePromise).then(() => {
|
|
if (signal.aborted || liveComponents()?.controls.styleManager !== style)
|
|
return;
|
|
style._showToast(
|
|
t('Globe engine failed to start. Running {engine}: {message}', {
|
|
engine: ENGINE_NAMES[running] ?? running,
|
|
message: describeError(error),
|
|
}),
|
|
6000,
|
|
);
|
|
});
|
|
return true;
|
|
}
|
|
|
|
function select(next) {
|
|
if (engineSwitch) void engineSwitch.select(next);
|
|
else if (!starting) void start(next, { rememberChoice: true });
|
|
}
|
|
|
|
// Keep the last visible frame while the first visit initializes the other renderer.
|
|
function keepGlobeFrame(engine) {
|
|
const source = engine.host.canvas;
|
|
const frame = document.createElement('canvas');
|
|
frame.width = source.width;
|
|
frame.height = source.height;
|
|
if (!frame.width || !frame.height) return null;
|
|
const context = frame.getContext('2d');
|
|
if (!context) return null;
|
|
context.drawImage(source, 0, 0);
|
|
frame.className = 'engine-switch-frame';
|
|
frame.setAttribute('aria-hidden', 'true');
|
|
document.getElementById('cesiumContainer').append(frame);
|
|
return frame;
|
|
}
|
|
|
|
let initialKind = pageEngineKind();
|
|
let starting = false;
|
|
const requestedEngineKind = () =>
|
|
resolveEngineKind({ search: location.search, fallback: initialKind });
|
|
|
|
function remember(kind) {
|
|
try {
|
|
localStorage.setItem(ENGINE_STORAGE_KEY, kind);
|
|
} catch {
|
|
// The current URL still carries the choice when storage is blocked.
|
|
}
|
|
}
|
|
|
|
async function start(kind, { fallback = false, rememberChoice = false } = {}) {
|
|
starting = true;
|
|
try {
|
|
await createApplication(kind, false).start();
|
|
if (rememberChoice) {
|
|
initialKind = kind;
|
|
remember(kind);
|
|
createEngineAddress({ location, history }).restore(kind);
|
|
}
|
|
session.count('attachments');
|
|
engineSwitch = createSceneSwitcher({
|
|
kind,
|
|
requested: requestedEngineKind,
|
|
signal,
|
|
getApplication: () => application,
|
|
startApplication: (kind, transition) =>
|
|
createApplication(kind, true, transition),
|
|
layerSession,
|
|
renderers,
|
|
diagnostics: session,
|
|
keepFrame: keepGlobeFrame,
|
|
onSettled: withdrawEngineRetry,
|
|
address: createEngineAddress({
|
|
location,
|
|
history,
|
|
flush: () => {
|
|
const live = liveComponents();
|
|
// A pick made mid-flight hands over the flight's destination, as
|
|
// if it had landed (Cesium's completeFlight), not a midpoint.
|
|
live?.scene.engine.camera.completeFlight();
|
|
live?.controls.styleManager.shareLinkManager?.flush();
|
|
},
|
|
}),
|
|
remember,
|
|
onChange: present,
|
|
onFailure(error, { recovered, kind: running }) {
|
|
if (recovered && showStartFailure(error, running)) return;
|
|
report(error);
|
|
offerEngineRetry();
|
|
},
|
|
});
|
|
if (showingStartFailure)
|
|
await liveComponents()?.controls.styleManager.initialRestorePromise;
|
|
withdrawEngineRetry();
|
|
present();
|
|
// A history visit made while the first engine started.
|
|
void engineSwitch.reconcile();
|
|
} catch (error) {
|
|
await application?.destroy().catch(report);
|
|
if (fallback && kind !== DEFAULT_ENGINE_CHOICE) {
|
|
// A stored choice that cannot start would fail on every visit.
|
|
await start(DEFAULT_ENGINE_CHOICE, { rememberChoice: true });
|
|
showStartFailure(error, DEFAULT_ENGINE_CHOICE);
|
|
} else {
|
|
report(error, kind);
|
|
offerEngineRetry();
|
|
}
|
|
} finally {
|
|
starting = false;
|
|
}
|
|
}
|
|
|
|
void start(initialKind, {
|
|
fallback: !new URLSearchParams(location.search).has('engine'),
|
|
});
|
|
|
|
export { application };
|