Files
gods-eye-view/src/layers/satellites/issCommand.js
T
Denis Groshev 9cc077964f ISS live telemetry, STATION and LIVE sections, Tiangong model, drawn through the renderer's draw port
Builds on the ISS 3D model (PR #1690) and brings it onto main's renderer
seam: the station models are items of a `models` draw set, posed by
heading, pitch and roll from the station's flight axes
(`headingPitchRollOfAxes`), with the camera, canvas and clicks read from
the renderer's ports; no satellites file reaches Cesium. The joint drivers
write column-major matrices into node poses the model part keeps, for a
renderer that can pose nodes; until the draw contract has that member the
models draw rigid.

- ISS joints take their angles from NASA's ISSLive telemetry, relayed by
  the server behind ISS_TELEMETRY_ENABLED.
- STATION and LIVE sections of Context replace the floating command panel
  and player; both collapse like the Radio section.
- Cockpit rides the ISS from mounts on its model; the LIVE page in the
  Cockpit briefing.
- Tiangong as a second station model, with computed joints.
- Installations: a label-box click selects the site.
2026-11-16 18:39:39 +01:00

170 lines
6.2 KiB
JavaScript

import { t } from '../../i18n/index.js';
import { ISS_NORAD, issTrackedOnStation } from './policy.js';
/**
* Whether the command panel shows: the ISS selected (tracked), or an object
* docked to it, the layer on and the Cockpit not riding it.
* @param {{enabled: boolean, trackedNorad: number|null, cockpitHeld: boolean,
* docked?: boolean}} input `docked`: the tracked satellite is docked to the
* ISS (issTrackedOnStation).
* @returns {boolean}
*/
export function issCommandShouldShow({
enabled,
trackedNorad,
cockpitHeld,
docked = false,
}) {
const onStation =
trackedNorad === ISS_NORAD || (Boolean(docked) && trackedNorad !== null);
return Boolean(enabled) && onStation && !cockpitHeld;
}
const unit = (v) => {
const n = Math.hypot(...v);
return v.map((c) => c / n);
};
/**
* The Sun positions Manual offers, on the model's axes (port, zenith,
* forward), and whether the station is lit there.
* @returns {Array<{label: string, sun: number[], sunlit: boolean}>}
*/
export function issCommandSunPoses() {
return [
{ label: t('Overhead'), sun: [0, 1, 0], sunlit: true },
{ label: t('Ahead'), sun: unit([0, 0.05, 1]), sunlit: true },
{ label: t('Behind'), sun: unit([0, 0.05, -1]), sunlit: true },
{ label: t('Below'), sun: unit([0, -1, 0.05]), sunlit: true },
{ label: t('Port side'), sun: unit([0.8, 0.5, 0.3]), sunlit: true },
{ label: t('Starboard side'), sun: unit([-0.8, 0.5, 0.3]), sunlit: true },
{ label: t('Night (shadow)'), sun: [0, -1, 0], sunlit: false },
];
}
/** Where "Zoom to the ISS" stops: the whole 109 m station fills the view. */
export const ISS_COMMAND_ZOOM_RANGE_M = 260;
/**
* The Automatic mode's status line.
* @param {boolean|null} sunlit Null while the model has not been placed yet.
* @returns {string}
*/
export function issCommandStatusText(sunlit) {
if (sunlit === null) return '';
return sunlit ? t('Now: in sunlight') : t("Now: in the Earth's shadow");
}
/**
* The Automatic mode's note: what moves the joints right now.
* @param {boolean} live Whether the joints are on NASA's telemetry.
* @returns {string}
*/
export function issCommandNoteText(live) {
return live
? t(
"Arrays, radiators and one dish follow NASA's live telemetry. The other dish holds still and the arms sway for illustration.",
)
: t(
'Arrays and radiators follow the Sun, the dishes aim at relay satellites and the arms sway for illustration. Computed, not live telemetry.',
);
}
/** Beyond this the camera counts as far, and the zoom button is offered. */
export const ISS_COMMAND_FAR_M = 1000;
/**
* Whether "Zoom to the ISS" is offered: only from far away, so it goes once
* the camera is in close (by the button or by hand) and returns on zooming
* back out.
* @param {number} distance Meters from the camera to the station.
* @returns {boolean}
*/
export function issCommandOffersZoom(distance) {
return distance > ISS_COMMAND_FAR_M;
}
/**
* One step of the zoom: how far to move in from `distance`, easing out as
* the target range nears, never past it.
* @param {number} distance Meters from the camera to the station.
* @returns {number} Meters to move in; 0 once close enough.
*/
export function issCommandZoomStep(distance) {
const left = distance - ISS_COMMAND_ZOOM_RANGE_M;
if (!(left > ISS_COMMAND_ZOOM_RANGE_M * 0.02)) return 0;
return left * 0.14;
}
/**
* The follow camera's range after one step of the zoom: the step nearer,
* never past the target range, and unchanged once there. The camera is moved
* by scaling its follow offset from the station (the camera port's
* `followOffset`, the eye in the follow's frame) by
* `issCommandZoomRange(range) / range`, which can only bring it in; a move
* along the view direction is not used, since it ran away when the camera
* was not looking at the station.
* @param {number} range Meters from the camera to the station.
* @returns {number} The range to set; `range` itself when there is no step.
*/
export function issCommandZoomRange(range) {
if (!(range > 0) || !Number.isFinite(range)) return range;
const step = issCommandZoomStep(range);
return step > 0 ? Math.max(ISS_COMMAND_ZOOM_RANGE_M, range - step) : range;
}
/**
* One step of the zoom on the follow offset: the same offset, shortened to
* `issCommandZoomRange` of its length, so the eye keeps its bearing on the
* station and only comes in.
* @param {{x: number, y: number, z: number}|null|undefined} offset The
* eye's offset from the station, metres in the follow's frame.
* @returns {{x: number, y: number, z: number}|null} The offset to set; null
* when there is no step (close enough, or no offset to shorten).
*/
export function issCommandZoomOffset(offset) {
if (!offset) return null;
const range = Math.hypot(offset.x, offset.y, offset.z);
const next = issCommandZoomRange(range);
if (!(next < range)) return null;
const k = next / range;
return { x: offset.x * k, y: offset.y * k, z: offset.z * k };
}
/**
* Whether the zoom may run: only while the camera follows the station's
* follow target and has framed it, so that its follow offset is the eye's
* offset from the station and shortening it brings the camera in. From any
* other camera (still flying to the station, following something else, or
* a follow not yet framed) there is no such offset to shorten.
* @param {{followed?: object|null, followFramed?: boolean}|null|undefined}
* camera What the camera port reports (`cameraOf(viewer)`).
* @param {object|null|undefined} target The layer's follow target for the
* station (`layerState._followTarget`).
* @returns {boolean}
*/
export function issCommandCameraOnStation(camera, target) {
return (
Boolean(target) &&
camera?.followed === target &&
camera.followFramed === true
);
}
/** How long one lap of the "fast orbit" takes, and its share in shadow. */
const FAST_ORBIT_MS = 40_000;
/**
* The Sun over one accelerated orbit: it circles the truss, a third of the
* lap in the Earth's shadow.
* @param {number} elapsedMs
* @returns {{sun: number[], sunlit: boolean}}
*/
export function issCommandFastOrbit(elapsedMs) {
const angle = (elapsedMs / FAST_ORBIT_MS) * 2 * Math.PI;
return {
sun: unit([0.35, Math.cos(angle), Math.sin(angle)]),
sunlit: Math.cos(angle) > -0.5,
};
}