mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 08:12:24 +00:00
The awareness lifecycle and focus parts had left the Cesium allow-list but still hooked the scene's preRender event and read the Cesium camera's position and orientation. They now use the frame port and the camera port's pose, with the same quantized motion signature.
261 lines
9.5 KiB
JavaScript
261 lines
9.5 KiB
JavaScript
import { findCamera, findFrame } from '../../render/rendererOf.js';
|
|
|
|
export function createLifecycle({
|
|
state: layerState,
|
|
services,
|
|
parts,
|
|
source,
|
|
}) {
|
|
const { holdContinuousRender, releaseContinuousRender } = services.render;
|
|
|
|
/**
|
|
* Quantized camera-pose signature (position to ~10 m, angles to ~0.06
|
|
* degrees), or '' when the camera cannot report a full pose yet. An unknown
|
|
* pose reads as PARKED, so a camera that is still coming up can never be
|
|
* mistaken for continuous movement.
|
|
* @param {object|null|undefined} viewer
|
|
* @returns {string}
|
|
*/
|
|
|
|
function cameraMotionSignature(viewer) {
|
|
const pose = findCamera(viewer)?.pose();
|
|
const p = pose?.position;
|
|
if (!p || !Number.isFinite(pose.heading)) return '';
|
|
return (
|
|
`${Math.round(p.x / 10)}:${Math.round(p.y / 10)}:${Math.round(p.z / 10)}:` +
|
|
`${pose.heading.toFixed(3)}:${pose.pitch.toFixed(3)}:${pose.roll.toFixed(3)}`
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Take or drop the continuous-render hold to match the current need. Idempotent
|
|
* (the governor is identity-keyed), and self-healing: the release decision is
|
|
* made on a frame the hold itself guaranteed, so a hold can never strand the
|
|
* scene in continuous mode.
|
|
* @returns {void}
|
|
*/
|
|
|
|
function syncAwarenessRenderHold() {
|
|
if (layerState.enabled && parts.model.awarenessNeedsContinuousRender())
|
|
holdContinuousRender('military-awareness');
|
|
else releaseContinuousRender('military-awareness');
|
|
}
|
|
|
|
function attachRuntimeListeners() {
|
|
if (layerState.runtimeListenersAttached || !layerState.viewer) return;
|
|
window.addEventListener(
|
|
'gev:awareness-subject-selected',
|
|
layerState.subjectListener,
|
|
);
|
|
window.addEventListener('gev:entity-selected', layerState.contextListener);
|
|
window.addEventListener(
|
|
'gev:entity-selection-cleared',
|
|
layerState.clearListener,
|
|
);
|
|
window.addEventListener(
|
|
'gev:awareness-subject-cleared',
|
|
layerState.subjectClearListener,
|
|
);
|
|
layerState.preRenderRemover = findFrame(layerState.viewer)?.on(
|
|
'preRender',
|
|
() => {
|
|
if (!layerState.enabled) return;
|
|
const now = Date.now();
|
|
// "Did the camera move" uses the same quantization as the fleet
|
|
// rotation pass's iconOrientation.cameraPoseSignature (keep the two
|
|
// in step), read from the camera port's pose, rather than
|
|
// camera.changed, whose granularity is globally degraded by other layers
|
|
// mutating camera.percentageChanged.
|
|
const poseSig = cameraMotionSignature(layerState.viewer);
|
|
if (poseSig !== layerState.lastCameraPoseSig) {
|
|
layerState.lastCameraPoseSig = poseSig;
|
|
layerState.lastCameraPoseChangeMs = now;
|
|
}
|
|
const decision = parts.model.awarenessRefreshDecision({
|
|
nowMs: now,
|
|
lastRefreshMs: layerState.lastSubjectRefreshMs,
|
|
lastPoseChangeMs: layerState.lastCameraPoseChangeMs,
|
|
wasMoving: layerState.cameraMoving,
|
|
});
|
|
layerState.cameraMoving = decision.moving;
|
|
syncAwarenessRenderHold();
|
|
if (!decision.refresh) return;
|
|
layerState.lastSubjectRefreshMs = now;
|
|
if (
|
|
layerState.subject &&
|
|
['flights', 'military', 'ais-live-vessels'].includes(
|
|
layerState.subject.layerId,
|
|
)
|
|
) {
|
|
parts.subject.refreshSelectedSubject();
|
|
} else if (!layerState.passive && layerState.autoFocusRetryPending) {
|
|
layerState.autoFocusRetryPending = false;
|
|
parts.focus.focusAttentionTarget();
|
|
} else {
|
|
parts.rendering.scheduleDirectionOverlayUpdate();
|
|
}
|
|
},
|
|
);
|
|
layerState.runtimeListenersAttached = true;
|
|
}
|
|
|
|
function detachRuntimeListeners() {
|
|
if (layerState.runtimeListenersAttached) {
|
|
window.removeEventListener(
|
|
'gev:awareness-subject-selected',
|
|
layerState.subjectListener,
|
|
);
|
|
window.removeEventListener(
|
|
'gev:entity-selected',
|
|
layerState.contextListener,
|
|
);
|
|
window.removeEventListener(
|
|
'gev:entity-selection-cleared',
|
|
layerState.clearListener,
|
|
);
|
|
window.removeEventListener(
|
|
'gev:awareness-subject-cleared',
|
|
layerState.subjectClearListener,
|
|
);
|
|
}
|
|
layerState.preRenderRemover?.();
|
|
layerState.preRenderRemover = null;
|
|
layerState.lastCameraPoseSig = '';
|
|
layerState.lastCameraPoseChangeMs = 0;
|
|
layerState.cameraMoving = false;
|
|
// No frames will arrive to run the per-frame release once the listener is
|
|
// gone, so drop the hold here.
|
|
releaseContinuousRender('military-awareness');
|
|
parts.rendering.cancelDirectionOverlayUpdate();
|
|
layerState.runtimeListenersAttached = false;
|
|
}
|
|
const methods = {
|
|
init(viewer) {
|
|
detachRuntimeListeners();
|
|
layerState.viewer = viewer;
|
|
layerState.subjectListener = (event) => {
|
|
if (!layerState.enabled) return;
|
|
parts.subject.selectSubject(event.detail);
|
|
};
|
|
layerState.contextListener = (event) => {
|
|
if (!layerState.enabled) return;
|
|
const subject = parts.subject.subjectFromContext(event.detail);
|
|
if (!subject) return;
|
|
if (parts.model.contextTargetFlyToAllowed(subject.layerId))
|
|
parts.model.releaseAircraftTracking();
|
|
parts.subject.selectSubject(subject);
|
|
};
|
|
layerState.clearListener = (event) => {
|
|
if (!layerState.enabled || layerState.pendingSelectionKey) return;
|
|
if (
|
|
!parts.subject.awarenessClearMatchesSubject(
|
|
layerState.subject,
|
|
event.detail,
|
|
)
|
|
)
|
|
return;
|
|
// An eviction keeps the subject so the readout can hold last-known
|
|
// values; only a deliberate clear tears the selection down.
|
|
if (parts.model.awarenessClearIsEviction(event.detail)) {
|
|
parts.subject.markSubjectEvicted();
|
|
return;
|
|
}
|
|
parts.subject.clearAwarenessSubject();
|
|
};
|
|
layerState.subjectClearListener = (event) => {
|
|
if (!layerState.enabled) return;
|
|
const cleared = event.detail;
|
|
if (layerState.pendingSelectionKey) return;
|
|
if (
|
|
parts.subject.awarenessClearMatchesSubject(
|
|
layerState.subject,
|
|
cleared,
|
|
) &&
|
|
String(layerState.subject?.id) === String(cleared?.id)
|
|
) {
|
|
if (parts.model.awarenessClearIsEviction(cleared)) {
|
|
// Deliberately does NOT set autoFocusAttempted: the subject survives,
|
|
// so the entry fallback has nothing to replace and the settlement
|
|
// guard below stays scoped to real deselects.
|
|
parts.subject.markSubjectEvicted();
|
|
return;
|
|
}
|
|
// A deliberate clear during dependency settlement must win over the
|
|
// entry fallback; otherwise Contacts can silently select a replacement.
|
|
layerState.autoFocusAttempted = true;
|
|
parts.subject.clearAwarenessSubject();
|
|
}
|
|
};
|
|
},
|
|
|
|
enable() {
|
|
layerState.enabled = true;
|
|
// NO unconditional continuous-render hold here. Contacts animates per frame
|
|
// only while the VIEW is moving (the direction arrows are screen-projected);
|
|
// parked, it is a throttled readout with nothing to animate. The hold is
|
|
// taken and released per frame by syncAwarenessRenderHold().
|
|
attachRuntimeListeners();
|
|
parts.panel.startAwarenessPageRotation();
|
|
layerState.autoFocusAttempted = false;
|
|
layerState.autoFocusRetryPending = false;
|
|
parts.panel.ensurePanel();
|
|
parts.panel.hidePanel();
|
|
if (!layerState.passive)
|
|
return parts.dependencies.activateOperationalContext();
|
|
return true;
|
|
},
|
|
|
|
disable() {
|
|
layerState.enabled = false;
|
|
releaseContinuousRender('military-awareness');
|
|
detachRuntimeListeners();
|
|
parts.panel.stopAwarenessPageRotation();
|
|
layerState.cohortPages.clear();
|
|
const releaseActivationId = ++layerState.activationId;
|
|
layerState.autoFocusAttempted = false;
|
|
layerState.autoFocusRetryPending = false;
|
|
layerState.subject = null;
|
|
services.installations?.setContextAnchor?.(null);
|
|
layerState.results = null;
|
|
layerState.lastSubjectRefreshMs = 0;
|
|
layerState.lastEvaluatedPosition = null;
|
|
layerState.sourceRevision = '';
|
|
layerState.navigationHistory = [];
|
|
layerState.navigationVisited.clear();
|
|
layerState.navigationIndex = -1;
|
|
layerState.suppressedHistoryKey = null;
|
|
layerState.pendingSelectionKey = null;
|
|
parts.rendering.clearVisual();
|
|
parts.panel.hidePanel();
|
|
// The manager must not publish this coordinator as settled OFF while its
|
|
// owned dependency releases are still issuing newer absolute intents.
|
|
// Context mode handoffs restore the pre-entry snapshot only after this
|
|
// promise resolves, preventing those releases from superseding restore.
|
|
layerState.passive = true;
|
|
return parts.dependencies.releaseOwnedDependencies(releaseActivationId);
|
|
},
|
|
|
|
destroy() {
|
|
this.disable();
|
|
detachRuntimeListeners();
|
|
parts.panel.clearPanel();
|
|
parts.rendering.removeDirectionOverlay();
|
|
parts.rendering.disposeVisual();
|
|
layerState.subjectListener = null;
|
|
layerState.contextListener = null;
|
|
layerState.clearListener = null;
|
|
layerState.subjectClearListener = null;
|
|
layerState.viewer = null;
|
|
layerState.dataManager = null;
|
|
},
|
|
};
|
|
|
|
return {
|
|
cameraMotionSignature,
|
|
syncAwarenessRenderHold,
|
|
attachRuntimeListeners,
|
|
detachRuntimeListeners,
|
|
methods,
|
|
};
|
|
}
|