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

+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;