mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 16:22:20 +00:00
# Conflicts: # scripts/package-boundaries.json # src/i18n/locales/ar.json # src/i18n/locales/de.json # src/i18n/locales/es.json # src/i18n/locales/fr.json # src/i18n/locales/it.json # src/i18n/locales/ja.json # src/i18n/locales/pt.json # src/i18n/locales/ru.json # src/i18n/locales/uk.json # src/i18n/locales/zh-CN.json # src/i18n/locales/zh-Hant.json # src/layers/satellites/ingestion.test.mjs # src/layers/satellites/lifecycle.js # src/layers/satellites/state.js
336 lines
12 KiB
JavaScript
336 lines
12 KiB
JavaScript
import * as Cesium from 'cesium';
|
||
import { gstime } from 'satellite.js';
|
||
import {
|
||
ISS_NORAD,
|
||
ORBIT_REBAKE_MS,
|
||
POSITION_UPDATE_MS,
|
||
RING_ROTATION_MS,
|
||
} from './policy.js';
|
||
|
||
export function createRendering({
|
||
state: layerState,
|
||
services,
|
||
parts,
|
||
source,
|
||
}) {
|
||
const {
|
||
focusNowMs,
|
||
getFocusTarget,
|
||
focusPassIsNeeded,
|
||
nearFarScalarValueAtDistance,
|
||
advanceSpriteFocus,
|
||
focusAlphaNeedsWrite,
|
||
} = services.focus;
|
||
|
||
/**
|
||
* 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.
|
||
*/
|
||
|
||
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(layerState.now());
|
||
const basePositions = parts.orbits.computeOrbitPath(sat.satrec, bakeDate);
|
||
if (basePositions.length < 2) return;
|
||
|
||
const pathColor = 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,
|
||
color: pathColor,
|
||
bakeMs: bakeDate.getTime(),
|
||
// 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.
|
||
gmstAtBake: gstime(bakeDate),
|
||
});
|
||
}
|
||
|
||
/**
|
||
* Rotate 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.
|
||
*
|
||
* 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.
|
||
* @param {Date} nowDate Epoch used for current GMST.
|
||
*/
|
||
|
||
function _updateOrbitPathRotations(nowDate) {
|
||
if (layerState._orbitPaths.size === 0) return;
|
||
|
||
for (const [noradId, path] of [...layerState._orbitPaths]) {
|
||
if (!path.primitive) continue;
|
||
// The rotation keeps the ring under the dot for minutes; the plane
|
||
// itself precesses, so a world time moved far from the bake re-bakes.
|
||
if (Math.abs(nowDate.getTime() - path.bakeMs) > ORBIT_REBAKE_MS) {
|
||
_hideOrbitPath(noradId);
|
||
_showOrbitPath(noradId, path.color);
|
||
continue;
|
||
}
|
||
parts.orbits.orbitFrameModelMatrix(
|
||
path.gmstAtBake,
|
||
nowDate,
|
||
path.primitive.modelMatrix,
|
||
);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Remove orbital path for a satellite.
|
||
*/
|
||
|
||
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);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Propagate all CORE satellite positions and update point primitives.
|
||
* (About 1,300 core satellites: ~840 measured at ≈ 1.6 ms/pass, so ≈ 2.5 ms,
|
||
* 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(layerState.now());
|
||
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 cartesian = Cesium.Cartesian3.fromDegrees(
|
||
pos.longitude,
|
||
pos.latitude,
|
||
pos.altitude,
|
||
);
|
||
const point = layerState._points.get(noradId);
|
||
if (point) {
|
||
point.position = cartesian;
|
||
updated++;
|
||
}
|
||
}
|
||
|
||
return updated;
|
||
}
|
||
|
||
/**
|
||
* Shared scene.preRender tick (single definition for init + enable):
|
||
* - 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).
|
||
*/
|
||
|
||
function _preRenderTick() {
|
||
if (!layerState._enabled) return;
|
||
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 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
|
||
}
|
||
}
|
||
|
||
_updatePointFocus(now);
|
||
|
||
// Hidden standalone orbit primitives do not need GMST matrix writes while
|
||
// Space Missions draws the selected mission orbit itself.
|
||
if (
|
||
layerState._params.showOrbits &&
|
||
now - layerState._lastRingRotation >= RING_ROTATION_MS
|
||
) {
|
||
_updateOrbitPathRotations(new Date(layerState.now()));
|
||
layerState._lastRingRotation = now;
|
||
}
|
||
}
|
||
|
||
/** Focus alpha for satellite points, inside the existing shared preRender tick. */
|
||
|
||
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 scene = layerState._viewer.scene;
|
||
const camera = layerState._viewer.camera;
|
||
const result = applySatellitePointFocusDeemphasis({
|
||
points: layerState._points,
|
||
trackedId: layerState._trackedNorad,
|
||
target,
|
||
previousActiveCount: layerState._activeFocusCount,
|
||
nowMs,
|
||
screenPositionFor: (position) =>
|
||
Cesium.SceneTransforms.worldToWindowCoordinates(
|
||
scene,
|
||
position,
|
||
layerState._scratchFocusScreen,
|
||
),
|
||
cameraDistanceFor: (position) =>
|
||
Cesium.Cartesian3.distance(camera.positionWC, 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
|
||
* @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?.position) continue;
|
||
const cameraDistance = cameraDistanceFor(point.position);
|
||
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.position),
|
||
cameraDistance,
|
||
nowMs,
|
||
target,
|
||
params,
|
||
spriteHalfWidthPx: halfExtentPx,
|
||
spriteHalfHeightPx: halfExtentPx,
|
||
});
|
||
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)) {
|
||
// 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);
|
||
writes += 1;
|
||
}
|
||
}
|
||
return { writes, transitioning, activeCount, ran: true };
|
||
}
|
||
return {
|
||
_showOrbitPath,
|
||
_updateOrbitPathRotations,
|
||
_hideOrbitPath,
|
||
_propagateAll,
|
||
_preRenderTick,
|
||
_updatePointFocus,
|
||
applySatellitePointFocusDeemphasis,
|
||
};
|
||
}
|