Draw the traffic dots through the draw port and read the road surface through renderer ports

The traffic layer's vehicle dots are now a points set on the draw port,
moved, added to and taken from in place each frame, instead of a Cesium
point collection. Road surface heights and readiness read the query,
camera, frame and globe ports and the heights service instead of the
scene; the surface identity and "any tileset drawn" checks, which the
contract cannot answer, move to rendering.js with the heat lines.

animation.js, style.js and surface.js leave the Cesium allow-list.

The Cesium draw port compares a moved point's look without allocating:
colours by index, and a frozen colour or curve of plain data by identity,
so a thousand dots moved every frame cost about what direct writes did.
The traffic QA scripts read the dots' draw items.
This commit is contained in:
Sameh Khamis committed 2026-11-07 23:16:11 -08:00
1 parent d9db5199ed
commit bbd6049e21
24 files changed
+872 -467

No files matched your search

+4
View File
@@ -2342,6 +2342,10 @@
"src/layers/traffic/ingestion.js",
"src/sources/requestDeadline.js",
"src/layers/traffic/lifecycle.js",
"src/render/cesium/globe.js",
"src/maps/google3d.js",
"src/render/cesium/imagery.js",
"src/render/cesium/tileRequests.js",
"src/layers/traffic/model.js",
"src/geo/ellipsoid.js",
"src/geo/vector.js",
+8 -4
View File
@@ -158,9 +158,13 @@ try {
(window.__motion.holdStart === null
? ''
: ` | camera stopped +${((now - window.__motion.holdStart) / 1000).toFixed(1)}s`);
// A layer dot is its draw item (`pos`, hidden only when `show` is
// false); a collection's point is Cesium's.
const visit = (id, roadId, point) => {
if (!point.show) return;
const s = scene.cartesianToCanvasCoordinates(point.position);
if (point.show === false) return;
const s = scene.cartesianToCanvasCoordinates(
point.pos ?? point.position,
);
if (s && s.x >= 0 && s.y >= 0 && s.x <= 1280 && s.y <= 800)
points.set(id, { x: s.x, y: s.y, roadId });
};
@@ -168,7 +172,7 @@ try {
offRoad = 0;
if (!baseline && layer.visitMotionDots) {
layer.visitMotionDots((id, roadId, point, road) => {
if (point.show) {
if (point.show !== false) {
const p = road?.roadProperties;
const allowed = road?.directFlow
? [
@@ -195,7 +199,7 @@ try {
p?.brunnel !== 'tunnel';
if (!allowed) offRoad++;
}
if (point.show) n++;
if (point.show !== false) n++;
visit(id, roadId, point);
});
} else {
+8 -5
View File
@@ -83,9 +83,10 @@ try {
lower = 0;
dataManager.layers
.get('traffic')
.module.visitMotionDots((id, key, p) => {
if (!p.show) return;
const s = viewer.scene.cartesianToCanvasCoordinates(p.position);
.module.visitMotionDots((id, key, dot) => {
// A dot is its draw item: `pos`, hidden only when `show` is false.
if (dot.show === false) return;
const s = viewer.scene.cartesianToCanvasCoordinates(dot.pos);
if (s && s.x >= 240 && s.x <= 1040 && s.y >= 0 && s.y <= 800) {
if (s.y < 400) upper++;
else lower++;
@@ -197,8 +198,10 @@ try {
const camera = viewer.camera.positionWC;
dataManager.layers
.get('traffic')
.module.visitMotionDots((id, key, p) => {
if (!p.show) return;
.module.visitMotionDots((id, key, dot) => {
// A dot is its draw item: `pos`, hidden only when `show` is false.
if (dot.show === false) return;
const p = { position: dot.pos };
const q = viewer.scene.cartesianToCanvasCoordinates(p.position);
if (q && q.x >= 240 && q.x <= 1040 && q.y >= 0 && q.y <= 800) {
if (q.y < 400) upper++;
+4
View File
@@ -257,6 +257,10 @@ test('traffic timing pairs real ordering to the scheduling change and guards re-
return { west: degrees(r.west), south: degrees(r.south), east: degrees(r.east), north: degrees(r.north) };
},
},
// The dots' draw set: timing reads none of what it draws.
draw: {
points: () => ({ show: false, upsert() {}, remove() {}, clear() {}, dispose() {} }),
},
});
performance.clearMarks();
+60 -64
View File
@@ -1,7 +1,7 @@
import { DOT_FADE_MS } from './retention.js';
import { flowBucket, flowSpeedScale } from '../../data/trafficFlowStyle.js';
import { presetDotOutline } from '../../data/trafficPresetStyle.js';
import * as Cesium from 'cesium';
import { lerpInto } from '../../geo/vector.js';
import { findFrame } from '../../render/rendererOf.js';
import { queuePlatoons, locateAlongRoad } from '../../data/trafficQueue.js';
import {
SPEED_MPS,
@@ -10,8 +10,6 @@ import {
CREEP_MOVE_MS,
CREEP_STOP_MS,
CREEP_BURST,
HEAT_JAM_BASE_ALPHA,
HEAT_JAM_PULSE_ALPHA,
} from './policy.js';
export function createAnimation({
@@ -20,13 +18,24 @@ export function createAnimation({
parts,
source,
}) {
/** Scratch point for the per-frame lerp, so a frame allocates nothing. */
const scratchLerp = new Cesium.Cartesian3();
/** The dots' point items, gathered once a frame for one upsert. */
const frameItems = [];
/**
* Send every dot's point item to the draw set: the set moves and
* restyles the points it has, and adds the new ones, in place.
*/
function flushDots() {
const dots = layerState._dots;
frameItems.length = dots.length;
for (let i = 0; i < dots.length; i++) frameItems[i] = dots[i].point;
layerState._dotSet?.upsert(frameItems);
}
function syncRenderDemand() {
const needed = Boolean(
layerState._enabled &&
(layerState._dots.length || layerState._heatJamPrim),
(layerState._dots.length || parts.rendering.heatPulsing?.()),
);
// Height easing only runs in a held frame. Settle it before releasing, so
// a population emptied mid-correction cannot report loading forever.
@@ -36,7 +45,7 @@ export function createAnimation({
if (needed) {
layerState._lastAnimTime = 0;
services.render.holdContinuousRender('traffic');
layerState._viewer?.scene?.requestRender?.();
findFrame(layerState._viewer)?.requestRender('traffic');
} else services.render.releaseContinuousRender('traffic');
}
@@ -78,18 +87,7 @@ export function createAnimation({
(bucket === 'jam' ? 1 : 0) +
parts.style.activeSizeDelta(bucket);
// Dark-halo outline under styled presets (null = shipped no-outline).
const outlineSpec =
bucket && layerState._presetDots === 'on'
? presetDotOutline(layerState._stylePreset, bucket)
: null;
const outlineColor = outlineSpec
? new Cesium.Color(
outlineSpec.rgba[0] / 255,
outlineSpec.rgba[1] / 255,
outlineSpec.rgba[2] / 255,
outlineSpec.rgba[3],
)
: null;
const outline = bucket ? parts.style.outlineOf(bucket) : null;
const flowSpeed = flow ? flowSpeedScale(flow.level) : 1;
const now = Date.now();
@@ -113,8 +111,9 @@ export function createAnimation({
}
}
const spawned = [];
for (let i = 0; i < count; i++) {
if (layerState._dots.length >= MAX_DOTS) return;
if (layerState._dots.length >= MAX_DOTS) break;
// Random start position: pick a random segment and offset within it —
// unless this is a queued jam dot with a platoon placement.
@@ -140,43 +139,44 @@ export function createAnimation({
? 1
: -1;
// Compute initial Cartesian3 position via linear interpolation
Cesium.Cartesian3.lerp(
road.waypoints[segIdx],
road.waypoints[segIdx + 1],
t,
scratchLerp,
);
// Grounded traffic respects building/terrain occlusion. The former
// depth override made distant roads look like vehicles crossing roofs.
const jamProminent = bucket === 'jam' && parts.style.jamDensityOn();
const id = layerState._nextDotId++;
const point = layerState._pointCollection.add({
position: Cesium.Cartesian3.clone(scratchLerp),
// The dot's point item, kept and changed in place: its draw id stays
// while the dot's vehicle identity (`id`) is renewed at each recycle.
const point = {
id: `dot:${id}`,
// Its initial position, by linear interpolation.
pos: lerpInto(road.waypoints[segIdx], road.waypoints[segIdx + 1], t, {
x: 0,
y: 0,
z: 0,
}),
pixelSize,
// No flow data → today's exact simulated white.
color: parts.style.dotColor(bucket),
scaleByDistance: new Cesium.NearFarScalar(
100,
1.5,
layerState._fadeScaleFar,
jamProminent ? JAM_DOT_FAR_SCALE : 0.3,
),
translucencyByDistance: new Cesium.NearFarScalar(
100,
1.0,
layerState._fadeTransFar,
0.0,
),
// Frozen, as the colours are: the draw port then tells them
// unchanged by identity when the dots move each frame.
scaleByDistance: Object.freeze({
near: 100,
nearValue: 1.5,
far: layerState._fadeScaleFar,
farValue: jamProminent ? JAM_DOT_FAR_SCALE : 0.3,
}),
fadeByDistance: Object.freeze({
near: 100,
nearValue: 1.0,
far: layerState._fadeTransFar,
farValue: 0.0,
}),
// Respect the sampled mesh at every viewing distance.
disableDepthTestDistance: 0,
// Preset dark halo (spread only when present — the keyless/normal
// path passes the exact shipped option set).
...(outlineSpec
? { outlineColor, outlineWidth: outlineSpec.width }
: {}),
});
disableDepthTest: 0,
// Preset dark halo (only when present — the keyless/normal path
// passes the shipped look).
...outline,
};
spawned.push(point);
layerState._bucketCounts[bucket || 'sim'] += 1;
layerState._motion.added++;
@@ -207,6 +207,8 @@ export function createAnimation({
: null,
});
}
// Drawn at once, as they join; each frame moves them on.
if (spawned.length) layerState._dotSet?.upsert(spawned);
syncRenderDemand();
}
@@ -307,23 +309,16 @@ export function createAnimation({
if (now < dot.stoppedUntil) break;
}
// Lerp between pre-computed Cartesian3 waypoints (no trig needed).
// Pass the scratch directly: PointPrimitive's position setter clones the
// value into its own storage (and skips the VBO dirty flag when equal), so
// the extra defensive clone here allocated 360–720k Cartesian3/s of pure
// garbage across 6000 dots. (perf item 5)
// Lerp between pre-computed ECEF waypoints (no trig needed), into the
// point item's own position: the draw set copies it.
const a = dot.waypoints[dot.segIdx];
const b = dot.waypoints[dot.segIdx + 1];
Cesium.Cartesian3.lerp(a, b, dot.t, scratchLerp);
dot.point.position = scratchLerp;
lerpInto(a, b, dot.t, dot.point.pos);
}
flushDots();
// Jam heat-lines throb (~1.6 s period) — one shared material uniform for
// the whole jam batch, no geometry rebuild. Null outside live heatline mode.
if (layerState._heatJamPrim?.appearance) {
layerState._heatJamPrim.appearance.material.uniforms.color.alpha =
HEAT_JAM_BASE_ALPHA + HEAT_JAM_PULSE_ALPHA * Math.sin(now / 260);
}
// Jam heat-lines throb (~1.6 s period); none outside live heatline mode.
parts.rendering.pulseHeatLines?.(now);
layerState._animFrame++;
}
@@ -354,7 +349,7 @@ export function createAnimation({
services.credits?.hideOsmCredit?.(layerState._viewer, 'traffic');
parts.retention.clear();
if (layerState._dots.length) layerState._motion.rebuilds++;
if (layerState._pointCollection) layerState._pointCollection.removeAll();
layerState._dotSet?.clear();
parts.rendering.removeHeatLines();
layerState._dots = [];
layerState._roads = [];
@@ -369,5 +364,6 @@ export function createAnimation({
maybeStopLight,
clearDots,
syncRenderDemand,
flushDots,
};
}
+2 -2
View File
@@ -208,7 +208,7 @@ export function createControls({ state: layerState, services, parts, source }) {
* @param {Object} [options]
* @param {number} [options.maxCount] - Maximum objects to return (defaults to all).
* @param {number} [options.seed] - Integer seed to offset the sampling start.
* @returns {Array<{position:Cesium.Cartesian3, id:string, type:string}>}
* @returns {Array<{position:{x:number, y:number, z:number}, id:string, type:string}>}
*/
getDetectableObjects(options = {}) {
if (!layerState._enabled || layerState._dots.length === 0) return [];
@@ -222,7 +222,7 @@ export function createControls({ state: layerState, services, parts, source }) {
const result = [];
for (let i = start; i < layerState._dots.length; i += stride) {
const pos = layerState._dots[i].point.position;
const pos = layerState._dots[i].point.pos;
if (!pos) continue;
const entry = {
position: pos,
+8 -12
View File
@@ -7,6 +7,7 @@ import { createRetention } from './retention.js';
import { createControls } from './controls.js';
import { createState } from './state.js';
import { bindRenderer } from '../../render/rendererOf.js';
import { surfaceViewer } from '../../testSupport/fakeSceneSurface.mjs';
const bounds = { west: 0, east: 0.01, south: 0, north: 0.01 };
const flush = async () => { for (let i = 0; i < 30; i++) await Promise.resolve(); };
@@ -212,20 +213,15 @@ function flowFixture(source) {
_enabled: true,
_roadMode: 'osm',
_parseRoads: (data) => data.roads,
_viewer: {
get canvas() {
return this.scene?.canvas;
},
scene: {
globe: {
show: true,
getHeight: () => {
calls.samples++;
return 100;
},
_viewer: surfaceViewer({
globe: {
show: true,
getHeight: () => {
calls.samples++;
return 100;
},
},
},
}),
});
const parts = {
viewport: {
-2
View File
@@ -479,7 +479,6 @@ export function createFlow({ state: layerState, services, parts, source }) {
let prepared = await viewerRoadSurface(layerState._viewer).prepare(
unresolved,
services.ground,
[layerState._pointCollection],
signal,
options,
);
@@ -500,7 +499,6 @@ export function createFlow({ state: layerState, services, parts, source }) {
prepared = await viewerRoadSurface(layerState._viewer).prepare(
prepared.pending,
services.ground,
[layerState._pointCollection],
signal,
options,
);
+4 -4
View File
@@ -273,10 +273,10 @@ export function createIngestion({
let estimated = services.ground?.cachedGroundFloor?.(centerLat, centerLon);
// A miss is the local mesh still loading.
if (!Number.isFinite(estimated))
estimated = viewerRoadSurface(layerState._viewer).loadedHeight(
{ lon: centerLon, lat: centerLat },
[layerState._pointCollection],
);
estimated = viewerRoadSurface(layerState._viewer).loadedHeight({
lon: centerLon,
lat: centerLat,
});
if (Number.isFinite(estimated) && Math.abs(estimated) <= 9000)
layerState._viewHeightEstimate = estimated;
+22 -21
View File
@@ -1,15 +1,19 @@
import { observeTrafficSurface } from './surface.js';
import * as Cesium from 'cesium';
// Still Cesium for its points and events, so this layer loads the unbound
// camera factory (with its query port) its other parts reach the renderer
// through.
// Still Cesium for its events, so this layer loads the unbound
// camera factory (with its query port) and globe factory its other parts
// reach the renderer through.
import '../../render/cesium/camera.js';
import '../../render/cesium/globe.js';
import { TRAFFIC_TIMING_ENABLED } from './policy.js';
import { drawOf } from '../../render/rendererOf.js';
import {
claimCameraSensitivity,
releaseCameraSensitivity,
} from '../../data/cameraSensitivity.js';
/** Numbers each layer instance's draw sets apart. */
let instances = 0;
export function createLifecycle({
state: layerState,
services,
@@ -20,20 +24,19 @@ export function createLifecycle({
const methods = {
/**
* One-time initialisation. Creates the PointPrimitiveCollection and adds it
* to the scene (hidden). The collection is never removed and re-added — only
* toggled via `.show` to avoid destroy-on-remove errors.
* One-time initialisation. Makes the dots' draw set (hidden); it is
* shown and hidden with the layer, and let go on destroy.
*
* @param {Cesium.Viewer} viewer - The Cesium viewer instance.
*/
init(viewer) {
layerState._viewer = viewer;
layerState._pointCollection = new Cesium.PointPrimitiveCollection({
blendOption: Cesium.BlendOption.TRANSLUCENT,
layerState._dotSet?.dispose();
layerState._dotSet = drawOf(viewer).points({
id: `traffic:${++instances}:dots`,
blend: 'translucent',
show: false,
});
// Add permanently — toggle with .show to avoid destroy-on-remove errors
viewer.scene.primitives.add(layerState._pointCollection);
layerState._pointCollection.show = false;
layerState._dots = [];
layerState._roads = [];
layerState._count = 0;
@@ -84,11 +87,11 @@ export function createLifecycle({
enable(viewer) {
if (layerState._enabled) return;
layerState._enabled = true;
layerState._surfaceFrameRemover = observeTrafficSurface(viewer.scene);
layerState._surfaceFrameRemover = observeTrafficSurface(viewer);
if (layerState._roadMode !== 'tomtom') source.prefetch?.();
parts.animation.syncRenderDemand();
layerState._lastAnimTime = 0;
layerState._pointCollection.show = true;
if (layerState._dotSet) layerState._dotSet.show = true;
layerState._preRenderRemover = viewer.scene.preRender.addEventListener(
parts.animation.animate,
@@ -187,21 +190,19 @@ export function createLifecycle({
layerState._arrivalRemover?.();
layerState._arrivalRemover = null;
releaseCameraSensitivity(viewer.camera, 'traffic');
if (layerState._pointCollection) layerState._pointCollection.show = false;
if (layerState._dotSet) layerState._dotSet.show = false;
},
/**
* Permanently tear down the layer. Disables it, removes the point collection
* from the scene, and clears the tile cache.
* Permanently tear down the layer. Disables it, lets the dots' draw set
* go, and clears the tile cache.
*
* @param {Cesium.Viewer} viewer - The Cesium viewer instance.
*/
destroy(viewer) {
this.disable(viewer);
if (layerState._pointCollection) {
viewer.scene.primitives.remove(layerState._pointCollection);
layerState._pointCollection = null;
}
layerState._dotSet?.dispose();
layerState._dotSet = null;
parts.rendering.removeHeatLines();
layerState._tileCache.clear();
resetFlowTileCache();
+21 -13
View File
@@ -7,6 +7,8 @@ import { createModel } from './model.js';
import { createAnimation } from './animation.js';
import { DOT_HEIGHT_OFFSET } from './policy.js';
import { bindRenderer } from '../../render/rendererOf.js';
import { fakeDrawPort } from '../../testSupport/fakeDrawPort.mjs';
import { surfaceViewer } from '../../testSupport/fakeSceneSurface.mjs';
import '../../render/cesium/camera.js';
import {
createRetention,
@@ -31,7 +33,7 @@ function setup(t) {
const state = createState({ services: {} });
state._enabled = true;
state._liveMode = true;
state._pointCollection = new C.PointPrimitiveCollection();
state._dotSet = fakeDrawPort().points({ id: 'traffic:test:dots' });
state._viewer = {
scene: {},
get canvas() {
@@ -92,7 +94,7 @@ function setup(t) {
};
t.after(() => {
parts.animation.clearDots();
state._pointCollection.destroy();
state._dotSet.dispose();
});
return { state, parts, roads, frame, settle, frames };
}
@@ -180,7 +182,7 @@ test('density and replacement changes are bounded; removed roads fade out and te
assert.equal(new Set(h.state._dots.map((d) => d.id)).size, 3000);
h.parts.animation.clearDots();
h.frame();
assert.equal(h.state._pointCollection.length, 0);
assert.equal(h.state._dotSet.size(), 0);
assert.equal(h.state._dots.length, 0);
assert.equal(h.frames.length, 0);
});
@@ -233,12 +235,12 @@ test('stopped vehicles still follow smooth height refinement without moving alon
h.settle();
const d = h.state._dots[0];
d.stoppedUntil = Date.now() + 100000;
const before = C.Cartographic.fromCartesian(d.point.position).height;
const before = C.Cartographic.fromCartesian(d.point.pos).height;
const progress = d.t;
h.parts.retention.reconcile(h.roads(0, 120), 450, true);
h.frame();
assert.equal(d.t, progress);
const after = C.Cartographic.fromCartesian(d.point.position).height;
const after = C.Cartographic.fromCartesian(d.point.pos).height;
assert.ok(after > before && after - before <= 2.01);
});
@@ -309,7 +311,7 @@ test('major previews merge and never retry missing mesh ahead of the detail pass
_dots: [],
_detailRoadsReady: true,
_motion: { added: 0 },
_viewer: { scene },
_viewer: surfaceViewer(scene),
_enabled: true,
_loadGeneration: 1,
_roadSource: 'OpenStreetMap',
@@ -444,7 +446,7 @@ test('measured preview heights select elevated detail roads before surface admis
};
const state = {
_dots: [],
_viewer: { scene },
_viewer: surfaceViewer(scene),
_enabled: true,
_loadGeneration: 1,
_roadSource: 'OpenStreetMap',
@@ -527,7 +529,7 @@ test('provisional opposite-direction heights cannot overwrite a measured sibling
};
const state = {
_dots: [],
_viewer: { scene },
_viewer: surfaceViewer(scene),
_enabled: true,
_loadGeneration: 1,
_roadSource: 'OpenStreetMap',
@@ -655,10 +657,10 @@ test('grounded vehicles respect mesh occlusion even after live congestion change
h.parts.retention.reconcile(roads, 450, true);
h.settle();
assert.ok(h.state._dots.length > 0);
assert.ok(h.state._dots.every((d) => d.point.disableDepthTestDistance === 0));
assert.ok(h.state._dots.every((d) => d.point.disableDepthTest === 0));
for (const road of roads) road.flow = { level: 0.01, closure: false };
h.parts.model.recolorDotsInPlace('late jam');
assert.ok(h.state._dots.every((d) => d.point.disableDepthTestDistance === 0));
assert.ok(h.state._dots.every((d) => d.point.disableDepthTest === 0));
});
test('retained road density follows the settled view without requiring a toggle', (t) => {
@@ -716,9 +718,9 @@ test('parsed roads carry plain ECEF waypoints that dots spawn on and move along'
h.settle();
assert.ok(h.state._dots.length > 0);
const dot = h.state._dots[0];
const before = C.Cartesian3.clone(dot.point.position);
const before = C.Cartesian3.clone(dot.point.pos);
h.frame(500);
const after = dot.point.position;
const after = dot.point.pos;
assert.ok(Number.isFinite(after.x) && Number.isFinite(after.z));
assert.ok(C.Cartesian3.distance(before, after) > 0, 'the dot moves');
});
@@ -757,7 +759,9 @@ test('selection asks the query port for depth and screen positions, and the came
camera: {
pose: () => (poses++, { position: { x: eye.x, y: eye.y, z: eye.z } }),
},
globe: { isGlobeVisible: () => true },
query: {
sampleHeightNow: () => 0,
pickPosition(x, y) {
picks.push([x, y]);
return C.Cartesian3.fromDegrees(0, 0, 400);
@@ -810,7 +814,11 @@ test('selection asks the query port for depth and screen positions, and the came
);
assert.deepEqual(picks[0], [500, 480], 'the depth probe below centre');
assert.equal(state._viewHeightEstimate, 400);
assert.equal(poses, 1, 'the eye is read once a pass');
assert.equal(
poses,
2,
'the eye is read once a pass, by selection and by the surface',
);
assert.ok(rendered.includes(near), 'an on-canvas road is admitted');
assert.ok(!rendered.includes(offCanvas), 'an off-canvas road is not');
assert.ok(!rendered.includes(outOfRange), 'nor one out of range');
+25 -13
View File
@@ -2,7 +2,10 @@ import test from 'node:test';
import assert from 'node:assert/strict';
import * as Cesium from 'cesium';
import { createTrafficLayer } from './index.js';
import { findCamera } from '../../render/rendererOf.js';
import { bindFakeCesiumCamera } from '../../testSupport/fakeCameraPort.mjs';
import { fakeDrawPort } from '../../testSupport/fakeDrawPort.mjs';
import { sceneSurfacePorts } from '../../testSupport/fakeSceneSurface.mjs';
function deferred() {
let resolve;
@@ -56,7 +59,15 @@ function setup(
},
};
// The layer reads the camera through its port.
bindFakeCesiumCamera(viewer, ports);
bindFakeCesiumCamera(viewer, {
...sceneSurfacePorts(viewer),
draw: fakeDrawPort(),
...ports,
});
// The fake camera has view matrices only where a test gives it some.
const cameraPort = findCamera(viewer);
const matrices = cameraPort.matrices.bind(cameraPort);
cameraPort.matrices = () => (camera.viewMatrix ? matrices() : undefined);
const layer = createTrafficLayer({
services: {
credits: {},
@@ -461,6 +472,7 @@ test('an unready surface waits for drawn frames through the frame port, then ref
listeners.add(cb);
return () => listeners.delete(cb);
},
requestRender() {},
};
const { layer, viewer, tick } = setup(
t,
@@ -468,41 +480,40 @@ test('an unready surface waits for drawn frames through the frame port, then ref
undefined,
{ frame },
);
// The rendered-frame observer records on the scene's own postRender.
// The rendered-frame observer records on the frame port too, from the
// camera's matrices.
viewer.camera.viewMatrix = Cesium.Matrix4.clone(Cesium.Matrix4.IDENTITY);
viewer.camera.frustum = {
projectionMatrix: Cesium.Matrix4.clone(Cesium.Matrix4.IDENTITY),
};
viewer.scene.camera = viewer.camera;
viewer.scene.postRender = new Cesium.Event();
const drawn = (n) => {
// The frame port's listeners run first, as the renderer registers its
// frame listener before any layer's.
for (const cb of [...listeners]) cb({ frame: n });
viewer.scene.postRender.raiseEvent();
};
let samples = 0;
viewer.scene.globe.getHeight = () => (samples++, 0);
viewer.scene.globe.tilesLoaded = false;
layer.enable(viewer);
// The observer, while the layer is enabled.
const observer = listeners.size;
assert.equal(observer, 1);
const waiting = () => listeners.size - observer;
await tick(400);
await tick(400);
assert.equal(listeners.size, 1, 'a drawn frame is awaited');
assert.equal(waiting(), 1, 'a drawn frame is awaited');
drawn(1);
await tick(400);
assert.equal(listeners.size, 1, 'still loading: keep waiting');
// The frame that finishes loading refines, though the rendered-frame
// observer has not yet recorded it as ready.
assert.equal(waiting(), 1, 'still loading: keep waiting');
// The frame that finishes loading refines.
viewer.scene.globe.tilesLoaded = true;
const before = samples;
drawn(2);
assert.equal(listeners.size, 0, 'a ready frame starts the refinement');
assert.equal(waiting(), 0, 'a ready frame starts the refinement');
await tick(400);
await tick(400);
assert.ok(samples > before, 'the refinement samples the surface again');
const after = samples;
await tick(5000);
assert.equal(listeners.size, 0, 'and refines only once');
assert.equal(waiting(), 0, 'and refines only once');
assert.equal(samples, after);
layer.disable(viewer);
await tick(5000);
@@ -516,6 +527,7 @@ test('disabling while a refinement waits drops its frame listener', async (t) =>
listeners.add(cb);
return () => listeners.delete(cb);
},
requestRender() {},
};
const { layer, viewer, tick } = setup(
t,
+1
View File
@@ -16,6 +16,7 @@ test('traffic render demand follows animated population and jam lines across emp
parts: {
retention: { clear() {} },
rendering: {
heatPulsing: () => Boolean(state._heatJamPrim),
removeHeatLines() {
state._heatJamPrim = null;
},
+95
View File
@@ -7,10 +7,88 @@ import {
HEAT_SLOW_COLOR,
HEAT_LINE_JAM_WIDTH,
HEAT_JAM_BASE_ALPHA,
HEAT_JAM_PULSE_ALPHA,
HEAT_LINE_SLOW_WIDTH,
TRAFFIC_TIMING_ENABLED,
} from './policy.js';
/**
* Whether the surface the dots sit on has loaded what is in view: the
* globe's tiles while it is shown, otherwise every shown 3D tileset (and
* there is one). The globe port's settle states cannot say whether any
* tileset is drawn at all, so this reads the scene.
* @param {object|undefined} viewer
*/
export function surfaceTilesReady(viewer) {
const scene = viewer?.scene;
if (!scene) return false;
if (scene.globe?.show) return scene.globe.tilesLoaded !== false;
let found = false;
for (let i = 0; i < (scene.primitives?.length || 0); i++) {
const primitive = scene.primitives.get(i);
if (!primitive.show || typeof primitive.tilesLoaded !== 'boolean') continue;
found = true;
if (!primitive.tilesLoaded) return false;
}
return found;
}
// Stable ids for the objects heights are sampled from (tilesets, terrain).
const surfaceIds = new WeakMap();
let nextSurfaceId = 1;
const surfaceId = (object) => {
if (!object || typeof object !== 'object') return 0;
if (!surfaceIds.has(object)) surfaceIds.set(object, nextSurfaceId++);
return surfaceIds.get(object);
};
/**
* Name what heights are sampled against: the terrain provider when the globe
* is shown, otherwise the set of visible 3D tilesets. A map-provider switch
* changes it and invalidates every cached height. The renderer contract
* names no surface identity, so this reads the scene.
* @param {object|undefined} viewer
*/
const surfaceKeys = new WeakMap();
export function trafficSurfaceKey(viewer) {
const scene = viewer?.scene;
if (!scene) return '';
let state = surfaceKeys.get(scene);
if (!state) {
state = { globe: null, terrain: null, tiles: [], key: '' };
surfaceKeys.set(scene, state);
}
const globe = Boolean(scene.globe?.show);
const terrain = globe ? scene.globe.terrainProvider : null;
let changed = state.globe !== globe || state.terrain !== terrain;
let count = 0;
if (!globe) {
for (let i = 0; i < (scene.primitives?.length || 0); i++) {
const primitive = scene.primitives.get(i);
if (!primitive?.show || typeof primitive.tilesLoaded !== 'boolean')
continue;
if (state.tiles[count] !== primitive) {
state.tiles[count] = primitive;
changed = true;
}
count++;
}
}
if (count !== state.tiles.length) {
state.tiles.length = count;
changed = true;
}
if (changed) {
state.globe = globe;
state.terrain = terrain;
// Allocate only when the actual map surface changes, never per frame.
state.key = globe
? `globe:${surfaceId(terrain)}`
: `tiles:${state.tiles.map(surfaceId).join(',')}`;
}
return state.key;
}
export function createRendering({
state: layerState,
services,
@@ -166,6 +244,21 @@ export function createRendering({
}
}
/** Whether jam heat-lines are drawn, which pulse every frame. */
const heatPulsing = () => Boolean(layerState._heatJamPrim);
/**
* Throb the jam heat-lines (~1.6 s period): one shared material uniform
* for the whole jam batch, no geometry rebuild.
* @param {number} now - Epoch ms.
*/
function pulseHeatLines(now) {
if (layerState._heatJamPrim?.appearance) {
layerState._heatJamPrim.appearance.material.uniforms.color.alpha =
HEAT_JAM_BASE_ALPHA + HEAT_JAM_PULSE_ALPHA * Math.sin(now / 260);
}
}
/**
* Reconcile road populations without respawning retained dots.
*
@@ -317,6 +410,8 @@ export function createRendering({
}
}
return {
heatPulsing,
pulseHeatLines,
visibleRoadsForAltitude,
removeHeatLines,
rebuildHeatLines,
+5 -2
View File
@@ -68,6 +68,8 @@ export function createRetention({ state, parts }) {
timer = null;
if (!state._enabled) return;
let budget = DOT_CHANGE_BUDGET;
// The dots that finished fading out, taken from the draw set at once.
const gone = [];
let pending = false;
const now = Date.now();
// Removing a road or reducing density fades only surplus dots. A retained
@@ -84,7 +86,7 @@ export function createRetention({ state, parts }) {
for (let i = record.dots.length - 1; i >= 0 && budget > 0; i--) {
const dot = record.dots[i];
if (!dot.retiring || now - dot.retiring < DOT_FADE_MS) continue;
state._pointCollection.remove(dot.point);
gone.push(dot.point.id);
const last = state._dots.pop();
if (last !== dot) {
state._dots[dot.index] = last;
@@ -127,6 +129,7 @@ export function createRetention({ state, parts }) {
if (!record.target && !record.dots.length)
records.delete(record.road.key);
}
if (gone.length) state._dotSet?.remove(gone);
refreshCounts();
state._populationPending = pending;
if (pending) schedule();
@@ -136,7 +139,7 @@ export function createRetention({ state, parts }) {
counts.free = counts.slow = counts.jam = counts.sim = 0;
let count = 0;
for (const dot of state._dots) {
if (!dot.point.show) continue;
if (dot.point.show === false) continue;
counts[dot.bucket || 'sim']++;
count++;
}
+2 -2
View File
@@ -17,9 +17,9 @@ export function createState({ services }) {
layerState._viewer = null;
/** @type {object|null} The dots' point collection. */
/** @type {object|null} The dots' draw set (points), made at init. */
layerState._pointCollection = null;
layerState._dotSet = null;
/** @type {Array<{point:object, waypoints:Array<{x:number, y:number, z:number}>, segmentDist:number[], numSegments:number, segIdx:number, t:number, mps:number, direction:number, stoppedUntil:number}>} Active animated dots */
+37 -42
View File
@@ -4,7 +4,6 @@ import {
presetDotRgba,
presetDotOutline,
} from '../../data/trafficPresetStyle.js';
import * as Cesium from 'cesium';
import {
SIZE_BY_TYPE,
STYLED_MIN_BASE_PX,
@@ -14,26 +13,9 @@ import {
} from './policy.js';
export function createStyle({ state: layerState, services, parts, source }) {
// The dots' renderer colours as the point primitives take them, one per
// colour, so painting a dot allocates nothing. Keyed by identity: the
// colours are frozen, and a preset change makes new ones.
const pointColors = new WeakMap();
/** A renderer colour (`[r, g, b, a]`) as a point primitive colour. */
function pointColor(rgba) {
let color = pointColors.get(rgba);
if (!color) {
color = new Cesium.Color(rgba[0], rgba[1], rgba[2], rgba[3]);
pointColors.set(rgba, color);
}
return color;
}
/** The point colour of a dot in `bucket` (null: simulated white). */
/** The colour of a dot in `bucket` (null: simulated white). */
function dotColor(bucket) {
return pointColor(
bucket ? layerState._activeBucketColors[bucket] : SIM_DOT_COLOR,
);
return bucket ? layerState._activeBucketColors[bucket] : SIM_DOT_COLOR;
}
/** Paint a dot's point in its bucket's colour, as a late flow update does. */
@@ -48,12 +30,36 @@ export function createStyle({ state: layerState, services, parts, source }) {
/** Keep a prominent jam dot larger at range. */
function emphasizeJamDot(dot) {
dot.point.scaleByDistance = new Cesium.NearFarScalar(
100,
1.5,
layerState._fadeScaleFar,
JAM_DOT_FAR_SCALE,
);
dot.point.scaleByDistance = Object.freeze({
near: 100,
nearValue: 1.5,
far: layerState._fadeScaleFar,
farValue: JAM_DOT_FAR_SCALE,
});
}
/**
* The preset's dark-halo outline for a coloured dot, as the point item's
* members, or null for the shipped no-outline state.
* @param {'free'|'slow'|'jam'|null} bucket - Flow bucket (null = sim).
* @returns {{outlineColor: number[], outlineWidth: number}|null}
*/
function outlineOf(bucket) {
const spec =
layerState._presetDots === 'on'
? presetDotOutline(layerState._stylePreset, bucket)
: null;
return spec
? {
outlineColor: Object.freeze([
spec.rgba[0] / 255,
spec.rgba[1] / 255,
spec.rgba[2] / 255,
spec.rgba[3],
]),
outlineWidth: spec.width,
}
: null;
}
/** @returns {boolean} A non-normal preset profile is active and enabled. */
@@ -111,26 +117,14 @@ export function createStyle({ state: layerState, services, parts, source }) {
* it back to the shipped no-outline state). NVG's auto-gain saturates the
* scene, so brightness alone cannot separate a dot from a bright road —
* the dark ring restores local contrast through every luma-mapping shader.
* @param {Cesium.PointPrimitive} point - The dot primitive.
* @param {object} point - The dot's point item.
* @param {'free'|'slow'|'jam'|null} bucket - Flow bucket (null = sim).
*/
function applyOutline(point, bucket) {
const spec =
layerState._presetDots === 'on'
? presetDotOutline(layerState._stylePreset, bucket)
: null;
if (spec) {
point.outlineColor = new Cesium.Color(
spec.rgba[0] / 255,
spec.rgba[1] / 255,
spec.rgba[2] / 255,
spec.rgba[3],
);
point.outlineWidth = spec.width;
} else {
point.outlineWidth = 0;
}
const outline = outlineOf(bucket);
if (outline) Object.assign(point, outline);
else point.outlineWidth = 0;
}
/**
@@ -187,6 +181,7 @@ export function createStyle({ state: layerState, services, parts, source }) {
}
return {
dotColor,
outlineOf,
paintDot,
showDot,
emphasizeJamDot,
+20 -14
View File
@@ -1,6 +1,6 @@
// src/layers/traffic/style.test.mjs — the traffic layer keeps its dot
// colours as renderer colours and paints them onto the points as the colours
// they always were.
// colours as renderer colours and paints them onto the points' items as the
// colours they always were.
import test from 'node:test';
import assert from 'node:assert/strict';
import * as Cesium from 'cesium';
@@ -13,6 +13,9 @@ import {
import { presetDotRgba } from '../../data/trafficPresetStyle.js';
import { createState } from './state.js';
/** A renderer colour (`[r, g, b, a]`) as Cesium draws it. */
const asColor = (rgba) => new Cesium.Color(...rgba);
function style(preset = 'normal') {
const state = createState({ services: {} });
state._stylePreset = preset;
@@ -32,11 +35,14 @@ test('bucket colours are the shipped palette, painted as before', () => {
};
for (const bucket of ['free', 'slow', 'jam'])
assert.ok(
Cesium.Color.equals(s.dotColor(bucket), expected[bucket]),
Cesium.Color.equals(asColor(s.dotColor(bucket)), expected[bucket]),
bucket,
);
assert.ok(
Cesium.Color.equals(s.dotColor(null), Cesium.Color.WHITE.withAlpha(0.85)),
Cesium.Color.equals(
asColor(s.dotColor(null)),
Cesium.Color.WHITE.withAlpha(0.85),
),
);
assert.deepEqual(SIM_DOT_COLOR, [1, 1, 1, 0.85]);
assert.equal(s.dotColor('jam'), s.dotColor('jam'), 'one colour per bucket');
@@ -51,12 +57,12 @@ test('a dot is painted, shown and emphasised on its point', () => {
s.showDot(dot, false);
assert.equal(dot.point.show, false);
s.emphasizeJamDot(dot);
assert.ok(
Cesium.NearFarScalar.equals(
dot.point.scaleByDistance,
new Cesium.NearFarScalar(100, 1.5, 9000, JAM_DOT_FAR_SCALE),
),
);
assert.deepEqual(dot.point.scaleByDistance, {
near: 100,
nearValue: 1.5,
far: 9000,
farValue: JAM_DOT_FAR_SCALE,
});
});
test('a styled preset recolours the buckets', () => {
@@ -67,7 +73,7 @@ test('a styled preset recolours the buckets', () => {
const [r, g, b, a] = presetDotRgba('surveillance', 'jam');
assert.ok(
Cesium.Color.equals(
s.dotColor('jam'),
asColor(s.dotColor('jam')),
new Cesium.Color(r / 255, g / 255, b / 255, a),
),
);
@@ -84,9 +90,9 @@ test('switching presets and back repaints dots with the shipped colours', () =>
state._dots = [dot];
const shipped = Cesium.Color.fromCssColorString('#2ecc71').withAlpha(0.9);
parts.style.setStylePreset('surveillance');
assert.ok(!Cesium.Color.equals(dot.point.color, shipped));
assert.ok(Cesium.Color.equals(dot.point.color, parts.style.dotColor('free')));
assert.ok(!Cesium.Color.equals(asColor(dot.point.color), shipped));
assert.equal(dot.point.color, parts.style.dotColor('free'));
parts.style.setStylePreset('normal');
assert.ok(Cesium.Color.equals(dot.point.color, shipped));
assert.ok(Cesium.Color.equals(asColor(dot.point.color), shipped));
assert.deepEqual(state._activeBucketColors.free, FLOW_BUCKET_COLORS.free);
});
+143 -194
View File
@@ -1,66 +1,76 @@
import { phaseTiming } from '../../sources/phaseTiming.js';
import * as Cesium from 'cesium';
import { DOT_HEIGHT_OFFSET, MAX_WAYPOINTS_PER_ROAD } from './policy.js';
import { heightsFor } from '../../render/cesium/heights.js';
import { heightsOf } from '../../queries/heights.js';
import { fromDegreesInto, toLonLatH } from '../../geo/ellipsoid.js';
import { distanceSquared } from '../../geo/vector.js';
import {
canvasOf,
findCamera,
findFrame,
findGlobe,
findQuery,
} from '../../render/rendererOf.js';
import { surfaceTilesReady, trafficSurfaceKey } from './rendering.js';
function surfaceTilesReady(scene) {
if (scene.globe?.show) return scene.globe.tilesLoaded !== false;
let found = false;
for (let i = 0; i < (scene.primitives?.length || 0); i++) {
const primitive = scene.primitives.get(i);
if (!primitive.show || typeof primitive.tilesLoaded !== 'boolean') continue;
found = true;
if (!primitive.tilesLoaded) return false;
}
return found;
export { trafficSurfaceKey };
/** Whether the globe surface is drawn (else tiles alone are). */
const globeShown = (viewer) => findGlobe(viewer)?.isGlobeVisible?.() === true;
/** The camera's view and projection now, when the renderer reports them. */
function cameraMatrices(viewer) {
const camera = findCamera(viewer);
return typeof camera?.matrices === 'function'
? (camera.matrices() ?? null)
: null;
}
const sameMatrix = (a, b) =>
a.length === b.length && a.every((value, i) => value === b[i]);
const renderedFrames = new WeakMap();
/** Observe completed frames only while an enabled traffic consumer owns them. */
export function observeTrafficSurface(scene) {
if (!scene.postRender?.addEventListener || !scene.camera?.viewMatrix)
return () => {};
let frame = renderedFrames.get(scene);
if (!frame) {
frame = {
view: new Cesium.Matrix4(),
projection: new Cesium.Matrix4(),
owners: 0,
};
renderedFrames.set(scene, frame);
frame.remove = scene.postRender.addEventListener(() => {
Cesium.Matrix4.clone(scene.camera.viewMatrix, frame.view);
Cesium.Matrix4.clone(
scene.camera.frustum.projectionMatrix,
frame.projection,
);
frame.surface = trafficSurfaceKey(scene);
frame.ready = surfaceTilesReady(scene);
export function observeTrafficSurface(viewer) {
const frame = findFrame(viewer);
if (!frame || !cameraMatrices(viewer)) return () => {};
let rendered = renderedFrames.get(viewer);
if (!rendered) {
rendered = { view: null, projection: null, owners: 0 };
renderedFrames.set(viewer, rendered);
rendered.remove = frame.on('postRender', () => {
const matrices = cameraMatrices(viewer);
rendered.view = matrices?.view ?? null;
rendered.projection = matrices?.projection ?? null;
rendered.surface = trafficSurfaceKey(viewer);
rendered.ready = surfaceTilesReady(viewer);
});
}
frame.owners++;
rendered.owners++;
let released = false;
return () => {
if (released) return;
released = true;
if (--frame.owners === 0) {
frame.remove();
renderedFrames.delete(scene);
if (--rendered.owners === 0) {
rendered.remove();
renderedFrames.delete(viewer);
}
};
}
function currentRenderedFrame(scene) {
if (!scene.postRender?.addEventListener || !scene.camera?.viewMatrix)
return { ready: surfaceTilesReady(scene) };
const frame = renderedFrames.get(scene);
return frame &&
frame.surface === trafficSurfaceKey(scene) &&
Cesium.Matrix4.equals(frame.view, scene.camera.viewMatrix) &&
Cesium.Matrix4.equals(
frame.projection,
scene.camera.frustum.projectionMatrix,
)
/**
* The completed frame drawn from the camera as it is now, of the surface
* drawn now; null when the camera has moved or the surface changed since.
* Without a frame port or camera matrices, the surface's readiness alone.
*/
function currentRenderedFrame(viewer) {
if (!findFrame(viewer)) return { ready: surfaceTilesReady(viewer) };
const matrices = cameraMatrices(viewer);
if (!matrices) return { ready: surfaceTilesReady(viewer) };
const frame = renderedFrames.get(viewer);
return frame?.view &&
frame.surface === trafficSurfaceKey(viewer) &&
sameMatrix(frame.view, matrices.view) &&
sameMatrix(frame.projection, matrices.projection)
? frame
: null;
}
@@ -71,28 +81,26 @@ function currentRenderedFrame(scene) {
* rendered-frame observer is recording for this same frame, which a frame
* listener may run before.
*/
export function drawnSurfaceReady(scene) {
return surfaceTilesReady(scene);
export function drawnSurfaceReady(viewer) {
return surfaceTilesReady(viewer);
}
/** Only a completed render of this camera can certify cached surface heights. */
export function trafficSurfaceReady(scene) {
return currentRenderedFrame(scene)?.ready === true;
export function trafficSurfaceReady(viewer) {
return currentRenderedFrame(viewer)?.ready === true;
}
/**
* The surface reads here over the scene `viewer` draws, for code that holds
* the viewer: the scene is read once, as this is called.
* The surface reads here over what `viewer` draws, through its renderer's
* ports.
* @param {object|undefined} viewer
*/
export function viewerRoadSurface(viewer) {
const scene = viewer?.scene;
return {
drawnReady: () => drawnSurfaceReady(scene),
ready: () => trafficSurfaceReady(scene),
prepare: (roads, ...rest) => prepareRoadSurfaces(roads, scene, ...rest),
loadedHeight: (location, exclude) =>
loadedSurfaceHeight(scene, location, exclude),
drawnReady: () => drawnSurfaceReady(viewer),
ready: () => trafficSurfaceReady(viewer),
prepare: (roads, ...rest) => prepareRoadSurfaces(roads, viewer, ...rest),
loadedHeight: (location) => loadedSurfaceHeight(viewer, location),
};
}
@@ -166,19 +174,19 @@ const validHeight = (height) =>
/**
* One loaded-surface height at a point, for the view-height estimate road
* selection starts from: terrain while the globe is shown, otherwise what is
* drawn (seeing through `exclude`, the layer's own dots) where the scene can
* sample it. Undefined when the scene cannot say.
* @param {object|undefined} scene
* drawn where the renderer can sample it (draw sets, the layer's own dots
* among them, are seen through). Undefined when it cannot say.
* @param {object|undefined} viewer
* @param {{lon: number, lat: number}} location Degrees.
* @param {object[]} exclude
* @returns {number|null|undefined}
*/
export function loadedSurfaceHeight(scene, location, exclude) {
if (!scene) return undefined;
return scene.globe?.show
? heightsFor(scene).now(location, { against: 'terrain' })
: scene.sampleHeightSupported
? heightsFor(scene).now(location, { exclude })
export function loadedSurfaceHeight(viewer, location) {
if (!viewer) return undefined;
const heights = heightsOf(viewer);
return globeShown(viewer)
? heights.now(location, { against: 'terrain' })
: heights.supported().surface
? heights.now(location)
: undefined;
}
@@ -186,106 +194,54 @@ export function loadedSurfaceHeight(scene, location, exclude) {
* Reuse the rendered depth buffer instead of drawing a new pick frustum per
* station. Iteration corrects the projection's height estimate. A depth hit
* is accepted only at this road coordinate (2 m), never on a foreground roof
* or hillside projected onto a different geographic point. Translucent traffic
* is absent from Cesium's default pickPosition depth pass.
* or hillside projected onto a different geographic point. The query port's
* depth pick answers against tiles and terrain, never the translucent dots.
* `rendered` is the completed frame of this camera, as `prepareRoadSurfaces`
* read it for its current slice.
*/
export function renderedRoadHeight(scene, lon, lat, estimate) {
if (
!scene.pickPositionSupported ||
scene.pickTranslucentDepth ||
!currentRenderedFrame(scene) ||
!scene.canvas?.clientWidth ||
!scene.frameState
)
return undefined;
export function renderedRoadHeight(
viewer,
lon,
lat,
estimate,
rendered = currentRenderedFrame(viewer),
) {
const query = findQuery(viewer);
const canvas = canvasOf(viewer);
if (!query || !rendered || !canvas?.clientWidth) return undefined;
let height = validHeight(estimate) ? estimate : 0;
const point = new Cesium.Cartesian3();
const screen = new Cesium.Cartesian2();
const point = { x: 0, y: 0, z: 0 };
for (let attempt = 0; attempt < 4; attempt++) {
Cesium.Cartesian3.fromDegrees(lon, lat, height, undefined, point);
fromDegreesInto(lon, lat, height, point);
const screen = query.project(point);
if (
!Cesium.SceneTransforms.worldToWindowCoordinates(scene, point, screen) ||
screen.x < 0 ||
screen.y < 0 ||
screen.x >= scene.canvas.clientWidth ||
screen.y >= scene.canvas.clientHeight
!screen ||
!(screen.x >= 0) ||
!(screen.y >= 0) ||
screen.x >= canvas.clientWidth ||
screen.y >= canvas.clientHeight
)
return undefined;
let hit;
try {
hit = scene.pickPosition(screen);
hit = query.pickPosition(screen.x, screen.y);
} catch {
return undefined;
}
if (!hit) return undefined;
const location = Cesium.Cartographic.fromCartesian(hit);
const location = toLonLatH(hit);
if (!location || !validHeight(location.height)) return undefined;
const dx =
(Cesium.Math.toDegrees(location.longitude) - lon) *
Math.cos((lat * Math.PI) / 180) *
111320;
const dy = (Cesium.Math.toDegrees(location.latitude) - lat) * 111320;
const dx = (location.lon - lon) * Math.cos((lat * Math.PI) / 180) * 111320;
const dy = (location.lat - lat) * 111320;
if (Math.hypot(dx, dy) <= 2) return location.height;
height = location.height;
}
return undefined;
}
// Per-scene, coordinate-keyed LRU. Never writes raw samples into shared ground floors.
// Per-viewer, coordinate-keyed LRU. Never writes raw samples into shared ground floors.
const sceneCaches = new WeakMap();
// Stable ids for the objects heights are sampled from (tilesets, terrain).
const surfaceIds = new WeakMap();
let nextSurfaceId = 1;
const surfaceId = (object) => {
if (!object || typeof object !== 'object') return 0;
if (!surfaceIds.has(object)) surfaceIds.set(object, nextSurfaceId++);
return surfaceIds.get(object);
};
/**
* Name what heights are sampled against: the terrain provider when the globe
* is shown, otherwise the set of visible 3D tilesets. A map-provider switch
* changes it and invalidates every cached height.
*/
const surfaceKeys = new WeakMap();
export function trafficSurfaceKey(scene) {
let state = surfaceKeys.get(scene);
if (!state) {
state = { globe: null, terrain: null, tiles: [], key: '' };
surfaceKeys.set(scene, state);
}
const globe = Boolean(scene.globe?.show);
const terrain = globe ? scene.globe.terrainProvider : null;
let changed = state.globe !== globe || state.terrain !== terrain;
let count = 0;
if (!globe) {
for (let i = 0; i < (scene.primitives?.length || 0); i++) {
const primitive = scene.primitives.get(i);
if (!primitive?.show || typeof primitive.tilesLoaded !== 'boolean')
continue;
if (state.tiles[count] !== primitive) {
state.tiles[count] = primitive;
changed = true;
}
count++;
}
}
if (count !== state.tiles.length) {
state.tiles.length = count;
changed = true;
}
if (changed) {
state.globe = globe;
state.terrain = terrain;
// Allocate only when the actual map surface changes, never per frame.
state.key = globe
? `globe:${surfaceId(terrain)}`
: `tiles:${state.tiles.map(surfaceId).join(',')}`;
}
return state.key;
}
/**
* Level-of-detail band for a point seen from the camera: log2 of the
* camera-to-point distance in 100 m steps. Streamed meshes refine roughly
@@ -309,29 +265,26 @@ const nextSlice = (hasSurface) =>
/** Prepare only admitted roads in bounded slices; locally missing surfaces defer that road. */
export async function prepareRoadSurfaces(
roads,
scene,
viewer,
ground,
excluded,
signal,
{ onReady, onMetrics, frameBudgetMs = 12, revalidate = false } = {},
) {
// Cached heights are only as good as the surface and detail they came
// from: a provider switch drops them all, and a point now seen from a
// closer band than its sample is re-sampled against the finer mesh.
const surface = trafficSurfaceKey(scene);
let cache = sceneCaches.get(scene);
const surface = trafficSurfaceKey(viewer);
let cache = sceneCaches.get(viewer);
if (!cache || cache.surface !== surface) {
cache = { surface, heights: new Map() };
sceneCaches.set(scene, cache);
sceneCaches.set(viewer, cache);
}
const cameraCarto = scene.camera?.positionCartographic;
const cameraLon = cameraCarto
? Cesium.Math.toDegrees(cameraCarto.longitude)
: 0;
const cameraLat = cameraCarto
? Cesium.Math.toDegrees(cameraCarto.latitude)
: 0;
const cameraHeight = cameraCarto ? cameraCarto.height : NaN;
const eye = findCamera(viewer)?.pose()?.position;
const cameraAt = eye ? toLonLatH(eye) : null;
const cameraLon = cameraAt ? cameraAt.lon : 0;
const cameraLat = cameraAt ? cameraAt.lat : 0;
const cameraHeight = cameraAt ? cameraAt.height : NaN;
const heights = heightsOf(viewer);
const start = performance.now();
const metrics = {
sampleCount: 0,
@@ -343,20 +296,28 @@ export async function prepareRoadSurfaces(
maxSliceMs: 0,
};
let sliceStart = performance.now();
const carto = new Cesium.Cartographic();
// What the view holds can only change between slices (no frame draws
// within one), so each slice reads it once.
let rendered, settled, globe;
const readView = () => {
rendered = currentRenderedFrame(viewer);
settled = rendered?.ready === true;
globe = globeShown(viewer);
};
readView();
const location = { lon: 0, lat: 0 };
const ready = [],
pending = [];
for (const road of roads) {
let resolved = true;
let settledRoad = true;
const { indices, distances } = roadHeightStations(road.coords);
const heights = new Array(road.coords.length);
const stationHeights = new Array(road.coords.length);
for (const i of indices) {
signal?.throwIfAborted();
const [lon, lat] = road.coords[i];
const key = `${lon.toFixed(6)},${lat.toFixed(6)}`;
const cached = cache.heights.get(key);
const settled = trafficSurfaceReady(scene);
const band = detailBand(cameraLon, cameraLat, cameraHeight, lon, lat);
let height =
cached &&
@@ -372,37 +333,25 @@ export async function prepareRoadSurfaces(
cache.heights.set(key, cached);
} else {
if (!settled) settledRoad = false;
carto.longitude = Cesium.Math.toRadians(lon);
carto.latitude = Cesium.Math.toRadians(lat);
carto.height = 0;
location.lon = lon;
location.lat = lat;
const floor = ground?.cachedGroundFloor?.(lat, lon);
let sampled;
// sampleHeight reads the locally rendered mesh, not unresolved/offscreen
// tiles. Global tilesLoaded can stay false while this street is usable.
if (scene.globe?.show)
sampled = heightsFor(scene).now(carto, { against: 'terrain' });
// A height now reads the locally rendered mesh, not unresolved or
// offscreen tiles. Global readiness can stay false while this street
// is usable.
if (globe) sampled = heights.now(location, { against: 'terrain' });
else {
const estimate = Cesium.Cartographic.fromCartesian(
road.waypoints[i],
)?.height;
sampled = renderedRoadHeight(scene, lon, lat, estimate);
const estimate = toLonLatH(road.waypoints[i])?.height;
sampled = renderedRoadHeight(viewer, lon, lat, estimate, rendered);
if (validHeight(sampled)) metrics.depthHits++;
}
if (
!scene.globe?.show &&
!validHeight(sampled) &&
scene.sampleHeightSupported
) {
if (!globe && !validHeight(sampled) && heights.supported().surface) {
const sampleStart = performance.now();
metrics.sampleCount++;
const shown = (excluded || []).filter((p) => p?.show);
for (const primitive of shown) primitive.show = false;
try {
// A miss is the local mesh still missing.
sampled = heightsFor(scene).now(carto, { exclude: excluded });
} finally {
for (const primitive of shown) primitive.show = true;
}
// A miss is the local mesh still missing. Draw sets, the dots
// among them, are seen through.
sampled = heights.now(location);
metrics.sampleMs += performance.now() - sampleStart;
}
// A shared floor is a safe provisional waypoint, but not permission to
@@ -428,13 +377,14 @@ export async function prepareRoadSurfaces(
cache.heights.delete(cache.heights.keys().next().value);
}
}
heights[i] = height;
stationHeights[i] = height;
const elapsed = performance.now() - sliceStart;
if (elapsed >= frameBudgetMs) {
metrics.maxSliceMs = Math.max(metrics.maxSliceMs, elapsed);
// Before the first local mesh exists, give its tile/worker tasks the
// normal queue priority instead of repeatedly probing an empty scene.
await nextSlice(metrics.cacheHits + metrics.depthHits > 0);
readView();
sliceStart = performance.now();
}
}
@@ -445,22 +395,21 @@ export async function prepareRoadSurfaces(
b = indices[station];
const span = distances[b] - distances[a];
const t = span > 0 ? (distances[i] - distances[a]) / span : 0;
const height = heights[a] + (heights[b] - heights[a]) * t;
const height =
stationHeights[a] + (stationHeights[b] - stationHeights[a]) * t;
const [lon, lat] = road.coords[i];
const floor = ground?.cachedGroundFloor?.(lat, lon);
Cesium.Cartesian3.fromDegrees(
fromDegreesInto(
lon,
lat,
(validHeight(floor) ? Math.max(height, floor) : height) +
DOT_HEIGHT_OFFSET,
undefined,
road.waypoints[i],
);
}
for (let i = 0; i < road.segmentDist.length; i++)
road.segmentDist[i] = Cesium.Cartesian3.distance(
road.waypoints[i],
road.waypoints[i + 1],
road.segmentDist[i] = Math.sqrt(
distanceSquared(road.waypoints[i], road.waypoints[i + 1]),
);
road.surfaceReady = resolved;
road.surfaceSettled = settledRoad;
+64 -56
View File
@@ -1,6 +1,7 @@
import test from 'node:test';
import assert from 'node:assert/strict';
import * as C from 'cesium';
import { surfaceViewer } from '../../testSupport/fakeSceneSurface.mjs';
import {
detailBand,
loadedSurfaceHeight,
@@ -64,12 +65,13 @@ test('per-vertex mesh heights follow terrain, reject invalid samples, and leave
sampleHeightSupported: true,
sampleHeight: () => heights[samples++],
};
const viewer = surfaceViewer(scene);
const ground = {
cachedGroundFloor: () => 50,
reportMeshFloorCell: () => assert.fail('raw sample poisoned shared floor'),
};
let metrics;
const prepared = await prepareRoadSurfaces([r], scene, ground, [], null, {
const prepared = await prepareRoadSurfaces([r], viewer, ground, null, {
onMetrics: (value) => (metrics = value),
});
assert.equal(metrics.sampleCount, 5);
@@ -80,9 +82,9 @@ test('per-vertex mesh heights follow terrain, reject invalid samples, and leave
);
assert.deepEqual(actual, [103, 203, 53, 53, 53]);
tileset.tilesLoaded = false;
assert.equal(trafficSurfaceReady(scene), false);
assert.equal(trafficSurfaceReady(viewer), false);
scene.sampleHeight = () => 75;
const resumed = await prepareRoadSurfaces([r], scene, ground, []);
const resumed = await prepareRoadSurfaces([r], viewer, ground);
assert.equal(
resumed.ready.length,
1,
@@ -93,14 +95,13 @@ test('per-vertex mesh heights follow terrain, reject invalid samples, and leave
picks++;
return 75;
};
await prepareRoadSurfaces([r], scene, ground, []);
await prepareRoadSurfaces([r], viewer, ground);
assert.equal(picks, 0, 'validated coordinate heights survive cache hits');
const abort = new AbortController();
abort.abort();
await assert.rejects(
prepareRoadSurfaces([r], scene, ground, [], abort.signal),
{ name: 'AbortError' },
);
await assert.rejects(prepareRoadSurfaces([r], viewer, ground, abort.signal), {
name: 'AbortError',
});
});
test('visible-globe roads floor each vertex without mesh picks', async () => {
const r = road([
@@ -110,12 +111,12 @@ test('visible-globe roads floor each vertex without mesh picks', async () => {
let calls = 0;
await prepareRoadSurfaces(
[r],
{
surfaceViewer({
globe: { show: true, tilesLoaded: true, getHeight: () => ++calls * 100 },
sampleHeightSupported: true,
sampleHeight: () => assert.fail('mesh sampled'),
},
}),
{ cachedGroundFloor: () => 20 },
[],
);
assert.equal(calls, 2);
assert.deepEqual(
@@ -142,26 +143,27 @@ test('cached heights follow detail and provider; same-detail revisits sample not
sampleHeight: () => (samples++, mesh),
camera: camera(3000),
};
const viewer = surfaceViewer(scene);
const heightAt = () =>
Math.round(C.Cartographic.fromCartesian(r.waypoints[0]).height);
// Settled but coarse: sampled from 3 km.
await prepareRoadSurfaces([r], scene, null, []);
await prepareRoadSurfaces([r], viewer, null);
assert.equal(samples, 2);
assert.equal(heightAt(), 43);
// Same detail band on a revisit: zero samples.
await prepareRoadSurfaces([r], scene, null, []);
await prepareRoadSurfaces([r], viewer, null);
assert.equal(samples, 2);
// Zooming out never re-samples a finer height either.
scene.camera = camera(6000);
await prepareRoadSurfaces([r], scene, null, []);
await prepareRoadSurfaces([r], viewer, null);
assert.equal(samples, 2);
// Closer view, finer mesh: re-sampled and the waypoint follows it.
mesh = 47;
scene.camera = camera(250);
await prepareRoadSurfaces([r], scene, null, []);
await prepareRoadSurfaces([r], viewer, null);
assert.equal(samples, 4);
assert.equal(heightAt(), 50);
await prepareRoadSurfaces([r], scene, null, []);
await prepareRoadSurfaces([r], viewer, null);
assert.equal(samples, 4, 'the finer sample is now the cached one');
// A different photoreal tileset (map provider switch) invalidates all,
// even from a coarser view that would otherwise reuse the finer sample.
@@ -169,13 +171,13 @@ test('cached heights follow detail and provider; same-detail revisits sample not
scene.primitives.get = () => other;
scene.camera = camera(3000);
mesh = 30;
await prepareRoadSurfaces([r], scene, null, []);
await prepareRoadSurfaces([r], viewer, null);
assert.equal(samples, 6);
assert.equal(heightAt(), 33);
// A finer sample that fails keeps the coarser measured height.
scene.camera = camera(250);
mesh = NaN;
const kept = await prepareRoadSurfaces([r], scene, null, []);
const kept = await prepareRoadSurfaces([r], viewer, null);
assert.equal(samples, 8);
assert.equal(kept.ready.length, 1);
assert.equal(heightAt(), 33);
@@ -204,13 +206,14 @@ test('a camera jump cannot certify old rendered depth or cache coarse heights as
sampleHeightSupported: true,
sampleHeight: () => (samples++, height),
};
assert.equal(trafficSurfaceReady(scene), false);
const removeSurfaceObserver = observeTrafficSurface(scene);
const viewer = surfaceViewer(scene);
assert.equal(trafficSurfaceReady(viewer), false);
const removeSurfaceObserver = observeTrafficSurface(viewer);
scene.postRender.raiseEvent();
assert.equal(trafficSurfaceReady(scene), true);
assert.equal(trafficSurfaceReady(viewer), true);
scene.camera.viewMatrix[12] = 100;
assert.equal(
trafficSurfaceReady(scene),
trafficSurfaceReady(viewer),
false,
'old camera readiness is stale',
);
@@ -218,18 +221,18 @@ test('a camera jump cannot certify old rendered depth or cache coarse heights as
[0, 0],
[0.001, 0],
]);
await prepareRoadSurfaces([r], scene, null, []);
await prepareRoadSurfaces([r], viewer, null);
assert.equal(r.surfaceSettled, false);
height = 80;
scene.postRender.raiseEvent();
await prepareRoadSurfaces([r], scene, null, []);
await prepareRoadSurfaces([r], viewer, null);
assert.equal(samples, 4, 'the first fresh render revalidates coarse heights');
assert.equal(r.surfaceSettled, true);
assert.ok(
Math.abs(C.Cartographic.fromCartesian(r.waypoints[0]).height - 83) < 0.01,
);
height = 100;
await prepareRoadSurfaces([r, r], scene, null, [], null, {
await prepareRoadSurfaces([r, r], viewer, null, null, {
revalidate: true,
});
assert.equal(
@@ -241,9 +244,9 @@ test('a camera jump cannot certify old rendered depth or cache coarse heights as
assert.ok(
Math.abs(C.Cartographic.fromCartesian(r.waypoints[0]).height - 103) < 0.01,
);
await prepareRoadSurfaces([r], scene, null, []);
await prepareRoadSurfaces([r], viewer, null);
assert.equal(samples, 6, 'ordinary same-band revisits still reuse the cache');
await prepareRoadSurfaces([r], scene, null, [], null, { revalidate: true });
await prepareRoadSurfaces([r], viewer, null, null, { revalidate: true });
assert.equal(
samples,
6,
@@ -264,7 +267,7 @@ test('height stations preserve bends while bounding sample spacing along the roa
let picks = 0;
await prepareRoadSurfaces(
[r],
{
surfaceViewer({
globe: {
show: true,
tilesLoaded: true,
@@ -273,9 +276,8 @@ test('height stations preserve bends while bounding sample spacing along the roa
return C.Math.toDegrees(c.longitude) * 1000;
},
},
},
}),
null,
[],
);
assert.equal(picks, indices.length);
for (let i = 0; i < coords.length; i++) {
@@ -306,7 +308,8 @@ test('rendered road depth is geographically checked, bounded, and avoids mesh re
sampleHeight: () =>
assert.fail('valid depth must not draw another pick frustum'),
};
assert.ok(Math.abs(renderedRoadHeight(scene, -97, 30, 0) - 100) < 0.001);
const viewer = surfaceViewer(scene);
assert.ok(Math.abs(renderedRoadHeight(viewer, -97, 30, 0) - 100) < 0.001);
const r = road([
[-97, 30],
[-97, 30.000005],
@@ -314,7 +317,7 @@ test('rendered road depth is geographically checked, bounded, and avoids mesh re
r.waypoints = r.coords.map(([lon, lat]) =>
C.Cartesian3.fromDegrees(lon, lat, 50),
);
const result = await prepareRoadSurfaces([r], scene, null, []);
const result = await prepareRoadSurfaces([r], viewer, null);
assert.equal(result.metrics.depthHits, 2);
assert.equal(result.metrics.sampleCount, 0);
let calls = 0;
@@ -323,19 +326,24 @@ test('rendered road depth is geographically checked, bounded, and avoids mesh re
return C.Cartesian3.fromDegrees(-97.001, 30, 150);
};
assert.equal(
renderedRoadHeight(scene, -97, 30, 0),
renderedRoadHeight(viewer, -97, 30, 0),
undefined,
'foreground roof is not the road coordinate',
);
assert.equal(calls, 4);
scene.pickPosition = () => C.Cartesian3.fromDegrees(-97, 30, 10000);
assert.equal(renderedRoadHeight(scene, -97, 30, 0), undefined);
assert.equal(renderedRoadHeight(viewer, -97, 30, 0), undefined);
scene.pickPosition = () => {
throw new Error('depth unavailable');
};
assert.equal(renderedRoadHeight(scene, -97, 30, 0), undefined);
scene.pickTranslucentDepth = true;
assert.equal(renderedRoadHeight(scene, -97, 30, 0), undefined);
assert.equal(renderedRoadHeight(viewer, -97, 30, 0), undefined);
scene.pickPositionSupported = false;
scene.pickPosition = () => C.Cartesian3.fromDegrees(-97, 30, 100);
assert.equal(
renderedRoadHeight(viewer, -97, 30, 0),
undefined,
'no depth pick, no depth height',
);
});
test('surface keys reuse identity without building arrays or strings on unchanged frames', (t) => {
@@ -357,8 +365,9 @@ test('surface keys reuse identity without building arrays or strings on unchange
},
postRender: new C.Event(),
};
const first = trafficSurfaceKey(scene);
const remove = observeTrafficSurface(scene);
const viewer = surfaceViewer(scene);
const first = trafficSurfaceKey(viewer);
const remove = observeTrafficSurface(viewer);
const originalMap = Array.prototype.map;
const originalJoin = Array.prototype.join;
let maps = 0,
@@ -374,7 +383,7 @@ test('surface keys reuse identity without building arrays or strings on unchange
try {
for (let i = 0; i < 1000; i++) {
scene.postRender.raiseEvent();
assert.equal(trafficSurfaceKey(scene), first);
assert.equal(trafficSurfaceKey(viewer), first);
}
} finally {
Array.prototype.map = originalMap;
@@ -383,23 +392,23 @@ test('surface keys reuse identity without building arrays or strings on unchange
assert.equal(maps, 0);
assert.equal(joins, 0);
tiles[1].show = false;
const hidden = trafficSurfaceKey(scene);
const hidden = trafficSurfaceKey(viewer);
assert.notEqual(hidden, first);
tiles[1] = { show: true, tilesLoaded: true };
assert.notEqual(
trafficSurfaceKey(scene),
trafficSurfaceKey(viewer),
first,
'same-count tileset replacement is a new surface',
);
scene.globe.show = true;
const terrain = trafficSurfaceKey(scene);
const terrain = trafficSurfaceKey(viewer);
scene.globe.terrainProvider = {};
assert.notEqual(trafficSurfaceKey(scene), terrain);
assert.notEqual(trafficSurfaceKey(viewer), terrain);
remove();
remove();
assert.equal(scene.postRender.numberOfListeners, 0);
assert.equal(
trafficSurfaceReady(scene),
trafficSurfaceReady(viewer),
false,
'readiness cannot recreate a subscription',
);
@@ -407,26 +416,25 @@ test('surface keys reuse identity without building arrays or strings on unchange
test('the view-height estimate reads terrain under a shown globe, else the drawn surface past the dots', () => {
const at = { lon: -97.7431, lat: 30.2672 };
const dots = {};
const seen = [];
const terrain = {
const terrain = surfaceViewer({
globe: { show: true, getHeight: (carto) => (seen.push(carto), 151) },
// A shown globe wins even where the scene could sample what is drawn.
sampleHeightSupported: true,
sampleHeight: () => assert.fail('terrain, not the drawn surface'),
};
assert.equal(loadedSurfaceHeight(terrain, at, [dots]), 151);
});
assert.equal(loadedSurfaceHeight(terrain, at), 151);
assert.ok(Math.abs(C.Math.toDegrees(seen[0].longitude) - at.lon) < 1e-12);
const tiles = {
// The query port sees through draw sets (the dots among them) itself.
const tiles = surfaceViewer({
globe: { show: false },
sampleHeightSupported: true,
sampleHeight: (_carto, exclude) => (seen.push(exclude), 188),
};
assert.equal(loadedSurfaceHeight(tiles, at, [dots]), 188);
assert.deepEqual(seen[1], [dots], 'sees through the layer dots');
sampleHeight: () => 188,
});
assert.equal(loadedSurfaceHeight(tiles, at), 188);
assert.equal(
loadedSurfaceHeight({ globe: { show: false } }, at, [dots]),
loadedSurfaceHeight(surfaceViewer({ globe: { show: false } }), at),
undefined,
);
assert.equal(loadedSurfaceHeight(undefined, at, [dots]), undefined);
assert.equal(loadedSurfaceHeight(undefined, at), undefined);
});
+73 -14
View File
@@ -1049,8 +1049,31 @@ export function createCesiumDraw({
'displayRange',
];
/**
* What a point's look keeps of an item member: a frozen value of plain
* members (a frozen colour or curve) as it is, since it cannot change and
* is then told unchanged by identity; anything else as a `plainCopy`.
*/
function lookCopy(value) {
if (!value || typeof value !== 'object' || !Object.isFrozen(value))
return plainCopy(value);
// Only plain data cannot change: no getters, nothing inherited.
const proto = Object.getPrototypeOf(value);
if (proto !== Object.prototype && proto !== Array.prototype)
return plainCopy(value);
for (const key of Reflect.ownKeys(value)) {
const member = Object.getOwnPropertyDescriptor(value, key);
if (
!('value' in member) ||
(member.value !== null && typeof member.value === 'object')
)
return plainCopy(value);
}
return value;
}
/** A copy of the item members a point's look is drawn from. */
const pointLookOf = (item) => LOOK_FROM.map((key) => plainCopy(item[key]));
const pointLookOf = (item) => LOOK_FROM.map((key) => lookCopy(item[key]));
/**
* Whether `value` holds what `kept` (a `plainCopy` of a colour, curve or
@@ -1067,6 +1090,13 @@ export function createCesiumDraw({
)
return false;
if (Array.isArray(kept) !== Array.isArray(value)) return false;
if (Array.isArray(value)) {
// Colours, read by index: a `for...in` over an array is far slower.
if (kept.length !== value.length) return false;
for (let i = 0; i < value.length; i++)
if (!Object.is(kept[i], value[i])) return false;
return true;
}
let count = 0;
for (const key in value) {
if (value[key] === undefined) continue;
@@ -1083,28 +1113,57 @@ export function createCesiumDraw({
const value = item[LOOK_FROM[i]];
if (sameLookValue(was.look[i], value)) continue;
was.primitive[LOOK[i][0]] = LOOK[i][1](item);
was.look[i] = plainCopy(value);
was.look[i] = lookCopy(value);
}
}
const PLACE_KEYS = ['x', 'y', 'z', 'lon', 'lat', 'height'];
/**
* Where an item is, as its values when drawn: a caller may change the
* position object it passes and send the same one again.
*/
const placeOf = (item) =>
PLACE_KEYS.map((key) => item.pos?.[key]).concat(item.height);
const placeOf = (item) => {
const pos = item.pos;
return [
pos?.x,
pos?.y,
pos?.z,
pos?.lon,
pos?.lat,
pos?.height,
item.height,
];
};
/** Whether an item is somewhere else than `at`; if so, `at` takes it. */
/**
* Whether an item is somewhere else than `at`; if so, `at` takes it. Read
* member by member, by name: points moved every frame are compared every
* frame.
*/
function movedFrom(at, item) {
let moved = !Object.is(item.height, at[PLACE_KEYS.length]);
for (let i = 0; !moved && i < PLACE_KEYS.length; i++)
moved = !Object.is(item.pos?.[PLACE_KEYS[i]], at[i]);
if (!moved) return false;
for (let i = 0; i < PLACE_KEYS.length; i++)
at[i] = item.pos?.[PLACE_KEYS[i]];
at[PLACE_KEYS.length] = item.height;
const pos = item.pos;
const x = pos?.x;
const y = pos?.y;
const z = pos?.z;
const lon = pos?.lon;
const lat = pos?.lat;
const height = pos?.height;
if (
Object.is(x, at[0]) &&
Object.is(y, at[1]) &&
Object.is(z, at[2]) &&
Object.is(lon, at[3]) &&
Object.is(lat, at[4]) &&
Object.is(height, at[5]) &&
Object.is(item.height, at[6])
)
return false;
at[0] = x;
at[1] = y;
at[2] = z;
at[3] = lon;
at[4] = lat;
at[5] = height;
at[6] = item.height;
return true;
}
+150
View File
@@ -912,6 +912,127 @@ test('the bikeshare layer draws its stations as point primitives on a viewer of
assert.equal(scene.added.length, 0);
});
test('the traffic layer draws its dots as one point collection moved, added to and taken from in place on a viewer of its own', async (t) => {
const { createState } = await import('../../layers/traffic/state.js');
const { createStyle } = await import('../../layers/traffic/style.js');
const { createModel } = await import('../../layers/traffic/model.js');
const { createAnimation } = await import('../../layers/traffic/animation.js');
const { JAM_DOT_FAR_SCALE } = await import('../../layers/traffic/policy.js');
let now = 10000;
t.mock.method(Date, 'now', () => now);
const { scene, draw } = drawOver();
const state = createState({ services: {} });
state._enabled = true;
state._fadeScaleFar = 8000;
state._fadeTransFar = 10000;
state._dotSet = draw.points({ id: 'traffic:1:dots', blend: 'translucent' });
const parts = {
rendering: { removeHeatLines() {}, rebuildHeatLines() {} },
retention: { easeHeights() {}, finishHeights() {}, clear() {} },
};
const context = {
state,
services: {
render: { holdContinuousRender() {}, releaseContinuousRender() {} },
},
parts,
source: {},
};
parts.style = createStyle(context);
parts.model = createModel(context);
parts.animation = createAnimation(context);
parts.style.refreshBucketColors();
const [road] = parts.model.parseRoads({
roads: [
{
type: 'primary',
oneway: 1,
coordinates: [
[-97.74, 30.26],
[-97.737, 30.26],
],
},
],
});
parts.animation.spawnDotsForRoad(road, 450, 3);
const host = scene.added[0];
assert.ok(host instanceof Cesium.PointPrimitiveCollection);
assert.equal(host.blendOption, Cesium.BlendOption.TRANSLUCENT);
assert.equal(host.length, 3, 'drawn as they join');
const point = host.get(0);
assert.equal(point.id.set, 'traffic:1:dots');
assert.ok(
Cesium.Color.equals(point.color, Cesium.Color.WHITE.withAlpha(0.85)),
'the simulated white',
);
assert.equal(point.disableDepthTestDistance, 0);
const before = Cesium.Cartesian3.clone(point.position);
now += 500;
parts.animation.animate();
assert.equal(scene.added[0], host, 'moved where it is');
assert.equal(host.get(0), point);
assert.ok(!Cesium.Cartesian3.equals(point.position, before), 'it moves');
assert.ok(
Cesium.NearFarScalar.equals(
point.scaleByDistance,
new Cesium.NearFarScalar(100, 1.5, 8000, 0.3),
),
);
assert.ok(
Cesium.NearFarScalar.equals(
point.translucencyByDistance,
new Cesium.NearFarScalar(100, 1, 10000, 0),
),
);
// What the style part changes on a dot reaches its point at the next
// frame, on the point it has.
const dot = state._dots[0];
parts.style.paintDot(dot, 'jam');
parts.style.emphasizeJamDot(dot);
dot.point.outlineColor = Object.freeze([0, 0, 0, 0.5]);
dot.point.outlineWidth = 2;
now += 16;
parts.animation.animate();
assert.equal(host.get(0), point);
assert.ok(
Cesium.Color.equals(
point.color,
new Cesium.Color(...state._activeBucketColors.jam),
),
'painted',
);
assert.ok(
Cesium.NearFarScalar.equals(
point.scaleByDistance,
new Cesium.NearFarScalar(100, 1.5, 8000, JAM_DOT_FAR_SCALE),
),
'emphasised',
);
assert.ok(
Cesium.Color.equals(point.outlineColor, new Cesium.Color(0, 0, 0, 0.5)),
);
assert.equal(point.outlineWidth, 2);
parts.style.showDot(dot, false);
now += 16;
parts.animation.animate();
assert.equal(point.show, false, 'hidden');
parts.style.showDot(dot, true);
now += 16;
parts.animation.animate();
assert.equal(point.show, true);
parts.animation.spawnDotsForRoad(road, 450, 2);
assert.equal(scene.added[0], host, 'joined where it is');
assert.equal(host.length, 5);
// A dot that has faded out leaves the collection where it is, as the
// retention part takes it.
state._dotSet.remove([state._dots[0].point.id]);
assert.equal(scene.added[0], host);
assert.equal(state._dotSet.size(), 4);
parts.animation.clearDots();
state._dotSet.dispose();
assert.equal(scene.added.length, 0);
});
test('a rebuilt set keeps its place among the scene primitives, and names its host', async () => {
const {
registerSpriteSet,
@@ -1186,6 +1307,35 @@ test('a point moved in place sets only the members of its look that changed', ()
item.color[1] = 1;
set.upsert([item]);
assert.deepEqual(written, ['color', 'scaleByDistance', 'color']);
// A frozen colour or curve is kept as it is, and told unchanged by
// identity; an equal one sent anew still sets nothing.
item.color = Object.freeze([0, 0, 1, 1]);
set.upsert([item]);
set.upsert([item]);
item.color = Object.freeze([0, 0, 1, 1]);
set.upsert([item]);
assert.deepEqual(written, ['color', 'scaleByDistance', 'color', 'color']);
// A frozen curve read through a getter can change, so it is copied and
// compared by value.
let farValue = 0.3;
item.scaleByDistance = Object.freeze(
Object.defineProperties(
{},
{
near: { value: 100, enumerable: true },
nearValue: { value: 1.5, enumerable: true },
far: { value: 12000, enumerable: true },
farValue: { get: () => farValue, enumerable: true },
},
),
);
set.upsert([item]);
const writes = written.length;
set.upsert([item]);
assert.equal(written.length, writes, 'unchanged');
farValue = 0.8;
set.upsert([item]);
assert.equal(written.at(-1), 'scaleByDistance', 'the change is seen');
set.dispose();
});
-3
View File
@@ -28,11 +28,8 @@
"src/layers/radio/rendering.js",
"src/layers/recentImagery/rendering.js",
"src/layers/satellites/rendering.js",
"src/layers/traffic/animation.js",
"src/layers/traffic/lifecycle.js",
"src/layers/traffic/rendering.js",
"src/layers/traffic/style.js",
"src/layers/traffic/surface.js",
"src/layers/transit/rendering.js",
"src/layers/weather/shellRendering.js",
"src/layers/wind/gpuRendering.js",
+116
View File
@@ -0,0 +1,116 @@
/**
* Renderer ports over a scene double, for tests of code that reads the
* surface through the query, globe, camera and frame ports: they answer
* from the double's Cesium-shaped members, read when asked, so a test that
* changes its scene is seen.
*
* - query: `sampleHeightNow` (terrain from `globe.getHeight`, else the
* scene's `sampleHeight` where `sampleHeightSupported`), `project`
* (`SceneTransforms.worldToWindowCoordinates`, which a test may mock),
* `pickPosition` (the scene's), and null for every other pick.
* - globe: `isGlobeVisible` from `globe.show`.
* - camera (`withCamera`): `pose().position` from `camera.positionCartographic`,
* `matrices()` from `camera.viewMatrix` and `frustum.projectionMatrix`
* (undefined without them).
* - frame: `on('postRender')` on the scene's `postRender`, when it has one.
* - capabilities: `sampleHeight` while the scene is `sampleHeightSupported`.
*/
import * as Cesium from 'cesium';
import { bindRenderer } from '../render/rendererOf.js';
import { fakeDrawPort } from './fakeDrawPort.mjs';
const carto = ({ lon, lat }) => Cesium.Cartographic.fromDegrees(lon, lat);
const ecef = (p) => (p ? { x: p.x, y: p.y, z: p.z } : null);
/** The surface ports over `viewer.scene`. */
export function sceneSurfacePorts(viewer, { withCamera = false } = {}) {
const scene = () => viewer.scene ?? {};
const query = {
sampleHeightNow(point, { against } = {}) {
const s = scene();
if (against === 'terrain')
return s.globe?.getHeight?.(carto(point)) ?? null;
return s.sampleHeightSupported
? (s.sampleHeight?.(carto(point)) ?? null)
: null;
},
project(position) {
const at = Cesium.SceneTransforms.worldToWindowCoordinates(
scene(),
new Cesium.Cartesian3(position.x, position.y, position.z),
new Cesium.Cartesian2(),
);
return at ? { x: at.x, y: at.y } : null;
},
pickPosition(x, y) {
const s = scene();
if (!s.pickPositionSupported) return null;
return ecef(s.pickPosition?.(new Cesium.Cartesian2(x, y)));
},
pickEllipsoid: () => null,
pickRay: () => null,
pick: () => null,
drillPick: () => [],
isOccluded: () => false,
};
const ports = {
query,
globe: { isGlobeVisible: () => Boolean(scene().globe?.show) },
frame: {
on(phase, cb) {
const event = phase === 'postRender' ? scene().postRender : null;
return event?.addEventListener?.(cb) ?? (() => {});
},
requestRender() {},
},
get capabilities() {
return new Set(scene().sampleHeightSupported ? ['sampleHeight'] : []);
},
get canvas() {
return scene().canvas;
},
};
if (withCamera)
ports.camera = {
pose() {
const c = scene().camera?.positionCartographic;
return {
position: c
? ecef(
Cesium.Cartesian3.fromRadians(
c.longitude,
c.latitude,
c.height,
),
)
: null,
};
},
matrices() {
const camera = scene().camera;
if (!camera?.viewMatrix || !camera.frustum?.projectionMatrix)
return undefined;
return {
view: Float64Array.from(Cesium.Matrix4.toArray(camera.viewMatrix)),
projection: Float64Array.from(
Cesium.Matrix4.toArray(camera.frustum.projectionMatrix),
),
};
},
};
return ports;
}
/**
* A viewer over `scene` bound to the surface ports, its camera and a fake
* draw port.
* @returns {{scene: object}}
*/
export function surfaceViewer(scene) {
const viewer = { scene };
bindRenderer(viewer, {
...sceneSurfacePorts(viewer, { withCamera: true }),
draw: fakeDrawPort(),
});
return viewer;
}