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`,