mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 08:12:24 +00:00
The launches layer's sites, markers, reticles, mission lines, live orbit rings and pad zone are now renderer draw sets. Picks go through the query port, double-click follow through the camera port (shared with other layers in src/data/stockFollow.js), and per-frame work through the frame port. rendering.js, orbitRendering.js and launchPad.js leave the Cesium list. The Cesium draw port gains what these need: pattern line styles, lines in the inertial frame turned each frame by the set's motion clock, radial-rim fills on clamped ellipses with a depth bias, and parking for hidden lines that cannot settle into a static batch, so a hidden line no longer costs a draw each frame. A roster writes each set once, and a followed live payload shares one position sample with its marker each frame.
483 lines
16 KiB
JavaScript
483 lines
16 KiB
JavaScript
import { toCartographicRadians } from '../../geo/ellipsoid.js';
|
||
import { formatNumber, isolate, onLocaleChange, t } from '../../i18n/index.js';
|
||
import {
|
||
MISSION_CLOSE_VIEW_RANGE_M,
|
||
MISSION_GLOBE_VIEW_RANGE_M,
|
||
} from './policy.js';
|
||
import { UNKNOWN_LAUNCH_STATUS } from './model.js';
|
||
|
||
// Landing endpoints carry an English accuracy code (the panel and the map
|
||
// entity compare it); only the text shown in the stage table is translated.
|
||
// The downrange estimate arrives already translated.
|
||
function accuracyLabel(accuracy) {
|
||
if (accuracy === 'CONFIRMED') return t('CONFIRMED');
|
||
if (accuracy === 'PAD / RTLS') return t('PAD / RTLS');
|
||
return accuracy;
|
||
}
|
||
|
||
export function createPanel({ state: layerState, services, parts, source }) {
|
||
/**
|
||
* Preserve the user's globe scale for roster previews while avoiding an
|
||
* accidental surface-level fly-to when the list is opened from a close view.
|
||
* @param {number} cameraHeight Current camera height above the ellipsoid.
|
||
* @returns {number} Preview range in metres.
|
||
*/
|
||
|
||
function missionHoverPreviewRange(cameraHeight) {
|
||
const height = Number(cameraHeight);
|
||
return Math.max(
|
||
MISSION_CLOSE_VIEW_RANGE_M,
|
||
Number.isFinite(height) ? height : MISSION_GLOBE_VIEW_RANGE_M,
|
||
);
|
||
}
|
||
|
||
/**
|
||
* Coordinate pointer and keyboard ownership of the temporary roster preview.
|
||
* The most recent input owns the preview until it leaves, then any remaining
|
||
* input resumes ownership. This lets keyboard focus take over from a pointer
|
||
* resting on another row without losing that pointer preview on blur.
|
||
* @param {{preview: (index: number) => void, clear: () => void}} handlers
|
||
* @returns {{pointerEnter: (index: number) => void, pointerLeave: () => void,
|
||
* focus: (index: number) => void, blur: (nextIndex?: number|null) => void,
|
||
* reset: () => void}}
|
||
*/
|
||
|
||
function createMissionRosterPreviewOwnership({ preview, clear }) {
|
||
let pointerIndex = null;
|
||
let focusIndex = null;
|
||
let latestOwner = null;
|
||
let activeIndex = null;
|
||
|
||
const sync = () => {
|
||
const nextIndex =
|
||
latestOwner === 'pointer'
|
||
? (pointerIndex ?? focusIndex)
|
||
: (focusIndex ?? pointerIndex);
|
||
if (nextIndex === activeIndex) return;
|
||
activeIndex = nextIndex;
|
||
if (Number.isInteger(nextIndex)) preview(nextIndex);
|
||
else clear();
|
||
};
|
||
|
||
return {
|
||
pointerEnter(index) {
|
||
pointerIndex = index;
|
||
latestOwner = 'pointer';
|
||
sync();
|
||
},
|
||
pointerLeave() {
|
||
pointerIndex = null;
|
||
if (latestOwner === 'pointer')
|
||
latestOwner = focusIndex === null ? null : 'focus';
|
||
sync();
|
||
},
|
||
focus(index) {
|
||
focusIndex = index;
|
||
latestOwner = 'focus';
|
||
sync();
|
||
},
|
||
blur(nextIndex = null) {
|
||
focusIndex = Number.isInteger(nextIndex) ? nextIndex : null;
|
||
if (latestOwner === 'focus')
|
||
latestOwner =
|
||
focusIndex === null
|
||
? pointerIndex === null
|
||
? null
|
||
: 'pointer'
|
||
: 'focus';
|
||
sync();
|
||
},
|
||
reset() {
|
||
pointerIndex = null;
|
||
focusIndex = null;
|
||
latestOwner = null;
|
||
activeIndex = null;
|
||
clear();
|
||
},
|
||
};
|
||
}
|
||
|
||
/** Resolve a pending preview against the current refresh, never a stale object. */
|
||
|
||
function resolveMissionRosterPreviewLaunch(launches, launchId) {
|
||
return (
|
||
(launches || []).find((candidate) => candidate.id === launchId) || null
|
||
);
|
||
}
|
||
|
||
/**
|
||
* Publish a fresh view unless it is the one already shown. The roster
|
||
* carries its own signature, so a telemetry update compares the mission.
|
||
*/
|
||
function publish(view) {
|
||
const signature = `${layerState._missionRosterSignature}|${JSON.stringify(view.mission)}`;
|
||
if (layerState._missionPanelSignature === signature) return;
|
||
layerState._missionPanelSignature = signature;
|
||
layerState._missionPanelView = view;
|
||
for (const listener of [...layerState._missionPanelListeners])
|
||
listener(view);
|
||
}
|
||
|
||
/**
|
||
* Receive every published view, starting with the current one.
|
||
* @param {(view: {roster: ?object, mission: ?object}) => void} listener
|
||
* @returns {() => void} Unsubscribe.
|
||
*/
|
||
function subscribePanel(listener) {
|
||
layerState._missionPanelListeners.add(listener);
|
||
if (layerState._missionPanelView) listener(layerState._missionPanelView);
|
||
return () => layerState._missionPanelListeners.delete(listener);
|
||
}
|
||
|
||
/** Publish the roster and the selected mission as they stand. */
|
||
function publishPanel() {
|
||
if (!layerState._missionPanelReady) return;
|
||
publish({
|
||
roster: layerState._missionRosterView,
|
||
mission: presentMission(),
|
||
});
|
||
}
|
||
|
||
/** A detail value, or null when the panel hides its row. */
|
||
function presentField(value) {
|
||
return value !== null && value !== undefined && String(value).trim() !== ''
|
||
? String(value)
|
||
: null;
|
||
}
|
||
|
||
function presentPayload(payload, launch) {
|
||
const detail = [
|
||
payload.manufacturer,
|
||
payload.operator && payload.operator !== payload.manufacturer
|
||
? payload.operator
|
||
: null,
|
||
Number.isFinite(payload.massKg)
|
||
? `${formatNumber(payload.massKg)} KG`
|
||
: null,
|
||
]
|
||
.filter(Boolean)
|
||
.join(' · ');
|
||
return {
|
||
name: `${payload.name ?? ''}${payload.amount > 1 ? ` ×${payload.amount}` : ''}`,
|
||
detail,
|
||
type: payload.type || t('UNSPECIFIED'),
|
||
destination:
|
||
payload.destination || launch.orbit?.name || t('UNAVAILABLE'),
|
||
};
|
||
}
|
||
|
||
function presentStage(stage, launch) {
|
||
const endpoint = stage.endpoint;
|
||
const destination =
|
||
stage.destination ||
|
||
(endpoint?.accuracy === 'PAD / RTLS'
|
||
? launch.launchSite
|
||
: t('UNAVAILABLE'));
|
||
const position = endpoint
|
||
? `${isolate(`${endpoint.lat.toFixed(2)}, ${endpoint.lon.toFixed(2)}`)} · ${accuracyLabel(endpoint.accuracy)}`
|
||
: stage.downrangeKm > 0
|
||
? t('{value} KM DOWNRANGE', {
|
||
value: formatNumber(stage.downrangeKm),
|
||
})
|
||
: t('POSITION UNAVAILABLE');
|
||
const detail = [
|
||
Number.isFinite(stage.flightNumber)
|
||
? t('FLIGHT {count}', {
|
||
count: stage.flightNumber,
|
||
})
|
||
: null,
|
||
stage.reused ? t('REUSED') : null,
|
||
stage.recoveryType,
|
||
]
|
||
.filter(Boolean)
|
||
.join(' · ');
|
||
return {
|
||
name: String(stage.name ?? ''),
|
||
detail,
|
||
status: String(stage.status ?? ''),
|
||
destination: String(destination ?? ''),
|
||
position,
|
||
};
|
||
}
|
||
|
||
/**
|
||
* The selected mission as the panel shows it, or null when none is
|
||
* selected and the panel hides. Text arrives in the UI language.
|
||
*/
|
||
function presentMission() {
|
||
const launch = layerState._launches.find(
|
||
(item) => item.id === layerState._selectedLaunchId,
|
||
);
|
||
if (!launch) return null;
|
||
const index = layerState._launches.indexOf(launch);
|
||
const pathPresentation = parts.policyHelpers.missionPathPresentation(
|
||
launch,
|
||
layerState._replayTracks.has(launch.id),
|
||
);
|
||
const telemetry = layerState._missionTelemetry;
|
||
return {
|
||
scrollRequest: layerState._missionPanelScrollRequest,
|
||
title: parts.overlays.shortMissionLabel(launch.name, 32).toUpperCase(),
|
||
provider: presentField(launch.provider),
|
||
// Launch Library status names are provider data, shown as sent; only
|
||
// the fallback for a launch without one is ours to translate.
|
||
status: presentField(
|
||
launch.status === UNKNOWN_LAUNCH_STATUS
|
||
? t(UNKNOWN_LAUNCH_STATUS)
|
||
: launch.status,
|
||
),
|
||
site: presentField(
|
||
launch.launchSite && launch.launchSite !== 'Unknown launch site'
|
||
? launch.launchSite
|
||
: null,
|
||
),
|
||
time: presentField(launch.launchTime),
|
||
orbit: presentField(pathPresentation.orbit),
|
||
ascent: pathPresentation.ascent ?? '',
|
||
distance: telemetry?.distance ?? null,
|
||
speed: telemetry?.speed ?? null,
|
||
speedTitle: telemetry?.speedTitle ?? null,
|
||
payloads: launch.payloads
|
||
.slice(0, 5)
|
||
.map((payload) => presentPayload(payload, launch)),
|
||
payloadsMore:
|
||
launch.payloads.length > 5
|
||
? t('+{count} additional payload records', {
|
||
count: launch.payloads.length - 5,
|
||
})
|
||
: null,
|
||
stages: launch.recoveryStages.map((stage) => presentStage(stage, launch)),
|
||
index: `${index + 1} / ${layerState._launches.length}`,
|
||
previousDisabled: index <= 0,
|
||
nextDisabled: index < 0 || index >= layerState._launches.length - 1,
|
||
replay: parts.replay.presentReplay(),
|
||
};
|
||
}
|
||
|
||
/** Present the newly selected mission and return its panel to the top. */
|
||
function renderMissionPanel() {
|
||
if (!layerState._missionPanelReady) return;
|
||
layerState._missionTelemetry = null;
|
||
updateMissionTelemetry(true, false);
|
||
layerState._missionPanelScrollRequest++;
|
||
publishPanel();
|
||
}
|
||
|
||
/** The roster entries as the list shows them. */
|
||
function presentRoster() {
|
||
const entries = parts.policyHelpers
|
||
.missionRosterEntries(layerState._launches)
|
||
.map(({ launch, index }) => {
|
||
const label = parts.overlays
|
||
.shortMissionLabel(launch.name, 27)
|
||
.toUpperCase();
|
||
return {
|
||
index,
|
||
id: String(launch.id ?? ''),
|
||
color: parts.model.missionMarkerCss(launch),
|
||
label,
|
||
ariaLabel: t('Select {mission}', { mission: label }),
|
||
provider: launch.provider || t('UNSPECIFIED OPERATOR'),
|
||
date: launch.launchTime?.slice(0, 10) || t('DATE UNAVAILABLE'),
|
||
};
|
||
});
|
||
return {
|
||
count: t('{count} / 30D', { count: layerState._launches.length }),
|
||
entries,
|
||
empty: t('NO MISSIONS AVAILABLE IN THE CURRENT 30-DAY WINDOW'),
|
||
};
|
||
}
|
||
|
||
/**
|
||
* Present the roster. A changed roster drops the hover and keyboard
|
||
* preview; the list restores keyboard focus by mission identity, which
|
||
* resumes the preview.
|
||
*/
|
||
function renderMissionRoster() {
|
||
if (!layerState._missionPanelReady) return;
|
||
const roster = presentRoster();
|
||
const signature = JSON.stringify(roster);
|
||
if (signature !== layerState._missionRosterSignature) {
|
||
layerState._missionRosterSignature = signature;
|
||
layerState._missionRosterView = roster;
|
||
layerState._missionRosterPreviewOwnership?.reset();
|
||
}
|
||
publishPanel();
|
||
}
|
||
|
||
/**
|
||
* Read the selected mission's altitude and speed, at most four times a
|
||
* second unless forced, and republish when they change.
|
||
*/
|
||
function updateMissionTelemetry(force = false, republish = true) {
|
||
if (
|
||
!layerState._missionPanelReady ||
|
||
!layerState._selectedLaunchId ||
|
||
!layerState._missionSets
|
||
)
|
||
return;
|
||
const now = performance.now();
|
||
if (!force && now - layerState._lastPanelTelemetryMs < 250) return;
|
||
layerState._lastPanelTelemetryMs = now;
|
||
const telemetry = layerState._satelliteTelemetry.get(
|
||
layerState._selectedLaunchId,
|
||
);
|
||
const position = telemetry?.position?.();
|
||
const altitudeM = position ? toCartographicRadians(position)?.height : null;
|
||
const speedMps = telemetry?.speedMps;
|
||
layerState._missionTelemetry = {
|
||
distance: Number.isFinite(altitudeM)
|
||
? t('{value} KM', {
|
||
value: formatNumber(Math.max(0, altitudeM / 1000), {
|
||
maximumFractionDigits: 0,
|
||
}),
|
||
})
|
||
: null,
|
||
speed: Number.isFinite(speedMps)
|
||
? t('{value} KM/S', {
|
||
value: formatNumber(speedMps / 1000, {
|
||
minimumFractionDigits: 2,
|
||
maximumFractionDigits: 2,
|
||
}),
|
||
})
|
||
: null,
|
||
speedTitle: Number.isFinite(speedMps)
|
||
? `${formatNumber(speedMps * 3.6, { maximumFractionDigits: 0 })} km/h`
|
||
: null,
|
||
};
|
||
if (republish) publishPanel();
|
||
}
|
||
|
||
function selectMissionAt(index) {
|
||
const launch = layerState._launches[index];
|
||
if (!launch) return;
|
||
parts.selection.setSelectedMission(launch.id, true);
|
||
parts.selection.focusMission(launch);
|
||
}
|
||
|
||
function clearMissionRosterPreviewState() {
|
||
if (layerState._missionRosterHoverTimer)
|
||
clearTimeout(layerState._missionRosterHoverTimer);
|
||
layerState._missionRosterHoverTimer = null;
|
||
const changed = layerState._hoveredRosterLaunchId !== null;
|
||
layerState._hoveredRosterLaunchId = null;
|
||
if (changed) parts.overlays.syncMissionOverlayEntries();
|
||
}
|
||
|
||
function clearMissionRosterHover() {
|
||
if (layerState._missionRosterPreviewOwnership)
|
||
layerState._missionRosterPreviewOwnership.reset();
|
||
else clearMissionRosterPreviewState();
|
||
}
|
||
|
||
function scheduleMissionRosterPreview(index) {
|
||
const launch = layerState._launches[index];
|
||
if (!launch || layerState._selectedLaunchId) return;
|
||
if (layerState._missionRosterHoverTimer)
|
||
clearTimeout(layerState._missionRosterHoverTimer);
|
||
layerState._hoveredRosterLaunchId = launch.id;
|
||
parts.overlays.syncMissionOverlayEntries();
|
||
layerState._missionRosterHoverTimer = setTimeout(() => {
|
||
layerState._missionRosterHoverTimer = null;
|
||
if (layerState._hoveredRosterLaunchId !== launch.id) return;
|
||
const currentLaunch = resolveMissionRosterPreviewLaunch(
|
||
layerState._launches,
|
||
launch.id,
|
||
);
|
||
if (currentLaunch)
|
||
parts.policyHelpers.previewMissionFromRoster(currentLaunch);
|
||
}, 140);
|
||
}
|
||
|
||
/** Select the mission before or after the selected one. */
|
||
function selectAdjacentMission(step) {
|
||
selectMissionAt(
|
||
layerState._launches.findIndex(
|
||
(item) => item.id === layerState._selectedLaunchId,
|
||
) + step,
|
||
);
|
||
}
|
||
|
||
/** The panel's commands, called by Core's mission components. */
|
||
const commands = {
|
||
selectMissionAt,
|
||
selectPreviousMission: () => selectAdjacentMission(-1),
|
||
selectNextMission: () => selectAdjacentMission(1),
|
||
deselectMission: () => parts.selection.setSelectedMission(null),
|
||
focusSelectedLaunchSite() {
|
||
const launch = layerState._launches.find(
|
||
(item) => item.id === layerState._selectedLaunchId,
|
||
);
|
||
if (launch) parts.selection.focusLaunchSite(launch);
|
||
},
|
||
startSelectedReplay() {
|
||
if (layerState._selectedLaunchId)
|
||
parts.replay.startMissionReplay(layerState._selectedLaunchId);
|
||
},
|
||
toggleReplayPause() {
|
||
if (layerState._replayPaused) parts.replay.resumeMissionReplay();
|
||
else parts.replay.pauseMissionReplay();
|
||
},
|
||
cancelReplay: () => parts.replay.stopMissionReplay(),
|
||
setReplaySpeed: (value) => parts.replay.setReplaySpeed(value),
|
||
rosterPointerEnter: (index) =>
|
||
layerState._missionRosterPreviewOwnership?.pointerEnter(index),
|
||
rosterPointerLeave: () =>
|
||
layerState._missionRosterPreviewOwnership?.pointerLeave(),
|
||
rosterFocus: (index) =>
|
||
layerState._missionRosterPreviewOwnership?.focus(index),
|
||
rosterBlur: (nextIndex) =>
|
||
layerState._missionRosterPreviewOwnership?.blur(nextIndex),
|
||
};
|
||
|
||
/** Start presenting the roster and the selected mission. */
|
||
function createMissionPanel() {
|
||
if (layerState._missionPanelReady) return;
|
||
layerState._missionPanelReady = true;
|
||
layerState._missionRosterPreviewOwnership =
|
||
createMissionRosterPreviewOwnership({
|
||
preview: scheduleMissionRosterPreview,
|
||
clear: clearMissionRosterPreviewState,
|
||
});
|
||
// The roster and mission are worded again in a new locale.
|
||
layerState._offMissionLocale = onLocaleChange(() => {
|
||
renderMissionRoster();
|
||
updateMissionTelemetry(true, false);
|
||
publishPanel();
|
||
});
|
||
publishPanel();
|
||
}
|
||
|
||
/** Stop presenting; the components return to their initial markup. */
|
||
function clearMissionPanel() {
|
||
layerState._missionPanelReady = false;
|
||
layerState._offMissionLocale?.();
|
||
layerState._offMissionLocale = null;
|
||
layerState._missionRosterPreviewOwnership = null;
|
||
layerState._missionRosterView = null;
|
||
layerState._missionRosterSignature = null;
|
||
layerState._missionTelemetry = null;
|
||
layerState._replayTransportLabel = null;
|
||
publish({ roster: null, mission: null });
|
||
}
|
||
|
||
return {
|
||
missionHoverPreviewRange,
|
||
createMissionRosterPreviewOwnership,
|
||
resolveMissionRosterPreviewLaunch,
|
||
subscribePanel,
|
||
publishPanel,
|
||
presentMission,
|
||
renderMissionPanel,
|
||
renderMissionRoster,
|
||
updateMissionTelemetry,
|
||
selectMissionAt,
|
||
clearMissionRosterPreviewState,
|
||
clearMissionRosterHover,
|
||
scheduleMissionRosterPreview,
|
||
createMissionPanel,
|
||
clearMissionPanel,
|
||
commands,
|
||
};
|
||
}
|