mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 16:22:20 +00:00
refactor(radio): separate directory and playback components
This commit is contained in:
1 parent
ba7fda74d7
commit
41b3cc1705
30 files changed
+4488
-2795
No files matched your search
@@ -0,0 +1,395 @@
|
||||
import * as Cesium from 'cesium';
|
||||
import {
|
||||
HORIZON_CAMERA_MOVE_EPSILON_M,
|
||||
GLOBAL_RADIO_ALTITUDE_M,
|
||||
RADIO_GLOBE_RECENTER_MAX_HEIGHT_M,
|
||||
} from './policy.js';
|
||||
|
||||
export function createNavigation({
|
||||
state: layerState,
|
||||
services,
|
||||
parts,
|
||||
source,
|
||||
}) {
|
||||
const {
|
||||
isFullGlobeInsideKeyhole,
|
||||
GLOBE_ENTER_CLEARANCE_PX,
|
||||
projectEarthDiscToViewport,
|
||||
earthDiscScreenRadius,
|
||||
getKeyholeGeometry,
|
||||
} = services.globe;
|
||||
|
||||
/** Return whether camera translation materially changes horizon visibility. */
|
||||
|
||||
function radioCameraPositionChanged(
|
||||
previous,
|
||||
current,
|
||||
epsilonM = HORIZON_CAMERA_MOVE_EPSILON_M,
|
||||
) {
|
||||
if (!previous || !current) return true;
|
||||
const dx = Number(current.x) - Number(previous.x);
|
||||
const dy = Number(current.y) - Number(previous.y);
|
||||
const dz = Number(current.z) - Number(previous.z);
|
||||
if (![dx, dy, dz].every(Number.isFinite)) return true;
|
||||
const threshold = Math.max(0, Number(epsilonM) || 0);
|
||||
return dx * dx + dy * dy + dz * dz > threshold * threshold;
|
||||
}
|
||||
|
||||
/** Classify a globe-scale Radio view without flapping on Cesium height round-off. */
|
||||
|
||||
function radioViewIsGlobal(altitudeM) {
|
||||
return (
|
||||
Number.isFinite(altitudeM) &&
|
||||
Math.round(altitudeM) >= GLOBAL_RADIO_ALTITUDE_M
|
||||
);
|
||||
}
|
||||
|
||||
/** Plan a station-centered camera move that preserves altitude and view angle. */
|
||||
|
||||
function radioStationCameraPlan(station, cameraState = {}) {
|
||||
const targetLat = Number(station?.lat);
|
||||
const targetLon = Number(station?.lon);
|
||||
const height = Math.max(1, Number(cameraState.height) || 1);
|
||||
const heading = Number.isFinite(cameraState.heading)
|
||||
? cameraState.heading
|
||||
: 0;
|
||||
const pitch = Number.isFinite(cameraState.pitch)
|
||||
? cameraState.pitch
|
||||
: -Math.PI / 2;
|
||||
const roll = Number.isFinite(cameraState.roll) ? cameraState.roll : 0;
|
||||
if (!Number.isFinite(targetLat) || !Number.isFinite(targetLon)) return null;
|
||||
|
||||
const downAngle = Math.min(
|
||||
Math.PI / 2,
|
||||
Math.max(0.08, Math.abs(Math.min(-0.001, pitch))),
|
||||
);
|
||||
const groundOffsetM =
|
||||
downAngle > Math.PI / 2 - 1e-6
|
||||
? 0
|
||||
: Math.min(2_000_000, height / Math.max(0.08, Math.tan(downAngle)));
|
||||
const angularDistance = groundOffsetM / 6_378_137;
|
||||
const targetLatRad = (targetLat * Math.PI) / 180;
|
||||
const cameraBearing = heading + Math.PI;
|
||||
const cameraLatRad = Math.asin(
|
||||
Math.sin(targetLatRad) * Math.cos(angularDistance) +
|
||||
Math.cos(targetLatRad) *
|
||||
Math.sin(angularDistance) *
|
||||
Math.cos(cameraBearing),
|
||||
);
|
||||
const cameraLonRad =
|
||||
(targetLon * Math.PI) / 180 +
|
||||
Math.atan2(
|
||||
Math.sin(cameraBearing) *
|
||||
Math.sin(angularDistance) *
|
||||
Math.cos(targetLatRad),
|
||||
Math.cos(angularDistance) -
|
||||
Math.sin(targetLatRad) * Math.sin(cameraLatRad),
|
||||
);
|
||||
const cameraLon = (((cameraLonRad * 180) / Math.PI + 540) % 360) - 180;
|
||||
return {
|
||||
lat: (cameraLatRad * 180) / Math.PI,
|
||||
lon: cameraLon,
|
||||
height,
|
||||
heading,
|
||||
pitch,
|
||||
roll,
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Decide whether Radio navigation should first restore a centered Earth view.
|
||||
* Fit-capable clipped discs and closer views whose optical center has reached
|
||||
* the Earth limb use the staged path; ordinary centered local views stay direct.
|
||||
*/
|
||||
|
||||
function radioGlobeNeedsRecentering(geometry) {
|
||||
if (!geometry || isFullGlobeInsideKeyhole(geometry, false)) return false;
|
||||
const centeredGeometry = {
|
||||
...geometry,
|
||||
earthCenterX: geometry.keyholeCenterX,
|
||||
earthCenterY: geometry.keyholeCenterY,
|
||||
};
|
||||
if (isFullGlobeInsideKeyhole(centeredGeometry, false)) return true;
|
||||
const values = [
|
||||
geometry.earthCenterX,
|
||||
geometry.earthCenterY,
|
||||
geometry.earthRadius,
|
||||
geometry.keyholeCenterX,
|
||||
geometry.keyholeCenterY,
|
||||
];
|
||||
if (!values.every(Number.isFinite) || geometry.earthRadius <= 0)
|
||||
return false;
|
||||
const centerOffset = Math.hypot(
|
||||
geometry.earthCenterX - geometry.keyholeCenterX,
|
||||
geometry.earthCenterY - geometry.keyholeCenterY,
|
||||
);
|
||||
return geometry.earthRadius - centerOffset < GLOBE_ENTER_CLEARANCE_PX;
|
||||
}
|
||||
|
||||
/** Preserve closer zoom while capping an extreme full-globe recovery. */
|
||||
|
||||
function radioGlobeRecenterHeight(currentHeight, fullGlobeCapable) {
|
||||
if (!Number.isFinite(currentHeight) || currentHeight < 0) return null;
|
||||
return fullGlobeCapable
|
||||
? Math.min(currentHeight, RADIO_GLOBE_RECENTER_MAX_HEIGHT_M)
|
||||
: currentHeight;
|
||||
}
|
||||
|
||||
function radioCameraState(camera = layerState._viewer?.camera) {
|
||||
if (!camera) return null;
|
||||
return {
|
||||
height: camera.positionCartographic?.height,
|
||||
heading: camera.heading,
|
||||
pitch: camera.pitch,
|
||||
roll: camera.roll,
|
||||
};
|
||||
}
|
||||
|
||||
/** Radio may move the globe only while no tracked entity owns the follow camera. */
|
||||
|
||||
function radioCameraNavigationAllowed(viewer = layerState._viewer) {
|
||||
return Boolean(viewer?.camera) && !viewer.trackedEntity;
|
||||
}
|
||||
|
||||
function radioGlobeRecenterPlan(viewer = layerState._viewer) {
|
||||
const camera = viewer?.camera;
|
||||
const canvas = viewer?.scene?.canvas;
|
||||
const width = canvas?.clientWidth || canvas?.width;
|
||||
const height = canvas?.clientHeight || canvas?.height;
|
||||
const cartographic = camera?.positionCartographic;
|
||||
if (!camera || !cartographic || !(width > 0) || !(height > 0)) return null;
|
||||
const geometry = projectEarthDiscToViewport(
|
||||
viewer,
|
||||
width,
|
||||
height,
|
||||
layerState._radioEarthScreenCenter,
|
||||
layerState._radioEarthToCenter,
|
||||
);
|
||||
let fullGlobeCapable = false;
|
||||
if (geometry) {
|
||||
if (!radioGlobeNeedsRecentering(geometry)) return null;
|
||||
fullGlobeCapable = isFullGlobeInsideKeyhole(
|
||||
{
|
||||
...geometry,
|
||||
earthCenterX: geometry.keyholeCenterX,
|
||||
earthCenterY: geometry.keyholeCenterY,
|
||||
},
|
||||
false,
|
||||
);
|
||||
} else {
|
||||
const earthRadius = earthDiscScreenRadius(
|
||||
Cesium.Cartesian3.magnitude(camera.positionWC),
|
||||
height,
|
||||
camera.frustum?.fovy,
|
||||
);
|
||||
const facingEarthCenter =
|
||||
Cesium.Cartesian3.dot(
|
||||
camera.directionWC,
|
||||
layerState._radioEarthToCenter,
|
||||
) > 0;
|
||||
if (!earthRadius || facingEarthCenter) return null;
|
||||
const keyhole = getKeyholeGeometry(width, height);
|
||||
fullGlobeCapable =
|
||||
earthRadius + GLOBE_ENTER_CLEARANCE_PX <= keyhole.radius;
|
||||
}
|
||||
const recenterHeight = radioGlobeRecenterHeight(
|
||||
cartographic.height,
|
||||
fullGlobeCapable,
|
||||
);
|
||||
if (recenterHeight == null) return null;
|
||||
return {
|
||||
destination: Cesium.Cartesian3.fromRadians(
|
||||
cartographic.longitude,
|
||||
cartographic.latitude,
|
||||
recenterHeight,
|
||||
),
|
||||
cameraState: {
|
||||
...radioCameraState(camera),
|
||||
height: recenterHeight,
|
||||
heading: 0,
|
||||
pitch: -Cesium.Math.PI_OVER_TWO,
|
||||
roll: 0,
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
function radioCameraNavigationIsCurrent(navigation) {
|
||||
return Boolean(
|
||||
navigation &&
|
||||
navigation.generation === layerState._radioCameraNavigationGeneration &&
|
||||
layerState._enabled &&
|
||||
radioCameraNavigationAllowed(layerState._viewer),
|
||||
);
|
||||
}
|
||||
|
||||
function cancelActiveRadioCameraFlight() {
|
||||
if (
|
||||
!layerState._activeRadioCameraFlight ||
|
||||
!radioCameraNavigationAllowed(layerState._viewer)
|
||||
)
|
||||
return;
|
||||
layerState._activeRadioCameraFlight = null;
|
||||
layerState._viewer.camera.cancelFlight();
|
||||
}
|
||||
|
||||
function invalidateRadioCameraNavigation() {
|
||||
layerState._radioCameraNavigationGeneration += 1;
|
||||
cancelActiveRadioCameraFlight();
|
||||
layerState._activeRadioCameraFlight = null;
|
||||
}
|
||||
|
||||
function radioCameraNavigationOwnsSelection(navigation, station) {
|
||||
return Boolean(
|
||||
navigation &&
|
||||
station &&
|
||||
navigation.generation === layerState._radioCameraNavigationGeneration &&
|
||||
navigation.target?.id === station.id,
|
||||
);
|
||||
}
|
||||
|
||||
function startRadioCameraFlight(navigation, options, onComplete) {
|
||||
if (!radioCameraNavigationIsCurrent(navigation)) return false;
|
||||
const token = ++layerState._radioCameraFlightSequence;
|
||||
layerState._activeRadioCameraFlight = {
|
||||
generation: navigation.generation,
|
||||
token,
|
||||
};
|
||||
const finish = (completed) => {
|
||||
if (layerState._activeRadioCameraFlight?.token === token)
|
||||
layerState._activeRadioCameraFlight = null;
|
||||
if (completed && radioCameraNavigationIsCurrent(navigation))
|
||||
onComplete?.();
|
||||
};
|
||||
layerState._viewer.camera.flyTo({
|
||||
...options,
|
||||
complete: () => finish(true),
|
||||
cancel: () => finish(false),
|
||||
});
|
||||
return true;
|
||||
}
|
||||
|
||||
function focusRadioNavigationTarget(navigation) {
|
||||
if (!radioCameraNavigationIsCurrent(navigation) || !navigation.target)
|
||||
return false;
|
||||
const plan = radioStationCameraPlan(
|
||||
navigation.target,
|
||||
navigation.cameraState,
|
||||
);
|
||||
if (!plan) return false;
|
||||
navigation.phase = 'focusing';
|
||||
return startRadioCameraFlight(
|
||||
navigation,
|
||||
{
|
||||
destination: Cesium.Cartesian3.fromDegrees(
|
||||
plan.lon,
|
||||
plan.lat,
|
||||
plan.height,
|
||||
),
|
||||
orientation: {
|
||||
heading: plan.heading,
|
||||
pitch: plan.pitch,
|
||||
roll: plan.roll,
|
||||
},
|
||||
duration: navigation.duration,
|
||||
},
|
||||
() => {
|
||||
navigation.phase = 'settled';
|
||||
},
|
||||
);
|
||||
}
|
||||
|
||||
function beginRadioCameraNavigation(cameraState = null) {
|
||||
const generation = ++layerState._radioCameraNavigationGeneration;
|
||||
if (
|
||||
!radioCameraNavigationAllowed(layerState._viewer) ||
|
||||
!layerState._enabled
|
||||
)
|
||||
return null;
|
||||
cancelActiveRadioCameraFlight();
|
||||
const recenterPlan = radioGlobeRecenterPlan(layerState._viewer);
|
||||
return {
|
||||
generation,
|
||||
phase: 'idle',
|
||||
recentered: false,
|
||||
recenterPlan,
|
||||
cameraState:
|
||||
recenterPlan?.cameraState || cameraState || radioCameraState(),
|
||||
target: null,
|
||||
duration: 0.35,
|
||||
};
|
||||
}
|
||||
|
||||
function rotateRadioStationIntoView(
|
||||
station,
|
||||
duration = 0.35,
|
||||
cameraState = null,
|
||||
navigation = null,
|
||||
) {
|
||||
const activeNavigation =
|
||||
navigation || beginRadioCameraNavigation(cameraState);
|
||||
if (!station || !radioCameraNavigationIsCurrent(activeNavigation))
|
||||
return false;
|
||||
activeNavigation.target = station;
|
||||
activeNavigation.duration = duration;
|
||||
if (activeNavigation.phase === 'recentering') return true;
|
||||
if (activeNavigation.phase === 'focusing') cancelActiveRadioCameraFlight();
|
||||
if (activeNavigation.recenterPlan && !activeNavigation.recentered) {
|
||||
activeNavigation.phase = 'recentering';
|
||||
const recenterDuration = Math.min(0.9, Math.max(0.65, duration));
|
||||
return startRadioCameraFlight(
|
||||
activeNavigation,
|
||||
{
|
||||
destination: activeNavigation.recenterPlan.destination,
|
||||
orientation: {
|
||||
heading: activeNavigation.cameraState.heading,
|
||||
pitch: activeNavigation.cameraState.pitch,
|
||||
roll: activeNavigation.cameraState.roll,
|
||||
},
|
||||
duration: recenterDuration,
|
||||
easingFunction: Cesium.EasingFunction.CUBIC_IN_OUT,
|
||||
},
|
||||
() => {
|
||||
activeNavigation.recentered = true;
|
||||
activeNavigation.phase = 'idle';
|
||||
focusRadioNavigationTarget(activeNavigation);
|
||||
},
|
||||
);
|
||||
}
|
||||
return focusRadioNavigationTarget(activeNavigation);
|
||||
}
|
||||
|
||||
function focusStation(station) {
|
||||
layerState._radioCameraNavigationGeneration += 1;
|
||||
if (!station || !radioCameraNavigationAllowed(layerState._viewer))
|
||||
return false;
|
||||
cancelActiveRadioCameraFlight();
|
||||
layerState._viewer.camera.flyTo({
|
||||
destination: Cesium.Cartesian3.fromDegrees(
|
||||
station.lon,
|
||||
station.lat,
|
||||
85_000,
|
||||
),
|
||||
duration: 1.1,
|
||||
});
|
||||
return true;
|
||||
}
|
||||
return {
|
||||
radioCameraPositionChanged,
|
||||
radioViewIsGlobal,
|
||||
radioStationCameraPlan,
|
||||
radioGlobeNeedsRecentering,
|
||||
radioGlobeRecenterHeight,
|
||||
radioCameraState,
|
||||
radioCameraNavigationAllowed,
|
||||
radioGlobeRecenterPlan,
|
||||
radioCameraNavigationIsCurrent,
|
||||
cancelActiveRadioCameraFlight,
|
||||
invalidateRadioCameraNavigation,
|
||||
radioCameraNavigationOwnsSelection,
|
||||
startRadioCameraFlight,
|
||||
focusRadioNavigationTarget,
|
||||
beginRadioCameraNavigation,
|
||||
rotateRadioStationIntoView,
|
||||
focusStation,
|
||||
};
|
||||
}
|
||||
Reference in new issue
Block a user