mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 16:22:20 +00:00
camera.follow({ position, viewFrom, minRange = 150, native? }) keeps a
moving target centred at an east-north-up offset the user may turn and
zoom; camera.following() and camera.followChanged report it; stop() frees
the camera and a camera command (setView, flyTo, flyToSphere, lookAt,
cancelFlight) ends it.
Probe ruling: Navara 0.2.1's cameraFollow holds the target but ignores the
user's drag and wheel, the aircraft sits ~13 px off centre with 7.6 px of
spread, and calling it without an offset each frame gives a NaN camera.
So Navara (and the fake engine) follow with src/globe/follow.js: each
frame, before Navara draws, the offset is re-read from where the user put
the camera relative to the previous target, kept outside the minimum
range and carried to the new target.
Cesium follows with viewer.trackedEntity: the layer's own Entity
(`native`) or a proxy Entity at position() with a 1 px transparent point,
since EntityView moves the camera only for an entity with a bounding
sphere. applyTrackedCameraFrame and the zoom limits moved to
src/globe/cesium/follow.js; src/data/trackedCamera.js keeps the pure parts
(the range clamp now lives in src/globe/follow.js). following() also
reports an entity the app tracked itself. Camera sensitivity claims made
on a viewer's Cesium camera now share the engine camera's ledger, and the
orientation controls and the world jump read the follow from the engine.
Contract (both engines): a target flying at 250 m/s stays within 3 px of
the centre for 2 s, zoomIn through it stops at 150 m, stop() and setView
end the follow. Cesium 71/71, Navara 77/77; shell 23/25/4.
110 lines
4.3 KiB
JavaScript
110 lines
4.3 KiB
JavaScript
// src/data/cameraSensitivity.js
|
|
/**
|
|
* Shared claims on `camera.percentageChanged`.
|
|
*
|
|
* `camera.changed` fires once the view has moved by this fraction, and it is a
|
|
* single number on the camera that every listener in the app shares. Several
|
|
* layers want it finer than the default — traffic, bikeshare and transit all
|
|
* ask for 0.05 so they notice they have entered a coverage area — and each of
|
|
* them used to write the number directly and hand back whatever it remembered.
|
|
*
|
|
* That cannot work, because a number is not an owner. Two layers asking for the
|
|
* same 0.05 write the same value, so when the first one leaves it sees its own
|
|
* number still in place, concludes nothing else has claimed it, and restores
|
|
* the coarse default out from under a layer that is still running. The symptom
|
|
* is a camera-driven layer that quietly stops noticing the camera: Transit is
|
|
* turned off and Bikeshare stops loading new cities until something else nudges
|
|
* it.
|
|
*
|
|
* So ownership is tracked explicitly. Claims are named, the camera gets the
|
|
* finest value anyone has asked for, and the original value returns only when
|
|
* the last claim is gone. Claiming twice under one name replaces that claim.
|
|
*
|
|
* This is bookkeeping, not policy: it never decides what a layer should ask
|
|
* for, only that nobody's answer is taken away while they still need it.
|
|
*/
|
|
|
|
import { engineFromViewer } from '../globe/cesium/engineFromViewer.js';
|
|
|
|
/** @type {WeakMap<object, {base: number, claims: Map<string, number>}>} */
|
|
const _cameras = new WeakMap();
|
|
|
|
/** The value Cesium starts a camera at, used when the camera reports nothing. */
|
|
const DEFAULT_PERCENTAGE_CHANGED = 0.5;
|
|
|
|
/**
|
|
* One key per camera: the engine's camera. A globe engine claims through its
|
|
* camera; a Cesium viewer or its camera through the engine registered for
|
|
* that viewer (engineFromViewer); anything else is the camera itself (a
|
|
* camera has no `camera` of its own).
|
|
*/
|
|
const cameraOf = (target) =>
|
|
engineFromViewer(target)?.camera ?? target?.camera ?? target;
|
|
|
|
function ledgerFor(camera) {
|
|
let ledger = _cameras.get(camera);
|
|
if (!ledger) {
|
|
const base = Number.isFinite(camera.percentageChanged)
|
|
? camera.percentageChanged
|
|
: DEFAULT_PERCENTAGE_CHANGED;
|
|
ledger = { base, claims: new Map() };
|
|
_cameras.set(camera, ledger);
|
|
}
|
|
return ledger;
|
|
}
|
|
|
|
function applyLedger(camera, ledger) {
|
|
let value = ledger.base;
|
|
for (const claimed of ledger.claims.values()) {
|
|
if (claimed < value) value = claimed;
|
|
}
|
|
camera.percentageChanged = value;
|
|
return value;
|
|
}
|
|
|
|
/**
|
|
* Ask for a camera-change sensitivity at least as fine as `value`.
|
|
* @param {object|null|undefined} target A globe engine, its camera, or a
|
|
* Cesium viewer or camera (anything with `percentageChanged`). A viewer
|
|
* with a registered engine, and its camera, claim on the engine camera.
|
|
* @param {string} owner Stable claim name, usually the layer id.
|
|
* @param {number} value Requested `percentageChanged`.
|
|
* @returns {number|null} The value now in force, or null when there is no camera.
|
|
*/
|
|
export function claimCameraSensitivity(target, owner, value) {
|
|
const camera = cameraOf(target);
|
|
if (!camera || !owner || !Number.isFinite(value)) return null;
|
|
const ledger = ledgerFor(camera);
|
|
ledger.claims.set(owner, value);
|
|
return applyLedger(camera, ledger);
|
|
}
|
|
|
|
/**
|
|
* Give up one claim. The camera keeps the finest value still claimed by
|
|
* somebody else, and returns to its original only when none are left.
|
|
* @param {object|null|undefined} target A globe engine or a camera.
|
|
* @param {string} owner
|
|
* @returns {number|null} The value now in force, or null when there is no camera.
|
|
*/
|
|
export function releaseCameraSensitivity(target, owner) {
|
|
const camera = cameraOf(target);
|
|
if (!camera || !owner) return null;
|
|
const ledger = _cameras.get(camera);
|
|
if (!ledger) return null;
|
|
if (!ledger.claims.delete(owner)) return camera.percentageChanged;
|
|
const applied = applyLedger(camera, ledger);
|
|
if (ledger.claims.size === 0) _cameras.delete(camera);
|
|
return applied;
|
|
}
|
|
|
|
/**
|
|
* Who currently holds a claim. For tests and diagnostics only.
|
|
* @param {object|null|undefined} target A globe engine or a camera.
|
|
* @returns {Array<string>}
|
|
*/
|
|
export function cameraSensitivityClaims(target) {
|
|
const camera = cameraOf(target);
|
|
const ledger = camera ? _cameras.get(camera) : null;
|
|
return ledger ? [...ledger.claims.keys()] : [];
|
|
}
|