diff --git a/docs/INFRASTRUCTURE-LAYERS.md b/docs/INFRASTRUCTURE-LAYERS.md index 9c358f487..b2dd78567 100644 --- a/docs/INFRASTRUCTURE-LAYERS.md +++ b/docs/INFRASTRUCTURE-LAYERS.md @@ -56,7 +56,11 @@ Cesium viewer with no renderer bound loads `gods-eye-view/render/cesium/unbound` once first; until then the layer reports an error naming it, as it does for a dataset it cannot load. A selected feature is the context record its draw item carries as `meta`; the -layer no longer sets the viewer's `selectedEntity`. +layer no longer sets the viewer's `selectedEntity`. While the renderer's own +double-click follow is on, a double-click follows a point or polygon through +the camera port, looking at the centre of what it draws (stem included), framed +as the default renderer framed an entity it began following, and zooms to a +line, which has no stem to follow. Features keep their own simplestyle `fill`, `fill-opacity`, `stroke`, `stroke-opacity`, `stroke-width`, `marker-color` and `marker-size`, given as hex, `rgb()` or `hsl()` colours or by the CSS colour names the default renderer diff --git a/src/data/infrastructure.test.mjs b/src/data/infrastructure.test.mjs index 15d116ba5..be8e196f1 100644 --- a/src/data/infrastructure.test.mjs +++ b/src/data/infrastructure.test.mjs @@ -207,6 +207,7 @@ test('consumer build includes only infrastructure code and resolves assets under 'drawHit.js', 'ellipsoid.js', 'follow.js', + 'frames.js', 'geojsonPins.js', 'heights.js', 'infrastructure.js', diff --git a/src/data/localGeojsonCore.js b/src/data/localGeojsonCore.js index 589f4f182..e55a87bfc 100644 --- a/src/data/localGeojsonCore.js +++ b/src/data/localGeojsonCore.js @@ -8,7 +8,13 @@ import { findQuery, } from '../render/rendererOf.js'; import { cssColor } from '../render/color.js'; -import { fromDegrees, fromDegreesInto, toLonLatH } from '../geo/ellipsoid.js'; +import { + WGS84, + fromDegrees, + fromDegreesInto, + toLonLatH, +} from '../geo/ellipsoid.js'; +import { offsetFromHeadingPitchRange } from '../geo/frames.js'; import { sphereFromPoints } from '../geo/sphere.js'; import { densifyRhumb } from '../geo/rhumb.js'; import { heightsOf } from '../queries/heights.js'; @@ -315,6 +321,34 @@ const STEM_WIDTH_PX = 3.5; const PIN_SIZE_PX = 8; const BLACK = Object.freeze([0, 0, 0, 1]); +/** The range the default renderer frames a sphere of no size from. */ +const MINIMUM_FIT_RANGE_M = 100; + +/** + * Where the camera frames a part it starts following, as the default + * renderer framed an entity it started following with no view of its own: + * looking at the bounds' centre, heading north, pitched down 45° (steeper + * far from the ground), at the range that fits the bounds in view, within + * the camera's zoom limits. Returned as the eye's offset from the centre, + * east-north-up there; `at` is where the part stands. + */ +function followViewFrom(sphere, at, camera) { + const pose = camera.pose?.(); + const fovy = Number.isFinite(pose?.fovy) ? pose.fovy : Math.PI / 3; + const aspect = Number.isFinite(pose?.aspectRatio) ? pose.aspectRatio : 1; + const tanPhi = Math.tan(fovy / 2); + const tanTheta = aspect * tanPhi; + let range = + sphere.radius === 0 + ? MINIMUM_FIT_RANGE_M + : Math.max(sphere.radius / tanTheta, sphere.radius / tanPhi); + const { minDistance = 0, maxDistance = Infinity } = camera.controls ?? {}; + range = Math.min(Math.max(range, minDistance), maxDistance); + const factor = + 2 - 1 / Math.max(1, Math.hypot(at.x, at.y, at.z) / WGS84.radii.x); + return offsetFromHeadingPitchRange(0, (-Math.PI / 4) * factor, range); +} + /** The GeoJSON loader's `marker-size` names, in pixels. */ const MARKER_SIZES = Object.freeze({ small: 24, medium: 48, large: 64 }); /** @@ -544,6 +578,9 @@ export function createLocalGeoJsonLayer( let _drawn = null; let _enabled = false; let _clickSubscription = null; + let _dblclickSubscription = null; + /** The follow a double-click started, while the camera keeps it. */ + let _follow = null; let _count = 0; /** @type {number|null} Timestamp of the last successful dataset load. */ let _lastUpdate = null; @@ -681,6 +718,9 @@ export function createLocalGeoJsonLayer( _lastLodBudgetLimit = 0; _lodComputed = false; _lastLodProbeMs = Number.NEGATIVE_INFINITY; + // Its parts go, and the follow of one with them, as a removed entity + // stopped being followed. + stopFollow(viewer); releaseDrawn(); _overlayPublisher.hide(); clearSelectedEntityContextForLayer(id); @@ -886,6 +926,78 @@ export function createLocalGeoJsonLayer( if (pins.length) drawn.sets.pins.upsert(pins); } + /** + * Follow the part under `position`: a part with a stem by the centre of + * all it draws, stem and all, as the default renderer followed the + * loader's entity by its bounds, framed as that renderer framed an entity + * it started following; a line, which had no position to + * follow, is flown into view instead. + */ + function followAt(viewer, position) { + const hit = findQuery(viewer)?.pick(position.x, position.y); + if (!hit || !hit.set?.startsWith(`${setPrefix}:`)) return; + const part = _drawn?.parts.get(hit.id); + if (!part) return; + const camera = findCamera(viewer); + if (!camera) return; + const points = framedPoints(part); + if (!points.length) return; + const record = part.carrier.record; + try { + if (!record) { + // As the default renderer zoomed to an entity with no position: at + // once, north up, pitched down 45°, at the range that fits it in + // view (the camera port's defaults). + const sphere = sphereFromPoints(points); + // Following nothing then, as that zoom stopped any follow first. + if (camera.followed) camera.follow(null); + camera.flyToBounds(sphere, { durationS: 0 }); + return; + } + // The camera looks at the bounds' centre, kept where the stem now + // stands, as the default renderer kept its entity's bounds. + const outline = framedPoints(part, false); + const centre = () => + sphereFromPoints([...outline, record.base, record.tip]).center; + const target = { + key: `${id}:${record.id}`, + position: centre, + frame: 'enu', + viewFrom: followViewFrom(sphereFromPoints(points), record.tip, camera), + }; + camera.follow(target); + _follow = target; + } catch (error) { + // A camera that cannot follow (a viewer without entity tracking) + // leaves the view where it is, as that viewer's double-click did. + console.warn(`${id}: cannot follow`, error); + } + } + + /** + * What the default renderer framed for a part: all it drew of it (but + * for its stem, without `withStem`). + */ + function framedPoints(part, withStem = true) { + const record = part.carrier.record; + const points = []; + if (part.kind === 'polygon') + for (const { lon, lat, height } of part.rings[0]) + points.push(fromDegrees(lon, lat, height ?? 0)); + else if (part.kind === 'line') + for (const [lon, lat] of part.coordinates) + points.push(fromDegrees(lon, lat, 0)); + if (record && withStem) points.push(copy(record.base), copy(record.tip)); + return points; + } + + /** Stop a follow this layer started, if the camera still keeps it. */ + function stopFollow(viewer) { + const camera = findCamera(viewer); + if (_follow && camera?.followed === _follow) camera.follow(null); + _follow = null; + } + /** Fly to where a clicked part stands, holding camera input meanwhile. */ function flyToPart(viewer, input, part) { const target = part.carrier.record @@ -1064,6 +1176,19 @@ export function createLocalGeoJsonLayer( flyToPart(viewer, input, part); }); } + // 3. Follow a part on a double-click, as the default renderer's + // own double-click followed the loader's entities. + if (!_dblclickSubscription) { + const input = inputFor(viewer); + _dblclickSubscription = + input.onPointer?.('dblclick', (event) => { + if (!_enabled || !_drawn) return; + // The renderer's own double-click follow, off while a + // tool holds it or on a renderer without one. + if (input.stockEnabled?.('dblclickFollow') !== true) return; + followAt(viewer, event.position); + }) ?? null; + } })(); try { await _loadPromise; @@ -1305,6 +1430,8 @@ export function createLocalGeoJsonLayer( removeEntityContextsForLayer(id); _clickSubscription?.(); _clickSubscription = null; + _dblclickSubscription?.(); + _dblclickSubscription = null; _overlayPublisher.destroy(); _cachedFeatures = null; pinMaker.clear(); diff --git a/src/data/localGeojsonDraw.test.mjs b/src/data/localGeojsonDraw.test.mjs index 49ad98a59..f52c86c89 100644 --- a/src/data/localGeojsonDraw.test.mjs +++ b/src/data/localGeojsonDraw.test.mjs @@ -8,6 +8,8 @@ import { localGeoJsonServices } from '../app/localGeojsonServices.js'; import { getContextStore } from './contextStore.js'; import { readEntityRecord } from './entityRecords.js'; import { bindFakeGroundRenderer } from '../testSupport/fakeGroundRenderer.mjs'; +import { distance, normalize, sub } from '../geo/vector.js'; +import { eastNorthUp, framePoint, inverseFrameVector } from '../geo/frames.js'; const feature = (id, geometry, properties = { name: `Feature ${id}` }) => ({ type: 'Feature', @@ -80,6 +82,8 @@ async function enabledLayer(t, features) { eye: { lon: 0.005, lat: 0.005, height: 50_000 }, }); let click = null; + let dblclick = null; + const stock = { dblclickFollow: true }; const holds = []; const layer = createLocalGeoJsonLayer( { @@ -99,6 +103,14 @@ async function enabledLayer(t, features) { holds.push(reason); return () => holds.push(`release:${reason}`); }, + onPointer: (type, handler) => { + assert.equal(type, 'dblclick'); + dblclick = handler; + return () => { + dblclick = null; + }; + }, + stockEnabled: (name) => stock[name] === true, }), }, { @@ -117,7 +129,16 @@ async function enabledLayer(t, features) { if (originalWindow === undefined) delete globalThis.window; else globalThis.window = originalWindow; }); - return { layer, viewer, fake, holds, click: (event) => click?.(event) }; + return { + layer, + viewer, + fake, + holds, + stock, + click: (event) => click?.(event), + dblclick: (event) => dblclick?.(event), + subscribed: () => dblclick !== null, + }; } test('polygons fill the ground, lines drape, points stand on pins, all shown', async (t) => { @@ -387,3 +408,99 @@ test('a marker-symbol is stamped on its pin: a character as text, a longer one a assert.match(pins.get('missing').image.svg, /fill="rgba\(255,0,0,1\)"/); assert.deepEqual(pins.get('missing').image, pins.get('plain').image); }); + +test('a double-click follows a part as the default renderer followed its entity, and zooms to a line', async (t) => { + const env = await enabledLayer(t, [ + feature('pt', { type: 'Point', coordinates: [0.002, 0.003] }), + feature('l', { + type: 'LineString', + coordinates: [ + [0, 0], + [0.01, 0], + ], + }), + ]); + const { fake } = env; + const setOf = (role) => fake.set(role).spec.id; + const stem = fake.set('stems').items.get('pt'); + const [base, tip] = stem.positions; + let picked = null; + fake.setPick((x, y) => (x === 7 && y === 9 ? picked : null)); + + // Nothing of this layer's under it: nothing happens. + env.dblclick({ position: { x: 7, y: 9 } }); + picked = { set: 'someone-else', id: 'pt' }; + env.dblclick({ position: { x: 7, y: 9 } }); + assert.equal(fake.follows.length, 0); + + // Its pin, its stem or its dot: the camera follows the stem's centre, + // where the default renderer kept the entity's bounds. A tall view, so + // its width is what fits the stem in. + fake.view.aspectRatio = 0.5; + picked = { set: setOf('pins'), id: 'pt' }; + env.dblclick({ position: { x: 7, y: 9 } }); + const target = fake.follows.at(-1); + assert.equal(target.key, 'local-dams:pt'); + assert.equal(target.frame, 'enu'); + const center = { + x: (base.x + tip.x) / 2, + y: (base.y + tip.y) / 2, + z: (base.z + tip.z) / 2, + }; + assert.ok(distance(target.position(0), center) < 1e-6); + // Looking at it north up, pitched down 45 degrees (a little more for a + // tip above the ellipsoid), at the range that fits the stem in view. + const eye = framePoint(eastNorthUp(center), target.viewFrom); + const radius = distance(base, tip) / 2; + const fit = radius / (0.5 * Math.tan(Math.PI / 6)); + assert.ok(Math.abs(distance(eye, center) - fit) < 1e-6); + const look = inverseFrameVector( + eastNorthUp(center), + normalize(sub(center, eye)), + ); + const factor = 2 - 1 / Math.max(1, Math.hypot(tip.x, tip.y, tip.z) / 6378137); + assert.ok(factor > 1 + 1e-5, 'the tip stands above the ellipsoid'); + assert.ok(Math.abs(look.x) < 1e-9, 'heading north'); + assert.ok(look.y > 0); + assert.ok( + Math.abs(Math.asin(-look.z) - (Math.PI / 4) * factor) < 1e-9, + 'pitched down 45 degrees, steeper above the ground', + ); + fake.view.aspectRatio = 1; + + // Off while the renderer's own double-click follow is held off. + env.stock.dblclickFollow = false; + picked = { set: setOf('stems'), id: 'pt' }; + env.dblclick({ position: { x: 7, y: 9 } }); + assert.equal(fake.follows.length, 1); + env.stock.dblclickFollow = true; + + // A line had no position to follow: it is zoomed to instead, at once, + // with the camera's default framing (north, 45 degrees down, fitted). + picked = { set: setOf('lines'), id: 'l' }; + env.dblclick({ position: { x: 7, y: 9 } }); + const zoom = fake.flights.at(-1); + assert.ok(zoom.sphere.radius > 500); + assert.deepEqual(zoom.options, { durationS: 0 }); + // Stopping the follow first, as that zoom did. + assert.equal(fake.follows.length, 2); + assert.equal(fake.follows.at(-1), null); + + // Disabled, the layer leaves a follow another started in place of its + // own, and stops its own. + picked = { set: setOf('dots'), id: 'pt' }; + env.dblclick({ position: { x: 7, y: 9 } }); + assert.equal(fake.follows.at(-1).key, 'local-dams:pt'); + const theirs = { key: 'theirs' }; + fake.follows.push(theirs); + env.layer.disable(env.viewer); + assert.equal(fake.follows.at(-1), theirs); + await env.layer.enable(env.viewer); + env.dblclick({ position: { x: 7, y: 9 } }); + assert.equal(fake.follows.at(-1).key, 'local-dams:pt'); + env.layer.disable(env.viewer); + assert.equal(fake.follows.at(-1), null); + // Destroyed, it stops listening. + env.layer.destroy(env.viewer); + assert.equal(env.subscribed(), false); +}); diff --git a/src/testSupport/fakeGroundRenderer.mjs b/src/testSupport/fakeGroundRenderer.mjs index be38f790b..5ed5ec744 100644 --- a/src/testSupport/fakeGroundRenderer.mjs +++ b/src/testSupport/fakeGroundRenderer.mjs @@ -84,6 +84,12 @@ export function bindFakeGroundRenderer( const moveEnd = new FakeEvent(); const capabilities = new Set(sampleHeight ? ['sampleHeight'] : []); const flights = []; + /** What the camera has been told to follow, in order; the last is followed. */ + const follows = []; + /** The camera's view shape, which a test may change. */ + const view = { fovy: Math.PI / 3, aspectRatio: 1 }; + /** What a pick answers at a window position; default: nothing drawn. */ + let pickAt = () => null; const renders = []; let position = fromDegrees(eye.lon, eye.lat, eye.height); let surfaceHeight = surface; @@ -114,8 +120,7 @@ export function bindFakeGroundRenderer( return { ...at, position: { ...position }, - fovy: Math.PI / 3, - aspectRatio: 1, + ...view, }; }, on: (event, cb) => (event === 'moveEnd' ? moveEnd.on(cb) : () => {}), @@ -123,8 +128,20 @@ export function bindFakeGroundRenderer( flights.push({ destination, options }); return { done: Promise.resolve('complete'), cancel() {} }; }, + flyToBounds(sphere, options) { + flights.push({ sphere, options }); + return { done: Promise.resolve('complete'), cancel() {} }; + }, + follow(target) { + follows.push(target); + }, + get followed() { + return follows.at(-1) ?? null; + }, + controls: { minDistance: 1, maxDistance: Infinity }, }, query: { + pick: (x, y) => pickAt(x, y), project: () => ({ x: canvas.width / 2, y: canvas.height / 2 }), isOccluded: (point) => occluded(position, point), sampleHeightNow(point, options = {}) { @@ -149,6 +166,8 @@ export function bindFakeGroundRenderer( moveEnd, globe, flights, + follows, + view, renders, sampleCalls, capabilities, @@ -169,6 +188,10 @@ export function bindFakeGroundRenderer( position = { ...next }; }, eyePosition: () => ({ ...position }), + /** Change what a pick answers at a window position. */ + setPick(next) { + pickAt = next; + }, /** Change what surface samples answer. */ setSurface(next) { surfaceHeight = next;