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
+42
-8
@@ -1130,6 +1130,24 @@ controller throws naming it. Whether the aircraft it flies still draws comes
|
||||
from its `trackedEntityDrawn` service (the application asks the viewer's
|
||||
entities); without one, Cockpit takes the aircraft as drawn.
|
||||
|
||||
## Rendered-mesh floor cells — November 8, 2026
|
||||
|
||||
On the photoreal stack the shared floor (`cachedGroundFloor`) answers from a
|
||||
rendered-mesh reading per coarse cell (0.001°, about 110 × 80 m), sampled by
|
||||
`src/services/meshFloorSampler.js` and gated against the DEM by
|
||||
`reportValidatedMeshFloorCell` in `src/services/groundFloor.js`. The probe goes
|
||||
where the caller's point is (a vehicle or contact), not to the cell's centre;
|
||||
a cell is read up to eight times, at points about 17 m or more apart, and each
|
||||
reading that passes the gate is kept at its point. A read answers from the
|
||||
cell's reading nearest the asked point, so a viaduct and the street beside it
|
||||
in one cell keep their own heights; two readings within about 5 m of each other
|
||||
keep the lower. Before this, one probe at the cell's centre latched for the
|
||||
session, so a centre on a roof lifted everything in the cell (a Haymarket bus
|
||||
drew 23.5 m above the street, on the garage roof) and a centre in the river put
|
||||
Red Line trains on the Longfellow Bridge 6–9 m under the deck. Residual: the
|
||||
probe is vertical, so a vehicle directly under a deck or a roof overhang reads
|
||||
the structure above it.
|
||||
|
||||
## Vessel components and sources
|
||||
|
||||
`src/data/aisLiveVessels.js` assembles `createVesselLayer` from the
|
||||
@@ -2542,7 +2560,7 @@ This is the current runtime/source-of-truth snapshot for the project.
|
||||
> `HELD_SNAP_CONTRADICTION_M` (5 m) ABOVE the held value drops the hold and the
|
||||
> contact is COLD again, back to the floored 2D billboard. The rule is
|
||||
> ONE-SIDED on purpose — it targets BURIAL. A cell reading BELOW a real sample
|
||||
> is the floor chain's expected under-read (one-shot latch over ~111 m,
|
||||
> is the floor chain's expected under-read (a few point readings over ~111 m,
|
||||
> neighbours lean lowest, `displayFloorHeightM` only ever raises), not evidence
|
||||
> of anything, and a two-sided cut was disproved on the track rig by a planted
|
||||
> cell 66.7 m below a real sample at the same spot. Accepted residual, stated
|
||||
@@ -4632,12 +4650,27 @@ synchronizes visible playback before its next frame.
|
||||
Playback reserves numeric scratch before the first sample, including unknown
|
||||
heights, and reuses caller-owned sample and segment storage.
|
||||
|
||||
**Scene work.** Stationary and animated billboards use separate, adjacent
|
||||
collections above CCTV and Bikeshare. Transit listens to the camera port at its
|
||||
own `changed` threshold (0.05); the port measures each listener separately, so no
|
||||
layer changes another's camera trigger.
|
||||
Visibility checks combine the camera frustum and ellipsoid occlusion at no more
|
||||
than 4 Hz; missing map bounds do not admit the globe's far side. Camera arrivals
|
||||
**Scene work.** Stationary and animated vehicles are two draw-port icon sets
|
||||
(`transit:<n>:still` and `transit:<n>:moving`), registered by set id with the
|
||||
sprite order in their old adjacent places above CCTV and Bikeshare. Each marker
|
||||
is a plain record (position, show, image, size, colour, rotation); a frame
|
||||
writes the changed ones to their set in one batched upsert, markers taken out
|
||||
in one task go in one removal, and a marker that starts or stops moving moves
|
||||
between the sets. The renderer moves and turns an icon without restyling it.
|
||||
Rotation is computed in screen space through the query port's projection
|
||||
(`perspectiveCourseRotation`), as before. Clicks read the draw-port hit. The
|
||||
layer no longer reaches Cesium, so a caller handing it a Cesium viewer,
|
||||
their own, with no renderer bound, loads the `./render/cesium/unbound` export
|
||||
once first. Transit listens to the camera port at its own `changed` threshold
|
||||
(0.05); the port measures each listener separately, so no layer changes
|
||||
another's camera trigger.
|
||||
Visibility checks combine the camera port's frustum and the query port's
|
||||
ellipsoid occlusion at no more than 4 Hz; missing map bounds do not admit the
|
||||
globe's far side. Whether the globe is the bare ellipsoid is asked of the
|
||||
height service at the camera's subpoint each time the globe's surface
|
||||
changes; the answer comes asynchronously, the last one holds until then, and
|
||||
floors are read again when it flips.
|
||||
Camera arrivals
|
||||
rebuild an unprepared or cold marker corridor during that visibility sweep,
|
||||
adopt a loaded surface, and update both heightPending and surfaceReady diagnostics.
|
||||
A resolved display sample clears its pending-height gate without waiting for a poll. Frame work
|
||||
@@ -4668,7 +4701,8 @@ it does not establish Google 3D acceptance.
|
||||
The full run samples completed frames at 1920×1080 CSS pixels, records DPR, and
|
||||
measures moving fleets of 800 and 3,000 vehicles with 128 fixes each and DETECT
|
||||
on. Street/metro targets are respectively: transit frame CPU p95 ≤1/4 ms, frame
|
||||
interval p95 ≤20/25 ms, billboard uploads ≤256 KiB/1 MiB per frame, and retained
|
||||
interval p95 ≤20/25 ms, billboard uploads ≤256 KiB/1 MiB per frame (counted by
|
||||
`src/render/cesium/uploadProbe.js` for the two marker sets), and retained
|
||||
heap growth ≤24/48 MiB. The 3,000-vehicle CPU budget is 4 ms (recorded browser
|
||||
measurement 3.4 ms); the 800-vehicle budget stays at 1 ms (measured 0.9 ms).
|
||||
Transit-authored frame allocation is ≤8 KiB/frame at both fleets, attributed
|
||||
|
||||
@@ -65,6 +65,8 @@
|
||||
"src/render/motion/iconBook.test.mjs",
|
||||
"src/render/camera/poseSignature.test.mjs",
|
||||
"src/render/cesium/internals.test.mjs",
|
||||
"src/render/cesium/uploadProbe.js",
|
||||
"src/render/cesium/uploadProbe.test.mjs",
|
||||
"src/render/cesium/tileRequests.js",
|
||||
"src/render/cesium/tileRequests.test.mjs",
|
||||
"src/queries/heights.test.mjs",
|
||||
|
||||
@@ -5748,6 +5748,7 @@
|
||||
"src/layers/transit/qaMetrics.js",
|
||||
"src/layers/transit/queries.js",
|
||||
"src/layers/transit/rendering.js",
|
||||
"src/geo/frustum.js",
|
||||
"src/render/cesium/iconOrientation.js",
|
||||
"src/layers/transit/selection.js",
|
||||
"src/layers/transit/state.js",
|
||||
@@ -5821,6 +5822,7 @@
|
||||
"src/layers/transit/policy.js",
|
||||
"src/layers/transit/queries.js",
|
||||
"src/layers/transit/rendering.js",
|
||||
"src/geo/frustum.js",
|
||||
"src/render/cesium/iconOrientation.js",
|
||||
"src/layers/transit/selection.js",
|
||||
"src/geo/index.js",
|
||||
|
||||
@@ -177,6 +177,19 @@ export async function sampleTransitPixels(page, palette) {
|
||||
];
|
||||
const width = canvas.clientWidth;
|
||||
const height = canvas.clientHeight;
|
||||
// The billboards the draw port drew for the layer's two sets, by
|
||||
// vehicle key, with the collection drawing each.
|
||||
const drawn = new Map();
|
||||
const setIds = layer._transitSetIdsForTest();
|
||||
for (let i = 0; i < scene.primitives.length; i++) {
|
||||
const host = scene.primitives.get(i);
|
||||
if (!setIds.includes(host?.drawSetId)) continue;
|
||||
for (let j = 0; j < host.length; j++) {
|
||||
const billboard = host.get(j);
|
||||
if (typeof billboard?.id?.id === 'string')
|
||||
drawn.set(billboard.id.id, { billboard, host });
|
||||
}
|
||||
}
|
||||
const sprites = [];
|
||||
const footprints = [];
|
||||
const intersects = (a, b) =>
|
||||
@@ -256,20 +269,26 @@ export async function sampleTransitPixels(page, palette) {
|
||||
};
|
||||
for (const entry of state._vehicles.values()) {
|
||||
if (!entry.marker || entry.marker.show === false) continue;
|
||||
const p = entry.marker.position;
|
||||
const row = drawn.get(entry.key);
|
||||
if (!row || row.billboard.show === false) {
|
||||
skipped.push({ key: entry.key, reason: 'billboard not drawn' });
|
||||
continue;
|
||||
}
|
||||
const billboard = row.billboard;
|
||||
const p = billboard.position;
|
||||
const clip = mul(proj, mul(view, [p.x, p.y, p.z, 1]));
|
||||
if (!(clip[3] > 0)) continue;
|
||||
const screen = entry.marker.computeScreenSpacePosition?.(scene) || {
|
||||
const screen = billboard.computeScreenSpacePosition?.(scene) || {
|
||||
x: ((clip[0] / clip[3]) * 0.5 + 0.5) * width,
|
||||
y: (1 - ((clip[1] / clip[3]) * 0.5 + 0.5)) * height,
|
||||
};
|
||||
const rect = entry.marker.constructor.getScreenSpaceBoundingBox?.(
|
||||
entry.marker,
|
||||
const rect = billboard.constructor.getScreenSpaceBoundingBox?.(
|
||||
billboard,
|
||||
screen,
|
||||
) || { x: screen.x - 16, y: screen.y - 16, width: 32, height: 32 };
|
||||
const { x, y } = screenPoint(screen.x, screen.y);
|
||||
const c = Math.abs(Math.cos(entry.marker.rotation || 0)),
|
||||
sn = Math.abs(Math.sin(entry.marker.rotation || 0));
|
||||
const c = Math.abs(Math.cos(billboard.rotation || 0)),
|
||||
sn = Math.abs(Math.sin(billboard.rotation || 0));
|
||||
const w = rect.width * c + rect.height * sn,
|
||||
h = rect.height * c + rect.width * sn;
|
||||
const footprint = { x: x - w / 2, y: y - h / 2, w, h };
|
||||
@@ -282,10 +301,7 @@ export async function sampleTransitPixels(page, palette) {
|
||||
rect.y + rect.height > height
|
||||
)
|
||||
reason = 'billboard rectangle outside frame';
|
||||
if (
|
||||
entry.marker.color?.alpha < 0.95 ||
|
||||
entry.markerCollection?.show === false
|
||||
)
|
||||
if (billboard.color?.alpha < 0.95 || row.host.show === false)
|
||||
reason = 'billboard not opaque/collection hidden';
|
||||
const raster = rasters.get(entry.marker.image);
|
||||
if (!raster) reason = 'billboard alpha unavailable';
|
||||
@@ -351,12 +367,12 @@ export async function sampleTransitPixels(page, palette) {
|
||||
bracketX: entry.detectContact?._candidateScreenX ?? screen.x,
|
||||
bracketY: entry.detectContact?._candidateScreenY ?? screen.y,
|
||||
raster,
|
||||
rotation: entry.marker.rotation || 0,
|
||||
halfW: Number.isFinite(entry.marker.width)
|
||||
? Math.ceil(entry.marker.width / 2) + 2
|
||||
rotation: billboard.rotation || 0,
|
||||
halfW: Number.isFinite(billboard.width)
|
||||
? Math.ceil(billboard.width / 2) + 2
|
||||
: 11,
|
||||
halfH: Number.isFinite(entry.marker.height)
|
||||
? Math.ceil(entry.marker.height / 2) + 2
|
||||
halfH: Number.isFinite(billboard.height)
|
||||
? Math.ceil(billboard.height / 2) + 2
|
||||
: 7,
|
||||
});
|
||||
}
|
||||
@@ -658,12 +674,23 @@ export function readTransitFleetStyle({ key, resetSelection = false } = {}) {
|
||||
const entry = key
|
||||
? state._vehicles.get(key)
|
||||
: [...state._vehicles.values()].find((e) => e.marker?.show);
|
||||
return entry
|
||||
// The billboard the draw port drew for it, in either of the layer's sets.
|
||||
const scene = window.__godsEyeView.viewer.scene;
|
||||
const setIds = layer._transitSetIdsForTest();
|
||||
let billboard = null;
|
||||
for (let i = 0; entry && !billboard && i < scene.primitives.length; i++) {
|
||||
const host = scene.primitives.get(i);
|
||||
if (!setIds.includes(host?.drawSetId)) continue;
|
||||
for (let j = 0; j < host.length; j++)
|
||||
if (host.get(j)?.id?.id === entry.key) billboard = host.get(j);
|
||||
}
|
||||
// An undrawn marker has no style to compare: no answer.
|
||||
return entry && billboard
|
||||
? {
|
||||
key: entry.key,
|
||||
selected: state._selectedKey === entry.key,
|
||||
color: entry.marker.color.toCssColorString(),
|
||||
width: entry.marker.width,
|
||||
color: billboard.color.toCssColorString(),
|
||||
width: billboard.width,
|
||||
image: entry.marker.image,
|
||||
}
|
||||
: null;
|
||||
|
||||
@@ -182,7 +182,8 @@ try {
|
||||
});
|
||||
parts.rendering.sampleIdle(entry);
|
||||
parts.rendering.schedulePlayback(entry);
|
||||
const V = entry.marker.position.constructor;
|
||||
// Marker positions are plain records; the camera's eye is a Cartesian3.
|
||||
const V = scene.camera.positionWC.constructor;
|
||||
const points = entry.trailSegments
|
||||
.filter((s) => s.toT <= entry.sample.displayT)
|
||||
.flatMap((s) => s.positions);
|
||||
|
||||
@@ -146,11 +146,7 @@ export async function runFleetBudgets({
|
||||
// The retained delta is conservative: it includes concurrent page growth.
|
||||
const retained = await cdp.send('Runtime.getHeapUsage');
|
||||
// Timing/upload acceptance runs without the allocation profiler attached.
|
||||
const trace = await page.evaluate(() =>
|
||||
window.__godsEyeView.dataManager.layers
|
||||
.get('transit')
|
||||
.module._measureTransitFramesForTest(8000),
|
||||
);
|
||||
const trace = await page.evaluate(measureTransitFrames, 8000);
|
||||
await page.evaluate(() =>
|
||||
window.__godsEyeView.dataManager.layers
|
||||
.get('transit')
|
||||
@@ -166,11 +162,7 @@ export async function runFleetBudgets({
|
||||
page,
|
||||
`${count} budget visibility before allocation trace`,
|
||||
);
|
||||
const allocationTrace = await page.evaluate(() =>
|
||||
window.__godsEyeView.dataManager.layers
|
||||
.get('transit')
|
||||
.module._measureTransitFramesForTest(6000),
|
||||
);
|
||||
const allocationTrace = await page.evaluate(measureTransitFrames, 6000);
|
||||
const { profile } = await cdp.send('HeapProfiler.stopSampling');
|
||||
const allocations = allocationTotals(profile);
|
||||
const retainedBytes = retained.usedSize - before.usedSize;
|
||||
@@ -361,13 +353,23 @@ export async function runBostonMatrix({
|
||||
const modes = await page.evaluate(() => {
|
||||
const layer =
|
||||
window.__godsEyeView.dataManager.layers.get('transit').module;
|
||||
// The billboards the draw port drew for the markers, by key.
|
||||
const scene = window.__godsEyeView.viewer.scene;
|
||||
const setIds = layer._transitSetIdsForTest();
|
||||
const drawn = new Map();
|
||||
for (let i = 0; i < scene.primitives.length; i++) {
|
||||
const host = scene.primitives.get(i);
|
||||
if (!setIds.includes(host?.drawSetId)) continue;
|
||||
for (let j = 0; j < host.length; j++)
|
||||
drawn.set(host.get(j)?.id?.id, host.get(j));
|
||||
}
|
||||
return [...layer._transitStateForTest()._vehicles.values()].map(
|
||||
(e) => ({
|
||||
key: e.key,
|
||||
route: e.record.routeId,
|
||||
image: e.marker.image,
|
||||
width: e.marker.width,
|
||||
color: e.marker.color.toCssHexString(),
|
||||
width: drawn.get(e.key)?.width ?? null,
|
||||
color: drawn.get(e.key)?.color.toCssHexString() ?? null,
|
||||
}),
|
||||
);
|
||||
});
|
||||
@@ -418,15 +420,27 @@ export async function runBostonMatrix({
|
||||
window.__godsEyeView.dataManager.layers.get('transit').module;
|
||||
layer._transitPartsForTest().selection.clearSelection();
|
||||
const e = layer._transitStateForTest()._vehicles.get(key);
|
||||
// The billboard the draw port drew for it.
|
||||
const scene = window.__godsEyeView.viewer.scene;
|
||||
const setIds = layer._transitSetIdsForTest();
|
||||
let drawn = null;
|
||||
for (let i = 0; !drawn && i < scene.primitives.length; i++) {
|
||||
const host = scene.primitives.get(i);
|
||||
if (!setIds.includes(host?.drawSetId)) continue;
|
||||
for (let j = 0; j < host.length; j++)
|
||||
if (host.get(j)?.id?.id === key) drawn = host.get(j);
|
||||
}
|
||||
return {
|
||||
drawn: Boolean(drawn),
|
||||
image: e.marker.image,
|
||||
width: e.marker.width,
|
||||
color: e.marker.color.toCssHexString(),
|
||||
width: drawn?.width ?? null,
|
||||
color: drawn?.color.toCssHexString() ?? null,
|
||||
};
|
||||
}, target.key);
|
||||
check(
|
||||
`Boston ${background.name}/${look.name}/${target.route}: deselect restores fleet styling`,
|
||||
restored.image === target.image &&
|
||||
restored.drawn &&
|
||||
restored.image === target.image &&
|
||||
restored.width === target.width &&
|
||||
restored.color === target.color,
|
||||
);
|
||||
@@ -884,7 +898,18 @@ export async function runTrailVisibility({
|
||||
if (points.length < 2)
|
||||
return { ...setup, present: 0, reason: 'no completed path' };
|
||||
const C = scene.camera.positionCartographic.constructor;
|
||||
const V = entry.marker.position.constructor;
|
||||
// Marker positions are plain records; the camera's eye is a Cartesian3.
|
||||
const V = scene.camera.positionWC.constructor;
|
||||
// The billboard the draw port drew for the marker, seen through.
|
||||
const setIds = layer._transitSetIdsForTest();
|
||||
const markerBillboards = [];
|
||||
for (let i = 0; i < scene.primitives.length; i++) {
|
||||
const host = scene.primitives.get(i);
|
||||
if (!setIds.includes(host?.drawSetId)) continue;
|
||||
for (let j = 0; j < host.length; j++)
|
||||
if (host.get(j)?.id?.id === entry.key)
|
||||
markerBillboards.push(host.get(j));
|
||||
}
|
||||
const lengths = [0];
|
||||
for (let i = 1; i < points.length; i++)
|
||||
lengths.push(lengths.at(-1) + V.distance(points[i - 1], points[i]));
|
||||
@@ -905,7 +930,7 @@ export async function runTrailVisibility({
|
||||
);
|
||||
const cart = C.fromCartesian(p);
|
||||
const height = scene.sampleHeight(cart, [
|
||||
entry.marker,
|
||||
...markerBillboards,
|
||||
...partsOf(trail.body),
|
||||
...partsOf(trail.headLines),
|
||||
]);
|
||||
@@ -1077,3 +1102,24 @@ export async function runTrailVisibility({
|
||||
.selection.clearSelection(),
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* The transit frame probe over the bytes the renderer uploads for the
|
||||
* layer's marker sets (the Cesium renderer's upload probe), in the page.
|
||||
* @param {number} durationMs
|
||||
*/
|
||||
async function measureTransitFrames(durationMs) {
|
||||
const { countDrawSetUploads } =
|
||||
await import('/src/render/cesium/uploadProbe.js');
|
||||
const app = window.__godsEyeView;
|
||||
const layer = app.dataManager.layers.get('transit').module;
|
||||
const uploads = countDrawSetUploads(
|
||||
app.viewer,
|
||||
layer._transitSetIdsForTest(),
|
||||
);
|
||||
try {
|
||||
return await layer._measureTransitFramesForTest(durationMs, uploads);
|
||||
} finally {
|
||||
uploads.stop();
|
||||
}
|
||||
}
|
||||
+48
-20
@@ -98,7 +98,7 @@ const renderingSource = await readFile(
|
||||
);
|
||||
const frameSource = renderingSource
|
||||
.split('function onPreRender()')[1]
|
||||
.split('const occluder')[0];
|
||||
.split('const candidatePosition')[0];
|
||||
check(
|
||||
'frame pass does not scan the fleet or copy the moving set',
|
||||
!/_vehicles\.values|\[\.\.\.state\._moving\]/.test(frameSource),
|
||||
@@ -815,25 +815,38 @@ try {
|
||||
const layer =
|
||||
window.__godsEyeView.dataManager.layers.get('transit').module;
|
||||
const state = layer._transitStateForTest();
|
||||
const entry = state._vehicles.get(key);
|
||||
const scene = window.__godsEyeView.viewer.scene;
|
||||
// The billboard the draw port drew for it, and the set drawing it.
|
||||
const setIds = layer._transitSetIdsForTest();
|
||||
let billboard = null,
|
||||
setId = null;
|
||||
for (let i = 0; !billboard && i < scene.primitives.length; i++) {
|
||||
const host = scene.primitives.get(i);
|
||||
if (!setIds.includes(host?.drawSetId)) continue;
|
||||
for (let j = 0; j < host.length; j++)
|
||||
if (host.get(j)?.id?.id === key) {
|
||||
billboard = host.get(j);
|
||||
setId = host.drawSetId;
|
||||
}
|
||||
}
|
||||
const set = layer._transitPartsForTest().rendering.setNameOf(setId);
|
||||
return {
|
||||
selected: state._selectedKey === key,
|
||||
color: entry?.marker.color.toCssColorString(),
|
||||
width: entry?.marker.width,
|
||||
color: billboard?.color.toCssColorString(),
|
||||
width: billboard?.width,
|
||||
pickOwner: (() => {
|
||||
const p = window.__godsEyeView.viewer.scene.pick(
|
||||
entry.marker.computeScreenSpacePosition(
|
||||
window.__godsEyeView.viewer.scene,
|
||||
),
|
||||
);
|
||||
const p = billboard
|
||||
? scene.pick(billboard.computeScreenSpacePosition(scene))
|
||||
: null;
|
||||
return {
|
||||
id: typeof p?.id === 'string' ? p.id : null,
|
||||
primitiveId:
|
||||
typeof p?.primitive?.id === 'string' ? p.primitive.id : null,
|
||||
id: typeof p?.id?.id === 'string' ? p.id.id : null,
|
||||
set: typeof p?.id?.set === 'string' ? p.id.set : null,
|
||||
collection:
|
||||
entry.markerCollection === state._animatedMarkers
|
||||
set === 'moving'
|
||||
? 'animated'
|
||||
: 'stationary',
|
||||
: set === 'still'
|
||||
? 'stationary'
|
||||
: null,
|
||||
};
|
||||
})(),
|
||||
};
|
||||
@@ -1596,7 +1609,8 @@ try {
|
||||
key: entry.key,
|
||||
x,
|
||||
y,
|
||||
pickKey: picked?.id ?? picked?.primitive?.id ?? null,
|
||||
// A draw-port pick carries {set, id, meta}; the vehicle is its id.
|
||||
pickKey: picked?.id?.id ?? picked?.id ?? picked?.primitive?.id ?? null,
|
||||
};
|
||||
});
|
||||
let anchor = null;
|
||||
@@ -1849,19 +1863,33 @@ try {
|
||||
await page.$eval(row, (element) =>
|
||||
element.scrollIntoView({ block: 'center' }),
|
||||
);
|
||||
// The marker sets drawn while on, to look for after disable.
|
||||
const markerSets = await page.evaluate(() =>
|
||||
window.__godsEyeView.dataManager.layers
|
||||
.get('transit')
|
||||
.module._transitSetIdsForTest(),
|
||||
);
|
||||
await page.click(`${row} .data-toggle-btn`);
|
||||
await page.waitForFunction(
|
||||
() => !window.__godsEyeView.dataManager.isEnabled('transit'),
|
||||
{ timeout: 20_000 },
|
||||
);
|
||||
const afterDisable = transitRequests.length;
|
||||
const teardown = await page.evaluate(() => {
|
||||
const teardown = await page.evaluate((setIds) => {
|
||||
const layer = window.__godsEyeView.dataManager.layers.get('transit').module;
|
||||
const state = layer._transitStateForTest();
|
||||
return {
|
||||
vehicles: state._vehicles.size,
|
||||
primitives:
|
||||
(state._markers?.length || 0) + (state._animatedMarkers?.length || 0),
|
||||
// Billboards still drawn in the sets drawn while on.
|
||||
primitives: (() => {
|
||||
const scene = window.__godsEyeView.viewer.scene;
|
||||
let count = 0;
|
||||
for (let i = 0; i < scene.primitives.length; i++) {
|
||||
const host = scene.primitives.get(i);
|
||||
if (setIds.includes(host?.drawSetId)) count += host.length || 0;
|
||||
}
|
||||
return count;
|
||||
})(),
|
||||
visible: state._visible.size,
|
||||
moving: state._moving.size,
|
||||
detect: state._detectCache,
|
||||
@@ -1873,12 +1901,12 @@ try {
|
||||
],
|
||||
trailPending: layer._transitPartsForTest().trails.requestDiagnostics()
|
||||
.pending,
|
||||
shown: state._markers ? state._markers.show : null,
|
||||
shown: state._markersShown ?? null,
|
||||
inFlight: state._inFlight.size,
|
||||
activeFeeds: state._activeFeeds.size,
|
||||
holds: window.__godsEyeView.getRenderGovernorDiagnostics().holds,
|
||||
};
|
||||
});
|
||||
}, markerSets);
|
||||
check(
|
||||
'disable leaves no vehicles and no point primitives',
|
||||
teardown.vehicles === 0 &&
|
||||
|
||||
@@ -747,3 +747,93 @@ test('the perspective helper is continuous through the sub-pixel band, not a 23
|
||||
`exact alone at ${s.separation.toFixed(2)} px`,
|
||||
);
|
||||
});
|
||||
|
||||
test('the port-side perspective rotation matches the Cesium one through the whole band', async () => {
|
||||
// The transit layer turns its icons with `perspectiveCourseRotation`, which
|
||||
// projects through the query port and blends with the camera-port basis;
|
||||
// given the same projection and basis it must answer as the scene helper.
|
||||
const { perspectiveCourseRotation } = await import('./screenRotation.js');
|
||||
let compared = 0;
|
||||
for (let altitude = 500; altitude <= 600_000; altitude *= 1.05) {
|
||||
const scene = obliqueScene(altitude, 45);
|
||||
const project = (p) => {
|
||||
const s = Cesium.SceneTransforms.worldToWindowCoordinates(
|
||||
scene,
|
||||
new Cesium.Cartesian3(p.x, p.y, p.z),
|
||||
);
|
||||
return s ? { x: s.x, y: s.y } : null;
|
||||
};
|
||||
const basis = { right: scene.camera.rightWC, up: scene.camera.upWC };
|
||||
for (const [east, north] of [
|
||||
[0.7, 1.2],
|
||||
[-0.4, 0.9],
|
||||
[0, 0.5],
|
||||
[0, -2],
|
||||
])
|
||||
for (const course of [0, 37, 90, 181, 300]) {
|
||||
const contact = Cesium.Cartesian3.fromDegrees(
|
||||
(east * altitude) / 111_320,
|
||||
(north * altitude) / 111_320,
|
||||
0,
|
||||
);
|
||||
for (const previous of [null, 0.25]) {
|
||||
const expected = perspectiveProjectedRotation(
|
||||
scene,
|
||||
contact,
|
||||
course,
|
||||
previous,
|
||||
);
|
||||
const actual = perspectiveCourseRotation(
|
||||
project,
|
||||
basis,
|
||||
{ x: contact.x, y: contact.y, z: contact.z },
|
||||
course,
|
||||
previous,
|
||||
);
|
||||
if (expected === null || actual === null)
|
||||
assert.equal(actual, expected);
|
||||
else
|
||||
assert.ok(
|
||||
Math.abs(actual - expected) < 1e-9,
|
||||
`${altitude.toFixed(0)} m, course ${course}: ${actual} vs ${expected}`,
|
||||
);
|
||||
compared += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
assert.ok(compared > 1000);
|
||||
assert.equal(perspectiveCourseRotation(null, null, null, 0, 0.5), 0.5);
|
||||
});
|
||||
|
||||
test('the port-side perspective rotation probes along the east-north frame, poles included', async () => {
|
||||
const { perspectiveCourseRotation, PERSPECTIVE_PROBE_M: probeM } =
|
||||
await import('./screenRotation.js');
|
||||
const { eastNorthUp, frameVector } = await import('../geo/frames.js');
|
||||
const { fromDegrees } = await import('../geo/ellipsoid.js');
|
||||
for (const position of [
|
||||
fromDegrees(-71.06, 42.36, 12),
|
||||
fromDegrees(150, -60, 0),
|
||||
{ x: 0, y: 0, z: 6_356_752.314245 },
|
||||
])
|
||||
for (const course of [0, 45, 200]) {
|
||||
const seen = [];
|
||||
perspectiveCourseRotation(
|
||||
(p) => (seen.push({ x: p.x, y: p.y, z: p.z }), { x: 0, y: 0 }),
|
||||
null,
|
||||
position,
|
||||
course,
|
||||
);
|
||||
const rad = (course * Math.PI) / 180;
|
||||
const forward = frameVector(eastNorthUp(position), {
|
||||
x: Math.sin(rad) * probeM,
|
||||
y: Math.cos(rad) * probeM,
|
||||
z: 0,
|
||||
});
|
||||
const [, ahead] = seen;
|
||||
for (const axis of ['x', 'y', 'z'])
|
||||
assert.ok(
|
||||
Math.abs(ahead[axis] - (position[axis] + forward[axis])) < 1e-6,
|
||||
`${axis} at course ${course}`,
|
||||
);
|
||||
}
|
||||
});
|
||||
@@ -25,7 +25,7 @@ import { bindRenderer } from '../render/rendererOf.js';
|
||||
import { resolveEllipsoidalGround } from './terrainHeights.js';
|
||||
import {
|
||||
cachedGroundFloor, cachedMeshFloor, setMeshFloorPreferred,
|
||||
_clearMeshFloorCellsForTest,
|
||||
_clearMeshFloorCellsForTest, reportValidatedMeshFloorCell,
|
||||
} from './groundFloor.js';
|
||||
|
||||
/** Distinct site per test — terrainHeights' cache is module-global and warm
|
||||
@@ -183,3 +183,72 @@ test('sampler: with `sets` the probe asks the query port, naming those sets', as
|
||||
assert.ok(Math.abs(asked[0].point.lat - cell.lat) < 0.05);
|
||||
assert.equal(cachedMeshFloor(cell.lat, cell.lon), 138.0);
|
||||
});
|
||||
|
||||
test('sampler: the probe goes where the point is, not to the cell centre', async () => {
|
||||
reset();
|
||||
const cell = nextSite();
|
||||
await seedDem(cell, 120.0);
|
||||
const asked = [];
|
||||
const scene = fakeScene((carto) => {
|
||||
asked.push(Cesium.Math.toDegrees(carto.longitude));
|
||||
return 122.0;
|
||||
});
|
||||
const point = { lat: cell.lat + 0.0003, lon: cell.lon + 0.0004 };
|
||||
sampleMeshFloorCells(scene, [point], { viewerLat: cell.lat, viewerLon: cell.lon });
|
||||
assert.equal(asked.length, 1);
|
||||
assert.ok(Math.abs(asked[0] - point.lon) < 1e-9, `probed at ${asked[0]}, not ${point.lon}`);
|
||||
});
|
||||
|
||||
test('sampler: a viaduct and the street beside it in one cell keep their own heights', async () => {
|
||||
reset();
|
||||
const cell = nextSite();
|
||||
await seedDem(cell, 120.0);
|
||||
// A viaduct deck 9 m up along one line of the cell, the street elsewhere.
|
||||
const deckLat = cell.lat + 0.0003;
|
||||
let calls = 0;
|
||||
const scene = fakeScene((carto) => {
|
||||
calls += 1;
|
||||
return Math.abs(Cesium.Math.toDegrees(carto.latitude) - deckLat) < 1e-7 ? 129.0 : 121.0;
|
||||
});
|
||||
const opts = { viewerLat: cell.lat, viewerLon: cell.lon };
|
||||
const onDeck = { lat: deckLat, lon: cell.lon };
|
||||
const street = { lat: cell.lat - 0.0003, lon: cell.lon };
|
||||
sampleMeshFloorCells(scene, [onDeck], opts);
|
||||
sampleMeshFloorCells(scene, [street], opts);
|
||||
assert.equal(calls, 2);
|
||||
assert.equal(cachedMeshFloor(onDeck.lat, onDeck.lon + 0.0001), 129.0, 'the train stays on the deck');
|
||||
assert.equal(cachedMeshFloor(street.lat, street.lon - 0.0001), 121.0, 'the bus stays on the street');
|
||||
assert.equal(cachedGroundFloor(street.lat, street.lon), 121.0);
|
||||
sampleMeshFloorCells(scene, [{ lat: deckLat, lon: cell.lon + 0.00001 }], opts);
|
||||
assert.equal(calls, 2, 'a point next to one already probed is not probed again');
|
||||
});
|
||||
|
||||
test('sampler: a second reading at the same spot keeps the lower one', async () => {
|
||||
reset();
|
||||
const cell = nextSite();
|
||||
await seedDem(cell, 120.0);
|
||||
assert.equal(reportValidatedMeshFloorCell(cell.lat, cell.lon, 131.0), true);
|
||||
assert.equal(reportValidatedMeshFloorCell(cell.lat + 0.00002, cell.lon, 122.0), true);
|
||||
assert.equal(cachedMeshFloor(cell.lat, cell.lon), 122.0);
|
||||
assert.equal(reportValidatedMeshFloorCell(cell.lat, cell.lon + 0.00002, 140.0), true);
|
||||
assert.equal(cachedMeshFloor(cell.lat, cell.lon), 122.0, 'a higher one never raises it');
|
||||
});
|
||||
|
||||
test('sampler: a latched cell is read a few times at most', async () => {
|
||||
reset();
|
||||
const cell = nextSite();
|
||||
await seedDem(cell, 120.0);
|
||||
let calls = 0;
|
||||
const scene = fakeScene(() => {
|
||||
calls += 1;
|
||||
return 121.0;
|
||||
});
|
||||
const opts = { viewerLat: cell.lat, viewerLon: cell.lon };
|
||||
for (let i = 0; i < 20; i++)
|
||||
sampleMeshFloorCells(
|
||||
scene,
|
||||
[{ lat: cell.lat - 0.0004 + (i % 5) * 0.0002, lon: cell.lon - 0.00045 + Math.floor(i / 5) * 0.0003 }],
|
||||
opts,
|
||||
);
|
||||
assert.equal(calls, 8);
|
||||
});
|
||||
@@ -6,6 +6,7 @@
|
||||
* render noise. See `iconOrientation.js` for why the course is projected
|
||||
* onto the camera basis. No engine.
|
||||
*/
|
||||
import { WGS84 } from '../geo/ellipsoid.js';
|
||||
import { eastNorthUp, frameVector } from '../geo/frames.js';
|
||||
import { dot, toRadians, vec } from '../geo/vector.js';
|
||||
|
||||
@@ -79,3 +80,117 @@ export function stabilizeScreenRotation(
|
||||
);
|
||||
return Math.abs(delta) < Math.max(0, deadbandRad) ? previous : next;
|
||||
}
|
||||
|
||||
/**
|
||||
* Metres ahead `perspectiveCourseRotation` probes: short, so the projection
|
||||
* is local to the contact (a two kilometre probe on a bus seen from six
|
||||
* hundred metres would sample a part of the view the bus is nowhere near).
|
||||
*/
|
||||
export const PERSPECTIVE_PROBE_M = 30;
|
||||
/**
|
||||
* Probe separations (CSS px) across which the exact and camera-basis
|
||||
* answers are blended: at or below the floor the camera-basis answer alone,
|
||||
* at or above the ceiling the exact one.
|
||||
*/
|
||||
export const PERSPECTIVE_BLEND_MIN_PX = 0.5;
|
||||
export const PERSPECTIVE_BLEND_MAX_PX = 3;
|
||||
|
||||
/**
|
||||
* The icon rotation (as `courseScreenRotation`'s) that points a SURFACE
|
||||
* contact along `courseDeg`, projected exactly, perspective division
|
||||
* included: the contact and a point `PERSPECTIVE_PROBE_M` ahead of it are
|
||||
* projected through `project` (a query port's `project`) and the angle
|
||||
* between them read on screen. The camera-basis answer is orthographic,
|
||||
* exact at the view's centre and wrong by twenty-odd degrees for a
|
||||
* street-level contact away from it in an oblique view. Where either point
|
||||
* cannot be projected it falls back to the camera-basis answer; below a few
|
||||
* pixels of separation, where projection noise rules the exact one, the
|
||||
* two are blended the short way round, so the rotation is continuous.
|
||||
* @param {(p: {x: number, y: number, z: number}) => ({x: number, y: number}|null)} project
|
||||
* @param {{right?: object, up?: object}|null} basis The camera's axes.
|
||||
* @param {{x: number, y: number, z: number}|null} position ECEF.
|
||||
* @param {number} courseDeg Degrees clockwise from north.
|
||||
* @param {number|null} [previous] Kept when the rotation is unknown.
|
||||
* @returns {number|null}
|
||||
*/
|
||||
export function perspectiveCourseRotation(
|
||||
project,
|
||||
basis,
|
||||
position,
|
||||
courseDeg,
|
||||
previous = null,
|
||||
) {
|
||||
if (!project || !position || !Number.isFinite(courseDeg)) return previous;
|
||||
if (!courseProbeInto(position, courseDeg, probeScratch)) {
|
||||
// At a pole, through the frame `eastNorthUp` defines there.
|
||||
const courseRad = toRadians(courseDeg);
|
||||
const forward = frameVector(
|
||||
eastNorthUp(position),
|
||||
vec(
|
||||
Math.sin(courseRad) * PERSPECTIVE_PROBE_M,
|
||||
Math.cos(courseRad) * PERSPECTIVE_PROBE_M,
|
||||
0,
|
||||
),
|
||||
);
|
||||
probeScratch.x = position.x + forward.x;
|
||||
probeScratch.y = position.y + forward.y;
|
||||
probeScratch.z = position.z + forward.z;
|
||||
}
|
||||
const at = project(position);
|
||||
const atX = at?.x;
|
||||
const atY = at?.y;
|
||||
const ahead = at ? project(probeScratch) : null;
|
||||
if (!at || !ahead)
|
||||
return courseScreenRotation(basis, position, courseDeg, previous);
|
||||
const dx = ahead.x - atX;
|
||||
const dy = ahead.y - atY;
|
||||
const separation = Math.hypot(dx, dy);
|
||||
// Window y grows downward; rotation 0 points the icon screen-up.
|
||||
const exact = Math.atan2(-dx, -dy);
|
||||
if (separation >= PERSPECTIVE_BLEND_MAX_PX) return exact;
|
||||
const camera = courseScreenRotation(basis, position, courseDeg, previous);
|
||||
if (!Number.isFinite(camera)) return exact;
|
||||
if (separation <= PERSPECTIVE_BLEND_MIN_PX) return camera;
|
||||
const weight =
|
||||
(separation - PERSPECTIVE_BLEND_MIN_PX) /
|
||||
(PERSPECTIVE_BLEND_MAX_PX - PERSPECTIVE_BLEND_MIN_PX);
|
||||
const delta = Math.atan2(Math.sin(exact - camera), Math.cos(exact - camera));
|
||||
return camera + delta * weight;
|
||||
}
|
||||
|
||||
// The probe point, reused: the rotation pass visits every visible contact.
|
||||
const probeScratch = { x: 0, y: 0, z: 0 };
|
||||
|
||||
/**
|
||||
* The point `PERSPECTIVE_PROBE_M` ahead of `position` along `courseDeg` on
|
||||
* its east-north plane (as `eastNorthUp` and `frameVector` give it), into
|
||||
* `out`, allocating nothing. False at a pole, where `eastNorthUp` picks
|
||||
* its own east.
|
||||
*/
|
||||
function courseProbeInto(position, courseDeg, out) {
|
||||
const { x, y, z } = position;
|
||||
// `eastNorthUp`'s own test for a pole.
|
||||
if (Math.abs(x) <= 1e-14 && Math.abs(y) <= 1e-14) return false;
|
||||
const eastLength = Math.hypot(x, y);
|
||||
const o = WGS84.oneOverRadiiSquared;
|
||||
let ux = x * o.x,
|
||||
uy = y * o.y,
|
||||
uz = z * o.z;
|
||||
const upLength = Math.sqrt(ux * ux + uy * uy + uz * uz);
|
||||
ux /= upLength;
|
||||
uy /= upLength;
|
||||
uz /= upLength;
|
||||
const ex = -y / eastLength,
|
||||
ey = x / eastLength;
|
||||
// North is up × east (east has no z).
|
||||
const nx = -uz * ey,
|
||||
ny = uz * ex,
|
||||
nz = ux * ey - uy * ex;
|
||||
const courseRad = toRadians(courseDeg);
|
||||
const e = Math.sin(courseRad) * PERSPECTIVE_PROBE_M;
|
||||
const n = Math.cos(courseRad) * PERSPECTIVE_PROBE_M;
|
||||
out.x = x + ex * e + nx * n;
|
||||
out.y = y + ey * e + ny * n;
|
||||
out.z = z + nz * n;
|
||||
return true;
|
||||
}
|
||||
@@ -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) => {
|
||||
|
||||
@@ -949,6 +949,113 @@ export function createCesiumDraw({
|
||||
return look;
|
||||
}
|
||||
|
||||
/**
|
||||
* What a billboard draws of an icon item but its position, image, `meta`
|
||||
* and `lodGroup`, as plain values: the course rotation follows the
|
||||
* position, so it is written with it.
|
||||
*/
|
||||
function iconStyleOf(record, item) {
|
||||
const color = item.color;
|
||||
const curve = (c) =>
|
||||
c ? [c.near, c.nearValue, c.far, c.farValue] : undefined;
|
||||
return {
|
||||
width: item.size[0],
|
||||
height: item.size[1],
|
||||
scale: item.scale,
|
||||
color:
|
||||
Array.isArray(color) || ArrayBuffer.isView(color) ? [...color] : color,
|
||||
alpha: item.alpha,
|
||||
focus: item.focus,
|
||||
anchor: item.anchor,
|
||||
disableDepthTest: item.disableDepthTest,
|
||||
heightMode: item.height,
|
||||
clampTo: record.spec.clampTo,
|
||||
show: item.show,
|
||||
displayRange: item.displayRange ? [...item.displayRange] : undefined,
|
||||
scaleByDistance: curve(item.scaleByDistance),
|
||||
fadeByDistance: curve(item.fadeByDistance),
|
||||
rotationMode: item.rotationMode,
|
||||
rotation: item.rotation,
|
||||
course: item.course,
|
||||
};
|
||||
}
|
||||
|
||||
/** Two lists, or two missing ones, alike element by element. */
|
||||
function sameList(a, b) {
|
||||
if (!a || !b) return a === b;
|
||||
if (a.length !== b.length) return false;
|
||||
for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
/** A curve as `iconStyleOf` keeps it, and one as an item gives it. */
|
||||
function sameCurve(a, c) {
|
||||
return !a || !c
|
||||
? !a && !c
|
||||
: a[0] === c.near &&
|
||||
a[1] === c.nearValue &&
|
||||
a[2] === c.far &&
|
||||
a[3] === c.farValue;
|
||||
}
|
||||
|
||||
/**
|
||||
* Whether `item` draws as `style` (`iconStyleOf`) says, but its position
|
||||
* and, turned on screen, its rotation (`moveIcon` writes both).
|
||||
*/
|
||||
function sameIconStyle(style, record, item) {
|
||||
const color = item.color;
|
||||
return (
|
||||
style.width === item.size[0] &&
|
||||
style.height === item.size[1] &&
|
||||
style.scale === item.scale &&
|
||||
(Array.isArray(color) || ArrayBuffer.isView(color)
|
||||
? Array.isArray(style.color) && sameList(style.color, color)
|
||||
: style.color === color) &&
|
||||
style.alpha === item.alpha &&
|
||||
style.focus === item.focus &&
|
||||
style.anchor === item.anchor &&
|
||||
style.disableDepthTest === item.disableDepthTest &&
|
||||
style.heightMode === item.height &&
|
||||
style.clampTo === record.spec.clampTo &&
|
||||
style.show === item.show &&
|
||||
sameList(style.displayRange, item.displayRange) &&
|
||||
sameCurve(style.scaleByDistance, item.scaleByDistance) &&
|
||||
sameCurve(style.fadeByDistance, item.fadeByDistance) &&
|
||||
style.rotationMode === item.rotationMode &&
|
||||
(item.rotationMode === 'screen' || style.rotation === item.rotation) &&
|
||||
style.course === item.course
|
||||
);
|
||||
}
|
||||
|
||||
const movedEnu = new Cesium.Matrix4();
|
||||
const movedAxis = new Cesium.Cartesian3();
|
||||
/**
|
||||
* Move a drawn icon whose look is unchanged (`sameIconStyle`): its
|
||||
* position, the course rotation that follows it or the screen rotation
|
||||
* it is given, and its pick record.
|
||||
*/
|
||||
function moveIcon(record, entry, item) {
|
||||
const { billboard, placed } = entry;
|
||||
const position = toCartesianInto(item.pos, placed.position);
|
||||
billboard.position = position;
|
||||
if (item.rotationMode === 'course') {
|
||||
Cesium.Transforms.eastNorthUpToFixedFrame(position, undefined, movedEnu);
|
||||
// The billboard copies the axis it is given.
|
||||
billboard.alignedAxis = Cesium.Matrix4.multiplyByPointAsVector(
|
||||
movedEnu,
|
||||
Cesium.Cartesian3.UNIT_Y,
|
||||
movedAxis,
|
||||
);
|
||||
}
|
||||
if (item.rotationMode === 'screen') {
|
||||
billboard.rotation = item.rotation ?? 0;
|
||||
entry.style.rotation = item.rotation;
|
||||
}
|
||||
billboard.id.meta = item.meta;
|
||||
billboard.id.lodGroup = item.lodGroup;
|
||||
billboard.show = shownNow(record, placed);
|
||||
}
|
||||
|
||||
/** Give a billboard its image: a generated one under its key. */
|
||||
function setIconImage(record, billboard, image) {
|
||||
if (isKeyed(image)) billboard.setImage(image.key, image.canvas);
|
||||
@@ -971,6 +1078,8 @@ export function createCesiumDraw({
|
||||
placed,
|
||||
image: imageKeyOf(image),
|
||||
canvas: image?.canvas,
|
||||
// What it is drawn as, for `patchIcon`'s quick path.
|
||||
style: iconStyleOf(record, item),
|
||||
});
|
||||
}
|
||||
|
||||
@@ -982,6 +1091,17 @@ export function createCesiumDraw({
|
||||
*/
|
||||
function patchIcon(record, entry, item, image) {
|
||||
const { billboard, placed } = entry;
|
||||
// Drawn as it was but for where it is: only that is written, so a set
|
||||
// whose icons move every frame costs little more than the moves.
|
||||
if (
|
||||
entry.style &&
|
||||
imageKeyOf(image) === entry.image &&
|
||||
sameIconStyle(entry.style, record, item)
|
||||
) {
|
||||
moveIcon(record, entry, item);
|
||||
return;
|
||||
}
|
||||
entry.style = iconStyleOf(record, item);
|
||||
const position = toCartesian(item.pos);
|
||||
const look = iconLook(record, item, position);
|
||||
// Sized first: a new SVG image rasterises at the billboard's size.
|
||||
@@ -1000,6 +1120,42 @@ export function createCesiumDraw({
|
||||
billboard.show = shownNow(record, placed);
|
||||
}
|
||||
|
||||
/**
|
||||
* `syncIcons`' quick case: every item is drawn, every touched one keeps
|
||||
* the image it is drawn with, and nothing drawn has gone, so each touched
|
||||
* one is changed where it is and nothing is added, removed or reordered.
|
||||
* False, changing nothing, otherwise.
|
||||
* @param {object} record
|
||||
* @param {readonly string[]} touched
|
||||
*/
|
||||
function patchDrawnIcons(record, touched) {
|
||||
const drawn = record.billboards;
|
||||
// Nothing to remove: every item drawn, and nothing drawn but items.
|
||||
if (
|
||||
!Array.isArray(touched) ||
|
||||
touched.length === 0 ||
|
||||
drawn.size !== record.items.size
|
||||
)
|
||||
return false;
|
||||
for (const id of touched) {
|
||||
const entry = drawn.get(id);
|
||||
const item = record.items.get(id);
|
||||
if (!entry || !item) return false;
|
||||
const image = iconImage(record, item.image);
|
||||
if (
|
||||
image === undefined ||
|
||||
imageKeyOf(image) !== entry.image ||
|
||||
(isKeyed(image) && image.canvas !== entry.canvas)
|
||||
)
|
||||
return false;
|
||||
}
|
||||
for (const id of touched) {
|
||||
const item = record.items.get(id);
|
||||
patchIcon(record, drawn.get(id), item, iconImage(record, item.image));
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Bring an icon set's billboards in line with its items without a
|
||||
* rebuild: those of items gone (or whose image is gone) are removed, the
|
||||
@@ -1029,6 +1185,7 @@ export function createCesiumDraw({
|
||||
host.isDestroyed()
|
||||
)
|
||||
return false;
|
||||
if (!reordered && patchDrawnIcons(record, touched)) return ICONS_KEPT;
|
||||
const images = new Map();
|
||||
for (const id of touched) {
|
||||
const item = record.items.get(id);
|
||||
|
||||
@@ -1963,7 +1963,10 @@ test('the installations layer draws its site dots, outlines and selected dot on
|
||||
rendering.renderRecords();
|
||||
const after = billboards(dotsId);
|
||||
assert.equal(after.length, 2);
|
||||
assert.ok(after.every((dot, i) => dot === dots[i]), 'the same billboards');
|
||||
assert.ok(
|
||||
after.every((dot, i) => dot === dots[i]),
|
||||
'the same billboards',
|
||||
);
|
||||
assert.equal(after.find((dot) => dot.id.id === 'b').show, false);
|
||||
assert.equal(after.find((dot) => dot.id.id === 'a').show, true);
|
||||
const [selected] = billboards(state.sets.selected.id);
|
||||
@@ -2020,9 +2023,7 @@ test('the satellites layer draws its dots as one point collection and its rings
|
||||
assert.equal(points.get(0), iss);
|
||||
assert.equal(iss.position.x, 6.9e6);
|
||||
|
||||
withImageClasses(() =>
|
||||
rendering._showOrbitPath(25544, TRACKED_ORBIT_COLOR),
|
||||
);
|
||||
withImageClasses(() => rendering._showOrbitPath(25544, TRACKED_ORBIT_COLOR));
|
||||
const all = (host) =>
|
||||
host instanceof Cesium.PrimitiveCollection
|
||||
? Array.from({ length: host.length }, (_, i) => all(host.get(i))).flat()
|
||||
@@ -6460,3 +6461,211 @@ test('the recent imagery box preview drags its ground fill and dashed edge frame
|
||||
);
|
||||
assert.equal(await destroyed, 0, 'both sets let go');
|
||||
});
|
||||
|
||||
test('icons that only move are moved on the billboards they have, and still restyle', () => {
|
||||
const scene = fakeScene();
|
||||
const part = createCesiumDraw({
|
||||
scene,
|
||||
report: (error) => assert.fail(error),
|
||||
});
|
||||
const set = part.port.icons({ id: 'icons:moving' });
|
||||
const icon = (lon, extra = {}) => ({
|
||||
id: 'a',
|
||||
pos: Cesium.Cartesian3.fromDegrees(lon, 10, 20),
|
||||
image: 'a.png',
|
||||
size: [20, 20],
|
||||
color: [1, 0, 0, 1],
|
||||
rotationMode: 'screen',
|
||||
rotation: 0.25,
|
||||
disableDepthTest: Infinity,
|
||||
meta: { lon },
|
||||
...extra,
|
||||
});
|
||||
set.set([icon(0), { ...icon(5), id: 'b' }]);
|
||||
const [host] = scene.added;
|
||||
const a = host.get(0);
|
||||
const version = part.version();
|
||||
// Only moved: its look is not written again.
|
||||
let restyles = 0;
|
||||
const width = Object.getOwnPropertyDescriptor(
|
||||
Object.getPrototypeOf(a),
|
||||
'width',
|
||||
);
|
||||
Object.defineProperty(a, 'width', {
|
||||
get: width.get,
|
||||
set(value) {
|
||||
restyles += 1;
|
||||
width.set.call(this, value);
|
||||
},
|
||||
configurable: true,
|
||||
});
|
||||
for (const lon of [1, 2, 3]) set.upsert([icon(lon)]);
|
||||
assert.equal(restyles, 0, 'moved, not restyled');
|
||||
assert.equal(scene.added[0], host, 'the same collection');
|
||||
assert.equal(host.get(0), a, 'the same billboard');
|
||||
const at = Cesium.Cartographic.fromCartesian(a.position);
|
||||
assert.ok(Math.abs(Cesium.Math.toDegrees(at.longitude) - 3) < 1e-9);
|
||||
assert.ok(Math.abs(at.height - 20) < 1e-6);
|
||||
assert.equal(a.rotation, 0.25);
|
||||
assert.ok(Cesium.Color.equals(a.color, Cesium.Color.RED));
|
||||
assert.deepEqual(a.id.meta, { lon: 3 }, 'picks read the latest meta');
|
||||
assert.equal(part.version(), version, 'nothing added or removed');
|
||||
|
||||
// A look that changes after moves is drawn, then moves go on from it.
|
||||
set.upsert([icon(3, { color: [0, 1, 0, 1], rotation: 1, size: [30, 30] })]);
|
||||
assert.equal(restyles, 1, 'restyled once');
|
||||
assert.ok(Cesium.Color.equals(a.color, Cesium.Color.LIME));
|
||||
assert.equal(a.rotation, 1);
|
||||
assert.equal(a.width, 30);
|
||||
set.upsert([icon(4, { color: [0, 1, 0, 1], rotation: 1, size: [30, 30] })]);
|
||||
assert.ok(Cesium.Color.equals(a.color, Cesium.Color.LIME));
|
||||
assert.equal(a.width, 30);
|
||||
const moved = Cesium.Cartographic.fromCartesian(a.position);
|
||||
assert.ok(Math.abs(Cesium.Math.toDegrees(moved.longitude) - 4) < 1e-9);
|
||||
// Turning on screen as it moves is written with the move, not restyled.
|
||||
set.upsert([icon(5, { color: [0, 1, 0, 1], rotation: 2, size: [30, 30] })]);
|
||||
assert.equal(restyles, 1, 'a screen turn is not a restyle');
|
||||
assert.equal(a.rotation, 2);
|
||||
set.upsert([icon(5, { color: [0, 1, 0, 1], rotation: 2, size: [31, 30] })]);
|
||||
assert.equal(restyles, 2, 'a new size still restyles');
|
||||
assert.equal(a.rotation, 2);
|
||||
|
||||
// A course-turned icon's axis follows where it moves.
|
||||
const course = (lon) =>
|
||||
icon(lon, { rotationMode: 'course', course: 90, rotation: undefined });
|
||||
set.upsert([course(4)]);
|
||||
set.upsert([course(60)]);
|
||||
const north = Cesium.Matrix4.multiplyByPointAsVector(
|
||||
Cesium.Transforms.eastNorthUpToFixedFrame(
|
||||
Cesium.Cartesian3.fromDegrees(60, 10, 20),
|
||||
),
|
||||
Cesium.Cartesian3.UNIT_Y,
|
||||
new Cesium.Cartesian3(),
|
||||
);
|
||||
assert.ok(Cesium.Cartesian3.equalsEpsilon(a.alignedAxis, north, 1e-12));
|
||||
assert.equal(a.rotation, -Cesium.Math.toRadians(90));
|
||||
// Hidden in place, while it moves.
|
||||
set.upsert([{ ...course(61), show: false }]);
|
||||
assert.equal(a.show, false);
|
||||
set.upsert([{ ...course(62), show: false }]);
|
||||
assert.equal(a.show, false);
|
||||
set.upsert([course(63)]);
|
||||
assert.equal(a.show, true);
|
||||
set.dispose();
|
||||
});
|
||||
|
||||
test('the transit layer draws its vehicles as two icon sets, moving a marker between them, on a viewer of its own', async () => {
|
||||
const { createRendering } = await import('../../layers/transit/rendering.js');
|
||||
const { createState } = await import('../../layers/transit/state.js');
|
||||
const scene = fakeScene();
|
||||
const viewer = { scene };
|
||||
const noop = () => {};
|
||||
const registered = [];
|
||||
const services = {
|
||||
overlays: {
|
||||
setOverlayEntries: noop,
|
||||
setOverlaySourceVisible: noop,
|
||||
clearOverlaySource: noop,
|
||||
},
|
||||
render: {
|
||||
governorRequestRender: noop,
|
||||
holdContinuousRender: noop,
|
||||
releaseContinuousRender: noop,
|
||||
},
|
||||
sprites: {
|
||||
registerSpriteSet: (layerId, setId) => {
|
||||
const entry = { drawSetId: setId };
|
||||
registered.push([layerId, setId]);
|
||||
return entry;
|
||||
},
|
||||
unregisterSpriteCollection: noop,
|
||||
},
|
||||
};
|
||||
const state = createState({ services });
|
||||
state._viewer = viewer;
|
||||
const rendering = createRendering({
|
||||
state,
|
||||
services,
|
||||
parts: { height: { nearGround: () => false }, trails: { update: noop } },
|
||||
});
|
||||
rendering.createMarkers(viewer);
|
||||
const [stillId, movingId] = rendering.setIds();
|
||||
assert.deepEqual(registered, [
|
||||
['transit', stillId],
|
||||
['transit-motion', movingId],
|
||||
]);
|
||||
const hostOf = (setId) => scene.added.find((h) => h.drawSetId === setId);
|
||||
assert.ok(hostOf(stillId) instanceof Cesium.BillboardCollection);
|
||||
assert.ok(hostOf(movingId) instanceof Cesium.BillboardCollection);
|
||||
assert.equal(hostOf(stillId).show, false, 'hidden until the layer shows');
|
||||
rendering.showMarkers();
|
||||
|
||||
const at = Cesium.Cartesian3.fromDegrees(-71.06, 42.36, 12);
|
||||
const entry = { key: 'mbta:bus', mode: 'bus', toCart: at };
|
||||
rendering.addMarker(entry.key, entry);
|
||||
entry.marker.show = true;
|
||||
entry.marker.rotation = 0.5;
|
||||
rendering.markDirty(entry);
|
||||
rendering.flushMarkers();
|
||||
const still = hostOf(stillId);
|
||||
assert.equal(still.length, 1);
|
||||
const billboard = still.get(0);
|
||||
assert.equal(billboard.id.set, stillId);
|
||||
assert.equal(billboard.id.id, entry.key);
|
||||
assert.deepEqual(billboard.id.meta, { layer: 'transit', key: entry.key });
|
||||
assert.ok(Cesium.Cartesian3.equalsEpsilon(billboard.position, at, 0, 1e-6));
|
||||
assert.equal(billboard.rotation, 0.5);
|
||||
assert.equal(billboard.show, true);
|
||||
assert.equal(billboard.disableDepthTestDistance, Number.POSITIVE_INFINITY);
|
||||
assert.equal(billboard.width, entry.marker.width);
|
||||
assert.equal(
|
||||
rendering.setNameOf(
|
||||
drawHitOf({ primitive: billboard, id: billboard.id }).set,
|
||||
),
|
||||
'still',
|
||||
);
|
||||
|
||||
// Moving it moves the billboard it has.
|
||||
entry.marker.position.z += 10;
|
||||
rendering.markDirty(entry);
|
||||
rendering.flushMarkers();
|
||||
assert.equal(still.get(0), billboard);
|
||||
assert.ok(Math.abs(billboard.position.z - (at.z + 10)) < 1e-6);
|
||||
|
||||
// Starting to move takes it to the moving set and out of the still one.
|
||||
entry.animated = true;
|
||||
rendering.markDirty(entry);
|
||||
rendering.flushMarkers();
|
||||
const moving = hostOf(movingId);
|
||||
assert.equal(moving.length, 1);
|
||||
assert.equal(moving.get(0).id.id, entry.key);
|
||||
assert.equal(moving.get(0).id.set, movingId);
|
||||
const stillNow = hostOf(stillId);
|
||||
const keysInStill = [];
|
||||
for (let i = 0; i < stillNow.length; i += 1)
|
||||
keysInStill.push(stillNow.get(i).id?.id);
|
||||
assert.deepEqual(keysInStill, [], 'no longer drawn in the still set');
|
||||
|
||||
// Markers taken out in one task go in one removal, at its end.
|
||||
const other = { key: 'mbta:tram', mode: 'tram', toCart: at };
|
||||
rendering.addMarker(other.key, other);
|
||||
other.animated = true;
|
||||
rendering.markDirty(other);
|
||||
rendering.flushMarkers();
|
||||
assert.equal(moving.length, 2);
|
||||
const removals = [];
|
||||
const remove = state._movingIcons.remove;
|
||||
state._movingIcons.remove = function (ids) {
|
||||
removals.push([...ids]);
|
||||
return remove.call(this, ids);
|
||||
};
|
||||
rendering.removeMarker(entry);
|
||||
rendering.removeMarker(other);
|
||||
assert.equal(removals.length, 0, 'not yet');
|
||||
await Promise.resolve();
|
||||
assert.deepEqual(removals, [[entry.key, other.key]]);
|
||||
assert.equal(hostOf(movingId).length, 0);
|
||||
rendering.destroyMarkers(viewer);
|
||||
assert.equal(hostOf(stillId), undefined);
|
||||
assert.equal(hostOf(movingId), undefined);
|
||||
});
|
||||
@@ -0,0 +1,91 @@
|
||||
/**
|
||||
* @module render/cesium/uploadProbe
|
||||
* @description A QA probe: the bytes the WebGL context is handed
|
||||
* (`bufferData`, `bufferSubData`) while the hosts of some draw sets update,
|
||||
* frame by frame. A layer's frame probe takes it as its `uploads` (the
|
||||
* transit layer's `_measureTransitFramesForTest`), so the layer itself
|
||||
* stays off the default renderer. Diagnostics only: it wraps the context's
|
||||
* methods and the hosts' `update` until `stop()`.
|
||||
*/
|
||||
import { webglContext } from './internals.js';
|
||||
|
||||
/**
|
||||
* Count the bytes uploaded while the hosts of `setIds` update. Hosts are
|
||||
* found by the `drawSetId` the draw port names them with, again at each
|
||||
* `reset()`, so a host a rebuild puts in a set's place is counted too.
|
||||
* @param {object} viewer A Cesium viewer.
|
||||
* @param {readonly string[]} setIds
|
||||
* @returns {{reset: () => void, bytes: () => number, stop: () => void}}
|
||||
*/
|
||||
export function countDrawSetUploads(viewer, setIds) {
|
||||
const scene = viewer.scene;
|
||||
const ids = new Set(setIds);
|
||||
const gl = webglContext(scene);
|
||||
let active = false;
|
||||
let upload = 0;
|
||||
const restores = [];
|
||||
if (gl) {
|
||||
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[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);
|
||||
};
|
||||
restores.push(() => {
|
||||
gl[name] = original;
|
||||
});
|
||||
}
|
||||
}
|
||||
// Hosts wrapped so far, and how to give each its own `update` back (an
|
||||
// inherited one by deleting the wrapper).
|
||||
const wrapped = new Map();
|
||||
function wrapHosts() {
|
||||
const primitives = scene.primitives;
|
||||
for (let i = 0; i < (primitives?.length ?? 0); i++) {
|
||||
const host = primitives.get(i);
|
||||
if (!ids.has(host?.drawSetId) || wrapped.has(host)) continue;
|
||||
const original = host.update;
|
||||
const own = Object.prototype.hasOwnProperty.call(host, 'update');
|
||||
host.update = function (frameState) {
|
||||
active = true;
|
||||
try {
|
||||
return original.call(this, frameState);
|
||||
} finally {
|
||||
active = false;
|
||||
}
|
||||
};
|
||||
wrapped.set(host, { original, own, wrapper: host.update });
|
||||
}
|
||||
}
|
||||
wrapHosts();
|
||||
return {
|
||||
reset() {
|
||||
upload = 0;
|
||||
wrapHosts();
|
||||
},
|
||||
bytes: () => upload,
|
||||
stop() {
|
||||
for (const restore of restores) restore();
|
||||
restores.length = 0;
|
||||
for (const [host, { original, own, wrapper }] of wrapped) {
|
||||
// A host whose update was replaced meanwhile keeps the new one.
|
||||
if (host.update !== wrapper) continue;
|
||||
if (own) host.update = original;
|
||||
else delete host.update;
|
||||
}
|
||||
wrapped.clear();
|
||||
},
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,105 @@
|
||||
import assert from 'node:assert/strict';
|
||||
import test from 'node:test';
|
||||
import { countDrawSetUploads } from './uploadProbe.js';
|
||||
|
||||
/** A scene whose context counts nothing itself, and hosts that upload. */
|
||||
function sceneWith(hosts) {
|
||||
const gl = {
|
||||
bufferData() {},
|
||||
bufferSubData() {},
|
||||
};
|
||||
const scene = {
|
||||
context: { _gl: gl },
|
||||
primitives: {
|
||||
get: (i) => hosts[i],
|
||||
get length() {
|
||||
return hosts.length;
|
||||
},
|
||||
},
|
||||
};
|
||||
return { scene, gl };
|
||||
}
|
||||
|
||||
function uploader(gl, drawSetId, bytes) {
|
||||
return {
|
||||
drawSetId,
|
||||
update() {
|
||||
gl.bufferData(0, new Float32Array(bytes / 4), 0);
|
||||
gl.bufferSubData(0, 0, new Uint8Array(bytes), 2, 3);
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
test('only the named sets’ uploads count, from each reset, and stop gives everything back', () => {
|
||||
const hosts = [];
|
||||
const { scene, gl } = sceneWith(hosts);
|
||||
const ownBufferData = gl.bufferData;
|
||||
const mine = uploader(gl, 'transit:1:still', 16);
|
||||
const other = uploader(gl, 'traffic:1', 64);
|
||||
hosts.push(mine, other);
|
||||
const ownUpdate = mine.update;
|
||||
const uploads = countDrawSetUploads({ scene }, [
|
||||
'transit:1:still',
|
||||
'transit:1:moving',
|
||||
]);
|
||||
uploads.reset();
|
||||
mine.update();
|
||||
other.update();
|
||||
// 16 bytes of data, then 3 of the 16-byte view from element 2.
|
||||
assert.equal(uploads.bytes(), 16 + 3);
|
||||
// A host that comes later (a rebuild) is found at the next reset.
|
||||
const later = uploader(gl, 'transit:1:moving', 8);
|
||||
const laterUpdate = later.update;
|
||||
hosts.push(later);
|
||||
uploads.reset();
|
||||
assert.equal(uploads.bytes(), 0);
|
||||
later.update();
|
||||
assert.equal(uploads.bytes(), 8 + 3);
|
||||
// An update replaced while counting is the one kept.
|
||||
const replaced = function () {};
|
||||
mine.update = replaced;
|
||||
uploads.stop();
|
||||
assert.equal(gl.bufferData, ownBufferData);
|
||||
assert.equal(later.update, laterUpdate, 'its own update back');
|
||||
assert.equal(mine.update, replaced, 'an update replaced meanwhile stays');
|
||||
assert.notEqual(mine.update, ownUpdate);
|
||||
// Nothing counts once stopped.
|
||||
later.update();
|
||||
assert.equal(uploads.bytes(), 8 + 3);
|
||||
});
|
||||
|
||||
test('an inherited update is given back by removing the wrapper', () => {
|
||||
const hosts = [];
|
||||
const { scene, gl } = sceneWith(hosts);
|
||||
class Host {
|
||||
update() {
|
||||
gl.bufferData(0, 4, 0);
|
||||
}
|
||||
}
|
||||
const host = Object.assign(new Host(), { drawSetId: 's' });
|
||||
hosts.push(host);
|
||||
const uploads = countDrawSetUploads({ scene }, ['s']);
|
||||
assert.ok(Object.hasOwn(host, 'update'));
|
||||
uploads.reset();
|
||||
host.update();
|
||||
assert.equal(uploads.bytes(), 4);
|
||||
uploads.stop();
|
||||
assert.equal(Object.hasOwn(host, 'update'), false);
|
||||
assert.equal(host.update, Host.prototype.update);
|
||||
});
|
||||
|
||||
test('a size-only allocation counts its size', () => {
|
||||
const hosts = [];
|
||||
const { scene, gl } = sceneWith(hosts);
|
||||
hosts.push({
|
||||
drawSetId: 's',
|
||||
update() {
|
||||
gl.bufferData(0, 100, 0);
|
||||
},
|
||||
});
|
||||
const uploads = countDrawSetUploads({ scene }, ['s']);
|
||||
uploads.reset();
|
||||
hosts[0].update();
|
||||
assert.equal(uploads.bytes(), 100);
|
||||
uploads.stop();
|
||||
});
|
||||
@@ -8,7 +8,6 @@
|
||||
"src/cyberSonarScene.js",
|
||||
"src/data/geoImportPins.js",
|
||||
"src/layers/traffic/rendering.js",
|
||||
"src/layers/transit/rendering.js",
|
||||
"src/layers/weather/shellRendering.js",
|
||||
"src/layers/wind/gpuRendering.js",
|
||||
"src/layers/wind/relief.js",
|
||||
|
||||
@@ -120,6 +120,12 @@ const DRAW_FROM_CALLER = new Set([
|
||||
// Its pins, footprints and outlines draw through `drawOf`; its horizon
|
||||
// cull reads the camera and frame ports.
|
||||
'./layers/ghostmaps',
|
||||
// Its moving and still vehicle icons draw through `drawOf`; it projects,
|
||||
// culls, follows and samples floors through the ports.
|
||||
'./layers/transit',
|
||||
// Not Cesium-free (its legacy mesh floor sampler is), but its layer draws
|
||||
// and reads the view through the ports alone.
|
||||
'./layers/transit/standalone',
|
||||
]);
|
||||
|
||||
/**
|
||||
|
||||
+47
-12
@@ -418,13 +418,21 @@ export function createGroundFloor({ terrain, signal }) {
|
||||
// is the photogrammetric MESH, which sits above it (measured ~17 m at the
|
||||
// Austin airport apron). DEM-flooring therefore still buried sprites/trails
|
||||
// inside the mesh. These cells hold the RENDERED surface height, sampled
|
||||
// one-shot per coarse cell near the viewer (scene.sampleHeight — the same
|
||||
// at the callers' points, a few per coarse cell near the viewer, each kept
|
||||
// where it was taken and read back from the nearest (scene.sampleHeight — the same
|
||||
// source groundSnap uses, which is why 3D models always looked right) and
|
||||
// reported here by meshFloorSampler.js. Design principle (owner): NEVER
|
||||
// below the visible surface; slightly above is always fine. The DEM stays
|
||||
// the instant global prior/fallback and the sanity gate for samples.
|
||||
/** @type {Map<string, number>} coarse cell key -> rendered-surface height (m, ellipsoidal). */
|
||||
/** @type {Map<string, Array<{lat: number, lon: number, h: number}>>}
|
||||
* coarse cell key -> rendered-surface readings (m, ellipsoidal), each kept
|
||||
* at the point it was probed. A read answers from the reading nearest the
|
||||
* asked point, so a viaduct and the street beside it in one cell keep their
|
||||
* own heights. */
|
||||
const _meshCells = new Map();
|
||||
/** @constant {number} Readings closer than this (degrees, about 5 m) are
|
||||
* one spot: the lower one is kept there. */
|
||||
const MESH_READING_SAME_SPOT_DEG = 0.00005;
|
||||
/** @type {boolean} Whether mesh cells apply — true only in the google-3d
|
||||
* regime (photoreal stack). On globe stacks the rendered surface IS the
|
||||
* terrain provider (Re:Earth on keyless), so the DEM is already correct
|
||||
@@ -444,7 +452,8 @@ export function createGroundFloor({ terrain, signal }) {
|
||||
|
||||
/**
|
||||
* Records a sampled rendered-surface height for the cell containing the
|
||||
* coordinate (one-shot latch — first accepted sample wins).
|
||||
* coordinate, unchecked, when the cell has no reading yet. The sampler goes
|
||||
* through `reportValidatedMeshFloorCell`, which keeps a reading per point.
|
||||
* @param {number} lat @param {number} lon @param {number} heightM
|
||||
*/
|
||||
function reportMeshFloorCell(lat, lon, heightM) {
|
||||
@@ -456,7 +465,7 @@ export function createGroundFloor({ terrain, signal }) {
|
||||
return;
|
||||
const c = coarseFloorCoord(lat, lon);
|
||||
const key = `${c.lat},${c.lon}`;
|
||||
if (!_meshCells.has(key)) _meshCells.set(key, heightM);
|
||||
if (!_meshCells.has(key)) _meshCells.set(key, [{ lat, lon, h: heightM }]);
|
||||
}
|
||||
|
||||
/** Return whether a rendered-mesh sample is plausible against a real DEM prior. */
|
||||
@@ -471,9 +480,10 @@ export function createGroundFloor({ terrain, signal }) {
|
||||
|
||||
/**
|
||||
* Validate and record a rendered-mesh floor through the single shared gate.
|
||||
* Callers must not bypass this with raw `reportMeshFloorCell`: a coarse-LOD,
|
||||
* rooftop, or aircraft hit would otherwise win the session-long first-write
|
||||
* latch and poison every floor consumer in the cell.
|
||||
* Callers must not bypass this with raw `reportMeshFloorCell`: a coarse-LOD
|
||||
* or aircraft hit would otherwise poison every floor consumer in the cell.
|
||||
* The reading is kept at the point it was taken; a second reading at the
|
||||
* same spot (within about 5 m) keeps the lower of the two.
|
||||
* @returns {boolean} Whether the sample passed and was reported.
|
||||
*/
|
||||
function reportValidatedMeshFloorCell(lat, lon, heightM) {
|
||||
@@ -481,13 +491,26 @@ export function createGroundFloor({ terrain, signal }) {
|
||||
const cell = coarseFloorCoord(lat, lon);
|
||||
const prior = cachedRealEllipsoidalGround(cell.lat, cell.lon);
|
||||
if (!meshFloorSampleWithinPrior(heightM, prior)) return false;
|
||||
reportMeshFloorCell(cell.lat, cell.lon, heightM);
|
||||
const key = `${cell.lat},${cell.lon}`;
|
||||
const readings = _meshCells.get(key);
|
||||
if (!readings) {
|
||||
_meshCells.set(key, [{ lat, lon, h: heightM }]);
|
||||
return true;
|
||||
}
|
||||
const same = readings.find(
|
||||
(r) =>
|
||||
Math.abs(r.lat - lat) < MESH_READING_SAME_SPOT_DEG &&
|
||||
Math.abs(r.lon - lon) < MESH_READING_SAME_SPOT_DEG,
|
||||
);
|
||||
if (!same) readings.push({ lat, lon, h: heightM });
|
||||
else if (heightM < same.h) same.h = heightM;
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Synchronous mesh-cell read — null when the cell is unsampled OR the
|
||||
* google-3d regime is inactive (globe stacks must floor on the DEM).
|
||||
* Synchronous mesh-cell read — the cell's reading nearest the point, or
|
||||
* null when the cell is unsampled OR the google-3d regime is inactive (globe
|
||||
* stacks must floor on the DEM).
|
||||
* @param {number} lat @param {number} lon
|
||||
* @returns {number|null}
|
||||
*/
|
||||
@@ -495,8 +518,20 @@ export function createGroundFloor({ terrain, signal }) {
|
||||
if (!_meshPreferred) return null;
|
||||
if (!Number.isFinite(lat) || !Number.isFinite(lon)) return null;
|
||||
const c = coarseFloorCoord(lat, lon);
|
||||
const h = _meshCells.get(`${c.lat},${c.lon}`);
|
||||
return h != null ? h : null;
|
||||
const readings = _meshCells.get(`${c.lat},${c.lon}`);
|
||||
if (!readings) return null;
|
||||
if (readings.length === 1) return readings[0].h;
|
||||
const k = Math.cos((lat * Math.PI) / 180) ** 2;
|
||||
let best = readings[0],
|
||||
bestD = Infinity;
|
||||
for (const r of readings) {
|
||||
const d = (r.lat - lat) ** 2 + k * (r.lon - lon) ** 2;
|
||||
if (d < bestD) {
|
||||
bestD = d;
|
||||
best = r;
|
||||
}
|
||||
}
|
||||
return best.h;
|
||||
}
|
||||
|
||||
/** Test hook: clears mesh cells (never called at runtime — cells are valid all session). */
|
||||
|
||||
@@ -25,13 +25,16 @@ export function createMeshFloorSampler({
|
||||
// which sits above the Re:Earth bare-earth DEM (measured ~17 m at the Austin
|
||||
// airport apron) — so DEM-floored sprites/trails still buried themselves in
|
||||
// the mesh while 3D models (which groundSnap against the mesh) looked right.
|
||||
// This module samples the mesh height ONE-SHOT per coarse cell and reports it
|
||||
// to groundFloor.js, whose cachedGroundFloor() then answers mesh-first.
|
||||
// This module samples the mesh height at the callers' points, a few probes
|
||||
// per coarse cell, and reports them to groundFloor.js, which keeps each
|
||||
// reading that passes its gate at its own point; cachedGroundFloor() then
|
||||
// answers mesh-first, from the reading nearest the asked point.
|
||||
//
|
||||
// Rationing (the CCTV loading-jitter lesson): scene.sampleHeight forces
|
||||
// tile-load prioritization at the probe point, so sampling is (a) gated to
|
||||
// cells NEAR the viewer — where tiles are streamed and where an error is
|
||||
// visible at all, (b) capped per call, (c) one-shot per cell for the session,
|
||||
// visible at all, (b) capped per call, (c) at most MAX_PROBES_PER_CELL
|
||||
// readings per cell for the session, each at a point apart from the others,
|
||||
// (d) skipped entirely outside the google-3d regime. A returned-undefined
|
||||
// probe (tiles not streamed yet) is NOT latched — it retries on a later call.
|
||||
//
|
||||
@@ -51,6 +54,16 @@ export function createMeshFloorSampler({
|
||||
* streamed LOD under a high camera is coarse everywhere, so every probe
|
||||
* would latch junk. */
|
||||
const MAX_CAMERA_HEIGHT_M = 25_000;
|
||||
/** @constant {number} Readings per cell: a cell is probed at most this
|
||||
* many times, each at a point apart from the others, and groundFloor keeps
|
||||
* each reading at its point (a read answers from the nearest one). */
|
||||
const MAX_PROBES_PER_CELL = 8;
|
||||
/** @constant {number} How far apart (degrees, about 17 m) a new probe must
|
||||
* be from the cell's earlier ones to be worth taking. */
|
||||
const PROBE_APART_DEG = 0.00015;
|
||||
/** @type {Map<string, Array<{lat: number, lon: number}>>} Points probed
|
||||
* per cell that returned a reading. */
|
||||
const _probedPoints = new Map();
|
||||
/** @type {Cesium.Cartographic} Scratch for probe coordinates. */
|
||||
const _scratchProbe = new Cesium.Cartographic();
|
||||
|
||||
@@ -85,7 +98,7 @@ export function createMeshFloorSampler({
|
||||
|
||||
/**
|
||||
* Samples the rendered mesh height for the coarse cells containing `points`,
|
||||
* one-shot per cell, budget-capped, viewer-proximity-gated. Call ONCE per
|
||||
* a few probes per cell, budget-capped, viewer-proximity-gated. Call ONCE per
|
||||
* layer poll (never per contact, never per frame). Synchronous — Cesium's
|
||||
* sampleHeight is a CPU-side query against loaded tiles.
|
||||
*
|
||||
@@ -136,8 +149,21 @@ export function createMeshFloorSampler({
|
||||
const cell = coarseFloorCoord(p.lat, p.lon);
|
||||
const key = `${cell.lat},${cell.lon}`;
|
||||
if (attempted.has(key)) continue;
|
||||
// A latched cell is probed again only at a point well apart from the
|
||||
// ones already probed, a few times at most, so the cell's readings
|
||||
// follow where its vehicles actually are.
|
||||
const probes = _probedPoints.get(key);
|
||||
if (
|
||||
cachedMeshFloor(cell.lat, cell.lon) != null &&
|
||||
(probes?.length >= MAX_PROBES_PER_CELL ||
|
||||
probes?.some(
|
||||
(q) =>
|
||||
Math.abs(q.lat - p.lat) < PROBE_APART_DEG &&
|
||||
Math.abs(q.lon - p.lon) < PROBE_APART_DEG,
|
||||
))
|
||||
)
|
||||
continue;
|
||||
attempted.add(key);
|
||||
if (cachedMeshFloor(cell.lat, cell.lon) != null) continue; // one-shot latch
|
||||
if (
|
||||
Number.isFinite(viewerLat) &&
|
||||
Number.isFinite(viewerLon) &&
|
||||
@@ -146,14 +172,18 @@ export function createMeshFloorSampler({
|
||||
) {
|
||||
continue; // too far: tiles not streamed there, probe would be a guaranteed miss
|
||||
}
|
||||
// Probe where the caller's point is, not at the cell's centre: a
|
||||
// centre that falls on a roof would lift everything in the cell.
|
||||
const height = heights.now(
|
||||
Cesium.Cartographic.fromDegrees(cell.lon, cell.lat, 0, _scratchProbe),
|
||||
Cesium.Cartographic.fromDegrees(p.lon, p.lat, 0, _scratchProbe),
|
||||
{ exclude },
|
||||
);
|
||||
// A miss counts against the budget whatever its cause: past the support
|
||||
// gate a probe only throws mid-teardown, when every later cell would too.
|
||||
sampled += 1;
|
||||
if (height === null) continue; // tiles not loaded yet — no negative latch
|
||||
if (probes) probes.push({ lat: p.lat, lon: p.lon });
|
||||
else _probedPoints.set(key, [{ lat: p.lat, lon: p.lon }]);
|
||||
// Round 5: a REAL Re:Earth prior is REQUIRED before any sample latches.
|
||||
// - A geoid-fallback prior (cached while the proxy was failing) is a
|
||||
// sea-level poison that rejected legitimate samples at elevated
|
||||
@@ -182,7 +212,7 @@ export function createMeshFloorSampler({
|
||||
// feasible and deliberately deferred — see the P2 in
|
||||
// the project roadmap, which bundles it with the fly_route probe so
|
||||
// one post-launch pass settles rendered-mesh sampling everywhere.
|
||||
reportValidatedMeshFloorCell(cell.lat, cell.lon, height);
|
||||
reportValidatedMeshFloorCell(p.lat, p.lon, height);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -397,6 +397,28 @@ test('sensor sampler waits for postRender and reads framebuffer pixels; stopped
|
||||
}),
|
||||
}),
|
||||
};
|
||||
// The marker record (fresh with each state read, as the fixture's
|
||||
// wrappers are), and the billboard the draw port drew for the latest one
|
||||
// in the layer's still set.
|
||||
let marker = null;
|
||||
const billboard = {
|
||||
id: { set: 'transit:1:still', id: 'bus' },
|
||||
show: true,
|
||||
color: { alpha: 1 },
|
||||
rotation: 0,
|
||||
get position() {
|
||||
return marker.position;
|
||||
},
|
||||
};
|
||||
scene.primitives = {
|
||||
length: 1,
|
||||
get: () => ({
|
||||
drawSetId: 'transit:1:still',
|
||||
show: true,
|
||||
length: 1,
|
||||
get: () => billboard,
|
||||
}),
|
||||
};
|
||||
globalThis.window = {
|
||||
__godsEyeView: {
|
||||
viewer: { scene },
|
||||
@@ -406,22 +428,22 @@ test('sensor sampler waits for postRender and reads framebuffer pixels; stopped
|
||||
'transit',
|
||||
{
|
||||
module: {
|
||||
_transitStateForTest: () => ({
|
||||
_vehicles: new Map([
|
||||
[
|
||||
'bus',
|
||||
{
|
||||
key: 'bus',
|
||||
mode: 'bus',
|
||||
marker: {
|
||||
show: true,
|
||||
image: 'raster',
|
||||
position: { x: 0, y: 0, z: 0 },
|
||||
},
|
||||
},
|
||||
],
|
||||
]),
|
||||
}),
|
||||
_transitSetIdsForTest: () => [
|
||||
'transit:1:still',
|
||||
'transit:1:moving',
|
||||
],
|
||||
_transitStateForTest: () => {
|
||||
marker = {
|
||||
show: true,
|
||||
image: 'raster',
|
||||
position: { x: 0, y: 0, z: 0 },
|
||||
};
|
||||
return {
|
||||
_vehicles: new Map([
|
||||
['bus', { key: 'bus', mode: 'bus', marker }],
|
||||
]),
|
||||
};
|
||||
},
|
||||
},
|
||||
},
|
||||
],
|
||||
@@ -603,8 +625,30 @@ test('preset baseline clears a previous city selection before comparing fleet si
|
||||
_selectedKey: entry.key,
|
||||
_vehicles: new Map([[entry.key, entry]]),
|
||||
};
|
||||
// The billboard the draw port drew for the marker, styled as it is.
|
||||
const billboard = {
|
||||
id: { set: 'transit:1:still', id: entry.key },
|
||||
get width() {
|
||||
return entry.marker.width;
|
||||
},
|
||||
get color() {
|
||||
return entry.marker.color;
|
||||
},
|
||||
};
|
||||
globalThis.window = {
|
||||
__godsEyeView: {
|
||||
viewer: {
|
||||
scene: {
|
||||
primitives: {
|
||||
length: 1,
|
||||
get: () => ({
|
||||
drawSetId: 'transit:1:still',
|
||||
length: 1,
|
||||
get: () => billboard,
|
||||
}),
|
||||
},
|
||||
},
|
||||
},
|
||||
dataManager: {
|
||||
layers: new Map([
|
||||
[
|
||||
@@ -612,6 +656,7 @@ test('preset baseline clears a previous city selection before comparing fleet si
|
||||
{
|
||||
module: {
|
||||
_transitStateForTest: () => state,
|
||||
_transitSetIdsForTest: () => ['transit:1:still'],
|
||||
_transitPartsForTest: () => ({
|
||||
selection: {
|
||||
clearSelection() {
|
||||
|
||||
Reference in new issue
Block a user