From 40ad27fb950c5433984c93b756b8331001484f6f Mon Sep 17 00:00:00 2001 From: Sameh Khamis Date: Sat, 7 Nov 2026 01:03:05 -0800 Subject: [PATCH] Draw Street Level's marker and cones through the renderer's draw port The photo marker and every provider's image cones are icon sets on the draw port now, not billboard collections of their own. Each keeps its pick id as the item id, so clicks route as before; each set is drawn (empty) as soon as it is made, so the cones stay drawn over the marker whichever is first given something to show. The horizon cull still runs in the layer, against the ellipsoid lowered 1,000 m, and sends only the items whose show changed; a quiet first cull of items about to be drawn replaces the flags that held its callback back. marker and sequenceCones leave the Cesium allow-list. The Panoramax line click reads the camera height from the camera port. A difference the contract does not let us avoid: the icons turn to their bearing about local north (the contract's `course`), where the billboards used the Earth's axis. Looking straight down nothing changes; in a tilted view a cone now points along its true bearing on the ground instead of leaning toward the pole. --- src/layers/streetLevel/index.test.mjs | 5 - src/layers/streetLevel/marker.js | 108 ++++++----- src/layers/streetLevel/marker.test.mjs | 130 ++++++++----- .../streetLevel/providers/kartaview/index.js | 3 +- .../providers/kartaview/provider.test.mjs | 32 ++-- .../streetLevel/providers/mapillary/index.js | 3 +- .../streetLevel/providers/panoramax/index.js | 8 +- .../providers/panoramax/provider.test.mjs | 59 +++--- src/layers/streetLevel/sequenceCones.js | 91 ++++++---- src/layers/streetLevel/sequenceCones.test.mjs | 171 +++++++++++++----- src/layers/streetLevel/state.js | 3 +- src/layers/streetLevel/view.js | 19 +- src/render/cesiumAllowList.json | 2 - src/testSupport/streetLevelFakes.mjs | 31 +++- 14 files changed, 432 insertions(+), 233 deletions(-) diff --git a/src/layers/streetLevel/index.test.mjs b/src/layers/streetLevel/index.test.mjs index 0c80e5d14..b7a0a5ac0 100644 --- a/src/layers/streetLevel/index.test.mjs +++ b/src/layers/streetLevel/index.test.mjs @@ -337,11 +337,6 @@ function fakeViewer() { flights, scene: { canvas, - primitives: { add: (p) => p, remove() {} }, - // Enough of a scene for the position marker to clamp to the ground. - frameState: { mode: Cesium.SceneMode.SCENE3D }, - updateHeight: () => () => {}, - getHeight: () => undefined, }, camera: { changed: new Cesium.Event(), diff --git a/src/layers/streetLevel/marker.js b/src/layers/streetLevel/marker.js index a61036b84..319a24bfc 100644 --- a/src/layers/streetLevel/marker.js +++ b/src/layers/streetLevel/marker.js @@ -1,10 +1,14 @@ -import * as Cesium from 'cesium'; import { positionMarkerGlyph, viewConeMarkerGlyph } from './glyphs.js'; import { COLORS, POSITION_PICK_ID } from './policy.js'; import { createHorizonCull } from './view.js'; +import { fromDegrees } from '../../geo/ellipsoid.js'; +import { drawOf } from '../../render/rendererOf.js'; const SPRITE_ID = 'street-level:marker'; +/** Draw-set ids of the markers made so far, so every layer instance has its own. */ +let markerSets = 0; + function markerLook(style) { if (style?.kind === 'view-cone') { const color = style.color || COLORS.position; @@ -21,6 +25,24 @@ function markerLook(style) { }; } +/** + * The marker's icon: clamped to the ground, turned to the bearing, drawn + * over everything near it (the horizon cull hides it past the horizon). + */ +function markerIcon(position, bearing, look) { + return { + id: POSITION_PICK_ID, + pos: { lon: position.lon, lat: position.lat }, + height: 'clampGround', + image: look.image, + size: [look.size, look.size], + rotationMode: 'course', + course: bearing || 0, + anchor: 'center', + disableDepthTest: Number.POSITIVE_INFINITY, + }; +} + /** On-globe marker for the open image, clamped to the ground. */ export function createMarker({ state }) { const { render, sprites } = state.services; @@ -29,74 +51,72 @@ export function createMarker({ state }) { render?.governorRequestRender?.('street-level-marker'); } + /** The drawn marker: `{icon, position, show}`, or null. */ + const placed = () => state.marker.placed; + // It skips the depth test: hide it while it is behind the globe. const horizon = createHorizonCull({ getViewer: () => state.viewer, - items: () => (state.marker.billboard ? [state.marker.billboard] : []), - onChange: requestRender, + items: () => (placed() ? [placed()] : []), + onChange: () => { + const marker = placed(); + if (!marker) return; + state.marker.set?.upsert([{ ...marker.icon, show: marker.show }]); + requestRender(); + }, }); function ensure(viewer) { - if (state.marker.collection) return; - state.marker.collection = new Cesium.BillboardCollection({ - scene: viewer.scene, + if (state.marker.set) return; + state.marker.set = drawOf(viewer).icons({ + id: `${SPRITE_ID}:${++markerSets}`, }); - viewer.scene.primitives.add(state.marker.collection); - sprites?.registerSpriteCollection?.(SPRITE_ID, state.marker.collection); + // Drawn from now, empty: the marker keeps its place under the cones + // (made after it), whichever is first given something to draw. + state.marker.set.set([]); + state.marker.sprite = + sprites?.registerSpriteSet?.(SPRITE_ID, state.marker.set.id) ?? null; } /** Move (or create) the marker; null removes it. `style`: the provider's `marker`. */ function set(position, bearing, style = null) { - const collection = state.marker.collection; - if (!collection) return; + const markers = state.marker.set; + if (!markers) return; if (!position) { - collection.removeAll(); - state.marker.billboard = null; + markers.clear(); + state.marker.placed = null; horizon.stop(); requestRender(); return; } - const cartesian = Cesium.Cartesian3.fromDegrees(position.lon, position.lat); const look = markerLook(style); - if (state.marker.billboard && state.marker.look !== look.key) { - collection.remove?.(state.marker.billboard); - state.marker.billboard = null; - } - if (!state.marker.billboard) { - state.marker.look = look.key; - state.marker.billboard = collection.add({ - id: POSITION_PICK_ID, - position: cartesian, - image: look.image, - imageId: `sl-position:${look.key}`, - width: look.size, - height: look.size, - alignedAxis: Cesium.Cartesian3.UNIT_Z, - heightReference: Cesium.HeightReference.CLAMP_TO_GROUND, - disableDepthTestDistance: Number.POSITIVE_INFINITY, - verticalOrigin: Cesium.VerticalOrigin.CENTER, - }); - } else { - state.marker.billboard.position = cartesian; - } - state.marker.billboard.rotation = -Cesium.Math.toRadians(bearing || 0); - horizon.update([state.marker.billboard]); + state.marker.look = look.key; + // Culled before it is drawn, so a marker past the horizon never shows. + const marker = { + position: fromDegrees(position.lon, position.lat), + show: placed()?.show ?? true, + icon: markerIcon(position, bearing, look), + }; + state.marker.placed = marker; + horizon.update([marker], { quiet: true }); + markers.upsert([{ ...marker.icon, show: marker.show }]); requestRender(); } function setVisible(visible) { - if (state.marker.collection) state.marker.collection.show = visible; + if (state.marker.set) state.marker.set.show = visible; requestRender(); } - function destroy(viewer) { + function destroy() { horizon.stop(); - const collection = state.marker.collection; - if (!collection) return; - sprites?.unregisterSpriteCollection?.(SPRITE_ID, collection); - viewer?.scene?.primitives?.remove(collection); - state.marker.collection = null; - state.marker.billboard = null; + const markers = state.marker.set; + if (!markers) return; + sprites?.unregisterSpriteCollection?.(SPRITE_ID, state.marker.sprite); + markers.dispose(); + state.marker.set = null; + state.marker.sprite = null; + state.marker.placed = null; } return { diff --git a/src/layers/streetLevel/marker.test.mjs b/src/layers/streetLevel/marker.test.mjs index 14b46a021..8667e9ae5 100644 --- a/src/layers/streetLevel/marker.test.mjs +++ b/src/layers/streetLevel/marker.test.mjs @@ -4,6 +4,7 @@ import * as Cesium from 'cesium'; import { createMarker } from './marker.js'; import { bindRenderer } from '../../render/rendererOf.js'; import { streetPorts } from '../../testSupport/streetLevelFakes.mjs'; +import { fakeDrawPort } from '../../testSupport/fakeDrawPort.mjs'; /** A viewer whose camera is 20,000 km over `view`, and its pre-render listeners. */ function setup() { @@ -16,7 +17,6 @@ function setup() { }, }, scene: { - primitives: { add: (p) => p, remove() {} }, preRender: { addEventListener(listener) { preRender.add(listener); @@ -25,91 +25,129 @@ function setup() { }, }, }; - bindRenderer(viewer, streetPorts(viewer, { camera: true })); + const draw = fakeDrawPort(); + bindRenderer(viewer, streetPorts(viewer, { camera: true, draw })); + /** Sprite-order registrations: setId → the entry handed out. */ + const sprites = new Map(); const state = { - services: {}, - viewer, - marker: { - // Stands in for the billboard collection; ensure() keeps it. - collection: { - show: true, - add: (options) => ({ ...options }), - remove() {}, - removeAll() {}, + services: { + sprites: { + registerSpriteSet(layerId, setId) { + const entry = { layerId, setId }; + sprites.set(setId, entry); + return entry; + }, + unregisterSpriteCollection(layerId, entry) { + if (sprites.get(entry?.setId) === entry) sprites.delete(entry.setId); + }, }, - billboard: null, }, + viewer, + marker: { set: null, sprite: null, placed: null, look: null }, }; const marker = createMarker({ state }); + marker.ensure(viewer); const frame = () => { for (const listener of [...preRender]) listener(); }; - return { state, view, preRender, marker, frame }; + /** The marker's drawn icon, or undefined. */ + const icon = () => draw.find('street-level:marker:')?.items.get('sl:pos'); + return { state, viewer, view, preRender, marker, frame, draw, icon, sprites }; } test('the photo marker is hidden behind the globe, and shows from its side', () => { - const { state, view, preRender, marker, frame } = setup(); + const { view, preRender, marker, frame, icon } = setup(); // Placed on the far side of the Earth from the camera. marker.set({ lon: 58.51, lat: -38.58 }, 90); - const billboard = state.marker.billboard; - assert.equal(billboard.show, false, 'not drawn through the globe'); + assert.equal(icon().show, false, 'not drawn through the globe'); // Fly round to its side: it shows. view.lon = 58.51; view.lat = -38.58; frame(); - assert.equal(billboard.show, true); + assert.equal(icon().show, true); // Moved to the far side again, without the camera moving. marker.set({ lon: -121.49, lat: 38.58 }, 0); - assert.equal(billboard.show, false, 'culled where it now stands'); + assert.equal(icon().show, false, 'culled where it now stands'); marker.clear(); + assert.equal(icon(), undefined, 'cleared'); assert.equal(preRender.size, 0, 'the cull listener is gone'); }); -test('destroying the marker stops the horizon cull', () => { - const { marker, preRender } = setup(); +test('destroying the marker stops the horizon cull and lets its set go', () => { + const { marker, preRender, draw } = setup(); marker.set({ lon: -121.49, lat: 38.58 }, 0); assert.equal(preRender.size, 1); marker.destroy(); assert.equal(preRender.size, 0); + assert.equal(draw.find('street-level:marker:'), undefined, 'disposed'); }); const SPOT = { lon: -121.49, lat: 38.58 }; test('the marker is clamped to the ground and turned to the bearing', () => { - const { state, marker } = setup(); + const { marker, icon, draw } = setup(); marker.set(SPOT, 45); - const billboard = state.marker.billboard; - assert.equal( - billboard.heightReference, - Cesium.HeightReference.CLAMP_TO_GROUND, - ); - assert.equal(billboard.rotation, -Cesium.Math.toRadians(45)); - // Moving it keeps the same billboard. + assert.equal(icon().height, 'clampGround'); + assert.equal(icon().rotationMode, 'course'); + assert.equal(icon().course, 45); + assert.equal(icon().disableDepthTest, Number.POSITIVE_INFINITY); + // Moving it keeps the one item, updated in place. marker.set({ lon: -121.5, lat: 38.6 }, 90); - assert.equal(state.marker.billboard, billboard); - const placed = Cesium.Cartographic.fromCartesian(billboard.position); - assert.ok(Math.abs(Cesium.Math.toDegrees(placed.longitude) + 121.5) < 1e-9); - assert.equal(billboard.rotation, -Cesium.Math.toRadians(90)); + const set = draw.find('street-level:marker:'); + assert.equal(set.items.size, 1); + assert.deepEqual(icon().pos, { lon: -121.5, lat: 38.6 }); + assert.equal(icon().course, 90); }); test('a Street View photo gets a blue view cone; a Mapillary photo GEV\u2019s pin', () => { - const { state, marker } = setup(); - const removed = []; - state.marker.collection.remove = (billboard) => removed.push(billboard); + const { marker, icon, state } = setup(); const streetView = { kind: 'view-cone', color: '#4285f4' }; marker.set({ lon: -121.49, lat: 38.58 }, 45, streetView); - const cone = state.marker.billboard; - assert.equal(cone.imageId, 'sl-position:view-cone:#4285f4'); - assert.equal( - cone.rotation, - -Cesium.Math.toRadians(45), - 'it turns with the view', - ); - // Dragging the panorama keeps the look and the billboard. + const cone = icon().image; + assert.equal(state.marker.look, 'view-cone:#4285f4'); + assert.deepEqual(icon().size, [48, 48]); + assert.equal(icon().course, 45, 'it turns with the view'); + // Dragging the panorama keeps the look. marker.set({ lon: -121.49, lat: 38.58 }, 90, streetView); - assert.equal(state.marker.billboard, cone); + assert.equal(icon().image, cone); // A Mapillary photo next (its provider has no marker): the pin. marker.set({ lon: -121.49, lat: 38.58 }, 90, undefined); - assert.equal(state.marker.billboard.imageId, 'sl-position:pin'); - assert.deepEqual(removed, [cone]); + assert.equal(state.marker.look, 'pin'); + assert.notEqual(icon().image, cone); + assert.deepEqual(icon().size, [40, 40]); +}); + +test('hiding the layer hides the marker set', () => { + const { marker, draw } = setup(); + marker.set(SPOT, 0); + marker.setVisible(false); + assert.equal(draw.find('street-level:marker:').show, false); + marker.setVisible(true); + assert.equal(draw.find('street-level:marker:').show, true); +}); + +test('each placement is one write, culled before it is sent', () => { + const { marker, draw, icon } = setup(); + const set = draw.find('street-level:marker:'); + const before = set.writes; + // Past the horizon: culled, and still sent once. + marker.set({ lon: 58.51, lat: -38.58 }, 0); + assert.equal(set.writes, before + 1); + assert.equal(icon().show, false); + marker.set(SPOT, 0); + assert.equal(set.writes, before + 2); +}); + +test('a marker destroyed and made again draws in a new set, registered once', () => { + const { marker, viewer, draw, sprites, icon } = setup(); + const first = draw.find('street-level:marker:').spec.id; + assert.deepEqual([...sprites.keys()], [first]); + marker.destroy(); + assert.equal(sprites.size, 0, 'its sprite order entry goes with it'); + marker.ensure(viewer); + const second = draw.find('street-level:marker:').spec.id; + assert.notEqual(second, first); + assert.deepEqual([...sprites.keys()], [second]); + marker.set(SPOT, 30); + assert.equal(icon().course, 30); }); diff --git a/src/layers/streetLevel/providers/kartaview/index.js b/src/layers/streetLevel/providers/kartaview/index.js index 6e75f967a..134a45e86 100644 --- a/src/layers/streetLevel/providers/kartaview/index.js +++ b/src/layers/streetLevel/providers/kartaview/index.js @@ -99,7 +99,8 @@ export function createKartaViewProvider({ sequence: { selectedId: null, images: [], - collection: null, + set: null, + sprite: null, loading: false, error: null, abort: null, diff --git a/src/layers/streetLevel/providers/kartaview/provider.test.mjs b/src/layers/streetLevel/providers/kartaview/provider.test.mjs index d992313bb..f73709d6c 100644 --- a/src/layers/streetLevel/providers/kartaview/provider.test.mjs +++ b/src/layers/streetLevel/providers/kartaview/provider.test.mjs @@ -15,9 +15,11 @@ import { import { validateProviders } from '../../registry.js'; import { fakeHost, until } from '../../../../testSupport/kartaViewFakes.mjs'; import { + bindStreetViewer, coverageViewer, tileCentre, } from '../../../../testSupport/streetLevelFakes.mjs'; +import { fakeDrawPort } from '../../../../testSupport/fakeDrawPort.mjs'; /** A photo record `metres` east of (42.3314, -83.0458), in sequence `seq` at `index`. */ function photoRecord(id, { metres = 0, seq = '14010', index = 0 } = {}) { @@ -411,24 +413,24 @@ async function withCones(t, env) { createElement: () => ({ getContext: () => drawing }), }; t.after(() => (globalThis.document = saved)); - let collection = null; - env.instance.init({ - scene: { - frameState: { mode: Cesium.SceneMode.SCENE3D }, - updateHeight: () => () => {}, - getHeight: () => undefined, - primitives: { add: (c) => (collection = c), remove() {} }, - preRender: { addEventListener: () => () => {} }, - }, - camera: { positionWC: new Cesium.Cartesian3(0, 0, 1e8) }, - }); + const draw = fakeDrawPort(); + env.instance.init( + bindStreetViewer( + { + scene: { preRender: { addEventListener: () => () => {} } }, + camera: { positionWC: new Cesium.Cartesian3(0, 0, 1e8) }, + }, + { draw }, + ), + ); + const drawn = () => [ + ...(draw.find('street-level:kartaview-cones:')?.items.values() ?? []), + ]; const cones = () => { - const indexes = []; - for (let i = 0; i < collection.length; i++) - indexes.push(Number(collection.get(i).id.split('-').at(-1))); + const indexes = drawn().map((cone) => Number(cone.id.split('-').at(-1))); return [Math.min(...indexes), Math.max(...indexes)]; }; - cones.count = () => collection?.length ?? 0; + cones.count = () => drawn().length; return cones; } diff --git a/src/layers/streetLevel/providers/mapillary/index.js b/src/layers/streetLevel/providers/mapillary/index.js index 928922195..0584fc542 100644 --- a/src/layers/streetLevel/providers/mapillary/index.js +++ b/src/layers/streetLevel/providers/mapillary/index.js @@ -45,7 +45,8 @@ function createProviderState(context) { sequence: { selectedId: null, images: [], - collection: null, + set: null, + sprite: null, loading: false, /** Why the selected sequence's images could not load, until it goes. */ error: null, diff --git a/src/layers/streetLevel/providers/panoramax/index.js b/src/layers/streetLevel/providers/panoramax/index.js index e855c9c72..30c307f0d 100644 --- a/src/layers/streetLevel/providers/panoramax/index.js +++ b/src/layers/streetLevel/providers/panoramax/index.js @@ -7,6 +7,7 @@ import { createSequenceCones, thinImages } from '../../sequenceCones.js'; import { passesImageryFilter } from '../../filter.js'; import { lonToTileX, latToTileY, tileBounds } from '../../tileMath.js'; import { metresBetween } from '../../view.js'; +import { findCamera } from '../../../../render/rendererOf.js'; import { createLru, createTileCache } from '../../tileCache.js'; import { decodeCoverageTileSliced, decodePictures } from './decode.js'; import { createPanoramaxSource } from './source.js'; @@ -169,7 +170,8 @@ export function createPanoramaxProvider({ sequence: { selectedId: null, images: [], - collection: null, + set: null, + sprite: null, loading: false, error: null, abort: null, @@ -256,7 +258,9 @@ export function createPanoramaxProvider({ * from high up the click may land tens of metres off the line. */ function lineClickRadius() { - const height = state.viewer?.camera?.positionCartographic?.height; + const height = state.viewer + ? findCamera(state.viewer)?.pose().height + : undefined; if (!Number.isFinite(height)) return NEAREST_RADIUS_M; return Math.min( LINE_CLICK_RADIUS_MAX_M, diff --git a/src/layers/streetLevel/providers/panoramax/provider.test.mjs b/src/layers/streetLevel/providers/panoramax/provider.test.mjs index 628805ce1..a0d28dc95 100644 --- a/src/layers/streetLevel/providers/panoramax/provider.test.mjs +++ b/src/layers/streetLevel/providers/panoramax/provider.test.mjs @@ -16,9 +16,11 @@ import { validateProviders } from '../../registry.js'; import { tileBounds } from '../../tileMath.js'; import { fakeHost, until } from '../../../../testSupport/kartaViewFakes.mjs'; import { + bindStreetViewer, coverageViewer, tileCentre, } from '../../../../testSupport/streetLevelFakes.mjs'; +import { fakeDrawPort } from '../../../../testSupport/fakeDrawPort.mjs'; import { encodePanoramaxTile, stacItem, @@ -357,23 +359,22 @@ async function withCones(t, env) { createElement: () => ({ getContext: () => drawing }), }; t.after(() => (globalThis.document = saved)); - let collection = null; - env.instance.init({ - scene: { - frameState: { mode: Cesium.SceneMode.SCENE3D }, - updateHeight: () => () => {}, - getHeight: () => undefined, - primitives: { add: (c) => (collection = c), remove() {} }, - preRender: { addEventListener: () => () => {} }, - }, - camera: { positionWC: new Cesium.Cartesian3(0, 0, 1e8) }, - }); + const draw = fakeDrawPort(); + env.instance.init( + bindStreetViewer( + { + scene: { preRender: { addEventListener: () => () => {} } }, + camera: { positionWC: new Cesium.Cartesian3(0, 0, 1e8) }, + }, + { draw }, + ), + ); + const drawn = () => [ + ...(draw.find('street-level:panoramax-cones:')?.items.values() ?? []), + ]; return { - count: () => collection?.length ?? 0, - ids: () => - Array.from({ length: collection?.length ?? 0 }, (_, i) => - String(collection.get(i).id).replace(PICK_PREFIX.image, ''), - ), + count: () => drawn().length, + ids: () => drawn().map((cone) => cone.id.replace(PICK_PREFIX.image, '')), }; } @@ -455,13 +456,12 @@ test('a line clicked from high up looks for its sequence further off; the radius ]; const { instance, source } = setup({ items }); const height = (h) => - instance.init({ - camera: { positionCartographic: { height: h } }, - scene: { - primitives: { add() {}, remove() {} }, - preRender: { addEventListener: () => () => {} }, - }, - }); + instance.init( + bindStreetViewer({ + camera: { positionCartographic: { height: h } }, + scene: { preRender: { addEventListener: () => () => {} } }, + }), + ); const click = () => instance.handlePick(`${PICK_PREFIX.sequence}line`, { groundPoint: () => east(0), @@ -821,13 +821,12 @@ test('a line clicked from low down still searches its own sequence within 50 m', ...sequence('clicked', 1, { offset: 30 }), ]; const { instance, source } = setup({ items }); - instance.init({ - camera: { positionCartographic: { height: 300 } }, - scene: { - primitives: { add() {}, remove() {} }, - preRender: { addEventListener: () => () => {} }, - }, - }); + instance.init( + bindStreetViewer({ + camera: { positionCartographic: { height: 300 } }, + scene: { preRender: { addEventListener: () => () => {} } }, + }), + ); instance.handlePick(`${PICK_PREFIX.sequence}clicked`, { groundPoint: () => east(0), }); diff --git a/src/layers/streetLevel/sequenceCones.js b/src/layers/streetLevel/sequenceCones.js index b6c068d49..513451fc4 100644 --- a/src/layers/streetLevel/sequenceCones.js +++ b/src/layers/streetLevel/sequenceCones.js @@ -1,12 +1,23 @@ -import * as Cesium from 'cesium'; import { imageConeGlyph } from './glyphs.js'; import { passesImageryFilter } from './filter.js'; import { createHorizonCull, metresBetween } from './view.js'; import { msg } from '../../i18n/index.js'; +import { fromDegrees } from '../../geo/ellipsoid.js'; +import { drawOf } from '../../render/rendererOf.js'; /** Cones closer than this to the previous kept one are dropped. */ const IMAGE_CONE_MIN_SPACING_M = 3; const IMAGE_CONE_SIZE_PX = 26; +/** Cones a little larger near the eye, a third of their size far off. */ +const IMAGE_CONE_SCALE = Object.freeze({ + near: 200, + nearValue: 1.1, + far: 6000, + farValue: 0.35, +}); + +/** Draw-set ids of the cone sets made so far, so every provider instance has its own. */ +let coneSets = 0; /** * @typedef {object} ConeImage One image of a sequence, as the cones draw it. @@ -43,7 +54,7 @@ export function thinImages(images, spacingM = IMAGE_CONE_MIN_SPACING_M) { * The sequence's images in capture order, thinned (see `thinImages`). * @param {{coverage: string}} options.colors * @param {string} options.pickPrefix Pick-id prefix of the cones. - * @param {string} options.spriteId Sprite-order id of the cone collection. + * @param {string} options.spriteId Sprite-order id of the cone set (and its draw-set id's stem). * @param {string} options.renderKey Render-governor reason. * @param {(sequenceId: string|null) => void} [options.onHighlight] * Highlight the sequence's coverage line (null: none). @@ -70,37 +81,42 @@ export function createSequenceCones({ state.context.notify(); } - /** Drawn cone billboards. */ + /** Drawn cones: `{icon, position, show}` each, `icon` as last sent. */ let cones = []; // The cones skip the depth test: hide the ones behind the globe. const horizon = createHorizonCull({ getViewer: () => state.viewer, items: () => cones, - onChange: requestRender, + onChange: (changed) => { + state.sequence.set?.upsert( + changed.map((cone) => ({ ...cone.icon, show: cone.show })), + ); + requestRender(); + }, }); function ensureCollections(viewer) { - if (state.sequence.collection) return; - state.sequence.collection = new Cesium.BillboardCollection({ - scene: viewer.scene, + if (state.sequence.set) return; + state.sequence.set = drawOf(viewer).icons({ + id: `${spriteId}:${++coneSets}`, }); - viewer.scene.primitives.add(state.sequence.collection); - sprites?.registerSpriteCollection?.(spriteId, state.sequence.collection); + // Drawn from now, empty: the cones keep their place over the marker. + state.sequence.set.set([]); + state.sequence.sprite = + sprites?.registerSpriteSet?.(spriteId, state.sequence.set.id) ?? null; } function clearCones() { - state.sequence.collection?.removeAll(); + state.sequence.set?.clear(); state.sequence.images = []; cones = []; horizon.stop(); } function renderCones(images) { - const collection = state.sequence.collection; - if (!collection) return; - collection.removeAll(); - cones = []; + const set = state.sequence.set; + if (!set) return; // One colour per source; 360° images keep the ring shape. const cone = imageConeGlyph({ size: 32, color: colors.coverage }); const ring = imageConeGlyph({ @@ -110,25 +126,29 @@ export function createSequenceCones({ }); // Resolved now, so a "since N days" window keeps up with the clock. const filter = state.context.getFilter(); + cones = []; for (const image of images) { if (!passes(image, filter)) continue; - const billboard = collection.add({ - id: `${pickPrefix}${image.id}`, - position: Cesium.Cartesian3.fromDegrees(image.lon, image.lat), - heightReference: Cesium.HeightReference.CLAMP_TO_GROUND, - image: image.isPano ? ring : cone, - imageId: image.isPano ? `${spriteId}:pano` : `${spriteId}:flat`, - width: IMAGE_CONE_SIZE_PX, - height: IMAGE_CONE_SIZE_PX, - rotation: -Cesium.Math.toRadians(image.compassAngle), - alignedAxis: Cesium.Cartesian3.UNIT_Z, - disableDepthTestDistance: Number.POSITIVE_INFINITY, - verticalOrigin: Cesium.VerticalOrigin.CENTER, - scaleByDistance: new Cesium.NearFarScalar(200, 1.1, 6000, 0.35), + cones.push({ + position: fromDegrees(image.lon, image.lat), + show: true, + icon: { + id: `${pickPrefix}${image.id}`, + pos: { lon: image.lon, lat: image.lat }, + height: 'clampGround', + image: image.isPano ? ring : cone, + size: [IMAGE_CONE_SIZE_PX, IMAGE_CONE_SIZE_PX], + rotationMode: 'course', + course: image.compassAngle, + anchor: 'center', + disableDepthTest: Number.POSITIVE_INFINITY, + scaleByDistance: IMAGE_CONE_SCALE, + }, }); - cones.push(billboard); } - horizon.update(); + // Culled before they are drawn, so far-side cones never show. + horizon.update(cones, { quiet: true }); + set.set(cones.map((item) => ({ ...item.icon, show: item.show }))); requestRender(); } @@ -202,7 +222,7 @@ export function createSequenceCones({ } function setVisible(visible) { - if (state.sequence.collection) state.sequence.collection.show = visible; + if (state.sequence.set) state.sequence.set.show = visible; requestRender(); } @@ -210,11 +230,12 @@ export function createSequenceCones({ state.sequence.abort?.abort(); horizon.stop(); cones = []; - const collection = state.sequence.collection; - if (collection) { - sprites?.unregisterSpriteCollection?.(spriteId, collection); - viewer?.scene?.primitives?.remove(collection); - state.sequence.collection = null; + const set = state.sequence.set; + if (set) { + sprites?.unregisterSpriteCollection?.(spriteId, state.sequence.sprite); + set.dispose(); + state.sequence.set = null; + state.sequence.sprite = null; } state.sequence.images = []; state.sequence.selectedId = null; diff --git a/src/layers/streetLevel/sequenceCones.test.mjs b/src/layers/streetLevel/sequenceCones.test.mjs index 7ec95cfa3..865d12324 100644 --- a/src/layers/streetLevel/sequenceCones.test.mjs +++ b/src/layers/streetLevel/sequenceCones.test.mjs @@ -3,25 +3,38 @@ import test from 'node:test'; import * as Cesium from 'cesium'; import { resolveFilter } from './filter.js'; import { createSequenceCones, thinImages } from './sequenceCones.js'; +import { createMarker } from './marker.js'; +import { createCesiumDraw } from '../../render/cesium/draw.js'; import { bindRenderer } from '../../render/rendererOf.js'; import { streetPorts } from '../../testSupport/streetLevelFakes.mjs'; +import { fakeDrawPort } from '../../testSupport/fakeDrawPort.mjs'; const settle = () => new Promise((resolve) => setTimeout(resolve, 0)); -/** A billboard collection that remembers the cones on the globe. */ -function cones() { - const items = []; - return { - items, - show: true, - add(options) { - items.push(options); - return options; +/** + * A viewer 20,000 km over `view` (mutable), bound to a fake draw port and + * the camera and frame ports, with its pre-render listeners. + */ +function coneViewer({ draw = fakeDrawPort() } = {}) { + const view = { lon: -121.49, lat: 38.58, height: 20_000_000 }; + const preRender = new Set(); + const viewer = { + camera: { + get positionWC() { + return Cesium.Cartesian3.fromDegrees(view.lon, view.lat, view.height); + }, }, - removeAll() { - items.length = 0; + scene: { + preRender: { + addEventListener(listener) { + preRender.add(listener); + return () => preRender.delete(listener); + }, + }, }, }; + bindRenderer(viewer, streetPorts(viewer, { camera: true, draw })); + return { viewer, view, preRender, draw }; } /** A source whose sequence lookups the test answers, one call at a time. */ @@ -51,13 +64,16 @@ function records(sequenceId, count = 2) { })); } -function setup() { +function setup({ draw: port } = {}) { const source = deferredSource(); /** Every highlight asked of the coverage: a sequence id, or null for none. */ const highlights = []; + const { viewer, view, preRender, draw } = coneViewer( + port ? { draw: port } : {}, + ); const state = { services: {}, - viewer: {}, + viewer, filter: { pano: 'all', sinceDays: 0 }, context: { getFilter: () => resolveFilter(state.filter), @@ -66,7 +82,8 @@ function setup() { sequence: { selectedId: null, images: [], - collection: cones(), + set: null, + sprite: null, loading: false, error: null, abort: null, @@ -93,9 +110,24 @@ function setup() { renderKey: 'test-sequence', onHighlight: (id) => highlights.push(id), }); - const drawn = () => - state.sequence.collection.items.map((cone) => cone.id.split(':').at(-1)); - return { state, source, sequences, highlights, drawn }; + sequences.ensureCollections(viewer); + /** The drawn cones, in the order sent. */ + const cones = () => [ + ...(draw.find('street-level:test-cones:')?.items.values() ?? []), + ]; + const drawn = () => cones().map((cone) => cone.id.split(':').at(-1)); + return { + state, + viewer, + source, + sequences, + highlights, + drawn, + cones, + draw, + view, + preRender, + }; } test('a failed sequence load leaves no stale cones and can be retried', async () => { @@ -163,38 +195,33 @@ test('clearSelection cancels the lookup and drops the highlight', async () => { }); test('cones are clamped to the ground and turned to their compass angle', async () => { - const { state, source, sequences } = setup(); + const { source, sequences, cones } = setup(); sequences.select('A'); source.last('A').resolve(records('A', 2)); await settle(); - const items = state.sequence.collection.items; + const items = cones(); assert.equal(items.length, 2); for (const cone of items) { - assert.equal(cone.heightReference, Cesium.HeightReference.CLAMP_TO_GROUND); - assert.equal(cone.rotation, -Cesium.Math.toRadians(90)); + assert.equal(cone.height, 'clampGround'); + assert.equal(cone.rotationMode, 'course'); + assert.equal(cone.course, 90); + assert.equal(cone.disableDepthTest, Number.POSITIVE_INFINITY); + assert.deepEqual(cone.scaleByDistance, { + near: 200, + nearValue: 1.1, + far: 6000, + farValue: 0.35, + }); } + assert.deepEqual( + items.map((cone) => cone.id), + ['mly:img:A-0', 'mly:img:A-1'], + 'each picks as its image', + ); }); test('cones behind the globe are hidden, and show again from the other side', async () => { - const { state, source, sequences } = setup(); - const view = { lon: -121.49, lat: 38.58, height: 20_000_000 }; - const preRender = new Set(); - state.viewer = { - camera: { - get positionWC() { - return Cesium.Cartesian3.fromDegrees(view.lon, view.lat, view.height); - }, - }, - scene: { - preRender: { - addEventListener(listener) { - preRender.add(listener); - return () => preRender.delete(listener); - }, - }, - }, - }; - bindRenderer(state.viewer, streetPorts(state.viewer, { camera: true })); + const { source, sequences, cones, view, preRender } = setup(); sequences.select('A'); // One image under the camera, one near its antipode. source.last('A').resolve([ @@ -206,15 +233,77 @@ test('cones behind the globe are hidden, and show again from the other side', as }, ]); await settle(); - const [near, far] = state.sequence.collection.items; + let [near, far] = cones(); assert.equal(near.show, true, 'the near side stays visible'); assert.equal(far.show, false, 'the far side does not show through'); // Fly round to the other hemisphere: the two swap. view.lon = 58.51; view.lat = -38.58; for (const listener of [...preRender]) listener(); + [near, far] = cones(); assert.equal(near.show, false); assert.equal(far.show, true); sequences.clearSelection(); + assert.equal(cones().length, 0); assert.equal(preRender.size, 0, 'the cull listener is gone'); }); + +test('hiding and destroying the cones show and dispose their set', async () => { + const { source, sequences, draw, state } = setup(); + sequences.select('A'); + source.last('A').resolve(records('A')); + await settle(); + const set = draw.find('street-level:test-cones:'); + sequences.setVisible(false); + assert.equal(set.show, false); + sequences.setVisible(true); + assert.equal(set.show, true); + sequences.destroy(); + assert.equal(set.disposed, true); + assert.equal(state.sequence.set, null); +}); + +test('the cones stay drawn over the photo marker, whichever is drawn first', async () => { + const added = []; + const scene = { + camera: { positionWC: new Cesium.Cartesian3(2e7, 0, 0) }, + frameState: { mode: Cesium.SceneMode.SCENE3D }, + updateHeight: () => () => {}, + getHeight: () => undefined, + primitives: { + add: (primitive) => (added.push(primitive), primitive), + remove: (primitive) => { + const at = added.indexOf(primitive); + if (at >= 0) added.splice(at, 1); + return at >= 0; + }, + get length() { + return added.length; + }, + get: (i) => added[i], + }, + requestRender() {}, + }; + const { port } = createCesiumDraw({ + scene, + report: (error) => assert.fail(error), + }); + const { state, viewer, source, sequences } = setup({ draw: port }); + // As the layer starts: the marker's set first, then each provider's cones. + const marker = createMarker({ + state: Object.assign(state, { + marker: { set: null, sprite: null, placed: null, look: null }, + }), + }); + marker.ensure(viewer); + sequences.ensureCollections(viewer); + // A sequence selected before any photo opens: its cones draw first. + sequences.select('A'); + source.last('A').resolve(records('A')); + await settle(); + marker.set({ lon: -121.49, lat: 38.58 }, 90); + const order = added.map((host) => host.get(0)?.id?.id ?? null); + assert.deepEqual(order, ['sl:pos', 'mly:img:A-0'], 'bottom to top'); + sequences.destroy(viewer); + marker.destroy(); +}); diff --git a/src/layers/streetLevel/state.js b/src/layers/streetLevel/state.js index 268cc00b1..bf958c48a 100644 --- a/src/layers/streetLevel/state.js +++ b/src/layers/streetLevel/state.js @@ -55,7 +55,8 @@ export function createState({ services }) { /** Whether the camera is low enough for a ground click to open an image. */ groundClickReady: false, - marker: { collection: null, billboard: null, look: null }, + /** The open image's marker: its draw set, sprite registration and drawn icon. */ + marker: { set: null, sprite: null, placed: null, look: null }, clickSubscription: null, }; } diff --git a/src/layers/streetLevel/view.js b/src/layers/streetLevel/view.js index 3f295e982..d395d05c3 100644 --- a/src/layers/streetLevel/view.js +++ b/src/layers/streetLevel/view.js @@ -224,8 +224,11 @@ export function createHorizonCull({ getViewer, items, onChange }) { let from = null; let stopListening = null; - /** Show what is in front of the horizon, hide the rest; the count seen. */ - function cull(list, position) { + /** + * Show what is in front of the horizon, hide the rest; the count seen. + * `quiet`: `onChange` is not told (the caller draws them next anyway). + */ + function cull(list, position, quiet = false) { const horizon = horizonFrom(position, HORIZON_CULL_ELLIPSOID); let seen = 0; const changed = []; @@ -237,7 +240,7 @@ export function createHorizonCull({ getViewer, items, onChange }) { changed.push(item); } } - if (changed.length) onChange?.(changed); + if (changed.length && !quiet) onChange?.(changed); return seen; } @@ -256,11 +259,15 @@ export function createHorizonCull({ getViewer, items, onChange }) { if (!cullAll(position)) stop(); } - /** Cull `added` items (or all) now, then all again whenever the camera moves. */ - function update(added) { + /** + * Cull `added` items (or all) now, then all again whenever the camera + * moves. `quiet`: this first cull of `added` does not call `onChange`, + * for items about to be drawn with their `show`. + */ + function update(added, { quiet = false } = {}) { const viewer = getViewer(); const position = eyeOf(viewer); - if (position && !(added ? cull(added, position) : cullAll(position))) + if (position && !(added ? cull(added, position, quiet) : cullAll(position))) return; stopListening ||= (viewer && findFrame(viewer)?.on('preRender', onPreRender)) || null; diff --git a/src/render/cesiumAllowList.json b/src/render/cesiumAllowList.json index 3c44335b3..b02df8523 100644 --- a/src/render/cesiumAllowList.json +++ b/src/render/cesiumAllowList.json @@ -87,8 +87,6 @@ "src/layers/satellites/testing.js", "src/layers/satellites/tracking.js", "src/layers/streetLevel/lineCoverage.js", - "src/layers/streetLevel/marker.js", - "src/layers/streetLevel/sequenceCones.js", "src/layers/traffic/animation.js", "src/layers/traffic/lifecycle.js", "src/layers/traffic/rendering.js", diff --git a/src/testSupport/streetLevelFakes.mjs b/src/testSupport/streetLevelFakes.mjs index 5337c0d4c..d8b6da6d0 100644 --- a/src/testSupport/streetLevelFakes.mjs +++ b/src/testSupport/streetLevelFakes.mjs @@ -1,6 +1,8 @@ /** Shared Street Level test stand-ins: provider snapshot and provider, Mapillary source, photo viewer, Cesium viewer, ray-casting camera. */ import * as Cesium from 'cesium'; import { bindFakeCesiumCamera } from './fakeCameraPort.mjs'; +import { fakeDrawPort } from './fakeDrawPort.mjs'; +import { bindRenderer } from '../render/rendererOf.js'; import { MAPILLARY_CREDIT_HTML } from '../layers/streetLevel/providers/mapillary/policy.js'; import { latToTileY, @@ -284,12 +286,16 @@ export function rayCamera({ * through what its `pickEllipsoid` hits), heights from its scene's * `sampleHeight` (3D tiles: only while its globe is hidden) and its * globe's `getHeight` (terrain), and pre-render from its scene's - * `preRender`. `draw` adds a draw port. For `bindFakeCesiumCamera`'s - * `ports`. + * `preRender`; drawing goes to `draw` (a fake draw port by default), and + * with `camera` the camera is `liveCamera`'s. For `bindFakeCesiumCamera`'s + * `ports`, or `bindRenderer`. * @param {object} viewer * @param {{draw?: object}} [options] */ -export function streetPorts(viewer, { draw, camera = false } = {}) { +export function streetPorts( + viewer, + { draw = fakeDrawPort(), camera = false } = {}, +) { const finite = (height) => (Number.isFinite(height) ? height : null); const cartographic = ({ lon, lat }) => ({ longitude: lon * RAD, @@ -328,11 +334,28 @@ export function streetPorts(viewer, { draw, camera = false } = {}) { return event?.addEventListener?.(cb) ?? (() => {}); }, }, - ...(draw ? { draw } : {}), + draw, ...(camera ? { camera: liveCamera(viewer) } : {}), }; } +/** + * Bind `viewer` (a Cesium-shaped double) to `streetPorts` with its live + * camera, as the app binds its renderer; `draw` is the draw port it draws + * through (a fake one by default). Returns the viewer. + * @template V + * @param {V} viewer + * @param {{draw?: object}} [options] + * @returns {V} + */ +export function bindStreetViewer(viewer, { draw } = {}) { + bindRenderer( + viewer, + streetPorts(viewer, { camera: true, ...(draw ? { draw } : {}) }), + ); + return viewer; +} + /** * A camera port over whatever camera double `viewer.camera` is when asked * (tests swap it): its pose from `positionCartographic` and `positionWC`,