mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 08:12:24 +00:00
157 lines
5.4 KiB
JavaScript
157 lines
5.4 KiB
JavaScript
import {
|
|
cableClassificationTypeForScene,
|
|
cableClassificationTypeForStack,
|
|
} from './surface.js';
|
|
|
|
export function createLifecycle({ state, parts, source, mapStackEventTarget }) {
|
|
return {
|
|
id: 'telegeography-submarine-cables',
|
|
name: 'Submarine Cables',
|
|
icon: '≋',
|
|
source: source.label,
|
|
updateInterval: 0,
|
|
statsRefreshInterval: 500,
|
|
|
|
init(viewer) {
|
|
state._viewer = viewer;
|
|
state._classificationType = cableClassificationTypeForScene(
|
|
viewer?.scene,
|
|
);
|
|
if (!state._mapStackListener && mapStackEventTarget?.addEventListener) {
|
|
state._mapStackListener = (event) => {
|
|
parts.rendering.applyCableClassification(
|
|
event?.detail?.activeId
|
|
? cableClassificationTypeForStack(event.detail.activeId)
|
|
: cableClassificationTypeForScene(state._viewer?.scene),
|
|
);
|
|
};
|
|
mapStackEventTarget.addEventListener(
|
|
'gev:map-stack-changed',
|
|
state._mapStackListener,
|
|
);
|
|
}
|
|
parts.interaction.beginInteraction(viewer);
|
|
if (!state._preRenderRemover) {
|
|
state._preRenderRemover = viewer.scene.preRender.addEventListener(
|
|
() => {
|
|
// The camera is handed to the gate so tracked/orbit cameras — which
|
|
// never emit moveEnd — reach the motion fallback. No render is
|
|
// requested for a fallback sweep: it only fires while the camera is
|
|
// already moving, so frames are flowing by construction.
|
|
if (
|
|
!state._enabled ||
|
|
!state._loaded ||
|
|
!state._referenceSweepGate.shouldRun(viewer.camera)
|
|
)
|
|
return;
|
|
parts.rendering.updateReferenceVisibility();
|
|
},
|
|
);
|
|
}
|
|
if (!state._moveEndRemover) {
|
|
state._moveEndRemover = viewer.camera.moveEnd.addEventListener(() => {
|
|
if (!state._enabled) return;
|
|
state._referenceSweepGate.markDirty();
|
|
viewer.scene.requestRender?.();
|
|
});
|
|
}
|
|
},
|
|
|
|
enable(viewer) {
|
|
state._enabled = true;
|
|
parts.rendering.updateVisibility();
|
|
state._overlayPublisher.show();
|
|
// A hide() cleared the host source, so an identical cohort must still
|
|
// republish on the next sweep.
|
|
parts.rendering.resetPublishSignature();
|
|
state._referenceSweepGate.markDirty();
|
|
// The gate is dirty-only; ask for the frame its sweep needs in case the
|
|
// camera is parked and nothing else is rendering.
|
|
(viewer || state._viewer)?.scene?.requestRender?.();
|
|
void parts.ingestion.load(viewer || state._viewer);
|
|
},
|
|
|
|
disable() {
|
|
state._enabled = false;
|
|
state._overlayPublisher.hide();
|
|
parts.rendering.resetPublishSignature();
|
|
if (state._loading && state._abort) {
|
|
state._abort.abort();
|
|
state._loading = false;
|
|
state._loadingLabel = '';
|
|
}
|
|
// Free the entities rather than hide them; enable() rebuilds from the
|
|
// cached JSON. An in-flight load's own post-await ownership check
|
|
// removes whatever that stale generation adds later.
|
|
parts.rendering.releaseDataSources(state._viewer);
|
|
},
|
|
|
|
update(viewer) {
|
|
return parts.ingestion.load(viewer || state._viewer);
|
|
},
|
|
|
|
destroy(viewer) {
|
|
if (state._abort) state._abort.abort();
|
|
parts.rendering.releaseDataSources(viewer || state._viewer);
|
|
state._cachedCableJson = null;
|
|
state._cachedLandingJson = null;
|
|
// hide() clears every published host entry and goes invisible while
|
|
// keeping the publisher reusable — the legacy layer supported re-init
|
|
// after destroy, and hidden publishers already drop late publishes.
|
|
// Pinned by the direct-destroy host test: removing this line leaves a
|
|
// visible overlay source with orphan labels.
|
|
state._overlayPublisher.hide();
|
|
if (state._clickHandler) {
|
|
state._clickHandler.destroy();
|
|
state._clickHandler = null;
|
|
}
|
|
if (state._preRenderRemover) {
|
|
state._preRenderRemover();
|
|
state._preRenderRemover = null;
|
|
}
|
|
if (state._moveEndRemover) {
|
|
state._moveEndRemover();
|
|
state._moveEndRemover = null;
|
|
}
|
|
if (state._mapStackListener && mapStackEventTarget?.removeEventListener) {
|
|
mapStackEventTarget.removeEventListener(
|
|
'gev:map-stack-changed',
|
|
state._mapStackListener,
|
|
);
|
|
state._mapStackListener = null;
|
|
}
|
|
state._viewer = null;
|
|
state._enabled = false;
|
|
state._loading = false;
|
|
state._loaded = false;
|
|
state._count = 0;
|
|
state._error = null;
|
|
state._lastUpdate = null;
|
|
state._loadingLabel = '';
|
|
state._cableDataSource = null;
|
|
state._landingDataSource = null;
|
|
state._referenceDataSource = null;
|
|
state._referenceRecords = [];
|
|
state._surfaceRecords = [];
|
|
state._pickByEntity = new WeakMap();
|
|
state._referenceLabelCount = 0;
|
|
state._publishScratch.length = 0;
|
|
state._markerBlendDone = false;
|
|
state._markerBlendInvariantWarned = false;
|
|
parts.rendering.resetPublishSignature();
|
|
state._referenceSweepGate.reset();
|
|
},
|
|
|
|
getStats() {
|
|
return {
|
|
count: state._count,
|
|
lastUpdate: state._lastUpdate,
|
|
loading: state._loading,
|
|
loadingLabel: state._loadingLabel,
|
|
error: state._error,
|
|
referenceLabelCount: state._referenceLabelCount,
|
|
};
|
|
},
|
|
};
|
|
}
|