mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-19 01:32:19 +00:00
* Let an application leave the Data Library out * Changelog fragment for #1815
386 lines
15 KiB
JavaScript
386 lines
15 KiB
JavaScript
import { onFollowChanged } from '../data/followed.js';
|
|
import {
|
|
bootStories,
|
|
stopVoiceForStories,
|
|
storiesOpener,
|
|
} from '../stories/boot.js';
|
|
import { t } from '../i18n/index.js';
|
|
import { useStoriesStore } from '../ui/stores/stories.js';
|
|
import { SceneDirector } from '../scenes/director.js';
|
|
import { initAnnotations } from '../annotations/index.js';
|
|
import { initDrawTool } from '../annotations/drawTool.js';
|
|
import {
|
|
claimPointer,
|
|
isPointerFree,
|
|
releasePointer,
|
|
} from '../data/inputOwnership.js';
|
|
import { initGeoFileImport } from '../ui/geoFileImport.js';
|
|
import { useDisplayStore } from '../ui/stores/display.js';
|
|
import { applicationPinia } from '../ui/vueRuntime.js';
|
|
import { initImageryBoxTool } from '../ui/imageryBoxTool.js';
|
|
import { createRecentImageryPanel } from '../ui/recentImagery.js';
|
|
import { createDataLibrary } from '../library/controller.js';
|
|
import { flyToLibraryExtent } from '../library/camera.js';
|
|
import { createLibraryBrowser } from '../ui/libraryBrowser.js';
|
|
import { useDataLibraryStore } from '../ui/stores/dataLibrary.js';
|
|
import { localGeoJsonServices } from './localGeojsonServices.js';
|
|
import { initGevVoiceCommands } from '../voice/gevRealtime.js';
|
|
import { isStoriesOpen } from '../voice/realtimeInputPolicy.js';
|
|
import { installViews, isEmbeddedInline } from './embed.js';
|
|
import {
|
|
installScopeMask,
|
|
destroyScopeMask,
|
|
isScopeMaskEnabled,
|
|
} from '../scopeMask.js';
|
|
import { KEYHOLE_OUTER_RADIUS } from '../celestialRing.js';
|
|
import { installGlobeInViewRecovery } from './globeInViewRecovery.js';
|
|
import { installLayerReleaseTrim } from '../sceneCommandRelease.js';
|
|
import {
|
|
getRenderGovernorDiagnostics,
|
|
governorRequestRender,
|
|
holdContinuousRender,
|
|
releaseContinuousRender,
|
|
} from '../renderGovernor.js';
|
|
import { entityRecord, readEntityRecord } from '../data/entityRecords.js';
|
|
import { overlayHost } from './layers/overlayHost.js';
|
|
|
|
/**
|
|
* Attach scene tools, rendering listeners and the application debug handle.
|
|
* `scene` is what `createApplicationScene` returns; its `trimStaleCommands`
|
|
* runs after each layer disable (a scene without one keeps that memory).
|
|
* `library.fetchTile` and `library.fetchData` fetch the Data Library's tiles
|
|
* and proxied datasets in place of the defaults (`createLibrarySource`).
|
|
* `library.fetchImpl` asks the library server (its catalog) in place of the
|
|
* page's fetch, for a server that wants the application's own credentials.
|
|
* `library.requireCatalog` offers only what the server's library catalog
|
|
* names, and nothing while it does not answer. `library: false` leaves the
|
|
* Data Library out: no catalog is asked, and no Browse button is drawn.
|
|
*/
|
|
export function createApplicationTools({
|
|
scene,
|
|
controls,
|
|
data,
|
|
loadingScreen,
|
|
placeSearch,
|
|
voice = {},
|
|
startChrome,
|
|
onSceneDirector,
|
|
sceneDataPacks,
|
|
drawMarkActions = [],
|
|
library = {},
|
|
signal,
|
|
defer,
|
|
}) {
|
|
const { viewer, renderer, tileset, mapStackController, operations } = scene;
|
|
const { styleManager, weatherEffects, cockpitCloudEffects } = controls;
|
|
const { dataManager } = data;
|
|
const sceneDirector = new SceneDirector(viewer, styleManager, dataManager, {
|
|
dataPacks: { overlayHost, ...sceneDataPacks },
|
|
isMapStackAvailable: (id) =>
|
|
mapStackController?.isStackAvailable(id) === true,
|
|
});
|
|
dataManager.layers
|
|
.get('bhote-koshi-2026')
|
|
?.module.attachSceneController(sceneDirector);
|
|
defer(() => sceneDirector.destroy());
|
|
defer(
|
|
installGlobeInViewRecovery(viewer, {
|
|
// The scope mask hides everything outside its keyhole.
|
|
keyholeRadius: () => (isScopeMaskEnabled() ? KEYHOLE_OUTER_RADIUS : 0),
|
|
// An authored scene frames its own shots, holds included.
|
|
paused: () => sceneDirector.running,
|
|
}),
|
|
);
|
|
onSceneDirector?.(sceneDirector);
|
|
// Stories: GEV scenes on this globe, from a Stories button. Its screens,
|
|
// styles, story data and controller load on first use.
|
|
const storiesStore = useStoriesStore(applicationPinia());
|
|
let voiceCommands;
|
|
const stories = bootStories({
|
|
// Inline in a host page, the URL and history are the host's.
|
|
available: !isEmbeddedInline(),
|
|
viewer,
|
|
director: sceneDirector,
|
|
store: storiesStore,
|
|
onEnter: () => {
|
|
if (stopVoiceForStories(voiceCommands?.session))
|
|
storiesStore.flashToast(t('Voice is disabled in Stories.'), 4000);
|
|
},
|
|
onLoadFailed: () =>
|
|
styleManager._showToast?.(
|
|
t('Stories could not load. Check the connection and try again.'),
|
|
),
|
|
});
|
|
defer(() => stories.destroy());
|
|
const annotations = initAnnotations({
|
|
viewer,
|
|
tileset,
|
|
placeSearch,
|
|
resolver: operations.annotationResolver,
|
|
});
|
|
defer(() => {
|
|
if (window.__gevAnnotations === annotations) delete window.__gevAnnotations;
|
|
annotations.destroy();
|
|
});
|
|
const displayStore = useDisplayStore(applicationPinia());
|
|
// The Display panel's controls answer through the store; returns the
|
|
// disconnect.
|
|
const connectDisplay = (actions) => {
|
|
const token = displayStore.connect(actions);
|
|
return () => displayStore.detach(token);
|
|
};
|
|
// UTILITIES ▸ Draw: the same whiteboard, drawn by hand. It claims the pointer
|
|
// while a session is open, so its teardown belongs to the application
|
|
// lifetime rather than to whoever last pressed the button. A row's fly-to
|
|
// goes through the shell's navigation policy, as Import's does.
|
|
// `drawMarkActions` are an application's own buttons on a drawn area's or
|
|
// line's row (annotations/drawMarks.js); the standalone shell adds none.
|
|
const drawTool = initDrawTool({
|
|
viewer,
|
|
annotations,
|
|
navigation: styleManager,
|
|
publish: (view) => displayStore.publishDraw(view),
|
|
connect: connectDisplay,
|
|
markActions: drawMarkActions,
|
|
});
|
|
defer(() => drawTool?.destroy());
|
|
// UTILITIES ▸ Import: the person's own GeoJSON/KML/KMZ/GPX files, each its
|
|
// own data source. They live for the page session, so the application
|
|
// lifetime removes them and the drop listeners on the viewer container.
|
|
const geoFileImport = initGeoFileImport({
|
|
viewer,
|
|
navigation: styleManager,
|
|
ground: operations.surface?.groundFloor,
|
|
subscribeMapSource: (listener) => mapStackController?.subscribe?.(listener),
|
|
publish: (view) => displayStore.publishGeoImport(view),
|
|
connect: connectDisplay,
|
|
});
|
|
defer(() => geoFileImport?.destroy());
|
|
if (library !== false) {
|
|
// DATA ▸ Library: entries register their layers only when a viewer adds
|
|
// them, after the core catalog is sealed. The browser dialog and the
|
|
// controller share the application lifetime.
|
|
const dataLibrary = createDataLibrary({
|
|
dataManager,
|
|
services: localGeoJsonServices,
|
|
getTileset: () => tileset,
|
|
mapStackController,
|
|
shareLink: styleManager.shareLinkManager,
|
|
requestRender: governorRequestRender,
|
|
// An application's own tile and dataset fetches, when it keeps them in
|
|
// its own cache.
|
|
fetchImpl: library.fetchImpl ?? undefined,
|
|
fetchTile: library.fetchTile ?? null,
|
|
fetchData: library.fetchData ?? null,
|
|
requireCatalog: library.requireCatalog === true,
|
|
// Zoom to layer: an immediate navigation, so Cockpit can refuse it and
|
|
// the current follow owner is released first (as for imported files).
|
|
zoomTo: (extent) =>
|
|
styleManager.runImmediateNavigation('layer', () =>
|
|
flyToLibraryExtent(viewer, extent),
|
|
) !== false,
|
|
});
|
|
defer(() => dataLibrary.destroy());
|
|
// Browse: the owner presents the dialog through the store; LayerPanelsView
|
|
// draws the Browse button and the dialog from it.
|
|
const libraryStore = useDataLibraryStore(applicationPinia());
|
|
const libraryBrowser = createLibraryBrowser({
|
|
library: dataLibrary,
|
|
publish: (view) => libraryStore.publish(view),
|
|
});
|
|
libraryStore.connect(libraryBrowser.controls);
|
|
defer(() => {
|
|
libraryBrowser.destroy();
|
|
libraryStore.connect(null);
|
|
});
|
|
dataLibrary.start({ signal }).catch((error) => {
|
|
if (!signal?.aborted) console.warn('[Library] start failed:', error);
|
|
});
|
|
// The live gate's handle (scripts/qa-data-library.mjs).
|
|
const libraryHandle = {
|
|
library: dataLibrary,
|
|
browser: libraryBrowser,
|
|
// What Copy Link would copy.
|
|
buildShareLink: () =>
|
|
styleManager.shareLinkManager?.buildLink?.() ?? null,
|
|
};
|
|
window.__gevDataLibrary = libraryHandle;
|
|
defer(() => {
|
|
if (window.__gevDataLibrary === libraryHandle)
|
|
delete window.__gevDataLibrary;
|
|
});
|
|
}
|
|
// DATA ▸ Recent Imagery: the box tool claims the pointer like Draw and the
|
|
// panel lives on the right rail, so both belong to the application
|
|
// lifetime. The tileset lets the layer drape while the globe is hidden.
|
|
const recentImagery = dataManager.layers.get('recent-imagery')?.module;
|
|
if (recentImagery) {
|
|
recentImagery.attachTileset(tileset);
|
|
const imageryBoxTool = initImageryBoxTool({
|
|
viewer,
|
|
onBox: (box) => recentImagery.setBox(box),
|
|
onCancel: (reason, message, box) => {
|
|
if (message) recentImagery.reportBoxRefusal(message, box);
|
|
},
|
|
onActive: (active) => recentImagery.setToolActive(active),
|
|
// The tool takes Escape in a capture listener, so the panel's order
|
|
// (clear a preview before cancelling the tool) is applied here.
|
|
onEscape: () => recentImagery.clearPreview(),
|
|
});
|
|
// The readout mounts in its rail body through the layer panel, like the
|
|
// weather readout.
|
|
data.presentation.attachRecentImagery((container) =>
|
|
createRecentImageryPanel({
|
|
container,
|
|
viewer,
|
|
layer: recentImagery,
|
|
tool: imageryBoxTool,
|
|
}),
|
|
);
|
|
// The live gate's handle (scripts/qa-recent-imagery.mjs).
|
|
const recentImageryHandle = { layer: recentImagery, tool: imageryBoxTool };
|
|
window.__gevRecentImagery = recentImageryHandle;
|
|
defer(() => {
|
|
if (window.__gevRecentImagery === recentImageryHandle)
|
|
delete window.__gevRecentImagery;
|
|
data.presentation.attachRecentImagery(null);
|
|
imageryBoxTool?.destroy();
|
|
});
|
|
}
|
|
if (startChrome)
|
|
defer(startChrome({ loadingScreen, styleManager, dataManager, signal }));
|
|
// Idle render governor: the loop draws on demand whenever nothing animates
|
|
// per frame. It goes idle only now, after every module above has had its
|
|
// chance to hold. (perf wave 2)
|
|
releaseContinuousRender('boot');
|
|
// The renderer may keep a turned-off layer's draw commands (and so all its
|
|
// entities) alive; trim them after each disable.
|
|
if (scene.trimStaleCommands)
|
|
defer(
|
|
installLayerReleaseTrim({
|
|
frame: renderer.frame,
|
|
dataManager,
|
|
requestRender: governorRequestRender,
|
|
trim: scene.trimStaleCommands,
|
|
}),
|
|
);
|
|
|
|
// Install the explicit scope mask used by the DISPLAY controls.
|
|
installScopeMask(viewer);
|
|
defer(() => destroyScopeMask());
|
|
|
|
// The follow camera recomputes the tracked target's dead-reckon position
|
|
// every frame — tracking anything is a per-frame animation. (perf wave 2)
|
|
const removeTrackingListener = onFollowChanged(viewer, (followed) => {
|
|
if (followed) holdContinuousRender('tracked-entity');
|
|
else releaseContinuousRender('tracked-entity');
|
|
});
|
|
|
|
// Hidden-state suspension (perf wave 2): when the window/tab is hidden,
|
|
// stop the default render loop outright — a hidden canvas repaints for
|
|
// nobody, and browser rAF throttling still lets throttled frames burn
|
|
// GPU. Holder/data state is untouched, so return is seamless: restore
|
|
// the loop, refresh the one DOM surface we gated, render a frame.
|
|
const syncVisibilitySuspension = () => {
|
|
// A panel's host may report it hidden while it is on screen; the panel
|
|
// keeps drawing itself (see keepPanelRendering in app/panelRendering.js).
|
|
const hidden = document.hidden && !isEmbeddedInline();
|
|
renderer.frame.suspend(hidden);
|
|
cockpitCloudEffects?.setSuspended?.(hidden);
|
|
if (!hidden) {
|
|
data.presentation.flushVisible();
|
|
governorRequestRender('visibility-restore');
|
|
}
|
|
};
|
|
document.addEventListener('visibilitychange', syncVisibilitySuspension);
|
|
defer(() =>
|
|
document.removeEventListener('visibilitychange', syncVisibilitySuspension),
|
|
);
|
|
defer(() => {
|
|
removeTrackingListener();
|
|
releaseContinuousRender('tracked-entity');
|
|
});
|
|
// Apply the CURRENT state too — bootstrap can complete while the tab is
|
|
// already hidden, and waiting for the next transition would leave the
|
|
// loop burning behind a hidden tab. (perf wave 2 fix)
|
|
syncVisibilitySuspension();
|
|
|
|
window.__godsEyeView = Object.defineProperties(
|
|
{
|
|
viewer,
|
|
styleManager,
|
|
tileset,
|
|
dataManager,
|
|
sceneDirector,
|
|
mapStackController,
|
|
annotations,
|
|
weatherEffects,
|
|
cockpitCloudEffects,
|
|
getRenderGovernorDiagnostics,
|
|
surfaceServices: operations.surface,
|
|
requestRender: governorRequestRender,
|
|
entityRecords: { read: readEntityRecord, write: entityRecord },
|
|
},
|
|
// What the renderer's plugin lets QA scripts read (the Cesium viewer and
|
|
// its photoreal tileset, for the default renderer), in place of the
|
|
// scene's objects above; read as they are when asked.
|
|
Object.getOwnPropertyDescriptors(scene.qaHandles ?? {}),
|
|
);
|
|
const debug = window.__godsEyeView;
|
|
defer(() => {
|
|
if (window.__godsEyeView === debug) delete window.__godsEyeView;
|
|
});
|
|
voiceCommands = initGevVoiceCommands({
|
|
...voice,
|
|
canStartVoice: () => !isStoriesOpen(),
|
|
// An app may supply what open_stories does; the Stories page by default.
|
|
openStories: storiesOpener({
|
|
openStories: voice?.openStories,
|
|
store: storiesStore,
|
|
stories,
|
|
}),
|
|
floorServices: operations.surface.groundFloor,
|
|
annotationResolver: operations.annotationResolver,
|
|
searchNavigation: operations.searchAndFlyTo,
|
|
signal,
|
|
placeSearch,
|
|
viewer,
|
|
styleManager,
|
|
dataManager,
|
|
sceneDirector,
|
|
annotations,
|
|
});
|
|
defer(() => {
|
|
voiceCommands.stop({ removeUi: true });
|
|
if (window.__gevVoiceCommands === voiceCommands)
|
|
delete window.__gevVoiceCommands;
|
|
});
|
|
debug.voiceCommands = voiceCommands;
|
|
defer(
|
|
installViews({
|
|
shell: styleManager,
|
|
viewer,
|
|
dataManager,
|
|
run: (name, args, options = {}) =>
|
|
voiceCommands.runner(name, args, { ...options, signal }),
|
|
signal,
|
|
keepRendering: scene.keepPanelRendering,
|
|
terrain: operations.requests.terrain,
|
|
}),
|
|
);
|
|
// Any other tool takes the pointer as Draw does (the newest
|
|
// claim takes over; `claim(owner, {onLost})` tells the tool it replaces),
|
|
// and its own click handlers yield while a tool holds it, as the layers' do
|
|
// (data/inputOwnership.js).
|
|
return {
|
|
sceneDirector,
|
|
annotations,
|
|
voiceCommands,
|
|
pointer: {
|
|
claim: claimPointer,
|
|
release: releasePointer,
|
|
isFree: isPointerFree,
|
|
},
|
|
};
|
|
}
|