Merge branch 'sameh/renderer-leftovers' into sameh/renderer-seam

# Conflicts:
#	src/render/cesium/draw.test.mjs
#	src/render/cesiumAllowList.json
This commit is contained in:
Sameh Khamis committed 2026-11-08 12:00:30 -08:00
commit 481df0b093
25 files changed
+1823 -886

No files matched your search

+1
View File
@@ -224,6 +224,7 @@ test('consumer build includes only infrastructure code and resolves assets under
'scenePick.js',
'sensorPick.js',
'sphere.js',
'stockFollow.js',
'styleStages.js',
'vector.js',
]);
+2 -35
View File
@@ -8,13 +8,7 @@ import {
findQuery,
} from '../render/rendererOf.js';
import { cssColor } from '../render/color.js';
import {
WGS84,
fromDegrees,
fromDegreesInto,
toLonLatH,
} from '../geo/ellipsoid.js';
import { offsetFromHeadingPitchRange } from '../geo/frames.js';
import { fromDegrees, fromDegreesInto, toLonLatH } from '../geo/ellipsoid.js';
import { sphereFromPoints } from '../geo/sphere.js';
import { densifyRhumb } from '../geo/rhumb.js';
import { heightsOf } from '../queries/heights.js';
@@ -25,6 +19,7 @@ import {
} from '../sources/infrastructureData.js';
import { createInfrastructureOverlayEntry } from './infrastructureOverlayEntry.js';
import { createGeojsonPins } from './geojsonPins.js';
import { followViewFrom } from './stockFollow.js';
import { inputFor as defaultInputFor } from '../input/dispatcher.js';
import {
selectInfraLod,
@@ -321,34 +316,6 @@ const STEM_WIDTH_PX = 3.5;
const PIN_SIZE_PX = 8;
const BLACK = Object.freeze([0, 0, 0, 1]);
/** The range the default renderer frames a sphere of no size from. */
const MINIMUM_FIT_RANGE_M = 100;
/**
* Where the camera frames a part it starts following, as the default
* renderer framed an entity it started following with no view of its own:
* looking at the bounds' centre, heading north, pitched down 45° (steeper
* far from the ground), at the range that fits the bounds in view, within
* the camera's zoom limits. Returned as the eye's offset from the centre,
* east-north-up there; `at` is where the part stands.
*/
function followViewFrom(sphere, at, camera) {
const pose = camera.pose?.();
const fovy = Number.isFinite(pose?.fovy) ? pose.fovy : Math.PI / 3;
const aspect = Number.isFinite(pose?.aspectRatio) ? pose.aspectRatio : 1;
const tanPhi = Math.tan(fovy / 2);
const tanTheta = aspect * tanPhi;
let range =
sphere.radius === 0
? MINIMUM_FIT_RANGE_M
: Math.max(sphere.radius / tanTheta, sphere.radius / tanPhi);
const { minDistance = 0, maxDistance = Infinity } = camera.controls ?? {};
range = Math.min(Math.max(range, minDistance), maxDistance);
const factor =
2 - 1 / Math.max(1, Math.hypot(at.x, at.y, at.z) / WGS84.radii.x);
return offsetFromHeadingPitchRange(0, (-Math.PI / 4) * factor, range);
}
/** The GeoJSON loader's `marker-size` names, in pixels. */
const MARKER_SIZES = Object.freeze({ small: 24, medium: 48, large: 64 });
/**
+57 -72
View File
@@ -1,7 +1,8 @@
import test from 'node:test';
import assert from 'node:assert/strict';
import * as Cesium from 'cesium';
import { bindRenderer } from '../render/rendererOf.js';
import { fromDegrees } from '../geo/ellipsoid.js';
import { bindFakeDraw } from '../testSupport/fakeDrawPort.mjs';
import { fakeSceneFrame } from '../testSupport/fakeCesiumScene.mjs';
import { gstime } from 'satellite.js';
import { createModel } from '../layers/launches/model.js';
@@ -1159,37 +1160,34 @@ test('real mission build, select, refresh, deselect, disable, and destroy paths
removeEventListener(type) { listeners.delete(`document:${type}`); },
};
const canvas = new FakeElement('canvas');
const dataSources = [];
const camera = {
positionCartographic: null,
positionWC: Cesium.Cartesian3.fromDegrees(-80.604, 28.608, 18_000_000),
cancelFlight() {},
lookAtTransform() {},
};
let eye = fromDegrees(-80.604, 28.608, 18_000_000);
const scene = {
canvas,
camera,
frameState: { frameNumber: 1 },
postRender: new Cesium.Event(),
preRender: new Cesium.Event(),
preUpdate: new Cesium.Event(),
primitives: { add: (primitive) => primitive, remove: () => true },
drillPick: () => [],
};
const viewer = {
camera,
scene,
dataSources: {
add(dataSource) { dataSources.push(dataSource); return dataSource; },
remove(dataSource) {
const index = dataSources.indexOf(dataSource);
if (index >= 0) dataSources.splice(index, 1);
return index >= 0;
},
const viewer = { scene };
const { draw } = bindFakeDraw(viewer, {
frame: fakeSceneFrame(viewer),
camera: {
// No pose to fly from: the full-globe framing on enable stays put.
pose: () => ({ lon: Number.NaN, lat: Number.NaN, height: 18_000_000, position: eye, fovy: Number.NaN }),
on: () => () => {},
release() {},
cancelFlight() {},
},
selectedEntity: undefined,
query: { drillPick: () => [] },
});
// The mission sets' items by id, across the layer's draw sets.
const missionItems = () => {
const items = new Map();
for (const record of draw.sets.values())
if (!record.disposed && /:(lines|sites|markers)$/.test(record.spec.id))
for (const [id, item] of record.items) items.set(id, item);
return items;
};
bindRenderer(viewer, { frame: fakeSceneFrame(viewer) });
const item = (id) => missionItems().get(id);
const hostCalls = [];
const host = {
setEntries: (...args) => hostCalls.push(['entries', ...args]),
@@ -1245,9 +1243,10 @@ test('real mission build, select, refresh, deselect, disable, and destroy paths
await rocketLaunchesLayer.enable();
await rocketLaunchesLayer.update();
const entities = dataSources[0].entities.values;
assert.ok(entities.length >= 7, 'runtime guard requires the populated mission build path');
assert.ok(entities.every((entity) => entity.label === undefined));
assert.ok(missionItems().size >= 7, 'runtime guard requires the populated mission build path');
// Every set is a kind with no world text: labels are the host's.
const kinds = new Set(['lines', 'points', 'icons', 'shapes']);
assert.ok([...draw.sets.values()].every((record) => kinds.has(record.kind)));
const ambientPublication = hostCalls.findLast(([type, sourceId]) => (
type === 'entries' && sourceId === ROCKET_MISSION_AMBIENT_OVERLAY_SOURCE_ID
));
@@ -1259,26 +1258,25 @@ test('real mission build, select, refresh, deselect, disable, and destroy paths
collisionCapacity: ROCKET_MISSION_AMBIENT_OVERLAY_COLLISION_CAPACITY,
moving: false,
});
const launchEntity = dataSources[0].entities.getById('rocket-launch:mission-runtime');
assert.deepEqual(
assert.equal(
ambientPublication[2][0].position,
launchEntity.position.getValue(Cesium.JulianDate.now()),
'ambient host marker must reuse the entity anchor Cartesian',
item('rocket-launch:mission-runtime').pos,
'ambient host marker must reuse the site marker anchor',
);
const frameTime = Cesium.JulianDate.now();
scene.preRender.raiseEvent(scene, frameTime);
assert.equal(launchEntity.point.show.getValue(frameTime), true);
camera.positionWC = Cesium.Cartesian3.fromDegrees(99.396, -28.608, 18_000_000);
assert.equal(item('rocket-launch:mission-runtime').show, true);
eye = fromDegrees(99.396, -28.608, 18_000_000);
scene.preRender.raiseEvent(scene, frameTime);
assert.equal(
launchEntity.point.show.getValue(frameTime),
item('rocket-launch:mission-runtime').show,
false,
'pre-render horizon pass must hide a rear-side depth-free mission dot before draw and pick',
);
camera.positionWC = Cesium.Cartesian3.fromDegrees(-80.604, 28.608, 18_000_000);
eye = fromDegrees(-80.604, 28.608, 18_000_000);
scene.preRender.raiseEvent(scene, frameTime);
assert.equal(
launchEntity.point.show.getValue(frameTime),
item('rocket-launch:mission-runtime').show,
true,
'mission dot must return when its surface anchor faces the camera again',
);
@@ -1304,17 +1302,16 @@ test('real mission build, select, refresh, deselect, disable, and destroy paths
&& entry.paintLane === 'selected'
&& entry.edgeFade === 'keyhole'
)));
const satelliteEntity = dataSources[0].entities.getById('rocket-satellite:mission-runtime');
const satellitePosition = satelliteEntity.position.getValue(Cesium.JulianDate.now());
assert.equal(
scene.preRender.raiseEvent(scene, frameTime);
assert.deepEqual(
selectedPublication[2][2].position(),
satellitePosition,
'payload host getter must return the exact per-frame live-position cache',
item('rocket-satellite:mission-runtime').pos,
'payload host getter must return where the frame drew the payload',
);
// Jitter regression net: live-state propagation advances at most once per
// frameNumber, and the host getter is a pure read that never advances it.
// Without both halves, the host label and the native dot can propagate to
// Jitter regression net: live-state propagation advances at most once a
// frame, and the host getter is a pure read that never advances it.
// Without both halves, the host label and the drawn dot can propagate to
// different wall-clock instants inside one frame — the documented
// label-separation jitter class.
const payloadEntry = selectedPublication[2][2];
@@ -1322,52 +1319,40 @@ test('real mission build, select, refresh, deselect, disable, and destroy paths
try {
let nowMs = realDateNow();
Date.now = () => nowMs;
scene.frameState.frameNumber = 41;
const frameA = Cesium.Cartesian3.clone(
satelliteEntity.position.getValue(Cesium.JulianDate.now()),
);
scene.preRender.raiseEvent(scene, frameTime);
const frameA = { ...item('rocket-satellite:mission-runtime').pos };
assert.deepEqual({ ...payloadEntry.position() }, frameA);
nowMs += 30_000;
assert.deepEqual(
Cesium.Cartesian3.clone(satelliteEntity.position.getValue(Cesium.JulianDate.now())),
{ ...payloadEntry.position() },
frameA,
'a second native read in the same frame must not re-propagate',
'host getter must not advance propagation between frames',
);
nowMs += 30_000;
scene.frameState.frameNumber = 42;
scene.preRender.raiseEvent(scene, frameTime);
const frameB = { ...item('rocket-satellite:mission-runtime').pos };
assert.notDeepEqual(frameB, frameA, 'a new frame propagates (non-vacuous)');
assert.deepEqual(
Cesium.Cartesian3.clone(payloadEntry.position()),
frameA,
'host getter must not advance propagation, even on a new frame',
);
const frameB = Cesium.Cartesian3.clone(
satelliteEntity.position.getValue(Cesium.JulianDate.now()),
);
assert.notDeepEqual(frameB, frameA, 'native read on a new frame propagates (non-vacuous)');
assert.deepEqual(
Cesium.Cartesian3.clone(payloadEntry.position()),
{ ...payloadEntry.position() },
frameB,
'host getter reads the advanced cache after native propagation',
'host getter reads the advanced cache after the frame drew it',
);
} finally {
Date.now = realDateNow;
scene.frameState.frameNumber = 1;
}
const reentryEntity = dataSources[0].entities.getById('rocket-reentry:mission-runtime:0');
assert.deepEqual(
selectedPublication[2][1].position,
reentryEntity.polyline.positions.getValue(Cesium.JulianDate.now())[0],
're-entry host label must reuse the recovery-path interface Cartesian',
item('rocket-reentry:mission-runtime:0').positions[0],
're-entry host label must reuse the recovery-path interface point',
);
const transferEntity = dataSources[0].entities.getById('rocket-transfer:mission-runtime');
assert.deepEqual(
selectedPublication[2][3].position,
transferEntity.polyline.positions.getValue(Cesium.JulianDate.now()).at(-1),
'orbit host label must reuse the insertion Cartesian',
item('rocket-transfer:mission-runtime').positions.at(-1),
'orbit host label must reuse the insertion point',
);
launchName = 'Mission Refresh | Gauntlet Payload';
await rocketLaunchesLayer.update();
assert.ok(dataSources[0].entities.values.every((entity) => entity.label === undefined));
assert.ok(missionItems().size >= 7);
const refreshPublication = hostCalls.findLast(([type, sourceId]) => (
type === 'entries' && sourceId === ROCKET_MISSION_SELECTED_OVERLAY_SOURCE_ID
));
@@ -1390,7 +1375,7 @@ test('real mission build, select, refresh, deselect, disable, and destroy paths
]);
await rocketLaunchesLayer.destroy(viewer);
initialized = false;
assert.equal(dataSources.length, 0);
assert.ok([...draw.sets.values()].every((record) => record.disposed));
assert.deepEqual(hostCalls.slice(-4), [
['clear', ROCKET_MISSION_AMBIENT_OVERLAY_SOURCE_ID],
['visible', ROCKET_MISSION_AMBIENT_OVERLAY_SOURCE_ID, false],
+127
View File
@@ -0,0 +1,127 @@
/**
* @module data/stockFollow
* @description A double-click on a layer's drawn item follows it, as the
* default renderer's own double-click followed the entities layers drew
* before they drew through the draw port: an item with a position is
* followed, framed as that renderer framed an entity it started following;
* one without (a line) is zoomed to at once instead. It runs only while the
* renderer's own double-click follow is on (a tool can hold it off).
*/
import { WGS84 } from '../geo/ellipsoid.js';
import { offsetFromHeadingPitchRange } from '../geo/frames.js';
import { findCamera, findQuery } from '../render/rendererOf.js';
/** The range the default renderer frames a sphere of no size from. */
const MINIMUM_FIT_RANGE_M = 100;
/**
* Where the camera frames a part it starts following, as the default
* renderer framed an entity it started following with no view of its own:
* looking at the bounds' centre, heading north, pitched down 45° (steeper
* far from the ground), at the range that fits the bounds in view, within
* the camera's zoom limits. Returned as the eye's offset from the centre,
* east-north-up there; `at` is where the part stands.
* @param {{center: {x: number, y: number, z: number}, radius: number}} sphere
* @param {{x: number, y: number, z: number}} at
* @param {object} camera The camera port.
*/
export function followViewFrom(sphere, at, camera) {
const pose = camera.pose?.();
const fovy = Number.isFinite(pose?.fovy) ? pose.fovy : Math.PI / 3;
const aspect = Number.isFinite(pose?.aspectRatio) ? pose.aspectRatio : 1;
const tanPhi = Math.tan(fovy / 2);
const tanTheta = aspect * tanPhi;
let range =
sphere.radius === 0
? MINIMUM_FIT_RANGE_M
: Math.max(sphere.radius / tanTheta, sphere.radius / tanPhi);
const { minDistance = 0, maxDistance = Infinity } = camera.controls ?? {};
range = Math.min(Math.max(range, minDistance), maxDistance);
const factor =
2 - 1 / Math.max(1, Math.hypot(at.x, at.y, at.z) / WGS84.radii.x);
return offsetFromHeadingPitchRange(0, (-Math.PI / 4) * factor, range);
}
/**
* Follow (or zoom to) a layer's item on a double-click.
* @param {object} options
* @param {object} options.viewer
* @param {(viewer: object) => object} options.inputFor The click dispatcher.
* @param {string} options.name The layer, for warnings.
* @param {() => boolean} options.enabled Whether the layer takes clicks now.
* @param {(hit: import('../render/contract/query').Hit) =>
* ({key: string, position: () => ({x: number, y: number, z: number}|null),
* sphere?: {center: object, radius: number}}
* | {zoomTo: {center: object, radius: number}}
* | null)} options.targetFor What a hit on one of the layer's items is
* followed by (`key`, its live `position`, the bounds it is framed by,
* radius 0 by default), or zoomed to (`zoomTo`); null for anything else.
* @returns {{readonly following: object|null, stop(): void, destroy(): void}}
*/
export function followOnDoubleClick({
viewer,
inputFor,
name,
enabled,
targetFor,
}) {
const input = inputFor(viewer);
/** The follow a double-click started, while the camera keeps it. */
let follow = null;
const off =
input.onPointer?.('dblclick', (event) => {
if (!enabled()) return;
// The renderer's own double-click follow, off while a tool holds it
// or on a renderer without one.
if (input.stockEnabled?.('dblclickFollow') !== true) return;
const hit = findQuery(viewer)?.pick(event.position.x, event.position.y);
const found = hit && !hit.surface ? targetFor(hit) : null;
if (!found) return;
const camera = findCamera(viewer);
if (!camera) return;
try {
if (found.zoomTo) {
// As the default renderer zoomed to an entity with no position:
// at once, north up, pitched down 45°, at the range that fits it
// in view. Following nothing then, as that zoom stopped any
// follow first.
if (camera.followed) camera.follow(null);
camera.flyToBounds(found.zoomTo, { durationS: 0 });
return;
}
const at = found.position();
if (!at) return;
const target = {
key: found.key,
position: found.position,
frame: 'enu',
viewFrom: followViewFrom(
found.sphere ?? { center: at, radius: 0 },
at,
camera,
),
};
camera.follow(target);
follow = target;
} catch (error) {
// A camera that cannot follow leaves the view where it is, as a
// viewer without entity tracking did.
console.warn(`${name}: cannot follow`, error);
}
}) ?? null;
return {
get following() {
return follow && findCamera(viewer)?.followed === follow ? follow : null;
},
/** Stop a follow this started, if the camera still keeps it. */
stop() {
const camera = findCamera(viewer);
if (follow && camera?.followed === follow) camera.follow(null);
follow = null;
},
destroy() {
this.stop();
off?.();
},
};
}
+119
View File
@@ -0,0 +1,119 @@
import test from 'node:test';
import assert from 'node:assert/strict';
import { followOnDoubleClick, followViewFrom } from './stockFollow.js';
import { bindRenderer } from '../render/rendererOf.js';
import { WGS84 } from '../geo/ellipsoid.js';
/** A viewer whose renderer answers picks with `hit` and records the camera. */
function scene({ hit, stock = true, enabled = true }) {
const viewer = {};
const handlers = new Map();
const calls = [];
const camera = {
followed: null,
controls: { minDistance: 0, maxDistance: Infinity },
pose: () => ({ fovy: Math.PI / 3, aspectRatio: 2 }),
follow(target) {
calls.push(['follow', target]);
camera.followed = target;
},
flyToBounds(sphere, options) {
calls.push(['flyToBounds', sphere, options]);
},
};
const unbind = bindRenderer(viewer, {
camera,
query: { pick: () => hit },
});
const input = {
onPointer(type, handler) {
handlers.set(type, handler);
return () => handlers.delete(type);
},
stockEnabled: (name) => name === 'dblclickFollow' && stock,
};
const at = { x: WGS84.radii.x, y: 0, z: 0 };
const follow = followOnDoubleClick({
viewer,
inputFor: () => input,
name: 'test-layer',
enabled: () => enabled,
targetFor: (picked) =>
picked.id === 'point'
? { key: 'layer:point', position: () => at }
: picked.id === 'line'
? { zoomTo: { center: at, radius: 50 } }
: null,
});
const dblclick = () =>
handlers.get('dblclick')?.({ position: { x: 1, y: 2 } });
return { follow, camera, calls, dblclick, handlers, unbind };
}
test('a double-click follows a point, framed as the default renderer framed an entity', () => {
const s = scene({ hit: { set: 'layer', id: 'point', surface: false } });
s.dblclick();
const [[kind, target]] = s.calls;
assert.equal(kind, 'follow');
assert.equal(target.key, 'layer:point');
assert.equal(target.frame, 'enu');
// No size: the minimum fit range, 45 degrees down on the ground.
const range = Math.hypot(
target.viewFrom.x,
target.viewFrom.y,
target.viewFrom.z,
);
assert.ok(Math.abs(range - 100) < 1e-6);
assert.ok(Math.abs(target.viewFrom.z + target.viewFrom.y) < 1e-6);
assert.equal(s.follow.following, target);
// Stopping ends only the follow it started.
s.follow.stop();
assert.equal(s.camera.followed, null);
s.follow.destroy();
assert.equal(s.handlers.size, 0);
s.unbind();
});
test('a double-click on a line zooms to it at once, following nothing', () => {
const s = scene({ hit: { set: 'layer', id: 'line', surface: false } });
s.camera.followed = { key: 'other' };
s.dblclick();
assert.deepEqual(
s.calls.map(([kind]) => kind),
['follow', 'flyToBounds'],
);
assert.equal(s.calls[0][1], null);
assert.deepEqual(s.calls[1][2], { durationS: 0 });
s.follow.destroy();
s.unbind();
});
test('no follow while the stock double-click is held off, the layer is off, or the pick is not its own', () => {
for (const options of [
{ hit: { id: 'point', surface: false }, stock: false },
{ hit: { id: 'point', surface: false }, enabled: false },
{ hit: { id: 'other', surface: false } },
{ hit: { surface: true } },
{ hit: null },
]) {
const s = scene(options);
s.dblclick();
assert.deepEqual(s.calls, []);
s.follow.destroy();
s.unbind();
}
});
test('the frame view fits a sphere and steepens far from the ground', () => {
const camera = { pose: () => ({ fovy: Math.PI / 2, aspectRatio: 1 }) };
const ground = { x: WGS84.radii.x, y: 0, z: 0 };
const near = followViewFrom({ center: ground, radius: 1000 }, ground, camera);
assert.ok(Math.abs(Math.hypot(near.x, near.y, near.z) - 1000) < 1e-6);
const high = { x: WGS84.radii.x * 2, y: 0, z: 0 };
const far = followViewFrom({ center: high, radius: 0 }, high, camera);
// Looking down 45 degrees times 1.5 at twice the radius: the eye that
// far above, south of the point.
const elevation = Math.atan2(far.z, Math.hypot(far.x, far.y));
assert.ok(Math.abs(elevation - (Math.PI / 4) * 1.5) < 1e-9);
assert.ok(far.y < 0);
});
+192 -90
View File
@@ -1,4 +1,3 @@
import * as Cesium from 'cesium';
import {
decodeXml,
kmzImageResolver,
@@ -15,9 +14,9 @@ import {
tn,
} from '../../i18n/index.js';
import { createHorizonCull } from '../streetLevel/view.js';
// The horizon cull reads the camera and frame ports: a viewer of a
// caller's own gets them from the unbound factories this loads.
import '../../render/cesium/camera.js';
import { fromDegrees } from '../../geo/ellipsoid.js';
import { hexColor } from '../../render/color.js';
import { drawOf, findFrame } from '../../render/rendererOf.js';
import { readGhostMapsKml } from './kml.js';
import { fieldLabel, parseDescriptionFields, wrapCardText } from './records.js';
import { inputFor as defaultInputFor } from '../../input/dispatcher.js';
@@ -110,10 +109,34 @@ function markerImage(color) {
return url;
}
const cesiumColor = (rgba, fallback, alpha) =>
const drawColor = (rgba, fallback, alpha) =>
rgba
? new Cesium.Color(rgba[0], rgba[1], rgba[2], alpha ?? rgba[3])
: Cesium.Color.fromCssColorString(fallback).withAlpha(alpha ?? 1);
? [rgba[0], rgba[1], rgba[2], alpha ?? rgba[3]]
: hexColor(fallback, alpha ?? 1);
/** The size a marker image draws at, before its scale: the product marker. */
const MARKER_SIZE = [20, 20];
/**
* An image's own size in pixels, as an icon drew it unsized; null when it
* cannot be read here (no DOM, or the image does not decode).
*/
async function imageSizeOf(url) {
if (typeof globalThis.Image !== 'function' || !url) return null;
try {
const image = new globalThis.Image();
image.src = url;
await image.decode();
return image.naturalWidth > 0 && image.naturalHeight > 0
? [image.naturalWidth, image.naturalHeight]
: null;
} catch {
return null;
}
}
/** Each layer's draw sets have ids of their own. */
let instances = 0;
function anchorOf(geometry) {
if (geometry.type === 'point') return geometry.position;
@@ -157,7 +180,7 @@ export function createGhostMapsLayer({
let _selectedLink = null;
let _lifetime = new AbortController();
let _selection = readStoredSelection(storage);
/** productId → {version, dataSource, urls, count, features} */
/** productId → {version, sets, urls, features, pins} */
const _loaded = new Map();
/** productId → in-flight version */
const _loading = new Map();
@@ -165,7 +188,11 @@ export function createGhostMapsLayer({
const _failed = new Map();
const notifyRow = () => _rowListener?.();
const render = () => _viewer?.scene?.requestRender?.();
const render = () =>
_viewer && findFrame(_viewer)?.requestRender?.('ghostmaps');
/** This layer's draw sets' ids start with this; one set per edition. */
const setBase = `${GHOSTMAPS_LAYER_ID}:${++instances}`;
let editions = 0;
// Pins skip the depth test, and with Google 3D tiles the globe is hidden,
// so nothing else stops far-side pins drawing through the planet.
const _horizon = createHorizonCull({
@@ -173,7 +200,16 @@ export function createGhostMapsLayer({
items: function* () {
for (const item of _loaded.values()) yield* item.pins;
},
onChange: render,
// Pins the cull turned are written to their editions' icon sets.
onChange: (changed) => {
const bySet = new Map();
for (const pin of changed) {
if (!bySet.has(pin.set)) bySet.set(pin.set, []);
bySet.get(pin.set).push(pin.item);
}
for (const [set, items] of bySet) set?.upsert(items);
render();
},
});
const canSelect = () => overlayHost && inputFor && picking;
@@ -189,12 +225,61 @@ export function createGhostMapsLayer({
const item = _loaded.get(id);
if (!item) return;
_loaded.delete(id);
_viewer?.dataSources?.remove(item.dataSource, true);
disposeSets(item.sets);
item.urls.forEach((url) => URL.revokeObjectURL(url));
if (_selectedKey?.startsWith(`${id}:`)) clearSelection();
}
/** Build one product's data source off-scene, then swap it in. */
function disposeSets(sets) {
if (!sets) return;
for (const set of Object.values(sets)) set.dispose();
}
/**
* Draw a loaded edition in sets of its own, beside any edition drawing
* now. One that cannot be drawn draws nothing and lets its images go.
*/
function mount(next) {
const base = `${setBase}:${++editions}`;
const sets = {};
try {
// Inside the try: a viewer with no renderer bound draws nothing and
// still lets the edition's images go.
const draw = drawOf(_viewer);
sets.shapes = draw.shapes({ id: `${base}:shapes`, clampTo: 'both' });
sets.lines = draw.lines({ id: `${base}:lines`, clampTo: 'both' });
sets.icons = draw.icons({ id: `${base}:icons`, clampTo: 'both' });
sets.shapes.set(next.items.shapes);
sets.lines.set(next.items.lines);
sets.icons.set(next.items.icons);
} catch (error) {
disposeSets(sets);
next.urls.forEach((url) => URL.revokeObjectURL(url));
throw error;
}
for (const pin of next.pins) pin.set = sets.icons;
next.sets = sets;
}
/** The placemark a hit on one of this layer's items is, or null. */
function hitKey(hit) {
if (
!hit?.set?.startsWith(`${setBase}:`) ||
!hit.id?.startsWith(PICK_PREFIX)
)
return null;
const [productId, index] = hit.id.slice(PICK_PREFIX.length).split(':');
const loaded = _loaded.get(productId);
// Only the drawing edition's sets: a retiring one may still pick.
const current = loaded?.sets
? Object.values(loaded.sets).some((set) => set?.id === hit.set)
: false;
return current && loaded.features[Number(index)]
? `${productId}:${index}`
: null;
}
/** Build one product's draw items off-scene, then swap them in. */
async function load(product, signal) {
const bytes = await source.getFile(product.id, product.version, { signal });
signal.throwIfAborted();
@@ -222,93 +307,113 @@ export function createGhostMapsLayer({
entries.clear();
signal.throwIfAborted();
const color = PRODUCT_COLORS[product.id] || ACCENT;
const dataSource = new Cesium.CustomDataSource(
`${GHOSTMAPS_LAYER_ID}:${product.id}`,
);
const icons = [];
const lines = [];
const shapes = [];
const features = [];
const pins = [];
dataSource.entities.suspendEvents();
// Each distinct icon's own size, read once: icons draw at it, scaled.
const sizes = new Map();
const marker = markerImage(color);
for (const feature of parsed.features)
for (const geometry of feature.geometries)
if (geometry.type === 'point') {
const image = feature.style.icon || marker;
if (image && !sizes.has(image))
sizes.set(
image,
image === marker ? MARKER_SIZE : imageSizeOf(image),
);
}
for (const [image, size] of sizes) sizes.set(image, await size);
signal.throwIfAborted();
parsed.features.forEach((feature, index) => {
const key = `${product.id}:${index}`;
const { style } = feature;
feature.geometries.forEach((geometry, part) => {
const id = `${PICK_PREFIX}${key}:${part}`;
if (geometry.type === 'point') {
const position = Cesium.Cartesian3.fromDegrees(
...geometry.position,
);
const entity = dataSource.entities.add({
const position = fromDegrees(...geometry.position);
const image = style.icon || marker;
// An image that cannot be drawn shows nothing, as before.
if (!image) return;
const item = {
id,
position,
billboard: {
image: style.icon || markerImage(color),
scale: Math.min(
1.5,
Math.max(0.35, (style.iconScale ?? 1) * 0.7),
),
color:
style.icon && style.iconColor
? cesiumColor(style.iconColor)
: undefined,
heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
verticalOrigin: Cesium.VerticalOrigin.CENTER,
// Ground-clamped icons would sink into terrain and 3D tiles; the
// horizon cull hides the far side instead (see `_horizon`).
disableDepthTestDistance: Number.POSITIVE_INFINITY,
},
});
pos: position,
image,
size: sizes.get(image) ?? MARKER_SIZE,
scale: Math.min(
1.5,
Math.max(0.35, (style.iconScale ?? 1) * 0.7),
),
...(style.icon && style.iconColor
? { color: style.iconColor }
: {}),
height: 'clampGround',
anchor: 'center',
// Ground-clamped icons would sink into terrain and 3D tiles; the
// horizon cull hides the far side instead (see `_horizon`).
disableDepthTest: Number.POSITIVE_INFINITY,
};
const at = icons.push(item) - 1;
// What the horizon cull turns: the icon as it draws now, in its
// edition's icon set once mounted.
pins.push({
position,
set: null,
get item() {
return icons[at];
},
get show() {
return entity.show;
return icons[at].show !== false;
},
set show(value) {
entity.show = value;
icons[at] = { ...icons[at], show: value };
},
});
} else if (geometry.type === 'line') {
dataSource.entities.add({
lines.push({
id,
polyline: {
positions: Cesium.Cartesian3.fromDegreesArray(
geometry.positions.flat(),
),
width: Math.min(8, Math.max(1.5, style.lineWidth ?? 2)),
material: cesiumColor(style.lineColor, color),
clampToGround: true,
positions: geometry.positions.map(([lon, lat]) =>
fromDegrees(lon, lat),
),
widthPx: Math.min(8, Math.max(1.5, style.lineWidth ?? 2)),
mode: 'draped',
style: {
kind: 'solid',
color: drawColor(style.lineColor, color),
},
});
} else {
const ring = (points) =>
Cesium.Cartesian3.fromDegreesArray(points.flat());
dataSource.entities.add({
const ring = (points) => points.map(([lon, lat]) => ({ lon, lat }));
shapes.push({
id,
polygon: {
hierarchy: new Cesium.PolygonHierarchy(
ring(geometry.outer),
geometry.holes.map(
(hole) => new Cesium.PolygonHierarchy(ring(hole)),
),
),
material:
style.fill === false
? Cesium.Color.TRANSPARENT
: cesiumColor(
style.polyColor,
color,
style.polyColor ? undefined : 0.25,
),
classificationType: Cesium.ClassificationType.BOTH,
geometry: {
kind: 'polygon',
rings: [ring(geometry.outer), ...geometry.holes.map(ring)],
},
// An unfilled polygon is still there to click, as before.
fill:
style.fill === false
? [0, 0, 0, 0]
: drawColor(
style.polyColor,
color,
style.polyColor ? undefined : 0.25,
),
height: 'clampGround',
});
if (style.outline !== false)
dataSource.entities.add({
lines.push({
id: `${id}:outline`,
polyline: {
positions: ring([...geometry.outer, geometry.outer[0]]),
width: Math.min(6, Math.max(1.5, style.lineWidth ?? 2)),
material: cesiumColor(style.lineColor, color),
clampToGround: true,
positions: [...geometry.outer, geometry.outer[0]].map(
([lon, lat]) => fromDegrees(lon, lat),
),
widthPx: Math.min(6, Math.max(1.5, style.lineWidth ?? 2)),
mode: 'draped',
style: {
kind: 'solid',
color: drawColor(style.lineColor, color),
},
});
}
@@ -320,8 +425,14 @@ export function createGhostMapsLayer({
anchor: anchorOf(feature.geometries[0]),
});
});
dataSource.entities.resumeEvents();
return { version: product.version, dataSource, urls, features, pins };
return {
version: product.version,
items: { icons, lines, shapes },
sets: null,
urls,
features,
pins,
};
} catch (error) {
urls.forEach((url) => URL.revokeObjectURL(url));
throw error;
@@ -351,8 +462,8 @@ export function createGhostMapsLayer({
return;
}
// Cull before the first frame so far-side pins never flash.
_horizon.update(next.pins);
await _viewer.dataSources.add(next.dataSource);
_horizon.update(next.pins, { quiet: true });
mount(next);
// The new edition is on the globe before the old one leaves.
unload(product.id);
_loaded.set(product.id, next);
@@ -459,7 +570,7 @@ export function createGhostMapsLayer({
// when its marker turns behind the planet.
stateless: true,
horizonCull: true,
position: Cesium.Cartesian3.fromDegrees(...feature.anchor),
position: fromDegrees(...feature.anchor),
};
if (card.interactive) {
const link = _selectedLink;
@@ -487,16 +598,6 @@ export function createGhostMapsLayer({
overlayHost?.setEntries(GHOSTMAPS_OVERLAY_SOURCE_ID, [], CARD_HOST_OPTIONS);
}
function pickedKey(picked) {
const pickId = picking.resolvePickId(picked);
if (typeof pickId !== 'string' || !pickId.startsWith(PICK_PREFIX))
return null;
const [productId, index] = pickId.slice(PICK_PREFIX.length).split(':');
return _loaded.get(productId)?.features[Number(index)]
? `${productId}:${index}`
: null;
}
function installClickHandler() {
if (!canSelect() || _clickSubscription || !_viewer) return;
picking.registerPickOwner?.(
@@ -515,7 +616,7 @@ export function createGhostMapsLayer({
return;
}
const picked = event.pick;
const key = picked ? pickedKey(picked) : null;
const key = picked ? hitKey(event.drawHit) : null;
if (key) {
_selectedKey = key;
publishCard();
@@ -563,7 +664,8 @@ export function createGhostMapsLayer({
enable() {
_enabled = true;
_lifetime = new AbortController();
for (const item of _loaded.values()) item.dataSource.show = true;
for (const item of _loaded.values())
for (const set of Object.values(item.sets ?? {})) set.show = true;
installClickHandler();
if (!_unsubscribe && typeof source.subscribe === 'function')
_unsubscribe = source.subscribe(
+38 -17
View File
@@ -1,7 +1,7 @@
import assert from 'node:assert/strict';
import test from 'node:test';
import * as Cesium from 'cesium';
import { createGhostMapsLayer } from './index.js';
import { bindFakeDraw } from '../../testSupport/fakeDrawPort.mjs';
function element(localName, children = [], value = '', attributes = {}) {
const node = {
@@ -104,17 +104,17 @@ function fixture(t, { beforeFileReturns, onCreateUrl } = {}) {
});
t.mock.method(URL, 'revokeObjectURL', (url) => revoked.push(url));
t.mock.method(console, 'warn', () => {});
const mounted = new Set();
const viewer = {
scene: { requestRender() {} },
dataSources: {
async add(dataSource) {
mounted.add(dataSource);
return dataSource;
},
remove(dataSource) {
return mounted.delete(dataSource);
},
const viewer = {};
const { draw, unbind } = bindFakeDraw(viewer);
t.after(unbind);
// The editions drawn: each draws in sets of its own.
const mounted = {
get size() {
return new Set(
[...draw.sets.values()]
.filter((set) => !set.disposed)
.map((set) => set.spec.id.split(':').slice(0, 3).join(':')),
).size;
},
};
const layer = createGhostMapsLayer({
@@ -132,7 +132,7 @@ function fixture(t, { beforeFileReturns, onCreateUrl } = {}) {
layer.init(viewer);
layer.enable();
t.after(() => layer.destroy());
return { layer, viewer, mounted, created, revoked };
return { layer, viewer, draw, unbind, mounted, created, revoked };
}
test('cancelling a file read does not allocate packed-image URLs', async (t) => {
@@ -155,9 +155,9 @@ test('cancellation during parsing releases every packed-image URL', async (t) =>
assert.equal(mounted.size, 0);
});
test('entity construction failure releases parsed image URLs', async (t) => {
const { layer, viewer, mounted, created, revoked } = fixture(t);
t.mock.method(Cesium.EntityCollection.prototype, 'add', () => {
test('a draw failure releases parsed image URLs', async (t) => {
const { layer, viewer, draw, mounted, created, revoked } = fixture(t);
t.mock.method(draw, 'icons', () => {
throw new Error('fixture entity failure');
});
await layer.update(viewer);
@@ -167,13 +167,34 @@ test('entity construction failure releases parsed image URLs', async (t) => {
assert.equal(layer.getStats().error, 'fixture entity failure');
});
test('a viewer with no renderer bound releases parsed image URLs', async (t) => {
const { layer, viewer, unbind, mounted, created, revoked } = fixture(t);
unbind();
await layer.update(viewer);
assert.equal(created.length, 1);
assert.deepEqual(revoked, created);
assert.equal(mounted.size, 0);
assert.ok(layer.getStats().error);
});
test('successful load keeps icons until the product is disabled', async (t) => {
const { layer, viewer, mounted, created, revoked } = fixture(t);
const { layer, viewer, draw, mounted, created, revoked } = fixture(t);
await layer.update(viewer);
assert.equal(created.length, 1);
assert.equal(revoked.length, 0);
assert.equal(mounted.size, 1);
assert.equal(layer.getStats().count, 1);
const pins = [...draw.sets.values()].find(
(set) => !set.disposed && set.kind === 'icons',
);
const [pin] = pins.items.values();
assert.equal(pin.id, 'ghostmaps:cip:0:0');
assert.equal(pin.image, 'blob:local-0');
assert.equal(pin.height, 'clampGround');
assert.equal(pins.spec.clampTo, 'both');
assert.equal(pin.disableDepthTest, Infinity);
assert.equal(pin.scale, 0.7);
assert.deepEqual(pin.size, [20, 20], 'unread in Node: the marker size');
layer.disable();
assert.deepEqual(revoked, created);
assert.equal(mounted.size, 0);
+31 -14
View File
@@ -231,32 +231,49 @@ test('mission hover preserves the cursor of a pointer-owning tool', () => {
assert.equal(viewer.scene.canvas.style.cursor, 'crosshair');
});
test('mission picks are read by the rendering part, which owns the entities', async () => {
test('mission picks are read by the rendering part, which owns the draw sets', async () => {
const { createRendering } = await import('./rendering.js');
const mission = { id: 'rocket-launch:abc' };
const { bindFakeDraw } = await import('../../testSupport/fakeDrawPort.mjs');
const drilled = [];
const state = {
_viewer: {
scene: {
drillPick(position, limit) {
drilled.push([position, limit]);
return [{ id: { id: 'cable:1' } }, { id: mission }];
},
const viewer = {};
let hits = [];
const { unbind } = bindFakeDraw(viewer, {
query: {
drillPick(x, y, options) {
drilled.push([x, y, options]);
return hits;
},
},
};
});
const state = { _viewer: viewer };
const rendering = createRendering({
state,
services: { satellites: {} },
parts: {},
});
rendering.attach(viewer);
const { sites, lines } = rendering.setIds;
hits = [
{ set: 'cables:1', id: 'rocket-launch:zzz', surface: false },
{ set: sites, id: 'rocket-launch:abc', surface: false },
];
assert.equal(rendering.launchMarkerAt({ x: 3, y: 4 }), true);
assert.deepEqual(drilled, [[{ x: 3, y: 4 }, 12]]);
assert.deepEqual(drilled, [[3, 4, { limit: 12 }]]);
assert.equal(rendering.launchIdFromPicks(hits), 'abc');
assert.equal(
rendering.launchIdFromPicks([{ id: 'x' }, { id: mission }]),
'abc',
rendering.launchIdFromPicks([
{ set: lines, id: 'rocket-trajectory:def:0', surface: false },
]),
'def',
);
assert.equal(rendering.launchIdFromPicks([{ id: 'x' }]), null);
assert.equal(
rendering.launchIdFromPicks([{ set: sites, id: 'x', surface: false }]),
null,
);
hits = [hits[0]];
assert.equal(rendering.launchMarkerAt({ x: 3, y: 4 }), false);
state._viewer = null;
assert.equal(rendering.launchMarkerAt({ x: 3, y: 4 }), false);
rendering.detach();
unbind();
});
+3 -2
View File
@@ -182,7 +182,7 @@ export function createIngestion({
if (
!layerState._enabled ||
token !== layerState._lifecycleToken ||
!layerState._dataSource
!layerState._missionSets
)
return;
const activeTleText = layerState._activeTleText;
@@ -195,8 +195,9 @@ export function createIngestion({
layerState._replayTracks.clear();
layerState._orbitMatches = 0;
launches.forEach((launch) =>
parts.rendering.addLaunchEntity(launch, activeTleText),
parts.rendering.addLaunchEntity(launch, activeTleText, { defer: true }),
);
parts.rendering.flushLaunchEntities();
layerState._renderedTleText = activeTleText;
if (layerState._renderedTleText === layerState._activeTleText)
clearPostTleRetry();
+28 -23
View File
@@ -71,7 +71,7 @@ async function fixture({ legacySource = false } = {}) {
const state = createState({ services });
state._enabled = true;
state._lifecycleToken = 1;
state._dataSource = new Cesium.CustomDataSource('owned-qualification');
state._missionSets = { show: false, items: [] };
const canvas = Object.assign(new EventTarget(), {
disableRootEvents: true,
onwheel: null,
@@ -82,9 +82,10 @@ async function fixture({ legacySource = false } = {}) {
scene: { canvas, preRender: new Cesium.Event(), drillPick: () => [] },
};
bindRenderer(viewer, { frame: fakeSceneFrame(viewer) });
await viewer.dataSources.add(state._dataSource);
// Only presentation boundaries are inert. Source, normalization, state,
// ingestion, lifecycle, stats and feed-state policy execute unchanged.
// Mission draw sets attached and not let go: the fixture starts with one.
let attached = 1;
const parts = {
panel: {
createMissionPanel: noop,
@@ -115,32 +116,31 @@ async function fixture({ legacySource = false } = {}) {
destroyLaunchPadZonePrimitive: noop,
},
rendering: {
// As the rendering part owns the entities' data source.
attach(target) {
state._dataSource = new Cesium.CustomDataSource('rocket-launches');
state._dataSource.show = false;
target.dataSources.add(state._dataSource);
// As the rendering part owns the mission draw sets.
attach() {
state._missionSets = { show: false, items: [] };
attached += 1;
},
detach(target) {
if (state._dataSource)
target.dataSources.remove(state._dataSource, true);
state._dataSource = null;
detach() {
if (state._missionSets) attached -= 1;
state._missionSets = null;
},
updateMissionFrame: noop,
missionsShown: () => Boolean(state._dataSource?.show),
missionsShown: () => Boolean(state._missionSets?.show),
showMissions(shown) {
if (state._dataSource) state._dataSource.show = shown;
if (state._missionSets) state._missionSets.show = shown;
},
clearLaunchEntities: () => {
if (state._missionSets) state._missionSets.items = [];
},
clearLaunchEntities: () => state._dataSource?.entities.removeAll(),
launchIdFromPicks: () => null,
missionHitsAt: () => [],
followTargetFor: () => null,
launchMarkerAt: () => false,
addLaunchEntity(record) {
state._dataSource.entities.add({
id: record.id,
name: record.name,
position: Cesium.Cartesian3.fromDegrees(record.lon, record.lat),
});
state._missionSets.items.push(record.id);
},
flushLaunchEntities() {},
},
};
const context = { state, services, parts, source };
@@ -153,7 +153,7 @@ async function fixture({ legacySource = false } = {}) {
return {
stats,
feed: layerFeedState(stats),
rendered: state._dataSource?.entities.values.map((x) => x.id) || [],
rendered: state._missionSets?.items.slice() || [],
enabled: state._enabled,
};
};
@@ -163,6 +163,7 @@ async function fixture({ legacySource = false } = {}) {
source,
current,
viewer,
attachedSets: () => attached,
init: () => parts.lifecycle.methods.init(viewer),
update: () => parts.ingestion.methods.update(),
disable: () => parts.lifecycle.methods.disable(),
@@ -317,15 +318,19 @@ test('destroy followed by actual init starts a clean instance with owned handler
assert.equal(value.stats.lastUpdate, null);
assert.equal(value.stats.error, null);
assert.equal(value.enabled, false);
assert.equal(f.viewer.dataSources.length, 1);
assert.equal(f.attachedSets(), 1);
assert.equal(f.viewer.scene.preRender.numberOfListeners, 1);
const input = inputFor(f.viewer);
const before = input.subscriberCount();
assert.equal(typeof f.state._inputSubscription, 'function');
await f.destroy();
assert.equal(f.state._inputSubscription, null);
assert.equal(input.subscriberCount(), before - 2, 'click and hover');
assert.equal(f.viewer.dataSources.length, 0);
assert.equal(
input.subscriberCount(),
before - 3,
'click, hover and double-click follow',
);
assert.equal(f.attachedSets(), 0);
assert.equal(f.viewer.scene.preRender.numberOfListeners, 0);
} finally {
await f.close();
+92 -119
View File
@@ -1,146 +1,118 @@
import * as Cesium from 'cesium';
import { fromDegrees } from '../../geo/ellipsoid.js';
import { distance } from '../../geo/vector.js';
import { findCamera, findFrame } from '../../render/rendererOf.js';
import { hexColor } from '../../render/color.js';
import { LAUNCH_PAD_ZONE_RADIUS_M } from './policy.js';
/** The zone's colour: a faint fill under a brighter rim. */
const ZONE_COLOR = '#22e6e6';
const ZONE_FILL_ALPHA = 0.105;
const ZONE_RIM_ALPHA = 0.72;
/** The rim's width, a fraction of the zone's radius. */
const ZONE_RIM_WIDTH = 0.033;
/**
* Pulled toward the eye, metres, so the zone is not buried by the pad's
* mesh at oblique angles, without a height that would float it.
*/
const ZONE_DEPTH_BIAS_M = 1;
export function createLaunchPad({
state: layerState,
services,
parts,
source,
}) {
function zoneSet() {
return layerState._missionSets?.pad ?? null;
}
function hideLaunchPadZone() {
if (layerState._launchPadZonePrimitive)
layerState._launchPadZonePrimitive.show = false;
const item = layerState._launchPadZoneItem;
if (!item || item.show === false) return;
layerState._launchPadZoneItem = { ...item, show: false };
zoneSet()?.upsert([layerState._launchPadZoneItem]);
}
function removeLaunchPadZonePrimitive() {
if (
layerState._launchPadZonePrimitive &&
layerState._viewer?.scene?.primitives
) {
layerState._viewer.scene.primitives.remove(
layerState._launchPadZonePrimitive,
);
}
layerState._launchPadZonePrimitive = null;
if (layerState._launchPadZoneItem) zoneSet()?.clear();
layerState._launchPadZoneItem = null;
layerState._launchPadZoneLaunchId = null;
}
/** The zone drawn around a launch's pad, draped on the ground. */
function createLaunchPadZonePrimitive(launch) {
removeLaunchPadZonePrimitive();
const material = new Cesium.Material({
fabric: {
type: 'GevLaunchPadZone',
uniforms: {
color: Cesium.Color.fromCssColorString('#22e6e6'),
fillAlpha: 0.105,
rimAlpha: 0.72,
},
source: `
czm_material czm_getMaterial(czm_materialInput materialInput) {
czm_material material = czm_getDefaultMaterial(materialInput);
vec2 centered = (materialInput.st - vec2(0.5)) * 2.0;
float radius = length(centered);
float inside = 1.0 - smoothstep(0.985, 1.0, radius);
float rim = smoothstep(0.952, 0.985, radius) * inside;
material.diffuse = color.rgb;
material.emission = color.rgb * rim * 0.35;
material.alpha = color.a * inside * mix(fillAlpha, rimAlpha, rim);
return material;
}`,
const item = {
id: `rocket-pad-zone:${launch.id}`,
geometry: {
kind: 'ellipse',
center: { lon: launch.lon, lat: launch.lat },
semiMajor: LAUNCH_PAD_ZONE_RADIUS_M,
semiMinor: LAUNCH_PAD_ZONE_RADIUS_M,
},
});
const geometry = new Cesium.EllipseGeometry({
center: Cesium.Cartesian3.fromDegrees(launch.lon, launch.lat),
semiMajorAxis: LAUNCH_PAD_ZONE_RADIUS_M,
semiMinorAxis: LAUNCH_PAD_ZONE_RADIUS_M,
granularity: Cesium.Math.toRadians(0.08),
vertexFormat:
Cesium.MaterialAppearance.MaterialSupport.TEXTURED.vertexFormat,
});
layerState._launchPadZonePrimitive =
layerState._viewer.scene.primitives.add(
new Cesium.GroundPrimitive({
geometryInstances: new Cesium.GeometryInstance({
geometry,
id: `rocket-pad-zone:${launch.id}`,
}),
appearance: new Cesium.MaterialAppearance({
material,
translucent: true,
closed: false,
faceForward: true,
flat: true,
// Keep the zone classified onto the photoreal surface, but bias only its
// rasterized depth toward the camera. This avoids coplanar fragments
// being intermittently buried by the launch-pad mesh at oblique angles
// without adding a world-space height that would make the ring float.
renderState: {
depthTest: {
enabled: true,
},
depthMask: false,
polygonOffset: {
enabled: true,
factor: -1,
units: -4,
},
blending: Cesium.BlendingState.ALPHA_BLEND,
},
}),
classificationType: Cesium.ClassificationType.BOTH,
asynchronous: true,
show: true,
}),
);
fill: {
preset: 'radialRim',
color: hexColor(ZONE_COLOR, ZONE_FILL_ALPHA),
rimColor: hexColor(ZONE_COLOR, ZONE_RIM_ALPHA),
rimWidth: ZONE_RIM_WIDTH,
},
height: 'clampGround',
clampTo: 'both',
depthBias: ZONE_DEPTH_BIAS_M,
show: true,
};
layerState._launchPadZoneItem = item;
zoneSet()?.set([item]);
layerState._launchPadZoneLaunchId = launch.id;
}
/** Before each frame: the rings' labels, and the selected pad's zone. */
function updateLaunchPadZone() {
if (!layerState._enabled || !parts.rendering.missionsShown()) {
hideLaunchPadZone();
return;
}
const nowMs = Date.now();
if (nowMs - layerState._lastMissionRingRotationMs >= 1000) {
parts.orbitRendering.updateMissionOrbitPrimitiveFrames(nowMs);
layerState._lastMissionRingRotationMs = nowMs;
}
const launch = layerState._launches.find(
(item) => item.id === layerState._selectedLaunchId,
);
const pose = findCamera(layerState._viewer)?.pose();
if (!launch || !pose) {
hideLaunchPadZone();
return;
}
const launchPosition = fromDegrees(launch.lon, launch.lat);
const visible = parts.policyHelpers.launchPadZoneVisible({
layerActive: parts.rendering.missionsShown(),
selectedLaunchId: layerState._selectedLaunchId,
launchId: launch.id,
cameraHeightM: pose.height,
cameraDistanceM: distance(pose.position, launchPosition),
});
if (!visible) {
hideLaunchPadZone();
return;
}
if (layerState._launchPadZoneLaunchId !== launch.id)
createLaunchPadZonePrimitive(launch);
else if (layerState._launchPadZoneItem.show === false) {
layerState._launchPadZoneItem = {
...layerState._launchPadZoneItem,
show: true,
};
zoneSet()?.upsert([layerState._launchPadZoneItem]);
}
}
function initLaunchPadZonePrimitive() {
if (!layerState._viewer || layerState._launchPadZoneRemover) return;
layerState._launchPadZoneRemover =
layerState._viewer.scene.preRender.addEventListener(() => {
if (!layerState._enabled || !layerState._dataSource?.show) {
hideLaunchPadZone();
return;
}
const nowMs = Date.now();
if (nowMs - layerState._lastMissionRingRotationMs >= 1000) {
layerState._missionRingDate.setTime(nowMs);
parts.orbitRendering.updateMissionOrbitPrimitiveFrames(
layerState._missionRingDate,
);
layerState._lastMissionRingRotationMs = nowMs;
}
const launch = layerState._launches.find(
(item) => item.id === layerState._selectedLaunchId,
);
const camera = layerState._viewer?.camera;
if (!launch || !camera) {
hideLaunchPadZone();
return;
}
const launchPosition = Cesium.Cartesian3.fromDegrees(
launch.lon,
launch.lat,
);
const visible = parts.policyHelpers.launchPadZoneVisible({
layerActive: Boolean(layerState._dataSource?.show),
selectedLaunchId: layerState._selectedLaunchId,
launchId: launch.id,
cameraHeightM: camera.positionCartographic?.height,
cameraDistanceM: Cesium.Cartesian3.distance(
camera.positionWC,
launchPosition,
),
});
if (!visible) {
hideLaunchPadZone();
return;
}
if (layerState._launchPadZoneLaunchId !== launch.id)
createLaunchPadZonePrimitive(launch);
layerState._launchPadZonePrimitive.show = true;
});
findFrame(layerState._viewer)?.on('preRender', updateLaunchPadZone) ??
null;
}
function destroyLaunchPadZonePrimitive() {
@@ -154,5 +126,6 @@ export function createLaunchPad({
createLaunchPadZonePrimitive,
initLaunchPadZonePrimitive,
destroyLaunchPadZonePrimitive,
updateLaunchPadZone,
};
}
+19 -3
View File
@@ -1,6 +1,7 @@
import { isPointerFree } from '../../data/inputOwnership.js';
import { inputFor } from '../../input/dispatcher.js';
import { canvasOf, findCamera, findFrame } from '../../render/rendererOf.js';
import { followOnDoubleClick } from '../../data/stockFollow.js';
const HOVER_PICK_INTERVAL_MS = 120;
@@ -140,7 +141,10 @@ export function createLifecycle({
const input = inputFor(viewer);
const unsubscribeClick = input.onClick((event) => {
if (!layerState._enabled || !parts.rendering.missionsShown()) return;
const launchId = parts.rendering.launchIdFromPicks(event.drill(12));
// The click's pick position (CSS px), as the click picked it.
const launchId = parts.rendering.launchIdFromPicks(
parts.rendering.missionHitsAt(event.position, 12),
);
if (!launchId) return;
parts.selection.setSelectedMission(launchId);
parts.selection.focusMission(
@@ -153,11 +157,22 @@ export function createLifecycle({
launchAt: parts.rendering.launchMarkerAt,
});
const unsubscribeHover = input.onPointer('move', hover.move);
// A double-click follows a mission point, as the default renderer
// followed the missions' entities.
layerState._stockFollow = followOnDoubleClick({
viewer,
inputFor: () => input,
name: 'rocket-launches',
enabled: () => layerState._enabled && parts.rendering.missionsShown(),
targetFor: parts.rendering.followTargetFor,
});
layerState._inputSubscription = () => {
unsubscribeClick();
unsubscribeHover();
layerState._stockFollow?.destroy();
layerState._stockFollow = null;
};
// Apply horizon visibility before Cesium traverses and picks the scene.
// Apply horizon visibility before the renderer draws and picks.
// A postRender write is one frame late and can remain visibly stale when
// request-on-demand rendering stops after a globe camera move.
layerState._declutterHandler =
@@ -215,6 +230,7 @@ export function createLifecycle({
parts.replay.stopMissionReplay();
parts.selection.stopMissionZoomAnchor();
parts.rendering.showMissions(false);
layerState._stockFollow?.stop();
parts.orbitRendering.syncMissionOrbitPrimitiveVisibility();
const canvas = canvasOf(layerState._viewer);
if (canvas) canvas.style.cursor = '';
@@ -254,7 +270,7 @@ export function createLifecycle({
layerState._replayTracks.clear();
parts.panel.clearMissionPanel();
layerState._viewer = null;
parts.rendering.detach(viewer);
parts.rendering.detach();
layerState._count = 0;
layerState._orbitMatches = 0;
layerState._lastUpdate = null;
+150 -132
View File
@@ -1,183 +1,201 @@
import * as Cesium from 'cesium';
import { temeToPseudoFixed } from '../../geo/celestial.js';
import {
MISSION_ORBIT_PATTERN_GROUPS,
MISSION_ORBIT_DASHES_PER_GROUP,
} from './policy.js';
/** Pattern cells' width in the mission orbit image, pixels. */
const CELL_PX = 8;
/** The pattern image's height: the line's width, across. */
const PATTERN_HEIGHT_PX = 16;
const smoothstep = (edge0, edge1, x) => {
const t = Math.min(1, Math.max(0, (x - edge0) / (edge1 - edge0)));
return t * t * (3 - 2 * t);
};
/**
* The selected-orbit tactical pattern, one group of it: a compact round dot
* followed by one hundred short dashes, in `css` (`#rrggbb`) at `alpha`.
* Lit as the line drew it: the dot glows brighter than the dashes. Along
* the image is along the line; across is across its width.
*/
function drawMissionOrbitPattern(canvas, css, alpha) {
const cells = MISSION_ORBIT_DASHES_PER_GROUP + 1;
const width = cells * CELL_PX;
const height = PATTERN_HEIGHT_PX;
canvas.width = width;
canvas.height = height;
const context = canvas.getContext?.('2d');
// A canvas that cannot draw (no 2D context) stays blank.
if (typeof context?.createImageData !== 'function') return;
const image = context.createImageData(width, height);
const n = Number.parseInt(css.slice(1), 16);
const rgb = [(n >> 16) & 255, (n >> 8) & 255, n & 255];
// Antialiased across a pixel, as the pattern's edges were.
const edge = 1 / CELL_PX;
for (let px = 0; px < width; px++) {
const markPosition = (px + 0.5) / CELL_PX;
const markIndex = Math.floor(markPosition);
const local = markPosition - markIndex;
const isDot = markIndex === 0;
const centerDistance = Math.abs(local - 0.5);
const dashAlong =
1 - smoothstep(0.27 - edge * 1.35, 0.27 + edge * 1.35, centerDistance);
const dotAlong = (local - 0.5) / 0.32;
const glow = 1 + (isDot ? 0.65 : 0.07);
for (let py = 0; py < height; py++) {
const t = (py + 0.5) / height;
let visible;
if (isDot) {
const across = (t - 0.5) / 0.5;
visible = 1 - smoothstep(0.78, 1, Math.hypot(dotAlong, across));
} else {
const dashAcross = 1 - smoothstep(0.12, 0.24, Math.abs(t - 0.5));
visible = dashAlong * dashAcross;
}
const at = (py * width + px) * 4;
image.data[at] = Math.min(255, rgb[0] * glow);
image.data[at + 1] = Math.min(255, rgb[1] * glow);
image.data[at + 2] = Math.min(255, rgb[2] * glow);
image.data[at + 3] = Math.round(
255 * alpha * visible * (isDot ? 1 : 0.58),
);
}
}
context.putImageData(image, 0, 0);
}
/**
* The sidereal angle the inertial frame is turned by at `ms`, radians:
* a point there is drawn at that angle less around the Earth's axis.
*/
function siderealAngle(ms) {
const frame = temeToPseudoFixed(ms);
return Math.atan2(-frame.x.y, frame.x.x);
}
/** `p` turned by `angle` about the Earth's axis. */
function turned(p, angle) {
const c = Math.cos(angle);
const s = Math.sin(angle);
return { x: c * p.x - s * p.y, y: s * p.x + c * p.y, z: p.z };
}
export function createOrbitRendering({
state: layerState,
services,
parts,
source,
}) {
const { orbitFrameModelMatrix } = services.satellites;
/** Pattern images by colour. */
const patterns = new Map();
/**
* Register the selected-orbit tactical material once. Each group begins with
* one compact round dot followed by one hundred short dashes.
* The mission orbit's line style: the tactical pattern in `css` (at
* 0.95 alpha), repeated in groups along the whole orbit.
*/
function ensureMissionOrbitPatternRegistered() {
if (layerState._missionOrbitPatternRegistered) return;
new Cesium.Material({
fabric: {
type: 'GevMissionOrbitTactical',
uniforms: {
color: Cesium.Color.CYAN,
groupCount: MISSION_ORBIT_PATTERN_GROUPS,
dashCount: MISSION_ORBIT_DASHES_PER_GROUP,
},
source: `
czm_material czm_getMaterial(czm_materialInput materialInput) {
czm_material material = czm_getDefaultMaterial(materialInput);
float groupPosition = fract(materialInput.st.s * groupCount);
float markPosition = groupPosition * (dashCount + 1.0);
float markIndex = floor(markPosition);
float localPosition = fract(markPosition);
float centerDistance = abs(localPosition - 0.5);
float edge = max(fwidth(localPosition) * 1.35, 0.012);
float dashAlong = 1.0 - smoothstep(0.27 - edge, 0.27 + edge, centerDistance);
float dashAcross = 1.0 - smoothstep(0.12, 0.24, abs(materialInput.st.t - 0.5));
float dash = dashAlong * dashAcross;
float dotAlong = (localPosition - 0.5) / 0.32;
float dotAcross = (materialInput.st.t - 0.5) / 0.5;
float dot = 1.0 - smoothstep(0.78, 1.0, length(vec2(dotAlong, dotAcross)));
float isDot = 1.0 - step(0.5, markIndex);
float visible = mix(dash, dot, isDot);
material.diffuse = color.rgb;
material.emission = color.rgb * mix(0.07, 0.65, isDot);
material.alpha = color.a * visible * mix(0.58, 1.0, isDot);
return material;
}`,
},
});
layerState._missionOrbitPatternRegistered = true;
}
function createMissionOrbitPatternMaterial(color) {
ensureMissionOrbitPatternRegistered();
return Cesium.Material.fromType('GevMissionOrbitTactical', {
color,
groupCount: MISSION_ORBIT_PATTERN_GROUPS,
dashCount: MISSION_ORBIT_DASHES_PER_GROUP,
});
function missionOrbitPatternStyle(css) {
let canvas = patterns.get(css);
if (!canvas) {
canvas = globalThis.document?.createElement?.('canvas') ?? null;
if (canvas) drawMissionOrbitPattern(canvas, css, 0.95);
patterns.set(css, canvas);
}
return {
kind: 'pattern',
image: { canvas, key: `rocket-mission-orbit:${css}` },
repeat: MISSION_ORBIT_PATTERN_GROUPS,
};
}
function missionOrbitPrimitiveVisible(launchId) {
return Boolean(
layerState._enabled &&
layerState._dataSource?.show &&
parts.rendering.missionsShown() &&
(!layerState._selectedLaunchId ||
layerState._selectedLaunchId === launchId),
);
}
/** Show each live ring as its mission's selection allows. */
function syncMissionOrbitPrimitiveVisibility() {
const set = layerState._missionSets?.orbits;
if (!set) return;
const changed = [];
for (const [launchId, path] of layerState._missionOrbitPrimitives) {
if (path.primitive)
path.primitive.show = missionOrbitPrimitiveVisible(launchId);
const show = missionOrbitPrimitiveVisible(launchId);
if (path.item.show === show) continue;
path.item = { ...path.item, show };
changed.push(path.item);
}
if (changed.length) set.upsert(changed);
}
function removeMissionOrbitPrimitives() {
for (const path of layerState._missionOrbitPrimitives.values()) {
if (path.primitive && layerState._viewer?.scene?.primitives) {
layerState._viewer.scene.primitives.remove(path.primitive);
}
}
layerState._missionSets?.orbits.clear();
layerState._missionOrbitPrimitives.clear();
}
function updateMissionOrbitPrimitiveFrames(nowDate) {
/**
* Where a point of a live ring, baked in ECEF at the ring's GMST, is
* drawn at `ms`: the ring turns with the sky as its line does.
*/
function drawnRingPoint(path, bakePosition, ms) {
return turned(turned(bakePosition, path.gmstAtBake), -siderealAngle(ms));
}
/** Move the live rings' labels with their rings, at `nowMs`. */
function updateMissionOrbitPrimitiveFrames(nowMs = Date.now()) {
for (const [launchId, path] of layerState._missionOrbitPrimitives) {
if (!path.primitive || !missionOrbitPrimitiveVisible(launchId)) continue;
orbitFrameModelMatrix(
path.gmstAtBake,
nowDate,
path.primitive.modelMatrix,
);
if (path.labelBakePosition && path.labelPosition) {
Cesium.Matrix4.multiplyByPoint(
path.primitive.modelMatrix,
if (!missionOrbitPrimitiveVisible(launchId)) continue;
if (path.labelBakePosition)
path.labelPosition = drawnRingPoint(
path,
path.labelBakePosition,
path.labelPosition,
nowMs,
);
}
}
}
/**
* A live satellite's ring, baked in ECEF at its track's GMST, in the
* inertial frame, for the caller to write to the `orbits` set. Returns
* its record, or null when the track has no bake (the ring is then an
* ordinary mission line).
*/
function addMissionOrbitPrimitive(launch, orbitPath, satelliteTrack) {
if (
!layerState._viewer ||
!satelliteTrack ||
!Number.isFinite(satelliteTrack.gmstAtBake)
)
return false;
const collection = new Cesium.PolylineCollection();
collection.add({
positions: orbitPath,
width: 3,
material: createMissionOrbitPatternMaterial(
Cesium.Color.fromCssColorString('#22e6e6').withAlpha(0.95),
),
const set = layerState._missionSets?.orbits;
if (!set || !satelliteTrack || !Number.isFinite(satelliteTrack.gmstAtBake))
return null;
const positions = new Float64Array(orbitPath.length * 3);
orbitPath.forEach((point, i) => {
const p = turned(point, satelliteTrack.gmstAtBake);
positions[i * 3] = p.x;
positions[i * 3 + 1] = p.y;
positions[i * 3 + 2] = p.z;
});
collection.show = missionOrbitPrimitiveVisible(launch.id);
orbitFrameModelMatrix(
satelliteTrack.gmstAtBake,
new Date(),
collection.modelMatrix,
);
layerState._viewer.scene.primitives.add(collection);
layerState._missionOrbitPrimitives.set(launch.id, {
primitive: collection,
gmstAtBake: satelliteTrack.gmstAtBake,
});
return true;
const item = {
id: `rocket-orbit:${launch.id}`,
positions,
widthPx: 3,
mode: '3d',
frame: 'inertial',
style: missionOrbitPatternStyle('#22e6e6'),
show: missionOrbitPrimitiveVisible(launch.id),
};
const path = { item, gmstAtBake: satelliteTrack.gmstAtBake };
layerState._missionOrbitPrimitives.set(launch.id, path);
return path;
}
function MissionOrbitPatternMaterialProperty(color) {
ensureMissionOrbitPatternRegistered();
this._color = color;
this._definitionChanged = new Cesium.Event();
}
Object.defineProperties(MissionOrbitPatternMaterialProperty.prototype, {
isConstant: {
get() {
return true;
},
},
definitionChanged: {
get() {
return this._definitionChanged;
},
},
});
MissionOrbitPatternMaterialProperty.prototype.getType = function getType() {
return 'GevMissionOrbitTactical';
};
MissionOrbitPatternMaterialProperty.prototype.getValue = function getValue(
time,
result,
) {
if (!Cesium.defined(result)) result = {};
result.color = this._color;
result.groupCount = MISSION_ORBIT_PATTERN_GROUPS;
result.dashCount = MISSION_ORBIT_DASHES_PER_GROUP;
return result;
};
MissionOrbitPatternMaterialProperty.prototype.equals = function equals(
other,
) {
return this === other;
};
return {
ensureMissionOrbitPatternRegistered,
createMissionOrbitPatternMaterial,
missionOrbitPatternStyle,
missionOrbitPrimitiveVisible,
syncMissionOrbitPrimitiveVisibility,
removeMissionOrbitPrimitives,
updateMissionOrbitPrimitiveFrames,
addMissionOrbitPrimitive,
MissionOrbitPatternMaterialProperty,
drawnRingPoint,
};
}
+1 -1
View File
@@ -313,7 +313,7 @@ export function createPanel({ state: layerState, services, parts, source }) {
if (
!layerState._missionPanelReady ||
!layerState._selectedLaunchId ||
!layerState._dataSource
!layerState._missionSets
)
return;
const now = performance.now();
+405 -279
View File
@@ -1,8 +1,9 @@
import * as Cesium from 'cesium';
// Still Cesium for its entities, so this layer loads the unbound camera
// factory its other parts reach the renderer through.
import '../../render/cesium/camera.js';
import { fromDegrees, fromDegreesInto } from '../../geo/ellipsoid.js';
import { horizonFrom } from '../../geo/horizon.js';
import { sphereFromPoints } from '../../geo/sphere.js';
import { clamp } from '../../geo/vector.js';
import { hexColor } from '../../render/color.js';
import { drawOf, findCamera, findQuery } from '../../render/rendererOf.js';
import {
TRAJECTORY_STAGE_COLORS,
REPLAY_ORBIT_DURATION_SEC,
@@ -10,6 +11,24 @@ import {
STAGE_REENTRY_ALTITUDE_M,
} from './policy.js';
/** Layer instances made so far: each one's draw sets get their own ids. */
let instances = 0;
/** The mission draw sets: shown and hidden together, as one layer. */
const MISSION_SETS = ['lines', 'sites', 'markers', 'reticles'];
/** The reticle a hovered roster row draws over its launch site. */
const RETICLE_KEY = 'rocket-mission-hover-reticle';
/** The launch id in a mission item id (`rocket-<kind>:<launch id>...`). */
function launchIdOf(id) {
if (typeof id !== 'string') return null;
const match = id.match(/^rocket-[^:]+:([^:]+)/);
return match?.[1] || null;
}
const copy = (p) => ({ x: p.x, y: p.y, z: p.z });
export function createRendering({
state: layerState,
services,
@@ -18,164 +37,283 @@ export function createRendering({
}) {
const { getSatelliteOrbitTrack, findSatelliteOrbitTrackInTle } =
services.satellites;
const declutterTime = new Cesium.JulianDate();
/** A plain ECEF point (the paths are plain) as the entities take one. */
const cartesian = (point) => Cesium.Cartesian3.clone(point);
const cartesians = (points) => points.map(cartesian);
/** The ids of this layer's draw sets, by name. */
let setIds = null;
/** Frames the mission sets have been walked in, the live cache's key. */
let frameNumber = 0;
// The follow reads its target before preRender (once a tick, and again
// in preUpdate while it first frames), so a follow read opens the live
// sample the next preRender keeps: the camera and the marker stand at
// the same instant, and every read until then shares it.
let followSampled = false;
/** A launch's marker colour, for the entities. */
/** Open the live sample a follow read and the next preRender share. */
function openFollowSample() {
if (followSampled) return;
followSampled = true;
frameNumber += 1;
}
/**
* Every drawn mission item by set and id, with what decides whether it
* shows: `isolated` (the mission's selection), and for points and icons
* `graphicShow` (the horizon, and for the reticle the roster's hover).
*/
const records = new Map();
/** Items to write at the next flush, by set name. */
const pending = new Map();
/** A launch's marker colour. */
function markerColor(launch) {
const [r, g, b, a] = parts.model.missionMarkerColor(launch);
return new Cesium.Color(r, g, b, a);
return [r, g, b, a];
}
function setGraphicVisibility(graphic, visible, time) {
if (!graphic) return;
const next = Boolean(visible);
const current = graphic.show?.getValue?.(time);
if (current !== next) graphic.show = next;
const recordKey = (set, id) => `${set}\u0000${id}`;
/** Queue `item` for its set, replacing one queued under its id. */
function queue(set, item) {
let items = pending.get(set);
if (!items) pending.set(set, (items = new Map()));
items.set(item.id, item);
}
/** Write what was queued, one upsert a set. */
function flush() {
const sets = layerState._missionSets;
if (!sets) {
pending.clear();
return;
}
for (const [name, items] of pending)
if (items.size) sets[name].upsert([...items.values()]);
pending.clear();
}
/** What a record draws now. */
const drawnShow = (record) => record.isolated && record.graphicShow;
/** Add a mission item; it draws once flushed. */
function addItem(set, item, { graphicShow = true, position = null } = {}) {
const record = {
set,
id: item.id,
launchId: launchIdOf(item.id),
// Every item shows until the selection isolates a mission, as the
// entities did; `isolateMission` runs once a build is done.
isolated: true,
graphicShow,
// Where the horizon pass reads it; null for lines.
position,
item: { ...item, show: graphicShow },
};
records.set(recordKey(set, item.id), record);
queue(set, record.item);
return record;
}
/** Write a record again if what it draws changed. */
function refresh(record, moved = null) {
const show = drawnShow(record);
if (record.item.show === show && !moved) return;
record.item = moved
? { ...record.item, pos: moved, show }
: { ...record.item, show };
queue(record.set, record.item);
}
/**
* The layer's entities, hidden until enabled. They stay entities: the
* replay vehicle and the live payload move every frame, the selected site
* is the viewer's selected entity, and the orbits draw with their own
* materials.
* The layer's draw sets, hidden until enabled. The live satellite rings
* (`orbits`) and the pad zone (`pad`) show by their own rules.
*/
function attach(viewer) {
layerState._dataSource = new Cesium.CustomDataSource('rocket-launches');
layerState._dataSource.show = false;
viewer.dataSources.add(layerState._dataSource);
const draw = drawOf(viewer);
const base = `rocket-launches:${++instances}`;
setIds = {
lines: `${base}:lines`,
sites: `${base}:sites`,
markers: `${base}:markers`,
reticles: `${base}:reticles`,
orbits: `${base}:orbits`,
pad: `${base}:pad`,
};
const sets = {
lines: draw.lines({ id: setIds.lines, show: false }),
sites: draw.points({ id: setIds.sites, show: false }),
markers: draw.points({ id: setIds.markers, show: false }),
reticles: draw.icons({ id: setIds.reticles, show: false }),
orbits: draw.lines({ id: setIds.orbits }),
pad: draw.shapes({ id: setIds.pad }),
};
layerState._missionSets = sets;
}
function detach(viewer) {
if (layerState._dataSource)
viewer.dataSources.remove(layerState._dataSource, true);
layerState._dataSource = null;
function detach() {
const sets = layerState._missionSets;
layerState._missionSets = null;
records.clear();
pending.clear();
if (!sets) return;
for (const set of Object.values(sets)) set.dispose();
}
/** Whether the missions' entities are shown. */
/** Whether the missions are shown. */
function missionsShown() {
return Boolean(layerState._dataSource?.show);
return Boolean(layerState._missionSets?.lines.show);
}
/** Show or hide the missions' entities. */
/** Show or hide the missions. */
function showMissions(shown) {
if (layerState._dataSource) layerState._dataSource.show = shown;
const sets = layerState._missionSets;
if (!sets) return;
for (const name of MISSION_SETS) sets[name].show = shown;
}
/** Remove every mission entity, ahead of a rebuild. */
/** Remove every mission item, ahead of a rebuild. */
function clearLaunchEntities() {
layerState._dataSource?.entities.removeAll();
// A followed item goes with them, as a removed entity stopped being
// followed.
layerState._stockFollow?.stop();
const sets = layerState._missionSets;
records.clear();
pending.clear();
if (!sets) return;
for (const name of MISSION_SETS) sets[name].clear();
}
/** The launch id of a mission entity, or null for anything else. */
function entityLaunchId(entity) {
if (!entity?.id || typeof entity.id !== 'string') return null;
const match = entity.id.match(/^rocket-[^:]+:([^:]+)/);
return match?.[1] || null;
/** Whether a hit is one of this layer's mission items. */
function missionHit(hit) {
if (!hit || !setIds) return false;
return (
hit.set === setIds.lines ||
hit.set === setIds.sites ||
hit.set === setIds.markers ||
hit.set === setIds.reticles
);
}
/** The launch of the first mission entity among a click's drilled picks. */
function launchIdFromPicks(picks) {
for (const picked of picks) {
const launchId = entityLaunchId(picked?.id);
/**
* What a double-click on a mission item follows: a point by where it is
* drawn (the payload as it moves), a line zoomed to by its bounds.
*/
function followTargetFor(hit) {
if (!missionHit(hit)) return null;
const name = Object.keys(setIds).find((key) => setIds[key] === hit.set);
const record = records.get(recordKey(name, hit.id));
if (!record) return null;
if (!record.position)
return { zoomTo: sphereFromPoints(record.item.positions) };
const at = record.position;
return {
key: `${setIds.sites}:${hit.id}`,
position: () => {
if (typeof at === 'function') openFollowSample();
const p = typeof at === 'function' ? at() : at;
return p ? copy(p) : null;
},
};
}
/** The launch of the first mission item among a click's drilled hits. */
function launchIdFromPicks(hits) {
for (const hit of hits) {
if (!missionHit(hit)) continue;
const launchId = launchIdOf(hit.id);
if (launchId) return launchId;
}
return null;
}
/** Whether a mission entity is under a screen position (CSS px). */
function launchMarkerAt(position) {
const scene = layerState._viewer?.scene;
if (!scene) return false;
return scene
.drillPick(position, 12)
.some((picked) => entityLaunchId(picked?.id));
/** The mission items under a screen position (CSS px), at most `limit`. */
function missionHitsAt(position, limit = 12) {
const query = findQuery(layerState._viewer);
if (!query || !position) return [];
return query.drillPick(position.x, position.y, { limit });
}
/** Make a launch's site marker the viewer's selected entity, or none. */
function selectLaunchEntity(launchId) {
const viewer = layerState._viewer;
if (!viewer) return;
viewer.selectedEntity = launchId
? layerState._dataSource?.entities.getById(`rocket-launch:${launchId}`)
: undefined;
/** Whether a mission item is under a screen position (CSS px). */
function launchMarkerAt(position) {
return Boolean(launchIdFromPicks(missionHitsAt(position)));
}
/**
* Show only the selected mission's entities, or every site marker and
* Note the selected launch site. Nothing draws it differently; the
* selected mission is the layer's own (`_selectedLaunchId`).
*/
function selectLaunchEntity() {}
/**
* Show only the selected mission's items, or every site marker and
* nothing else when none is selected.
*/
function isolateMission(launchId) {
if (!layerState._dataSource) return;
for (const entity of layerState._dataSource.entities.values) {
const relatedId = entityLaunchId(entity);
entity.show = launchId
? relatedId === launchId
: entity.id.startsWith('rocket-launch:');
if (!layerState._missionSets) return;
for (const record of records.values()) {
record.isolated = launchId
? record.launchId === launchId
: record.id.startsWith('rocket-launch:');
refresh(record);
}
flush();
}
/**
* The projected (estimated) orbit drawn as an entity for a launch, ECEF;
* null when its orbit is a live satellite ring or it has none.
* The projected (estimated) orbit drawn as a mission line for a launch,
* ECEF; null when its orbit is a live satellite ring or it has none.
*/
function projectedOrbitPath(launchId) {
return layerState._replayTracks.get(launchId)?.projectedOrbitPath ?? null;
}
function updateMissionFrame() {
if (
!layerState._enabled ||
!layerState._viewer ||
!layerState._dataSource?.show
) {
if (followSampled) followSampled = false;
else frameNumber += 1;
if (!layerState._enabled || !layerState._viewer || !missionsShown()) {
parts.overlays.hideReplayVehicleOverlay();
return;
}
parts.panel.updateMissionTelemetry();
const time = Cesium.JulianDate.now(declutterTime);
const occluder = horizonFrom(layerState._viewer.scene.camera.positionWC);
const eye = findCamera(layerState._viewer)?.pose().position;
const occluder = eye ? horizonFrom(eye) : null;
parts.overlays.updateReplayVehicleOverlay(occluder);
parts.overlays.refreshSelectedMissionOverlayText();
for (const entity of layerState._dataSource.entities.values) {
if (!entity.show) continue;
if (!entity.position) continue;
const id = entityLaunchId(entity);
if (!id) continue;
const position = entity.position.getValue(time);
for (const record of records.values()) {
if (!record.isolated || !record.position) continue;
const live = typeof record.position === 'function';
const position = live ? record.position() : record.position;
let horizonVisible = Boolean(
position && occluder.isPointVisible(position),
position && occluder?.isPointVisible(position),
);
const launchAnchor = entity.id.startsWith('rocket-launch:');
if (launchAnchor) {
if (record.id.startsWith('rocket-launch:')) {
horizonVisible = parts.overlays.missionAnchorVisible(
layerState._viewer.scene.camera.positionWC,
eye,
position,
id,
record.launchId,
layerState._selectedLaunchId,
);
// Keep entity.show reserved for mission-selection isolation. Horizon
// state is applied to the individual graphics below so a rear-side
// anchor remains eligible for reevaluation as the camera moves.
}
if (entity.point) {
setGraphicVisibility(entity.point, horizonVisible, time);
}
if (launchAnchor && entity.billboard) {
setGraphicVisibility(
entity.billboard,
horizonVisible && id === layerState._hoveredRosterLaunchId,
time,
);
// The selection's isolation stays its own; horizon state is kept
// apart, so a rear-side anchor is judged again as the camera moves.
}
record.graphicShow =
record.set === 'reticles'
? horizonVisible &&
record.launchId === layerState._hoveredRosterLaunchId
: horizonVisible;
refresh(record, live && position ? copy(position) : null);
}
flush();
}
function addLaunchEntity(launch, activeTleText = layerState._activeTleText) {
const position = Cesium.Cartesian3.fromDegrees(launch.lon, launch.lat);
/**
* Draw a launch's items. With `defer`, they wait for `flushLaunchEntities`,
* so a whole roster writes each set once.
*/
function addLaunchEntity(
launch,
activeTleText = layerState._activeTleText,
{ defer = false } = {},
) {
const position = fromDegrees(launch.lon, launch.lat);
const overlayRecord = {
launch,
anchorPosition: position,
@@ -212,39 +350,50 @@ export function createRendering({
);
});
if (satelliteTrack) layerState._orbitMatches++;
layerState._dataSource.entities.add({
id: `rocket-launch:${launch.id}`,
position,
point: {
const siteMeta = {
launchId: launch.id,
launchName: launch.name,
launchTime: launch.launchTime,
launchSite: launch.launchSite,
provider: launch.provider,
mission: launch.mission,
status: launch.status,
source: launch.source,
orbit: JSON.stringify(launch.orbit || {}),
satelliteName: satelliteTrack?.name || '',
noradId: satelliteTrack?.noradId || '',
};
const color = markerColor(launch);
addItem(
'sites',
{
id: `rocket-launch:${launch.id}`,
pos: position,
pixelSize: 5,
color: markerColor(launch),
outlineColor: markerColor(launch),
color,
outlineColor: color,
outlineWidth: 0,
disableDepthTestDistance: Number.POSITIVE_INFINITY,
disableDepthTest: Number.POSITIVE_INFINITY,
meta: siteMeta,
},
billboard: {
image: parts.overlays.missionHoverReticleImage(),
width: 24,
height: 24,
show: false,
horizontalOrigin: Cesium.HorizontalOrigin.CENTER,
verticalOrigin: Cesium.VerticalOrigin.CENTER,
disableDepthTestDistance: Number.POSITIVE_INFINITY,
{ position },
);
addItem(
'reticles',
{
id: `rocket-launch:${launch.id}`,
pos: position,
image: {
canvas: parts.overlays.missionHoverReticleImage(),
key: RETICLE_KEY,
},
size: [24, 24],
anchor: 'center',
disableDepthTest: Number.POSITIVE_INFINITY,
meta: siteMeta,
},
properties: {
launchId: launch.id,
launchName: launch.name,
launchTime: launch.launchTime,
launchSite: launch.launchSite,
provider: launch.provider,
mission: launch.mission,
status: launch.status,
source: launch.source,
orbit: JSON.stringify(launch.orbit || {}),
satelliteName: satelliteTrack?.name || '',
noradId: satelliteTrack?.noradId || '',
},
});
{ position, graphicShow: false },
);
const points = launch.trajectory
.filter(
(point) =>
@@ -259,7 +408,7 @@ export function createRendering({
point.stageName ||
'trajectory',
),
position: Cesium.Cartesian3.fromDegrees(
position: fromDegrees(
Number(point.longitude),
Number(point.latitude),
Number(point.altitude || 0),
@@ -275,20 +424,19 @@ export function createRendering({
});
segments.forEach((segment, index) => {
if (segment.positions.length < 2) return;
layerState._dataSource.entities.add({
addItem('lines', {
id: `rocket-trajectory:${launch.id}:${index}`,
polyline: {
positions: cartesians(
parts.paths.surfaceSafePath(segment.positions),
),
width: 2,
material: Cesium.Color.fromCssColorString(
positions: parts.paths.surfaceSafePath(segment.positions).map(copy),
widthPx: 2,
mode: '3d',
style: {
kind: 'solid',
color: hexColor(
TRAJECTORY_STAGE_COLORS[index % TRAJECTORY_STAGE_COLORS.length],
).withAlpha(0.8),
clampToGround: false,
arcType: Cesium.ArcType.NONE,
0.8,
),
},
properties: {
meta: {
launchId: launch.id,
stage: segment.stage,
source: launch.source,
@@ -324,7 +472,7 @@ export function createRendering({
new Date(insertionEpochMs),
);
if (propagatedInsertion) {
insertionReference = Cesium.Cartesian3.fromDegrees(
insertionReference = fromDegrees(
propagatedInsertion.longitude,
propagatedInsertion.latitude,
propagatedInsertion.altitude,
@@ -337,7 +485,7 @@ export function createRendering({
// ascent duration, and join the forward orbit tangent. Using the UTC
// epoch as phase sent some ascents toward the far side of Earth and
// forced a visible 180-degree corrective hook before insertion.
const insertionProgress = Cesium.Math.clamp(
const insertionProgress = clamp(
insertionDurationSec / orbitPeriodSec,
1 / 96,
0.16,
@@ -357,11 +505,10 @@ export function createRendering({
launch,
ascentPath,
);
// Cesium can evaluate CallbackProperty values multiple times while it
// traverses one frame. Camera tracking and the HTML replay overlay must
// use the exact same replay epoch as those callbacks; sampling Date.now()
// independently made the vehicle advance relative to the camera and then
// snap back on the next frame.
// Camera tracking and the HTML replay overlay must use the exact same
// replay epoch within a frame; sampling Date.now() independently made
// the vehicle advance relative to the camera and then snap back on the
// next frame.
let replayStateForFrame = null;
const sampleReplayState = () =>
parts.replay.replayState(
@@ -375,10 +522,8 @@ export function createRendering({
REPLAY_TILE_SETTLE_DELAY_SEC,
layerState._replayCameraLaunchId !== launch.id,
);
// preUpdate runs before Cesium evaluates entity CallbackProperties. Seed
// one state there and retain it through postRender so every consumer in
// that traversal sees the same timestamp. scene.frameState.frameNumber is
// advanced between some of those phases, so it is not a reliable cache key.
// The replay camera seeds one state in preUpdate, and every consumer
// through postRender reads that one.
const beginReplayFrame = () => {
replayStateForFrame = sampleReplayState();
return replayStateForFrame;
@@ -404,24 +549,22 @@ export function createRendering({
if (path.length < 2) return;
const reentryIndex = parts.paths.atmosphericReentryIndex(path);
const reentryPath = path.slice(reentryIndex);
const color = Cesium.Color.fromCssColorString(
const stageColor =
TRAJECTORY_STAGE_COLORS[
(stageIndex + 1) % TRAJECTORY_STAGE_COLORS.length
],
);
layerState._dataSource.entities.add({
];
addItem('lines', {
id: `rocket-reentry-recovery:${launch.id}:${stageIndex}`,
polyline: {
positions: cartesians(path),
width: 2,
material: new Cesium.PolylineDashMaterialProperty({
color: color.withAlpha(0.82),
dashLength: 12,
dashPattern: 0xaaaa,
}),
arcType: Cesium.ArcType.NONE,
positions: path.map(copy),
widthPx: 2,
mode: '3d',
style: {
kind: 'dash',
color: hexColor(stageColor, 0.82),
length: 12,
pattern16: 0xaaaa,
},
properties: {
meta: {
launchId: launch.id,
stageId: stage.id,
phase: 'STAGE_REENTRY_RECOVERY',
@@ -430,20 +573,18 @@ export function createRendering({
},
});
if (reentryPath.length > 1) {
layerState._dataSource.entities.add({
addItem('lines', {
id: `rocket-reentry:${launch.id}:${stageIndex}`,
polyline: {
positions: cartesians(reentryPath),
width: 2.5,
material: new Cesium.PolylineDashMaterialProperty({
color:
Cesium.Color.fromCssColorString('#ffd166').withAlpha(0.9),
dashLength: 8,
dashPattern: 0xf0f0,
}),
arcType: Cesium.ArcType.NONE,
positions: reentryPath.map(copy),
widthPx: 2.5,
mode: '3d',
style: {
kind: 'dash',
color: hexColor('#ffd166', 0.9),
length: 8,
pattern16: 0xf0f0,
},
properties: {
meta: {
launchId: launch.id,
stageId: stage.id,
phase: 'ATMOSPHERIC_REENTRY',
@@ -451,7 +592,7 @@ export function createRendering({
source: 'Estimated 100 km atmospheric interface',
},
});
const reentryPosition = cartesian(path[reentryIndex]);
const reentryPosition = copy(path[reentryIndex]);
overlayRecord.elementEntryFactories.push(() =>
parts.overlays.createRocketMissionElementOverlayEntry({
id: `reentry:${launch.id}:${stageIndex}`,
@@ -463,22 +604,25 @@ export function createRendering({
}),
);
}
layerState._dataSource.entities.add({
id: `rocket-recovery-end:${launch.id}:${stageIndex}`,
position: cartesian(path.at(-1)),
point: {
const endpoint = copy(path.at(-1));
addItem(
'markers',
{
id: `rocket-recovery-end:${launch.id}:${stageIndex}`,
pos: endpoint,
pixelSize: 4,
color,
color: hexColor(stageColor),
outlineWidth: 0,
disableDepthTestDistance: Number.POSITIVE_INFINITY,
disableDepthTest: Number.POSITIVE_INFINITY,
meta: {
launchId: launch.id,
stageId: stage.id,
phase: 'RECOVERY_ENDPOINT',
source: launch.source,
},
},
properties: {
launchId: launch.id,
stageId: stage.id,
phase: 'RECOVERY_ENDPOINT',
source: launch.source,
},
});
{ position: endpoint },
);
});
layerState._replayTracks.set(launch.id, {
ascentPath,
@@ -494,7 +638,7 @@ export function createRendering({
lastOverlayWindowPosition: null,
lastOverlayMode: null,
});
let livePosition = Cesium.Cartesian3.fromDegrees(
let livePosition = fromDegrees(
orbitCurrent.longitude,
orbitCurrent.latitude,
orbitCurrent.altitude,
@@ -502,7 +646,7 @@ export function createRendering({
const liveTime = new Date();
const liveTelemetry = {
speedMps: null,
// Where the entity draws the payload now, for the mission panel.
// Where the payload draws now, for the mission panel.
position: () => {
updateLiveState();
return livePosition;
@@ -512,10 +656,10 @@ export function createRendering({
let liveFrameNumber = -1;
const fallbackPeriodSec =
parts.paths.estimatedOrbitPeriodSeconds(orbitPath);
// Propagated at most once a frame, so the marker and the label
// reading the same cache never stand at different instants.
const updateLiveState = () => {
const frameNumber =
layerState._viewer?.scene?.frameState?.frameNumber ?? -1;
if (frameNumber !== -1 && frameNumber === liveFrameNumber) return;
if (frameNumber !== 0 && frameNumber === liveFrameNumber) return;
liveFrameNumber = frameNumber;
const nowMs = Date.now();
liveTime.setTime(nowMs);
@@ -523,11 +667,10 @@ export function createRendering({
const propagated =
satelliteTrack.positionAt?.(liveTime) || satelliteTrack.current;
if (propagated) {
Cesium.Cartesian3.fromDegrees(
fromDegreesInto(
propagated.longitude,
propagated.latitude,
propagated.altitude,
undefined,
livePosition,
);
liveTelemetry.speedMps = Number.isFinite(propagated.speedMps)
@@ -535,8 +678,7 @@ export function createRendering({
: null;
}
} else {
// In-place write keeps one Cartesian3 for the mission's lifetime —
// the estimated branch previously reallocated per propagation.
// In-place write keeps one position for the mission's lifetime.
livePosition =
parts.paths.samplePath(
orbitPath,
@@ -545,31 +687,34 @@ export function createRendering({
) || livePosition;
}
};
layerState._dataSource.entities.add({
id: `rocket-satellite:${launch.id}`,
position: new Cesium.CallbackProperty(() => {
updateLiveState();
return livePosition;
}, false),
point: {
updateLiveState();
addItem(
'markers',
{
id: `rocket-satellite:${launch.id}`,
pos: copy(livePosition),
pixelSize: 6,
color: Cesium.Color.fromCssColorString(
satelliteTrack ? '#7bed9f' : '#ffd166',
),
color: hexColor(satelliteTrack ? '#7bed9f' : '#ffd166'),
outlineWidth: 0,
disableDepthTestDistance: Number.POSITIVE_INFINITY,
disableDepthTest: Number.POSITIVE_INFINITY,
meta: {
launchId: launch.id,
noradId: satelliteTrack?.noradId || '',
phase: satelliteTrack
? 'CURRENT_SATELLITE_POSITION'
: 'ESTIMATED_ORBIT_POSITION',
source: satelliteTrack
? 'Satellites layer'
: 'Approximate mission orbit',
},
},
properties: {
launchId: launch.id,
noradId: satelliteTrack?.noradId || '',
phase: satelliteTrack
? 'CURRENT_SATELLITE_POSITION'
: 'ESTIMATED_ORBIT_POSITION',
source: satelliteTrack
? 'Satellites layer'
: 'Approximate mission orbit',
{
position: () => {
updateLiveState();
return livePosition;
},
},
});
);
overlayRecord.liveEventTime = () => liveTime;
overlayRecord.elementEntryFactories.push(() => {
const name = satelliteTrack
@@ -586,29 +731,26 @@ export function createRendering({
gapPx: 12,
});
});
// Live satellite rings use a primitive collection so the core Satellite
// GMST transform can rotate their baked ECEF geometry without rebuilding
// it. Estimated launch-site-relative rings remain ordinary entities.
const primitiveOrbitAdded = parts.orbitRendering.addMissionOrbitPrimitive(
// A live satellite's ring is drawn in the inertial frame its GMST
// bake puts it in, so it turns with the sky as the payload does.
// An estimated, launch-site-relative ring is an ordinary line.
const ringPath = parts.orbitRendering.addMissionOrbitPrimitive(
launch,
orbitPath,
satelliteTrack,
);
if (!primitiveOrbitAdded) {
layerState._dataSource.entities.add({
if (ringPath) queue('orbits', ringPath.item);
else {
addItem('lines', {
id: `rocket-orbit:${launch.id}`,
polyline: {
positions: cartesians(orbitPath),
// The 3 px canvas gives the periodic dot room to read as round; the
// shader masks the ten intervening dashes down to a thin center stroke.
width: 3,
material:
new parts.orbitRendering.MissionOrbitPatternMaterialProperty(
Cesium.Color.fromCssColorString('#c084fc').withAlpha(0.95),
),
arcType: Cesium.ArcType.NONE,
},
properties: {
positions: orbitPath.map(copy),
// The 3 px width gives the periodic dot room to read as round;
// the pattern masks the intervening dashes down to a thin
// centre stroke.
widthPx: 3,
mode: '3d',
style: parts.orbitRendering.missionOrbitPatternStyle('#c084fc'),
meta: {
launchId: launch.id,
satelliteName: '',
noradId: '',
@@ -617,17 +759,16 @@ export function createRendering({
});
layerState._replayTracks.get(launch.id).projectedOrbitPath = orbitPath;
}
const orbitLabelBakePosition = cartesian(ascentPath.at(-1));
const orbitLabelBakePosition = copy(ascentPath.at(-1));
let orbitLabelPosition = orbitLabelBakePosition;
const primitivePath = layerState._missionOrbitPrimitives.get(launch.id);
if (primitivePath) {
primitivePath.labelBakePosition = orbitLabelBakePosition;
primitivePath.labelPosition = Cesium.Matrix4.multiplyByPoint(
primitivePath.primitive.modelMatrix,
if (ringPath) {
ringPath.labelBakePosition = orbitLabelBakePosition;
ringPath.labelPosition = parts.orbitRendering.drawnRingPoint(
ringPath,
orbitLabelBakePosition,
new Cesium.Cartesian3(),
Date.now(),
);
orbitLabelPosition = () => primitivePath.labelPosition;
orbitLabelPosition = () => ringPath.labelPosition;
}
overlayRecord.elementEntryFactories.push(() =>
parts.overlays.createRocketMissionElementOverlayEntry({
@@ -639,41 +780,20 @@ export function createRendering({
gapPx: 8,
}),
);
const replayPosition = new Cesium.CallbackProperty(() => {
const state = getReplayState();
const sample = state.ascending
? parts.paths.samplePath(ascentPath, state.phaseProgress)
: parts.paths.samplePath(animatedOrbitPath, state.phaseProgress);
return sample && cartesian(sample);
}, false);
layerState._dataSource.entities.add({
id: `rocket-vehicle:${launch.id}`,
position: replayPosition,
properties: {
launchId: launch.id,
noradId: satelliteTrack?.noradId || '',
phase: 'ASCENT_THEN_ORBIT',
source: satelliteTrack
? 'Satellite trajectory animation'
: 'Approximate trajectory animation',
},
});
layerState._dataSource.entities.add({
addItem('lines', {
id: `rocket-transfer:${launch.id}`,
polyline: {
positions: cartesians(ascentPath),
width: 1.5,
// The animated vehicle uses Cartesian interpolation between these
// exact samples. Prevent Cesium from replacing each segment with a
// geodesic arc, which would visually separate the dot from the line.
arcType: Cesium.ArcType.NONE,
material: new Cesium.PolylineDashMaterialProperty({
color: Cesium.Color.fromCssColorString('#7bed9f').withAlpha(0.8),
dashLength: 24,
dashPattern: 0xf0f0,
}),
positions: ascentPath.map(copy),
widthPx: 1.5,
// The replay vehicle moves straight between these exact samples:
// the line runs straight between them too, so the dot stays on it.
mode: '3d',
style: {
kind: 'dash',
color: hexColor('#7bed9f', 0.8),
length: 24,
pattern16: 0xf0f0,
},
properties: {
meta: {
launchId: launch.id,
phase: 'APPROXIMATE_TRANSFER',
source: satelliteTrack
@@ -682,6 +802,7 @@ export function createRendering({
},
});
}
if (!defer) flush();
}
return {
attach,
@@ -690,12 +811,17 @@ export function createRendering({
showMissions,
clearLaunchEntities,
launchIdFromPicks,
followTargetFor,
missionHitsAt,
launchMarkerAt,
setGraphicVisibility,
selectLaunchEntity,
isolateMission,
projectedOrbitPath,
updateMissionFrame,
addLaunchEntity,
flushLaunchEntities: flush,
get setIds() {
return setIds;
},
};
}
+1 -1
View File
@@ -79,7 +79,7 @@ export function createSelection({
stopMissionZoomAnchor();
parts.rendering.selectLaunchEntity(null);
}
if (!layerState._dataSource) return;
if (!layerState._missionSets) return;
parts.rendering.isolateMission(launchId);
parts.orbitRendering.syncMissionOrbitPrimitiveVisibility();
parts.overlays.syncMissionOverlayEntries();
+6 -6
View File
@@ -9,7 +9,8 @@ export function createState({ services }) {
clearSource: clearOverlaySource,
});
state._dataSource = null;
// The layer's draw sets by name, while it is initialised.
state._missionSets = null;
state._count = 0;
@@ -23,6 +24,9 @@ export function createState({ services }) {
state._inputSubscription = null;
// The double-click follow of mission points, while initialised.
state._stockFollow = null;
state._viewer = null;
state._declutterHandler = null;
@@ -126,7 +130,7 @@ export function createState({ services }) {
state._missionZoomAnchorId = null;
state._launchPadZonePrimitive = null;
state._launchPadZoneItem = null;
state._launchPadZoneRemover = null;
@@ -134,10 +138,6 @@ export function createState({ services }) {
state._missionOrbitPrimitives = new Map();
state._missionRingDate = new Date(0);
state._missionOrbitPatternRegistered = false;
state._pathDistanceCache = new WeakMap();
state._sourceController = new AbortController();
return state;
+222 -20
View File
@@ -32,6 +32,7 @@
* `findDraw` for one (`rendererOf.js`).
*/
import * as Cesium from 'cesium';
import { temeToPseudoFixed } from '../../geo/celestial.js';
import { alongLength } from '../../geo/polyline.js';
import { provideUnboundDraw } from '../rendererOf.js';
import { listenerList, toCartesian, uncaught } from './common.js';
@@ -187,6 +188,56 @@ czm_material czm_getMaterial(czm_materialInput materialInput) {
return m;
}`;
/** The `radialRim` fill's material type. */
const RADIAL_RIM_MATERIAL = 'DrawRadialRimFill';
/**
* Across the ellipse (`st` from its centre, 1 at its edge) the fill's
* colour, easing into the rim's over `rimWidth` (a fraction of the
* radius) just inside a soft edge; the rim glows a little.
*/
const RADIAL_RIM_SOURCE = `
czm_material czm_getMaterial(czm_materialInput materialInput) {
czm_material material = czm_getDefaultMaterial(materialInput);
vec2 centered = (materialInput.st - vec2(0.5)) * 2.0;
float radius = length(centered);
float inside = 1.0 - smoothstep(0.985, 1.0, radius);
float rim = smoothstep(0.985 - rimWidth, 0.985, radius) * inside;
material.diffuse = mix(color.rgb, rimColor.rgb, rim);
material.emission = rimColor.rgb * rim * 0.35;
material.alpha = inside * mix(color.a, rimColor.a, rim);
return material;
}`;
/** How finely a rim-filled ellipse is cut, radians. */
const RIM_GRANULARITY = Cesium.Math.toRadians(0.08);
/**
* A ground fill pulled toward the eye (`depthBias`): depth-tested, not
* writing depth, offset toward the camera, alpha blended.
*/
const DEPTH_BIASED_STATE = Object.freeze({
depthTest: { enabled: true },
depthMask: false,
polygonOffset: { enabled: true, factor: -1, units: -4 },
blending: Cesium.BlendingState.ALPHA_BLEND,
});
/** A `radialRim` fill's material. */
function radialRimMaterial(fill) {
const uniforms = {
color: toColor(fill.color),
rimColor: toColor(fill.rimColor),
rimWidth: fill.rimWidth,
};
// Built from its type, then given its values, as the line materials are.
const material = new Cesium.Material({
fabric: { type: RADIAL_RIM_MATERIAL, uniforms, source: RADIAL_RIM_SOURCE },
});
Object.assign(material.uniforms, uniforms);
return material;
}
/** The line styles the port drapes. */
const DRAPED_STYLES = new Set(['solid', 'glow', 'dash', 'flow']);
@@ -1392,9 +1443,12 @@ export function createCesiumDraw({
// values in the fabric would be merged into copies of the type's.
const template = ({ type, source, uniforms }) =>
source ? { type, source, uniforms } : { type };
// A pattern's image carries its own alpha: drawn in the translucent
// pass, whatever its colour.
const translucent = style.kind === 'pattern' ? { translucent: true } : {};
const material =
reveal === undefined
? new Cesium.Material({ fabric: template(fabric) })
? new Cesium.Material({ fabric: template(fabric), ...translucent })
: new Cesium.Material({
fabric: {
type: `${REVEAL_MATERIAL}_${style.kind}`,
@@ -1402,6 +1456,7 @@ export function createCesiumDraw({
uniforms: { reveal },
source: REVEAL_SOURCE,
},
...translucent,
});
const drawn = reveal === undefined ? material : material.materials.revealed;
Object.assign(drawn.uniforms, fabric.uniforms);
@@ -1474,6 +1529,15 @@ export function createCesiumDraw({
type: 'PolylineArrow',
uniforms: { color: toColor(style.color) },
};
case 'pattern':
// The image along the line `repeat` times, across its width once.
return {
type: 'Image',
uniforms: {
image: toImage(style.image),
repeat: new Cesium.Cartesian2(style.repeat, 1),
},
};
default:
throw new Error(`the Cesium renderer has no ${style.kind} lines`);
}
@@ -1635,6 +1699,28 @@ export function createCesiumDraw({
});
}
/**
* Turn a line set's inertial lines to the sky at its motion clock's time
* now: the frame rotated by sidereal time from the Earth-fixed one.
*/
function turnInertial(record) {
const lines = record.inertialLines;
if (!lines || lines.isDestroyed()) return;
const clock = record.spec.motionClock;
const ms =
clock?.kind === 'scene'
? Cesium.JulianDate.toDate(
scene.frameState?.time ?? Cesium.JulianDate.now(),
).getTime()
: Date.now() - (clock?.delayMs ?? 0);
const { x, y, z } = temeToPseudoFixed(ms);
lines.modelMatrix = Cesium.Matrix4.fromRotationTranslation(
new Cesium.Matrix3(x.x, y.x, z.x, x.y, y.y, z.y, x.z, y.z, z.z),
Cesium.Cartesian3.ZERO,
lines.modelMatrix,
);
}
function buildLines(record) {
// Refused before anything changes, so the set keeps drawing as it was.
for (const item of record.items.values())
@@ -1642,6 +1728,13 @@ export function createCesiumDraw({
throw new Error(
'the Cesium renderer drapes solid, glow, dash and flow lines only',
);
else if (
item.frame === 'inertial' &&
(item.mode === 'draped' || item.depthFailColor)
)
throw new Error(
'the Cesium renderer draws inertial lines undraped, without depth-fail colours',
);
else if (
segmented(item) &&
(item.mode !== 'draped' ||
@@ -1652,6 +1745,8 @@ export function createCesiumDraw({
'the Cesium renderer colours and shows segments of draped solid lines only',
);
const polylines = new Cesium.PolylineCollection();
// Lines in the inertial frame, turned with the sky each frame.
let inertial = null;
const draped = new Map();
// Draped glow lines that look alike: one ground primitive and one
// material for them all, so they recolour together in place.
@@ -1719,8 +1814,37 @@ export function createCesiumDraw({
continue;
}
const id = pickId(record, item);
const { polyline, reveal } = addPolyline(record, polylines, item, id);
if (item.frame === 'inertial') {
inertial ??= new Cesium.PolylineCollection();
const { polyline, reveal, parked } = addPolyline(
record,
inertial,
item,
id,
true,
);
// Never settled into a static batch, which would not turn.
parts.set(item.id, {
look: lineLook(item),
shape: null,
positions: null,
id,
polyline,
reveal,
parked,
home: inertial,
batched: null,
});
continue;
}
const settled = settles(item);
const { polyline, reveal, parked } = addPolyline(
record,
polylines,
item,
id,
!settled,
);
parts.set(item.id, {
look: lineLook(item),
// How it draws but for its colour, and where it runs, to tell a
@@ -1730,6 +1854,9 @@ export function createCesiumDraw({
id,
polyline,
reveal,
// Hidden, out of the collection until it shows (`addPolyline`).
parked,
home: polylines,
// Drawn in the set's static batch instead (`settleLines`).
batched: null,
});
@@ -1738,12 +1865,15 @@ export function createCesiumDraw({
// Lines in the collection that can settle into a static batch draw
// beside it once they do.
const settling = [...record.items.values()].some(settles);
if (deep || settling) {
if (deep || settling || inertial) {
own = new Cesium.PrimitiveCollection();
own.add(polylines);
if (deep) own.add(deep);
if (inertial) own.add(inertial);
}
record.deepLines = deep;
record.inertialLines = inertial;
if (inertial) turnInertial(record);
record.polylines = polylines;
record.lineBox = settling ? own : null;
record.batch = null;
@@ -2002,6 +2132,7 @@ export function createCesiumDraw({
return false;
// A viewer destroyed under the set took its batch with it.
if (was.batched?.isDestroyed()) return false;
if (was.home?.isDestroyed()) return false;
looks.push(look);
if (was.deep !== undefined && record.deepLines?.isDestroyed())
return false;
@@ -2028,7 +2159,7 @@ export function createCesiumDraw({
const item = list[k];
const was = parts.get(item.id);
const show = item.show !== false;
if (was.polyline || was.batched) {
if (was.polyline || was.parked || was.batched) {
patchUndraped(record, was, item, looks[k]);
continue;
}
@@ -2087,9 +2218,15 @@ export function createCesiumDraw({
/**
* An undraped line without a depth-fail colour in the set's polyline
* collection, under pick id `id`; `reveal` is the material its reveal
* is set on, or null.
* is set on, or null. A hidden line that never settles (`park`) is
* parked instead, out of the collection (`polyline` null, `parked`
* true): the collection draws every line it holds, shown or not, each
* on a material and command of its own, every frame; a hidden line
* that settles costs nothing once in its static batch.
*/
function addPolyline(record, polylines, item, id) {
function addPolyline(record, polylines, item, id, park = false) {
if (park && item.show === false)
return { polyline: null, reveal: null, parked: true };
const positions = linePositions(item);
const reveal = revealed(item)
? revealUniform(item.revealFraction, positions)
@@ -2102,7 +2239,11 @@ export function createCesiumDraw({
show: item.show !== false,
id,
});
return { polyline, reveal: reveal === undefined ? null : material };
return {
polyline,
reveal: reveal === undefined ? null : material,
parked: false,
};
}
/**
@@ -2112,6 +2253,7 @@ export function createCesiumDraw({
*/
const settles = (item) =>
item.mode !== 'draped' &&
item.frame !== 'inertial' &&
!item.depthFailColor &&
item.style.kind === 'solid' &&
!revealed(item) &&
@@ -2181,6 +2323,25 @@ export function createCesiumDraw({
unsettle(record);
return;
}
if (!show && !was.shape) {
// Parked out of the collection, which would draw it on regardless
// (a line that settles is hidden in its batch instead).
if (was.polyline) {
dropFlow(record, was.polyline.material, item.style);
was.home.remove(was.polyline);
was.polyline = null;
was.reveal = null;
requestRender();
}
was.parked = true;
return;
}
if (was.parked) {
// Back in the collection, as it now is.
Object.assign(was, addPolyline(record, was.home, item, was.id));
requestRender();
return;
}
// Only a change a batch would draw unsettles the set: a show is taken
// when the batch swaps in, and lines that cannot settle are not in it.
if (was.shape && (recolour || !flatEquals(item.positions, was.positions))) {
@@ -2585,8 +2746,11 @@ export function createCesiumDraw({
}
}
/** A clamped shape's fill geometry, on the ellipsoid for draping. */
function groundGeometry(item) {
/**
* A clamped shape's fill geometry, on the ellipsoid for draping; an
* ellipse with a rim fill is cut finely, so its rim runs round.
*/
function groundGeometry(item, rimFill = null) {
const g = item.geometry;
switch (g.kind) {
case 'polygon': {
@@ -2606,6 +2770,14 @@ export function createCesiumDraw({
semiMajorAxis: g.semiMajor,
semiMinorAxis: g.semiMinor,
rotation: g.rotation ?? 0,
...(rimFill
? {
granularity: RIM_GRANULARITY,
vertexFormat:
Cesium.MaterialAppearance.MaterialSupport.TEXTURED
.vertexFormat,
}
: {}),
});
case 'rectangle':
return new Cesium.RectangleGeometry({
@@ -2641,10 +2813,15 @@ export function createCesiumDraw({
parts.set(item.id, { look: lookOf(item), id: null, ground: null });
continue;
}
const imageFill =
const objectFill =
typeof item.fill === 'object' && !Array.isArray(item.fill)
? item.fill
: null;
const rimFill =
objectFill?.preset === 'radialRim' && item.geometry.kind === 'ellipse'
? objectFill
: null;
const imageFill = rimFill ? null : objectFill;
if (imageFill && !imageFill.image)
throw new Error('the Cesium renderer fills shapes with colours only');
if (item.extrudeHeight !== undefined)
@@ -2661,7 +2838,7 @@ export function createCesiumDraw({
// load when they show.
let geometry;
try {
geometry = groundGeometry(item);
geometry = groundGeometry(item, rimFill);
} catch (error) {
if (item.show === false) continue;
throw error;
@@ -2677,17 +2854,29 @@ export function createCesiumDraw({
);
const instance = new Cesium.GeometryInstance({
geometry,
attributes: imageFill
? { show }
: {
color: Cesium.ColorGeometryInstanceAttribute.fromColor(
toColor(item.fill),
),
show,
},
attributes:
imageFill || rimFill
? { show }
: {
color: Cesium.ColorGeometryInstanceAttribute.fromColor(
toColor(item.fill),
),
show,
},
id: part.id,
});
const clampTo = item.clampTo ?? record.spec.clampTo ?? 'both';
if (rimFill) {
// A rim fill is a ground primitive of its own, with its material.
batches.push({
clampTo,
instances: [instance],
parts: [part],
rimFill,
depthBias: item.depthBias,
});
continue;
}
if (imageFill) {
// An image fill is a ground primitive of its own, with its material.
// (Cesium turns its texture wrongly across the antimeridian: its
@@ -2733,7 +2922,9 @@ export function createCesiumDraw({
...(batch.imageFill.repeat ?? [1, 1]),
),
})
: null;
: batch.rimFill
? radialRimMaterial(batch.rimFill)
: null;
const ground = new Ground({
geometryInstances: batch.instances,
classificationType: classificationOf(batch.clampTo),
@@ -2746,6 +2937,15 @@ export function createCesiumDraw({
Cesium.MaterialAppearance.MaterialSupport.TEXTURED,
translucent: true,
flat: true,
...(batch.rimFill
? {
closed: false,
faceForward: true,
...(batch.depthBias
? { renderState: DEPTH_BIASED_STATE }
: {}),
}
: {}),
}),
}
: {}),
@@ -3103,6 +3303,8 @@ export function createCesiumDraw({
beforeRender() {
cullHorizon();
runFlows();
for (const record of sets.values())
if (record.inertialLines) turnInertial(record);
modelSets.beforeRender(sets.values());
quadSets.beforeRender(sets.values());
},
+223 -17
View File
@@ -595,8 +595,24 @@ test('clamped shapes refuse what they cannot draw', () => {
fill: '#fff',
height: 'clampGround',
};
// A rim fill is drawn on ellipses alone.
assert.throws(
() => set.set([{ ...disc, fill: { preset: 'radialRim' } }]),
() =>
set.set([
{
...disc,
geometry: {
kind: 'rectangle',
rect: { west: 0, south: 0, east: 1, north: 1 },
},
fill: {
preset: 'radialRim',
color: '#fff',
rimColor: '#fff',
rimWidth: 0.1,
},
},
]),
/colours only/,
);
assert.throws(
@@ -2114,8 +2130,9 @@ test('unchanged solid 3D lines settle into a static batch, changed there in plac
s.built(translucentAgain);
frame();
assert.equal(opaqueAgain.show, true, 'swapped in once built');
assert.equal(polylines.length, 1, 'the glow alone left in the collection');
assert.equal(polylines.get(0).id.id, 'glow');
// The glow, hidden, is parked out of the collection, which would draw
// it on regardless; the batch took the rest.
assert.equal(polylines.length, 0, 'none left in the collection');
// Show, colour and meta change in place on the batch.
set.upsert([
stem('a', 100, { show: false }),
@@ -2124,7 +2141,7 @@ test('unchanged solid 3D lines settle into a static batch, changed there in plac
assert.equal(s.host(), host);
assert.deepEqual([...s.attrs(opaqueAgain, 'a').show], [0]);
assert.deepEqual([...s.attrs(opaqueAgain, 'c').color], [0, 0, 255, 255]);
assert.equal(polylines.length, 1, 'nothing left the batch');
assert.equal(polylines.length, 0, 'nothing left the batch');
set.upsert([stem('a', 100, { meta: 'new' })]);
assert.deepEqual([...s.attrs(opaqueAgain, 'a').show], [1]);
assert.equal(opaqueAgain.geometryInstances[0].id.meta, 'new');
@@ -2133,8 +2150,8 @@ test('unchanged solid 3D lines settle into a static batch, changed there in plac
set.upsert([stem('a', 900)]);
assert.equal(s.host(), host);
assert.deepEqual([...s.attrs(opaqueAgain, 'a').show], [0]);
assert.equal(polylines.length, 2);
const moved = polylines.get(1);
assert.equal(polylines.length, 1);
const moved = polylines.get(0);
assert.equal(moved.id.id, 'a');
assert.ok(
Cesium.Cartesian3.equalsEpsilon(
@@ -2147,7 +2164,7 @@ test('unchanged solid 3D lines settle into a static batch, changed there in plac
set.upsert([
stem('c', 300, { style: { kind: 'solid', color: [0, 0, 1, 0.4] } }),
]);
assert.equal(polylines.length, 3);
assert.equal(polylines.length, 2);
// Two lines are few beside a batch: they wait longer.
s.settle();
assert.equal(s.batches().length, 2, 'not yet');
@@ -2173,7 +2190,12 @@ test('unchanged solid 3D lines settle into a static batch, changed there in plac
assert.deepEqual(s.batches(), next, 'the old batches are gone');
assert.equal(opaqueAgain.isDestroyed(), true);
assert.deepEqual([...s.attrs(next[1], 'b').show], [0]);
assert.equal(polylines.length, 0);
// The glow shown again draws in the collection, in place.
set.upsert([glow]);
assert.equal(s.host(), host);
assert.equal(polylines.length, 1);
assert.equal(polylines.get(0).id.id, 'glow');
// A line that looks different is still a rebuild.
set.upsert([stem('b', 200, { widthPx: 5 })]);
assert.notEqual(s.host(), host);
@@ -2981,12 +3003,15 @@ test('the FIRMS layer draws its fire glows as one GPU icon set on a viewer of it
const at = Cesium.Cartographic.fromCartesian(set.position(strong, tau));
assert.ok(Math.abs(Cesium.Math.toDegrees(at.longitude) + 97.7) < 1e-6);
assert.ok(Math.abs(at.height - 40) < 1e-3, 'at its anchor');
assert.deepEqual(drawHitOf(host._pickObject('firms-0', null, { show: true })), {
set: host.drawSetId,
id: 'firms-0',
meta: { layer: 'firms', id: 'firms-0' },
surface: false,
});
assert.deepEqual(
drawHitOf(host._pickObject('firms-0', null, { show: true })),
{
set: host.drawSetId,
id: 'firms-0',
meta: { layer: 'firms', id: 'firms-0' },
surface: false,
},
);
// A rebuild that keeps one fire writes nothing for it and drops the other.
const written = [];
@@ -3071,14 +3096,21 @@ test('the Radio layer draws its stations, clusters and selected marker as point
assert.equal(dots.length, 4);
assert.ok(dots.every((dot) => dot instanceof Cesium.PointPrimitive));
const lone = dots.find((dot) => dot.show);
assert.equal(lone.id.id, `radio:${stations[3].id}`, 'the others are in a cluster');
assert.equal(
lone.id.id,
`radio:${stations[3].id}`,
'the others are in a cluster',
);
assert.equal(lone.pixelSize, 13);
assert.equal(lone.outlineWidth, 1);
assert.ok(Math.abs(lone.color.alpha - 0.86) < 1e-6);
assert.equal(lone.disableDepthTestDistance, Number.POSITIVE_INFINITY);
assert.equal(lone.distanceDisplayCondition.far, 50_000_000);
assert.equal(lone.scaleByDistance.nearValue, 1.15);
assert.equal(radioStationIdFromPick({ primitive: lone, id: lone.id }), stations[3].id);
assert.equal(
radioStationIdFromPick({ primitive: lone, id: lone.id }),
stations[3].id,
);
const [cluster] = rows(/^radio:\d+:clusters$/);
assert.deepEqual(
@@ -3087,7 +3119,10 @@ test('the Radio layer draws its stations, clusters and selected marker as point
);
assert.equal(cluster.pixelSize, 12 + Math.log2(3) * 1.6);
assert.equal(cluster.outlineWidth, 2);
assert.equal(radioStationIdFromPick({ primitive: cluster, id: cluster.id }), stations[0].id);
assert.equal(
radioStationIdFromPick({ primitive: cluster, id: cluster.id }),
stations[0].id,
);
radioLayer.selectStation(stations[3].id, { autoplay: false, focus: false });
const [selected] = rows(/^radio:\d+:selected$/);
@@ -3097,7 +3132,10 @@ test('the Radio layer draws its stations, clusters and selected marker as point
assert.ok(bracket instanceof Cesium.Billboard);
assert.equal(bracket.width, 40);
assert.equal(bracket.scaleByDistance.farValue, 0.72);
assert.equal(radioStationIdFromPick({ primitive: bracket, id: bracket.id }), stations[3].id);
assert.equal(
radioStationIdFromPick({ primitive: bracket, id: bracket.id }),
stations[3].id,
);
});
assert.equal(scene.added.length, 0, 'gone with the layer');
});
@@ -5643,3 +5681,171 @@ test('meshes draw their triangles in the frame at their origin', () =>
assert.equal(host.length, 0);
set.dispose();
}));
test('a pattern line draws its image along it, repeated, and an inertial line turns with the sky', () =>
withImageClasses(() => {
const { scene, draw, frame } = drawOver();
const set = draw.lines({ id: 'orbit-rings' });
const ring = [
{ x: 7e6, y: 0, z: 0 },
{ x: 0, y: 7e6, z: 0 },
{ x: -7e6, y: 0, z: 0 },
];
const pattern = { kind: 'pattern', image: 'marks.png', repeat: 4 };
set.set([
{ id: 'fixed', positions: ring, widthPx: 3, mode: '3d', style: pattern },
{
id: 'sky',
positions: ring,
widthPx: 3,
mode: '3d',
style: pattern,
frame: 'inertial',
},
]);
const host = scene.added[0];
assert.ok(host instanceof Cesium.PrimitiveCollection);
const fixed = host.get(0);
const inertial = host.get(1);
assert.ok(inertial instanceof Cesium.PolylineCollection);
const material = fixed.get(0).material;
assert.equal(material.type, 'Image');
assert.equal(material.uniforms.image, 'marks.png');
assert.deepEqual(material.uniforms.repeat, new Cesium.Cartesian2(4, 1));
assert.equal(material.isTranslucent(), true, 'its image has its alpha');
assert.equal(inertial.get(0).id.id, 'sky');
// Turned by sidereal time: the inertial x axis is drawn where the
// pseudo-fixed frame puts it now.
const turnedTo = () =>
Cesium.Matrix4.multiplyByPointAsVector(
inertial.modelMatrix,
Cesium.Cartesian3.UNIT_X,
new Cesium.Cartesian3(),
);
const expected = Cesium.Matrix3.multiplyByVector(
Cesium.Transforms.computeTemeToPseudoFixedMatrix(Cesium.JulianDate.now()),
Cesium.Cartesian3.UNIT_X,
new Cesium.Cartesian3(),
);
assert.ok(
Cesium.Cartesian3.equalsEpsilon(turnedTo(), expected, 1e-6),
'turned as Cesium turns TEME',
);
const realNow = Date.now;
try {
const at = realNow();
Date.now = () => at + 3_600_000;
frame();
const later = turnedTo();
// An hour turns the frame about 15 degrees about the pole.
const angle = Cesium.Cartesian3.angleBetween(later, expected);
assert.ok(Math.abs(Cesium.Math.toDegrees(angle) - 15.04) < 0.05);
assert.ok(Math.abs(later.z) < 1e-9);
} finally {
Date.now = realNow;
}
// Never settled into a static batch; shown and hidden in place. A
// hidden line that never settles leaves its collection, which would
// draw it on regardless, until it shows again.
for (let i = 0; i < SETTLE_FRAMES + 2; i++) frame();
const sky = (show) => ({
id: 'sky',
positions: ring,
widthPx: 3,
mode: '3d',
style: pattern,
frame: 'inertial',
show,
});
set.upsert([sky(false), { ...sky(false), id: 'fixed', frame: undefined }]);
assert.equal(scene.added[0], host, 'patched, not rebuilt');
assert.equal(inertial.length, 0);
assert.equal(fixed.length, 0);
set.upsert([sky(true)]);
assert.equal(scene.added[0], host);
assert.equal(inertial.length, 1);
assert.equal(inertial.get(0).show, true);
assert.equal(inertial.get(0).id.id, 'sky');
assert.equal(inertial.get(0).material.type, 'Image');
// Built hidden, it starts out of its collection.
const later = draw.lines({ id: 'orbit-rings-hidden' });
later.set([{ ...sky(false), id: 'parked' }]);
assert.equal(scene.added.at(-1).get(1).length, 0);
later.upsert([{ ...sky(true), id: 'parked' }]);
assert.equal(scene.added.at(-1).get(1).length, 1);
later.dispose();
assert.throws(
() =>
set.upsert([
{
id: 'draped',
positions: ring,
widthPx: 3,
mode: 'draped',
style: { kind: 'solid', color: '#fff' },
frame: 'inertial',
},
]),
/inertial lines undraped/,
);
set.dispose();
assert.equal(scene.added.length, 0);
}));
test('a clamped ellipse filled with a radial rim drapes its material, finely cut, pulled toward the eye', () =>
withImageClasses(() => {
const { scene, draw } = drawOver();
const set = draw.shapes({ id: 'pad-zone' });
const zone = {
id: 'zone',
geometry: {
kind: 'ellipse',
center: { lon: -80.6, lat: 28.6 },
semiMajor: 500,
semiMinor: 500,
},
fill: {
preset: 'radialRim',
color: [0.13, 0.9, 0.9, 0.105],
rimColor: [0.13, 0.9, 0.9, 0.72],
rimWidth: 0.033,
},
height: 'clampGround',
depthBias: 1,
};
set.set([zone]);
const host = scene.added[0];
let ground = null;
for (let i = 0; i < host.length; i++)
if (host.get(i) instanceof Cesium.GroundPrimitive) ground = host.get(i);
assert.ok(ground);
const { appearance } = ground;
assert.ok(appearance instanceof Cesium.MaterialAppearance);
assert.equal(appearance.material.type, 'DrawRadialRimFill');
const { color, rimColor, rimWidth } = appearance.material.uniforms;
assert.ok(
color.equalsEpsilon(new Cesium.Color(0.13, 0.9, 0.9, 0.105), 1e-9),
);
assert.ok(
rimColor.equalsEpsilon(new Cesium.Color(0.13, 0.9, 0.9, 0.72), 1e-9),
);
assert.equal(rimWidth, 0.033);
assert.equal(appearance.renderState.polygonOffset.enabled, true);
assert.equal(appearance.renderState.depthMask, false);
assert.equal(ground.classificationType, Cesium.ClassificationType.BOTH);
const [instance] = ground.geometryInstances;
assert.ok(instance.geometry instanceof Cesium.EllipseGeometry);
assert.ok(
Math.abs(instance.geometry._granularity - Cesium.Math.toRadians(0.08)) <
1e-12,
);
assert.equal(instance.id.id, 'zone');
// Hidden and shown in place, once its primitive is ready.
Object.defineProperty(ground, 'ready', { value: true });
const shows = { show: Uint8Array.of(1) };
ground.getGeometryInstanceAttributes = () => shows;
set.upsert([{ ...zone, show: false }]);
assert.equal(scene.added[0], host, 'patched, not rebuilt');
assert.deepEqual([...shows.show], [0]);
set.dispose();
}));
-4
View File
@@ -10,11 +10,7 @@
"src/data/geoImportPins.js",
"src/input/dispatcher.js",
"src/input/sensorPick.js",
"src/layers/ghostMaps/index.js",
"src/layers/installations/rendering.js",
"src/layers/launches/launchPad.js",
"src/layers/launches/orbitRendering.js",
"src/layers/launches/rendering.js",
"src/layers/recentImagery/rendering.js",
"src/layers/satellites/rendering.js",
"src/layers/traffic/rendering.js",
+6
View File
@@ -109,6 +109,12 @@ const DRAW_FROM_CALLER = new Set([
// draw, size and fly through the ports alone.
'./infrastructure',
'./infrastructure/geojson',
// Not wholly Cesium-free (its pointer input still is), but its missions
// draw, pick and fly through the ports alone.
'./layers/launches',
// Its pins, footprints and outlines draw through `drawOf`; its horizon
// cull reads the camera and frame ports.
'./layers/ghostmaps',
]);
/**