mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-18 01:02:23 +00:00
Draw vessels, satellites, Space Missions, ALPR, bikeshare and OSM Places through one display each
Each layer now has one render/display.js on the globe contract, the same factory on both engines; its render/cesium* and render/navara* files go. Cesium's behaviour is the reference, and the logic that was written twice is written once: - AIS vessels: atlas chevrons and engine.lines trails. The display registers the gev-trail pick claim itself and its trailing visibility pass now also runs on Navara. - Satellites: point banks per look, orbit rings as lines turned by their model matrix, and selection and follow through engine.camera.follow. The emulated _viewer is gone, and the tracked readout republishes card text on Navara too. - Space Missions: dots, reticle, trajectories and tactical orbits as movers and lines. The layer keeps its own records instead of Entities and DataSources, and camera work goes through engine.camera. Clicks go through the selection dispatcher, and hover keeps Cesium's throttle. The pad zone is its rim only: the contract has no surface fill yet. - ALPR, bikeshare and OSM Places: one display and, for bikeshare, one style module each; clicks through engine.input, no ScreenSpaceEventHandler or EntityCluster. ALPR keeps Navara's horizon cull, and OSM Places points sample the surface where Cesium clamped them. Coupling: layer renderer lines fall from 4546/11106 to 2638/8735 (Cesium/Navara), `viewer` lines from 2209 to 2014, ScreenSpaceEventHandler files from 20 to 15.
This commit is contained in:
1 parent
3e261d1baf
commit
f06b93fbc9
120 files changed
+6626
-6998
No files matched your search
@@ -62,7 +62,7 @@ export function createCatalog({ state: layerState, services, parts, source }) {
|
||||
|
||||
async function _loadDenseCatalog({ signal = null } = {}) {
|
||||
if (layerState._waitForRenderer) await layerState._waitForRenderer;
|
||||
if (!layerState._viewer || !layerState._pointCollection)
|
||||
if (!layerState._pointCollection)
|
||||
return { status: 'source-unavailable', reason: 'layer-unavailable' };
|
||||
layerState._denseLoadController?.abort();
|
||||
const resourceController = new AbortController();
|
||||
|
||||
Vendored
+1
-1
@@ -261,7 +261,7 @@ export function createControls({ state: layerState, services, parts, source }) {
|
||||
const id = Number(noradId);
|
||||
if (
|
||||
!Number.isFinite(id) ||
|
||||
!layerState._viewer ||
|
||||
!layerState._renderer ||
|
||||
!layerState._catalog.has(id) ||
|
||||
!layerState._points.has(id)
|
||||
)
|
||||
|
||||
@@ -6,7 +6,7 @@ import assert from 'node:assert/strict';
|
||||
import * as geo from '../../geo/index.js';
|
||||
import { createFakeEngine } from '../../globe/testing/fakeEngine.js';
|
||||
import { createApplicationSatellites } from '../../app/layers/satellites.js';
|
||||
import { createSatellitesNavaraRenderer } from './render/navara.js';
|
||||
import { createSatellitesDisplay } from './render/display.js';
|
||||
import { appClock } from '../../time/clock.js';
|
||||
|
||||
// Canonical archived ISS element set (epoch 2008-09-20 ~12:25 UTC).
|
||||
@@ -65,7 +65,7 @@ test('edge:satellites: a scene switch at a stopped epoch keeps passes and coordi
|
||||
},
|
||||
},
|
||||
renderer: {
|
||||
create: ({ engine }) => createSatellitesNavaraRenderer(engine),
|
||||
create: ({ engine }) => createSatellitesDisplay(engine),
|
||||
},
|
||||
});
|
||||
const [first, second] = [createFakeEngine(), createFakeEngine()];
|
||||
|
||||
@@ -18,14 +18,8 @@ export function createSatellitesLayer({ services, source }) {
|
||||
throw new TypeError('A satellites source is required');
|
||||
const state = createState({ services });
|
||||
const parts = {};
|
||||
const getRenderer = () => {
|
||||
if (!state._renderer || state._renderer.view !== state._viewer)
|
||||
state._renderer = services.renderer.create({
|
||||
viewer: state._viewer,
|
||||
engine: state._engine,
|
||||
});
|
||||
return state._renderer;
|
||||
};
|
||||
// The engine's display while the layer draws (render/display.js), else null.
|
||||
const getRenderer = () => state._renderer;
|
||||
const context = { state, services, parts, source, getRenderer };
|
||||
parts.controls = createControls(context);
|
||||
parts.catalog = createCatalog(context);
|
||||
|
||||
@@ -94,7 +94,7 @@ export function createIngestion({
|
||||
layerState._pointCollection.removeAll();
|
||||
layerState._points.clear();
|
||||
for (const path of layerState._orbitPaths.values())
|
||||
getRenderer().removeOrbit(path.primitive);
|
||||
getRenderer()?.removeOrbit(path.primitive);
|
||||
layerState._orbitPaths.clear();
|
||||
layerState._catalog.clear();
|
||||
// The detection overlay caches one record per satellite and stamps its
|
||||
|
||||
@@ -16,21 +16,21 @@ export function createInteraction({
|
||||
}
|
||||
}
|
||||
|
||||
function _installClickHandler(viewer) {
|
||||
if (layerState._clickHandler) return; // already installed
|
||||
function _installClickHandler() {
|
||||
if (layerState._clickHandler || !getRenderer()) return; // already installed
|
||||
|
||||
// Cross-layer untrack (H2, mirror of flights): if ANOTHER layer (flights,
|
||||
// military, …) grabs the follow-camera, drop our tracking so the orbit ring /
|
||||
// tracked entity don't orphan — without touching viewer.trackedEntity (the
|
||||
// new owner controls it). Guarded so our OWN switch (viewer.trackedEntity
|
||||
// briefly undefined mid-_trackSatellite) doesn't self-clear.
|
||||
// tracked dot don't orphan — without releasing the follow (the new owner
|
||||
// controls it). Guarded so our OWN switch (the follow briefly null
|
||||
// mid-_trackSatellite) doesn't self-clear.
|
||||
if (!layerState._trackedEntityChangedRemove) {
|
||||
layerState._trackedEntityChangedRemove = getRenderer().follow.onChanged(
|
||||
() => {
|
||||
if (!layerState._enabled) return;
|
||||
if (
|
||||
layerState._trackedNorad &&
|
||||
layerState._viewer &&
|
||||
getRenderer() &&
|
||||
((getRenderer().follow.current() &&
|
||||
getRenderer().follow.current() !== layerState._trackedEntity) ||
|
||||
(!getRenderer().follow.current() &&
|
||||
@@ -70,7 +70,7 @@ export function createInteraction({
|
||||
|
||||
// A pick that belongs to a sibling layer (plane, vessel, station, CCTV
|
||||
// camera…) is not "empty space" — leave OUR tracking (and crucially
|
||||
// viewer.trackedEntity, which that sibling may have JUST set) alone (H2).
|
||||
// the follow, which that sibling may have JUST started) alone (H2).
|
||||
if (picked) {
|
||||
const pickedId = resolvePickId(picked);
|
||||
if (pickedId && isOwnedByOtherLayer('satellites', pickedId)) return;
|
||||
|
||||
@@ -2,7 +2,7 @@ import test from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import { createEngineEvent } from '../../globe/contract.js';
|
||||
import { createInteraction } from './interaction.js';
|
||||
test('external null follow clears satellite state on Cesium; own release stays guarded', () => {
|
||||
test('an external null follow clears satellite state; own release stays guarded', () => {
|
||||
const previous = globalThis.document;
|
||||
globalThis.document = new EventTarget();
|
||||
try {
|
||||
@@ -11,7 +11,6 @@ test('external null follow clears satellite state on Cesium; own release stays g
|
||||
releasing = false;
|
||||
const calls = [];
|
||||
const renderer = {
|
||||
kind: 'cesium',
|
||||
follow: {
|
||||
onChanged: (fn) => changed.addEventListener(fn),
|
||||
current: () => current,
|
||||
@@ -22,7 +21,6 @@ test('external null follow clears satellite state on Cesium; own release stays g
|
||||
const state = {
|
||||
_enabled: true,
|
||||
_trackedNorad: 25544,
|
||||
_viewer: {},
|
||||
_trackedEntity: { id: 'own' },
|
||||
};
|
||||
const interaction = createInteraction({
|
||||
@@ -31,7 +29,7 @@ test('external null follow clears satellite state on Cesium; own release stays g
|
||||
parts: { tracking: { _clearTracking: (...args) => calls.push(args) } },
|
||||
getRenderer: () => renderer,
|
||||
});
|
||||
interaction._installClickHandler(state._viewer);
|
||||
interaction._installClickHandler();
|
||||
releasing = true;
|
||||
changed.raiseEvent();
|
||||
assert.equal(calls.length, 0);
|
||||
|
||||
@@ -14,13 +14,15 @@ export function createLifecycle({
|
||||
const methods = {
|
||||
// Catalog data refresh; propagation remains preRender-owned.
|
||||
|
||||
async init(viewer, { engine = null } = {}) {
|
||||
// The display draws on `engine` (none without one: nothing is drawn).
|
||||
async init(_viewer, { engine = null } = {}) {
|
||||
parts.catalog._abortActiveUpdates();
|
||||
clearFocusTarget('satellites');
|
||||
layerState._engine = engine;
|
||||
layerState._renderer?.destroy();
|
||||
layerState._renderer = services.renderer.create({ viewer, engine });
|
||||
layerState._viewer = layerState._renderer.view;
|
||||
layerState._renderer = engine
|
||||
? (services.renderer.create({ engine }) ?? null)
|
||||
: null;
|
||||
layerState._catalog = new Map();
|
||||
layerState._points = new Map();
|
||||
layerState._detectionObjects = new Map();
|
||||
@@ -50,16 +52,19 @@ export function createLifecycle({
|
||||
layerState._denseError = null;
|
||||
layerState._catalogRevision++;
|
||||
|
||||
// Point primitives for satellite dots
|
||||
layerState._pointCollection = getRenderer().createPoints();
|
||||
const renderer = getRenderer();
|
||||
if (renderer) {
|
||||
// Point primitives for satellite dots
|
||||
layerState._pointCollection = renderer.createPoints();
|
||||
|
||||
parts.interaction._installClickHandler(viewer);
|
||||
parts.interaction._installClickHandler();
|
||||
|
||||
// Pre-render listener for real-time position updates
|
||||
// (fleet propagation + tracked per-frame dot + orbit ring GMST rotation)
|
||||
layerState._preRenderListener = getRenderer().onFrame(
|
||||
parts.rendering._preRenderTick,
|
||||
);
|
||||
// Pre-render listener for real-time position updates
|
||||
// (fleet propagation + tracked per-frame dot + orbit ring GMST rotation)
|
||||
layerState._preRenderListener = renderer.onFrame(
|
||||
parts.rendering._preRenderTick,
|
||||
);
|
||||
}
|
||||
|
||||
console.log('[Data:Satellites] Initialized');
|
||||
},
|
||||
@@ -123,7 +128,6 @@ export function createLifecycle({
|
||||
renderer.removePoints(layerState._pointCollection);
|
||||
renderer.destroy();
|
||||
layerState._engine =
|
||||
layerState._viewer =
|
||||
layerState._renderer =
|
||||
layerState._pointCollection =
|
||||
null;
|
||||
@@ -132,13 +136,17 @@ export function createLifecycle({
|
||||
},
|
||||
|
||||
attachRenderer(
|
||||
viewer,
|
||||
_viewer,
|
||||
{ engine = null, waitForCameraRestore = false } = {},
|
||||
) {
|
||||
layerState._engine = engine;
|
||||
const renderer = services.renderer.create({ viewer, engine });
|
||||
const renderer = engine
|
||||
? (services.renderer.create({ engine }) ?? null)
|
||||
: null;
|
||||
layerState._renderer = renderer;
|
||||
layerState._viewer = renderer.view;
|
||||
if (!renderer) return;
|
||||
// The new engine counts its own frames.
|
||||
layerState._trackedFrameNumber = -1;
|
||||
layerState._pointCollection = renderer.createPoints();
|
||||
for (const [id, spec] of layerState._points)
|
||||
layerState._points.set(id, layerState._pointCollection.add(spec));
|
||||
@@ -171,13 +179,13 @@ export function createLifecycle({
|
||||
origin: layerState._handoffOrigin,
|
||||
resuming: true,
|
||||
});
|
||||
this.enable(layerState._viewer);
|
||||
this.enable();
|
||||
}
|
||||
layerState._resumeRenderer?.();
|
||||
layerState._waitForRenderer = layerState._resumeRenderer = null;
|
||||
},
|
||||
|
||||
enable(viewer) {
|
||||
enable() {
|
||||
layerState._enabled = true;
|
||||
holdContinuousRender('satellites'); // per-frame animator (perf wave 2)
|
||||
if (layerState._pointCollection)
|
||||
@@ -194,14 +202,14 @@ export function createLifecycle({
|
||||
);
|
||||
parts.labels._syncIssOverlay();
|
||||
// Re-attach input handlers and preRender propagation
|
||||
parts.interaction._installClickHandler(viewer);
|
||||
if (layerState._renderer) parts.interaction._installClickHandler();
|
||||
// Pick-ownership (H2): satellite dot ids are numeric NORAD catalog numbers;
|
||||
// the registry hands predicates String()-coerced ids, so match via Number().
|
||||
registerPickOwner('satellites', (pickedId) => {
|
||||
const norad = Number(pickedId);
|
||||
return Number.isFinite(norad) && layerState._points.has(norad);
|
||||
});
|
||||
if (!layerState._preRenderListener && layerState._viewer) {
|
||||
if (!layerState._preRenderListener && layerState._renderer) {
|
||||
layerState._preRenderListener = getRenderer().onFrame(
|
||||
parts.rendering._preRenderTick,
|
||||
);
|
||||
@@ -209,7 +217,7 @@ export function createLifecycle({
|
||||
parts.tracking._applyPendingTrackingRestore();
|
||||
},
|
||||
|
||||
disable(viewer) {
|
||||
disable() {
|
||||
parts.catalog._abortActiveUpdates();
|
||||
parts.tracking._cancelPendingTrackingRestore();
|
||||
layerState._enabled = false;
|
||||
@@ -236,7 +244,7 @@ export function createLifecycle({
|
||||
}
|
||||
},
|
||||
|
||||
destroy(viewer) {
|
||||
destroy() {
|
||||
layerState._resumeRenderer?.();
|
||||
layerState._waitForRenderer = layerState._resumeRenderer = null;
|
||||
parts.catalog._abortActiveUpdates();
|
||||
@@ -266,7 +274,7 @@ export function createLifecycle({
|
||||
}
|
||||
// Orbit ring primitives are removed (and destroyed) here
|
||||
for (const path of layerState._orbitPaths.values()) {
|
||||
if (path.primitive) getRenderer().removeOrbit(path.primitive);
|
||||
if (path.primitive) getRenderer()?.removeOrbit(path.primitive);
|
||||
}
|
||||
layerState._points.clear();
|
||||
layerState._detectionObjects.clear();
|
||||
@@ -295,7 +303,6 @@ export function createLifecycle({
|
||||
layerState._renderer?.destroy();
|
||||
layerState._renderer = null;
|
||||
layerState._engine = null;
|
||||
layerState._viewer = null;
|
||||
},
|
||||
};
|
||||
|
||||
|
||||
@@ -1,125 +0,0 @@
|
||||
// Satellite drawing and guarded native follow.
|
||||
import * as Cesium from 'cesium';
|
||||
import { isPointerFree } from '../../../data/inputOwnership.js';
|
||||
|
||||
export function createSatellitesCesiumRenderer(engine, { viewer } = {}) {
|
||||
let releasing = false;
|
||||
let starting = null;
|
||||
return {
|
||||
kind: 'cesium',
|
||||
engine,
|
||||
view: viewer,
|
||||
createPoints() {
|
||||
const points = new Cesium.PointPrimitiveCollection();
|
||||
viewer.scene.primitives.add(points);
|
||||
return points;
|
||||
},
|
||||
removePoints(points) {
|
||||
viewer?.scene.primitives.remove(points);
|
||||
},
|
||||
onFrame: (listener) => viewer?.scene.preRender.addEventListener(listener),
|
||||
project: (position, result) =>
|
||||
Cesium.SceneTransforms.worldToWindowCoordinates(
|
||||
viewer.scene,
|
||||
position,
|
||||
result,
|
||||
),
|
||||
createOrbit({ positions, width, color }) {
|
||||
const primitive = new Cesium.Primitive({
|
||||
geometryInstances: new Cesium.GeometryInstance({
|
||||
geometry: new Cesium.PolylineGeometry({
|
||||
positions,
|
||||
width,
|
||||
vertexFormat: Cesium.PolylineColorAppearance.VERTEX_FORMAT,
|
||||
}),
|
||||
attributes: {
|
||||
color: Cesium.ColorGeometryInstanceAttribute.fromColor(
|
||||
color.withAlpha(0.6),
|
||||
),
|
||||
depthFailColor: Cesium.ColorGeometryInstanceAttribute.fromColor(
|
||||
color.withAlpha(0.35),
|
||||
),
|
||||
},
|
||||
}),
|
||||
appearance: new Cesium.PolylineColorAppearance({ translucent: true }),
|
||||
depthFailAppearance: new Cesium.PolylineColorAppearance({
|
||||
translucent: true,
|
||||
}),
|
||||
asynchronous: false,
|
||||
allowPicking: false,
|
||||
});
|
||||
viewer.scene.primitives.add(primitive);
|
||||
return primitive;
|
||||
},
|
||||
commitOrbit() {},
|
||||
removeOrbit: (primitive) => viewer?.scene.primitives.remove(primitive),
|
||||
createTracked({ position, viewFrom }) {
|
||||
return viewer.entities.add({
|
||||
position: new Cesium.CallbackProperty(position, false),
|
||||
viewFrom: new Cesium.Cartesian3(viewFrom.x, viewFrom.y, viewFrom.z),
|
||||
trackingReferenceFrame: Cesium.TrackingReferenceFrame.ENU,
|
||||
point: {
|
||||
pixelSize: 14,
|
||||
color: Cesium.Color.YELLOW,
|
||||
outlineColor: Cesium.Color.WHITE,
|
||||
outlineWidth: 2,
|
||||
disableDepthTestDistance: Number.POSITIVE_INFINITY,
|
||||
},
|
||||
});
|
||||
},
|
||||
trackedPosition: (entity) =>
|
||||
entity?.position?.getValue(viewer.clock.currentTime),
|
||||
removeTracked: (entity) => viewer?.entities.remove(entity),
|
||||
follow: {
|
||||
start: (entity) => {
|
||||
starting = entity;
|
||||
try {
|
||||
if (engine) {
|
||||
engine.camera.follow({
|
||||
native: entity,
|
||||
position: () =>
|
||||
entity.position.getValue(viewer.clock.currentTime),
|
||||
viewFrom: () =>
|
||||
entity.viewFrom.getValue(viewer.clock.currentTime),
|
||||
});
|
||||
} else {
|
||||
viewer.camera?.cancelFlight();
|
||||
viewer.trackedEntity = entity;
|
||||
}
|
||||
} finally {
|
||||
starting = null;
|
||||
}
|
||||
},
|
||||
release: () => {
|
||||
releasing = true;
|
||||
try {
|
||||
const current = engine?.camera.following();
|
||||
if (current && current.native === viewer?.trackedEntity)
|
||||
current.stop();
|
||||
else if (viewer) viewer.trackedEntity = undefined;
|
||||
} finally {
|
||||
releasing = false;
|
||||
}
|
||||
},
|
||||
current: () => starting ?? viewer?.trackedEntity,
|
||||
releasing: () => releasing,
|
||||
onChanged: (listener) =>
|
||||
viewer.trackedEntityChanged.addEventListener(listener),
|
||||
},
|
||||
listenClick(listener, { enabled = () => true } = {}) {
|
||||
const handler = new Cesium.ScreenSpaceEventHandler(viewer.scene.canvas);
|
||||
handler.setInputAction((click) => {
|
||||
if (!isPointerFree()) return;
|
||||
if (!enabled()) return;
|
||||
listener({
|
||||
picked: viewer.scene.pick(click.position),
|
||||
position: click.position,
|
||||
});
|
||||
}, Cesium.ScreenSpaceEventType.LEFT_CLICK);
|
||||
return { destroy: () => handler.destroy() };
|
||||
},
|
||||
pickedNorad: (picked) => Number(picked?.primitive?.id),
|
||||
isTrackedPick: (picked, entity) => Boolean(entity && picked?.id === entity),
|
||||
destroy() {},
|
||||
};
|
||||
}
|
||||
@@ -1,120 +0,0 @@
|
||||
import test from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import * as Cesium from 'cesium';
|
||||
import * as geo from '../../../geo/index.js';
|
||||
import { createSatellitesCesiumRenderer } from './cesium.js';
|
||||
|
||||
test('native satellite viewFrom fills the scratch vector used by EntityView', () => {
|
||||
const viewer = { entities: new Cesium.EntityCollection() };
|
||||
const renderer = createSatellitesCesiumRenderer(null, { viewer });
|
||||
const viewFrom = geo.cartesian3.create(-450000, -450000, 350000);
|
||||
const entity = renderer.createTracked({
|
||||
position: () => geo.cartesian3.fromDegrees(0, 0, 420000),
|
||||
viewFrom,
|
||||
});
|
||||
assert.equal(
|
||||
entity.trackingReferenceFrame,
|
||||
Cesium.TrackingReferenceFrame.ENU,
|
||||
);
|
||||
const scratch = new Cesium.Cartesian3();
|
||||
const value = entity.viewFrom.getValue(Cesium.JulianDate.now(), scratch);
|
||||
assert.equal(value, scratch);
|
||||
assert.deepEqual(
|
||||
[scratch.x, scratch.y, scratch.z],
|
||||
[viewFrom.x, viewFrom.y, viewFrom.z],
|
||||
);
|
||||
renderer.removeTracked(entity);
|
||||
assert.equal(viewer.entities.values.length, 0);
|
||||
});
|
||||
|
||||
test('native satellite follow goes through the shared camera contract', () => {
|
||||
let options;
|
||||
const viewer = {
|
||||
entities: new Cesium.EntityCollection(),
|
||||
clock: { currentTime: Cesium.JulianDate.now() },
|
||||
};
|
||||
const engine = {
|
||||
camera: {
|
||||
follow: (spec) => {
|
||||
options = spec;
|
||||
},
|
||||
},
|
||||
};
|
||||
const renderer = createSatellitesCesiumRenderer(engine, { viewer });
|
||||
const position = geo.cartesian3.fromDegrees(0, 0, 20200000);
|
||||
const offset = geo.cartesian3.create(-1800000, -1800000, 1400000);
|
||||
const entity = renderer.createTracked({
|
||||
position: () => position,
|
||||
viewFrom: offset,
|
||||
});
|
||||
renderer.follow.start(entity);
|
||||
assert.equal(options.native, entity);
|
||||
assert.equal(options.position(), position);
|
||||
assert.deepEqual({ ...options.viewFrom() }, { ...offset });
|
||||
});
|
||||
|
||||
test('native own follow release is guarded without hiding later external release', () => {
|
||||
const event = new Cesium.Event();
|
||||
let entity = { id: 'satellite' };
|
||||
const viewer = {
|
||||
trackedEntityChanged: event,
|
||||
get trackedEntity() {
|
||||
return entity;
|
||||
},
|
||||
set trackedEntity(value) {
|
||||
entity = value;
|
||||
event.raiseEvent(value);
|
||||
},
|
||||
};
|
||||
const renderer = createSatellitesCesiumRenderer(null, { viewer });
|
||||
const guards = [];
|
||||
renderer.follow.onChanged(() => guards.push(renderer.follow.releasing()));
|
||||
renderer.follow.release();
|
||||
viewer.trackedEntity = { id: 'other' };
|
||||
viewer.trackedEntity = undefined;
|
||||
assert.deepEqual(guards, [true, false, false]);
|
||||
assert.equal(renderer.follow.releasing(), false);
|
||||
});
|
||||
|
||||
test('native follow takeover reports its starting entity through an intermediate null', () => {
|
||||
const event = new Cesium.Event();
|
||||
let current = { id: 'foreign' };
|
||||
const viewer = {
|
||||
clock: { currentTime: Cesium.JulianDate.now() },
|
||||
trackedEntityChanged: event,
|
||||
get trackedEntity() {
|
||||
return current;
|
||||
},
|
||||
set trackedEntity(v) {
|
||||
current = v;
|
||||
event.raiseEvent();
|
||||
},
|
||||
};
|
||||
const engine = {
|
||||
camera: {
|
||||
follow: ({ native }) => {
|
||||
viewer.trackedEntity = undefined;
|
||||
viewer.trackedEntity = native;
|
||||
},
|
||||
},
|
||||
};
|
||||
const renderer = createSatellitesCesiumRenderer(engine, { viewer });
|
||||
const entity = {
|
||||
id: 'own',
|
||||
position: {
|
||||
getValue() {
|
||||
return geo.cartesian3.ZERO;
|
||||
},
|
||||
},
|
||||
viewFrom: {
|
||||
getValue() {
|
||||
return geo.cartesian3.ZERO;
|
||||
},
|
||||
},
|
||||
};
|
||||
const seen = [];
|
||||
renderer.follow.onChanged(() => seen.push(renderer.follow.current()));
|
||||
renderer.follow.start(entity);
|
||||
assert.deepEqual(seen, [entity, entity]);
|
||||
assert.equal(renderer.follow.current(), entity);
|
||||
});
|
||||
@@ -0,0 +1,431 @@
|
||||
// The satellites layer's display, the same on every globe engine, through
|
||||
// the engine contract only: the fleet's dots are engine.movers point banks
|
||||
// (one per look: size, outline, distance scale, depth mode), the tracked
|
||||
// satellite's dot is its own bank drawn over them, the orbit rings are
|
||||
// engine.lines turned by their model matrix (GMST), the follow is
|
||||
// engine.camera.follow and clicks come through the engine's selection
|
||||
// dispatcher. The view the logic reads (camera, scene, frame number) is the
|
||||
// shared engine layer view.
|
||||
//
|
||||
// The logic holds handles with Cesium's PointPrimitive field vocabulary
|
||||
// (position, show, pixelSize, color, outlineColor, outlineWidth,
|
||||
// scaleByDistance, disableDepthTestDistance, id); a change of look moves the
|
||||
// dot to that look's bank. The writes of a frame are committed once, at the
|
||||
// end of the frame listener that made them (or in a microtask for writes
|
||||
// outside a frame).
|
||||
|
||||
import * as geo from '../../../geo/index.js';
|
||||
import { createMoverBank } from '../../shared/render/moverBank.js';
|
||||
import { createEngineLayerView } from '../../shared/render/engineView.js';
|
||||
import { selectionDispatcherFor } from '../../../data/selectionDispatcher.js';
|
||||
import { Rgba, WHITE, constantRgba } from '../../shared/color.js';
|
||||
|
||||
const LAYER_ID = 'satellites';
|
||||
const YELLOW = constantRgba(1, 1, 0);
|
||||
// The tracked dot: 14 px yellow with a 2 px white outline, never depth-tested.
|
||||
const TRACKED_POINT = Object.freeze({
|
||||
pixelSize: 14,
|
||||
color: YELLOW,
|
||||
outlineColor: WHITE,
|
||||
outlineWidth: 2,
|
||||
disableDepthTestDistance: Number.POSITIVE_INFINITY,
|
||||
});
|
||||
// An orbit ring's alpha in front of the scene, and where the scene hides it.
|
||||
const ORBIT_ALPHA = 0.6;
|
||||
const ORBIT_OCCLUDED_ALPHA = 0.35;
|
||||
// The tracked dot draws over the fleet.
|
||||
const TRACKED_ORDER = 100;
|
||||
|
||||
const copyColor = (color) =>
|
||||
new Rgba(
|
||||
color?.red ?? 1,
|
||||
color?.green ?? 1,
|
||||
color?.blue ?? 1,
|
||||
color?.alpha ?? 1,
|
||||
);
|
||||
|
||||
const depthTestOf = (distance) =>
|
||||
distance === Number.POSITIVE_INFINITY
|
||||
? 'always'
|
||||
: distance > 0
|
||||
? { disableWithinM: distance }
|
||||
: 'normal';
|
||||
|
||||
/**
|
||||
* Registry factory (src/app/layers/renderers.js): `(engine)`.
|
||||
* @param {import('../../../globe/contract.js').GlobeEngine} engine
|
||||
*/
|
||||
export function createSatellitesDisplay(engine) {
|
||||
if (!engine?.movers || !engine?.lines)
|
||||
throw new TypeError('The satellites display needs a globe engine');
|
||||
const banks = new Map();
|
||||
const points = new Map();
|
||||
const tracked = new Set();
|
||||
const orbits = new Set();
|
||||
const dirty = new Set();
|
||||
let destroyed = false;
|
||||
let inFrame = 0;
|
||||
let queued = false;
|
||||
let visible = true;
|
||||
let sequence = 0;
|
||||
let releasing = false;
|
||||
let starting = null;
|
||||
|
||||
// --- commits: once per frame listener, or in a microtask -----------------
|
||||
const flush = () => {
|
||||
queued = false;
|
||||
for (const bank of dirty) bank.commit();
|
||||
dirty.clear();
|
||||
};
|
||||
const onCommit = (bank) => {
|
||||
dirty.add(bank);
|
||||
if (inFrame === 0 && !queued) {
|
||||
queued = true;
|
||||
queueMicrotask(flush);
|
||||
}
|
||||
};
|
||||
const inFrameDo = (run) => {
|
||||
inFrame++;
|
||||
try {
|
||||
return run();
|
||||
} finally {
|
||||
inFrame--;
|
||||
if (inFrame === 0) flush();
|
||||
}
|
||||
};
|
||||
const layerView = createEngineLayerView(engine, {
|
||||
layerId: LAYER_ID,
|
||||
wrap: inFrameDo,
|
||||
isDestroyed: () => destroyed,
|
||||
});
|
||||
|
||||
// --- the dots ----------------------------------------------------------------
|
||||
const rgba = new Float64Array(4);
|
||||
const writeColor = (color) => {
|
||||
rgba[0] = color.red;
|
||||
rgba[1] = color.green;
|
||||
rgba[2] = color.blue;
|
||||
rgba[3] = color.alpha;
|
||||
};
|
||||
const fields = {
|
||||
position: null,
|
||||
color: rgba,
|
||||
show: true,
|
||||
pickId: null,
|
||||
};
|
||||
const positionField = { position: null };
|
||||
const colorField = { color: rgba };
|
||||
const showField = { show: true };
|
||||
const write = (point, set, index) => {
|
||||
writeColor(point.values.color);
|
||||
fields.position = point.values.position;
|
||||
fields.show = point.values.show;
|
||||
fields.pickId = point.id;
|
||||
set.set(index, fields);
|
||||
};
|
||||
// One bank per family (fleet, tracked) and look.
|
||||
const bankFor = (point) => {
|
||||
const v = point.values;
|
||||
const scale = v.scaleByDistance;
|
||||
const outline = v.outlineColor;
|
||||
const key = [
|
||||
point.family,
|
||||
v.pixelSize,
|
||||
v.outlineWidth,
|
||||
outline.red,
|
||||
outline.green,
|
||||
outline.blue,
|
||||
outline.alpha,
|
||||
...(scale
|
||||
? [scale.near, scale.nearValue, scale.far, scale.farValue]
|
||||
: ['none']),
|
||||
v.disableDepthTestDistance,
|
||||
].join(':');
|
||||
let entry = banks.get(key);
|
||||
if (!entry) {
|
||||
const id = ++sequence;
|
||||
const bank = createMoverBank(engine, {
|
||||
options: (capacity, generation) => ({
|
||||
id: `${LAYER_ID}-points-${id}-${generation}`,
|
||||
kind: 'point',
|
||||
capacity,
|
||||
pickable: true,
|
||||
depthTest: depthTestOf(v.disableDepthTestDistance),
|
||||
order: point.family === 'tracked' ? TRACKED_ORDER : 0,
|
||||
point: {
|
||||
sizePx: v.pixelSize,
|
||||
outlinePx: v.outlineWidth,
|
||||
outlineColor: [
|
||||
outline.red,
|
||||
outline.green,
|
||||
outline.blue,
|
||||
outline.alpha,
|
||||
],
|
||||
scaleByDistance: scale
|
||||
? [scale.near, scale.nearValue, scale.far, scale.farValue]
|
||||
: undefined,
|
||||
},
|
||||
}),
|
||||
write,
|
||||
onCommit,
|
||||
});
|
||||
entry = { bank, family: point.family };
|
||||
banks.set(key, entry);
|
||||
bank.setVisible(point.family === 'tracked' || visible);
|
||||
}
|
||||
return entry.bank;
|
||||
};
|
||||
const LOOK = [
|
||||
'pixelSize',
|
||||
'outlineWidth',
|
||||
'outlineColor',
|
||||
'scaleByDistance',
|
||||
'disableDepthTestDistance',
|
||||
];
|
||||
const createPoint = (spec, family = 'fleet') => {
|
||||
const point = {
|
||||
id: spec.id,
|
||||
family,
|
||||
gevBank: null,
|
||||
gevIndex: -1,
|
||||
values: {
|
||||
position: geo.cartesian3.clone(spec.position ?? geo.cartesian3.ZERO),
|
||||
color: copyColor(spec.color ?? WHITE),
|
||||
show: spec.show !== false,
|
||||
pixelSize: spec.pixelSize ?? 1,
|
||||
outlineColor: copyColor(spec.outlineColor ?? WHITE),
|
||||
outlineWidth: spec.outlineWidth ?? 0,
|
||||
scaleByDistance: spec.scaleByDistance ?? null,
|
||||
disableDepthTestDistance: spec.disableDepthTestDistance ?? 0,
|
||||
},
|
||||
};
|
||||
Object.defineProperties(point, {
|
||||
position: {
|
||||
get: () => point.values.position,
|
||||
set(value) {
|
||||
geo.cartesian3.clone(value, point.values.position);
|
||||
positionField.position = point.values.position;
|
||||
point.gevBank?.update(point, positionField);
|
||||
},
|
||||
},
|
||||
color: {
|
||||
get: () => point.values.color,
|
||||
set(value) {
|
||||
point.values.color = copyColor(value);
|
||||
writeColor(point.values.color);
|
||||
point.gevBank?.update(point, colorField);
|
||||
},
|
||||
},
|
||||
show: {
|
||||
get: () => point.values.show,
|
||||
set(value) {
|
||||
if (point.values.show === Boolean(value)) return;
|
||||
point.values.show = Boolean(value);
|
||||
showField.show = point.values.show;
|
||||
point.gevBank?.update(point, showField);
|
||||
},
|
||||
},
|
||||
});
|
||||
for (const key of LOOK)
|
||||
Object.defineProperty(point, key, {
|
||||
get: () => point.values[key],
|
||||
set(value) {
|
||||
const next = key === 'outlineColor' ? copyColor(value) : value;
|
||||
const current = point.values[key];
|
||||
if (
|
||||
current === value ||
|
||||
(key === 'outlineColor' && current.equals(next))
|
||||
)
|
||||
return;
|
||||
point.values[key] = next;
|
||||
// Another look is another bank.
|
||||
if (point.gevBank) bankFor(point).add(point);
|
||||
},
|
||||
});
|
||||
bankFor(point).add(point);
|
||||
return point;
|
||||
};
|
||||
const collection = {
|
||||
get show() {
|
||||
return visible;
|
||||
},
|
||||
set show(value) {
|
||||
visible = Boolean(value);
|
||||
for (const entry of banks.values())
|
||||
if (entry.family === 'fleet') entry.bank.setVisible(visible);
|
||||
},
|
||||
add(spec) {
|
||||
const point = createPoint(spec);
|
||||
points.set(point.id, point);
|
||||
return point;
|
||||
},
|
||||
remove(point) {
|
||||
if (!point || points.get(point.id) !== point) return false;
|
||||
points.delete(point.id);
|
||||
point.gevBank?.remove(point);
|
||||
return true;
|
||||
},
|
||||
removeAll() {
|
||||
for (const point of points.values()) point.gevBank?.remove(point);
|
||||
points.clear();
|
||||
},
|
||||
};
|
||||
|
||||
// --- follow ------------------------------------------------------------------
|
||||
const follow = {
|
||||
start(handle) {
|
||||
const outer = starting;
|
||||
starting = handle;
|
||||
try {
|
||||
handle.gevFollowHandle = engine.camera.follow({
|
||||
native: handle,
|
||||
position: handle.sample,
|
||||
viewFrom: () => handle.viewFrom,
|
||||
// The tracked readout's card as plain data (the handle's
|
||||
// annotation fields, read when the card paints).
|
||||
label:
|
||||
typeof handle.gevTrackedId === 'string'
|
||||
? {
|
||||
id: handle.gevTrackedId,
|
||||
model: () => handle.gevLabelModel,
|
||||
position: () =>
|
||||
handle.gevDisplayPosition?.() ?? handle.sample(),
|
||||
}
|
||||
: undefined,
|
||||
});
|
||||
} finally {
|
||||
starting = outer;
|
||||
}
|
||||
},
|
||||
release() {
|
||||
releasing = true;
|
||||
try {
|
||||
engine.camera.following()?.stop();
|
||||
} finally {
|
||||
releasing = false;
|
||||
}
|
||||
},
|
||||
releasing: () => releasing,
|
||||
// What is followed: this layer's tracked handle, else what the follow is
|
||||
// of (another layer's handle or entity), else the follow itself.
|
||||
current() {
|
||||
if (starting) return starting;
|
||||
const current = engine.camera.following();
|
||||
if (!current) return null;
|
||||
for (const handle of tracked)
|
||||
if (handle.gevFollowHandle === current) return handle;
|
||||
return current.native ?? current;
|
||||
},
|
||||
onChanged: (listener) =>
|
||||
engine.camera.followChanged.addEventListener(listener),
|
||||
};
|
||||
|
||||
return {
|
||||
engine,
|
||||
view: layerView.view,
|
||||
createPoints: () => collection,
|
||||
removePoints: () => collection.removeAll(),
|
||||
project: (position, result) =>
|
||||
engine.projector.worldToWindow(position, result),
|
||||
// Each frame (before drawing): the listener, then the tracked dots read
|
||||
// their position (the frame's sample).
|
||||
onFrame: (listener) =>
|
||||
layerView.view.on('preRender', () => {
|
||||
listener();
|
||||
for (const handle of tracked) {
|
||||
const position = handle.sample();
|
||||
if (position) handle.point.position = position;
|
||||
}
|
||||
}),
|
||||
/** An orbit ring at identity; `commitOrbit` applies its modelMatrix. */
|
||||
createOrbit({ positions, width, color }) {
|
||||
const line = engine.lines.createLine({
|
||||
id: `${LAYER_ID}-orbit-${++sequence}`,
|
||||
widthPx: width,
|
||||
color: [color.red, color.green, color.blue, ORBIT_ALPHA],
|
||||
depthFailAlpha: ORBIT_OCCLUDED_ALPHA / ORBIT_ALPHA,
|
||||
arc: 'geodesic',
|
||||
});
|
||||
line.setPositions(positions);
|
||||
let shown = true;
|
||||
const orbit = {
|
||||
line,
|
||||
modelMatrix: geo.matrix4.clone(geo.matrix4.IDENTITY),
|
||||
get show() {
|
||||
return shown;
|
||||
},
|
||||
set show(value) {
|
||||
shown = Boolean(value);
|
||||
line.show(shown);
|
||||
},
|
||||
};
|
||||
orbits.add(orbit);
|
||||
return orbit;
|
||||
},
|
||||
commitOrbit(orbit) {
|
||||
if (orbits.has(orbit)) orbit.line.setModelMatrix(orbit.modelMatrix);
|
||||
},
|
||||
removeOrbit(orbit) {
|
||||
if (!orbit || !orbits.delete(orbit)) return;
|
||||
orbit.line.destroy();
|
||||
},
|
||||
/**
|
||||
* The tracked satellite: its dot over the fleet, followed by
|
||||
* follow.start. `position()` is read each frame.
|
||||
*/
|
||||
createTracked({ id, position, viewFrom }) {
|
||||
const handle = {
|
||||
id: `${LAYER_ID}:${id}`,
|
||||
sample: position,
|
||||
viewFrom,
|
||||
gevFollowHandle: null,
|
||||
position: { getValue: () => position() },
|
||||
point: createPoint(
|
||||
{ id, position: position(), ...TRACKED_POINT },
|
||||
'tracked',
|
||||
),
|
||||
};
|
||||
tracked.add(handle);
|
||||
return handle;
|
||||
},
|
||||
trackedPosition: (handle) => handle?.sample() ?? undefined,
|
||||
removeTracked(handle) {
|
||||
if (!handle || !tracked.delete(handle)) return;
|
||||
handle.point.gevBank?.remove(handle.point);
|
||||
if (
|
||||
handle.gevFollowHandle &&
|
||||
engine.camera.following() === handle.gevFollowHandle
|
||||
)
|
||||
follow.release();
|
||||
},
|
||||
follow,
|
||||
/** Every click with its top pick (the old LEFT_CLICK rule). */
|
||||
listenClick(listener) {
|
||||
const dispatcher = selectionDispatcherFor(engine);
|
||||
const remove = dispatcher.register(LAYER_ID, {
|
||||
owns: (id) => points.has(Number(id)),
|
||||
onClick: listener,
|
||||
});
|
||||
return { destroy: remove };
|
||||
},
|
||||
pickedNorad: (picked) => Number(picked?.id ?? picked?.primitive?.id),
|
||||
isTrackedPick: (picked, handle) =>
|
||||
Boolean(
|
||||
handle &&
|
||||
Number(picked?.id ?? picked?.primitive?.id) === handle.point.id,
|
||||
),
|
||||
destroy() {
|
||||
if (destroyed) return;
|
||||
flush();
|
||||
destroyed = true;
|
||||
for (const orbit of orbits) orbit.line.destroy();
|
||||
orbits.clear();
|
||||
for (const entry of banks.values()) entry.bank.destroy();
|
||||
banks.clear();
|
||||
dirty.clear();
|
||||
points.clear();
|
||||
tracked.clear();
|
||||
layerView.destroy();
|
||||
},
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,434 @@
|
||||
// The satellites display on the engine contract, on the fake engine and on
|
||||
// the Cesium engine (real Cesium point collections and polylines over a stub
|
||||
// scene: they draw nothing but hold what the engine writes): the fleet's
|
||||
// point banks and their looks, writes committed once per frame, the tracked
|
||||
// dot over the fleet, the follow (its target, offset, readout label and
|
||||
// release guard), the orbit rings turned by their model matrix, clicks and
|
||||
// teardown.
|
||||
|
||||
import test from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import * as Cesium from 'cesium';
|
||||
import * as geo from '../../../geo/index.js';
|
||||
import { createFakeEngine } from '../../../globe/testing/fakeEngine.js';
|
||||
import { createCesiumMoversEngine } from '../../../testSupport/cesiumMoversEngine.mjs';
|
||||
import { CYAN, WHITE, nearFarScale } from '../../shared/color.js';
|
||||
import { createSatellitesDisplay } from './display.js';
|
||||
|
||||
const settle = () => new Promise((resolve) => setTimeout(resolve, 0));
|
||||
const position = geo.cartesian3.fromDegrees(0, 0, 420000);
|
||||
const SCALE = nearFarScale(1e6, 1.5, 2e7, 0.6);
|
||||
const spec = (id, overrides = {}) => ({
|
||||
id,
|
||||
position,
|
||||
color: WHITE,
|
||||
pixelSize: 12,
|
||||
outlineColor: WHITE.withAlpha(0.3),
|
||||
outlineWidth: 1,
|
||||
scaleByDistance: SCALE,
|
||||
...overrides,
|
||||
});
|
||||
const near = (actual, expected, label, tolerance = 1e-6) =>
|
||||
assert.ok(
|
||||
Math.abs(actual - expected) < tolerance,
|
||||
`${label}: ${actual} vs ${expected}`,
|
||||
);
|
||||
|
||||
function fakeHarness() {
|
||||
const engine = createFakeEngine();
|
||||
return {
|
||||
name: 'the fake engine',
|
||||
engine,
|
||||
frame: () => engine.fake.frame(),
|
||||
destroy: () => engine.destroy(),
|
||||
};
|
||||
}
|
||||
|
||||
function cesiumHarness() {
|
||||
const { engine, ...rest } = createCesiumMoversEngine();
|
||||
return {
|
||||
name: 'the Cesium engine',
|
||||
cesium: true,
|
||||
engine,
|
||||
...rest,
|
||||
destroy: () => engine.destroy(),
|
||||
};
|
||||
}
|
||||
|
||||
const HARNESSES = [fakeHarness, cesiumHarness];
|
||||
|
||||
function setup(makeHarness) {
|
||||
const harness = makeHarness();
|
||||
harness.engine.camera.setView({
|
||||
destination: geo.cartesian3.fromDegrees(0, 0, 2e7),
|
||||
});
|
||||
return { ...harness, display: createSatellitesDisplay(harness.engine) };
|
||||
}
|
||||
|
||||
const setsOf = (engine) =>
|
||||
engine.movers.list().filter(({ id }) => id.startsWith('satellites-points'));
|
||||
|
||||
/** What a set's instance draws: its size, outline, depth mode and colour. */
|
||||
function drawn(h, setId, index) {
|
||||
if (h.cesium) {
|
||||
const item = h.primitive(setId).get(index);
|
||||
return {
|
||||
position: item.position,
|
||||
pixelSize: item.pixelSize,
|
||||
outlineWidth: item.outlineWidth,
|
||||
outline: item.outlineColor,
|
||||
depth: item.disableDepthTestDistance,
|
||||
scale: item.scaleByDistance,
|
||||
color: item.color,
|
||||
show: item.show,
|
||||
id: item.id,
|
||||
};
|
||||
}
|
||||
const { options, store } = h.engine.fake.moverSet(setId);
|
||||
const [r, g, b, a] = store.colors.slice(index * 4, index * 4 + 4);
|
||||
const [nearM, nearValue, farM, farValue] =
|
||||
options.point.scaleByDistance ?? [];
|
||||
return {
|
||||
position: {
|
||||
x: store.positions[index * 3],
|
||||
y: store.positions[index * 3 + 1],
|
||||
z: store.positions[index * 3 + 2],
|
||||
},
|
||||
pixelSize: options.point.sizePx * store.scales[index],
|
||||
outlineWidth: options.point.outlinePx,
|
||||
outline: {
|
||||
red: options.point.outlineColor[0],
|
||||
alpha: options.point.outlineColor[3],
|
||||
},
|
||||
depth:
|
||||
options.depthTest === 'always'
|
||||
? Number.POSITIVE_INFINITY
|
||||
: options.depthTest === 'normal'
|
||||
? 0
|
||||
: options.depthTest.disableWithinM,
|
||||
scale: { near: nearM, nearValue, far: farM, farValue },
|
||||
color: { red: r, green: g, blue: b, alpha: a },
|
||||
show: store.shows[index] === 1,
|
||||
id: store.pickIds[index],
|
||||
};
|
||||
}
|
||||
|
||||
test('the display needs a globe engine', () => {
|
||||
assert.throws(() => createSatellitesDisplay(null), TypeError);
|
||||
});
|
||||
|
||||
for (const makeHarness of HARNESSES) {
|
||||
const { name } = makeHarness();
|
||||
|
||||
test(`fleet dots draw as the layer asked, in banks that survive growth, written once per frame (${name})`, async () => {
|
||||
const h = setup(makeHarness);
|
||||
const { engine, display } = h;
|
||||
const points = display.createPoints();
|
||||
const all = Array.from({ length: 1500 }, (_, i) => points.add(spec(i)));
|
||||
await settle();
|
||||
const [listed] = setsOf(engine);
|
||||
assert.equal(setsOf(engine).length, 1);
|
||||
assert.equal(listed.count, 1500);
|
||||
let dot = drawn(h, listed.id, 699);
|
||||
assert.equal(dot.id, 699);
|
||||
assert.equal(dot.pixelSize, 12);
|
||||
assert.equal(dot.outlineWidth, 1);
|
||||
near(dot.outline.alpha, 0.3, 'outline alpha');
|
||||
assert.equal(dot.depth, 0, 'fleet dots are depth-tested');
|
||||
assert.equal(dot.scale.near, 1e6);
|
||||
assert.equal(dot.scale.nearValue, 1.5);
|
||||
assert.equal(dot.scale.far, 2e7);
|
||||
assert.equal(dot.scale.farValue, 0.6);
|
||||
assert.equal(dot.show, true);
|
||||
// Reads are the display's own copies.
|
||||
assert.notEqual(all[0].color, WHITE);
|
||||
assert.equal(all[0].color.alpha, 1);
|
||||
const commits = h.cesium
|
||||
? null
|
||||
: () => engine.fake.moverSet(listed.id).commits;
|
||||
const before = commits?.();
|
||||
const remove = display.onFrame(() => {
|
||||
all[0].position = { x: 1, y: 2, z: 3 };
|
||||
all[0].show = false;
|
||||
all[0].color = CYAN.withAlpha(0.25);
|
||||
});
|
||||
h.frame();
|
||||
remove();
|
||||
if (commits) assert.equal(commits(), before + 1, 'one commit per frame');
|
||||
dot = drawn(h, listed.id, 0);
|
||||
assert.deepEqual(
|
||||
[dot.position.x, dot.position.y, dot.position.z],
|
||||
[1, 2, 3],
|
||||
);
|
||||
assert.equal(dot.show, false);
|
||||
near(dot.color.alpha, 0.25, 'alpha');
|
||||
assert.equal(all[0].color.alpha, 0.25);
|
||||
// Another look is another bank.
|
||||
all[1].pixelSize = 14;
|
||||
await settle();
|
||||
assert.equal(setsOf(engine).length, 2);
|
||||
assert.equal(setsOf(engine)[0].count, 1499);
|
||||
assert.equal(all[1].pixelSize, 14);
|
||||
// A removed dot leaves; the look it had no longer matters.
|
||||
assert.equal(points.remove(all[2]), true);
|
||||
assert.equal(points.remove(all[2]), false);
|
||||
all[2].pixelSize = 16;
|
||||
await settle();
|
||||
assert.equal(setsOf(engine).length, 2);
|
||||
// Hiding the fleet hides its banks.
|
||||
points.show = false;
|
||||
await settle();
|
||||
assert.equal(points.show, false);
|
||||
assert.ok(setsOf(engine).every(({ count }) => count === 0));
|
||||
points.show = true;
|
||||
points.removeAll();
|
||||
await settle();
|
||||
assert.ok(setsOf(engine).every(({ count }) => count === 0));
|
||||
display.destroy();
|
||||
assert.equal(engine.movers.list().length, 0, 'no set left behind');
|
||||
h.destroy();
|
||||
});
|
||||
|
||||
test(`the tracked dot draws over the fleet at its follow's sample, whatever the fleet's visibility (${name})`, async () => {
|
||||
const h = setup(makeHarness);
|
||||
const { engine, display } = h;
|
||||
const points = display.createPoints();
|
||||
const fleetDot = points.add(spec(25544));
|
||||
fleetDot.show = false;
|
||||
let sample = position;
|
||||
const handle = display.createTracked({
|
||||
id: 25544,
|
||||
position: () => sample,
|
||||
viewFrom: { x: -450000, y: -450000, z: 350000 },
|
||||
});
|
||||
assert.equal(handle.id, 'satellites:25544');
|
||||
points.show = false;
|
||||
const remove = display.onFrame(() => {});
|
||||
sample = { x: position.x + 7600, y: 100, z: 0 };
|
||||
h.frame();
|
||||
remove();
|
||||
await settle();
|
||||
assert.deepEqual({ ...handle.point.position }, sample);
|
||||
assert.deepEqual({ ...display.trackedPosition(handle) }, sample);
|
||||
const tracked = setsOf(engine).find(
|
||||
({ id, count }) => count > 0 && drawn(h, id, 0).pixelSize === 14,
|
||||
);
|
||||
assert.ok(tracked, 'the tracked bank');
|
||||
const dot = drawn(h, tracked.id, 0);
|
||||
assert.equal(dot.show, true);
|
||||
assert.equal(dot.pixelSize, 14);
|
||||
assert.equal(dot.outlineWidth, 2);
|
||||
assert.equal(dot.outline.red, 1);
|
||||
assert.equal(dot.depth, Number.POSITIVE_INFINITY, 'never depth-tested');
|
||||
assert.deepEqual(
|
||||
[dot.color.red, dot.color.green, dot.color.blue],
|
||||
[1, 1, 0],
|
||||
'yellow',
|
||||
);
|
||||
assert.equal(dot.id, 25544);
|
||||
if (!h.cesium)
|
||||
assert.equal(engine.fake.moverSet(tracked.id).options.order, 100);
|
||||
assert.ok(
|
||||
setsOf(engine)
|
||||
.filter(({ id }) => id !== tracked.id)
|
||||
.every(({ count }) => count === 0),
|
||||
'the fleet is hidden',
|
||||
);
|
||||
display.removeTracked(handle);
|
||||
await settle();
|
||||
assert.equal(
|
||||
engine.movers.list().find(({ id }) => id === tracked.id).count,
|
||||
0,
|
||||
);
|
||||
display.destroy();
|
||||
h.destroy();
|
||||
});
|
||||
|
||||
test(`the follow centres the tracked satellite from its offset in the east-north-up frame and carries its readout label (${name})`, async () => {
|
||||
const h = setup(makeHarness);
|
||||
const { engine, display } = h;
|
||||
display.createPoints().add(spec(25544));
|
||||
const target = geo.cartesian3.fromDegrees(0, 0, 20200000);
|
||||
const offset = geo.cartesian3.create(-1800000, -1800000, 1400000);
|
||||
const handle = display.createTracked({
|
||||
id: 25544,
|
||||
position: () => target,
|
||||
viewFrom: offset,
|
||||
});
|
||||
handle.gevTrackedId = 'satellites:25544';
|
||||
handle.gevSelectionOrigin = 'user';
|
||||
handle.gevLabelModel = { title: 'ISS', details: [] };
|
||||
handle.gevDisplayPosition = () => target;
|
||||
const seen = [];
|
||||
const removeListener = display.follow.onChanged(() =>
|
||||
seen.push(display.follow.current()),
|
||||
);
|
||||
display.follow.start(handle);
|
||||
// Every change the start raises reads the satellite being followed.
|
||||
assert.ok(seen.length >= 1);
|
||||
assert.ok(seen.every((current) => current === handle));
|
||||
const following = engine.camera.following();
|
||||
assert.equal(following, handle.gevFollowHandle);
|
||||
assert.equal(following.native, handle);
|
||||
assert.equal(following.label.id, 'satellites:25544');
|
||||
assert.equal(following.label.model(), handle.gevLabelModel);
|
||||
assert.equal(following.label.position(), target);
|
||||
assert.equal(display.follow.current(), handle);
|
||||
assert.equal(following.target(), target);
|
||||
if (h.cesium) {
|
||||
const proxy = h.viewer.trackedEntity;
|
||||
assert.ok(proxy instanceof Cesium.Entity);
|
||||
assert.equal(
|
||||
proxy.trackingReferenceFrame,
|
||||
Cesium.TrackingReferenceFrame.ENU,
|
||||
);
|
||||
assert.equal(proxy.gevTrackedId, 'satellites:25544');
|
||||
assert.equal(proxy.gevSelectionOrigin, 'user');
|
||||
const scratch = new Cesium.Cartesian3();
|
||||
const value = proxy.viewFrom.getValue(
|
||||
h.viewer.clock.currentTime,
|
||||
scratch,
|
||||
);
|
||||
assert.deepEqual(
|
||||
[value.x, value.y, value.z],
|
||||
[offset.x, offset.y, offset.z],
|
||||
);
|
||||
}
|
||||
// The display's own release is guarded; a later external change is not.
|
||||
seen.length = 0;
|
||||
const guards = [];
|
||||
const removeGuard = display.follow.onChanged(() =>
|
||||
guards.push(display.follow.releasing()),
|
||||
);
|
||||
display.follow.release();
|
||||
assert.equal(engine.camera.following(), null);
|
||||
assert.equal(display.follow.current(), null);
|
||||
assert.ok(guards.length >= 1);
|
||||
assert.ok(guards.every(Boolean), 'own release');
|
||||
guards.length = 0;
|
||||
const other = { id: 'other', gevSelectionOrigin: 'programmatic' };
|
||||
const foreign = engine.camera.follow({
|
||||
native: other,
|
||||
position: () => target,
|
||||
viewFrom: { x: 0, y: -100, z: 100 },
|
||||
});
|
||||
assert.equal(display.follow.current(), other, "another layer's target");
|
||||
foreign.stop();
|
||||
assert.ok(guards.length >= 1);
|
||||
assert.ok(
|
||||
guards.every((guard) => guard === false),
|
||||
'external changes',
|
||||
);
|
||||
assert.equal(display.follow.releasing(), false);
|
||||
removeGuard();
|
||||
removeListener();
|
||||
// Removing the followed satellite ends its follow.
|
||||
display.follow.start(handle);
|
||||
display.removeTracked(handle);
|
||||
assert.equal(engine.camera.following(), null);
|
||||
if (h.cesium) assert.equal(h.viewer.trackedEntity, undefined);
|
||||
display.destroy();
|
||||
h.destroy();
|
||||
});
|
||||
|
||||
test(`orbit rings start at identity, turn by their model matrix without a rebuild, dim behind the globe and leave (${name})`, () => {
|
||||
const h = setup(makeHarness);
|
||||
const { engine, display } = h;
|
||||
const ring = [position, { x: 0, y: 6778137, z: 0 }];
|
||||
const orbit = display.createOrbit({
|
||||
positions: ring,
|
||||
width: 2.5,
|
||||
color: CYAN,
|
||||
});
|
||||
assert.deepEqual(orbit.modelMatrix, geo.matrix4.IDENTITY);
|
||||
const [before] = engine.lines.list();
|
||||
assert.equal(before.points, 2);
|
||||
if (h.cesium) {
|
||||
const primitive = h.primitive(before.id);
|
||||
assert.equal(primitive.allowPicking, false, 'rings are not picked');
|
||||
assert.equal(
|
||||
primitive.geometryInstances.geometry._arcType,
|
||||
Cesium.ArcType.GEODESIC,
|
||||
);
|
||||
assert.equal(primitive.geometryInstances.geometry._width, 2.5);
|
||||
near(primitive.appearance.material.uniforms.color.alpha, 0.6, 'alpha');
|
||||
near(
|
||||
primitive.depthFailAppearance.material.uniforms.color.alpha,
|
||||
0.35,
|
||||
'occluded alpha',
|
||||
);
|
||||
assert.equal(primitive.appearance.material.uniforms.color.red, 0);
|
||||
} else {
|
||||
const { options } = engine.fake.line(before.id);
|
||||
assert.equal(options.widthPx, 2.5);
|
||||
assert.equal(options.arc, 'geodesic');
|
||||
assert.equal(options.pickId, undefined, 'rings are not picked');
|
||||
near(options.color[3], 0.6, 'alpha');
|
||||
near(options.color[3] * options.depthFailAlpha, 0.35, 'occluded alpha');
|
||||
}
|
||||
orbit.modelMatrix[12] = 123;
|
||||
display.commitOrbit(orbit);
|
||||
assert.equal(engine.lines.list()[0].id, before.id, 'the same line');
|
||||
if (h.cesium) assert.equal(h.primitive(before.id).modelMatrix[12], 123);
|
||||
else assert.equal(engine.fake.line(before.id).modelMatrix[12], 123);
|
||||
orbit.show = false;
|
||||
assert.equal(orbit.show, false);
|
||||
assert.equal(engine.lines.list()[0].shown, false);
|
||||
// A ring that is not the display's is left alone.
|
||||
display.commitOrbit({ show: true, modelMatrix: geo.matrix4.create() });
|
||||
display.removeOrbit({ show: true });
|
||||
assert.equal(engine.lines.list().length, 1);
|
||||
display.removeOrbit(orbit);
|
||||
assert.equal(engine.lines.list().length, 0);
|
||||
display.createOrbit({ positions: ring, width: 2, color: CYAN });
|
||||
display.destroy();
|
||||
assert.equal(engine.lines.list().length, 0, 'the display releases rings');
|
||||
h.destroy();
|
||||
});
|
||||
|
||||
test(`the view reads the engine's camera and frames (${name})`, () => {
|
||||
const h = setup(makeHarness);
|
||||
const { display } = h;
|
||||
const frame = display.view.frameNumber();
|
||||
h.frame();
|
||||
assert.equal(display.view.frameNumber(), frame + 1);
|
||||
near(display.view.camera.positionCartographic.height, 2e7, 'height', 1);
|
||||
const screen = display.project(geo.cartesian3.fromDegrees(0, 0, 0));
|
||||
assert.ok(Number.isFinite(screen.x) && Number.isFinite(screen.y));
|
||||
display.destroy();
|
||||
h.destroy();
|
||||
});
|
||||
}
|
||||
|
||||
test('a click comes with its top pick; picks name the NORAD id and the tracked dot (the fake engine)', async () => {
|
||||
const previousDocument = globalThis.document;
|
||||
globalThis.document = new EventTarget();
|
||||
try {
|
||||
const engine = createFakeEngine();
|
||||
const display = createSatellitesDisplay(engine);
|
||||
display.createPoints().add(spec(25544));
|
||||
const clicks = [];
|
||||
const handler = display.listenClick((ctx) => clicks.push(ctx));
|
||||
engine.fake.script('pick', () => ({ id: 25544 }));
|
||||
engine.fake.input('click', { position: { x: 10, y: 10 } });
|
||||
assert.equal(clicks.length, 1);
|
||||
assert.equal(display.pickedNorad(clicks[0].picked), 25544);
|
||||
const handle = display.createTracked({
|
||||
id: 25544,
|
||||
position: () => position,
|
||||
viewFrom: { x: 0, y: 0, z: 1 },
|
||||
});
|
||||
assert.equal(display.isTrackedPick(clicks[0].picked, handle), true);
|
||||
assert.equal(display.isTrackedPick({ id: 1 }, handle), false);
|
||||
assert.equal(display.isTrackedPick(clicks[0].picked, null), false);
|
||||
assert.equal(Number.isNaN(display.pickedNorad({ id: { id: 'x' } })), true);
|
||||
handler.destroy();
|
||||
engine.fake.input('click', { position: { x: 10, y: 10 } });
|
||||
assert.equal(clicks.length, 1);
|
||||
display.destroy();
|
||||
engine.destroy();
|
||||
} finally {
|
||||
if (previousDocument === undefined) delete globalThis.document;
|
||||
else globalThis.document = previousDocument;
|
||||
}
|
||||
});
|
||||
@@ -1,355 +0,0 @@
|
||||
// Satellite points, rigid orbit rings and follow through the globe contract.
|
||||
import * as geo from '../../../geo/index.js';
|
||||
import { createMoverBank } from '../../shared/render/navaraMoverBank.js';
|
||||
import { createEngineLayerView } from '../../shared/render/engineView.js';
|
||||
import { selectionDispatcherFor } from '../../../data/selectionDispatcher.js';
|
||||
import { WHITE, constantRgba } from '../../shared/color.js';
|
||||
|
||||
const YELLOW = constantRgba(1, 1, 0);
|
||||
export function createSatellitesNavaraRenderer(engine) {
|
||||
const banks = new Map();
|
||||
const points = new Map();
|
||||
const tracked = new Set();
|
||||
const orbits = new Set();
|
||||
const dirty = new Set();
|
||||
let destroyed = false;
|
||||
let inFrame = false;
|
||||
let queued = false;
|
||||
let visible = true;
|
||||
let sequence = 0;
|
||||
let releasing = false;
|
||||
let starting = null;
|
||||
const rgba = new Float64Array(4);
|
||||
const fields = {
|
||||
position: null,
|
||||
color: rgba,
|
||||
scale: 1,
|
||||
show: true,
|
||||
pickId: null,
|
||||
};
|
||||
const positionField = { position: null };
|
||||
const colorField = { color: rgba };
|
||||
const showField = { show: true };
|
||||
const flush = () => {
|
||||
queued = false;
|
||||
for (const bank of dirty) bank.commit();
|
||||
dirty.clear();
|
||||
};
|
||||
const onCommit = (bank) => {
|
||||
dirty.add(bank);
|
||||
if (!inFrame && !queued) {
|
||||
queued = true;
|
||||
queueMicrotask(flush);
|
||||
}
|
||||
};
|
||||
const frame = (run) => {
|
||||
inFrame = true;
|
||||
try {
|
||||
return run();
|
||||
} finally {
|
||||
inFrame = false;
|
||||
flush();
|
||||
}
|
||||
};
|
||||
const layerView = createEngineLayerView(engine, {
|
||||
layerId: 'satellites',
|
||||
wrap: frame,
|
||||
isDestroyed: () => destroyed,
|
||||
});
|
||||
const copyColor = (color) => {
|
||||
rgba[0] = color.red;
|
||||
rgba[1] = color.green;
|
||||
rgba[2] = color.blue;
|
||||
rgba[3] = color.alpha;
|
||||
};
|
||||
const write = (point, set, index) => {
|
||||
copyColor(point.values.color);
|
||||
fields.position = point.values.position;
|
||||
fields.show = point.values.show;
|
||||
fields.pickId = point.id;
|
||||
set.set(index, fields);
|
||||
};
|
||||
const bankFor = (point) => {
|
||||
const v = point.values;
|
||||
const scale = v.scaleByDistance;
|
||||
const outline = v.outlineColor;
|
||||
const depth =
|
||||
v.disableDepthTestDistance === Infinity
|
||||
? 'always'
|
||||
: v.disableDepthTestDistance > 0
|
||||
? { disableWithinM: v.disableDepthTestDistance }
|
||||
: 'normal';
|
||||
const key = [
|
||||
point.family,
|
||||
v.pixelSize,
|
||||
v.outlineWidth,
|
||||
outline.red,
|
||||
outline.green,
|
||||
outline.blue,
|
||||
outline.alpha,
|
||||
...Object.values(scale ?? {}),
|
||||
v.disableDepthTestDistance,
|
||||
].join(':');
|
||||
let entry = banks.get(key);
|
||||
if (!entry) {
|
||||
const id = ++sequence;
|
||||
const bank = createMoverBank(engine, {
|
||||
options: (capacity, generation) => ({
|
||||
id: `satellites-points-${id}-${generation}`,
|
||||
kind: 'point',
|
||||
capacity,
|
||||
pickable: true,
|
||||
depthTest: depth,
|
||||
order: point.family === 'tracked' ? 100 : 0,
|
||||
point: {
|
||||
sizePx: v.pixelSize,
|
||||
outlinePx: v.outlineWidth,
|
||||
outlineColor: [
|
||||
outline.red,
|
||||
outline.green,
|
||||
outline.blue,
|
||||
outline.alpha,
|
||||
],
|
||||
scaleByDistance: scale
|
||||
? [scale.near, scale.nearValue, scale.far, scale.farValue]
|
||||
: null,
|
||||
},
|
||||
}),
|
||||
write,
|
||||
onCommit,
|
||||
});
|
||||
entry = { bank, family: point.family };
|
||||
banks.set(key, entry);
|
||||
bank.setVisible(point.family === 'tracked' || visible);
|
||||
}
|
||||
return entry.bank;
|
||||
};
|
||||
const createPoint = (spec, family = 'fleet') => {
|
||||
const point = {
|
||||
id: spec.id,
|
||||
family,
|
||||
gevBank: null,
|
||||
gevIndex: -1,
|
||||
values: {
|
||||
position: geo.cartesian3.clone(spec.position),
|
||||
color: spec.color ?? WHITE,
|
||||
show: spec.show !== false,
|
||||
pixelSize: spec.pixelSize ?? 1,
|
||||
outlineColor: spec.outlineColor ?? WHITE,
|
||||
outlineWidth: spec.outlineWidth ?? 0,
|
||||
scaleByDistance: spec.scaleByDistance ?? null,
|
||||
disableDepthTestDistance: spec.disableDepthTestDistance ?? 0,
|
||||
},
|
||||
};
|
||||
Object.defineProperties(point, {
|
||||
position: {
|
||||
get: () => point.values.position,
|
||||
set(value) {
|
||||
geo.cartesian3.clone(value, point.values.position);
|
||||
positionField.position = point.values.position;
|
||||
point.gevBank?.update(point, positionField);
|
||||
},
|
||||
},
|
||||
color: {
|
||||
get: () => point.values.color,
|
||||
set(value) {
|
||||
point.values.color = value;
|
||||
copyColor(value);
|
||||
point.gevBank?.update(point, colorField);
|
||||
},
|
||||
},
|
||||
show: {
|
||||
get: () => point.values.show,
|
||||
set(value) {
|
||||
if (point.values.show === Boolean(value)) return;
|
||||
point.values.show = Boolean(value);
|
||||
showField.show = point.values.show;
|
||||
point.gevBank?.update(point, showField);
|
||||
},
|
||||
},
|
||||
});
|
||||
for (const key of [
|
||||
'pixelSize',
|
||||
'outlineWidth',
|
||||
'outlineColor',
|
||||
'scaleByDistance',
|
||||
'disableDepthTestDistance',
|
||||
])
|
||||
Object.defineProperty(point, key, {
|
||||
get: () => point.values[key],
|
||||
set(value) {
|
||||
if (point.values[key] === value) return;
|
||||
point.values[key] = value;
|
||||
bankFor(point).add(point);
|
||||
},
|
||||
});
|
||||
bankFor(point).add(point);
|
||||
return point;
|
||||
};
|
||||
const collection = {
|
||||
get show() {
|
||||
return visible;
|
||||
},
|
||||
set show(value) {
|
||||
visible = Boolean(value);
|
||||
for (const entry of banks.values())
|
||||
if (entry.family === 'fleet') entry.bank.setVisible(visible);
|
||||
},
|
||||
add(spec) {
|
||||
const point = createPoint(spec);
|
||||
points.set(point.id, point);
|
||||
return point;
|
||||
},
|
||||
remove(point) {
|
||||
if (!points.delete(point.id)) return false;
|
||||
point.gevBank?.remove(point);
|
||||
return true;
|
||||
},
|
||||
removeAll() {
|
||||
for (const point of points.values()) point.gevBank?.remove(point);
|
||||
points.clear();
|
||||
},
|
||||
};
|
||||
const follow = {
|
||||
start(entity) {
|
||||
starting = entity;
|
||||
try {
|
||||
const followLabel = {
|
||||
id: entity.gevTrackedId,
|
||||
model: () => entity.gevLabelModel,
|
||||
position: () => entity.gevDisplayPosition?.() ?? entity.sample(),
|
||||
};
|
||||
entity.follow = engine.camera.follow({
|
||||
position: entity.sample,
|
||||
viewFrom: () => entity.viewFrom,
|
||||
label: followLabel,
|
||||
});
|
||||
} finally {
|
||||
starting = null;
|
||||
}
|
||||
},
|
||||
release() {
|
||||
releasing = true;
|
||||
try {
|
||||
engine.camera.following()?.stop();
|
||||
} finally {
|
||||
releasing = false;
|
||||
}
|
||||
},
|
||||
releasing: () => releasing,
|
||||
current() {
|
||||
if (starting) return starting;
|
||||
const current = engine.camera.following();
|
||||
for (const entity of tracked)
|
||||
if (entity.follow === current && current) return entity;
|
||||
return current;
|
||||
},
|
||||
onChanged: (listener) =>
|
||||
engine.camera.followChanged.addEventListener(listener),
|
||||
};
|
||||
return {
|
||||
kind: 'navara',
|
||||
engine,
|
||||
view: layerView.view,
|
||||
createPoints: () => collection,
|
||||
removePoints: () => collection.removeAll(),
|
||||
project: (position, result) =>
|
||||
engine.projector.worldToWindow(position, result),
|
||||
onFrame: (listener) =>
|
||||
layerView.view.on('preRender', () => {
|
||||
listener();
|
||||
for (const entity of tracked) {
|
||||
const position = entity.sample();
|
||||
if (position) entity.point.position = position;
|
||||
}
|
||||
}),
|
||||
createOrbit({ positions, width, color }) {
|
||||
const line = engine.lines.createLine({
|
||||
id: `satellites-orbit-${++sequence}`,
|
||||
widthPx: width,
|
||||
color: [color.red, color.green, color.blue, 0.6],
|
||||
depthFailAlpha: 0.35 / 0.6,
|
||||
arc: 'geodesic',
|
||||
});
|
||||
line.setPositions(positions);
|
||||
const primitive = {
|
||||
line,
|
||||
modelMatrix: geo.matrix4.clone(geo.matrix4.IDENTITY),
|
||||
visible: true,
|
||||
get show() {
|
||||
return this.visible;
|
||||
},
|
||||
set show(value) {
|
||||
this.visible = Boolean(value);
|
||||
line.show(this.visible);
|
||||
},
|
||||
};
|
||||
orbits.add(primitive);
|
||||
return primitive;
|
||||
},
|
||||
commitOrbit: (primitive) =>
|
||||
primitive.line.setModelMatrix(primitive.modelMatrix),
|
||||
removeOrbit(primitive) {
|
||||
primitive.line.destroy();
|
||||
orbits.delete(primitive);
|
||||
},
|
||||
createTracked({ id, position, viewFrom }) {
|
||||
const entity = {
|
||||
id: `satellites:${id}`,
|
||||
sample: position,
|
||||
viewFrom,
|
||||
follow: null,
|
||||
position: { getValue: position },
|
||||
point: createPoint(
|
||||
{
|
||||
id,
|
||||
position: position(),
|
||||
pixelSize: 14,
|
||||
color: YELLOW,
|
||||
outlineColor: WHITE,
|
||||
outlineWidth: 2,
|
||||
disableDepthTestDistance: Infinity,
|
||||
},
|
||||
'tracked',
|
||||
),
|
||||
};
|
||||
tracked.add(entity);
|
||||
return entity;
|
||||
},
|
||||
trackedPosition: (entity) => entity?.point.position,
|
||||
removeTracked(entity) {
|
||||
entity.point.gevBank?.remove(entity.point);
|
||||
tracked.delete(entity);
|
||||
if (entity.follow && engine.camera.following() === entity.follow)
|
||||
follow.release();
|
||||
},
|
||||
follow,
|
||||
listenClick(listener) {
|
||||
const dispatcher = selectionDispatcherFor(engine);
|
||||
if (!dispatcher)
|
||||
throw new Error('Satellite selection dispatcher unavailable');
|
||||
const remove = dispatcher.register('satellites', {
|
||||
owns: (id) => points.has(Number(id)),
|
||||
onClick: listener,
|
||||
});
|
||||
return { destroy: remove };
|
||||
},
|
||||
pickedNorad: (picked) => Number(picked?.id ?? picked?.primitive?.id),
|
||||
isTrackedPick: (picked, entity) =>
|
||||
Boolean(
|
||||
entity &&
|
||||
Number(picked?.id ?? picked?.primitive?.id) === entity.point.id,
|
||||
),
|
||||
destroy() {
|
||||
destroyed = true;
|
||||
for (const orbit of orbits) orbit.line.destroy();
|
||||
orbits.clear();
|
||||
for (const entry of banks.values()) entry.bank.destroy();
|
||||
banks.clear();
|
||||
dirty.clear();
|
||||
points.clear();
|
||||
tracked.clear();
|
||||
layerView.destroy();
|
||||
},
|
||||
};
|
||||
}
|
||||
@@ -1,101 +0,0 @@
|
||||
import test from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import * as geo from '../../../geo/index.js';
|
||||
import { createFakeEngine } from '../../../globe/testing/fakeEngine.js';
|
||||
import { WHITE, nearFarScale } from '../../shared/color.js';
|
||||
import { createSatellitesNavaraRenderer } from './navara.js';
|
||||
|
||||
const position = geo.cartesian3.fromDegrees(0, 0, 420000);
|
||||
const spec = (id) => ({
|
||||
id,
|
||||
position,
|
||||
color: WHITE,
|
||||
pixelSize: 12,
|
||||
outlineColor: WHITE.withAlpha(0.3),
|
||||
outlineWidth: 1,
|
||||
scaleByDistance: nearFarScale(1e6, 1.5, 2e7, 0.6),
|
||||
});
|
||||
|
||||
test('satellite banks retain styles, survive growth and update the real store', async () => {
|
||||
const engine = createFakeEngine();
|
||||
const renderer = createSatellitesNavaraRenderer(engine);
|
||||
const points = renderer.createPoints();
|
||||
const all = Array.from({ length: 1500 }, (_, i) => points.add(spec(i)));
|
||||
await Promise.resolve();
|
||||
const [listed] = engine.movers.list();
|
||||
const set = engine.fake.moverSet(listed.id);
|
||||
assert.equal(engine.movers.list().length, 1);
|
||||
assert.equal(set.store.count, 1500);
|
||||
assert.equal(set.store.pickIds[699], 699);
|
||||
assert.deepEqual(set.options.point.outlineColor, [1, 1, 1, 0.3]);
|
||||
const before = set.commits;
|
||||
const remove = renderer.onFrame(() => {
|
||||
all[0].position = { x: 1, y: 2, z: 3 };
|
||||
all[0].show = false;
|
||||
});
|
||||
engine.fake.frame();
|
||||
remove();
|
||||
assert.equal(engine.fake.moverSet(listed.id).commits, before + 1);
|
||||
assert.deepEqual([...set.store.positions.slice(0, 3)], [1, 2, 3]);
|
||||
assert.equal(set.store.shows[0], 0);
|
||||
all[1].pixelSize = 14;
|
||||
await Promise.resolve();
|
||||
assert.equal(set.store.count, 1499);
|
||||
assert.equal(engine.movers.list().length, 2);
|
||||
points.removeAll();
|
||||
await Promise.resolve();
|
||||
assert.ok(engine.movers.list().every((s) => s.count === 0));
|
||||
renderer.destroy();
|
||||
assert.equal(engine.movers.list().length, 0);
|
||||
engine.destroy();
|
||||
});
|
||||
|
||||
test('tracked glyph uses the follow sample and stays visible independently of fleet', async () => {
|
||||
const engine = createFakeEngine();
|
||||
const renderer = createSatellitesNavaraRenderer(engine);
|
||||
const points = renderer.createPoints();
|
||||
points.add(spec(25544));
|
||||
let sample = position;
|
||||
const entity = renderer.createTracked({
|
||||
id: 25544,
|
||||
position: () => sample,
|
||||
viewFrom: { x: -450000, y: -450000, z: 350000 },
|
||||
});
|
||||
entity.gevTrackedId = '25544';
|
||||
renderer.follow.start(entity);
|
||||
points.show = false;
|
||||
const remove = renderer.onFrame(() => {});
|
||||
sample = { x: position.x + 7600, y: 100, z: 0 };
|
||||
engine.fake.frame();
|
||||
remove();
|
||||
assert.deepEqual({ ...renderer.trackedPosition(entity) }, sample);
|
||||
assert.equal(renderer.follow.current(), entity);
|
||||
const sets = engine.movers.list().map((s) => engine.fake.moverSet(s.id));
|
||||
assert.equal(sets.find((s) => s.options.order === 100).store.shows[0], 1);
|
||||
assert.equal(sets.find((s) => s.options.order === 0).store.count, 0);
|
||||
renderer.removeTracked(entity);
|
||||
assert.equal(renderer.follow.current(), null);
|
||||
renderer.destroy();
|
||||
engine.destroy();
|
||||
});
|
||||
|
||||
test('orbit starts at identity, rotates without rebuilding and releases lines', () => {
|
||||
const engine = createFakeEngine();
|
||||
const renderer = createSatellitesNavaraRenderer(engine);
|
||||
const orbit = renderer.createOrbit({
|
||||
positions: [position, { x: 0, y: 6778137, z: 0 }],
|
||||
width: 2.5,
|
||||
color: WHITE,
|
||||
});
|
||||
assert.deepEqual(orbit.modelMatrix, geo.matrix4.IDENTITY);
|
||||
const before = engine.lines.list()[0];
|
||||
orbit.modelMatrix[12] = 123;
|
||||
renderer.commitOrbit(orbit);
|
||||
assert.equal(engine.lines.list()[0].id, before.id);
|
||||
orbit.show = false;
|
||||
assert.equal(engine.lines.list()[0].shown, false);
|
||||
renderer.removeOrbit(orbit);
|
||||
assert.equal(engine.lines.list().length, 0);
|
||||
renderer.destroy();
|
||||
engine.destroy();
|
||||
});
|
||||
@@ -23,27 +23,18 @@ export function createRendering({
|
||||
/**
|
||||
* 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.
|
||||
* The ring is one engine line built once from the baked positions, then
|
||||
* re-aligned to current GMST each tick through its model matrix: a rigid
|
||||
* Z-rotation, so its geometry is never rebuilt (no blink while a rebuild
|
||||
* is in flight). It is bright where the scene does not hide it and dimmed
|
||||
* where it passes behind the globe (the line's depth-fail alpha).
|
||||
*/
|
||||
|
||||
function _showOrbitPath(noradId, color) {
|
||||
if (layerState._orbitPaths.has(noradId)) return; // already showing
|
||||
|
||||
const sat = layerState._catalog.get(noradId);
|
||||
if (!sat || !layerState._viewer) return;
|
||||
if (!sat || !getRenderer()) return;
|
||||
|
||||
const bakeDate = new Date(appClock.now());
|
||||
const basePositions = parts.orbits.computeOrbitPath(sat.satrec, bakeDate);
|
||||
@@ -86,13 +77,11 @@ export function createRendering({
|
||||
* rotation cannot distinguish. Tiny negative deltas right after bake are
|
||||
* likewise harmless. No unwrapping needed.
|
||||
*
|
||||
* No SGP4 here — the rotation is applied as the ring primitive's modelMatrix
|
||||
* (exact compensation; WGS84 is rotationally symmetric about Z, so rotating
|
||||
* the baked curve rigidly equals rebaking from rotated points). modelMatrix
|
||||
* updates are synchronous uniforms — no geometry rebuild, no flicker. Post-
|
||||
* creation modelMatrix changes are supported for one-instance primitives in
|
||||
* 3D mode, which these rings are. In-place mutation is safe: Primitive.update
|
||||
* diffs modelMatrix against an internal clone.
|
||||
* No SGP4 here — the rotation is applied as the ring's modelMatrix (exact
|
||||
* compensation; WGS84 is rotationally symmetric about Z, so rotating the
|
||||
* baked curve rigidly equals rebaking from rotated points). The matrix is
|
||||
* written in place and handed to the line (commitOrbit): no geometry
|
||||
* rebuild, no flicker.
|
||||
* @param {Date} nowDate Epoch used for current GMST.
|
||||
*/
|
||||
|
||||
@@ -106,7 +95,7 @@ export function createRendering({
|
||||
nowDate,
|
||||
path.primitive.modelMatrix,
|
||||
);
|
||||
getRenderer().commitOrbit(path.primitive);
|
||||
getRenderer()?.commitOrbit(path.primitive);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -117,7 +106,7 @@ export function createRendering({
|
||||
function _hideOrbitPath(noradId) {
|
||||
const path = layerState._orbitPaths.get(noradId);
|
||||
if (path) {
|
||||
if (layerState._viewer) getRenderer().removeOrbit(path.primitive); // remove() destroys
|
||||
if (path.primitive) getRenderer()?.removeOrbit(path.primitive);
|
||||
layerState._orbitPaths.delete(noradId);
|
||||
}
|
||||
}
|
||||
@@ -213,8 +202,8 @@ export function createRendering({
|
||||
return;
|
||||
if (nowMs - layerState._lastFocusUpdate < 80) return;
|
||||
layerState._lastFocusUpdate = nowMs;
|
||||
const scene = layerState._viewer.scene;
|
||||
const camera = layerState._viewer.camera;
|
||||
const camera = getRenderer()?.view.camera;
|
||||
if (!camera) return;
|
||||
const result = applySatellitePointFocusDeemphasis({
|
||||
points: layerState._points,
|
||||
trackedId: layerState._trackedNorad,
|
||||
|
||||
@@ -1,9 +1,9 @@
|
||||
import { createSatellitesCesiumRenderer } from './render/cesium.js';
|
||||
import { createSatellitesDisplay } from './render/display.js';
|
||||
import assert from 'node:assert/strict';
|
||||
import http from 'node:http';
|
||||
import { EventEmitter, once } from 'node:events';
|
||||
import test from 'node:test';
|
||||
import * as Cesium from 'cesium';
|
||||
import { createFakeEngine } from '../../globe/testing/fakeEngine.js';
|
||||
import { createSatelliteSource } from './source.js';
|
||||
import { createState } from './state.js';
|
||||
import { createControls } from './controls.js';
|
||||
@@ -65,13 +65,13 @@ async function fixture(t) {
|
||||
fetchImpl: (path, options) =>
|
||||
fetch(`http://127.0.0.1:${server.address().port}${path}`, options),
|
||||
});
|
||||
// Application host services and native EventTargets; actual Cesium collections,
|
||||
// input handler, events, SGP4, ingestion and lifecycle run without a WebGL scene.
|
||||
// Application host services and native EventTargets; the display on the
|
||||
// fake engine, its input, events, SGP4, ingestion and lifecycle run without
|
||||
// a WebGL scene.
|
||||
const noop = () => {};
|
||||
const services = {
|
||||
renderer: {
|
||||
create: ({ viewer, engine }) =>
|
||||
createSatellitesCesiumRenderer(engine, { viewer }),
|
||||
create: ({ engine }) => createSatellitesDisplay(engine),
|
||||
},
|
||||
overlays: {
|
||||
setOverlayEntries: noop,
|
||||
@@ -118,18 +118,11 @@ async function fixture(t) {
|
||||
})) {
|
||||
parts[name] = factory(context);
|
||||
}
|
||||
const viewer = {
|
||||
scene: {
|
||||
canvas: new EventTarget(),
|
||||
primitives: new Cesium.PrimitiveCollection(),
|
||||
preRender: new Cesium.Event(),
|
||||
},
|
||||
trackedEntityChanged: new Cesium.Event(),
|
||||
};
|
||||
await parts.lifecycle.methods.init(viewer);
|
||||
const engine = createFakeEngine();
|
||||
await parts.lifecycle.methods.init(null, { engine });
|
||||
t.after(async () => {
|
||||
if (state._pointCollection) parts.lifecycle.methods.destroy(viewer);
|
||||
viewer.scene.primitives.destroy();
|
||||
if (state._pointCollection) parts.lifecycle.methods.destroy();
|
||||
engine.destroy();
|
||||
if (previousDocument === undefined) delete globalThis.document;
|
||||
else globalThis.document = previousDocument;
|
||||
server.closeAllConnections();
|
||||
@@ -138,9 +131,9 @@ async function fixture(t) {
|
||||
return {
|
||||
state,
|
||||
parts,
|
||||
viewer,
|
||||
engine,
|
||||
policy,
|
||||
update: (options) => parts.ingestion.methods.update(viewer, options),
|
||||
update: (options) => parts.ingestion.methods.update(null, options),
|
||||
stats: () => parts.controls.methods.getStats(),
|
||||
feed: () => layerFeedState(parts.controls.methods.getStats()),
|
||||
async waitHeld(count) {
|
||||
@@ -290,10 +283,10 @@ test('destroy aborts an in-flight response and initialization starts with new ow
|
||||
const work = f.update();
|
||||
await f.waitHeld(6);
|
||||
const rejected = assert.rejects(work, { name: 'AbortError' });
|
||||
f.parts.lifecycle.methods.destroy(f.viewer);
|
||||
f.parts.lifecycle.methods.destroy();
|
||||
assert.equal(f.stats().count, 0);
|
||||
assert.equal(f.stats().stale, false);
|
||||
await f.parts.lifecycle.methods.init(f.viewer);
|
||||
await f.parts.lifecycle.methods.init(null, { engine: f.engine });
|
||||
await rejected;
|
||||
assert.equal(f.stats().stale, false);
|
||||
f.policy.hold = false;
|
||||
|
||||
@@ -26,8 +26,8 @@ export function createState({ services }) {
|
||||
state._detectionObjects = new Map();
|
||||
|
||||
// noradId → { primitive, gmstAtBake }
|
||||
// primitive is a one-instance Cesium.Primitive holding the ring baked in ECEF
|
||||
// at gmstAtBake; the preRender tick re-aligns it to current GMST by updating
|
||||
// primitive is the display's orbit ring holding the ring baked in ECEF at
|
||||
// gmstAtBake; the preRender tick re-aligns it to current GMST by updating
|
||||
// its modelMatrix (rigid Z-rotation — no geometry rebuild, WS-D1).
|
||||
|
||||
state._orbitPaths = new Map();
|
||||
@@ -48,7 +48,7 @@ export function createState({ services }) {
|
||||
|
||||
state._denseLoadController = null;
|
||||
|
||||
state._viewer = null;
|
||||
/** The engine's display (render/display.js) while the layer draws. */
|
||||
state._renderer = null;
|
||||
state._engine = null;
|
||||
|
||||
@@ -88,7 +88,7 @@ export function createState({ services }) {
|
||||
|
||||
state._clickHandler = null;
|
||||
|
||||
/** @type {Cesium.Event.RemoveCallback|null} trackedEntityChanged listener disposer (cross-layer untrack) */
|
||||
/** @type {(() => void)|null} follow-changed listener disposer (cross-layer untrack) */
|
||||
|
||||
state._trackedEntityChangedRemove = null;
|
||||
|
||||
@@ -140,7 +140,7 @@ export function createState({ services }) {
|
||||
|
||||
// Per-frame cache for the tracked satellite (WS-D2): dot, host readout, camera, and
|
||||
// getTrackedInfo all read one SGP4 sample per rendered frame, keyed on
|
||||
// scene.frameState.frameNumber, so they never diverge in epoch.
|
||||
// the display's frame number, so they never diverge in epoch.
|
||||
|
||||
state._trackedFrameNumber = -1;
|
||||
|
||||
|
||||
@@ -8,6 +8,15 @@ export function createTesting({
|
||||
source,
|
||||
getRenderer,
|
||||
}) {
|
||||
// The layer's display on a test engine (none without one).
|
||||
function useEngine(engine) {
|
||||
layerState._renderer?.destroy();
|
||||
layerState._engine = engine ?? null;
|
||||
layerState._renderer = engine
|
||||
? (services.renderer.create({ engine }) ?? null)
|
||||
: null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Seed a single tracked satellite so tests can invoke the exact production
|
||||
* pre-render callback without constructing a WebGL viewer.
|
||||
@@ -17,7 +26,8 @@ export function createTesting({
|
||||
* @param {object} state.satrec
|
||||
* @param {object} state.entity
|
||||
* @param {object} state.point
|
||||
* @param {object} state.viewer
|
||||
* @param {object} [state.engine] The test engine the display draws on (its
|
||||
* frames number the per-frame sample).
|
||||
* @param {() => (number|Date)} state.now
|
||||
*/
|
||||
|
||||
@@ -27,15 +37,13 @@ export function createTesting({
|
||||
satrec,
|
||||
entity,
|
||||
point,
|
||||
viewer,
|
||||
engine = null,
|
||||
now,
|
||||
// Extra catalog/point rows so a test can exercise a docked cluster (and a
|
||||
// control satellite that must NOT be treated as part of it).
|
||||
neighbours = [],
|
||||
}) {
|
||||
layerState._renderer = null;
|
||||
layerState._engine = null;
|
||||
layerState._viewer = viewer;
|
||||
useEngine(engine);
|
||||
layerState._catalog = new Map([
|
||||
[noradId, { name, satrec, group: 'stations' }],
|
||||
]);
|
||||
@@ -106,9 +114,6 @@ export function createTesting({
|
||||
catalog = 'core',
|
||||
showPoints = true,
|
||||
} = {}) {
|
||||
layerState._viewer = {
|
||||
scene: { primitives: { add: (p) => p, remove() {} } },
|
||||
};
|
||||
// Neutralize the shared world-overlay host: these tests exercise catalog and
|
||||
// row-control logic, not the ISS callout.
|
||||
layerState._overlayHost = {
|
||||
@@ -144,7 +149,6 @@ export function createTesting({
|
||||
layerState._rowControlsListener = null;
|
||||
layerState._overlayHost = layerState.DEFAULT_OVERLAY_HOST;
|
||||
layerState._orbitPaths = new Map();
|
||||
layerState._viewer = null;
|
||||
layerState._pointCollection = null;
|
||||
layerState._catalog = new Map();
|
||||
layerState._points = new Map();
|
||||
@@ -167,18 +171,19 @@ export function createTesting({
|
||||
return layerState._catalog.get(Number(noradId))?.group;
|
||||
}
|
||||
|
||||
/** Seed ISS/tracking state while retaining the production track and host paths. */
|
||||
/**
|
||||
* Seed ISS/tracking state while retaining the production track and host
|
||||
* paths; `engine` is the test engine the display draws and follows on.
|
||||
*/
|
||||
|
||||
function _setSatelliteLabelLifecycleStateForTest({
|
||||
viewer,
|
||||
engine = null,
|
||||
satrec,
|
||||
point,
|
||||
overlayHost,
|
||||
preservePending = false,
|
||||
}) {
|
||||
layerState._renderer = null;
|
||||
layerState._engine = null;
|
||||
layerState._viewer = viewer;
|
||||
useEngine(engine);
|
||||
layerState._catalog = new Map([
|
||||
[ISS_NORAD, { name: 'ISS (ZARYA)', satrec, group: 'stations' }],
|
||||
]);
|
||||
|
||||
@@ -57,7 +57,7 @@ export function createTracking({
|
||||
)
|
||||
return false;
|
||||
if (
|
||||
!layerState._viewer ||
|
||||
!layerState._renderer ||
|
||||
!layerState._catalog.has(pending.id) ||
|
||||
!layerState._points.has(pending.id)
|
||||
)
|
||||
@@ -75,9 +75,9 @@ export function createTracking({
|
||||
/**
|
||||
* Stop tracking the currently followed satellite.
|
||||
* @param {boolean} [skipViewerUntrack=false] - When ANOTHER layer just grabbed
|
||||
* the follow-camera (viewer.trackedEntityChanged), tear down our own state
|
||||
* but do NOT clear viewer.trackedEntity — the new owner controls it now,
|
||||
* and clearing it would yank the camera off their target (mirror of flights).
|
||||
* the follow-camera (engine.camera.followChanged), tear down our own state
|
||||
* but do NOT release the follow — the new owner controls it now, and
|
||||
* releasing it would yank the camera off their target (mirror of flights).
|
||||
*/
|
||||
|
||||
function _clearTracking(
|
||||
@@ -121,10 +121,9 @@ export function createTracking({
|
||||
if (layerState._trackedNorad !== ISS_NORAD) {
|
||||
parts.rendering._hideOrbitPath(layerState._trackedNorad);
|
||||
}
|
||||
if (layerState._viewer && !skipViewerUntrack)
|
||||
getRenderer().follow.release();
|
||||
if (getRenderer() && !skipViewerUntrack) getRenderer().follow.release();
|
||||
if (layerState._trackedEntity) {
|
||||
getRenderer().removeTracked(layerState._trackedEntity);
|
||||
getRenderer()?.removeTracked(layerState._trackedEntity);
|
||||
layerState._trackedEntity = null;
|
||||
}
|
||||
layerState._trackedNorad = null;
|
||||
@@ -153,8 +152,7 @@ export function createTracking({
|
||||
const sat = layerState._catalog.get(layerState._trackedNorad);
|
||||
if (!sat) return null;
|
||||
|
||||
const frameNumber =
|
||||
layerState._viewer?.scene?.frameState?.frameNumber ?? -1;
|
||||
const frameNumber = getRenderer()?.view.frameNumber() ?? -1;
|
||||
if (
|
||||
frameNumber === -1 ||
|
||||
frameNumber !== layerState._trackedFrameNumber ||
|
||||
@@ -201,8 +199,8 @@ export function createTracking({
|
||||
publishFocusTargetFromCachedPosition({
|
||||
ownerLayer: 'satellites',
|
||||
id: layerState._trackedNorad,
|
||||
scene: layerState._viewer?.scene,
|
||||
camera: layerState._viewer?.camera,
|
||||
scene: getRenderer()?.view.scene,
|
||||
camera: getRenderer()?.view.camera,
|
||||
displayPosition: layerState._trackedFrameCartesian,
|
||||
widthPx: Math.max(trackedPointDiameterPx, Math.min(260, labelWidthPx)),
|
||||
// Union of the 14 px point and the two-line label shifted 18 px upward.
|
||||
|
||||
Reference in new issue
Block a user