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

+6
View File
@@ -1072,6 +1072,12 @@ a fresh winning record. Dense removal clears only its own provenance, and a
fresh core rebuild or lifecycle reset replaces the corresponding ownership. fresh core rebuild or lifecycle reset replaces the corresponding ownership.
Source adapters retain the existing CelesTrak and Launch Library Source adapters retain the existing CelesTrak and Launch Library
endpoints; standalone entries provide scene services and the satellite dependency. endpoints; standalone entries provide scene services and the satellite dependency.
The satellites layer draws through the renderer's draw port and no longer
reaches Cesium: the dots are one point set moved in a single write a frame, the
tracked satellite's dot a set of its own drawn where the follow camera framed
it, and the orbit rings a line set dimmed behind the globe and turned with the
Earth each second. A caller handing it a Cesium viewer, with no
renderer bound, loads the `./render/cesium/unbound` export once first.
The mission factory separates paths, replay, camera, panel, overlays and placement. The mission factory separates paths, replay, camera, panel, overlays and placement.
Launch Library pad coordinates retain unknown values: missing fields use the Launch Library pad coordinates retain unknown values: missing fields use the
reported location coordinates when available, and launches without a known pad reported location coordinates when available, and launches without a known pad
+4 -4
View File
@@ -114,10 +114,10 @@ assertResumeGate('CCTV', () => {
assertResumeGate('satellite', () => { assertResumeGate('satellite', () => {
const point = { const point = {
position: { x: 1, y: 2, z: 3 }, pos: { x: 1, y: 2, z: 3 },
show: true, show: true,
pixelSize: 6, pixelSize: 6,
color: color(), color: [1, 1, 1, 1],
}; };
return { return {
pass: ({ nowMs, target: focusTarget, previousActiveCount }) => pass: ({ nowMs, target: focusTarget, previousActiveCount }) =>
@@ -129,9 +129,9 @@ assertResumeGate('satellite', () => {
nowMs, nowMs,
screenPositionFor: () => ({ x: 50, y: 50 }), screenPositionFor: () => ({ x: 50, y: 50 }),
cameraDistanceFor: () => 1200, cameraDistanceFor: () => 1200,
baseColorFor: () => color(), baseColorFor: () => [1, 1, 1, 1],
params, params,
}), }),
readAlpha: () => point.color.alpha, readAlpha: () => point.color[3],
}; };
}); });
+3 -3
View File
@@ -96,7 +96,7 @@ test('satellite getAnalystRecords: disabled or empty catalog returns []', () =>
test('satellite getAnalystRecords: core rows beat dense extras under the cap', () => { test('satellite getAnalystRecords: core rows beat dense extras under the cap', () => {
const satrec = twoline2satrec(ISS_L1, ISS_L2); const satrec = twoline2satrec(ISS_L1, ISS_L2);
const point = { const point = {
position: Cesium.Cartesian3.fromDegrees(-97.7, 30.2, 420_000), pos: Cesium.Cartesian3.fromDegrees(-97.7, 30.2, 420_000),
}; };
_setTrackedSatelliteRefreshStateForTest({ _setTrackedSatelliteRefreshStateForTest({
noradId: ISS_NORAD, noradId: ISS_NORAD,
@@ -112,7 +112,7 @@ test('satellite getAnalystRecords: core rows beat dense extras under the cap', (
name: 'STARLINK-TEST', name: 'STARLINK-TEST',
satrec, satrec,
group: 'dense', group: 'dense',
point: { position: Cesium.Cartesian3.fromDegrees(-90, 20, 550_000) }, point: { pos: Cesium.Cartesian3.fromDegrees(-90, 20, 550_000) },
}, },
{ {
noradId: 24876, noradId: 24876,
@@ -120,7 +120,7 @@ test('satellite getAnalystRecords: core rows beat dense extras under the cap', (
satrec, satrec,
group: 'gps-ops', group: 'gps-ops',
point: { point: {
position: Cesium.Cartesian3.fromDegrees(-100, 10, 20_200_000), pos: Cesium.Cartesian3.fromDegrees(-100, 10, 20_200_000),
}, },
}, },
], ],
+29 -40
View File
@@ -18,6 +18,7 @@ import {
} from './satellites.js'; } from './satellites.js';
import { followedOf } from './followed.js'; import { followedOf } from './followed.js';
import { bindRenderer } from '../render/rendererOf.js'; import { bindRenderer } from '../render/rendererOf.js';
import { fakeDrawPort } from '../testSupport/fakeDrawPort.mjs';
import satellitesLayer from './satellites.js'; import satellitesLayer from './satellites.js';
import { createTrackedOverlayEntry } from './trackedReadout.js'; import { createTrackedOverlayEntry } from './trackedReadout.js';
import { readEntityRecord, withEntityRecord } from './entityRecords.js'; import { readEntityRecord, withEntityRecord } from './entityRecords.js';
@@ -110,23 +111,17 @@ test('satellite first update aborts every parallel catalog request', async () =>
test('selected satellite params survive delayed arrival and yield to newer explicit intent', (t) => { test('selected satellite params survive delayed arrival and yield to newer explicit intent', (t) => {
const point = { const point = {
position: Cesium.Cartesian3.fromDegrees(-97.7, 30.2, 420_000), pos: Cesium.Cartesian3.fromDegrees(-97.7, 30.2, 420_000),
show: true, show: true,
pixelSize: 12, pixelSize: 12,
color: Cesium.Color.RED, color: [1, 0, 0, 1],
outlineColor: Cesium.Color.WHITE, outlineColor: [1, 1, 1, 1],
outlineWidth: 2, outlineWidth: 2,
disableDepthTestDistance: 0, disableDepthTest: 0,
}; };
const viewer = { const viewer = {};
entities: new Cesium.EntityCollection(), const draw = fakeDrawPort();
trackedEntity: undefined, t.after(bindRenderer(viewer, { camera: followingPort(), draw }));
scene: {
frameState: { frameNumber: 1 },
primitives: { remove() {} },
},
};
t.after(bindRenderer(viewer, { camera: followingPort() }));
_setSatelliteLabelLifecycleStateForTest({ _setSatelliteLabelLifecycleStateForTest({
viewer, viewer,
satrec: twoline2satrec(L1, L2), satrec: twoline2satrec(L1, L2),
@@ -215,13 +210,13 @@ test('a tracked docked cluster consolidates its companions onto one card', () =>
// consolidate them as secondary info on that card, and suppress only those // consolidate them as secondary info on that card, and suppress only those
// members — never unrelated satellites that merely happen to be nearby. // members — never unrelated satellites that merely happen to be nearby.
const entity = withEntityRecord({}, { labelModel: { title: 'OLD', details: ['? km'] } }); const entity = withEntityRecord({}, { labelModel: { title: 'OLD', details: ['? km'] } });
const point = { position: new Cesium.Cartesian3() }; const point = { pos: new Cesium.Cartesian3() };
const viewer = { camera: null, scene: { frameState: { frameNumber: 1 } } }; const viewer = { camera: null, scene: { frameState: { frameNumber: 1 } } };
let nowMs = Date.UTC(2008, 8, 20, 12, 30); let nowMs = Date.UTC(2008, 8, 20, 12, 30);
// The tracked satellite moves ~7.6 km/s, so neighbours are defined RELATIVE to // The tracked satellite moves ~7.6 km/s, so neighbours are defined RELATIVE to
// wherever it is at scan time rather than pinned to a stale sample. // wherever it is at scan time rather than pinned to a stale sample.
const near = (metres) => ({ const near = (metres) => ({
get position() { get pos() {
const tracked = _trackedFrameCartesianForTest(); const tracked = _trackedFrameCartesianForTest();
return new Cesium.Cartesian3(tracked.x + metres, tracked.y, tracked.z); return new Cesium.Cartesian3(tracked.x + metres, tracked.y, tracked.z);
}, },
@@ -246,7 +241,6 @@ test('a tracked docked cluster consolidates its companions onto one card', () =>
// The cluster scan is throttled, so advance past its interval before the frame // The cluster scan is throttled, so advance past its interval before the frame
// that must observe the cluster. // that must observe the cluster.
nowMs += 2000; nowMs += 2000;
viewer.scene.frameState.frameNumber = 2;
_runSatellitePreRenderForTest(); _runSatellitePreRenderForTest();
const details = readEntityRecord(entity)?.labelModel.details; const details = readEntityRecord(entity)?.labelModel.details;
@@ -273,7 +267,7 @@ test('a tracked docked cluster consolidates its companions onto one card', () =>
}); });
test('satellite pre-render refreshes the tracked altitude on each propagated frame', () => { test('satellite pre-render refreshes the tracked altitude on each propagated frame', () => {
const entity = withEntityRecord({}, { labelModel: { title: 'OLD', details: ['? km'] } }); const entity = withEntityRecord({}, { labelModel: { title: 'OLD', details: ['? km'] } });
const point = { position: new Cesium.Cartesian3() }; const point = { pos: new Cesium.Cartesian3() };
const viewer = { const viewer = {
camera: null, camera: null,
scene: { frameState: { frameNumber: 1 } }, scene: { frameState: { frameNumber: 1 } },
@@ -297,7 +291,6 @@ test('satellite pre-render refreshes the tracked altitude on each propagated fra
assert.equal(readEntityRecord(entity)?.labelModel.details[1], '353\u00a0km · NORAD 25544'); assert.equal(readEntityRecord(entity)?.labelModel.details[1], '353\u00a0km · NORAD 25544');
epochIndex = 1; epochIndex = 1;
viewer.scene.frameState.frameNumber = 2;
_runSatellitePreRenderForTest(); _runSatellitePreRenderForTest();
assert.equal(readEntityRecord(entity)?.labelModel.details[1], '366\u00a0km · NORAD 25544'); assert.equal(readEntityRecord(entity)?.labelModel.details[1], '366\u00a0km · NORAD 25544');
assert.equal( assert.equal(
@@ -315,23 +308,17 @@ test('ISS ambient and tracked lifecycle uses cached host entries with no native
clearSource: (...args) => calls.push(['clear', ...args]), clearSource: (...args) => calls.push(['clear', ...args]),
}; };
const point = { const point = {
position: Cesium.Cartesian3.fromDegrees(-97.7, 30.2, 420_000), pos: Cesium.Cartesian3.fromDegrees(-97.7, 30.2, 420_000),
show: true, show: true,
pixelSize: 12, pixelSize: 12,
color: Cesium.Color.RED, color: [1, 0, 0, 1],
outlineColor: Cesium.Color.WHITE, outlineColor: [1, 1, 1, 1],
outlineWidth: 2, outlineWidth: 2,
disableDepthTestDistance: 0, disableDepthTest: 0,
}; };
const viewer = { const viewer = {};
entities: new Cesium.EntityCollection(), const draw = fakeDrawPort();
trackedEntity: undefined, t.after(bindRenderer(viewer, { camera: followingPort(), draw }));
scene: {
frameState: { frameNumber: 1 },
primitives: { remove() {} },
},
};
t.after(bindRenderer(viewer, { camera: followingPort() }));
let cleaned = false; let cleaned = false;
_setSatelliteLabelLifecycleStateForTest({ _setSatelliteLabelLifecycleStateForTest({
viewer, viewer,
@@ -348,7 +335,7 @@ test('ISS ambient and tracked lifecycle uses cached host entries with no native
assert.equal(ambient.title, 'ISS'); assert.equal(ambient.title, 'ISS');
assert.equal( assert.equal(
ambient.position(), ambient.position(),
point.position, point.pos,
'ISS getter reads the existing point cache', 'ISS getter reads the existing point cache',
); );
assert.equal( assert.equal(
@@ -359,16 +346,17 @@ test('ISS ambient and tracked lifecycle uses cached host entries with no native
const trackedEntity = _trackIssForTest(); const trackedEntity = _trackIssForTest();
assert.ok(trackedEntity); assert.ok(trackedEntity);
const tracked = [...draw.sets.values()].find(
(set) => !set.disposed && /^satellites:\d+:tracked$/.test(set.spec.id),
);
assert.ok(tracked, 'the tracked dot has a set of its own');
_runSatellitePreRenderForTest();
assert.equal( assert.equal(
viewer.entities.values.length, tracked.items.get('25544')?.pixelSize,
1, 14,
'runtime guard requires a real tracked entity', 'the tracked dot draws, as the follow camera frames it',
); );
assert.equal(trackedEntity.label, undefined); assert.equal(trackedEntity.label, undefined);
assert.ok(
trackedEntity.point,
'tracked dot remains on the entity for camera framing',
);
const trackedEntry = createTrackedOverlayEntry(trackedEntity); const trackedEntry = createTrackedOverlayEntry(trackedEntity);
assert.ok(trackedEntry); assert.ok(trackedEntry);
assert.equal(trackedEntry.id, 'satellites:25544'); assert.equal(trackedEntry.id, 'satellites:25544');
@@ -393,7 +381,8 @@ test('ISS ambient and tracked lifecycle uses cached host entries with no native
_clearSatelliteLabelLifecycleForTest(); _clearSatelliteLabelLifecycleForTest();
cleaned = true; cleaned = true;
assert.equal(viewer.entities.values.length, 0); assert.equal(tracked.items.size, 0);
assert.ok(tracked.disposed);
assert.equal( assert.equal(
calls.filter( calls.filter(
([type, sourceId]) => ([type, sourceId]) =>
+2 -3
View File
@@ -18,11 +18,11 @@ const L2 =
function run(locale) { function run(locale) {
setLocale(locale); setLocale(locale);
const entity = withEntityRecord({}, { labelModel: { title: 'OLD', details: ['? km'] } }); const entity = withEntityRecord({}, { labelModel: { title: 'OLD', details: ['? km'] } });
const point = { position: new Cesium.Cartesian3() }; const point = { pos: new Cesium.Cartesian3() };
const viewer = { camera: null, scene: { frameState: { frameNumber: 1 } } }; const viewer = { camera: null, scene: { frameState: { frameNumber: 1 } } };
let nowMs = Date.UTC(2008, 8, 20, 12, 30); let nowMs = Date.UTC(2008, 8, 20, 12, 30);
const near = (metres) => ({ const near = (metres) => ({
get position() { get pos() {
const tracked = _trackedFrameCartesianForTest(); const tracked = _trackedFrameCartesianForTest();
return new Cesium.Cartesian3(tracked.x + metres, tracked.y, tracked.z); return new Cesium.Cartesian3(tracked.x + metres, tracked.y, tracked.z);
}, },
@@ -42,7 +42,6 @@ function run(locale) {
}); });
_runSatellitePreRenderForTest(); _runSatellitePreRenderForTest();
nowMs += 2000; nowMs += 2000;
viewer.scene.frameState.frameNumber = 2;
_runSatellitePreRenderForTest(); _runSatellitePreRenderForTest();
const details = readEntityRecord(entity)?.labelModel.details; const details = readEntityRecord(entity)?.labelModel.details;
setLocale('en'); setLocale('en');
+10 -11
View File
@@ -21,7 +21,7 @@ export function createInteraction({
// Cross-layer untrack (H2, mirror of flights): if ANOTHER layer (flights, // Cross-layer untrack (H2, mirror of flights): if ANOTHER layer (flights,
// military, …) grabs the follow-camera, drop our tracking so the orbit ring / // military, …) grabs the follow-camera, drop our tracking so the orbit ring /
// tracked entity don't orphan — without touching viewer.trackedEntity (the // tracked dot don't orphan — without touching viewer.trackedEntity (the
// new owner controls it). Guarded so our OWN switch (viewer.trackedEntity // new owner controls it). Guarded so our OWN switch (viewer.trackedEntity
// briefly undefined mid-_trackSatellite) doesn't self-clear. // briefly undefined mid-_trackSatellite) doesn't self-clear.
if (!layerState._trackedEntityChangedRemove) { if (!layerState._trackedEntityChangedRemove) {
@@ -46,18 +46,17 @@ export function createInteraction({
layerState._clickSubscription = inputFor(viewer).onClick((event) => { layerState._clickSubscription = inputFor(viewer).onClick((event) => {
if (!layerState._enabled) return; if (!layerState._enabled) return;
const picked = event.pick; const picked = event.pick;
const hit = event.drawHit;
if (picked) { // Clicking the tracked satellite's own dot — ignore
// Clicking tracked entity itself — ignore if (parts.rendering._hitIsTracked(hit)) return;
if (parts.rendering._pickIsTrackedEntity(picked)) return;
// Check if it's a satellite point (id is NORAD catalog number) // A satellite dot (its item id is the NORAD catalog number)
const noradId = parts.rendering._pickedPointId(picked); const noradId = parts.rendering._hitPointId(hit);
if (noradId !== null && layerState._catalog.has(noradId)) { if (noradId !== null && layerState._catalog.has(noradId)) {
parts.tracking._cancelPendingTrackingRestore(); parts.tracking._cancelPendingTrackingRestore();
parts.tracking._trackSatellite(noradId, { origin: 'user' }); parts.tracking._trackSatellite(noradId, { origin: 'user' });
return; return;
}
} }
// A pick that belongs to a sibling layer (plane, vessel, station, CCTV // A pick that belongs to a sibling layer (plane, vessel, station, CCTV
+3 -3
View File
@@ -13,7 +13,7 @@ export function createLifecycle({
/** Run the shared per-frame tick before each frame draws. */ /** Run the shared per-frame tick before each frame draws. */
function onEachFrame(frame) { function onEachFrame(frame) {
return frame.on('preRender', () => parts.rendering._preRenderTick()); return frame.on('preRender', (t) => parts.rendering._preRenderTick(t));
} }
const methods = { const methods = {
@@ -54,7 +54,7 @@ export function createLifecycle({
layerState._denseError = null; layerState._denseError = null;
layerState._catalogRevision++; layerState._catalogRevision++;
// The collection the satellite dots draw in // The sets the satellite dots, the tracked dot and the rings draw in
parts.rendering._attach(viewer); parts.rendering._attach(viewer);
parts.interaction._installClickHandler(viewer); parts.interaction._installClickHandler(viewer);
@@ -141,7 +141,7 @@ export function createLifecycle({
} }
layerState._overlayHost.clearSource(ISS_OVERLAY_SOURCE_ID); layerState._overlayHost.clearSource(ISS_OVERLAY_SOURCE_ID);
layerState._overlayHost.setVisible(ISS_OVERLAY_SOURCE_ID, false); layerState._overlayHost.setVisible(ISS_OVERLAY_SOURCE_ID, false);
// The dots' collection and the orbit rings go (and are destroyed) // The dots', tracked dot's and rings' sets are disposed of
parts.rendering._detach(viewer); parts.rendering._detach(viewer);
layerState._points.clear(); layerState._points.clear();
layerState._detectionObjects.clear(); layerState._detectionObjects.clear();
+246 -62
View File
@@ -13,6 +13,9 @@ import {
TRACKED_ORBIT_COLOR, TRACKED_ORBIT_COLOR,
} from './policy.js'; } from './policy.js';
import { createRendering } from './rendering.js'; import { createRendering } from './rendering.js';
import { bindFakeDraw } from '../../testSupport/fakeDrawPort.mjs';
import { gstime } from 'satellite.js';
import * as focusDeemphasis from '../../data/focusDeemphasis.js';
const rgba = (color) => [color.red, color.green, color.blue, color.alpha]; const rgba = (color) => [color.red, color.green, color.blue, color.alpha];
@@ -44,9 +47,9 @@ test('point styles keep the colours the dots were drawn in', () => {
test('positions read back from the drawn dots match the Cesium geodetic conversion', () => { test('positions read back from the drawn dots match the Cesium geodetic conversion', () => {
const position = Cesium.Cartesian3.fromDegrees(-97.7, 30.2, 420_000); const position = Cesium.Cartesian3.fromDegrees(-97.7, 30.2, 420_000);
const point = { position, show: true }; const point = { pos: position, show: true };
_setSatelliteLabelLifecycleStateForTest({ _setSatelliteLabelLifecycleStateForTest({
viewer: { scene: { frameState: { frameNumber: 1 } } }, viewer: {},
satrec: null, satrec: null,
point, point,
overlayHost: { setEntries() {}, setVisible() {}, clearSource() {} }, overlayHost: { setEntries() {}, setVisible() {}, clearSource() {} },
@@ -68,7 +71,7 @@ test('positions read back from the drawn dots match the Cesium geodetic conversi
} }
}); });
test('only the rendering part drives Cesium', () => { test('no part of the layer drives Cesium', () => {
const offList = [ const offList = [
'catalog', 'catalog',
'controls', 'controls',
@@ -114,6 +117,13 @@ test('only the rendering part drives Cesium', () => {
for (const pattern of forbidden) for (const pattern of forbidden)
assert.doesNotMatch(source, pattern, `${name}.js: ${pattern}`); assert.doesNotMatch(source, pattern, `${name}.js: ${pattern}`);
} }
// The rendering part owns the handles, and draws through the draw port.
const rendering = readFileSync(
new URL('./rendering.js', import.meta.url),
'utf8',
);
for (const pattern of forbidden.slice(0, 7))
assert.doesNotMatch(rendering, pattern, `rendering.js: ${pattern}`);
// The patterns themselves still catch what they are for. // The patterns themselves still catch what they are for.
const caught = [ const caught = [
'layerState._trackedEntity.position.setValue(p)', 'layerState._trackedEntity.position.setValue(p)',
@@ -161,64 +171,238 @@ test('only the rendering part drives Cesium', () => {
); );
}); });
test('the rendering part draws the dots and rings in Cesium colours', () => { test('the rendering part draws the dots, the tracked dot and the rings through the draw port', () => {
const added = []; const viewer = {};
const state = { const { draw, unbind } = bindFakeDraw(viewer);
_points: new Map(), try {
_orbitPaths: new Map(), const state = {
_catalog: new Map([[25544, { satrec: {} }]]), _points: new Map(),
_pointCollection: { add: (options) => ({ ...options }) }, _orbitPaths: new Map(),
_viewer: { scene: { primitives: { add: (p) => added.push(p) } } }, _catalog: new Map([[25544, { satrec: {} }]]),
}; _viewer: viewer,
const path = [ _trackedNorad: null,
{ x: 7e6, y: 0, z: 0 }, _enabled: false,
{ x: 0, y: 7e6, z: 0 }, };
{ x: -7e6, y: 0, z: 0 }, const path = [
]; { x: 7e6, y: 0, z: 0 },
const rendering = createRendering({ { x: 0, y: 7e6, z: 0 },
state, { x: -7e6, y: 0, z: 0 },
services: { focus: {} }, ];
parts: { orbits: { computeOrbitPath: () => path } }, const rendering = createRendering({
}); state,
rendering._addPoint(25544, { x: 1, y: 2, z: 3 }, POINT_STYLES.iss); services: {
const point = state._points.get(25544); focus: {
assert.ok(point.position instanceof Cesium.Cartesian3); focusNowMs: (ms) => ms,
assert.deepEqual( getFocusTarget: () => null,
[point.position.x, point.position.y, point.position.z], focusPassIsNeeded: () => false,
[1, 2, 3], },
); },
assert.ok(point.color instanceof Cesium.Color); parts: {
assert.deepEqual( orbits: { computeOrbitPath: () => path },
rgba(point.color), tracking: { _getTrackedFramePosition: () => sampleFrame() },
rgba(Cesium.Color.fromCssColorString('#ff4444')), },
); });
assert.deepEqual( // The frame's own sample, taken after the tick's first part.
rgba(point.outlineColor), let sampleFrame = () => null;
rgba(Cesium.Color.WHITE.withAlpha(0.3)), rendering._attach(viewer);
); const points = draw.find('satellites:').spec.id;
assert.equal(point.pixelSize, 12); assert.match(points, /^satellites:\d+:points$/);
assert.equal(point.outlineWidth, 2); rendering._addPoint(25544, { x: 1, y: 2, z: 3 }, POINT_STYLES.iss);
assert.equal(point.id, 25544); const point = state._points.get(25544);
assert.ok( assert.deepEqual(point.pos, { x: 1, y: 2, z: 3 });
Cesium.NearFarScalar.equals( assert.equal(draw.set(points).items.size, 0, 'sent with the frame');
point.scaleByDistance, rendering._preRenderTick({ frame: 1 });
new Cesium.NearFarScalar(1e6, 1.5, 2e7, 0.6), const drawn = draw.set(points).items.get('25544');
), assert.equal(drawn, point);
); assert.deepEqual(
[...drawn.color],
rgba(Cesium.Color.fromCssColorString('#ff4444')),
);
assert.deepEqual(
[...drawn.outlineColor],
rgba(Cesium.Color.WHITE.withAlpha(0.3)),
);
assert.equal(drawn.pixelSize, 12);
assert.equal(drawn.outlineWidth, 2);
assert.deepEqual(drawn.meta, { noradId: 25544 });
assert.deepEqual(
{ ...drawn.scaleByDistance },
{ near: 1e6, nearValue: 1.5, far: 2e7, farValue: 0.6 },
);
// Moves go out in one upsert a frame.
const writes = draw.set(points).writes;
rendering._movePoint(25544, { x: 4, y: 5, z: 6 });
rendering._movePoint(25544, { x: 7, y: 8, z: 9 });
rendering._preRenderTick({ frame: 2 });
assert.equal(draw.set(points).writes, writes + 1);
assert.deepEqual(draw.set(points).items.get('25544').pos, {
x: 7,
y: 8,
z: 9,
});
// A pick on a dot names its satellite; one on another set does not.
assert.equal(rendering._hitPointId({ set: points, id: '25544' }), 25544);
assert.equal(rendering._hitPointId({ set: 'other:1', id: '25544' }), null);
rendering._showOrbitPath(25544, TRACKED_ORBIT_COLOR); rendering._showOrbitPath(25544, TRACKED_ORBIT_COLOR);
assert.equal(added.length, 1); const rings = draw.sets.get(points.replace(':points', ':rings'));
const instance = added[0].geometryInstances; assert.equal(rings.spec.pickable, false, 'ring clicks fall through');
assert.deepEqual( const ring = rings.items.get('25544');
[...instance.attributes.color.value], assert.deepEqual(ring.style, { kind: 'solid', color: [1, 1, 0, 0.6] });
[255, 255, 0, Cesium.Color.floatToByte(0.6)], assert.deepEqual(ring.depthFailColor, [1, 1, 0, 0.35]);
); assert.equal(ring.widthPx, 2.5, 'the ISS ring is wider');
assert.ok( assert.equal(ring.mode, 'geodesic');
instance.geometry._positions.every((p) => p instanceof Cesium.Cartesian3), assert.deepEqual([...ring.positions.slice(0, 3)], [7e6, 0, 0]);
); // Turned with the Earth: by minus the GMST elapsed since its bake.
assert.ok( const path0 = state._orbitPaths.get(25544);
rendering const later = new Date(Date.now() + 600_000);
._rendererPositions(path) rendering._updateOrbitPathRotations(later);
.every((p, i) => p instanceof Cesium.Cartesian3 && p.x === path[i].x), const angle = -(gstime(later) - path0.gmstAtBake);
); const turned = rings.items.get('25544').positions;
assert.ok(Math.abs(turned[0] - 7e6 * Math.cos(angle)) < 1e-3);
assert.ok(Math.abs(turned[1] - 7e6 * Math.sin(angle)) < 1e-3);
rendering._hideOrbitPath(25544);
assert.equal(rings.items.size, 0);
// The tracked dot draws at the tracker's position, from the next frame.
state._trackedNorad = 25544;
state._enabled = true;
state._params = { showPoints: false, showOrbits: false };
let at = { x: 10, y: 20, z: 30 };
const carrier = rendering._addTrackedEntity({ position: () => at });
assert.deepEqual(carrier, { noradId: 25544 });
const tracked = draw.set(points.replace(':points', ':tracked'));
assert.equal(tracked.items.size, 0);
rendering._preRenderTick({ frame: 3 });
assert.deepEqual(tracked.items.get('25544').pos, at);
assert.equal(tracked.items.get('25544').pixelSize, 14);
assert.equal(tracked.items.get('25544').disableDepthTest, Infinity);
at = { x: 11, y: 21, z: 31 };
rendering._preRenderTick({ frame: 4 });
assert.deepEqual(tracked.items.get('25544').pos, at);
// When the follow camera has already sampled this frame's key, the dot
// draws at that sample, before the frame's own sample moves it on.
const framed = { x: 12, y: 22, z: 32 };
at = framed;
state._trackedFrameGeo = {};
state._trackedFrameNumber = 4;
sampleFrame = () => {
at = { x: 13, y: 23, z: 33 };
return at;
};
rendering._preRenderTick({ frame: 5 });
assert.deepEqual(tracked.items.get('25544').pos, framed);
// With no sample under the frame's key, it draws after the frame's own.
state._trackedFrameNumber = 3;
at = framed;
rendering._preRenderTick({ frame: 6 });
assert.deepEqual(tracked.items.get('25544').pos, { x: 13, y: 23, z: 33 });
assert.equal(
rendering._hitIsTracked({ set: tracked.spec.id, id: '25544' }),
true,
);
rendering._removeTrackedEntity(carrier);
assert.equal(tracked.items.size, 0);
rendering._detach(viewer);
assert.ok([...draw.sets.values()].every((set) => set.disposed));
} finally {
unbind();
}
});
test('the orbit frame matrix turns ECEF about Z by minus the GMST elapsed', () => {
const rendering = createRendering({
state: {},
services: { focus: {} },
parts: {},
});
const bake = new Date('2026-07-20T10:00:00Z');
const now = new Date('2026-07-20T10:10:00Z');
const m = rendering.orbitFrameModelMatrix(gstime(bake), now);
const angle = -(gstime(now) - gstime(bake));
assert.equal(m.length, 16);
assert.ok(Math.abs(m[0] - Math.cos(angle)) < 1e-12);
assert.ok(Math.abs(m[1] - Math.sin(angle)) < 1e-12);
assert.ok(Math.abs(m[4] + Math.sin(angle)) < 1e-12);
assert.equal(m[10], 1);
assert.equal(m[15], 1);
// Written in place into a matrix it is handed.
const into = new Cesium.Matrix4();
assert.equal(rendering.orbitFrameModelMatrix(gstime(bake), now, into), into);
assert.ok(Math.abs(into[0] - Math.cos(angle)) < 1e-12);
});
test('the focus pass projects every dot in one call and dims the dot under the focus', () => {
const viewer = {};
const calls = [];
const { unbind } = bindFakeDraw(viewer, {
camera: { pose: () => ({ position: { x: 0, y: 0, z: 0 } }) },
query: {
// Screen x, y are the point's own x, y.
projectMany(source, out) {
calls.push(source.length / 3);
for (let i = 0, j = 0; i + 2 < source.length; i += 3, j += 2) {
out[j] = source[i];
out[j + 1] = source[i + 1];
}
},
project: () => {
throw new Error('the pass projects in one batch');
},
},
});
try {
const target = {
screenRect: { left: 90, right: 110, top: 90, bottom: 110 },
cameraDistance: 1,
};
const state = {
_points: new Map(),
_orbitPaths: new Map(),
_catalog: new Map(),
_viewer: viewer,
_trackedNorad: null,
_enabled: true,
_params: { showPoints: true, showOrbits: false },
_activeFocusCount: 0,
_lastFocusUpdate: -Infinity,
};
const rendering = createRendering({
state,
services: {
focus: {
...focusDeemphasis,
focusNowMs: (ms) => ms,
getFocusTarget: () => target,
focusPassIsNeeded: () => true,
},
},
parts: {
controls: { _pointStyleFor: () => ({ color: [1, 1, 1, 1] }) },
tracking: { _getTrackedFramePosition: () => null },
},
});
rendering._attach(viewer);
const style = { ...POINT_STYLES.iss, color: [1, 1, 1, 1] };
rendering._addPoint(1, { x: 100, y: 100, z: 0 }, style);
rendering._addPoint(2, { x: 100, y: 100, z: 0 }, style);
rendering._addPoint(3, { x: 500, y: 500, z: 0 }, style);
rendering._addPoint(4, { x: 100, y: 100, z: 0 }, style);
state._points.get(2).show = false;
state._trackedNorad = 4;
for (let now = 0; now <= 5000; now += 100) rendering._updatePointFocus(now);
assert.ok(calls.length > 0);
assert.ok(
calls.every((n) => n === 4),
'one call over every dot',
);
const alpha = (id) => state._points.get(id).color[3];
assert.ok(alpha(1) < 1, 'the dot under the focus dims');
assert.equal(alpha(2), 1, 'a hidden dot is not dimmed');
assert.equal(alpha(3), 1, 'a dot away from the focus is not dimmed');
assert.equal(alpha(4), 1, 'the tracked dot is not dimmed');
rendering._detach(viewer);
} finally {
unbind();
}
}); });
+416 -251
View File
@@ -1,39 +1,55 @@
import * as Cesium from 'cesium'; import { drawOf, findCamera, findQuery } from '../../render/rendererOf.js';
// The camera and frame ports over a viewer with no renderer bound, for the import { fromDegreesInto } from '../../geo/ellipsoid.js';
// tracking and lifecycle parts that follow and tick through them. import { distance } from '../../geo/vector.js';
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 { gstime } from 'satellite.js'; import { gstime } from 'satellite.js';
import { ISS_NORAD, POSITION_UPDATE_MS, RING_ROTATION_MS } from './policy.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 * The satellites layer's drawing, through the renderer contract's draw port:
* primitives, the baked orbit-ring primitives, the tracked entity the follow * a points set of the satellite dots, a points set of the tracked
* camera and the tracked card read, and the per-frame tick that moves them. * satellite's dot, and a lines set of the orbit rings, with the per-frame
* The other parts hand it render-contract values (ECEF `{x, y, z}`, colours * tick that moves them. The other parts hand it render-contract values
* as `[r, g, b, a]`) and never touch these objects themselves. * (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. */ /** 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(); * The tracked satellite's dot: 14 px yellow with a white outline, drawn
function cesiumStyleOf(style) { * over everything.
let converted = cesiumStyles.get(style); */
if (!converted) { const TRACKED_DOT = Object.freeze({
converted = { pixelSize: 14,
pixelSize: style.pixelSize, color: Object.freeze([1, 1, 0, 1]),
color: cesiumColor(style.color), outlineColor: Object.freeze([1, 1, 1, 1]),
outlineColor: cesiumColor(style.outlineColor), outlineWidth: 2,
outlineWidth: style.outlineWidth, disableDepthTest: Number.POSITIVE_INFINITY,
}; });
cesiumStyles.set(style, converted);
} /** An orbit ring's colour when none is given (cyan). */
return converted; 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({ export function createRendering({
state: layerState, state: layerState,
@@ -51,96 +67,182 @@ export function createRendering({
publishFocusTargetAt, publishFocusTargetAt,
} = services.focus; } = 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 // The tracked satellite's per-frame ECEF sample (WS-D2), shared with the
// tracked entity, the follow camera and the tracked card. Tracking writes // tracked dot, the follow camera and the tracked card. Tracking writes its
// its x/y/z; it stays one Cesium value for the readers that take it. // x/y/z in place.
layerState._trackedFrameCartesian = new Cesium.Cartesian3(); 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 * 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 {number} gmstAtBake GMST used when the path positions were baked.
* @param {Date} nowDate Epoch whose rotating-Earth frame should be displayed. * @param {Date} nowDate Epoch whose rotating-Earth frame should be displayed.
* @param {Cesium.Matrix4} [result] Optional matrix to update in place. * @param {ArrayLike<number>} [result] A 16-element matrix to update in place.
* @returns {Cesium.Matrix4} Z-rotation from bake-time ECEF to current ECEF. * @returns {ArrayLike<number>} Z-rotation from bake-time ECEF to current ECEF.
*/ */
function orbitFrameModelMatrix( function orbitFrameModelMatrix(gmstAtBake, nowDate, result = new Array(16)) {
gmstAtBake, const angle = -(gstime(nowDate) - gmstAtBake);
nowDate, const c = Math.cos(angle);
result = new Cesium.Matrix4(), const s = Math.sin(angle);
) { result[0] = c;
const deltaGmst = gstime(nowDate) - gmstAtBake; result[1] = s;
const rotation = Cesium.Matrix3.fromRotationZ( result[2] = 0;
-deltaGmst, result[3] = 0;
scratchRingRotation, result[4] = -s;
); result[5] = c;
return Cesium.Matrix4.fromRotationTranslation( result[6] = 0;
rotation, result[7] = 0;
Cesium.Cartesian3.ZERO, result[8] = 0;
result, 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) { 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() { 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) { function _attach(viewer) {
layerState._pointCollection = new Cesium.PointPrimitiveCollection(); _attachTo(drawOf(viewer));
viewer.scene.primitives.add(layerState._pointCollection);
} }
/** 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) { function _detach(viewer) {
if (layerState._pointCollection) { if (!sets) return;
viewer.scene.primitives.remove(layerState._pointCollection); sets.points.dispose();
layerState._pointCollection = null; sets.tracked.dispose();
} sets.rings.dispose();
// Orbit ring primitives are removed (and destroyed) here sets = null;
for (const path of layerState._orbitPaths.values()) { layerState._sets = null;
viewer.scene.primitives.remove(path.primitive); 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() { function _hasPointCollection() {
return Boolean(layerState._pointCollection); return Boolean(sets);
} }
/** Whether the satellite dots are shown. */ /** Whether the satellite dots are shown. */
function _pointsShown() { function _pointsShown() {
return Boolean(layerState._pointCollection?.show); return Boolean(sets) && pointsShown;
} }
function _setPointsShown(show) { 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) { function _setOrbitPathsShown(show) {
for (const path of layerState._orbitPaths.values()) const changed = [];
path.primitive.show = show; 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) { function _setOrbitPathShown(noradId, show) {
const path = layerState._orbitPaths.get(noradId); 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. */ /** Remove every orbit ring. */
function _clearOrbitPaths(viewer) { function _clearOrbitPaths() {
for (const path of layerState._orbitPaths.values()) const ids = [...layerState._orbitPaths.values()].map(
viewer.scene.primitives.remove(path.primitive); (path) => path.item.id,
);
layerState._orbitPaths.clear(); 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. * @param {object} style A `POINT_STYLES` entry.
*/ */
function _addPoint(noradId, position, style) { function _addPoint(noradId, position, style) {
const look = cesiumStyleOf(style); layerState._points.set(noradId, {
const point = layerState._pointCollection.add({ id: String(noradId),
position: toCartesian(position), pos: { x: position.x, y: position.y, z: position.z },
pixelSize: look.pixelSize, pixelSize: style.pixelSize,
color: look.color, color: style.color,
outlineColor: look.outlineColor, outlineColor: style.outlineColor,
outlineWidth: look.outlineWidth, outlineWidth: style.outlineWidth,
scaleByDistance: POINT_SCALE_BY_DISTANCE, 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. */ /** Move a drawn dot to ECEF `position`; false when it has none. */
function _movePoint(noradId, position) { function _movePoint(noradId, position) {
const point = layerState._points.get(noradId); const point = layerState._points.get(noradId);
if (!point) return false; 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; return true;
} }
function _removePoint(noradId) { function _removePoint(noradId) {
const point = layerState._points.get(noradId); if (!layerState._points.delete(noradId)) return;
if (point && layerState._pointCollection) dirty.delete(noradId);
layerState._pointCollection.remove(point); if (!cleared) gone.add(noradId);
layerState._points.delete(noradId);
} }
/** Remove every dot. */ /** Remove every dot. */
function _clearPoints() { function _clearPoints() {
layerState._pointCollection.removeAll();
layerState._points.clear(); layerState._points.clear();
dirty.clear();
gone.clear();
cleared = true;
} }
/** Where a dot is drawn (ECEF), or null. */ /** Where a dot is drawn (ECEF), or null. */
function _pointPosition(noradId) { 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) { function _hidePoint(noradId) {
const point = layerState._points.get(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). */ /** Show a dot again in its group's style (WS-D3). */
function _restorePoint(noradId, style) { function _restorePoint(noradId, style) {
const point = layerState._points.get(noradId); const point = layerState._points.get(noradId);
if (!point) return; if (!point) return;
const look = cesiumStyleOf(style);
point.show = true; point.show = true;
point.pixelSize = look.pixelSize; point.pixelSize = style.pixelSize;
point.color = look.color; point.color = style.color;
point.outlineColor = look.outlineColor; point.outlineColor = style.outlineColor;
point.outlineWidth = look.outlineWidth; point.outlineWidth = style.outlineWidth;
point.disableDepthTestDistance = 0; point.disableDepthTest = 0;
_markDirty(noradId);
} }
/** /**
* Add the tracked satellite's entity: it owns a point graphic so the * Draw the tracked satellite's dot and make the carrier the follow target
* follow camera can resolve a bounding sphere (a label-only entity left * and the tracked card read (its entity record holds the card).
* the camera stranded), and the tracked card reads its entity record.
* @param {{position: () => object, viewFrom: {x: number, y: number, * @param {{position: () => object, viewFrom: {x: number, y: number,
* z: number}}} options `position` is evaluated every time it is read. * z: number}}} options `position` is read as the follow camera reads
* @returns {object} The entity. * it, once each frame before the tick moves the sample on.
* @returns {object} The carrier.
*/ */
function _addTrackedEntity({ position, viewFrom }) { function _addTrackedEntity({ position }) {
return layerState._viewer.entities.add({ const noradId = layerState._trackedNorad;
position: new Cesium.CallbackProperty(position, false), const carrier = { noradId };
viewFrom: toCartesian(viewFrom), trackedDot = {
point: { position,
pixelSize: 14, item: {
color: Cesium.Color.YELLOW, id: String(noradId),
outlineColor: Cesium.Color.WHITE, pos: { x: 0, y: 0, z: 0 },
outlineWidth: 2, ...TRACKED_DOT,
disableDepthTestDistance: Number.POSITIVE_INFINITY, meta: { noradId },
}, },
}); drawn: false,
};
// Drawn from the next frame's tick on, as the camera first frames it.
return carrier;
} }
function _removeTrackedEntity(entity) { function _removeTrackedEntity() {
layerState._viewer.entities.remove(entity); if (trackedDot?.drawn) sets?.tracked.clear();
trackedDot = null;
} }
/** Whether a scene pick is the tracked satellite's entity. */ /** Put the tracked dot where the tracker says it is now. */
function _pickIsTrackedEntity(picked) { function _drawTrackedDot() {
return picked?.id === layerState._trackedEntity; 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. */
* The NORAD id a scene pick's point primitive carries, or null. Any function _hitIsTracked(hit) {
* primitive with a numeric id answers; the caller checks the catalog. return Boolean(sets) && hit?.set === sets.tracked.id;
*/ }
function _pickedPointId(picked) {
const prim = picked?.primitive; /** The NORAD id of the satellite dot a click's draw hit is on, or null. */
if (!prim || prim.id == null) return null; function _hitPointId(hit) {
const noradId = Number(prim.id); if (!sets || hit?.set !== sets.points.id) return null;
return isNaN(noradId) ? null : noradId; const noradId = Number(hit.id);
return Number.isFinite(noradId) ? noradId : null;
} }
/** Publish the tracked satellite's focus rectangle from its cached position. */ /** Publish the tracked satellite's focus rectangle from its cached position. */
@@ -255,23 +378,27 @@ export function createRendering({
publishFocusTargetAt({ ...target, viewer: layerState._viewer }); 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. * 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
* RING FLICKER FIX: this is a one-instance Cesium.Primitive built * behind it (`depthFailColor`), and turned with the Earth each
* synchronously ONCE (asynchronous: false), then re-aligned to current GMST * `RING_ROTATION_MS` (`_updateOrbitPathRotations`).
* 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) { function _showOrbitPath(noradId, color) {
@@ -281,86 +408,64 @@ export function createRendering({
if (!sat || !layerState._viewer) return; if (!sat || !layerState._viewer) return;
const bakeDate = new Date(); const bakeDate = new Date();
const basePositions = _rendererPositions( const base = parts.orbits.computeOrbitPath(sat.satrec, bakeDate);
parts.orbits.computeOrbitPath(sat.satrec, bakeDate), if (base.length < 2) return;
);
if (basePositions.length < 2) return;
const pathColor = color ? cesiumColor(color) : Cesium.Color.CYAN; const pathColor = color || DEFAULT_RING_COLOR;
const path = {
const primitive = new Cesium.Primitive({ base,
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,
// Same Date object as computeOrbitPath's internal fixedGmst → identical // Same Date object as computeOrbitPath's internal fixedGmst → identical
// GMST value (gstime is pure), so delta starts at exactly 0 and the // GMST value (gstime is pure), so the ring starts unturned.
// initial identity modelMatrix is correct until the first ring tick.
gmstAtBake: gstime(bakeDate), 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 * 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 * 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). * 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 * Sign derivation: a point fixed in inertial space keeps its right ascension
* α, so its ECEF longitude λ = α − gmst DECREASES by ΔGMST as time advances * α, so its ECEF longitude λ = α − gmst DECREASES by ΔGMST as time advances
* (it drifts WEST). Cesium.Matrix3.fromRotationZ(θ) rotates +X toward +Y, * (it drifts WEST). A rotation about Z by θ INCREASES longitude by θ — so
* i.e. INCREASES longitude by θ — so we rotate the baked points by −ΔGMST. * the baked points are rotated by −ΔGMST. Mental check: ISS baked over
* Mental check: ISS baked over Austin at t0; 10 min later Austin has rotated * Austin at t0; 10 min later Austin has rotated east under the (inertial)
* east under the (inertial) ring, so the ring must sit further WEST in ECEF. * ring, so the ring must sit further WEST in ECEF.
* *
* Wraparound: gstime returns radians in [0, 2π), so the raw difference can be * 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 * off from the continuous ΔGMST — but only by exact multiples of 2π, which a
* rotation cannot distinguish. Tiny negative deltas right after bake are * rotation cannot distinguish. Tiny negative deltas right after bake are
* likewise harmless. No unwrapping needed. * likewise harmless. No unwrapping needed.
* *
* No SGP4 here — the rotation is applied as the ring primitive's modelMatrix * No SGP4 here: WGS84 is rotationally symmetric about Z, so rotating the
* (exact compensation; WGS84 is rotationally symmetric about Z, so rotating * baked curve rigidly equals rebaking from rotated points. A ring with a
* the baked curve rigidly equals rebaking from rotated points). modelMatrix * `depthFailColor` is built at once where it now runs, so it never blinks.
* 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. * @param {Date} nowDate Epoch used for current GMST.
*/ */
function _updateOrbitPathRotations(nowDate) { function _updateOrbitPathRotations(nowDate) {
if (layerState._orbitPaths.size === 0) return; if (layerState._orbitPaths.size === 0) return;
const gmst = gstime(nowDate);
const changed = [];
for (const path of layerState._orbitPaths.values()) { for (const path of layerState._orbitPaths.values()) {
if (!path.primitive) continue; path.item.positions = _ringPositions(path, gmst);
orbitFrameModelMatrix( changed.push(path.item);
path.gmstAtBake,
nowDate,
path.primitive.modelMatrix,
);
} }
sets?.rings.upsert(changed);
} }
/** /**
@@ -369,15 +474,13 @@ export function createRendering({
function _hideOrbitPath(noradId) { function _hideOrbitPath(noradId) {
const path = layerState._orbitPaths.get(noradId); const path = layerState._orbitPaths.get(noradId);
if (path) { if (!path) return;
if (layerState._viewer) layerState._orbitPaths.delete(noradId);
layerState._viewer.scene.primitives.remove(path.primitive); // remove() destroys sets?.rings.remove([path.item.id]);
layerState._orbitPaths.delete(noradId);
}
} }
/** /**
* 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 * (~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. * 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); const pos = parts.orbits.propagatePosition(sat.satrec, now);
if (!pos) continue; if (!pos) continue;
const cartesian = Cesium.Cartesian3.fromDegrees(
pos.longitude,
pos.latitude,
pos.altitude,
);
const point = layerState._points.get(noradId); const point = layerState._points.get(noradId);
if (point) { if (point) {
point.position = cartesian; fromDegreesInto(pos.longitude, pos.latitude, pos.altitude, point.pos);
_markDirty(noradId);
updated++; 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, * - core fleet propagation at 200ms-tracked / 1s-idle cadence,
* - dense extras on a per-frame round-robin budget, * - dense extras on a per-frame round-robin budget,
* - tracked satellite's point primitive per frame (WS-D2), * - tracked satellite's dot sample per frame (WS-D2),
* - orbit ring GMST re-alignment every ~1s (WS-D1). * - 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() { function _preRenderTick(t) {
if (!layerState._enabled) return; 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 now = focusNowMs(Date.now());
const interval = layerState._trackedNorad ? 200 : POSITION_UPDATE_MS; const interval = layerState._trackedNorad ? 200 : POSITION_UPDATE_MS;
@@ -433,20 +560,20 @@ export function createRendering({
if (layerState._params.showPoints) parts.catalog._propagateDenseChunk(); if (layerState._params.showPoints) parts.catalog._propagateDenseChunk();
// Keep the tracked dot on the per-frame epoch shared with label + camera — // Keep the tracked satellite's (hidden) dot on the per-frame epoch shared
// runs after _propagateAll so the per-frame sample wins over the 200ms one. // with label + camera — runs after _propagateAll so the per-frame sample
// wins over the 200ms one.
if (layerState._trackedNorad !== null) { if (layerState._trackedNorad !== null) {
const pos = parts.tracking._getTrackedFramePosition(); const pos = parts.tracking._getTrackedFramePosition();
const point = layerState._points.get(layerState._trackedNorad); if (pos && layerState._points.has(layerState._trackedNorad))
if (pos && point) { _movePoint(layerState._trackedNorad, layerState._trackedFrameCartesian);
point.position = layerState._trackedFrameCartesian; // primitive setter clones if (!trackedDrawnThisTick) _drawTrackedDot();
}
} }
_updatePointFocus(now); _updatePointFocus(now);
// Hidden standalone orbit primitives do not need GMST matrix writes while // Hidden standalone orbit rings do not need turning while Space Missions
// Space Missions draws the selected mission orbit itself. // draws the selected mission orbit itself.
if ( if (
layerState._params.showOrbits && layerState._params.showOrbits &&
now - layerState._lastRingRotation >= RING_ROTATION_MS now - layerState._lastRingRotation >= RING_ROTATION_MS
@@ -458,6 +585,12 @@ export function createRendering({
/** Focus alpha for satellite points, inside the existing shared preRender tick. */ /** 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) { function _updatePointFocus(nowMs) {
const target = getFocusTarget(); const target = getFocusTarget();
if ( if (
@@ -467,28 +600,55 @@ export function createRendering({
return; return;
if (nowMs - layerState._lastFocusUpdate < 80) return; if (nowMs - layerState._lastFocusUpdate < 80) return;
layerState._lastFocusUpdate = nowMs; layerState._lastFocusUpdate = nowMs;
const scene = layerState._viewer.scene; const query = findQuery(layerState._viewer);
const camera = layerState._viewer.camera; 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({ const result = applySatellitePointFocusDeemphasis({
points: layerState._points, points: layerState._points,
trackedId: layerState._trackedNorad, trackedId: layerState._trackedNorad,
target, target,
previousActiveCount: layerState._activeFocusCount, previousActiveCount: layerState._activeFocusCount,
nowMs, nowMs,
screenPositionFor: (position) => screenPositionFor: (position) => {
Cesium.SceneTransforms.worldToWindowCoordinates( while (cursor < focusOrder.length && focusOrder[cursor] !== position)
scene, cursor++;
position, if (cursor >= focusOrder.length) {
scratchFocusScreen, cursor = 0;
), return query.project(position);
cameraDistanceFor: (position) => }
Cesium.Cartesian3.distance(camera.positionWC, 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) => baseColorFor: (noradId) =>
cesiumStyleOf( parts.controls._pointStyleFor(
parts.controls._pointStyleFor( noradId,
noradId, layerState._catalog.get(noradId)?.group,
layerState._catalog.get(noradId)?.group,
),
).color, ).color,
}); });
layerState._activeFocusCount = result.activeCount; layerState._activeFocusCount = result.activeCount;
@@ -497,6 +657,8 @@ export function createRendering({
/** /**
* Apply the gated satellite-point focus pass through the production color path. * Apply the gated satellite-point focus pass through the production color path.
* @param {object} input * @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}} * @returns {{writes:number,transitioning:boolean,activeCount:number,ran:boolean}}
*/ */
@@ -518,8 +680,8 @@ export function createRendering({
let transitioning = false; let transitioning = false;
let activeCount = 0; let activeCount = 0;
for (const [noradId, point] of points || []) { for (const [noradId, point] of points || []) {
if (noradId === trackedId || !point?.position) continue; if (noradId === trackedId || !point?.pos) continue;
const cameraDistance = cameraDistanceFor(point.position); const cameraDistance = cameraDistanceFor(point.pos);
const distanceScale = nearFarScalarValueAtDistance( const distanceScale = nearFarScalarValueAtDistance(
point.scaleByDistance, point.scaleByDistance,
cameraDistance, cameraDistance,
@@ -529,7 +691,7 @@ export function createRendering({
// Hidden points still release toward identity, preventing stale dim // Hidden points still release toward identity, preventing stale dim
// alpha if a catalog/presentation toggle later makes them visible. // alpha if a catalog/presentation toggle later makes them visible.
screenPosition: screenPosition:
point.show === false ? null : screenPositionFor(point.position), point.show === false ? null : screenPositionFor(point.pos),
cameraDistance, cameraDistance,
nowMs, nowMs,
target, target,
@@ -540,11 +702,12 @@ export function createRendering({
transitioning ||= focus.transitioning; transitioning ||= focus.transitioning;
if (focus.active) activeCount += 1; if (focus.active) activeCount += 1;
const base = baseColorFor(noradId); const base = baseColorFor(noradId);
const alpha = base.alpha * focus.factor; const alpha = base[3] * focus.factor;
if (focusAlphaNeedsWrite(point.color?.alpha, alpha, params)) { if (focusAlphaNeedsWrite(point.color?.[3], alpha, params)) {
// Point stays continuously present at the non-zero emphasis floor; its // Point stays continuously present at the non-zero emphasis floor; its
// own alpha yields around the tracked target, independent of draw order. // 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; writes += 1;
} }
} }
@@ -555,6 +718,7 @@ export function createRendering({
_rendererPositions, _rendererPositions,
_drawnFrameNumber, _drawnFrameNumber,
_attach, _attach,
_attachTo,
_detach, _detach,
_hasPointCollection, _hasPointCollection,
_pointsShown, _pointsShown,
@@ -572,8 +736,8 @@ export function createRendering({
_addTrackedEntity, _addTrackedEntity,
_removeTrackedEntity, _removeTrackedEntity,
_publishTrackedFocus, _publishTrackedFocus,
_pickIsTrackedEntity, _hitIsTracked,
_pickedPointId, _hitPointId,
_showOrbitPath, _showOrbitPath,
_updateOrbitPathRotations, _updateOrbitPathRotations,
_hideOrbitPath, _hideOrbitPath,
@@ -581,5 +745,6 @@ export function createRendering({
_preRenderTick, _preRenderTick,
_updatePointFocus, _updatePointFocus,
applySatellitePointFocusDeemphasis, applySatellitePointFocusDeemphasis,
_flushPoints,
}; };
} }
+7 -3
View File
@@ -12,6 +12,7 @@ import { createTracking } from './tracking.js';
import { createRendering } from './rendering.js'; import { createRendering } from './rendering.js';
import { bindRenderer } from '../../render/rendererOf.js'; import { bindRenderer } from '../../render/rendererOf.js';
import { fakeSceneFrame } from '../../testSupport/fakeCesiumScene.mjs'; import { fakeSceneFrame } from '../../testSupport/fakeCesiumScene.mjs';
import { fakeDrawPort } from '../../testSupport/fakeDrawPort.mjs';
import { createCatalog } from './catalog.js'; import { createCatalog } from './catalog.js';
import { createLifecycle } from './lifecycle.js'; import { createLifecycle } from './lifecycle.js';
import { createInteraction } from './interaction.js'; import { createInteraction } from './interaction.js';
@@ -66,7 +67,7 @@ async function fixture(t) {
fetchImpl: (path, options) => fetchImpl: (path, options) =>
fetch(`http://127.0.0.1:${server.address().port}${path}`, options), fetch(`http://127.0.0.1:${server.address().port}${path}`, options),
}); });
// Application host services and native EventTargets; actual Cesium collections, // Application host services and native EventTargets; a fake draw port,
// input handler, events, SGP4, ingestion and lifecycle run without a WebGL scene. // input handler, events, SGP4, ingestion and lifecycle run without a WebGL scene.
const noop = () => {}; const noop = () => {};
const services = { const services = {
@@ -117,11 +118,14 @@ async function fixture(t) {
}, },
trackedEntityChanged: new Cesium.Event(), trackedEntityChanged: new Cesium.Event(),
}; };
const unbind = bindRenderer(viewer, { frame: fakeSceneFrame(viewer) }); const unbind = bindRenderer(viewer, {
frame: fakeSceneFrame(viewer),
draw: fakeDrawPort(),
});
await parts.lifecycle.methods.init(viewer); await parts.lifecycle.methods.init(viewer);
t.after(async () => { t.after(async () => {
unbind(); unbind();
if (state._pointCollection) parts.lifecycle.methods.destroy(viewer); if (state._sets) parts.lifecycle.methods.destroy(viewer);
viewer.scene.primitives.destroy(); viewer.scene.primitives.destroy();
if (previousDocument === undefined) delete globalThis.document; if (previousDocument === undefined) delete globalThis.document;
else globalThis.document = previousDocument; else globalThis.document = previousDocument;
+6 -6
View File
@@ -15,18 +15,18 @@ export function createState({ services }) {
state._catalog = new Map(); state._catalog = new Map();
state._pointCollection = null; /** The draw sets (`{points, tracked, rings}`), owned by the rendering part. */
state._sets = null;
state._points = new Map(); state._points = new Map();
// noradId → point primitive // noradId → the point item its dot is drawn from (the rendering part's)
/** Stable lightweight records reused by the detection overlay between updates. */ /** Stable lightweight records reused by the detection overlay between updates. */
state._detectionObjects = new Map(); state._detectionObjects = new Map();
// noradId → { primitive, gmstAtBake }, owned by the rendering part: // noradId → { base, gmstAtBake, item }, owned by the rendering part: base
// primitive is a one-instance primitive holding the ring baked in ECEF // is the ring baked in ECEF at gmstAtBake; the preRender tick turns it to
// at gmstAtBake; the preRender tick re-aligns it to current GMST by updating // current GMST (rigid Z-rotation, WS-D1) into the line item drawn.
// its modelMatrix (rigid Z-rotation — no geometry rebuild, WS-D1).
state._orbitPaths = new Map(); state._orbitPaths = new Map();
+35 -17
View File
@@ -1,5 +1,23 @@
import { rendererOf } from '../../render/rendererOf.js';
import { ISS_NORAD, ISS_OVERLAY_SOURCE_ID } from './policy.js'; import { ISS_NORAD, ISS_OVERLAY_SOURCE_ID } from './policy.js';
/** A draw port that draws nothing, for seams that need sets but no renderer. */
const NO_DRAW = (() => {
const set = (spec) => ({
id: spec.id,
show: spec.show !== false,
set() {},
upsert() {},
remove() {},
clear() {},
setOptions() {},
size: () => 0,
on: () => () => {},
dispose() {},
});
return { points: set, lines: set, icons: set, shapes: set };
})();
export function createTesting({ state: layerState, services, parts, source }) { export function createTesting({ state: layerState, services, parts, source }) {
/** /**
* Seed a single tracked satellite so tests can invoke the exact production * Seed a single tracked satellite so tests can invoke the exact production
@@ -8,8 +26,8 @@ export function createTesting({ state: layerState, services, parts, source }) {
* @param {number} state.noradId * @param {number} state.noradId
* @param {string} state.name * @param {string} state.name
* @param {object} state.satrec * @param {object} state.satrec
* @param {object} state.entity * @param {object} state.entity The tracked carrier.
* @param {object} state.point * @param {object} state.point The satellite's point item (`pos` ECEF).
* @param {object} state.viewer * @param {object} state.viewer
* @param {() => (number|Date)} state.now * @param {() => (number|Date)} state.now
*/ */
@@ -97,9 +115,7 @@ export function createTesting({ state: layerState, services, parts, source }) {
catalog = 'core', catalog = 'core',
showPoints = true, showPoints = true,
} = {}) { } = {}) {
layerState._viewer = { layerState._viewer = {};
scene: { primitives: { add: (p) => p, remove() {} } },
};
// Neutralize the shared world-overlay host: these tests exercise catalog and // Neutralize the shared world-overlay host: these tests exercise catalog and
// row-control logic, not the ISS callout. // row-control logic, not the ISS callout.
layerState._overlayHost = { layerState._overlayHost = {
@@ -107,12 +123,7 @@ export function createTesting({ state: layerState, services, parts, source }) {
setVisible() {}, setVisible() {},
clearSource() {}, clearSource() {},
}; };
layerState._pointCollection = { parts.rendering._attachTo(NO_DRAW);
show: true,
add: (opts) => ({ ...opts }),
remove() {},
removeAll() {},
};
layerState._catalog = new Map(); layerState._catalog = new Map();
layerState._points = new Map(); layerState._points = new Map();
layerState._detectionObjects = new Map(); layerState._detectionObjects = new Map();
@@ -136,7 +147,7 @@ export function createTesting({ state: layerState, services, parts, source }) {
layerState._overlayHost = layerState.DEFAULT_OVERLAY_HOST; layerState._overlayHost = layerState.DEFAULT_OVERLAY_HOST;
layerState._orbitPaths = new Map(); layerState._orbitPaths = new Map();
layerState._viewer = null; layerState._viewer = null;
layerState._pointCollection = null; parts.rendering._detach();
layerState._catalog = new Map(); layerState._catalog = new Map();
layerState._points = new Map(); layerState._points = new Map();
layerState._denseIds = []; layerState._denseIds = [];
@@ -176,17 +187,23 @@ export function createTesting({ state: layerState, services, parts, source }) {
[ [
ISS_NORAD, ISS_NORAD,
{ {
// A stand-in ring: shown, at the identity 4x4 (column-major). // A stand-in ring: shown, baked with no points.
primitive: { base: [],
show: true,
modelMatrix: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1],
},
gmstAtBake: 0, gmstAtBake: 0,
item: {
id: String(ISS_NORAD),
positions: new Float64Array(0),
show: true,
},
}, },
], ],
]); ]);
layerState._trackedNorad = null; layerState._trackedNorad = null;
layerState._trackedEntity = null; layerState._trackedEntity = null;
// Drawn through the viewer's renderer when it has one bound.
parts.rendering._detach();
const draw = rendererOf(viewer)?.draw;
if (draw) parts.rendering._attachTo(draw);
if (!preservePending) parts.tracking._cancelPendingTrackingRestore(); if (!preservePending) parts.tracking._cancelPendingTrackingRestore();
layerState._trackedFrameNumber = -1; layerState._trackedFrameNumber = -1;
layerState._trackedFrameGeo = null; layerState._trackedFrameGeo = null;
@@ -231,6 +248,7 @@ export function createTesting({ state: layerState, services, parts, source }) {
function _clearSatelliteLabelLifecycleForTest() { function _clearSatelliteLabelLifecycleForTest() {
parts.tracking._clearTracking(); parts.tracking._clearTracking();
parts.rendering._detach();
layerState._enabled = false; layerState._enabled = false;
layerState._overlayHost.clearSource(ISS_OVERLAY_SOURCE_ID); layerState._overlayHost.clearSource(ISS_OVERLAY_SOURCE_ID);
layerState._overlayHost.setVisible(ISS_OVERLAY_SOURCE_ID, false); layerState._overlayHost.setVisible(ISS_OVERLAY_SOURCE_ID, false);
+9 -11
View File
@@ -90,7 +90,7 @@ export function createTracking({ state: layerState, services, parts, source }) {
const clearedNorad = layerState._trackedNorad; const clearedNorad = layerState._trackedNorad;
clearFocusTarget('satellites', layerState._trackedNorad); clearFocusTarget('satellites', layerState._trackedNorad);
// Re-show the dot (hidden while the tracked entity rendered it) and // Re-show the dot (hidden while the tracked dot drew it) and
// restore the original group palette from the shared style table (WS-D3) // restore the original group palette from the shared style table (WS-D3)
parts.rendering._restorePoint( parts.rendering._restorePoint(
layerState._trackedNorad, layerState._trackedNorad,
@@ -104,7 +104,7 @@ export function createTracking({ state: layerState, services, parts, source }) {
layerState._trackedFrameNumber = -1; layerState._trackedFrameNumber = -1;
layerState._trackedFrameGeo = null; layerState._trackedFrameGeo = null;
// Remove tracked entity and orbit path (unless ISS — keep its path) // Remove the tracked dot and orbit path (unless ISS — keep its path)
if (layerState._trackedNorad !== ISS_NORAD) { if (layerState._trackedNorad !== ISS_NORAD) {
parts.rendering._hideOrbitPath(layerState._trackedNorad); parts.rendering._hideOrbitPath(layerState._trackedNorad);
} }
@@ -128,8 +128,8 @@ export function createTracking({ state: layerState, services, parts, source }) {
/** /**
* Get the tracked satellite's geodetic position, propagated at most once per * Get the tracked satellite's geodetic position, propagated at most once per
* rendered frame (WS-D2). All tracked-satellite consumers (entity position * rendered frame (WS-D2). All tracked-satellite consumers (the tracked dot
* callback → camera, host model, point primitive, getTrackedInfo) share this * and follow camera, host model, the hidden dot, getTrackedInfo) share this
* single `new Date()` epoch per frame, so they can never diverge by the old * single `new Date()` epoch per frame, so they can never diverge by the old
* 200ms throttle. The matching ECEF position is left in * 200ms throttle. The matching ECEF position is left in
* `_trackedFrameCartesian`. SGP4 for one satellite per frame is cheap. * `_trackedFrameCartesian`. SGP4 for one satellite per frame is cheap.
@@ -405,16 +405,13 @@ export function createTracking({ state: layerState, services, parts, source }) {
layerState._trackedFrameGeo = null; layerState._trackedFrameGeo = null;
parts.labels._syncIssOverlay(); parts.labels._syncIssOverlay();
// Hide the dot — the tracked ENTITY renders it below. The entity must // Hide the dot — the tracked dot draws it, larger and over everything.
// own a point graphic so the tracking camera can resolve a bounding
// sphere and engage viewFrom (a label-only entity left the camera
// stranded; this mirrors the proven flights pattern).
parts.rendering._hidePoint(noradId); parts.rendering._hidePoint(noradId);
// Show orbital path // Show orbital path
parts.rendering._showOrbitPath(noradId, TRACKED_ORBIT_COLOR); parts.rendering._showOrbitPath(noradId, TRACKED_ORBIT_COLOR);
// Tracked entity position propagates per evaluation through the per-frame // The tracked position propagates per evaluation through the per-frame
// cache (WS-D2) — dot, host readout, and camera share one SGP4 epoch per frame. // cache (WS-D2) — dot, host readout, and camera share one SGP4 epoch per frame.
// Falls back to the dot's 1s-throttled position if SGP4 fails. // Falls back to the dot's 1s-throttled position if SGP4 fails.
const trackedPosition = () => { const trackedPosition = () => {
@@ -457,8 +454,9 @@ export function createTracking({ state: layerState, services, parts, source }) {
selectTrackedSubjectContext(_contextSubjectMetadata(noradId, initialPos)); selectTrackedSubjectContext(_contextSubjectMetadata(noradId, initialPos));
layerState._contextRefreshedAtMs = Date.now(); layerState._contextRefreshedAtMs = Date.now();
// The renderer's own frame for a fast mover (autodetect), as the tracked entity // The renderer's own frame for a fast mover (autodetect), as the tracked
// had; no close-range rules at orbital distances. // entity had; no close-range rules at orbital distances. The carrier is
// what the tracked card reads (its entity record).
layerState._followTarget = entityFollowTarget(layerState._trackedEntity, { layerState._followTarget = entityFollowTarget(layerState._trackedEntity, {
position: trackedPosition, position: trackedPosition,
frame: 'autodetect', frame: 'autodetect',
+2
View File
@@ -1572,6 +1572,8 @@ export function createCesiumDraw({
}), }),
show: item.show !== false, show: item.show !== false,
asynchronous: false, asynchronous: false,
// A set that never picks keeps these out of the pick pass too.
allowPicking: record.spec.pickable !== false,
}); });
} }
+64
View File
@@ -1889,6 +1889,70 @@ test('the installations layer draws its site dots, outlines and selected dot on
assert.equal(scene.added.length, 0, 'gone with the layer'); assert.equal(scene.added.length, 0, 'gone with the layer');
}); });
test('the satellites layer draws its dots as one point collection and its rings as depth-fail primitives out of picks', async () => {
const { createRendering } =
await import('../../layers/satellites/rendering.js');
const { POINT_STYLES, TRACKED_ORBIT_COLOR } =
await import('../../layers/satellites/policy.js');
const scene = fakeScene();
const viewer = { scene };
const state = {
_points: new Map(),
_orbitPaths: new Map(),
_catalog: new Map([[25544, { satrec: {} }]]),
_viewer: viewer,
_trackedNorad: null,
_enabled: false,
};
const ring = [
{ x: 7e6, y: 0, z: 0 },
{ x: 0, y: 7e6, z: 0 },
{ x: -7e6, y: 0, z: 0 },
];
const rendering = createRendering({
state,
services: { focus: {} },
parts: { orbits: { computeOrbitPath: () => ring } },
});
rendering._attach(viewer);
rendering._addPoint(25544, { x: 7e6, y: 0, z: 0 }, POINT_STYLES.iss);
rendering._addPoint(5, { x: 0, y: 7e6, z: 0 }, POINT_STYLES.visual);
rendering._preRenderTick({ frame: 1 });
const points = scene.added.find(
(host) => host instanceof Cesium.PointPrimitiveCollection,
);
assert.equal(points.length, 2);
const iss = points.get(0);
assert.equal(iss.id.id, '25544');
assert.deepEqual(iss.id.meta, { noradId: 25544 });
assert.equal(iss.pixelSize, 12);
assert.equal(iss.scaleByDistance.nearValue, 1.5);
assert.equal(iss.scaleByDistance.far, 2e7);
// Moved in place, both in one write.
rendering._movePoint(25544, { x: 6.9e6, y: 0, z: 0 });
rendering._movePoint(5, { x: 0, y: 6.9e6, z: 0 });
rendering._preRenderTick({ frame: 2 });
assert.equal(points.get(0), iss);
assert.equal(iss.position.x, 6.9e6);
withImageClasses(() =>
rendering._showOrbitPath(25544, TRACKED_ORBIT_COLOR),
);
const all = (host) =>
host instanceof Cesium.PrimitiveCollection
? Array.from({ length: host.length }, (_, i) => all(host.get(i))).flat()
: [host];
const primitive = scene.added
.flatMap(all)
.find(
(host) => host instanceof Cesium.Primitive && host.depthFailAppearance,
);
assert.ok(primitive, 'a ring with a dimmed part behind the globe');
assert.equal(primitive.allowPicking, false, 'ring clicks fall through');
rendering._detach(viewer);
assert.equal(scene.added.length, 0, 'gone with the layer');
});
test('the ALPR layer draws its badges as icons that follow the ground, restyled in place', async () => { test('the ALPR layer draws its badges as icons that follow the ground, restyled in place', async () => {
const { alprMarkers, createAlprMarkerSet } = const { alprMarkers, createAlprMarkerSet } =
await import('../../layers/alpr/markerState.js'); await import('../../layers/alpr/markerState.js');
-1
View File
@@ -15,7 +15,6 @@
"src/layers/launches/orbitRendering.js", "src/layers/launches/orbitRendering.js",
"src/layers/launches/rendering.js", "src/layers/launches/rendering.js",
"src/layers/recentImagery/rendering.js", "src/layers/recentImagery/rendering.js",
"src/layers/satellites/rendering.js",
"src/layers/traffic/rendering.js", "src/layers/traffic/rendering.js",
"src/layers/transit/rendering.js", "src/layers/transit/rendering.js",
"src/layers/weather/shellRendering.js", "src/layers/weather/shellRendering.js",
+3
View File
@@ -98,6 +98,9 @@ const DRAW_FROM_CALLER = new Set([
// Its site dots, outlines and selected fill draw through `drawOf`; it // Its site dots, outlines and selected fill draw through `drawOf`; it
// follows a site and reads the globe through the camera and globe ports. // follows a site and reads the globe through the camera and globe ports.
'./layers/installations', './layers/installations',
// Its dots, tracked dot and orbit rings draw through `drawOf`; it follows,
// ticks, projects and reads the eye through the ports.
'./layers/satellites',
// Its data packs draw through `drawOf`; its flights ask `cameraOf`, which // Its data packs draw through `drawOf`; its flights ask `cameraOf`, which
// throws until then too. // throws until then too.
'./scenes', './scenes',