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

# Conflicts:
#	src/render/cesium/draw.test.mjs
This commit is contained in:
Sameh Khamis committed 2026-11-09 01:00:43 -08:00
commit 9d4e438e63
27 files changed
+2016 -465

No files matched your search

+1 -1
View File
@@ -185,7 +185,7 @@ export function createHeight({ state, services, parts }) {
meshUsed += mesh.length;
for (let i = 0; i < dem.length; i += 8)
warmGroundFloor(dem.slice(i, i + 8));
parts.rendering.sampleMeshFloors(mesh, entries);
parts.rendering.sampleMeshFloors(mesh);
// Cached completions can be adopted now; asynchronous completions are
// adopted by the next bounded reread.
for (const entry of entries) parts.trails.prepareEntry(entry);
+3 -1
View File
@@ -72,7 +72,7 @@ export function createIngestion({ state, services, parts, source }) {
const entry = state._vehicles.get(key);
if (!entry) return;
if (state._selectedKey === key) parts.selection.clearSelection();
if (entry.marker) entry.markerCollection?.remove(entry.marker);
parts.rendering.removeMarker(entry);
entry.marker = null;
entry.detectContact = null;
state._visible.delete(entry);
@@ -414,6 +414,8 @@ export function createIngestion({ state, services, parts, source }) {
// trip and must never sit on the render path.
parts.height.anchorFloors();
state._detectRevision++;
// New markers are drawn now, hidden until the visibility sweep shows them.
parts.rendering.flushMarkers();
parts.rendering.requestVisibility();
parts.rendering.syncRenderHold();
governorRequestRender('transit-poll');
+330 -88
View File
@@ -40,7 +40,7 @@ import {
import { fakeInput } from '../../input/testDoubles.mjs';
import { fakeCameraPort } from '../../testSupport/fakeCameraPort.mjs';
import { fakeDrawPort } from '../../testSupport/fakeDrawPort.mjs';
import { bindRenderer } from '../../render/rendererOf.js';
import { bindRenderer, rendererOf } from '../../render/rendererOf.js';
import { fakeSceneQuery } from '../../testSupport/fakeCesiumScene.mjs';
import { framePortFor } from '../../testSupport/fakeFramePort.mjs';
import { registerStyleStages } from '../../styles/styleStages.js';
@@ -148,6 +148,60 @@ function groundStub(floorAt) {
};
}
/** A number per terrain the fake viewer has had, as `surfaceVersion` is. */
const surfaceVersions = new WeakMap();
let surfaceVersionSeq = 0;
function surfaceVersion(terrain) {
if (!terrain) return 0;
if (!surfaceVersions.has(terrain))
surfaceVersions.set(terrain, (surfaceVersionSeq += 1));
return surfaceVersions.get(terrain);
}
// A marker record's colour (a 0..1 tuple or a CSS string) as a Cesium colour.
function colourOf(c) {
return typeof c === 'string'
? Cesium.Color.fromCssColorString(c)
: new Cesium.Color(c[0], c[1], c[2], c[3]);
}
// A camera `height` metres above a place, looking straight down at it or,
// with `away`, straight out to space.
function viewFrom(lon, lat, height, away = false) {
const ground = Cesium.Cartesian3.fromDegrees(lon, lat, 0);
const n = Cesium.Cartesian3.normalize(ground, new Cesium.Cartesian3());
const position = Cesium.Cartesian3.fromDegrees(lon, lat, height);
const east = Cesium.Cartesian3.normalize(
Cesium.Cartesian3.cross(
Cesium.Cartesian3.UNIT_Z,
n,
new Cesium.Cartesian3(),
),
new Cesium.Cartesian3(),
);
const north = Cesium.Cartesian3.cross(n, east, new Cesium.Cartesian3());
const v = (c) => ({ x: c.x, y: c.y, z: c.z });
const down = Cesium.Cartesian3.negate(n, new Cesium.Cartesian3());
return {
position: v(position),
direction: v(away ? n : down),
up: v(north),
right: v(
away ? Cesium.Cartesian3.negate(east, new Cesium.Cartesian3()) : east,
),
heading: 0,
pitch: away ? Math.PI / 2 : -Math.PI / 2,
roll: 0,
fovy: Math.PI / 3,
aspectRatio: 1,
near: 1,
far: 5e8,
};
}
// A camera above Boston's antipode looking out to space: Boston is behind it.
const lookingAway = () => viewFrom(BOSTON.lon + 180, -BOSTON.lat, 1e6, true);
function harness(
t,
{
@@ -206,6 +260,11 @@ function harness(
const cameraChanged = new Cesium.Event();
const cameraListeners = new Set();
const preUpdates = new Set();
const preRenders = new Set();
// The scene's preRender is the frame port's, as the Cesium port's is.
preRender.addEventListener(() => {
for (const cb of [...preRenders]) cb({ frame: 0 });
});
const viewer = {
camera: {
changed: cameraChanged,
@@ -243,6 +302,10 @@ function harness(
return index >= 0;
},
contains: (primitive) => primitives.includes(primitive),
get: (index) => primitives[index],
get length() {
return primitives.length;
},
raiseToTop() {},
},
},
@@ -283,6 +346,11 @@ function harness(
sprites: {
registerSpriteCollection: (id, collection) =>
sprites.set(id, collection),
registerSpriteSet: (id, setId) => {
const entry = { drawSetId: setId };
sprites.set(id, entry);
return entry;
},
unregisterSpriteCollection: (id) => sprites.delete(id),
restoreSpriteOrder() {},
},
@@ -313,13 +381,71 @@ function harness(
const draw = fakeDrawPort();
const unbindCamera = bindRenderer(viewer, {
draw,
query: fakeSceneQuery(viewer),
// Only the tick the layer's camera listener waits on.
query: {
...fakeSceneQuery(viewer),
// A 1000 px square pinhole through the test's `view`; none without.
project(p) {
const view = viewer.camera.view;
if (!view) return null;
const dot = (a, b) => a.x * b.x + a.y * b.y + a.z * b.z;
const v = {
x: p.x - view.position.x,
y: p.y - view.position.y,
z: p.z - view.position.z,
};
const z = dot(v, view.direction);
if (!(z > 0)) return null;
const f = 500 / Math.tan(view.fovy / 2);
return {
x: 500 + (f * dot(v, view.right)) / z,
y: 500 - (f * dot(v, view.up)) / z,
};
},
// The horizon from the fake camera's eye, as the Cesium port reads it
// from a real camera's.
isOccluded(position) {
const eye = Cesium.Ellipsoid.WGS84.cartographicToCartesian(
viewer.camera.positionCartographic,
);
return !new Cesium.EllipsoidalOccluder(
Cesium.Ellipsoid.WGS84,
eye,
).isPointVisible(
new Cesium.Cartesian3(position.x, position.y, position.z),
);
},
// Terrain heights as the fake globe has them, told apart from the
// bare ellipsoid as the Cesium port tells them.
async sampleHeight(points, { against } = {}) {
if (against !== 'terrain') return points.map(() => null);
const flat =
viewer.terrainProvider instanceof Cesium.EllipsoidTerrainProvider;
return points.map(() => ({
height: 0,
confidence: 1,
source: flat ? 'ellipsoid' : 'terrain',
lod: 'visible',
}));
},
},
// Whether the fake globe is shown, and a version that changes with its
// terrain, as the Cesium globe port reads them.
globe: {
isGlobeVisible: () => viewer.scene.globe.show === true,
surfaceVersion: () => surfaceVersion(viewer.terrainProvider),
},
// The tick the layer's camera listener waits on, and its frames.
frame: {
on(phase, cb) {
if (phase !== 'preUpdate') return () => {};
preUpdates.add(cb);
return () => preUpdates.delete(cb);
const listeners =
phase === 'preUpdate'
? preUpdates
: phase === 'preRender'
? preRenders
: null;
if (!listeners) return () => {};
listeners.add(cb);
return () => listeners.delete(cb);
},
requestRender() {},
},
@@ -342,6 +468,9 @@ function harness(
lon: carto ? Cesium.Math.toDegrees(carto.longitude) : NaN,
lat: carto ? Cesium.Math.toDegrees(carto.latitude) : NaN,
height: carto ? carto.height : NaN,
// A test sets `view` (position, direction, up, right and the
// frustum's fovy, aspectRatio and near) to cull by the frustum.
...viewer.camera.view,
};
},
viewRectangle() {
@@ -407,6 +536,27 @@ function harness(
responders.delete(feedId);
},
state: () => layer._transitStateForTest(),
/**
* The items of the markers' draw set, `still` or `moving`, as the draw
* port holds them (none once the set is gone).
*/
markers(name = 'still') {
const state = layer._transitStateForTest();
const set = name === 'moving' ? state._movingIcons : state._stillIcons;
return set ? (draw.set(set.id)?.items ?? new Map()) : new Map();
},
/**
* What a Cesium pick of a vehicle's marker returns: the draw port's pick
* id for its item in the set that draws it now.
*/
pickOf(entry) {
const state = layer._transitStateForTest();
const set = entry.animated ? state._movingIcons : state._stillIcons;
return {
primitive: {},
id: { set: set.id, id: entry.key, meta: { layer: 'transit' } },
};
},
vehicles: () => [...layer._transitStateForTest()._vehicles.values()],
frame() {
preRender.raiseEvent();
@@ -551,8 +701,7 @@ test('a vehicle the feed stops reporting is removed, and its primitive with it',
app.layer.enable(app.viewer);
await app.layer.update();
assert.equal(app.vehicles().length, 2);
const collection = app.sprites.get('transit');
assert.equal(collection.length, 2);
assert.equal(app.markers('still').size, 2);
app.serve('mbta', () => ({
status: 200,
@@ -576,7 +725,7 @@ test('a vehicle the feed stops reporting is removed, and its primitive with it',
['bus-1'],
);
assert.equal(
collection.length + app.sprites.get('transit-motion').length,
app.markers('still').size + app.markers('moving').size,
1,
'the removed vehicle released its point primitive',
);
@@ -646,7 +795,7 @@ test('a feed that goes silent has its vehicles evicted instead of frozen on the
app.advance(FEED_EVICT_AFTER_MS + 1_000);
await app.layer.update();
assert.equal(app.vehicles().length, 0, 'the last fleet is not left standing');
assert.equal(app.sprites.get('transit').length, 0);
assert.equal(app.markers('still').size, 0);
const stats = app.layer.getStats();
assert.equal(stats.count, 0);
assert.equal(stats.stale, true);
@@ -730,7 +879,7 @@ test('a snapshot the proxy replayed from its own cache for six minutes is refuse
0,
'the replayed fleet is gone, not frozen',
);
assert.equal(app.sprites.get('transit').length, 0);
assert.equal(app.markers('still').size, 0);
const stats = app.layer.getStats();
assert.equal(stats.count, 0);
assert.equal(stats.stale, true);
@@ -961,7 +1110,12 @@ test('destroy releases every shared registration this layer took', async (t) =>
await app.layer.update();
assert.ok(app.sprites.has('transit'));
assert.ok(app.pickOwners.has('transit'));
assert.equal(app.primitives.length, 2);
const ids = app.layer._transitSetIdsForTest();
assert.deepEqual(
ids.map((id) => app.draw.set(id)?.spec.id),
ids,
'two marker sets are live',
);
app.layer.destroy(app.viewer);
assert.deepEqual(app.cameraThresholds(), [], 'the camera listener goes');
@@ -975,10 +1129,10 @@ test('destroy releases every shared registration this layer took', async (t) =>
false,
'the pick owner is released',
);
assert.equal(
app.primitives.length,
0,
'the primitive collection leaves the scene',
assert.deepEqual(
ids.map((id) => app.draw.set(id)),
[undefined, undefined],
'both marker sets are let go',
);
assert.equal(app.holds().includes('transit'), false);
assert.equal(app.state()._viewer, null);
@@ -2217,12 +2371,12 @@ test('under FLIR and NVG every sprite is white-hot with a dark halo, and selecti
const bus = byRoute.get('742');
const plainImage = bus.marker.image;
const plainWidth = bus.marker.width;
const modeColour = bus.marker.color.clone();
const modeColour = colourOf(bus.marker.color);
app.style('thermal');
for (const entry of app.vehicles()) {
assert.ok(
Cesium.Color.equals(entry.marker.color, Cesium.Color.WHITE),
Cesium.Color.equals(colourOf(entry.marker.color), Cesium.Color.WHITE),
`${entry.record.routeId} is white-hot`,
);
assert.notEqual(entry.marker.image, plainImage, 'a haloed raster');
@@ -2236,7 +2390,7 @@ test('under FLIR and NVG every sprite is white-hot with a dark halo, and selecti
// Selecting under FLIR grows the sprite and keeps it white — cyan would dim it.
app.layer._transitPartsForTest().selection.selectVehicle(bus.key);
assert.ok(
Cesium.Color.equals(bus.marker.color, Cesium.Color.WHITE),
Cesium.Color.equals(colourOf(bus.marker.color), Cesium.Color.WHITE),
'still white when selected',
);
assert.ok(
@@ -2245,7 +2399,7 @@ test('under FLIR and NVG every sprite is white-hot with a dark halo, and selecti
);
app.layer._transitPartsForTest().selection.clearSelection();
assert.ok(
Cesium.Color.equals(bus.marker.color, Cesium.Color.WHITE),
Cesium.Color.equals(colourOf(bus.marker.color), Cesium.Color.WHITE),
'and white when deselected',
);
assert.equal(bus.marker.width, byRoute.get('Red').marker.width);
@@ -2253,7 +2407,7 @@ test('under FLIR and NVG every sprite is white-hot with a dark halo, and selecti
// Back to normal: the shipped look, exactly.
app.style('normal');
assert.ok(
Cesium.Color.equals(bus.marker.color, modeColour),
Cesium.Color.equals(colourOf(bus.marker.color), modeColour),
'mode colour restored',
);
assert.equal(bus.marker.image, plainImage, 'plain raster restored');
@@ -2278,12 +2432,12 @@ test('a cockpit vision override wins over the map style while it lasts, and dest
const plain = entry.marker.image;
app.vision('nvg', true);
assert.ok(
Cesium.Color.equals(entry.marker.color, Cesium.Color.WHITE),
Cesium.Color.equals(colourOf(entry.marker.color), Cesium.Color.WHITE),
'cockpit NVG restyles',
);
app.style('normal');
assert.ok(
Cesium.Color.equals(entry.marker.color, Cesium.Color.WHITE),
Cesium.Color.equals(colourOf(entry.marker.color), Cesium.Color.WHITE),
'the map style cannot undo a live cockpit override',
);
app.vision('normal', false);
@@ -2356,16 +2510,16 @@ test('the floor cycle samples the rendered mesh for the cells it warms, with its
'the sampler was asked after the floor resolved',
);
const call = app.meshCalls[0];
assert.equal(call.scene, app.viewer.scene);
assert.equal(call.scene, app.viewer);
assert.deepEqual(
call.points.map((p) => p.lat).sort(),
[42.36, 42.37],
'the in-view cells, and not the one off screen',
);
assert.equal(
call.options.excludeObjects.length,
2,
'both in-view billboards excluded',
assert.deepEqual(
call.options.sets,
app.layer._transitPartsForTest().rendering.setIds(),
'both marker sets excluded',
);
assert.ok(
Math.abs(call.options.viewerLat - BOSTON.lat) < 1e-6,
@@ -2801,11 +2955,7 @@ test('missing rectangle still rejects the far side, and frustum rejection wins',
[...app.state()._visible].map((e) => e.record.id),
['near'],
);
app.viewer.camera.frustum = {
computeCullingVolume: () => ({
computeVisibility: () => Cesium.Intersect.OUTSIDE,
}),
};
app.viewer.camera.view = lookingAway();
app.advance(250);
app.layer._transitPartsForTest().rendering.refreshVisibility();
assert.equal(app.state()._visible.size, 0);
@@ -2835,11 +2985,15 @@ test('motion transitions migrate billboards and update cached positions; disable
latitude += 0.001;
await app.layer.update();
app.run(8000, 16);
assert.equal(entry.markerCollection, app.state()._animatedMarkers);
assert.notEqual(entry.marker, old);
assert.equal(entry.animated, true);
assert.ok(app.markers('moving').has(entry.key));
assert.equal(app.markers('still').has(entry.key), false);
assert.equal(entry.marker, old, 'the record stays; only its draw set moves');
assert.equal(entry.detectContact.position, entry.marker.position);
app.run(30000, 16);
assert.equal(entry.markerCollection, app.state()._markers);
assert.equal(entry.animated, false);
assert.ok(app.markers('still').has(entry.key));
assert.equal(app.markers('moving').has(entry.key), false);
const parts = app.layer._transitPartsForTest();
const contacts = app.layer.getDetectableObjects();
const metric = contacts[0].metric;
@@ -2876,7 +3030,10 @@ test('every styling path retains the mode palette and exact unpadded size', asyn
const entry = app.vehicles()[0],
parts = app.layer._transitPartsForTest();
const check = (hex, display) => {
assert.equal(entry.marker.color.toCssHexString().toUpperCase(), hex);
assert.equal(
colourOf(entry.marker.color).toCssHexString().toUpperCase(),
hex,
);
const svg = Buffer.from(
entry.marker.image.split(',')[1],
'base64',
@@ -2926,11 +3083,7 @@ test('visible motion is recullable without a camera event and releases its hold
await app.layer.update();
app.layer._loadTransitFleetForTest(1, BOSTON, 1);
assert.equal(app.state()._moving.size, 1);
app.viewer.camera.frustum = {
computeCullingVolume: () => ({
computeVisibility: () => Cesium.Intersect.OUTSIDE,
}),
};
app.viewer.camera.view = lookingAway();
app.layer._transitPartsForTest().rendering.maintainPresentation();
app.advance(250);
assert.equal(app.state()._moving.size, 0);
@@ -3095,11 +3248,8 @@ test('tab visibility synchronizes playback before the returning frame and remove
for (const bounds of ['null', 'stale']) {
test(`browser visibility starts an injected fleet with ${bounds} bounds and an unsampled hidden marker`, async (t) => {
const app = harness(t);
app.viewer.camera.frustum = {
computeCullingVolume: () => ({
computeVisibility: () => Cesium.Intersect.INSIDE,
}),
};
// A real view over the fleet: the frustum, not the bounds, admits it.
app.viewer.camera.view = viewFrom(BOSTON.lon, BOSTON.lat, 4000);
app.layer.enable(app.viewer);
const loaded = app.layer._loadTransitFleetForTest(4, BOSTON, 70, [
'Red',
@@ -3158,7 +3308,7 @@ test('keyless loaded terrain resolves a pending surface without needing a frame
assert.equal(entry.marker.show, true);
});
test('the terrain under a vehicle is asked through the query port, and a flat globe stands at the ellipsoid', (t) => {
test('the terrain under a vehicle is asked through the query port, and a flat globe stands at the ellipsoid', async (t) => {
const app = harness(t, { floorAt: () => undefined });
const parts = app.layer._transitPartsForTest();
const lift = parts.height.requestHeight(0, 0).height;
@@ -3174,12 +3324,65 @@ test('the terrain under a vehicle is asked through the query port, and a flat gl
assert.equal(parts.rendering.globeSurface(), 'terrain');
app.viewer.scene.globe.getHeight = () => undefined;
app.viewer.terrainProvider = new Cesium.EllipsoidTerrainProvider();
// The surface is read once in a task, as a terrain swap comes in a task
// of its own.
await new Promise((resolve) => setImmediate(resolve));
// The new surface is asked about through the height service; until the
// answer arrives the last one holds.
assert.equal(parts.rendering.globeSurface(), 'terrain');
await new Promise((resolve) => setImmediate(resolve));
assert.equal(parts.rendering.globeSurface(), 'flat');
const flat = parts.height.requestHeight(42.36, -71.06);
assert.equal(terrain.height - flat.height, 30, 'flat terrain is height 0');
assert.equal(flat.prior, null);
});
test('a flat-globe answer that flips starts one fresh floor cycle, and a failed one is asked again', async (t) => {
const app = harness(t, { floorAt: () => undefined });
app.viewer.scene.globe.show = true;
app.layer.enable(app.viewer);
const parts = app.layer._transitPartsForTest();
const anchored = [];
const anchorFloors = parts.height.anchorFloors;
parts.height.anchorFloors = () => {
anchored.push(app.state()._floorTimer);
anchorFloors();
};
const tick = () => new Promise((resolve) => setImmediate(resolve));
assert.equal(parts.rendering.globeSurface(), 'terrain');
await tick();
assert.equal(anchored.length, 0, 'the same answer starts nothing');
app.viewer.terrainProvider = new Cesium.EllipsoidTerrainProvider();
await tick();
parts.rendering.globeSurface();
await tick();
assert.equal(parts.rendering.globeSurface(), 'flat');
assert.equal(anchored.length, 1, 'one fresh cycle on the flip');
// A probe that fails is asked again at the next read.
const query = rendererOf(app.viewer).query;
const sampleHeight = query.sampleHeight;
let asked = 0;
query.sampleHeight = async () => {
asked += 1;
throw new Error('terrain request failed');
};
app.viewer.terrainProvider = new Cesium.EllipsoidTerrainProvider();
await tick();
parts.rendering.globeSurface();
await tick();
assert.ok(asked > 0);
let askedAgain = 0;
query.sampleHeight = (...args) => {
askedAgain += 1;
return sampleHeight(...args);
};
await tick();
assert.equal(parts.rendering.globeSurface(), 'flat', 'the last answer holds');
assert.ok(askedAgain > 0, 'and the same surface is asked about again');
await tick();
assert.equal(anchored.length, 1, 'the same answer starts nothing');
});
test('scripted keyless fleet keeps its known floor through selection and floor rereads', async (t) => {
const app = harness(t, { floorAt: () => undefined });
app.viewer.scene.globe.show = true;
@@ -3200,27 +3403,13 @@ for (const count of [800, 3000]) {
test(`real perspective frustum admits all ${count} moving budget fixtures`, async (t) => {
const altitude = count === 800 ? 600 : 30000;
const app = harness(t, { altitude, floorAt: () => undefined });
const camera = app.viewer.camera;
camera.positionWC = Cesium.Cartesian3.fromDegrees(
BOSTON.lon,
BOSTON.lat,
altitude,
);
camera.directionWC = Cesium.Cartesian3.negate(
Cesium.Ellipsoid.WGS84.geodeticSurfaceNormal(
camera.positionWC,
new Cesium.Cartesian3(),
),
new Cesium.Cartesian3(),
);
const enu = Cesium.Transforms.eastNorthUpToFixedFrame(camera.positionWC);
camera.upWC = Cesium.Matrix4.getColumn(enu, 1, new Cesium.Cartesian3());
camera.frustum = new Cesium.PerspectiveFrustum({
fov: Math.PI / 3,
// Straight down from the altitude, through the frustum the camera port
// describes.
app.viewer.camera.view = {
...viewFrom(BOSTON.lon, BOSTON.lat, altitude),
aspectRatio: 1920 / 1080,
near: 1,
far: 100000,
});
};
app.layer.enable(app.viewer);
const loaded = app.layer._loadTransitFleetForTest(
count,
@@ -3229,6 +3418,10 @@ for (const count of [800, 3000]) {
);
assert.equal(loaded.moving, count);
assert.equal(app.state()._visible.size, count);
assert.ok(
app.vehicles().every((e) => e.visibility?.boundsApplied === false),
'the frustum, not the view rectangle, admitted them',
);
const entry = app.vehicles()[0],
before = Cesium.Cartesian3.clone(entry.marker.position);
app.run(1000, 16);
@@ -3242,8 +3435,8 @@ test('click handler selects a migrated scripted billboard and prepares its drape
app.layer.enable(app.viewer);
app.layer._loadTransitFleetForTest(4, BOSTON, 70);
const entry = app.vehicles()[0];
assert.equal(entry.markerCollection, app.state()._animatedMarkers);
app.viewer.scene.pick = () => ({ primitive: entry.marker, id: entry.key });
assert.equal(entry.animated, true);
app.viewer.scene.pick = () => app.pickOf(entry);
app.input.click(new Cesium.Cartesian2(500, 400));
assert.equal(app.state()._selectedKey, entry.key);
const body = app.layer._transitPartsForTest().trails.diagnostics().body;
@@ -3445,7 +3638,7 @@ test('selected anchor rejects nonfinite marker coordinates before sampling and d
assert.equal(card.position(), null);
});
test('preset clicks preserve both pick id paths through moving and stationary collection migration', async (t) => {
test('preset clicks pick the marker in whichever set draws it, moving or still', async (t) => {
const app = harness(t, { floorAt: () => undefined });
app.layer.enable(app.viewer);
app.layer._loadTransitFleetForTest(4, BOSTON, 70);
@@ -3459,17 +3652,17 @@ test('preset clicks preserve both pick id paths through moving and stationary co
entry.sample.nextWakeMonoMs = Infinity;
entry.sample.segmentCourseDeg = entry.courseDeg;
parts.rendering.schedulePlayback(entry);
parts.rendering.flushMarkers();
assert.equal(entry.animated, animated);
assert.ok(app.markers(animated ? 'moving' : 'still').has(entry.key));
app.viewer.scene.pick = () => app.pickOf(entry);
app.input.click(new Cesium.Cartesian2(500, 400));
assert.equal(app.state()._selectedKey, entry.key);
assert.equal(
entry.markerCollection,
animated ? app.state()._animatedMarkers : app.state()._markers,
app.state()._lastPickForTest.collection,
animated ? 'animated' : 'stationary',
);
assert.equal(entry.marker.id, entry.key);
for (const pick of [{ id: entry.key }, { primitive: entry.marker }]) {
app.viewer.scene.pick = () => pick;
app.input.click(new Cesium.Cartesian2(500, 400));
assert.equal(app.state()._selectedKey, entry.key);
parts.selection.clearSelection();
}
parts.selection.clearSelection();
}
});
@@ -3501,7 +3694,7 @@ test('sensor clicks map displayed pixels into the pre-shader pick buffer', async
let actual;
scene.pick = (p) => {
actual = { x: p.x, y: p.y };
return { id: entry.key };
return app.pickOf(entry);
};
scene.canvas = {
width: 1920,
@@ -3765,7 +3958,12 @@ test('moving and stationary transit stay adjacent above CCTV and Bikeshare durin
const cctv = {},
bike = {},
flights = {};
app.primitives.push(cctv, bike, flights);
// The marker sets' hosts, named by their set ids as the draw port names
// them, between the others.
const [stillId, movingId] = app.layer._transitSetIdsForTest();
const still = { drawSetId: stillId },
moving = { drawSetId: movingId };
app.primitives.push(cctv, still, bike, moving, flights);
app.viewer.scene.primitives.raiseToTop = (c) => {
app.primitives.splice(app.primitives.indexOf(c), 1);
app.primitives.push(c);
@@ -3783,24 +3981,24 @@ test('moving and stationary transit stay adjacent above CCTV and Bikeshare durin
});
const entry = app.vehicles()[0],
parts = app.layer._transitPartsForTest();
const stillHost = still,
movingHost = moving;
for (const moving of [true, false, true]) {
entry.sample.phase = moving ? 'playing' : 'held';
entry.sample.segmentSpeedMps = moving ? 1 : 0;
entry.sample.segmentCourseDeg = NaN;
parts.rendering.schedulePlayback(entry);
restoreSpriteOrder(app.viewer);
const active = app.primitives.indexOf(entry.markerCollection);
parts.rendering.flushMarkers();
assert.ok(app.markers(moving ? 'moving' : 'still').has(entry.key));
const active = app.primitives.indexOf(moving ? movingHost : stillHost);
assert.ok(active > app.primitives.indexOf(cctv));
assert.ok(active > app.primitives.indexOf(bike));
assert.ok(active < app.primitives.indexOf(flights));
assert.equal(
Math.abs(
app.primitives.indexOf(app.state()._markers) -
app.primitives.indexOf(app.state()._animatedMarkers),
),
app.primitives.indexOf(movingHost) - app.primitives.indexOf(stillHost),
1,
);
assert.equal(entry.marker.id, entry.key);
}
});
@@ -4003,6 +4201,50 @@ test('parked transit reprojects held and reported courses at the bounded camera
);
};
pose(0);
// The camera port reads the camera above; the query port projects through
// it as a pinhole the size of the canvas.
const viewer = { scene };
const plainOf = (c) => ({ x: c.x, y: c.y, z: c.z });
const direction = { x: -1, y: 0, z: 0 };
const dot = (a, b) => a.x * b.x + a.y * b.y + a.z * b.z;
const unbind = bindRenderer(viewer, {
camera: {
pose: () => ({
lon: 0,
lat: 0,
height: 1000,
heading: scene.camera.heading,
pitch: scene.camera.pitch,
roll: scene.camera.roll,
position: plainOf(cameraPosition),
direction,
up: plainOf(scene.camera.upWC),
right: plainOf(scene.camera.rightWC),
fovy: scene.camera.frustum.fovy,
aspectRatio: 1.6,
near: 1,
far: 1e7,
}),
},
query: {
project(p) {
const v = {
x: p.x - cameraPosition.x,
y: p.y - cameraPosition.y,
z: p.z - cameraPosition.z,
};
const z = dot(v, direction);
if (!(z > 0)) return null;
const f = 400 / Math.tan(scene.camera.frustum.fovy / 2);
return {
x: 640 + (f * dot(v, scene.camera.rightWC)) / z,
y: 400 - (f * dot(v, scene.camera.upWC)) / z,
};
},
isOccluded: () => false,
},
});
t.after(unbind);
const make = (key, courseDeg, bearing) => ({
key,
courseDeg,
@@ -4015,7 +4257,7 @@ test('parked transit reprojects held and reported courses at the bounded camera
const unknown = make('unknown', null, null);
const hidden = make('hidden', 90, 90);
const state = {
_viewer: { scene },
_viewer: viewer,
_enabled: true,
_vehicles: new Map(
[held, reportedOnly, unknown, hidden].map((e) => [e.key, e]),
+1 -1
View File
@@ -84,7 +84,7 @@ export function createQueries({ state, parts }) {
* @returns {Array<object>}
*/
function collectDetectableVehicles(options = defaults) {
if (!state._enabled || !state._markers?.show) return empty;
if (!state._enabled || !state._markersShown) return empty;
if (state._vehicles.size === 0) return empty;
const maxCount = Number.isFinite(options.maxCount)
? Math.max(1, Math.floor(options.maxCount))
+452 -231
View File
@@ -1,14 +1,16 @@
import * as Cesium from 'cesium';
// The Cesium camera factory: given a viewer of a caller's own, with no
// renderer bound, the layer's camera reads find a camera port.
import '../../render/cesium/camera.js';
import '../../render/cesium/frame.js';
import { webglContext } from '../../render/cesium/internals.js';
import { findCamera, findFrame } from '../../render/rendererOf.js';
import {
cameraPoseSignature,
perspectiveProjectedRotation,
} from '../../render/cesium/iconOrientation.js';
canvasOf,
drawOf,
findCamera,
findFrame,
findGlobe,
findQuery,
} from '../../render/rendererOf.js';
import { poseSignature } from '../../render/camera/poseSignature.js';
import { heightsOf } from '../../queries/heights.js';
import { fromDegreesInto } from '../../geo/ellipsoid.js';
import { frustumPlanes } from '../../geo/frustum.js';
import { perspectiveCourseRotation } from '../../data/screenRotation.js';
import {
updatePlayback,
applyDisplayCourse,
@@ -35,15 +37,22 @@ import {
vehicleNearView,
} from './policy.js';
export const MODE_CESIUM_COLORS = Object.fromEntries(
Object.entries(TRANSIT_MODE_COLORS).map(([mode, css]) => [
mode,
Cesium.Color.fromCssColorString(css),
]),
);
/** Layers built so far, so each one's draw sets have ids of their own. */
let instances = 0;
/** Radius, metres, of the sphere a vehicle is culled by. */
const CULL_RADIUS_M = 5;
/**
* Billboards and the per-frame glide.
* Markers and the per-frame glide.
*
* Each vehicle's marker is a plain record (`entry.marker`: its position,
* whether it shows, its image, size, colour and screen rotation) drawn as
* an icon in one of two draw sets: the still one, or the moving one while
* it glides or turns, so a fleet at rest is not rewritten with the few
* that move. Changed markers are pushed to their sets once per frame (and
* once per visibility sweep), each with the one item object it keeps:
* a frame pass over a moving fleet allocates nothing per vehicle.
* @param {object} context
* @returns {object}
*/
@@ -56,69 +65,211 @@ export function createRendering({ state, services, parts }) {
// The application's rendered-mesh sampler. Optional so a layer built on a
// bare floor stub still runs; the application always supplies it.
const sampleMeshFloorCells = services.mesh?.sampleMeshFloorCells || null;
const instance = (instances += 1);
/** Markers changed since they were last pushed to their sets. */
const dirty = new Set();
// Kept between pushes, so a push allocates no lists.
const stillUpserts = [];
const movingUpserts = [];
const stillRemovals = [];
const movingRemovals = [];
/**
* The two billboard collections, still and moving, added to the scene and
* to the shared sprite order, hidden.
* The two icon sets, still and moving, hidden, in the scene now (with no
* items) and in the shared sprite order. A viewer of the layer's own
* draws through `./render/cesium/unbound`, which its owner loads.
* @param {object} viewer
*/
function createMarkers(viewer) {
state._markers = new Cesium.BillboardCollection({
blendOption: Cesium.BlendOption.TRANSLUCENT,
destroyMarkers(viewer);
const draw = drawOf(viewer);
state._stillIcons = draw.icons({
id: `transit:${instance}:still`,
blend: 'translucent',
show: false,
});
viewer.scene.primitives.add(state._markers);
services.sprites.registerSpriteCollection('transit', state._markers);
state._animatedMarkers = new Cesium.BillboardCollection({
blendOption: Cesium.BlendOption.TRANSLUCENT,
state._movingIcons = draw.icons({
id: `transit:${instance}:moving`,
blend: 'translucent',
show: false,
});
viewer.scene.primitives.add(state._animatedMarkers);
services.sprites.registerSpriteCollection(
// Emptied, they are drawn now: the sprite order finds them at once.
state._stillIcons.set([]);
state._movingIcons.set([]);
const { registerSpriteSet } = services.sprites;
state._stillSprite = registerSpriteSet?.('transit', state._stillIcons.id);
state._movingSprite = registerSpriteSet?.(
'transit-motion',
state._animatedMarkers,
state._movingIcons.id,
);
state._animatedMarkers.show = false;
state._markers.show = false;
state._markersShown = false;
}
/** Show both collections. */
/** Show both sets. */
function showMarkers() {
state._markers.show = true;
state._animatedMarkers.show = true;
if (!state._stillIcons) return;
state._stillIcons.show = true;
state._movingIcons.show = true;
state._markersShown = true;
}
/** Drop every billboard and hide both collections. */
/** Drop every marker and hide both sets. */
function clearMarkers() {
state._markers?.removeAll();
state._animatedMarkers?.removeAll();
if (state._animatedMarkers) state._animatedMarkers.show = false;
if (state._markers) state._markers.show = false;
dirty.clear();
stillRemovals.length = 0;
movingRemovals.length = 0;
state._stillIcons?.clear();
state._movingIcons?.clear();
if (state._movingIcons) state._movingIcons.show = false;
if (state._stillIcons) state._stillIcons.show = false;
state._markersShown = false;
}
/**
* Take both collections off the scene and out of the sprite order.
* @param {object|null|undefined} viewer
* Let both sets go and take them out of the sprite order.
* @param {object|null|undefined} _viewer
*/
function destroyMarkers(viewer) {
if (state._markers) {
services.sprites.unregisterSpriteCollection('transit', state._markers);
viewer?.scene?.primitives?.remove(state._markers);
state._markers = null;
function destroyMarkers(_viewer) {
dirty.clear();
stillRemovals.length = 0;
movingRemovals.length = 0;
const { unregisterSpriteCollection } = services.sprites;
if (state._stillIcons) {
if (state._stillSprite)
unregisterSpriteCollection?.('transit', state._stillSprite);
state._stillIcons.dispose();
state._stillIcons = null;
state._stillSprite = null;
}
if (state._animatedMarkers) {
services.sprites.unregisterSpriteCollection(
'transit-motion',
state._animatedMarkers,
);
viewer?.scene?.primitives?.remove(state._animatedMarkers);
state._animatedMarkers = null;
if (state._movingIcons) {
if (state._movingSprite)
unregisterSpriteCollection?.('transit-motion', state._movingSprite);
state._movingIcons.dispose();
state._movingIcons = null;
state._movingSprite = null;
}
state._markersShown = false;
}
/** Whether a vehicle's billboard is shown. */
/** The ids of both sets (for the frame probe and floor sampling). */
function setIds() {
return [state._stillIcons?.id, state._movingIcons?.id].filter(Boolean);
}
/** Whether `setId` is one of this layer's sets. */
function ownsSet(setId) {
return (
typeof setId === 'string' &&
(setId === state._stillIcons?.id || setId === state._movingIcons?.id)
);
}
/** Which of the sets a draw set id is: `'moving'`, `'still'` or null. */
function setNameOf(setId) {
if (setId && setId === state._movingIcons?.id) return 'moving';
if (setId && setId === state._stillIcons?.id) return 'still';
return null;
}
/** Whether a vehicle's marker is shown. */
function markerShown(entry) {
return entry.marker?.show === true;
}
/** Note that a marker changed, for the next push. */
function markDirty(entry) {
if (entry.marker) dirty.add(entry);
}
/** Show or hide a marker. */
function setShown(entry, shown) {
if (entry.marker.show === shown) return;
entry.marker.show = shown;
dirty.add(entry);
}
/**
* The icon item a marker draws as: the one item object the vehicle
* keeps, brought up to date. Its position is the marker's own, which the
* frame pass moves in place; the renderer reads positions as they are
* when pushed.
*/
function itemOf(entry) {
const marker = entry.marker;
const item = (entry.iconItem ||= {
id: entry.key,
pos: marker.position,
image: marker.image,
size: [0, 0],
color: marker.color,
rotationMode: 'screen',
rotation: 0,
show: false,
disableDepthTest: Infinity,
meta: { layer: 'transit', key: entry.key },
});
item.pos = marker.position;
item.image = marker.image;
item.size[0] = marker.width;
item.size[1] = marker.height;
item.color = marker.color;
item.rotation = marker.rotation;
item.show = marker.show;
return item;
}
/**
* Push the markers changed since the last push to their sets: a marker
* that changed set leaves the one it was in first.
*/
function flushMarkers() {
const still = state._stillIcons;
const moving = state._movingIcons;
if (!still || !moving) return;
if (!dirty.size && !stillRemovals.length && !movingRemovals.length) return;
for (const entry of dirty) {
if (!entry.marker) continue;
const target = entry.animated ? moving : still;
if (entry.drawnIn && entry.drawnIn !== target)
(entry.drawnIn === still ? stillRemovals : movingRemovals).push(
entry.key,
);
entry.drawnIn = target;
(target === still ? stillUpserts : movingUpserts).push(itemOf(entry));
}
dirty.clear();
if (stillRemovals.length) still.remove(stillRemovals);
if (movingRemovals.length) moving.remove(movingRemovals);
if (stillUpserts.length) still.upsert(stillUpserts);
if (movingUpserts.length) moving.upsert(movingUpserts);
stillRemovals.length = 0;
movingRemovals.length = 0;
stillUpserts.length = 0;
movingUpserts.length = 0;
}
/**
* Take a vehicle's marker out of the set it is drawn in: with the others
* taken out in this task, in one removal (a sweep drops many at once).
*/
let flushQueued = false;
function removeMarker(entry) {
dirty.delete(entry);
const set = entry.drawnIn;
entry.drawnIn = null;
if (!set) return;
if (set === state._stillIcons) stillRemovals.push(entry.key);
else if (set === state._movingIcons) movingRemovals.push(entry.key);
else return;
if (flushQueued) return;
flushQueued = true;
queueMicrotask(() => {
flushQueued = false;
flushMarkers();
});
}
/**
* Listen for the camera moving, at this layer's own threshold.
*
@@ -159,7 +310,7 @@ export function createRendering({ state, services, parts }) {
function startFrames(viewer) {
if (!state._preRenderRemove)
state._preRenderRemove =
viewer.scene.preRender.addEventListener(onPreRender);
findFrame(viewer)?.on('preRender', onPreRender) ?? null;
}
/** Stop the per-frame glide. */
@@ -170,23 +321,91 @@ export function createRendering({ state, services, parts }) {
}
}
// The camera's pose and the globe's surface version, read once in a task:
// a sweep, a frame or a poll asks for them per vehicle, and reading them
// walks the camera's frames and the scene's primitives. Forgotten when the
// task ends, and at the start of every frame and visibility sweep.
let viewMemo = null;
let viewMemoQueued = false;
function forgetView() {
viewMemo = null;
}
function viewOf() {
if (viewMemo) return viewMemo;
viewMemo = { pose: undefined, surface: undefined };
if (!viewMemoQueued) {
viewMemoQueued = true;
queueMicrotask(() => {
viewMemoQueued = false;
viewMemo = null;
});
}
return viewMemo;
}
/** The camera port's pose, or null without a camera. */
function cameraPose() {
const view = viewOf();
if (view.pose === undefined)
view.pose = findCamera(state._viewer)?.pose() ?? null;
return view.pose;
}
/**
* The camera's height above the ellipsoid, or Infinity when it has none.
* @returns {number}
*/
function cameraHeightM() {
const carto = state._viewer?.camera?.positionCartographic;
return carto && Number.isFinite(carto.height) ? carto.height : Infinity;
const height = cameraPose()?.height;
return Number.isFinite(height) ? height : Infinity;
}
/** The camera's subpoint in degrees, for the sampler's proximity gate. */
function viewerSubpoint() {
const carto = state._viewer?.camera?.positionCartographic;
if (!carto) return { viewerLat: undefined, viewerLon: undefined };
return {
viewerLat: (carto.latitude * 180) / Math.PI,
viewerLon: (carto.longitude * 180) / Math.PI,
const pose = cameraPose();
if (!pose) return { viewerLat: undefined, viewerLon: undefined };
return { viewerLat: pose.lat, viewerLon: pose.lon };
}
// Whether the globe's terrain is the bare ellipsoid, as the height service
// last said for the surface `surfaceVersion` names; asked again whenever
// that changes, keeping the last answer until the new one comes. A terrain
// height that is only the ellipsoid's is one the service counts as a miss
// when asked to, so the ellipsoid is the point answered plainly and missed
// that way.
let flatVersion = null;
let flatTerrain = false;
function askFlat(globe) {
const view = viewOf();
if (view.surface === undefined)
view.surface = globe.surfaceVersion?.() ?? 0;
const version = view.surface;
if (version === flatVersion) return;
flatVersion = version;
const pose = cameraPose();
const point = {
lon: Number.isFinite(pose?.lon) ? pose.lon : 0,
lat: Number.isFinite(pose?.lat) ? pose.lat : 0,
};
const heights = heightsOf(state._viewer);
Promise.all([
heights.batch([point], { against: 'terrain' }),
heights.batch([point], { against: 'terrain', ellipsoidMisses: true }),
]).then(
([[answered], [terrain]]) => {
if (flatVersion !== version) return;
const flat = answered !== null && terrain === null;
if (flat === flatTerrain) return;
flatTerrain = flat;
// Floors read under the last answer are read again under this one,
// in a fresh cycle (which replaces the one pending).
if (state._enabled) parts.height.anchorFloors?.();
},
() => {
// Asked again at the next read.
if (flatVersion === version) flatVersion = null;
},
);
}
/**
@@ -195,44 +414,36 @@ export function createRendering({ state, services, parts }) {
* @returns {'none'|'flat'|'terrain'}
*/
function globeSurface() {
if (state._viewer?.scene?.globe?.show !== true) return 'none';
return state._viewer?.terrainProvider instanceof
Cesium.EllipsoidTerrainProvider
? 'flat'
: 'terrain';
const globe = findGlobe(state._viewer);
if (globe?.isGlobeVisible?.() !== true) return 'none';
askFlat(globe);
return flatTerrain ? 'flat' : 'terrain';
}
/**
* Sample the rendered mesh under floor cells, seeing through these
* vehicles' billboards.
* Sample the rendered mesh under floor cells, seeing through this layer's
* own sets.
* @param {object[]} cells
* @param {object[]} entries
*/
function sampleMeshFloors(cells, entries) {
function sampleMeshFloors(cells) {
if (!sampleMeshFloorCells) return;
const markers = entries.map((entry) => entry.marker).filter(Boolean);
const sets = setIds();
for (let i = 0; i < cells.length; i += 8)
sampleMeshFloorCells(state._viewer?.scene, cells.slice(i, i + 8), {
excludeObjects: markers,
sampleMeshFloorCells(state._viewer, cells.slice(i, i + 8), {
sets,
...viewerSubpoint(),
});
}
/**
* Cartesian position for a lat/lon at a height. Called on POLL, not per
* frame: `fromDegrees` runs trigonometry, and doing that for every vehicle on
* ECEF position for a lat/lon at a height. Called on POLL, not per frame:
* the conversion runs trigonometry, and doing that for every vehicle on
* every frame was most of what made this layer heavy.
*/
function cartesianFor(lat, lon, heightM, out) {
function cartesianFor(lat, lon, heightM, out = { x: 0, y: 0, z: 0 }) {
// `heightM` already carries the shared floor's own lift, so nothing is
// added here: two lifts stacked is a vehicle hovering.
return Cesium.Cartesian3.fromDegrees(
lon,
lat,
heightM || 0,
undefined,
out,
);
return fromDegreesInto(lon, lat, heightM || 0, out);
}
/** Heights are aligned to work with Google 3D tiles. Rebuild both ends. */
@@ -244,13 +455,13 @@ export function createRendering({ state, services, parts }) {
entry.from.lat,
entry.from.lon,
entry.from.h,
entry.fromCart || new Cesium.Cartesian3(),
entry.fromCart || { x: 0, y: 0, z: 0 },
);
entry.toCart = cartesianFor(
entry.to.lat,
entry.to.lon,
entry.to.h,
entry.toCart || new Cesium.Cartesian3(),
entry.toCart || { x: 0, y: 0, z: 0 },
);
entry.endpointRevision = entry.sample.revision;
entry.endpointFromSeq = entry.sample.fromSeq;
@@ -271,9 +482,16 @@ export function createRendering({ state, services, parts }) {
);
entry.surfaceReady = !!known;
entry.heightPending = !known;
entry.marker.show = !!known && vehicleInView(entry);
setShown(entry, !!known && vehicleInView(entry));
if (known) {
entry.marker.position = state._scratchCartesian;
const p = entry.marker.position;
const s = state._scratchCartesian;
if (p.x !== s.x || p.y !== s.y || p.z !== s.z) {
p.x = s.x;
p.y = s.y;
p.z = s.z;
dirty.add(entry);
}
entry.hasRendered = true;
}
}
@@ -288,29 +506,12 @@ export function createRendering({ state, services, parts }) {
if (entry.wakeTimer != null) clearTimeout(entry.wakeTimer);
entry.wakeTimer = null;
}
/** Draw a marker in the moving set, or the still one. */
function migrateMarker(entry, animated) {
const collection = animated ? state._animatedMarkers : state._markers;
if (!entry.marker || entry.markerCollection === collection) return;
const old = entry.marker;
const marker = collection.add({
id: entry.key,
position: old.position,
image: old.image,
width: old.width,
height: old.height,
color: old.color,
scaleByDistance: old.scaleByDistance,
rotation: old.rotation,
alignedAxis: old.alignedAxis,
show: old.show,
disableDepthTestDistance: old.disableDepthTestDistance,
});
entry.markerCollection.remove(old);
entry.marker = marker;
entry.markerCollection = collection;
if (!entry.marker || entry.animated === animated) return;
entry.animated = animated;
entry.markerRevision = (entry.markerRevision || 0) + 1;
// Cached contacts and card getters must follow the replacement billboard.
if (entry.detectContact) entry.detectContact.position = marker.position;
dirty.add(entry);
}
function schedulePlayback(entry) {
cancelWake(entry);
@@ -346,6 +547,7 @@ export function createRendering({ state, services, parts }) {
updatePlayback(entry, Date.now(), performance.now());
placeSample(entry);
schedulePlayback(entry);
flushMarkers();
syncRenderHold();
governorRequestRender('transit-motion-boundary');
},
@@ -365,7 +567,7 @@ export function createRendering({ state, services, parts }) {
return state._visible.has(entry);
}
/** Cesium colour for a preset tuple, cached per profile+mode. */
/** A preset tuple as a colour (0..1 channels), cached per profile+mode. */
const _presetColors = new Map();
function presetColor(style, mode) {
const rgba = presetSpriteRgba(style, mode);
@@ -373,12 +575,12 @@ export function createRendering({ state, services, parts }) {
const key = `${transitStyleProfile(style)}:${mode}`;
let color = _presetColors.get(key);
if (!color) {
color = new Cesium.Color(
color = Object.freeze([
rgba[0] / 255,
rgba[1] / 255,
rgba[2] / 255,
rgba[3],
);
]);
_presetColors.set(key, color);
}
return color;
@@ -416,28 +618,27 @@ export function createRendering({ state, services, parts }) {
entry.detectContact.bracketHalfWidth = Math.ceil(px / 2) + 2;
entry.detectContact.bracketHalfHeight = Math.ceil(px / 2) + 2;
}
const preset = presetColor(style, entry.mode);
if (preset) marker.color = preset;
else
marker.color =
MODE_CESIUM_COLORS[entry.mode] || MODE_CESIUM_COLORS.unknown;
marker.color =
presetColor(style, entry.mode) ||
TRANSIT_MODE_COLORS[entry.mode] ||
TRANSIT_MODE_COLORS.unknown;
dirty.add(entry);
}
function addMarker(key, entry) {
const marker = state._markers.add({
id: key,
position: entry.toCart,
const at = entry.toCart;
const marker = {
position: { x: at?.x ?? 0, y: at?.y ?? 0, z: at?.z ?? 0 },
show: false,
image: transitIcon(entry.mode),
width: MARKER_PIXEL_SIZE,
height: MARKER_PIXEL_SIZE,
color: MODE_CESIUM_COLORS[entry.mode],
color: TRANSIT_MODE_COLORS[entry.mode],
rotation: 0,
alignedAxis: Cesium.Cartesian3.ZERO,
disableDepthTestDistance: Number.POSITIVE_INFINITY,
});
};
entry.marker = marker;
entry.markerCollection = state._markers;
marker.show = false;
entry.animated = false;
entry.drawnIn = null;
applySpriteStyle(entry);
return marker;
}
@@ -462,14 +663,29 @@ export function createRendering({ state, services, parts }) {
if (next === state._stylePreset) return;
state._stylePreset = next;
for (const entry of state._vehicles.values()) applySpriteStyle(entry);
flushMarkers();
parts.trails.style();
governorRequestRender('transit-style');
}
/**
* The screen rotation that points a marker along `course`, projected
* exactly through the query port (see `perspectiveCourseRotation`).
*/
function courseRotation(query, pose, position, course, previous) {
return perspectiveCourseRotation(
query.project,
pose,
position,
course,
previous,
);
}
/**
* Point every glyph along its reported course.
*
* Billboards are camera-facing quads, so a course has to be projected into
* Icons are camera-facing quads, so a course has to be projected into
* screen space — which depends on where the camera is, not only on the
* vehicle. Doing that for the whole fleet on every frame is exactly the kind
* of cost that made this layer heavy, and it buys nothing: a bus icon whose
@@ -478,17 +694,18 @@ export function createRendering({ state, services, parts }) {
* changed somebody's heading.
*/
function refreshRotations(now) {
const scene = state._viewer?.scene;
if (!scene?.camera) return;
if (now - state._rotationAt < ROTATION_REFRESH_MS) return;
const pose = cameraPose();
const query = findQuery(state._viewer);
if (!pose?.position || !query) return;
state._rotationAt = now;
const pose = cameraPoseSignature(scene.camera);
const signature = poseSignature(pose);
const cameraChanged =
state._rotationPose !== pose ||
state._rotationPose !== signature ||
state._rotationRevision !== state._cameraRevision;
if (!cameraChanged && !state._rotationDirty && state._moving.size === 0)
return;
state._rotationPose = pose;
state._rotationPose = signature;
state._rotationRevision = state._cameraRevision;
state._rotationDirty = false;
const monoNow = performance.now();
@@ -496,13 +713,15 @@ export function createRendering({ state, services, parts }) {
// Idle contacts still need a course when their first usable bearing arrives.
if (!state._moving.has(entry)) applyDisplayCourse(entry, monoNow);
if (entry.key === state._selectedKey) continue;
const marker = entry.marker;
const course = entry.courseDeg;
if (!Number.isFinite(course)) {
entry.marker.rotation = 0;
if (marker.rotation !== 0) dirty.add(entry);
marker.rotation = 0;
entry.rotationCourse = null;
continue;
}
const position = entry.marker.position;
const position = marker.position;
if (
!cameraChanged &&
entry.rotationCourse === course &&
@@ -520,12 +739,17 @@ export function createRendering({ state, services, parts }) {
// camera-basis helper aircraft use is orthographic — fine at altitude,
// and wrong by twenty-odd degrees for a street-level contact away from
// the centre of an obliquely pitched view, which is most of them.
entry.marker.rotation = perspectiveProjectedRotation(
scene,
entry.marker.position,
const rotation = courseRotation(
query,
pose,
position,
course,
entry.marker.rotation,
marker.rotation,
);
if (rotation !== marker.rotation) {
marker.rotation = rotation;
dirty.add(entry);
}
}
}
@@ -559,6 +783,7 @@ export function createRendering({ state, services, parts }) {
)
return;
if (!state._enabled) return;
forgetView();
const now = Date.now();
if (state._vehicles.size === 0) {
state._moving.clear();
@@ -598,23 +823,31 @@ export function createRendering({ state, services, parts }) {
refreshRotations(now);
const selected = state._vehicles.get(state._selectedKey);
if (selected && state._visible.has(selected)) {
selected.marker.rotation = Number.isFinite(selected.courseDeg)
? perspectiveProjectedRotation(
state._viewer.scene,
selected.marker.position,
const marker = selected.marker;
const pose = Number.isFinite(selected.courseDeg) ? cameraPose() : null;
const query = pose?.position ? findQuery(state._viewer) : null;
const rotation = query
? courseRotation(
query,
pose,
marker.position,
selected.courseDeg,
selected.marker.rotation,
marker.rotation,
)
: 0;
: Number.isFinite(selected.courseDeg)
? marker.rotation
: 0;
if (rotation !== marker.rotation) {
marker.rotation = rotation;
dirty.add(selected);
}
}
flushMarkers();
if (state._heightDirty.size) governorRequestRender('transit-height-batch');
syncRenderHold();
}
const occluder = new Cesium.EllipsoidalOccluder(Cesium.Ellipsoid.WGS84);
const sphere = new Cesium.BoundingSphere(undefined, 5);
const cameraPosition = new Cesium.Cartesian3();
const candidatePosition = new Cesium.Cartesian3();
const candidatePosition = { x: 0, y: 0, z: 0 };
/** Visibility work runs off the frame path, coalesced at four sweeps/second. */
function requestVisibility() {
state._visibilityDirty = true;
@@ -627,6 +860,24 @@ export function createRendering({ state, services, parts }) {
Math.max(0, VISIBILITY_REFRESH_MS - (Date.now() - state._visibilityAt)),
);
}
/**
* The planes of the frustum the camera looks through, as the default
* renderer culls with them, or null when the pose does not describe one.
*/
function viewPlanes(pose) {
if (
!pose?.position ||
!pose.direction ||
!pose.up ||
!Number.isFinite(pose.fovy) ||
!Number.isFinite(pose.aspectRatio) ||
!Number.isFinite(pose.near)
)
return null;
return frustumPlanes(pose);
}
function refreshVisibility() {
if (!state._enabled) return 0;
const now = Date.now();
@@ -636,33 +887,22 @@ export function createRendering({ state, services, parts }) {
}
state._visibilityAt = now;
state._visibilityDirty = false;
const viewer = state._viewer,
camera = viewer?.camera;
if (!camera) return 0;
const position =
camera.positionWC ||
Cesium.Ellipsoid.WGS84.cartographicToCartesian(
camera.positionCartographic,
cameraPosition,
);
occluder.cameraPosition = position;
const frustum = camera.frustum?.computeCullingVolume(
position,
camera.directionWC,
camera.upWC,
);
const planes = frustum?.planes;
forgetView();
const pose = cameraPose();
if (!pose) return 0;
const query = findQuery(state._viewer);
const planes = viewPlanes(pose);
let changed = false;
for (const entry of state._vehicles.values()) {
if (!entry.marker) continue;
// Refresh hidden clocks before testing admission, even if no frame has
// ever sampled them. Do not write the billboard until it is admitted.
// ever sampled them. Do not write the marker until it is admitted.
const noSample = !entry.sample || !Number.isFinite(entry.sample.lat);
if (entry.track?.count && (!state._visible.has(entry) || noSample)) {
entry.sample ||= {};
updatePlayback(entry, now, performance.now());
}
sphere.center =
const center =
state._visible.has(entry) || !entry.sample
? entry.marker.position
: cartesianFor(
@@ -675,24 +915,24 @@ export function createRendering({ state, services, parts }) {
// view. The current frustum is authoritative; the horizon still rejects
// the far side when the rectangle is missing or stale.
const bounds = vehicleNearView(state._viewBounds, entry);
const horizon = occluder.isPointVisible(sphere.center);
const horizon = !(query?.isOccluded(center) ?? false);
let inFrustum = true;
if (planes) {
for (let i = 0; i < planes.length; i++) {
const p = planes[i],
c = sphere.center;
if (p.x * c.x + p.y * c.y + p.z * c.z + p.w < -sphere.radius) {
const { normal: n, w } = planes[i];
if (
n.x * center.x + n.y * center.y + n.z * center.z + w <
-CULL_RADIUS_M
) {
inFrustum = false;
break;
}
}
} else if (frustum)
inFrustum =
frustum.computeVisibility(sphere) !== Cesium.Intersect.OUTSIDE;
const visible = (frustum || bounds) && horizon && inFrustum;
}
const visible = (planes || bounds) && horizon && inFrustum;
const visibility = (entry.visibility ||= {});
visibility.bounds = bounds;
visibility.boundsApplied = !frustum;
visibility.boundsApplied = !planes;
visibility.occluder = horizon;
visibility.frustum = inFrustum;
visibility.noSample = noSample;
@@ -713,13 +953,18 @@ export function createRendering({ state, services, parts }) {
placeSample(entry);
}
}
entry.marker.show =
visible && !entry.heightPending && entry.surfaceReady !== false;
setShown(
entry,
Boolean(
visible && !entry.heightPending && entry.surfaceReady !== false,
),
);
visibility.heightPending = !!entry.heightPending;
visibility.surfaceReady = entry.surfaceReady ?? null;
schedulePlayback(entry);
changed ||= visible !== wasVisible || wasShown !== entry.marker.show;
}
flushMarkers();
state._shownCount = state._visible.size;
if (changed) state._detectRevision++;
syncRenderHold();
@@ -740,6 +985,7 @@ export function createRendering({ state, services, parts }) {
placeSample(entry);
schedulePlayback(entry);
}
flushMarkers();
parts.trails.update();
parts.selection.refreshSelectedCard(true);
state._detectRevision++;
@@ -758,6 +1004,7 @@ export function createRendering({ state, services, parts }) {
function paintSelected(entry, selected) {
void selected; // decided from state._selectedKey, which the caller has set
applySpriteStyle(entry);
flushMarkers();
}
let stopProbe = null;
@@ -766,60 +1013,30 @@ export function createRendering({ state, services, parts }) {
stopProbe?.();
}
/** Measure inside Cesium postRender with fixed typed storage; no sample objects per frame. */
function measureFrames(durationMs = 12000) {
/**
* Measure inside the renderer's frames with fixed typed storage; no sample
* objects per frame. `uploads`, when given, counts the bytes the
* renderer uploads for this layer's sets each frame (the Cesium one's is
* `src/render/cesium/uploadProbe.js`, which QA hands in): `reset()` at
* each frame's start, `bytes()` at its end, `stop()` when done.
* @param {number} [durationMs]
* @param {{reset: () => void, bytes: () => number, stop: () => void}|null} [uploads]
*/
function measureFrames(durationMs = 12000, uploads = null) {
stopProbe?.();
const scene = state._viewer.scene;
const frame = findFrame(state._viewer);
const canvas = canvasOf(state._viewer);
const capacity = 20000,
stride = 12,
data = new Float64Array(capacity * stride);
const previousPositions = new Float64Array(state._vehicles.size * 3);
const gl = webglContext(scene);
let active = false,
upload = 0,
cpu = 0,
let cpu = 0,
count = 0,
previous = 0;
const saved = [];
for (const name of ['bufferData', 'bufferSubData']) {
const original = gl[name];
gl[name] = function (...args) {
if (active) {
const value = args[name === 'bufferData' ? 1 : 2];
const offset = args[name === 'bufferData' ? 3 : 3] || 0;
const length = args[4];
upload +=
typeof value === 'number'
? value
: value
? length !== undefined
? length * (value.BYTES_PER_ELEMENT || 1)
: value.byteLength - offset * (value.BYTES_PER_ELEMENT || 1)
: 0;
}
return original.apply(this, args);
};
saved.push(() => {
gl[name] = original;
});
}
for (const collection of [state._markers, state._animatedMarkers]) {
const original = collection.update;
collection.update = function (frame) {
active = true;
try {
return original.call(this, frame);
} finally {
active = false;
}
};
saved.push(() => {
collection.update = original;
});
}
state._preRenderRemove?.();
const removePre = scene.preRender.addEventListener(() => {
upload = 0;
const wasRunning = state._preRenderRemove !== null;
stopFrames();
const removePre = frame.on('preRender', () => {
uploads?.reset();
const start = performance.now();
onPreRender();
cpu = performance.now() - start;
@@ -830,10 +1047,8 @@ export function createRendering({ state, services, parts }) {
clearTimeout(timer);
removePre();
removePost?.();
for (const restore of saved) restore();
if (state._enabled)
state._preRenderRemove =
scene.preRender.addEventListener(onPreRender);
uploads?.stop();
if (wasRunning && state._enabled) startFrames(state._viewer);
stopProbe = null;
const rows = [];
for (let i = 1; i < count; i++) {
@@ -854,12 +1069,12 @@ export function createRendering({ state, services, parts }) {
resolve({
rows,
dpr: devicePixelRatio,
width: scene.canvas.clientWidth,
height: scene.canvas.clientHeight,
width: canvas?.clientWidth,
height: canvas?.clientHeight,
});
};
stopProbe = finish;
removePost = scene.postRender.addEventListener(() => {
removePost = frame.on('postRender', () => {
const now = performance.now();
if (count >= capacity) return;
const k = count++ * stride;
@@ -867,7 +1082,7 @@ export function createRendering({ state, services, parts }) {
data[k] = previous ? now - previous : 0;
previous = now;
data[k + 1] = cpu;
data[k + 2] = upload;
data[k + 2] = uploads ? uploads.bytes() : 0;
let actuallyMoved = 0;
for (const vehicle of state._visible) {
const p = vehicle.marker.position,
@@ -905,7 +1120,13 @@ export function createRendering({ state, services, parts }) {
showMarkers,
clearMarkers,
destroyMarkers,
setIds,
ownsSet,
setNameOf,
markerShown,
markDirty,
flushMarkers,
removeMarker,
watchCamera,
unwatchCamera,
startFrames,
+10 -31
View File
@@ -119,42 +119,21 @@ export function createSelection({ state, services, parts }) {
// (src/input/sensorPick.js) and skips it while a tool holds the pointer.
state._clickSubscription = inputFor(viewer).onClick((event) => {
const position = event.position;
const picked = event.pick;
// The collection of the marker picked: the one its vehicle's marker is
// in, when the pick is one of this layer's markers.
const owner = state._vehicles.get(picked?.primitive?.id);
const collection =
owner && owner.marker === picked.primitive
? owner.markerCollection
: null;
// A marker is an item of one of this layer's two sets, by its key.
const hit = event.drawHit;
const set = parts.rendering.setNameOf(hit?.set);
const key = set && state._vehicles.has(hit.id) ? hit.id : null;
state._lastPickForTest = {
id: typeof picked?.id === 'string' ? picked.id : null,
primitiveId:
typeof picked?.primitive?.id === 'string'
? picked.primitive.id
: null,
id: key,
set: hit?.set ?? null,
x: position.x,
y: position.y,
collection:
collection && collection === state._animatedMarkers
? 'animated'
: collection && collection === state._markers
? 'stationary'
: null,
set === 'moving' ? 'animated' : set === 'still' ? 'stationary' : null,
};
if (picked) {
const primitiveId = picked.primitive?.id;
if (
typeof primitiveId === 'string' &&
state._vehicles.has(primitiveId)
) {
selectVehicle(primitiveId);
return;
}
if (typeof picked.id === 'string' && state._vehicles.has(picked.id)) {
selectVehicle(picked.id);
return;
}
if (key) {
selectVehicle(key);
return;
}
if (state._selectedKey) clearSelection();
});
+10 -4
View File
@@ -23,9 +23,14 @@ export function createState({ services }) {
/** The viewer the layer draws on, or null. */
state._viewer = null;
/** The stationary markers' billboard collection, or null. */
state._markers = null;
state._animatedMarkers = null;
/** The still markers' icon draw set, and the moving ones', or null. */
state._stillIcons = null;
state._movingIcons = null;
/** Their sprite-order registrations. */
state._stillSprite = null;
state._movingSprite = null;
/** Whether the markers are shown (the layer is on). */
state._markersShown = false;
state._visible = new Set();
state._visibilityTimer = null;
state._maintenanceTimer = null;
@@ -119,7 +124,8 @@ export function createState({ services }) {
state._error = null;
state._limitWarned = false;
// Where `samplePosition` writes a marker's position, each frame.
// Where `samplePosition` writes a marker's position, each frame, before
// it is copied into the marker.
state._scratchCartesian = { x: 0, y: 0, z: 0 };
return state;
+13 -3
View File
@@ -108,6 +108,7 @@ export function createTesting({ state, parts }) {
updatePlayback(entry, now, mono);
parts.rendering.placeSample(entry);
}
parts.rendering.flushMarkers();
clearTimeout(state._floorTimer);
state._floorTimer = null;
// Establish the fixture clock without the live re-entry reset.
@@ -147,11 +148,20 @@ export function createTesting({ state, parts }) {
parts.rendering.placeSample(entry);
parts.rendering.schedulePlayback(entry);
}
parts.rendering.flushMarkers();
parts.rendering.syncRenderHold();
},
/** Measure inside the renderer's frames with fixed typed storage. */
_measureTransitFramesForTest(durationMs = 12000) {
return parts.rendering.measureFrames(durationMs);
/**
* Measure inside the renderer's frames with fixed typed storage;
* `uploads` counts what the renderer uploads for the markers' sets
* (`src/render/cesium/uploadProbe.js` on the default renderer).
*/
_measureTransitFramesForTest(durationMs = 12000, uploads = null) {
return parts.rendering.measureFrames(durationMs, uploads);
},
/** The ids of the markers' two draw sets: still, then moving. */
_transitSetIdsForTest() {
return parts.rendering.setIds();
},
_transitVisibilityForTest() {
return [...state._vehicles.values()].map((entry) => {