Draw directions through the draw port

The directions layer draws its endpoint markers, its flowing route and
its maneuver dots through draw-port sets, takes clicks from the draw hit
and ground picks from the click's ground position, and leaves the Cesium
allow-list. The route keeps the annotation's flowing dashes, draped on
terrain and tiles; the maneuver dots keep their place in the sprite
order through the steps set.
This commit is contained in:
Sameh Khamis committed 2026-11-07 05:42:26 -08:00
1 parent d18fae43c2
commit 9de93b8d31
8 files changed
+361 -180

No files matched your search

+5 -9
View File
@@ -4,20 +4,18 @@ import { createDirectionsSource } from '../layers/directions/source.js';
* @description Service bundle for the Directions layer.
*
* The layer itself lives in `src/layers/directions/`, which imports nothing
* but Cesium and the pure step formatter. This module is the one place that
* names the application's shared services — the render governor, sprite order,
* the pick registry, the world overlay, the annotation material, the camera
* verbs, the shared ground floor and the pointer arbiter — and it re-exports
* the layer's pure helpers for the tests and the share-link code.
* but the renderer's draw port, geodesy and the pure step formatter. This
* module is the one place that names the application's shared services —
* the render governor, sprite order, the pick registry, the world overlay,
* the camera verbs, the shared ground floor and the pointer arbiter — and it
* re-exports the layer's pure helpers for the tests and the share-link code.
*/
import * as credits from './dataCredits.js';
import * as render from '../renderGovernor.js';
import * as sprites from './spriteOrder.js';
import * as picking from './pickRegistry.js';
import * as scenePick from './scenePick.js';
import * as overlays from '../overlays/worldOverlay.js';
import * as annotations from '../annotations/worldAnnotationRenderer.js';
import * as camera from '../cameraVerbs.js';
import * as ground from './groundFloor.js';
import * as input from './inputOwnership.js';
@@ -29,9 +27,7 @@ const directionsServices = Object.freeze({
render,
sprites,
picking,
scenePick,
overlays,
annotations,
camera,
ground,
input,
+12 -19
View File
@@ -1,6 +1,7 @@
import test from 'node:test';
import assert from 'node:assert/strict';
import * as Cesium from 'cesium';
import { bindFakeDraw } from '../testSupport/fakeDrawPort.mjs';
import {
DEFAULT_DIRECTIONS_MODE,
DIRECTIONS_MODES,
@@ -969,7 +970,6 @@ test('a placed endpoint draws its letter through the overlay, not as entity text
const published = [];
const cleared = [];
const visibility = [];
const entities = [];
const markerVisibility = () =>
visibility
.filter(([source]) => source === DIRECTIONS_MARKER_OVERLAY_SOURCE_ID)
@@ -983,23 +983,11 @@ test('a placed endpoint draws its letter through the overlay, not as entity text
resetPointerOwnership();
const viewer = {
isDestroyed: () => false,
entities: {
add: (spec) => (entities.push(spec), spec),
remove() {},
},
scene: {
requestRender() {},
primitives: {
add: (primitive) => primitive,
remove() {},
raiseToTop() {},
lowerToBottom() {},
contains: () => true,
length: 0,
},
},
scene: { requestRender() {} },
};
const { draw, unbind } = bindFakeDraw(viewer);
t.after(() => {
unbind();
directionsLayer.destroy(viewer);
directionsLayer._setOverlayHostForTest(null);
resetPointerOwnership();
@@ -1008,9 +996,13 @@ test('a placed endpoint draws its letter through the overlay, not as entity text
assert.equal(markerVisibility(), false, 'hidden until enabled');
directionsLayer.placeEndpoint('a', { lat: 37.7955, lon: -122.3937 });
assert.equal(entities.length, 1);
assert.equal(entities[0].label, undefined, 'no Cesium label on the marker');
assert.ok(entities[0].point, 'the marker keeps its point');
const markers = [...draw.sets.values()].find(
(set) => !set.disposed && set.spec.id.endsWith(':markers'),
);
assert.deepEqual([...markers.items.keys()], ['directions:marker:A']);
const marker = markers.items.get('directions:marker:A');
assert.equal(marker.label, undefined, 'no renderer label on the marker');
assert.equal(marker.height, 'clampGround', 'a dot on the ground');
const [source, entries] = published.at(-1);
assert.equal(source, DIRECTIONS_MARKER_OVERLAY_SOURCE_ID);
assert.deepEqual(
@@ -1027,6 +1019,7 @@ test('a placed endpoint draws its letter through the overlay, not as entity text
assert.ok(Math.abs(Cesium.Math.toDegrees(anchor.latitude) - 37.7955) < 1e-9);
directionsLayer.setParams({ clear: true });
assert.equal(markers.items.size, 0, 'CLEAR takes the markers');
assert.ok(cleared.includes(DIRECTIONS_MARKER_OVERLAY_SOURCE_ID));
cleared.length = 0;
directionsLayer.destroy(viewer);
+7 -5
View File
@@ -2,11 +2,12 @@ import test from 'node:test';
import assert from 'node:assert/strict';
import * as C from 'cesium';
import { showOsmCredit, hideOsmCredit } from './dataCredits.js';
import { bindFakeCesiumCredits } from '../testSupport/fakeCreditsPort.mjs';
import { bindFakeCesiumCredits, fakeCesiumCredits } from '../testSupport/fakeCreditsPort.mjs';
import { fakeDrawPort } from '../testSupport/fakeDrawPort.mjs';
import { bindRenderer } from '../render/rendererOf.js';
import { createInfrastructureLayers } from './infrastructure.js';
import { createBhoteKoshiLocatorLayer } from './bhoteKoshiLocator.js';
import { createWorldAnnotationRenderer } from '../annotations/worldAnnotationRenderer.js';
import * as annotations from '../annotations/worldAnnotationRenderer.js';
import { createDirectionsLayer } from '../layers/directions/index.js';
import { createDirectionsSource } from '../layers/directions/source.js';
import { createLifecycle as createCctvLifecycle } from '../layers/cctv/lifecycle.js';
@@ -15,7 +16,7 @@ import { createOverpassAlprSource } from '../layers/alpr/source.js';
const noop = () => {};
const overlayHost = { setEntries: noop, setVisible: noop, clearSource: noop };
function viewer(t) {
function viewer(t, ports = null) {
t.mock.timers.enable({ apis: ['setTimeout'] });
for (const name of ['HTMLCanvasElement', 'HTMLImageElement', 'ImageBitmap', 'OffscreenCanvas']) {
const original = globalThis[name];
@@ -32,6 +33,7 @@ function viewer(t) {
scene: { requestRender: noop, canvas: { addEventListener: noop, removeEventListener: noop }, preRender: new C.Event(),
primitives: { add: (p) => p, remove: noop }, screenSpaceCameraController: { enableInputs: true } },
};
if (ports) bindRenderer(v, { credits: fakeCesiumCredits(v), ...ports });
return bindFakeCesiumCredits(v);
}
function assertCredit(v) {
@@ -64,10 +66,10 @@ test('voice route geometry introduces the shared OSM credit', (t) => {
});
test('Directions introduces the shared OSM credit when the requested route draws', async (t) => {
const v = viewer(t);
const v = viewer(t, { draw: fakeDrawPort() });
t.mock.method(globalThis, 'fetch', async () => Response.json({ ok: true, geometry: [[0, 0], [0.01, 0.01]], steps: [] }));
const layer = createDirectionsLayer({ source: createDirectionsSource(), services: {
credits: { showOsmCredit, hideOsmCredit }, annotations, input, scenePick: {}, camera: {},
credits: { showOsmCredit, hideOsmCredit }, input, camera: {},
overlays: { setOverlayEntries: noop, setOverlaySourceVisible: noop, clearOverlaySource: noop },
render: { governorRequestRender: noop, holdContinuousRender: noop, releaseContinuousRender: noop },
sprites: { registerSpriteCollection: noop, unregisterSpriteCollection: noop, restoreSpriteOrder: noop },
+189 -146
View File
@@ -16,8 +16,10 @@
* route.
*/
import * as Cesium from 'cesium';
import { roadLabel } from '../../data/routeSteps.js';
import { fromDegrees, toLonLatH } from '../../geo/ellipsoid.js';
import { hexColor } from '../../render/color.js';
import { drawOf } from '../../render/rendererOf.js';
import {
t,
msg,
@@ -78,10 +80,24 @@ export function presentRoutingFailure(error) {
export const DIRECTIONS_ROUTE_COLOR = '#39d0ff';
const MARKER_A_CSS = '#5dff9f';
const MARKER_B_CSS = '#ff6b6b';
const MARKER_A_COLOR = Cesium.Color.fromCssColorString(MARKER_A_CSS);
const MARKER_B_COLOR = Cesium.Color.fromCssColorString(MARKER_B_CSS);
const STEP_COLOR = Cesium.Color.WHITE.withAlpha(0.95);
const STEP_OUTLINE = Cesium.Color.fromCssColorString(DIRECTIONS_ROUTE_COLOR);
const MARKER_A_COLOR = hexColor(MARKER_A_CSS);
const MARKER_B_COLOR = hexColor(MARKER_B_CSS);
const MARKER_OUTLINE = [0, 0, 0, 1];
const STEP_COLOR = [1, 1, 1, 0.95];
const STEP_OUTLINE = hexColor(DIRECTIONS_ROUTE_COLOR);
/**
* The route's flowing dashes, as the voice route annotation draws them:
* 64 cells along the whole route, each lit for its first 46%, running
* toward B at 0.55 cells a second.
*/
const ROUTE_STYLE = Object.freeze({
kind: 'flow',
color: hexColor(DIRECTIONS_ROUTE_COLOR, 0.95),
repeat: 64,
duty: 0.46,
speed: 0.55,
});
const ROUTE_WIDTH_PX = 9;
const STEP_PIXEL_SIZE = 8;
const STEP_SELECTED_PIXEL_SIZE = 13;
/** Route request timeout (ms) — the proxy itself gives OSRM 12 s. */
@@ -776,7 +792,7 @@ export function directionsStepCopy(steps, index) {
/**
* Shared-host card for the selected maneuver.
* @param {number} index
* @param {Cesium.Cartesian3} position
* @param {{x: number, y: number, z: number}} position
* @param {{title:string, details:string[]}} copy
* @returns {object|null}
*/
@@ -809,7 +825,7 @@ export function createDirectionsStepOverlayEntry(index, position, copy) {
* The letter above one endpoint marker, as a world-overlay label. It is
* protected, like the step card, so it never yields to ambient labels.
* @param {'A'|'B'} letter
* @param {Cesium.Cartesian3|(() => Cesium.Cartesian3)} position
* @param {{x: number, y: number, z: number}|(() => {x: number, y: number, z: number}|null)} position
* @param {string} accent CSS colour of the marker.
*/
export function createDirectionsMarkerOverlayEntry(letter, position, accent) {
@@ -885,13 +901,16 @@ export function normalizeRoutePayload(payload, mode) {
};
}
/** Directions layers made, so each one's draw sets have ids of their own. */
let _instances = 0;
/**
* Construct one Directions layer over the application scene owners.
*
* Each catalog builds its own, so two applications on a page never share the
* route, the markers, the pointer claim or the flight this layer owns. The
* shared services are injected, which is what keeps this module's own imports
* down to Cesium and the pure step formatter.
* down to the renderer's draw port, geodesy and the pure step formatter.
* @param {{services: object, source: {getRoute: Function}}} options
* @returns {object} The layer module the data manager registers.
*/
@@ -932,10 +951,22 @@ export function createDirectionsLayer({ services, source }) {
let _routeSeq = 0;
let _routeAbort = null;
let _lastUpdate = null;
let _markerA = null;
let _markerB = null;
let _routeEntity = null;
let _stepPoints = null;
/**
* The layer's draw sets on its viewer's renderer (`drawOf`), made at
* `init`: the A and B markers, the maneuver dots and the route.
* @type {{markers: object, steps: object, route: object}|null}
*/
let _sets = null;
/** The registration of the dots in the shared sprite order. */
let _spriteEntry = null;
/** Whether a route is drawn. */
let _routeDrawn = false;
/**
* Each maneuver dot drawn, by step index: where it stands (once its ground
* cell has answered) and whether it shows.
* @type {Map<number, {pos: {x: number, y: number, z: number}, show: boolean}>}
*/
const _stepDots = new Map();
let _selectedStep = null;
let _clickSubscription = null;
let _renderHeld = false;
@@ -969,6 +1000,18 @@ export function createDirectionsLayer({ services, source }) {
// Internals
// ---------------------------------------------------------------------------
/** Let the layer's draw sets go. */
function detachSets() {
if (_spriteEntry)
services.sprites.unregisterSpriteCollection?.('directions', _spriteEntry);
_spriteEntry = null;
if (!_sets) return;
for (const set of Object.values(_sets)) set.dispose();
_sets = null;
_routeDrawn = false;
_stepDots.clear();
}
function state() {
return {
enabled: _enabled,
@@ -996,7 +1039,7 @@ export function createDirectionsLayer({ services, source }) {
}
function syncRenderHold() {
const shouldHold = _enabled && Boolean(_routeEntity);
const shouldHold = _enabled && _routeDrawn;
if (shouldHold && !_renderHeld) {
services.render.holdContinuousRender('directions');
_renderHeld = true;
@@ -1006,37 +1049,35 @@ export function createDirectionsLayer({ services, source }) {
}
}
function pickGround(screenPosition) {
const cartesian = services.scenePick.pickGroundPosition(
_viewer,
screenPosition,
);
if (!cartesian) return null;
const carto = Cesium.Cartographic.fromCartesian(cartesian);
/**
* Where a click lands on the ground, from the click's own ground pick (the
* rendered surface, else the ellipsoid; null over the sky).
* @param {{ground: () => ({x: number, y: number, z: number}|null)}} event
*/
function pickGround(event) {
const ecef = event.ground?.();
if (!ecef) return null;
const carto = toLonLatH(ecef);
if (!carto) return null;
const point = {
lat: Cesium.Math.toDegrees(carto.latitude),
lon: Cesium.Math.toDegrees(carto.longitude),
};
const point = { lat: carto.lat, lon: carto.lon };
// A pick at the ellipsoid itself is the fallback when the drawn surface
// gave no position; the floor path places that letter instead.
if (Math.abs(carto.height) > 0.01) _surfaceHeights.set(point, carto.height);
return point;
}
function markerEntity(letter, point, color) {
return _viewer.entities.add({
/** An endpoint marker: a dot on the ground, drawn over everything. */
function markerItem(letter, point, color) {
return {
id: `directions:marker:${letter}`,
position: Cesium.Cartesian3.fromDegrees(point.lon, point.lat, 0),
point: {
pixelSize: 14,
color,
outlineColor: Cesium.Color.BLACK,
outlineWidth: 2,
heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
disableDepthTestDistance: Number.POSITIVE_INFINITY,
},
});
pos: { lon: point.lon, lat: point.lat, height: 0 },
height: 'clampGround',
pixelSize: 14,
color,
outlineColor: MARKER_OUTLINE,
outlineWidth: 2,
disableDepthTest: Number.POSITIVE_INFINITY,
};
}
/**
@@ -1054,7 +1095,7 @@ export function createDirectionsLayer({ services, source }) {
_surfaceHeights.get(point) ??
services.ground.cachedGroundFloor(point.lat, point.lon);
if (!Number.isFinite(height) && !_floorSettled.has(point)) return null;
position = Cesium.Cartesian3.fromDegrees(
position = fromDegrees(
point.lon,
point.lat,
Number.isFinite(height) ? height : 0,
@@ -1085,20 +1126,13 @@ export function createDirectionsLayer({ services, source }) {
);
}
function removeEntity(entity) {
if (entity && _viewer && !_viewer.isDestroyed?.())
_viewer.entities.remove(entity);
}
function placeMarker(letter, point) {
if (!_viewer) return;
if (letter === 'a') {
removeEntity(_markerA);
_markerA = markerEntity('A', point, MARKER_A_COLOR);
} else {
removeEntity(_markerB);
_markerB = markerEntity('B', point, MARKER_B_COLOR);
}
if (!_viewer || !_sets) return;
_sets.markers.upsert([
letter === 'a'
? markerItem('A', point, MARKER_A_COLOR)
: markerItem('B', point, MARKER_B_COLOR),
]);
publishMarkerLabels();
if (_surfaceHeights.has(point)) return;
// The letter appears when its floor cell lands, even under a still camera.
@@ -1116,9 +1150,10 @@ export function createDirectionsLayer({ services, source }) {
services.credits?.hideOsmCredit?.(_viewer, 'directions');
_clearStepSelection();
stopStepAnchoring();
removeEntity(_routeEntity);
_routeEntity = null;
_stepPoints?.removeAll();
_sets?.route.clear();
_routeDrawn = false;
_stepDots.clear();
_sets?.steps.clear();
syncRenderHold();
}
@@ -1137,31 +1172,28 @@ export function createDirectionsLayer({ services, source }) {
*/
function anchorStepPoints() {
_anchorTimer = null;
if (!_stepPoints || !_route || !_enabled) return;
if (!_sets || !_route || !_enabled) return;
const steps = _route.steps;
const pending = [];
let unresolved = 0;
for (const index of stepMarkerIndices(steps)) {
const step = steps[index];
const point = findStepPoint(index);
if (!point) continue;
const dot = _stepDots.get(index);
if (!dot) continue;
const height = stepMarkerHeightM(
services.ground.cachedGroundFloor(step.lat, step.lon),
services.ground.GROUND_FLOOR_LIFT_M,
);
if (height === null) {
unresolved += 1;
point.show = false;
dot.show = false;
pending.push({ lat: step.lat, lon: step.lon });
continue;
}
point.position = Cesium.Cartesian3.fromDegrees(
step.lon,
step.lat,
height,
);
point.show = true;
dot.pos = fromDegrees(step.lon, step.lat, height);
dot.show = true;
}
drawStepDots();
// A card already open on a step that has just been anchored moves with it.
if (_selectedStep !== null) refreshStepCard(_selectedStep);
services.render.governorRequestRender('directions-anchor');
@@ -1180,45 +1212,63 @@ export function createDirectionsLayer({ services, source }) {
_anchorTimer = setTimeout(anchorStepPoints, delay);
}
/** One maneuver dot as the steps set draws it. */
function stepDotItem(index, dot) {
return {
id: `directions:step:${index}`,
pos: dot.pos,
color: STEP_COLOR,
pixelSize:
index === _selectedStep ? STEP_SELECTED_PIXEL_SIZE : STEP_PIXEL_SIZE,
outlineColor: STEP_OUTLINE,
outlineWidth: 2,
show: dot.show,
// The shared ground floor is a coarse cell, and on the photoreal stack
// the rendered mesh can stand above it. Keeping the dot always visible
// is the same choice every other anchored sprite in the app makes.
disableDepthTest: Number.POSITIVE_INFINITY,
};
}
/** Draw the maneuver dots as they now are (moved and restyled in place). */
function drawStepDots(indices = _stepDots.keys()) {
if (!_sets) return;
const items = [];
for (const index of indices) {
const dot = _stepDots.get(index);
if (dot) items.push(stepDotItem(index, dot));
}
if (items.length) _sets.steps.upsert(items);
}
function drawRoute(route) {
clearRouteGraphics();
if (!_viewer) return;
services.annotations.ensureFlowFabricRegistered();
const positions = Cesium.Cartesian3.fromDegreesArray(route.geometry.flat());
_routeEntity = _viewer.entities.add({
id: 'directions:route',
polyline: {
positions,
width: 9,
material: new services.annotations.FlowMaterialProperty(
DIRECTIONS_ROUTE_COLOR,
),
clampToGround: true,
// BOTH: drape on 3D tiles when they are up and on terrain when they are
if (!_viewer || !_sets) return;
_sets.route.set([
{
id: 'directions:route',
positions: route.geometry.map(([lon, lat]) => fromDegrees(lon, lat, 0)),
widthPx: ROUTE_WIDTH_PX,
mode: 'draped',
// Draped on 3D tiles when they are up and on terrain when they are
// not, so the keyless globe shows the route too.
classificationType: Cesium.ClassificationType.BOTH,
clampTo: 'both',
style: ROUTE_STYLE,
},
});
]);
_routeDrawn = true;
// One dot per decision; A and B already mark departure and arrival. The dots
// start hidden and appear as anchorStepPoints resolves each ground cell.
const cells = [];
const dots = [];
for (const index of stepMarkerIndices(route.steps)) {
const step = route.steps[index];
cells.push({ lat: step.lat, lon: step.lon });
_stepPoints.add({
id: `directions:step:${index}`,
position: Cesium.Cartesian3.fromDegrees(step.lon, step.lat, 0),
color: STEP_COLOR,
pixelSize: STEP_PIXEL_SIZE,
outlineColor: STEP_OUTLINE,
outlineWidth: 2,
show: false,
// The shared ground floor is a coarse cell, and on the photoreal stack
// the rendered mesh can stand above it. Keeping the dot always visible
// is the same choice every other anchored sprite in the app makes.
disableDepthTestDistance: Number.POSITIVE_INFINITY,
});
const dot = { pos: fromDegrees(step.lon, step.lat, 0), show: false };
_stepDots.set(index, dot);
dots.push(stepDotItem(index, dot));
}
_sets.steps.set(dots);
services.credits?.showOsmCredit?.(_viewer, 'directions');
services.ground.warmGroundFloor(cells);
_anchorAttempts = 0;
@@ -1411,10 +1461,7 @@ export function createDirectionsLayer({ services, source }) {
_route = null;
_status = 'idle';
_error = null;
removeEntity(_markerA);
removeEntity(_markerB);
_markerA = null;
_markerB = null;
_sets?.markers.clear();
_overlayHost.clearSource(DIRECTIONS_MARKER_OVERLAY_SOURCE_ID);
clearRouteGraphics();
services.render.governorRequestRender('directions-clear');
@@ -1506,24 +1553,12 @@ export function createDirectionsLayer({ services, source }) {
// --- Step selection ---
function _clearStepSelection() {
if (_selectedStep !== null && _stepPoints) {
const point = findStepPoint(_selectedStep);
if (point) point.pixelSize = STEP_PIXEL_SIZE;
}
const was = _selectedStep;
_selectedStep = null;
if (was !== null) drawStepDots([was]);
_overlayHost.clearSource(DIRECTIONS_STEP_OVERLAY_SOURCE_ID);
}
function findStepPoint(index) {
if (!_stepPoints) return null;
const id = `directions:step:${index}`;
for (let i = 0; i < _stepPoints.length; i += 1) {
const point = _stepPoints.get(i);
if (point.id === id) return point;
}
return null;
}
/**
* Where a step's card should hang, or null while that is not yet known.
*
@@ -1533,13 +1568,13 @@ export function createDirectionsLayer({ services, source }) {
* the same shared floor, and a step whose cell is still cold has no anchor at
* all rather than one at sea level.
* @param {number} index Step index.
* @returns {Cesium.Cartesian3|null}
* @returns {{x: number, y: number, z: number}|null}
*/
function stepAnchorPosition(index) {
const step = _route?.steps?.[index];
if (!step) return null;
const point = findStepPoint(index);
if (point?.show) return Cesium.Cartesian3.clone(point.position);
const dot = _stepDots.get(index);
if (dot?.show) return { ...dot.pos };
const height = stepMarkerHeightM(
services.ground.cachedGroundFloor(step.lat, step.lon),
services.ground.GROUND_FLOOR_LIFT_M,
@@ -1548,7 +1583,7 @@ export function createDirectionsLayer({ services, source }) {
services.ground.warmGroundFloor([{ lat: step.lat, lon: step.lon }]);
return null;
}
return Cesium.Cartesian3.fromDegrees(step.lon, step.lat, height);
return fromDegrees(step.lon, step.lat, height);
}
function refreshStepCard(index) {
@@ -1585,20 +1620,17 @@ export function createDirectionsLayer({ services, source }) {
return false;
}
_selectedStep = index;
const point = findStepPoint(index);
if (point) point.pixelSize = STEP_SELECTED_PIXEL_SIZE;
drawStepDots([index]);
services.render.governorRequestRender('directions-select');
return true;
}
function stepIndexFromPick(picked) {
const candidates = [picked?.primitive?.id, picked?.id];
for (const candidate of candidates) {
if (typeof candidate !== 'string') continue;
const match = /^directions:step:(\d+)$/.exec(candidate);
if (match) return Number(match[1]);
}
return null;
/** The step of a maneuver dot this layer draws under a click, or null. */
function stepIndexFromHit(hit) {
if (!hit || !_sets || hit.set !== _sets.steps.id) return null;
const match = /^directions:step:(\d+)$/.exec(hit.id);
const index = match ? Number(match[1]) : null;
return index !== null && _stepDots.has(index) ? index : null;
}
function _onKeyDown(event) {
@@ -1621,7 +1653,7 @@ export function createDirectionsLayer({ services, source }) {
'click',
(event) => {
if (!_enabled || !_armed) return;
const point = pickGround(event.position);
const point = pickGround(event);
if (!point) return;
placeDirectionsEndpoint(_armed, point);
},
@@ -1631,13 +1663,13 @@ export function createDirectionsLayer({ services, source }) {
// yields the moment a tool (this one included) owns the click.
const offSelect = input.onClick((event) => {
if (!_enabled) return;
let picked = null;
let hit = null;
try {
picked = event.pick;
hit = event.drawHit;
} catch {
picked = null;
hit = null;
}
const index = stepIndexFromPick(picked);
const index = stepIndexFromHit(hit);
if (index !== null) {
_selectStep(index);
return;
@@ -1672,17 +1704,31 @@ export function createDirectionsLayer({ services, source }) {
updateInterval: 0,
/**
* Create the maneuver-dot collection. Called once at bootstrap.
* @param {Cesium.Viewer} viewer
* Make the layer's draw sets on the viewer's renderer. Called once at
* bootstrap.
* @param {object} viewer
*/
init(viewer) {
_viewer = viewer;
_stepPoints = new Cesium.PointPrimitiveCollection({
blendOption: Cesium.BlendOption.TRANSLUCENT,
});
viewer.scene.primitives.add(_stepPoints);
services.sprites.registerSpriteCollection('directions', _stepPoints);
_stepPoints.show = false;
detachSets();
const draw = drawOf(viewer);
const prefix = `directions:${++_instances}`;
_sets = {
markers: draw.points({ id: `${prefix}:markers` }),
steps: draw.points({
id: `${prefix}:steps`,
blend: 'translucent',
show: false,
}),
route: draw.lines({ id: `${prefix}:route` }),
};
// Drawn from the start, empty, so the dots take their place in the
// scene now, as their collection did; their place among the other
// sprite layers is the sprite order's.
_sets.steps.set([]);
_spriteEntry =
services.sprites.registerSpriteSet?.('directions', _sets.steps.id) ??
null;
_enabled = false;
_mode = DEFAULT_DIRECTIONS_MODE;
disarm();
@@ -1700,12 +1746,12 @@ export function createDirectionsLayer({ services, source }) {
/**
* Show the row chips and listen for placement clicks.
* @param {Cesium.Viewer} viewer
* @param {object} viewer
*/
enable(viewer) {
_enabled = true;
_pointerBlocked = false;
_stepPoints.show = true;
if (_sets) _sets.steps.show = true;
_overlayHost.setVisible(DIRECTIONS_STEP_OVERLAY_SOURCE_ID, true);
_overlayHost.setVisible(DIRECTIONS_MARKER_OVERLAY_SOURCE_ID, true);
_installClickHandler(viewer);
@@ -1720,7 +1766,7 @@ export function createDirectionsLayer({ services, source }) {
/**
* Remove the route, markers and listeners.
* @param {Cesium.Viewer} viewer
* @param {object} viewer
*/
disable(viewer) {
_enabled = false;
@@ -1729,7 +1775,7 @@ export function createDirectionsLayer({ services, source }) {
_overlayHost.setVisible(DIRECTIONS_MARKER_OVERLAY_SOURCE_ID, false);
_removeClickHandler();
services.picking.unregisterPickOwner('directions');
if (_stepPoints) _stepPoints.show = false;
if (_sets) _sets.steps.show = false;
syncRenderHold();
void viewer;
},
@@ -1814,7 +1860,7 @@ export function createDirectionsLayer({ services, source }) {
/**
* Tear down entirely.
* @param {Cesium.Viewer} viewer
* @param {object} viewer
*/
destroy(viewer) {
if (_enabled) this.disable(viewer);
@@ -1827,11 +1873,8 @@ export function createDirectionsLayer({ services, source }) {
_shellSeams = null;
_dataManager = null;
_rowControlsListener = null;
if (_stepPoints) {
services.sprites.unregisterSpriteCollection('directions', _stepPoints);
viewer.scene.primitives.remove(_stepPoints);
_stepPoints = null;
}
detachSets();
void viewer;
_overlayHost.clearSource(DIRECTIONS_STEP_OVERLAY_SOURCE_ID);
_overlayHost.clearSource(DIRECTIONS_MARKER_OVERLAY_SOURCE_ID);
_viewer = null;
+143
View File
@@ -2524,3 +2524,146 @@ test('a draped flow line still drawing while its rebuilds build keeps flowing',
assert.ok(material.uniforms.time >= 0, 'and keeps its clock');
set.dispose();
}));
test('the directions layer draws its markers, flowing route and maneuver dots on a viewer of its own', async (t) => {
// Materials check their uniforms against the DOM's image classes.
const names = ['HTMLCanvasElement', 'HTMLImageElement', 'ImageBitmap', 'OffscreenCanvas'];
const real = names.map((name) => globalThis[name]);
for (const name of names) globalThis[name] ??= class {};
t.after(() => names.forEach((name, i) => (globalThis[name] = real[i])));
{
const { createDirectionsLayer } =
await import('../../layers/directions/index.js');
const { fakeInput } = await import('../../input/testDoubles.mjs');
const ownership = await import('../../data/inputOwnership.js');
const scene = fakeScene();
scene.pickResult = undefined;
scene.pick = () => scene.pickResult;
scene.drillPick = () => [];
const viewer = { scene, isDestroyed: () => false };
const clicks = fakeInput(viewer);
const noop = () => {};
const sprites = [];
const overlays = [];
const layer = createDirectionsLayer({
source: {
getRoute: async () => ({
ok: true,
distanceM: 2000,
durationS: 200,
geometry: [
[-97.74, 30.26],
[-97.73, 30.27],
[-97.72, 30.27],
],
steps: [
{ instruction: 'Depart', lat: 30.26, lon: -97.74 },
{ instruction: 'Turn left', lat: 30.27, lon: -97.73 },
{ instruction: 'Arrive', lat: 30.27, lon: -97.72 },
],
}),
},
services: {
render: {
governorRequestRender: noop,
holdContinuousRender: noop,
releaseContinuousRender: noop,
},
sprites: {
registerSpriteSet: (layerId, setId) => {
sprites.push([layerId, setId]);
return { drawSetId: setId };
},
unregisterSpriteCollection: noop,
restoreSpriteOrder: noop,
},
picking: { registerPickOwner: noop, unregisterPickOwner: noop },
overlays: {
setOverlayEntries: (source, entries) =>
overlays.push([source, entries]),
setOverlaySourceVisible: noop,
clearOverlaySource: noop,
},
ground: {
GROUND_FLOOR_LIFT_M: 2,
cachedGroundFloor: () => 150,
warmGroundFloor: noop,
resolveGroundFloorCells: async () => {},
},
input: ownership,
camera: {},
},
});
ownership.resetPointerOwnership();
// Let go even when an assertion fails, so nothing leaks into later tests.
t.after(() => {
layer.destroy(viewer);
clicks.destroy();
ownership.resetPointerOwnership();
});
layer.init(viewer);
layer.enable(viewer);
layer.placeEndpoint('a', { lat: 30.26, lon: -97.74 });
layer.placeEndpoint('b', { lat: 30.27, lon: -97.72 });
const hostOf = (suffix) =>
scene.added.find((host) => host.drawSetId?.endsWith(suffix));
// The route is asked for, then drawn.
const deadline = Date.now() + 5000;
while (!(hostOf(':route')?.length > 0) && Date.now() < deadline)
await new Promise((resolve) => setTimeout(resolve, 5));
// A and B: dots on the ground, drawn over everything.
const markers = hostOf(':markers');
assert.ok(markers instanceof Cesium.BillboardCollection);
assert.equal(markers.length, 2);
const a = markers.get(0);
assert.equal(a.id.id, 'directions:marker:A');
assert.equal(a.disableDepthTestDistance, Infinity);
assert.equal(a.heightReference, Cesium.HeightReference.CLAMP_TO_GROUND);
// The route: the annotation's flowing dashes, draped on everything.
const route = hostOf(':route');
const ground = route.get(1);
assert.ok(ground instanceof Cesium.GroundPolylinePrimitive);
assert.equal(ground.classificationType, Cesium.ClassificationType.BOTH);
assert.equal(ground.geometryInstances[0].geometry.width, 9);
assert.equal(ground.geometryInstances[0].id.id, 'directions:route');
const flow = ground.appearance.material.uniforms;
assert.deepEqual(
[flow.repeat, flow.duty, flow.speed, flow.color.alpha],
[64, 0.46, 0.55, 0.95],
);
// One maneuver dot, at its junction on the ground floor, in the sprite
// order.
const steps = hostOf(':steps');
assert.ok(steps instanceof Cesium.PointPrimitiveCollection);
assert.equal(steps.blendOption, Cesium.BlendOption.TRANSLUCENT);
assert.deepEqual(sprites, [['directions', steps.drawSetId]]);
assert.equal(steps.length, 1);
const dot = steps.get(0);
assert.equal(dot.id.id, 'directions:step:1');
assert.equal(dot.show, true);
assert.equal(dot.pixelSize, 8);
assert.equal(dot.disableDepthTestDistance, Infinity);
const at = Cesium.Cartographic.fromCartesian(dot.position);
assert.ok(Math.abs(at.height - 152) < 1e-6, 'floor plus its lift');
// A click on the dot opens its card and enlarges it, in place.
scene.pickResult = { primitive: dot, id: dot.id };
clicks.click({ x: 10, y: 10 });
assert.equal(steps.get(0), dot, 'the same point');
assert.equal(dot.pixelSize, 13);
const card = overlays.findLast(([source]) => source === 'directions-step');
assert.equal(card[1][0].id, 'directions-step-1');
// Empty map closes it.
scene.pickResult = undefined;
clicks.click({ x: 10, y: 10 });
assert.equal(dot.pixelSize, 8);
layer.disable(viewer);
assert.equal(hostOf(':markers').length, 0, 'markers cleared');
layer.destroy(viewer);
clicks.destroy();
ownership.resetPointerOwnership();
assert.equal(scene.added.length, 0, 'every set let go');
}
});
-1
View File
@@ -34,7 +34,6 @@
"src/input/sensorPick.js",
"src/layers/cctv/projection.js",
"src/layers/cctv/rendering.js",
"src/layers/directions/index.js",
"src/layers/firms/rendering.js",
"src/layers/flights/enrichment.js",
"src/layers/flights/evidence.js",
+1
View File
@@ -84,6 +84,7 @@ const DRAW_FROM_CALLER = new Set([
'./layers/street-level/kartaview',
'./layers/street-level/panoramax',
'./layers/air-quality',
'./layers/directions',
// Its data packs draw through `drawOf`; its flights ask `cameraOf`, which
// throws until then too.
'./scenes',