mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 08:12:24 +00:00
Takes main's per-point mesh floor readings (#1642) onto the seam's port-based sampler: a spot refused only while the cell's DEM prior was cold is probed again, each spot is recorded once, a cell keeps at most sixteen readings, and grounded flights read the floor at the contact held inside its sticky cell.
275 lines
10 KiB
JavaScript
275 lines
10 KiB
JavaScript
import { onFollowChanged } from '../data/followed.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 { initGevVoiceCommands } from '../voice/gevRealtime.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).
|
|
*/
|
|
export function createApplicationTools({
|
|
scene,
|
|
controls,
|
|
data,
|
|
loadingScreen,
|
|
placeSearch,
|
|
voice = {},
|
|
startChrome,
|
|
onSceneDirector,
|
|
sceneDataPacks,
|
|
drawMarkActions = [],
|
|
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);
|
|
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());
|
|
// 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 render/cesium/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 = {
|
|
viewer,
|
|
styleManager,
|
|
tileset,
|
|
dataManager,
|
|
sceneDirector,
|
|
mapStackController,
|
|
annotations,
|
|
weatherEffects,
|
|
cockpitCloudEffects,
|
|
getRenderGovernorDiagnostics,
|
|
surfaceServices: operations.surface,
|
|
requestRender: governorRequestRender,
|
|
entityRecords: { read: readEntityRecord, write: entityRecord },
|
|
};
|
|
const debug = window.__godsEyeView;
|
|
defer(() => {
|
|
if (window.__godsEyeView === debug) delete window.__godsEyeView;
|
|
});
|
|
const voiceCommands = initGevVoiceCommands({
|
|
...voice,
|
|
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) => voiceCommands.runner(name, args, { signal }),
|
|
signal,
|
|
keepRendering: scene.keepPanelRendering,
|
|
}),
|
|
);
|
|
// An application's own tool takes the pointer as Draw does, 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,
|
|
},
|
|
};
|
|
}
|