mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 08:12:24 +00:00
Merge branch 'sameh/renderer-transit' into sameh/renderer-seam
# Conflicts: # src/render/cesium/draw.test.mjs
This commit is contained in:
commit
9d4e438e63
27 files changed
+2016
-465
No files matched your search
@@ -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);
|
||||
|
||||
@@ -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');
|
||||
|
||||
@@ -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]),
|
||||
|
||||
@@ -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
@@ -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,
|
||||
|
||||
@@ -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();
|
||||
});
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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) => {
|
||||
|
||||
Reference in new issue
Block a user