Draw contact trails through the draw port

The shared trail renderer draws a trail's history and its live head as
lines in a draw-port set, geodesic for the history and straight for the
head, each dimmed behind the surface in its depth-fail colour, and
leaves the Cesium allow-list. The flights and military trail heads are
drawn through the trail each frame from the frame port instead of
entity callbacks, and the local ADS-B head uses the same head line. A
head given while its trail is hidden waits until the trail shows.

Geodesic lines are cut a step a degree of arc, with at least 64 steps
over the line, so a long trail of short legs costs its positions rather
than 64 vertices a leg.
This commit is contained in:
Sameh Khamis committed 2026-11-07 07:39:58 -08:00
1 parent 6bbe35f232
commit 8cefc8cc4a
12 files changed
+631 -350

No files matched your search

+140 -51
View File
@@ -1,62 +1,151 @@
import test from 'node:test';
import assert from 'node:assert/strict';
import * as Cesium from 'cesium';
import { bindFakeDraw } from '../testSupport/fakeDrawPort.mjs';
import { createTrail } from './trailRenderer.js';
import { findPickOwner } from './pickRegistry.js';
test('trail visibility can change without discarding its accumulated geometry', () => {
const added = [];
const removed = [];
const viewer = {
isDestroyed: () => false,
entities: {
add(definition) {
added.push(definition);
return definition;
},
remove(entity) {
removed.push(entity);
},
},
};
function viewerWithDraw(t) {
const viewer = { isDestroyed: () => false };
const { draw, unbind } = bindFakeDraw(viewer);
t.after(unbind);
return { viewer, draw };
}
test('a trail draws its history as one dimmed-when-hidden geodesic line', (t) => {
const { viewer, draw } = viewerWithDraw(t);
const trail = createTrail(viewer, { color: '#00d4ff', width: 2.5 });
trail.setPositions([
{ x: 1, y: 2, z: 3 },
{ x: 1, y: 2, z: 3.01 },
{ x: 4, y: 5, z: 6 },
]);
const set = draw.find('trail:');
assert.equal(set.kind, 'lines');
assert.equal(set.items.size, 1);
const [line] = set.items.values();
assert.match(line.id, /^gev-trail:/, 'claimed by the trail pick owner');
assert.equal(findPickOwner(line.id), 'trails');
// The near-duplicate merges.
assert.deepEqual(line.positions, [
{ x: 1, y: 2, z: 3 },
{ x: 4, y: 5, z: 6 },
]);
assert.equal(line.widthPx, 2.5);
assert.equal(line.mode, 'geodesic');
assert.equal(line.style.kind, 'solid');
assert.deepEqual(line.style.color, [0, 212 / 255, 1, 0.85]);
assert.deepEqual(line.depthFailColor, [0, 212 / 255, 1, 0.4]);
// The same positions again change nothing; fewer than two distinct hide it.
const writes = set.writes;
trail.setPositions([
{ x: 1, y: 2, z: 3 },
{ x: 4, y: 5, z: 6 },
]);
assert.equal(set.writes, writes);
trail.setPositions([{ x: 1, y: 2, z: 3 }]);
assert.equal(set.items.get(line.id).show, false, 'hidden, kept in place');
});
test('a trail head is a line of its own beside the history, at the head alphas', (t) => {
const { viewer, draw } = viewerWithDraw(t);
const trail = createTrail(viewer, { color: '#ffb800' });
trail.setPositions([
{ x: 0, y: 0, z: 0 },
{ x: 10, y: 0, z: 0 },
]);
trail.setHead([
{ x: 10, y: 0, z: 0 },
{ x: 20, y: 0, z: 0 },
]);
const set = draw.find('trail:');
assert.equal(set.items.size, 2);
const head = [...set.items.values()].find((line) =>
line.id.endsWith(':head'),
);
assert.equal(findPickOwner(head.id), 'trails');
assert.equal(head.style.color[3], 0.9);
assert.equal(head.depthFailColor[3], 0.45);
assert.equal(head.mode, '3d', 'short: straight, two positions a frame');
// No head: hidden once, then nothing more to write.
trail.setHead(null);
assert.equal(set.items.get(head.id).show, false);
const writes = set.writes;
trail.setHead([]);
assert.equal(set.writes, writes);
trail.clear();
assert.equal(set.items.size, 0);
});
test('trail visibility can change without discarding its accumulated geometry', (t) => {
const { viewer, draw } = viewerWithDraw(t);
const trail = createTrail(viewer, { color: '#ffffff' });
const positions = [
new Cesium.Cartesian3(1, 2, 3),
new Cesium.Cartesian3(4, 5, 6),
];
trail.setVisible(false);
trail.setPositions(positions);
assert.equal(added.length, 1);
assert.equal(added[0].show, false);
assert.deepEqual(added[0].polyline.positions.getValue(), positions);
trail.setPositions([
{ x: 1, y: 2, z: 3 },
{ x: 4, y: 5, z: 6 },
]);
const set = draw.find('trail:');
assert.equal(set.show, false, 'made hidden');
trail.setVisible(true);
assert.equal(added[0].show, true);
assert.deepEqual(added[0].polyline.positions.getValue(), positions);
assert.equal(set.show, true);
assert.equal(set.items.size, 1, 'history kept');
trail.destroy();
assert.deepEqual(removed, [added[0]]);
assert.equal(set.disposed, true);
trail.setPositions([
{ x: 1, y: 2, z: 3 },
{ x: 4, y: 5, z: 6 },
]);
assert.equal(draw.find('trail:'), undefined, 'nothing after destroy');
});
test('trail positions may be plain ECEF: the polyline still draws Cartesian3s', () => {
const added = [];
const viewer = {
isDestroyed: () => false,
entities: {
add(definition) {
added.push(definition);
return definition;
},
remove() {},
},
};
const trail = createTrail(viewer, { color: '#ffffff' });
const given = new Cesium.Cartesian3(1, 2, 3);
trail.setPositions([given, { x: 1, y: 2, z: 3.01 }, { x: 4, y: 5, z: 6 }]);
const drawn = added[0].polyline.positions.getValue();
// The near-duplicate merges; a Cartesian3 given passes through as it is.
assert.equal(drawn.length, 2);
assert.equal(drawn[0], given);
assert.ok(drawn[1] instanceof Cesium.Cartesian3);
assert.deepEqual([drawn[1].x, drawn[1].y, drawn[1].z], [4, 5, 6]);
test('a head given while the trail is hidden is drawn once it shows', (t) => {
const { viewer, draw } = viewerWithDraw(t);
const trail = createTrail(viewer, { color: '#fff' });
trail.setPositions([
{ x: 0, y: 0, z: 0 },
{ x: 10, y: 0, z: 0 },
]);
const set = draw.find('trail:');
trail.setVisible(false);
const writes = set.writes;
for (let i = 1; i <= 3; i++)
trail.setHead([
{ x: 10, y: 0, z: 0 },
{ x: 10 + i, y: 0, z: 0 },
]);
assert.equal(set.writes, writes, 'nothing drawn while hidden');
trail.setVisible(true);
const head = [...set.items.values()].find((line) =>
line.id.endsWith(':head'),
);
assert.deepEqual(head.positions.at(-1), { x: 13, y: 0, z: 0 }, 'the last');
// Any CSS colour, at the trail's alphas.
assert.deepEqual(head.style.color, [1, 1, 1, 0.9]);
});
test('a hidden line shows again where it is next given', (t) => {
const { viewer, draw } = viewerWithDraw(t);
const trail = createTrail(viewer, { color: '#39ffd5' });
const line = (x) => [
{ x: 0, y: 0, z: 0 },
{ x, y: 0, z: 0 },
];
trail.setPositions(line(10));
trail.setPositions([]);
trail.setPositions(line(20));
const [body] = draw.find('trail:').items.values();
assert.notEqual(body.show, false);
assert.deepEqual(body.positions, line(20));
});
test('a viewer with nothing to draw with draws no trail', () => {
const trail = createTrail({ isDestroyed: () => false }, { color: '#fff' });
assert.doesNotThrow(() =>
trail.setPositions([
{ x: 1, y: 2, z: 3 },
{ x: 4, y: 5, z: 6 },
]),
);
trail.destroy();
});