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.
This commit is contained in:
Sameh Khamis committed 2026-11-08 13:06:52 -08:00
1 parent 1bff078097
commit d513034f3d
17 files changed
+845 -415

No files matched your search

+416 -251
View File
@@ -1,39 +1,55 @@
import * as Cesium from 'cesium';
// The camera and frame ports over a viewer with no renderer bound, for the
// tracking and lifecycle parts that follow and tick through them.
import '../../render/cesium/camera.js';
import '../../render/cesium/frame.js';
import { toCartesian } from '../../render/cesium/common.js';
import { toColor as cesiumColor } from '../../render/cesium/draw.js';
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 Cesium side: the point collection and its point
* primitives, the baked orbit-ring primitives, the tracked entity the follow
* camera and the tracked card read, and 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]`) and never touch these objects themselves.
* 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 = new Cesium.NearFarScalar(1e6, 1.5, 2e7, 0.6);
const POINT_SCALE_BY_DISTANCE = Object.freeze({
near: 1e6,
nearValue: 1.5,
far: 2e7,
farValue: 0.6,
});
/** Each policy style once in Cesium's colours (styles are module constants). */
const cesiumStyles = new WeakMap();
function cesiumStyleOf(style) {
let converted = cesiumStyles.get(style);
if (!converted) {
converted = {
pixelSize: style.pixelSize,
color: cesiumColor(style.color),
outlineColor: cesiumColor(style.outlineColor),
outlineWidth: style.outlineWidth,
};
cesiumStyles.set(style, converted);
}
return converted;
}
/**
* 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,
@@ -51,96 +67,182 @@ export function createRendering({
publishFocusTargetAt,
} = services.focus;
const scratchFocusScreen = new Cesium.Cartesian2();
const scratchRingRotation = new Cesium.Matrix3();
// The tracked satellite's per-frame ECEF sample (WS-D2), shared with the
// tracked entity, the follow camera and the tracked card. Tracking writes
// its x/y/z; it stays one Cesium value for the readers that take it.
layerState._trackedFrameCartesian = new Cesium.Cartesian3();
// 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.
* 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 {Cesium.Matrix4} [result] Optional matrix to update in place.
* @returns {Cesium.Matrix4} Z-rotation from bake-time ECEF to current ECEF.
* @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 Cesium.Matrix4(),
) {
const deltaGmst = gstime(nowDate) - gmstAtBake;
const rotation = Cesium.Matrix3.fromRotationZ(
-deltaGmst,
scratchRingRotation,
);
return Cesium.Matrix4.fromRotationTranslation(
rotation,
Cesium.Cartesian3.ZERO,
result,
);
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. */
/** ECEF `{x, y, z}` positions as the renderer's own: plain copies. */
function _rendererPositions(positions) {
return positions.map(toCartesian);
return positions.map((p) => ({ x: p.x, y: p.y, z: p.z }));
}
/** The scene's rendered-frame number, the tracked sample's cache key. */
/** The frame the tick last ran in, the tracked sample's cache key. */
function _drawnFrameNumber() {
return layerState._viewer?.scene?.frameState?.frameNumber ?? -1;
return renderedFrame;
}
/** Add the point collection the satellite dots draw in. */
/** Make the sets the dots, the tracked dot and the rings draw in. */
function _attach(viewer) {
layerState._pointCollection = new Cesium.PointPrimitiveCollection();
viewer.scene.primitives.add(layerState._pointCollection);
_attachTo(drawOf(viewer));
}
/** Remove the point collection and every orbit ring from `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 (layerState._pointCollection) {
viewer.scene.primitives.remove(layerState._pointCollection);
layerState._pointCollection = null;
}
// Orbit ring primitives are removed (and destroyed) here
for (const path of layerState._orbitPaths.values()) {
viewer.scene.primitives.remove(path.primitive);
}
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 point collection to draw satellites in. */
/** Whether there is a set to draw satellites in. */
function _hasPointCollection() {
return Boolean(layerState._pointCollection);
return Boolean(sets);
}
/** Whether the satellite dots are shown. */
function _pointsShown() {
return Boolean(layerState._pointCollection?.show);
return Boolean(sets) && pointsShown;
}
function _setPointsShown(show) {
if (layerState._pointCollection) layerState._pointCollection.show = show;
if (!sets) return;
pointsShown = show;
sets.points.show = show;
}
/** Show or hide every ring. */
function _setOrbitPathsShown(show) {
for (const path of layerState._orbitPaths.values())
path.primitive.show = 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) path.primitive.show = show;
if (!path) return;
path.item.show = show;
sets?.rings.upsert([path.item]);
}
/** Remove every orbit ring from `viewer`'s scene. */
function _clearOrbitPaths(viewer) {
for (const path of layerState._orbitPaths.values())
viewer.scene.primitives.remove(path.primitive);
/** 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);
}
}
/**
@@ -150,104 +252,125 @@ export function createRendering({
* @param {object} style A `POINT_STYLES` entry.
*/
function _addPoint(noradId, position, style) {
const look = cesiumStyleOf(style);
const point = layerState._pointCollection.add({
position: toCartesian(position),
pixelSize: look.pixelSize,
color: look.color,
outlineColor: look.outlineColor,
outlineWidth: look.outlineWidth,
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,
id: noradId,
disableDepthTest: 0,
show: true,
meta: { noradId },
});
layerState._points.set(noradId, point);
_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.position = position; // primitive setter clones
point.pos.x = position.x;
point.pos.y = position.y;
point.pos.z = position.z;
_markDirty(noradId);
return true;
}
function _removePoint(noradId) {
const point = layerState._points.get(noradId);
if (point && layerState._pointCollection)
layerState._pointCollection.remove(point);
layerState._points.delete(noradId);
if (!layerState._points.delete(noradId)) return;
dirty.delete(noradId);
if (!cleared) gone.add(noradId);
}
/** Remove every dot. */
function _clearPoints() {
layerState._pointCollection.removeAll();
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)?.position || null;
return layerState._points.get(noradId)?.pos || null;
}
/** Hide a dot while the tracked entity draws it. */
/** Hide a dot while the tracked dot draws it. */
function _hidePoint(noradId) {
const point = layerState._points.get(noradId);
if (point) point.show = false;
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;
const look = cesiumStyleOf(style);
point.show = true;
point.pixelSize = look.pixelSize;
point.color = look.color;
point.outlineColor = look.outlineColor;
point.outlineWidth = look.outlineWidth;
point.disableDepthTestDistance = 0;
point.pixelSize = style.pixelSize;
point.color = style.color;
point.outlineColor = style.outlineColor;
point.outlineWidth = style.outlineWidth;
point.disableDepthTest = 0;
_markDirty(noradId);
}
/**
* Add the tracked satellite's entity: it owns a point graphic so the
* follow camera can resolve a bounding sphere (a label-only entity left
* the camera stranded), and the tracked card reads its entity record.
* 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 evaluated every time it is read.
* @returns {object} The entity.
* 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, viewFrom }) {
return layerState._viewer.entities.add({
position: new Cesium.CallbackProperty(position, false),
viewFrom: toCartesian(viewFrom),
point: {
pixelSize: 14,
color: Cesium.Color.YELLOW,
outlineColor: Cesium.Color.WHITE,
outlineWidth: 2,
disableDepthTestDistance: Number.POSITIVE_INFINITY,
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(entity) {
layerState._viewer.entities.remove(entity);
function _removeTrackedEntity() {
if (trackedDot?.drawn) sets?.tracked.clear();
trackedDot = null;
}
/** Whether a scene pick is the tracked satellite's entity. */
function _pickIsTrackedEntity(picked) {
return picked?.id === layerState._trackedEntity;
/** 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;
}
/**
* The NORAD id a scene pick's point primitive carries, or null. Any
* primitive with a numeric id answers; the caller checks the catalog.
*/
function _pickedPointId(picked) {
const prim = picked?.primitive;
if (!prim || prim.id == null) return null;
const noradId = Number(prim.id);
return isNaN(noradId) ? null : noradId;
/** 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. */
@@ -255,23 +378,27 @@ export function createRendering({
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.
*
* RING FLICKER FIX: this is a one-instance Cesium.Primitive built
* synchronously ONCE (asynchronous: false), then re-aligned to current GMST
* each tick via its modelMatrix. The previous Entity-polyline approach
* rebuilt geometry ASYNCHRONOUSLY on every positions assignment, which made
* both the selected ring and the ISS ring blink once per second while the
* rebuild was in flight. A rigid Z-rotation needs no rebuild at all.
*
* Why not a CallbackProperty entity (dynamic mode)? Verified in Cesium
* 1.138 source: the dynamic polyline updater renders through a shared
* PolylineCollection and applies only the fill material —
* `depthFailMaterial` is silently dropped, losing the dimmed behind-Earth
* segment. The Primitive keeps it via depthFailAppearance + the per-instance
* depthFailColor attribute (same mechanism the entity STATIC batch uses):
* bright where above the horizon, dimmed where behind the globe.
* 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) {
@@ -281,86 +408,64 @@ export function createRendering({
if (!sat || !layerState._viewer) return;
const bakeDate = new Date();
const basePositions = _rendererPositions(
parts.orbits.computeOrbitPath(sat.satrec, bakeDate),
);
if (basePositions.length < 2) return;
const base = parts.orbits.computeOrbitPath(sat.satrec, bakeDate);
if (base.length < 2) return;
const pathColor = color ? cesiumColor(color) : Cesium.Color.CYAN;
const primitive = new Cesium.Primitive({
geometryInstances: new Cesium.GeometryInstance({
geometry: new Cesium.PolylineGeometry({
positions: basePositions,
width: noradId === ISS_NORAD ? 2.5 : 2.0,
vertexFormat: Cesium.PolylineColorAppearance.VERTEX_FORMAT,
}),
attributes: {
color: Cesium.ColorGeometryInstanceAttribute.fromColor(
pathColor.withAlpha(0.6),
),
depthFailColor: Cesium.ColorGeometryInstanceAttribute.fromColor(
pathColor.withAlpha(0.35),
),
},
}),
appearance: new Cesium.PolylineColorAppearance({ translucent: true }),
depthFailAppearance: new Cesium.PolylineColorAppearance({
translucent: true,
}),
asynchronous: false, // build this frame — no async-rebuild blink window
allowPicking: false, // ring clicks fall through to satellites/deselect
});
layerState._viewer.scene.primitives.add(primitive);
layerState._orbitPaths.set(noradId, {
primitive,
const pathColor = color || DEFAULT_RING_COLOR;
const path = {
base,
// Same Date object as computeOrbitPath's internal fixedGmst → identical
// GMST value (gstime is pure), so delta starts at exactly 0 and the
// initial identity modelMatrix is correct until the first ring tick.
// 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]);
}
/**
* Rotate every baked orbit ring from its bake-time ECEF snapshot to current
* 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). Cesium.Matrix3.fromRotationZ(θ) rotates +X toward +Y,
* i.e. INCREASES longitude by θ — so we rotate the baked points 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.
* (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 — the rotation is applied as the ring primitive's modelMatrix
* (exact compensation; WGS84 is rotationally symmetric about Z, so rotating
* the baked curve rigidly equals rebaking from rotated points). modelMatrix
* updates are synchronous uniforms — no geometry rebuild, no flicker. Post-
* creation modelMatrix changes are supported for one-instance primitives in
* 3D mode, which these rings are. In-place mutation is safe: Primitive.update
* diffs modelMatrix against an internal clone.
* 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()) {
if (!path.primitive) continue;
orbitFrameModelMatrix(
path.gmstAtBake,
nowDate,
path.primitive.modelMatrix,
);
path.item.positions = _ringPositions(path, gmst);
changed.push(path.item);
}
sets?.rings.upsert(changed);
}
/**
@@ -369,15 +474,13 @@ export function createRendering({
function _hideOrbitPath(noradId) {
const path = layerState._orbitPaths.get(noradId);
if (path) {
if (layerState._viewer)
layerState._viewer.scene.primitives.remove(path.primitive); // remove() destroys
layerState._orbitPaths.delete(noradId);
}
if (!path) return;
layerState._orbitPaths.delete(noradId);
sets?.rings.remove([path.item.id]);
}
/**
* Propagate all CORE satellite positions and update point primitives.
* 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.
*/
@@ -391,14 +494,10 @@ export function createRendering({
const pos = parts.orbits.propagatePosition(sat.satrec, now);
if (!pos) continue;
const cartesian = Cesium.Cartesian3.fromDegrees(
pos.longitude,
pos.latitude,
pos.altitude,
);
const point = layerState._points.get(noradId);
if (point) {
point.position = cartesian;
fromDegreesInto(pos.longitude, pos.latitude, pos.altitude, point.pos);
_markDirty(noradId);
updated++;
}
}
@@ -407,15 +506,43 @@ export function createRendering({
}
/**
* Shared scene.preRender tick (single definition for init + enable):
* 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 point primitive per frame (WS-D2),
* - orbit ring GMST re-alignment every ~1s (WS-D1).
* - 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() {
if (!layerState._enabled) return;
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;
@@ -433,20 +560,20 @@ export function createRendering({
if (layerState._params.showPoints) parts.catalog._propagateDenseChunk();
// Keep the tracked dot on the per-frame epoch shared with label + camera —
// runs after _propagateAll so the per-frame sample wins over the 200ms one.
// 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();
const point = layerState._points.get(layerState._trackedNorad);
if (pos && point) {
point.position = layerState._trackedFrameCartesian; // primitive setter clones
}
if (pos && layerState._points.has(layerState._trackedNorad))
_movePoint(layerState._trackedNorad, layerState._trackedFrameCartesian);
if (!trackedDrawnThisTick) _drawTrackedDot();
}
_updatePointFocus(now);
// Hidden standalone orbit primitives do not need GMST matrix writes while
// Space Missions draws the selected mission orbit itself.
// 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
@@ -458,6 +585,12 @@ export function createRendering({
/** 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 (
@@ -467,28 +600,55 @@ export function createRendering({
return;
if (nowMs - layerState._lastFocusUpdate < 80) return;
layerState._lastFocusUpdate = nowMs;
const scene = layerState._viewer.scene;
const camera = layerState._viewer.camera;
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) =>
Cesium.SceneTransforms.worldToWindowCoordinates(
scene,
position,
scratchFocusScreen,
),
cameraDistanceFor: (position) =>
Cesium.Cartesian3.distance(camera.positionWC, position),
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) =>
cesiumStyleOf(
parts.controls._pointStyleFor(
noradId,
layerState._catalog.get(noradId)?.group,
),
parts.controls._pointStyleFor(
noradId,
layerState._catalog.get(noradId)?.group,
).color,
});
layerState._activeFocusCount = result.activeCount;
@@ -497,6 +657,8 @@ export function createRendering({
/**
* 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}}
*/
@@ -518,8 +680,8 @@ export function createRendering({
let transitioning = false;
let activeCount = 0;
for (const [noradId, point] of points || []) {
if (noradId === trackedId || !point?.position) continue;
const cameraDistance = cameraDistanceFor(point.position);
if (noradId === trackedId || !point?.pos) continue;
const cameraDistance = cameraDistanceFor(point.pos);
const distanceScale = nearFarScalarValueAtDistance(
point.scaleByDistance,
cameraDistance,
@@ -529,7 +691,7 @@ export function createRendering({
// 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.position),
point.show === false ? null : screenPositionFor(point.pos),
cameraDistance,
nowMs,
target,
@@ -540,11 +702,12 @@ export function createRendering({
transitioning ||= focus.transitioning;
if (focus.active) activeCount += 1;
const base = baseColorFor(noradId);
const alpha = base.alpha * focus.factor;
if (focusAlphaNeedsWrite(point.color?.alpha, alpha, params)) {
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 = base.withAlpha(alpha);
point.color = withAlpha(base, alpha);
if (points === layerState._points) _markDirty(noradId);
writes += 1;
}
}
@@ -555,6 +718,7 @@ export function createRendering({
_rendererPositions,
_drawnFrameNumber,
_attach,
_attachTo,
_detach,
_hasPointCollection,
_pointsShown,
@@ -572,8 +736,8 @@ export function createRendering({
_addTrackedEntity,
_removeTrackedEntity,
_publishTrackedFocus,
_pickIsTrackedEntity,
_pickedPointId,
_hitIsTracked,
_hitPointId,
_showOrbitPath,
_updateOrbitPathRotations,
_hideOrbitPath,
@@ -581,5 +745,6 @@ export function createRendering({
_preRenderTick,
_updatePointFocus,
applySatellitePointFocusDeemphasis,
_flushPoints,
};
}