diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md index 73bd5402b..a46153eaf 100644 --- a/docs/CURRENT-STATE.md +++ b/docs/CURRENT-STATE.md @@ -4632,12 +4632,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::still` and `transit::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 +4683,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 diff --git a/scripts/format-scope.json b/scripts/format-scope.json index be64b4236..9f4eb4e9a 100644 --- a/scripts/format-scope.json +++ b/scripts/format-scope.json @@ -62,6 +62,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", diff --git a/scripts/package-boundaries.json b/scripts/package-boundaries.json index 481b04902..16df5be05 100644 --- a/scripts/package-boundaries.json +++ b/scripts/package-boundaries.json @@ -5671,6 +5671,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", @@ -5741,6 +5742,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", diff --git a/scripts/qa-transit-browser.mjs b/scripts/qa-transit-browser.mjs index 23925c743..7b9f1ee44 100644 --- a/scripts/qa-transit-browser.mjs +++ b/scripts/qa-transit-browser.mjs @@ -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; diff --git a/scripts/qa-transit-recovery.mjs b/scripts/qa-transit-recovery.mjs index a54e81239..6d45e684b 100644 --- a/scripts/qa-transit-recovery.mjs +++ b/scripts/qa-transit-recovery.mjs @@ -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); diff --git a/scripts/qa-transit-scenes.mjs b/scripts/qa-transit-scenes.mjs index 6ad1238f7..1098ba460 100644 --- a/scripts/qa-transit-scenes.mjs +++ b/scripts/qa-transit-scenes.mjs @@ -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(); + } +} diff --git a/scripts/qa-transit.mjs b/scripts/qa-transit.mjs index 49a25fd18..87fadd842 100644 --- a/scripts/qa-transit.mjs +++ b/scripts/qa-transit.mjs @@ -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, }; })(), }; @@ -1849,19 +1862,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 +1900,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 && diff --git a/src/data/iconOrientation.test.mjs b/src/data/iconOrientation.test.mjs index d2836bfb3..982d2bf7b 100644 --- a/src/data/iconOrientation.test.mjs +++ b/src/data/iconOrientation.test.mjs @@ -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}`, + ); + } +}); diff --git a/src/data/screenRotation.js b/src/data/screenRotation.js index cbad595b9..90a7b41c8 100644 --- a/src/data/screenRotation.js +++ b/src/data/screenRotation.js @@ -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; +} diff --git a/src/layers/transit/height.js b/src/layers/transit/height.js index 4a0b3d1f5..defb49f61 100644 --- a/src/layers/transit/height.js +++ b/src/layers/transit/height.js @@ -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); diff --git a/src/layers/transit/ingestion.js b/src/layers/transit/ingestion.js index 22b179120..98d24f9fe 100644 --- a/src/layers/transit/ingestion.js +++ b/src/layers/transit/ingestion.js @@ -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'); diff --git a/src/layers/transit/lifecycle.test.mjs b/src/layers/transit/lifecycle.test.mjs index feaff6513..1f8996cbb 100644 --- a/src/layers/transit/lifecycle.test.mjs +++ b/src/layers/transit/lifecycle.test.mjs @@ -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]), diff --git a/src/layers/transit/queries.js b/src/layers/transit/queries.js index b86613160..536032358 100644 --- a/src/layers/transit/queries.js +++ b/src/layers/transit/queries.js @@ -84,7 +84,7 @@ export function createQueries({ state, parts }) { * @returns {Array} */ 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)) diff --git a/src/layers/transit/rendering.js b/src/layers/transit/rendering.js index fed2a778c..9bffd17c9 100644 --- a/src/layers/transit/rendering.js +++ b/src/layers/transit/rendering.js @@ -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, diff --git a/src/layers/transit/selection.js b/src/layers/transit/selection.js index c072ba1c9..4c7daccc9 100644 --- a/src/layers/transit/selection.js +++ b/src/layers/transit/selection.js @@ -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(); }); diff --git a/src/layers/transit/state.js b/src/layers/transit/state.js index eb76662e7..e406bea91 100644 --- a/src/layers/transit/state.js +++ b/src/layers/transit/state.js @@ -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; diff --git a/src/layers/transit/testing.js b/src/layers/transit/testing.js index 66b3929ea..887abaca5 100644 --- a/src/layers/transit/testing.js +++ b/src/layers/transit/testing.js @@ -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) => { diff --git a/src/render/cesium/draw.js b/src/render/cesium/draw.js index 5f3da9385..f9c4fa8cb 100644 --- a/src/render/cesium/draw.js +++ b/src/render/cesium/draw.js @@ -966,21 +966,29 @@ export function createCesiumDraw({ }; } - /** Whether `item` draws as `style` (`iconStyleOf`) says, but its position. */ - function sameIconStyle(style, record, item) { - const 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; - }; - const sameCurve = (a, c) => - !a || !c - ? !a && !c - : a[0] === c.near && + /** 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] && @@ -1000,7 +1008,7 @@ export function createCesiumDraw({ sameCurve(style.scaleByDistance, item.scaleByDistance) && sameCurve(style.fadeByDistance, item.fadeByDistance) && style.rotationMode === item.rotationMode && - style.rotation === item.rotation && + (item.rotationMode === 'screen' || style.rotation === item.rotation) && style.course === item.course ); } @@ -1009,7 +1017,8 @@ export function createCesiumDraw({ const movedAxis = new Cesium.Cartesian3(); /** * Move a drawn icon whose look is unchanged (`sameIconStyle`): its - * position, the course rotation that follows it, and its pick record. + * 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; @@ -1024,6 +1033,10 @@ export function createCesiumDraw({ 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); diff --git a/src/render/cesium/draw.test.mjs b/src/render/cesium/draw.test.mjs index dc575d4e9..9b558c8bc 100644 --- a/src/render/cesium/draw.test.mjs +++ b/src/render/cesium/draw.test.mjs @@ -2883,6 +2883,13 @@ test('icons that only move are moved on the billboards they have, and still rest 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) => @@ -6160,3 +6167,117 @@ test('a clamped ellipse filled with a radial rim drapes its material, finely cut assert.deepEqual([...shows.show], [0]); 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); +}); diff --git a/src/render/cesium/uploadProbe.js b/src/render/cesium/uploadProbe.js new file mode 100644 index 000000000..b3313dc09 --- /dev/null +++ b/src/render/cesium/uploadProbe.js @@ -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(); + }, + }; +} diff --git a/src/render/cesium/uploadProbe.test.mjs b/src/render/cesium/uploadProbe.test.mjs new file mode 100644 index 000000000..5f526bb4c --- /dev/null +++ b/src/render/cesium/uploadProbe.test.mjs @@ -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(); +}); diff --git a/src/render/cesiumAllowList.json b/src/render/cesiumAllowList.json index 4d32d6d5c..011497fd5 100644 --- a/src/render/cesiumAllowList.json +++ b/src/render/cesiumAllowList.json @@ -10,7 +10,6 @@ "src/input/dispatcher.js", "src/layers/recentImagery/rendering.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", diff --git a/src/render/unboundCamera.test.mjs b/src/render/unboundCamera.test.mjs index fb16b85e9..3eecb883a 100644 --- a/src/render/unboundCamera.test.mjs +++ b/src/render/unboundCamera.test.mjs @@ -121,6 +121,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', ]); /** diff --git a/src/tooling/transitQa.test.mjs b/src/tooling/transitQa.test.mjs index 7ab6a8fa3..bfedb8fbe 100644 --- a/src/tooling/transitQa.test.mjs +++ b/src/tooling/transitQa.test.mjs @@ -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() {