Files
gods-eye-view/src/layers/satellites/rendering.js
T
Sameh Khamis d513034f3d Draw the satellites layer through the renderer ports
The satellite dots, the tracked satellite's dot and the orbit rings now go
through the draw port instead of a raw point collection, an entity and
primitives, so the layer's rendering no longer drives Cesium and leaves the
Cesium allow-list.

- Dots are one points set, patched in place and sent once per frame.
- The tracked dot is its own set, drawn at the sample the follow camera
  framed (or after the frame's own sample when no camera read it).
- Rings are geodesic lines with a behind-the-globe colour, turned about the
  pole by the sidereal angle in the layer each second, since the port has no
  inertial frame. The orbit frame matrix is a plain 16-number array, and
  the launches layer now receives plain ECEF orbit positions.
- Clicks match the draw hit against the layer's own sets.
- The focus pass projects every dot in one batched call.
- Depth-fail lines in the Cesium draw port honour pickable: false.
2026-11-08 13:06:52 -08:00

751 lines
24 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 { drawOf, findCamera, findQuery } from '../../render/rendererOf.js';
import { fromDegreesInto } from '../../geo/ellipsoid.js';
import { distance } from '../../geo/vector.js';
import { gstime } from 'satellite.js';
import { ISS_NORAD, POSITION_UPDATE_MS, RING_ROTATION_MS } from './policy.js';
/**
* The satellites layer's drawing, through the renderer contract's draw port:
* a points set of the satellite dots, a points set of the tracked
* satellite's dot, and a lines set of the orbit rings, with the per-frame
* tick that moves them. The other parts hand it render-contract values
* (ECEF `{x, y, z}`, colours as `[r, g, b, a]`).
*
* `layerState._points` keeps each satellite's dot as the point item it is
* drawn from (NORAD id → item): its `pos` is moved in place, so a reader
* holding it sees where the dot is now, as one holding a point primitive's
* position did. Writes are kept and sent to the set once per frame, at the
* end of the tick, so a catalog of thousands moves in one upsert.
*/
/** Points shrink with distance as they always have. */
const POINT_SCALE_BY_DISTANCE = Object.freeze({
near: 1e6,
nearValue: 1.5,
far: 2e7,
farValue: 0.6,
});
/**
* The tracked satellite's dot: 14 px yellow with a white outline, drawn
* over everything.
*/
const TRACKED_DOT = Object.freeze({
pixelSize: 14,
color: Object.freeze([1, 1, 0, 1]),
outlineColor: Object.freeze([1, 1, 1, 1]),
outlineWidth: 2,
disableDepthTest: Number.POSITIVE_INFINITY,
});
/** An orbit ring's colour when none is given (cyan). */
const DEFAULT_RING_COLOR = Object.freeze([0, 1, 1, 1]);
/** Rings: this alpha in front of the globe, the dimmer one behind it. */
const RING_ALPHA = 0.6;
const RING_BEHIND_ALPHA = 0.35;
/** An RGBA colour with another alpha. */
const withAlpha = (color, alpha) => [color[0], color[1], color[2], alpha];
/** Layer instances so far: set ids unique to each. */
let instances = 0;
export function createRendering({
state: layerState,
services,
parts,
source,
}) {
const {
focusNowMs,
getFocusTarget,
focusPassIsNeeded,
nearFarScalarValueAtDistance,
advanceSpriteFocus,
focusAlphaNeedsWrite,
publishFocusTargetAt,
} = services.focus;
// The tracked satellite's per-frame ECEF sample (WS-D2), shared with the
// tracked dot, the follow camera and the tracked card. Tracking writes its
// x/y/z in place.
layerState._trackedFrameCartesian = { x: 0, y: 0, z: 0 };
/** The draw sets, while attached: `{points, tracked, rings}`. */
let sets = null;
/** Dots changed since the last write to the set, by NORAD id. */
const dirty = new Set();
/** Dots removed since the last write to the set, by NORAD id. */
const gone = new Set();
/** Whether every dot was removed since the last write. */
let cleared = false;
/** Whether the satellite dots are shown. */
let pointsShown = true;
/**
* The tracked dot: its item and how its position is read (the tracker's
* callback, read as the follow camera reads it).
*/
let trackedDot = null;
let trackedDrawnThisTick = false;
/** The frame the tick last ran in: the tracked sample's cache key. */
let renderedFrame = -1;
/**
* Build the rigid ECEF transform that keeps an orbit path baked at one GMST
* aligned with live SGP4 positions propagated at another epoch: a column-
* major 4×4 rotation about Z.
* @param {number} gmstAtBake GMST used when the path positions were baked.
* @param {Date} nowDate Epoch whose rotating-Earth frame should be displayed.
* @param {ArrayLike<number>} [result] A 16-element matrix to update in place.
* @returns {ArrayLike<number>} Z-rotation from bake-time ECEF to current ECEF.
*/
function orbitFrameModelMatrix(gmstAtBake, nowDate, result = new Array(16)) {
const angle = -(gstime(nowDate) - gmstAtBake);
const c = Math.cos(angle);
const s = Math.sin(angle);
result[0] = c;
result[1] = s;
result[2] = 0;
result[3] = 0;
result[4] = -s;
result[5] = c;
result[6] = 0;
result[7] = 0;
result[8] = 0;
result[9] = 0;
result[10] = 1;
result[11] = 0;
result[12] = 0;
result[13] = 0;
result[14] = 0;
result[15] = 1;
return result;
}
/** ECEF `{x, y, z}` positions as the renderer's own: plain copies. */
function _rendererPositions(positions) {
return positions.map((p) => ({ x: p.x, y: p.y, z: p.z }));
}
/** The frame the tick last ran in, the tracked sample's cache key. */
function _drawnFrameNumber() {
return renderedFrame;
}
/** Make the sets the dots, the tracked dot and the rings draw in. */
function _attach(viewer) {
_attachTo(drawOf(viewer));
}
/** Make the layer's sets on `draw`, a draw port. */
function _attachTo(draw) {
if (sets) _detach();
const prefix = `satellites:${++instances}`;
pointsShown = true;
sets = {
points: draw.points({ id: `${prefix}:points`, show: pointsShown }),
tracked: draw.points({ id: `${prefix}:tracked` }),
// Ring clicks fall through to the satellites and the deselect.
rings: draw.lines({ id: `${prefix}:rings`, pickable: false }),
};
layerState._sets = sets;
dirty.clear();
gone.clear();
cleared = false;
// Dots kept while detached draw once attached.
for (const noradId of layerState._points.keys()) dirty.add(noradId);
}
/** Dispose of the sets; the dots and rings go with them. */
function _detach(viewer) {
if (!sets) return;
sets.points.dispose();
sets.tracked.dispose();
sets.rings.dispose();
sets = null;
layerState._sets = null;
trackedDot = null;
dirty.clear();
gone.clear();
cleared = false;
}
/** Whether there is a set to draw satellites in. */
function _hasPointCollection() {
return Boolean(sets);
}
/** Whether the satellite dots are shown. */
function _pointsShown() {
return Boolean(sets) && pointsShown;
}
function _setPointsShown(show) {
if (!sets) return;
pointsShown = show;
sets.points.show = show;
}
/** Show or hide every ring. */
function _setOrbitPathsShown(show) {
const changed = [];
for (const path of layerState._orbitPaths.values()) {
path.item.show = show;
changed.push(path.item);
}
if (sets && changed.length) sets.rings.upsert(changed);
}
function _setOrbitPathShown(noradId, show) {
const path = layerState._orbitPaths.get(noradId);
if (!path) return;
path.item.show = show;
sets?.rings.upsert([path.item]);
}
/** Remove every orbit ring. */
function _clearOrbitPaths() {
const ids = [...layerState._orbitPaths.values()].map(
(path) => path.item.id,
);
layerState._orbitPaths.clear();
if (sets && ids.length) sets.rings.remove(ids);
}
/** Note a dot's change, sent at the end of the frame's tick. */
function _markDirty(noradId) {
gone.delete(noradId);
dirty.add(noradId);
}
/** Send the dots changed since the last frame to the points set. */
function _flushPoints() {
if (!sets) return;
if (cleared) {
cleared = false;
gone.clear();
dirty.clear();
sets.points.set([...layerState._points.values()]);
return;
}
if (gone.size) {
sets.points.remove([...gone].map(String));
gone.clear();
}
if (dirty.size) {
const items = [];
for (const noradId of dirty) {
const item = layerState._points.get(noradId);
if (item) items.push(item);
}
dirty.clear();
if (items.length) sets.points.upsert(items);
}
}
/**
* Draw one satellite's dot.
* @param {number} noradId
* @param {{x: number, y: number, z: number}} position ECEF metres.
* @param {object} style A `POINT_STYLES` entry.
*/
function _addPoint(noradId, position, style) {
layerState._points.set(noradId, {
id: String(noradId),
pos: { x: position.x, y: position.y, z: position.z },
pixelSize: style.pixelSize,
color: style.color,
outlineColor: style.outlineColor,
outlineWidth: style.outlineWidth,
scaleByDistance: POINT_SCALE_BY_DISTANCE,
disableDepthTest: 0,
show: true,
meta: { noradId },
});
_markDirty(noradId);
}
/** Move a drawn dot to ECEF `position`; false when it has none. */
function _movePoint(noradId, position) {
const point = layerState._points.get(noradId);
if (!point) return false;
point.pos.x = position.x;
point.pos.y = position.y;
point.pos.z = position.z;
_markDirty(noradId);
return true;
}
function _removePoint(noradId) {
if (!layerState._points.delete(noradId)) return;
dirty.delete(noradId);
if (!cleared) gone.add(noradId);
}
/** Remove every dot. */
function _clearPoints() {
layerState._points.clear();
dirty.clear();
gone.clear();
cleared = true;
}
/** Where a dot is drawn (ECEF), or null. */
function _pointPosition(noradId) {
return layerState._points.get(noradId)?.pos || null;
}
/** Hide a dot while the tracked dot draws it. */
function _hidePoint(noradId) {
const point = layerState._points.get(noradId);
if (!point) return;
point.show = false;
_markDirty(noradId);
}
/** Show a dot again in its group's style (WS-D3). */
function _restorePoint(noradId, style) {
const point = layerState._points.get(noradId);
if (!point) return;
point.show = true;
point.pixelSize = style.pixelSize;
point.color = style.color;
point.outlineColor = style.outlineColor;
point.outlineWidth = style.outlineWidth;
point.disableDepthTest = 0;
_markDirty(noradId);
}
/**
* Draw the tracked satellite's dot and make the carrier the follow target
* and the tracked card read (its entity record holds the card).
* @param {{position: () => object, viewFrom: {x: number, y: number,
* z: number}}} options `position` is read as the follow camera reads
* it, once each frame before the tick moves the sample on.
* @returns {object} The carrier.
*/
function _addTrackedEntity({ position }) {
const noradId = layerState._trackedNorad;
const carrier = { noradId };
trackedDot = {
position,
item: {
id: String(noradId),
pos: { x: 0, y: 0, z: 0 },
...TRACKED_DOT,
meta: { noradId },
},
drawn: false,
};
// Drawn from the next frame's tick on, as the camera first frames it.
return carrier;
}
function _removeTrackedEntity() {
if (trackedDot?.drawn) sets?.tracked.clear();
trackedDot = null;
}
/** Put the tracked dot where the tracker says it is now. */
function _drawTrackedDot() {
if (!trackedDot || !sets) return;
const at = trackedDot.position();
if (!at) return;
const pos = trackedDot.item.pos;
pos.x = at.x;
pos.y = at.y;
pos.z = at.z;
sets.tracked.upsert([trackedDot.item]);
trackedDot.drawn = true;
}
/** Whether a click's draw hit is the tracked satellite's dot. */
function _hitIsTracked(hit) {
return Boolean(sets) && hit?.set === sets.tracked.id;
}
/** The NORAD id of the satellite dot a click's draw hit is on, or null. */
function _hitPointId(hit) {
if (!sets || hit?.set !== sets.points.id) return null;
const noradId = Number(hit.id);
return Number.isFinite(noradId) ? noradId : null;
}
/** Publish the tracked satellite's focus rectangle from its cached position. */
function _publishTrackedFocus(target) {
publishFocusTargetAt({ ...target, viewer: layerState._viewer });
}
/** A ring's positions rotated from its bake-time frame to `gmst`'s. */
function _ringPositions(path, gmst) {
const angle = -(gmst - path.gmstAtBake);
const c = Math.cos(angle);
const s = Math.sin(angle);
const base = path.base;
const out = new Float64Array(base.length * 3);
for (let i = 0; i < base.length; i++) {
const p = base[i];
out[i * 3] = c * p.x - s * p.y;
out[i * 3 + 1] = s * p.x + c * p.y;
out[i * 3 + 2] = p.z;
}
return out;
}
/**
* Show orbital path for a satellite: the ring over one orbit, baked once
* in ECEF at the current GMST, bright in front of the globe and dimmed
* behind it (`depthFailColor`), and turned with the Earth each
* `RING_ROTATION_MS` (`_updateOrbitPathRotations`).
*/
function _showOrbitPath(noradId, color) {
if (layerState._orbitPaths.has(noradId)) return; // already showing
const sat = layerState._catalog.get(noradId);
if (!sat || !layerState._viewer) return;
const bakeDate = new Date();
const base = parts.orbits.computeOrbitPath(sat.satrec, bakeDate);
if (base.length < 2) return;
const pathColor = color || DEFAULT_RING_COLOR;
const path = {
base,
// Same Date object as computeOrbitPath's internal fixedGmst → identical
// GMST value (gstime is pure), so the ring starts unturned.
gmstAtBake: gstime(bakeDate),
item: null,
};
path.item = {
id: String(noradId),
positions: _ringPositions(path, path.gmstAtBake),
widthPx: noradId === ISS_NORAD ? 2.5 : 2.0,
// Along the ellipsoid between samples, as the ring always ran.
mode: 'geodesic',
style: { kind: 'solid', color: withAlpha(pathColor, RING_ALPHA) },
depthFailColor: withAlpha(pathColor, RING_BEHIND_ALPHA),
show: true,
};
layerState._orbitPaths.set(noradId, path);
sets?.rings.upsert([path.item]);
}
/**
* Turn every baked orbit ring from its bake-time ECEF snapshot to current
* GMST (WS-D1). The baked ring is an inertial-frame snapshot frozen at
* gmstAtBake; the live dot lives in true rotating-frame ECEF, so without this
* the dot slides west off the ring at Earth-rotation rate (~0.25°/min).
*
* Sign derivation: a point fixed in inertial space keeps its right ascension
* α, so its ECEF longitude λ = α − gmst DECREASES by ΔGMST as time advances
* (it drifts WEST). A rotation about Z by θ INCREASES longitude by θ — so
* the baked points are rotated by −ΔGMST. Mental check: ISS baked over
* Austin at t0; 10 min later Austin has rotated east under the (inertial)
* ring, so the ring must sit further WEST in ECEF.
*
* Wraparound: gstime returns radians in [0, 2π), so the raw difference can be
* off from the continuous ΔGMST — but only by exact multiples of 2π, which a
* rotation cannot distinguish. Tiny negative deltas right after bake are
* likewise harmless. No unwrapping needed.
*
* No SGP4 here: WGS84 is rotationally symmetric about Z, so rotating the
* baked curve rigidly equals rebaking from rotated points. A ring with a
* `depthFailColor` is built at once where it now runs, so it never blinks.
* @param {Date} nowDate Epoch used for current GMST.
*/
function _updateOrbitPathRotations(nowDate) {
if (layerState._orbitPaths.size === 0) return;
const gmst = gstime(nowDate);
const changed = [];
for (const path of layerState._orbitPaths.values()) {
path.item.positions = _ringPositions(path, gmst);
changed.push(path.item);
}
sets?.rings.upsert(changed);
}
/**
* Remove orbital path for a satellite.
*/
function _hideOrbitPath(noradId) {
const path = layerState._orbitPaths.get(noradId);
if (!path) return;
layerState._orbitPaths.delete(noradId);
sets?.rings.remove([path.item.id]);
}
/**
* Propagate all CORE satellite positions and update their dots.
* (~840 sats ≈ 1.6 ms/pass — fine at the 1s/200ms cadence.) Dense extras are
* excluded: they refresh on the round-robin budget in _propagateDenseChunk.
*/
function _propagateAll() {
const now = new Date();
let updated = 0;
for (const [noradId, sat] of layerState._catalog) {
if (sat.group === 'dense') continue;
const pos = parts.orbits.propagatePosition(sat.satrec, now);
if (!pos) continue;
const point = layerState._points.get(noradId);
if (point) {
fromDegreesInto(pos.longitude, pos.latitude, pos.altitude, point.pos);
_markDirty(noradId);
updated++;
}
}
return updated;
}
/**
* Shared preRender tick (single definition for init + enable):
* - the tracked dot where the follow camera put it this frame,
* - core fleet propagation at 200ms-tracked / 1s-idle cadence,
* - dense extras on a per-frame round-robin budget,
* - tracked satellite's dot sample per frame (WS-D2),
* - orbit ring GMST re-alignment every ~1s (WS-D1),
* - the frame's dot changes sent to the points set.
* @param {{frame: number}} [t] The frame port's tick.
*/
function _preRenderTick(t) {
if (layerState._enabled) _tick();
// The frame's sample is taken from here on (the tracked dot above was
// drawn from the last one, as the camera framed it).
renderedFrame = Number.isFinite(t?.frame) ? t.frame : renderedFrame + 1;
if (layerState._enabled) _tickAfterFrame();
_flushPoints();
}
/** The tick's part read before the frame's own sample is taken. */
function _tick() {
// The tracked dot draws at the sample the follow camera framed this frame.
// With no camera reading it this frame, it is drawn after the frame's own
// sample instead, so the tracked satellite is propagated once a frame.
trackedDrawnThisTick = false;
if (
layerState._trackedNorad !== null &&
layerState._trackedFrameGeo !== null &&
layerState._trackedFrameNumber === renderedFrame
) {
_drawTrackedDot();
trackedDrawnThisTick = true;
}
}
/** The tick's part that takes the frame's own sample. */
function _tickAfterFrame() {
const now = focusNowMs(Date.now());
const interval = layerState._trackedNorad ? 200 : POSITION_UPDATE_MS;
// Space Missions keeps this layer enabled for TLE lookup while deliberately
// hiding its standalone fleet. Do not rebuild hidden point buffers on the
// one-second propagation cadence: that GPU upload presented as a periodic
// whole-globe pulse even though the camera remained stationary.
if (
layerState._params.showPoints &&
now - layerState._lastPropagation >= interval
) {
_propagateAll();
layerState._lastPropagation = now;
}
if (layerState._params.showPoints) parts.catalog._propagateDenseChunk();
// Keep the tracked satellite's (hidden) dot on the per-frame epoch shared
// with label + camera — runs after _propagateAll so the per-frame sample
// wins over the 200ms one.
if (layerState._trackedNorad !== null) {
const pos = parts.tracking._getTrackedFramePosition();
if (pos && layerState._points.has(layerState._trackedNorad))
_movePoint(layerState._trackedNorad, layerState._trackedFrameCartesian);
if (!trackedDrawnThisTick) _drawTrackedDot();
}
_updatePointFocus(now);
// Hidden standalone orbit rings do not need turning while Space Missions
// draws the selected mission orbit itself.
if (
layerState._params.showOrbits &&
now - layerState._lastRingRotation >= RING_ROTATION_MS
) {
_updateOrbitPathRotations(new Date(now));
layerState._lastRingRotation = now;
}
}
/** Focus alpha for satellite points, inside the existing shared preRender tick. */
// The focus pass projects every dot in one call, into buffers kept between
// passes, so a pass over thousands of dots allocates nothing per dot.
let focusSource = new Float64Array(0);
let focusScreen = new Float32Array(0);
const focusOrder = [];
const focusScreenXY = { x: 0, y: 0 };
function _updatePointFocus(nowMs) {
const target = getFocusTarget();
if (
!layerState._params.showPoints ||
!focusPassIsNeeded(target, layerState._activeFocusCount)
)
return;
if (nowMs - layerState._lastFocusUpdate < 80) return;
layerState._lastFocusUpdate = nowMs;
const query = findQuery(layerState._viewer);
const eye = findCamera(layerState._viewer)?.pose()?.position;
if (!query || !eye) return;
const count = layerState._points.size;
if (focusSource.length < count * 3) {
focusSource = new Float64Array(count * 3);
focusScreen = new Float32Array(count * 2);
}
focusOrder.length = 0;
for (const point of layerState._points.values()) {
const pos = point?.pos;
const i = focusOrder.length * 3;
focusSource[i] = pos ? pos.x : NaN;
focusSource[i + 1] = pos ? pos.y : NaN;
focusSource[i + 2] = pos ? pos.z : NaN;
focusOrder.push(pos);
}
query.projectMany(
focusSource.subarray(0, focusOrder.length * 3),
focusScreen,
);
// The pass asks in the points' own order, skipping some: a cursor finds
// each asked position in one sweep.
let cursor = 0;
const result = applySatellitePointFocusDeemphasis({
points: layerState._points,
trackedId: layerState._trackedNorad,
target,
previousActiveCount: layerState._activeFocusCount,
nowMs,
screenPositionFor: (position) => {
while (cursor < focusOrder.length && focusOrder[cursor] !== position)
cursor++;
if (cursor >= focusOrder.length) {
cursor = 0;
return query.project(position);
}
const x = focusScreen[cursor * 2];
const y = focusScreen[cursor * 2 + 1];
if (Number.isNaN(x) || Number.isNaN(y)) return null;
focusScreenXY.x = x;
focusScreenXY.y = y;
return focusScreenXY;
},
cameraDistanceFor: (position) => distance(eye, position),
baseColorFor: (noradId) =>
parts.controls._pointStyleFor(
noradId,
layerState._catalog.get(noradId)?.group,
).color,
});
layerState._activeFocusCount = result.activeCount;
}
/**
* Apply the gated satellite-point focus pass through the production color path.
* @param {object} input
* @param {Map<number, object>} input.points Point items by NORAD id; a
* written colour is sent to the set with the frame's other changes.
* @returns {{writes:number,transitioning:boolean,activeCount:number,ran:boolean}}
*/
function applySatellitePointFocusDeemphasis({
points,
trackedId,
target,
previousActiveCount = 0,
nowMs,
screenPositionFor,
cameraDistanceFor,
baseColorFor,
params,
}) {
if (!focusPassIsNeeded(target, previousActiveCount)) {
return { writes: 0, transitioning: false, activeCount: 0, ran: false };
}
let writes = 0;
let transitioning = false;
let activeCount = 0;
for (const [noradId, point] of points || []) {
if (noradId === trackedId || !point?.pos) continue;
const cameraDistance = cameraDistanceFor(point.pos);
const distanceScale = nearFarScalarValueAtDistance(
point.scaleByDistance,
cameraDistance,
);
const halfExtentPx = (point.pixelSize || 5) * distanceScale * 0.5;
const focus = advanceSpriteFocus(point, {
// Hidden points still release toward identity, preventing stale dim
// alpha if a catalog/presentation toggle later makes them visible.
screenPosition:
point.show === false ? null : screenPositionFor(point.pos),
cameraDistance,
nowMs,
target,
params,
spriteHalfWidthPx: halfExtentPx,
spriteHalfHeightPx: halfExtentPx,
});
transitioning ||= focus.transitioning;
if (focus.active) activeCount += 1;
const base = baseColorFor(noradId);
const alpha = base[3] * focus.factor;
if (focusAlphaNeedsWrite(point.color?.[3], alpha, params)) {
// Point stays continuously present at the non-zero emphasis floor; its
// own alpha yields around the tracked target, independent of draw order.
point.color = withAlpha(base, alpha);
if (points === layerState._points) _markDirty(noradId);
writes += 1;
}
}
return { writes, transitioning, activeCount, ran: true };
}
return {
orbitFrameModelMatrix,
_rendererPositions,
_drawnFrameNumber,
_attach,
_attachTo,
_detach,
_hasPointCollection,
_pointsShown,
_setPointsShown,
_setOrbitPathsShown,
_setOrbitPathShown,
_clearOrbitPaths,
_addPoint,
_movePoint,
_removePoint,
_clearPoints,
_pointPosition,
_hidePoint,
_restorePoint,
_addTrackedEntity,
_removeTrackedEntity,
_publishTrackedFocus,
_hitIsTracked,
_hitPointId,
_showOrbitPath,
_updateOrbitPathRotations,
_hideOrbitPath,
_propagateAll,
_preRenderTick,
_updatePointFocus,
applySatellitePointFocusDeemphasis,
_flushPoints,
};
}