Files
gods-eye-view/src/layers/launches/replay.js
T
Mazeyar Moeini FeizabadiandClaude Opus 5.5 13219828e3 fix(launches): cancel mission flights on exit and name a failed index load
Review fixes on top of #1578:
- Exiting Space Missions cancels the layer's own camera flights again (entry,
  roster preview, mission focus); only a flight navigation started after
  releaseCameraOwnership() runs on.
- A failed first index load says so: "Space Missions unavailable: the
  mission index could not load. Try again later." on both the Context and
  Data Layers routes, instead of a generic transition toast. Translated.
- Regression tests for both; docs and changelog describe the real feedback.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-11-06 19:20:11 +01:00

537 lines
18 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import * as Cesium from 'cesium';
import { t } from '../../i18n/index.js';
import {
REPLAY_ASCENT_FALLBACK_SEC,
REPLAY_ASCENT_MIN_SEC,
REPLAY_ASCENT_MAX_SEC,
REPLAY_SPEED_MIN,
REPLAY_SPEED_MAX,
REPLAY_SPEED_STEP,
REPLAY_TILE_SETTLE_DELAY_SEC,
REPLAY_COUNTDOWN_DURATION_SEC,
REPLAY_ORBIT_PULLBACK_FRACTION,
REPLAY_ORBIT_DURATION_SEC,
REPLAY_INITIAL_RANGE_M,
} from './policy.js';
export function createReplay({ state: layerState, services, parts, source }) {
/**
* Rotate an upright screen-space rocket so its nose follows a projected path.
* @param {{x: number, y: number}} from Current screen point.
* @param {{x: number, y: number}} to Forward screen point.
* @returns {number} Clockwise CSS rotation in radians.
*/
function replayVehicleScreenRotation(from, to) {
const dx = Number(to?.x) - Number(from?.x);
const dy = Number(to?.y) - Number(from?.y);
if (
!Number.isFinite(dx) ||
!Number.isFinite(dy) ||
Math.hypot(dx, dy) < 0.01
)
return 0;
return Math.atan2(dx, -dy);
}
/**
* Reduce small screen-space reprojection jitter without allowing the marker
* to lag behind a camera jump or a phase transition.
* @param {{x:number,y:number}|null} previous Previous rendered position.
* @param {{x:number,y:number}} next Current path projection.
* @param {number} [alpha] Interpolation amount.
* @param {number} [snapDistance] Maximum distance to smooth.
* @returns {{x:number,y:number}}
*/
function smoothReplayWindowPosition(
previous,
next,
alpha = 0.55,
snapDistance = 24,
) {
if (!previous || !next) return next;
const distance = Math.hypot(next.x - previous.x, next.y - previous.y);
if (!Number.isFinite(distance) || distance > snapDistance) return next;
const amount = Cesium.Math.clamp(Number(alpha) || 0, 0, 1);
return {
x: Cesium.Math.lerp(previous.x, next.x, amount),
y: Cesium.Math.lerp(previous.y, next.y, amount),
};
}
/**
* Derive a compressed but mission-specific ascent replay duration.
* Launch Library timelines are authoritative when they expose insertion,
* SECO, or separation timing. Sparse records fall back to the reconstructed
* path length and a conservative ascent velocity estimate.
* @param {object} launch Normalized launch record.
* @param {Cesium.Cartesian3[]} ascentPath Reconstructed or supplied ascent.
* @returns {number} Replay duration in seconds.
*/
function replayAscentDurationSeconds(launch, ascentPath = []) {
const disclosedSeconds = parts.paths.orbitInsertionOffsetSeconds(launch);
let realAscentSeconds = disclosedSeconds > 0 ? disclosedSeconds : null;
if (!realAscentSeconds && ascentPath.length > 1) {
const pathLength = ascentPath
.slice(1)
.reduce(
(total, point, index) =>
total + Cesium.Cartesian3.distance(ascentPath[index], point),
0,
);
realAscentSeconds = Math.max(180, pathLength / 9000);
}
if (!realAscentSeconds) realAscentSeconds = REPLAY_ASCENT_FALLBACK_SEC * 50;
return Cesium.Math.clamp(
REPLAY_ASCENT_FALLBACK_SEC * (realAscentSeconds / 600),
REPLAY_ASCENT_MIN_SEC,
REPLAY_ASCENT_MAX_SEC,
);
}
/**
* Clamp and snap a replay speed multiplier to the supported slider range.
* @param {number|string} value Requested playback multiplier.
* @returns {number} Supported multiplier between 0.25x and 4x.
*/
function normalizeReplaySpeed(value) {
const numeric = Number(value);
if (!Number.isFinite(numeric)) return 1;
const clamped = Cesium.Math.clamp(
numeric,
REPLAY_SPEED_MIN,
REPLAY_SPEED_MAX,
);
return Math.round(clamped / REPLAY_SPEED_STEP) * REPLAY_SPEED_STEP;
}
/**
* Preserve replay elapsed time when resuming after a pause.
* @param {number} startedAt Original replay start epoch in milliseconds.
* @param {number} pausedAt Pause epoch in milliseconds.
* @param {number} resumedAt Resume epoch in milliseconds.
* @returns {number} Shifted start epoch.
*/
function replayStartAfterPause(startedAt, pausedAt, resumedAt) {
if (![startedAt, pausedAt, resumedAt].every(Number.isFinite))
return startedAt;
return startedAt + Math.max(0, resumedAt - pausedAt);
}
function replayState(
launch,
startedAt,
ascentDurationSec,
orbitDurationSec,
orbitPeriodSec,
speed = 1,
nowMs = Date.now(),
preCountdownDurationSec = 0,
loop = true,
) {
const animationDurationSec = ascentDurationSec + orbitDurationSec;
const realSecondsSinceStart = (nowMs - startedAt) / 1000;
const preCountdownDuration = Math.max(
0,
Number(preCountdownDurationSec) || 0,
);
// The hold precedes the whole countdown; ending it at -hold cut T-10 to T-5.
const preCountdownActive =
preCountdownDuration > 0 &&
realSecondsSinceStart < -REPLAY_COUNTDOWN_DURATION_SEC;
const countdownActive = realSecondsSinceStart < 0 && !preCountdownActive;
const countdownSeconds = countdownActive
? Math.ceil(-realSecondsSinceStart)
: 0;
const elapsedSinceStart = Math.max(
0,
realSecondsSinceStart * normalizeReplaySpeed(speed),
);
const elapsed = loop
? elapsedSinceStart % animationDurationSec
: Math.min(elapsedSinceStart, Math.max(0, animationDurationSec - 1e-6));
const insertionOffsetSec = parts.paths.orbitInsertionOffsetSeconds(launch);
const ascending = elapsed < ascentDurationSec;
const phaseProgress = ascending
? elapsed / ascentDurationSec
: (elapsed - ascentDurationSec) / orbitDurationSec;
const missionOffsetSec =
insertionOffsetSec === null
? null
: ascending
? phaseProgress * insertionOffsetSec
: insertionOffsetSec + phaseProgress * orbitPeriodSec;
const launchEpoch = Date.parse(launch.launchTime);
const eventTime =
Number.isFinite(launchEpoch) && missionOffsetSec !== null
? new Date(launchEpoch + missionOffsetSec * 1000)
: null;
return {
ascending,
phaseProgress,
eventTime,
elapsedSinceStart,
countdownActive,
preCountdownActive,
countdownSeconds,
};
}
/** Republish the mission panel after a replay state change. */
function syncReplayButton() {
parts.panel.publishPanel();
}
/**
* The replay controls as the mission panel shows them: the start button,
* the transport with its pause toggle, and the speed slider.
*/
function presentReplay() {
const active = Boolean(
layerState._replayCameraLaunchId &&
layerState._replayCameraLaunchId === layerState._selectedLaunchId,
);
const available = Boolean(
layerState._selectedLaunchId &&
layerState._replayTracks.has(layerState._selectedLaunchId),
);
const paused = layerState._replayPaused;
const speed = layerState._replaySpeed;
return {
available,
active,
paused: active && paused,
toggleText: paused ? '▶' : 'Ⅱ',
toggleLabel: paused ? t('Resume replay') : t('Pause replay'),
transportLabel: layerState._replayTransportLabel,
speed: String(speed),
speedText: `${speed.toFixed(speed % 1 ? 2 : 0)}×`,
speedProgress: `${((speed - REPLAY_SPEED_MIN) / (REPLAY_SPEED_MAX - REPLAY_SPEED_MIN)) * 100}%`,
};
}
function syncReplayCountdownButton(state) {
if (!layerState._replayCameraLaunchId) return;
const phase = state.countdownActive
? t('T minus {seconds}', {
seconds: state.countdownSeconds,
})
: state.preCountdownActive
? t('Preparing launch site')
: state.elapsedSinceStart < 1
? t('Liftoff')
: state.ascending
? t('Ascent replay')
: t('Orbit replay');
const label = `${phase}${layerState._replayPaused ? t(', paused') : ''}`;
if (label === layerState._replayTransportLabel) return;
layerState._replayTransportLabel = label;
parts.panel.publishPanel();
}
function syncReplaySpeedControl() {
parts.panel.publishPanel();
}
function setReplaySpeed(value) {
const nextSpeed = normalizeReplaySpeed(value);
const previousSpeed = layerState._replaySpeed;
if (nextSpeed === previousSpeed) {
syncReplaySpeedControl();
return;
}
const now =
layerState._replayPaused && Number.isFinite(layerState._replayPausedAtMs)
? layerState._replayPausedAtMs
: Date.now();
for (const [launchId, startedAt] of layerState._animationStarts) {
// A countdown runs in real time; rescaling it turned T-8 into T-32 at 0.25x.
if (!Number.isFinite(startedAt) || startedAt > now) continue;
const elapsedMissionMs = (now - startedAt) * previousSpeed;
layerState._animationStarts.set(
launchId,
now - elapsedMissionMs / nextSpeed,
);
}
layerState._replaySpeed = nextSpeed;
syncReplaySpeedControl();
}
function replayClockNow(launchId) {
if (
layerState._replayPaused &&
layerState._replayCameraLaunchId === launchId &&
Number.isFinite(layerState._replayPausedAtMs)
) {
return layerState._replayPausedAtMs;
}
return Date.now();
}
function pauseMissionReplay() {
if (!layerState._replayCameraLaunchId || layerState._replayPaused)
return false;
layerState._replayPausedAtMs = Date.now();
layerState._replayPaused = true;
syncReplayButton();
return true;
}
function resumeMissionReplay() {
if (
!layerState._replayCameraLaunchId ||
!layerState._replayPaused ||
!Number.isFinite(layerState._replayPausedAtMs)
) {
return false;
}
const resumedAt = Date.now();
const startedAt = layerState._animationStarts.get(
layerState._replayCameraLaunchId,
);
if (Number.isFinite(startedAt)) {
layerState._animationStarts.set(
layerState._replayCameraLaunchId,
replayStartAfterPause(
startedAt,
layerState._replayPausedAtMs,
resumedAt,
),
);
}
layerState._replayPaused = false;
layerState._replayPausedAtMs = null;
syncReplayButton();
return true;
}
function stopMissionReplay() {
const stoppedLaunchId = layerState._replayCameraLaunchId;
layerState._replayCameraToken++;
if (layerState._replayCameraRemover) layerState._replayCameraRemover();
layerState._replayCameraRemover = null;
// Cancel the layer's own flights, never one navigation started after
// taking the camera.
if (
(stoppedLaunchId || !layerState._cameraReleased) &&
layerState._viewer?.camera
) {
layerState._viewer.camera.cancelFlight();
layerState._viewer.camera.lookAtTransform(Cesium.Matrix4.IDENTITY);
}
layerState._replayCameraLaunchId = null;
layerState._replayPaused = false;
layerState._replayPausedAtMs = null;
if (stoppedLaunchId)
layerState._animationStarts.set(stoppedLaunchId, Date.now());
syncReplayButton();
parts.overlays.syncMissionOverlayEntries();
}
function startMissionReplay(launchId) {
const launch = layerState._launches.find((item) => item.id === launchId);
const track = layerState._replayTracks.get(launchId);
if (!layerState._viewer || !launch || !track) return false;
if (layerState._replayCameraLaunchId === launchId) {
stopMissionReplay();
return false;
}
parts.selection.stopMissionZoomAnchor();
stopMissionReplay();
layerState._replayCameraLaunchId = launchId;
layerState._replayPaused = false;
layerState._replayPausedAtMs = null;
const token = ++layerState._replayCameraToken;
const ascentDurationSec = track.ascentDurationSec;
// Start broadside to the ascent/orbit direction so the launch profile is
// visible. The chase heading then eases toward the path tangent after the
// camera is established.
const initialHeading = parts.camera.replayInitialCameraHeading(
track.ascentPath,
);
track.lastCameraHeading = initialHeading;
syncReplayButton();
parts.overlays.syncMissionOverlayEntries();
parts.policyHelpers.releaseAircraftTracking(layerState._dataManager);
layerState._viewer.trackedEntity = undefined;
layerState._viewer.camera.cancelFlight();
layerState._animationStarts.set(
launchId,
Date.now() +
(REPLAY_TILE_SETTLE_DELAY_SEC + REPLAY_COUNTDOWN_DURATION_SEC) * 1000,
);
let cameraReady = false;
let lastCameraUpdateMs = null;
// Move the chase camera before scene traversal. Mutating it in preRender
// makes Cesium discover a new view after 3D-tile refinement, which can cause
// a self-sustaining refinement loop and visible stutter during slow replay.
layerState._replayCameraRemover =
layerState._viewer.scene.preUpdate.addEventListener(() => {
if (
token !== layerState._replayCameraToken ||
layerState._replayCameraLaunchId !== launchId
)
return;
const state = track.beginReplayFrame();
syncReplayCountdownButton(state);
if (!cameraReady) return;
const path = state.ascending
? track.ascentPath
: track.animatedOrbitPath;
const position = parts.paths.samplePath(path, state.phaseProgress);
if (!position) return;
const pathHeading = parts.camera.cameraHeadingForPath(
path,
state.phaseProgress,
track.lastCameraHeading,
);
const orbitBlend = !state.ascending
? Cesium.Math.clamp(
(Number(state.phaseProgress) || 0) /
REPLAY_ORBIT_PULLBACK_FRACTION,
0,
1,
)
: 0;
const desiredHeading = parts.camera.replayChaseCameraHeading(
pathHeading,
orbitBlend,
);
if (state.ascending) track.orbitCameraWorldFrame = false;
const nowMs = performance.now();
const frameDurationMs = Number.isFinite(lastCameraUpdateMs)
? Cesium.Math.clamp(nowMs - lastCameraUpdateMs, 4, 50)
: 1000 / 60;
lastCameraUpdateMs = nowMs;
track.lastCameraHeading = parts.camera.smoothReplayCameraHeading(
track.lastCameraHeading,
desiredHeading,
(Cesium.Math.toRadians(2) * frameDurationMs) / (1000 / 60),
);
const cartographic =
Cesium.Ellipsoid.WGS84.cartesianToCartographic(position);
const altitude = Math.max(0, cartographic?.height || 0);
const cameraView = parts.camera.replayCameraView(state, altitude);
const defaultOrbitTarget = !state.ascending
? parts.camera.replayOrbitGlobeAnchor(position, orbitBlend)
: position;
const cameraTarget = !state.ascending
? parts.camera.replayOrbitCameraTarget(
defaultOrbitTarget,
track.orbitFrameSphere?.center,
orbitBlend,
)
: defaultOrbitTarget;
const cameraRange = !state.ascending
? parts.camera.replayOrbitGlobeRange(
cameraView.range,
altitude,
orbitBlend,
track.orbitFrameSphere?.radius,
)
: cameraView.range;
if (state.ascending) {
layerState._viewer.camera.lookAt(
cameraTarget,
new Cesium.HeadingPitchRange(
track.lastCameraHeading,
cameraView.pitch,
cameraRange,
),
);
} else {
const tangentStep = Math.max(
0.002,
0.8 / Math.max(2, path.length - 1),
);
const tangentProgress = Math.min(
1,
state.phaseProgress + tangentStep,
);
const tangentPosition = parts.paths.samplePath(
path,
tangentProgress > state.phaseProgress
? tangentProgress
: Math.max(0, state.phaseProgress - tangentStep),
);
const orbitPose = parts.camera.replayOrbitCameraPose(
position,
tangentPosition,
cameraTarget,
cameraRange,
cameraView.pitch,
);
if (orbitPose) {
if (!track.orbitCameraWorldFrame) {
layerState._viewer.camera.lookAtTransform(
Cesium.Matrix4.IDENTITY,
);
track.orbitCameraWorldFrame = true;
}
layerState._viewer.camera.setView({
destination: orbitPose.destination,
orientation: {
direction: orbitPose.direction,
up: orbitPose.up,
},
});
}
}
if (
state.elapsedSinceStart >=
ascentDurationSec + REPLAY_ORBIT_DURATION_SEC
) {
stopMissionReplay();
}
});
layerState._viewer.camera.flyToBoundingSphere(
new Cesium.BoundingSphere(track.ascentPath[0], 0),
{
offset: new Cesium.HeadingPitchRange(
initialHeading,
Cesium.Math.toRadians(-20),
REPLAY_INITIAL_RANGE_M,
),
duration: 1.4,
easingFunction: Cesium.EasingFunction.CUBIC_IN_OUT,
complete: () => {
cameraReady = true;
},
cancel: () => {
if (
token === layerState._replayCameraToken &&
layerState._replayCameraLaunchId === launchId
)
stopMissionReplay();
},
},
);
return true;
}
return {
replayVehicleScreenRotation,
smoothReplayWindowPosition,
replayAscentDurationSeconds,
normalizeReplaySpeed,
replayStartAfterPause,
replayState,
syncReplayButton,
presentReplay,
syncReplayCountdownButton,
syncReplaySpeedControl,
setReplaySpeed,
replayClockNow,
pauseMissionReplay,
resumeMissionReplay,
stopMissionReplay,
startMissionReplay,
};
}