diff --git a/src/layers/transit/height.js b/src/layers/transit/height.js index 024a5546f..4a0b3d1f5 100644 --- a/src/layers/transit/height.js +++ b/src/layers/transit/height.js @@ -1,4 +1,3 @@ -import * as Cesium from 'cesium'; import { FLOOR_REREAD_ATTEMPTS, FLOOR_REREAD_MS, @@ -7,7 +6,7 @@ import { HEIGHT_SAMPLE_MAX_ALTITUDE_M, withinViewBounds, } from './policy.js'; -import { heightsFor } from '../../render/cesium/heights.js'; +import { heightsOf } from '../../queries/heights.js'; /** Surface preparation off the render path, shared by markers and history. */ export function createHeight({ state, services, parts }) { @@ -19,24 +18,6 @@ export function createHeight({ state, services, parts }) { coarseFloorCoord, GROUND_FLOOR_LIFT_M, } = services.ground; - // 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; - - /** 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, - }; - } - - function cameraAltitude() { - const carto = state._viewer?.camera?.positionCartographic; - return carto && Number.isFinite(carto.height) ? carto.height : Infinity; - } /** * Whether ground matters at this camera. Above the gate a few metres of @@ -45,7 +26,7 @@ export function createHeight({ state, services, parts }) { * @returns {boolean} */ function nearGround() { - return cameraAltitude() <= HEIGHT_SAMPLE_MAX_ALTITUDE_M; + return parts.rendering.cameraHeightM() <= HEIGHT_SAMPLE_MAX_ALTITUDE_M; } /** @@ -54,7 +35,7 @@ export function createHeight({ state, services, parts }) { * @param {number} lon * @returns {{cell: string, height: number|null, prior: number|null}} */ - const terrainPoint = new Cesium.Cartographic(); + const terrainPoint = { lon: 0, lat: 0 }; function requestHeight(lat, lon, entry = null) { const coarse = coarseFloorCoord(lat, lon); const cell = `${coarse.lat},${coarse.lon}`; @@ -64,15 +45,14 @@ export function createHeight({ state, services, parts }) { return { cell, height: fixtureFloor, prior: null }; // On a terrain globe, use the loaded surface under the marker. This is // synchronous cache work and does not launch a terrain request. - const scene = state._viewer?.scene; - if (scene?.globe?.show === true) { - Cesium.Cartographic.fromDegrees(lon, lat, 0, terrainPoint); - const rendered = heightsFor(scene).now(terrainPoint, { + const globe = parts.rendering.globeSurface(); + if (globe !== 'none') { + terrainPoint.lon = lon; + terrainPoint.lat = lat; + const rendered = heightsOf(state._viewer).now(terrainPoint, { against: 'terrain', }); - const flat = - state._viewer?.terrainProvider instanceof - Cesium.EllipsoidTerrainProvider; + const flat = globe === 'flat'; if (rendered !== null || flat) return { cell, @@ -203,14 +183,9 @@ export function createHeight({ state, services, parts }) { if (admitted && cell.entry) cellCursors.set(cell.entry, cell.next); } meshUsed += mesh.length; - const markers = entries.map((entry) => entry.marker).filter(Boolean); for (let i = 0; i < dem.length; i += 8) warmGroundFloor(dem.slice(i, i + 8)); - for (let i = 0; i < mesh.length; i += 8) - sampleMeshFloorCells?.(state._viewer?.scene, mesh.slice(i, i + 8), { - excludeObjects: markers, - ...viewerSubpoint(), - }); + parts.rendering.sampleMeshFloors(mesh, entries); // Cached completions can be adopted now; asynchronous completions are // adopted by the next bounded reread. for (const entry of entries) parts.trails.prepareEntry(entry); diff --git a/src/layers/transit/lifecycle.js b/src/layers/transit/lifecycle.js index 6711eacd2..4b0e557be 100644 --- a/src/layers/transit/lifecycle.js +++ b/src/layers/transit/lifecycle.js @@ -1,16 +1,5 @@ import { destroyTrack } from '../../data/contactPlayback.js'; -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 { - claimCameraSensitivity, - releaseCameraSensitivity, -} from '../../data/cameraSensitivity.js'; -import { - CAMERA_PERCENTAGE_CHANGED, - TRANSIT_SELECTED_OVERLAY_SOURCE_ID, -} from './policy.js'; +import { TRANSIT_SELECTED_OVERLAY_SOURCE_ID } from './policy.js'; import { TRANSIT_ENABLED_FEEDS } from '../../data/transitFeeds.js'; /** @@ -22,38 +11,10 @@ import { TRANSIT_ENABLED_FEEDS } from '../../data/transitFeeds.js'; * @returns {object} */ export function createLifecycle({ state, services, parts }) { - const { - registerSpriteCollection, - unregisterSpriteCollection, - restoreSpriteOrder, - } = services.sprites; + const { restoreSpriteOrder } = services.sprites; const { registerPickOwner, unregisterPickOwner } = services.picking; const { releaseContinuousRender } = services.render; - /** - * Borrow the camera's change sensitivity through the shared claim ledger. - * - * `camera.changed` fires on a percentage of the view moving, and this layer - * needs a finer trigger than the default to notice it has entered a feed's - * coverage. It is a single shared number, so the claim is registered by name - * rather than written directly: comparing the VALUE on the way out could not - * tell this layer's 0.05 from anybody else's, and handing back the coarse - * default while Bikeshare was still relying on a fine one was exactly the - * bug that produced. - */ - function borrowCameraSensitivity(viewer) { - claimCameraSensitivity( - viewer?.camera, - 'transit', - CAMERA_PERCENTAGE_CHANGED, - ); - } - - /** Give the claim up. The camera keeps whatever anyone else still asks for. */ - function returnCameraSensitivity(viewer) { - releaseCameraSensitivity(viewer?.camera, 'transit'); - } - /** * Follow the active post-FX style so the sprites can be restyled for it. * The map style arrives on `gev:style-change`; a cockpit vision override @@ -126,22 +87,11 @@ export function createLifecycle({ state, services, parts }) { /** * Create the point collection. Called once at bootstrap. - * @param {Cesium.Viewer} viewer + * @param {object} viewer */ init(viewer) { state._viewer = viewer; - state._markers = new Cesium.BillboardCollection({ - blendOption: Cesium.BlendOption.TRANSLUCENT, - }); - viewer.scene.primitives.add(state._markers); - registerSpriteCollection('transit', state._markers); - state._animatedMarkers = new Cesium.BillboardCollection({ - blendOption: Cesium.BlendOption.TRANSLUCENT, - }); - viewer.scene.primitives.add(state._animatedMarkers); - registerSpriteCollection('transit-motion', state._animatedMarkers); - state._animatedMarkers.show = false; - state._markers.show = false; + parts.rendering.createMarkers(viewer); state._enabled = false; state._activeFeeds.clear(); state._feedStatus.clear(); @@ -172,15 +122,14 @@ export function createLifecycle({ state, services, parts }) { /** * Show vehicles, watch the camera, and poll every feed in range. - * @param {Cesium.Viewer} viewer + * @param {object} viewer */ enable(viewer) { state._enabled = true; bindVisibility(); state._generation += 1; state._error = null; - state._markers.show = true; - state._animatedMarkers.show = true; + parts.rendering.showMarkers(); state._maintenanceTimer = setInterval( parts.rendering.maintainPresentation, 250, @@ -189,22 +138,17 @@ export function createLifecycle({ state, services, parts }) { parts.selection.installClickHandler(viewer); registerPickOwner('transit', (pickedId) => state._vehicles.has(pickedId)); if (!state._cameraChangedAttached) { - viewer.camera.changed.addEventListener(parts.viewport.onCameraChanged); - borrowCameraSensitivity(viewer); + parts.rendering.watchCamera(viewer, parts.viewport.onCameraChanged); state._cameraChangedAttached = true; } - if (!state._preRenderRemove) { - state._preRenderRemove = viewer.scene.preRender.addEventListener( - parts.rendering.onPreRender, - ); - } + parts.rendering.startFrames(viewer); parts.viewport.runProximityCheck(); restoreSpriteOrder(viewer); }, /** * Hide everything, stop polling, drop all vehicles. - * @param {Cesium.Viewer} viewer + * @param {object} viewer */ disable(viewer) { state._enabled = false; @@ -226,16 +170,10 @@ export function createLifecycle({ state, services, parts }) { parts.selection.removeClickHandler(); unregisterPickOwner('transit'); if (state._cameraChangedAttached) { - viewer.camera.changed.removeEventListener( - parts.viewport.onCameraChanged, - ); - returnCameraSensitivity(viewer); + parts.rendering.unwatchCamera(viewer, parts.viewport.onCameraChanged); state._cameraChangedAttached = false; } - if (state._preRenderRemove) { - state._preRenderRemove(); - state._preRenderRemove = null; - } + parts.rendering.stopFrames(); parts.ingestion.abortAllInFlight(); state._activeFeeds.clear(); state._feedStatus.clear(); @@ -246,10 +184,7 @@ export function createLifecycle({ state, services, parts }) { } state._vehicles.clear(); parts.height.clear(); - state._markers?.removeAll(); - state._animatedMarkers?.removeAll(); - if (state._animatedMarkers) state._animatedMarkers.show = false; - if (state._markers) state._markers.show = false; + parts.rendering.clearMarkers(); state._altitudeGateOpen = false; state._moving.clear(); state._heightDirty.clear(); @@ -281,20 +216,11 @@ export function createLifecycle({ state, services, parts }) { /** * Tear down the collection entirely and release every shared registration. - * @param {Cesium.Viewer} viewer + * @param {object} viewer */ destroy(viewer) { this.disable(viewer); - if (state._markers) { - unregisterSpriteCollection('transit', state._markers); - viewer?.scene?.primitives?.remove(state._markers); - state._markers = null; - } - if (state._animatedMarkers) { - unregisterSpriteCollection('transit-motion', state._animatedMarkers); - viewer?.scene?.primitives?.remove(state._animatedMarkers); - state._animatedMarkers = null; - } + parts.rendering.destroyMarkers(viewer); state._overlayHost.clearSource(TRANSIT_SELECTED_OVERLAY_SOURCE_ID); parts.height.clear(); unbindStyleEvents(); diff --git a/src/layers/transit/lifecycle.test.mjs b/src/layers/transit/lifecycle.test.mjs index 069c5c4d9..36ceea40d 100644 --- a/src/layers/transit/lifecycle.test.mjs +++ b/src/layers/transit/lifecycle.test.mjs @@ -45,6 +45,7 @@ import { import { fakeInput } from '../../input/testDoubles.mjs'; import { fakeCameraPort } from '../../testSupport/fakeCameraPort.mjs'; import { bindRenderer } from '../../render/rendererOf.js'; +import { fakeSceneQuery } from '../../testSupport/fakeCesiumScene.mjs'; import { framePortFor } from '../../testSupport/fakeFramePort.mjs'; import { registerStyleStages } from '../../styles/styleStages.js'; @@ -308,8 +309,10 @@ function harness( // The layer reads the camera through its port; this one reads the fake // camera above as the Cesium port reads a real one, so a test can still - // move it by changing the fake. + // move it by changing the fake. Terrain heights come through the query + // port, which reads the fake globe the same way. const unbindCamera = bindRenderer(viewer, { + query: fakeSceneQuery(viewer), camera: { pose() { const carto = viewer.camera.positionCartographic; @@ -2938,7 +2941,6 @@ test('mesh refinement reaches all 100 retained DEM cells within five poll budget _vehicles: new Map([[entry.key, entry]]), _floorCursor: 0, _heightDirty: new Set(), - _viewer: { camera: { positionCartographic: { height: 100 } } }, }; const height = createHeight({ state, @@ -2949,11 +2951,6 @@ test('mesh refinement reaches all 100 retained DEM cells within five poll budget cachedGroundFloor: () => 10, GROUND_FLOOR_LIFT_M: 1.5, }, - mesh: { - sampleMeshFloorCells(scene, points) { - for (const point of points) probed.add(point.cell); - }, - }, }, parts: { trails: { @@ -2963,7 +2960,14 @@ test('mesh refinement reaches all 100 retained DEM cells within five poll budget collect(point, height.requestHeight(point.lat, point.lon)); }, }, - rendering: { requestVisibility() {} }, + rendering: { + requestVisibility() {}, + cameraHeightM: () => 100, + globeSurface: () => 'none', + sampleMeshFloors(cells) { + for (const point of cells) probed.add(point.cell); + }, + }, }, }); t.after(() => height.clear()); @@ -3141,6 +3145,28 @@ 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) => { + const app = harness(t, { floorAt: () => undefined }); + const parts = app.layer._transitPartsForTest(); + const lift = parts.height.requestHeight(0, 0).height; + assert.equal(lift, null, 'with the globe hidden, no terrain is read'); + const asked = []; + app.viewer.scene.globe.show = true; + app.viewer.scene.globe.getHeight = (carto) => { + asked.push(Cesium.Math.toDegrees(carto.latitude)); + return 30; + }; + const terrain = parts.height.requestHeight(42.36, -71.06); + assert.ok(Math.abs(asked[0] - 42.36) < 1e-9, 'asked at the vehicle'); + assert.equal(parts.rendering.globeSurface(), 'terrain'); + app.viewer.scene.globe.getHeight = () => undefined; + app.viewer.terrainProvider = new Cesium.EllipsoidTerrainProvider(); + 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('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; diff --git a/src/layers/transit/rendering.js b/src/layers/transit/rendering.js index 2309978a5..70cd33ae3 100644 --- a/src/layers/transit/rendering.js +++ b/src/layers/transit/rendering.js @@ -1,4 +1,12 @@ 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 { webglContext } from '../../render/cesium/internals.js'; +import { + claimCameraSensitivity, + releaseCameraSensitivity, +} from '../../data/cameraSensitivity.js'; import { cameraPoseSignature, perspectiveProjectedRotation, @@ -20,6 +28,7 @@ import { transitStyleProfile, } from '../../data/transitPresetStyle.js'; import { + CAMERA_PERCENTAGE_CHANGED, MARKER_PIXEL_SIZE, ROTATION_REFRESH_MS, VISIBILITY_REFRESH_MS, @@ -46,6 +55,163 @@ export function createRendering({ state, services, parts }) { holdContinuousRender, releaseContinuousRender, } = services.render; + // 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; + + /** + * The two billboard collections, still and moving, added to the scene and + * to the shared sprite order, hidden. + * @param {object} viewer + */ + function createMarkers(viewer) { + state._markers = new Cesium.BillboardCollection({ + blendOption: Cesium.BlendOption.TRANSLUCENT, + }); + viewer.scene.primitives.add(state._markers); + services.sprites.registerSpriteCollection('transit', state._markers); + state._animatedMarkers = new Cesium.BillboardCollection({ + blendOption: Cesium.BlendOption.TRANSLUCENT, + }); + viewer.scene.primitives.add(state._animatedMarkers); + services.sprites.registerSpriteCollection( + 'transit-motion', + state._animatedMarkers, + ); + state._animatedMarkers.show = false; + state._markers.show = false; + } + + /** Show both collections. */ + function showMarkers() { + state._markers.show = true; + state._animatedMarkers.show = true; + } + + /** Drop every billboard and hide both collections. */ + function clearMarkers() { + state._markers?.removeAll(); + state._animatedMarkers?.removeAll(); + if (state._animatedMarkers) state._animatedMarkers.show = false; + if (state._markers) state._markers.show = false; + } + + /** + * Take both collections off the scene and 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; + } + if (state._animatedMarkers) { + services.sprites.unregisterSpriteCollection( + 'transit-motion', + state._animatedMarkers, + ); + viewer?.scene?.primitives?.remove(state._animatedMarkers); + state._animatedMarkers = null; + } + } + + /** Whether a vehicle's billboard is shown. */ + function markerShown(entry) { + return entry.marker?.show === true; + } + + /** + * Listen for the camera moving, borrowing its change sensitivity through + * the shared claim ledger. + * + * `camera.changed` fires on a percentage of the view moving, and this layer + * needs a finer trigger than the default to notice it has entered a feed's + * coverage. It is a single shared number, so the claim is registered by name + * rather than written directly: comparing the VALUE on the way out could not + * tell this layer's 0.05 from anybody else's, and handing back the coarse + * default while Bikeshare was still relying on a fine one was exactly the + * bug that produced. + * @param {object} viewer + * @param {() => void} onChanged + */ + function watchCamera(viewer, onChanged) { + viewer.camera.changed.addEventListener(onChanged); + claimCameraSensitivity( + viewer?.camera, + 'transit', + CAMERA_PERCENTAGE_CHANGED, + ); + } + + /** Stop listening and give the claim up; the camera keeps anyone else's. */ + function unwatchCamera(viewer, onChanged) { + viewer.camera.changed.removeEventListener(onChanged); + releaseCameraSensitivity(viewer?.camera, 'transit'); + } + + /** Run the per-frame glide before each render, once. */ + function startFrames(viewer) { + if (!state._preRenderRemove) + state._preRenderRemove = + viewer.scene.preRender.addEventListener(onPreRender); + } + + /** Stop the per-frame glide. */ + function stopFrames() { + if (state._preRenderRemove) { + state._preRenderRemove(); + state._preRenderRemove = null; + } + } + + /** + * 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; + } + + /** 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, + }; + } + + /** + * What the globe draws under the fleet: `'none'` when it is hidden (the + * photoreal stack), `'flat'` on the ellipsoid, `'terrain'` otherwise. + * @returns {'none'|'flat'|'terrain'} + */ + function globeSurface() { + if (state._viewer?.scene?.globe?.show !== true) return 'none'; + return state._viewer?.terrainProvider instanceof + Cesium.EllipsoidTerrainProvider + ? 'flat' + : 'terrain'; + } + + /** + * Sample the rendered mesh under floor cells, seeing through these + * vehicles' billboards. + * @param {object[]} cells + * @param {object[]} entries + */ + function sampleMeshFloors(cells, entries) { + if (!sampleMeshFloorCells) return; + const markers = entries.map((entry) => entry.marker).filter(Boolean); + for (let i = 0; i < cells.length; i += 8) + sampleMeshFloorCells(state._viewer?.scene, cells.slice(i, i + 8), { + excludeObjects: markers, + ...viewerSubpoint(), + }); + } /** * Cartesian position for a lat/lon at a height. Called on POLL, not per @@ -589,7 +755,161 @@ export function createRendering({ state, services, parts }) { applySpriteStyle(entry); } + let stopProbe = null; + /** Stop a running frame probe, resolving it with what it has. */ + function stopFrameProbe() { + stopProbe?.(); + } + + /** Measure inside Cesium postRender with fixed typed storage; no sample objects per frame. */ + function measureFrames(durationMs = 12000) { + stopProbe?.(); + const scene = state._viewer.scene; + 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, + 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 start = performance.now(); + onPreRender(); + cpu = performance.now() - start; + }); + let removePost, timer; + return new Promise((resolve) => { + const finish = () => { + clearTimeout(timer); + removePre(); + removePost?.(); + for (const restore of saved) restore(); + if (state._enabled) + state._preRenderRemove = + scene.preRender.addEventListener(onPreRender); + stopProbe = null; + const rows = []; + for (let i = 1; i < count; i++) { + const k = i * stride; + rows.push({ + intervalMs: data[k], + cpuMs: data[k + 1], + uploadBytes: data[k + 2], + moving: data[k + 3], + x: data[k + 4], + y: data[k + 5], + z: data[k + 6], + displayT: data[k + 7], + expectedMps: data[k + 8], + segment: data[k + 9], + }); + } + resolve({ + rows, + dpr: devicePixelRatio, + width: scene.canvas.clientWidth, + height: scene.canvas.clientHeight, + }); + }; + stopProbe = finish; + removePost = scene.postRender.addEventListener(() => { + const now = performance.now(); + if (count >= capacity) return; + const k = count++ * stride; + const entry = state._vehicles.get('mbta:qa-0'); + data[k] = previous ? now - previous : 0; + previous = now; + data[k + 1] = cpu; + data[k + 2] = upload; + let actuallyMoved = 0; + for (const vehicle of state._visible) { + const p = vehicle.marker.position, + index = vehicle.qaIndex * 3; + if ( + count > 1 && + Math.hypot( + p.x - previousPositions[index], + p.y - previousPositions[index + 1], + p.z - previousPositions[index + 2], + ) > 0.00001 + ) + actuallyMoved++; + previousPositions[index] = p.x; + previousPositions[index + 1] = p.y; + previousPositions[index + 2] = p.z; + } + data[k + 3] = actuallyMoved; + if (entry?.marker) { + const p = entry.marker.position; + data[k + 4] = p.x; + data[k + 5] = p.y; + data[k + 6] = p.z; + data[k + 7] = entry.sample.displayT; + data[k + 8] = entry.sample.segmentSpeedMps; + data[k + 9] = entry.sample.fromSeq; + } + }); + timer = setTimeout(finish, durationMs); + }); + } + return { + createMarkers, + showMarkers, + clearMarkers, + destroyMarkers, + markerShown, + watchCamera, + unwatchCamera, + startFrames, + stopFrames, + cameraHeightM, + globeSurface, + sampleMeshFloors, + measureFrames, + stopFrameProbe, resumePlayback, maintainPresentation, requestVisibility, diff --git a/src/layers/transit/testing.js b/src/layers/transit/testing.js index bc39ecc72..66b3929ea 100644 --- a/src/layers/transit/testing.js +++ b/src/layers/transit/testing.js @@ -1,5 +1,4 @@ -import * as Cesium from 'cesium'; -import { webglContext } from '../../render/cesium/internals.js'; +import { fromDegrees } from '../../geo/ellipsoid.js'; import { recordFix, updatePlayback, attachFloorToPlace } from './movement.js'; import { seek, setRate, mergeHistory } from '../../data/contactPlayback.js'; import { getRegisteredTransitFeed } from '../../data/transitFeeds.js'; @@ -12,13 +11,12 @@ import { getRegisteredTransitFeed } from '../../data/transitFeeds.js'; import { transitIconCacheSize } from '../../data/transitIcons.js'; export function createTesting({ state, parts }) { - let stopProbe = null; return { _setTransitFixtureFloorsForTest(keys, heightM) { state._qaFixtureFloors = new Map(keys.map((key) => [key, heightM])); }, _stopTransitProbeForTest() { - stopProbe?.(); + parts.rendering.stopFrameProbe(); }, /** Deterministic observed-position fixtures, independent of upstream availability. */ _loadTransitFleetForTest(count, origin, spacingM = 6, routes = ['741']) { @@ -98,12 +96,8 @@ export function createTesting({ state, parts }) { entry.displayPaths.set(fixes[i].seq, { toSeq: fixes[i + 1].seq, positions: [ - Cesium.Cartesian3.fromDegrees(fixes[i].lon, fixes[i].lat, 20), - Cesium.Cartesian3.fromDegrees( - fixes[i + 1].lon, - fixes[i + 1].lat, - 20, - ), + fromDegrees(fixes[i].lon, fixes[i].lat, 20), + fromDegrees(fixes[i + 1].lon, fixes[i + 1].lat, 20), ], }); } @@ -140,12 +134,8 @@ export function createTesting({ state, parts }) { entry.displayPaths.set(fixes[i].seq, { toSeq: fixes[i + 1].seq, positions: [ - Cesium.Cartesian3.fromDegrees(fixes[i].lon, fixes[i].lat, 20), - Cesium.Cartesian3.fromDegrees( - fixes[i + 1].lon, - fixes[i + 1].lat, - 20, - ), + fromDegrees(fixes[i].lon, fixes[i].lat, 20), + fromDegrees(fixes[i + 1].lon, fixes[i + 1].lat, 20), ], }); } @@ -159,139 +149,9 @@ export function createTesting({ state, parts }) { } parts.rendering.syncRenderHold(); }, - /** Measure inside Cesium postRender with fixed typed storage; no sample objects per frame. */ + /** Measure inside the renderer's frames with fixed typed storage. */ _measureTransitFramesForTest(durationMs = 12000) { - stopProbe?.(); - const scene = state._viewer.scene; - 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, - 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 start = performance.now(); - parts.rendering.onPreRender(); - cpu = performance.now() - start; - }); - let removePost, timer; - return new Promise((resolve) => { - const finish = () => { - clearTimeout(timer); - removePre(); - removePost?.(); - for (const restore of saved) restore(); - if (state._enabled) - state._preRenderRemove = scene.preRender.addEventListener( - parts.rendering.onPreRender, - ); - stopProbe = null; - const rows = []; - for (let i = 1; i < count; i++) { - const k = i * stride; - rows.push({ - intervalMs: data[k], - cpuMs: data[k + 1], - uploadBytes: data[k + 2], - moving: data[k + 3], - x: data[k + 4], - y: data[k + 5], - z: data[k + 6], - displayT: data[k + 7], - expectedMps: data[k + 8], - segment: data[k + 9], - }); - } - resolve({ - rows, - dpr: devicePixelRatio, - width: scene.canvas.clientWidth, - height: scene.canvas.clientHeight, - }); - }; - stopProbe = finish; - removePost = scene.postRender.addEventListener(() => { - const now = performance.now(); - if (count >= capacity) return; - const k = count++ * stride; - const entry = state._vehicles.get('mbta:qa-0'); - data[k] = previous ? now - previous : 0; - previous = now; - data[k + 1] = cpu; - data[k + 2] = upload; - let actuallyMoved = 0; - for (const vehicle of state._visible) { - const p = vehicle.marker.position, - index = vehicle.qaIndex * 3; - if ( - count > 1 && - Math.hypot( - p.x - previousPositions[index], - p.y - previousPositions[index + 1], - p.z - previousPositions[index + 2], - ) > 0.00001 - ) - actuallyMoved++; - previousPositions[index] = p.x; - previousPositions[index + 1] = p.y; - previousPositions[index + 2] = p.z; - } - data[k + 3] = actuallyMoved; - if (entry?.marker) { - const p = entry.marker.position; - data[k + 4] = p.x; - data[k + 5] = p.y; - data[k + 6] = p.z; - data[k + 7] = entry.sample.displayT; - data[k + 8] = entry.sample.segmentSpeedMps; - data[k + 9] = entry.sample.fromSeq; - } - }); - timer = setTimeout(finish, durationMs); - }); + return parts.rendering.measureFrames(durationMs); }, _transitVisibilityForTest() { return [...state._vehicles.values()].map((entry) => { @@ -308,7 +168,7 @@ export function createTesting({ state, parts }) { if (!state._enabled) why.push('disabled'); return { key: entry.key, - shown: entry.marker?.show === true, + shown: parts.rendering.markerShown(entry), why, ...gate, heightPending: !!entry.heightPending, diff --git a/src/render/cesiumAllowList.json b/src/render/cesiumAllowList.json index 8abc20a1c..03b5353a3 100644 --- a/src/render/cesiumAllowList.json +++ b/src/render/cesiumAllowList.json @@ -70,10 +70,7 @@ "src/layers/traffic/rendering.js", "src/layers/traffic/style.js", "src/layers/traffic/surface.js", - "src/layers/transit/height.js", - "src/layers/transit/lifecycle.js", "src/layers/transit/rendering.js", - "src/layers/transit/testing.js", "src/layers/weather/shellRendering.js", "src/layers/wind/gpuRendering.js", "src/layers/wind/relief.js",