mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 16:22:20 +00:00
The awareness layer presents the compass ring, heading, cardinal labels and contact bearing markers through subscribeDirectionOverlay(); the application shell publishes them to the gev-awareness-direction store and the scene chrome renders them in the viewer's container.
348 lines
12 KiB
JavaScript
348 lines
12 KiB
JavaScript
import * as Cesium from 'cesium';
|
|
import { t } from '../../i18n/index.js';
|
|
import {
|
|
createCyberSonarSampler,
|
|
isCyberContactSonarActive as isCyberSonarActive,
|
|
} from '../../cyberSonar.js';
|
|
import {
|
|
formatAwarenessLabel,
|
|
formatAwarenessDistance,
|
|
AWARENESS_RADIUS_M,
|
|
} from '../../data/militaryAwarenessEngine.js';
|
|
import { bearingBetweenCoordinates } from '../../cockpitMath.js';
|
|
import { AWARENESS_PAGE_SIZE, CONTEXT_RIM_HEIGHT_M } from './policy.js';
|
|
import { formatAwarenessDirection } from './presentation.js';
|
|
|
|
export function createRendering({
|
|
state: layerState,
|
|
services,
|
|
parts,
|
|
source,
|
|
}) {
|
|
const { getKeyholeGeometry, celestialScreenAngle } = services.geometry;
|
|
const { governorRequestRender } = services.render;
|
|
|
|
const CARDINALS = [
|
|
['N', 0],
|
|
['E', 90],
|
|
['S', 180],
|
|
['W', 270],
|
|
];
|
|
|
|
/**
|
|
* The direction overlay as its view renders it: the compass ring, its
|
|
* cardinals and heading, and up to three contact markers inside the
|
|
* viewer's container. Each part keeps its last placement while hidden.
|
|
*/
|
|
function ensureDirectionOverlay() {
|
|
if (layerState.directionView || !layerState.viewer)
|
|
return layerState.directionView;
|
|
presentDirection({
|
|
container: layerState.viewer.container,
|
|
hidden: true,
|
|
ring: null,
|
|
heading: { text: '', left: null, top: null },
|
|
labels: CARDINALS.map(([label, bearing]) => ({
|
|
label,
|
|
bearing,
|
|
left: null,
|
|
top: null,
|
|
})),
|
|
markers: Array.from({ length: 3 }, () => ({
|
|
hidden: false,
|
|
style: null,
|
|
arrow: null,
|
|
caption: { text: '', style: null },
|
|
})),
|
|
});
|
|
return layerState.directionView;
|
|
}
|
|
|
|
/** Publish a change to the overlay, skipping one that changes nothing. */
|
|
function presentDirection(patch) {
|
|
const next = patch && { ...layerState.directionView, ...patch };
|
|
const signature = JSON.stringify(next, (name, value) =>
|
|
name === 'container' ? undefined : value,
|
|
);
|
|
if (next && signature === layerState.directionSignature) return;
|
|
layerState.directionSignature = next ? signature : '';
|
|
layerState.directionView = next && Object.freeze(next);
|
|
for (const listener of [...layerState.directionListeners])
|
|
listener(layerState.directionView);
|
|
}
|
|
|
|
/**
|
|
* Receive the direction overlay now and after every change.
|
|
* @param {(view: ?object) => void} listener
|
|
* @returns {() => void} Unsubscribe.
|
|
*/
|
|
function subscribeDirectionOverlay(listener) {
|
|
layerState.directionListeners.add(listener);
|
|
listener(layerState.directionView);
|
|
return () => layerState.directionListeners.delete(listener);
|
|
}
|
|
|
|
/** Hide the overlay, keeping its last placement. */
|
|
function hideDirectionOverlay() {
|
|
if (layerState.directionView) presentDirection({ hidden: true });
|
|
}
|
|
|
|
/** Withdraw the overlay when the layer is destroyed. */
|
|
function removeDirectionOverlay() {
|
|
if (layerState.directionView) presentDirection(null);
|
|
layerState.directionAngles = [0, 0, 0];
|
|
}
|
|
|
|
function scheduleDirectionOverlayUpdate(force = false) {
|
|
if (layerState.directionFrame !== null || !layerState.enabled) return;
|
|
const now = Date.now();
|
|
if (
|
|
!force &&
|
|
now - layerState.lastDirectionUpdateMs <
|
|
parts.model.awarenessRefreshIntervalMs(layerState.cameraMoving)
|
|
)
|
|
return;
|
|
layerState.directionFrame = window.requestAnimationFrame(() => {
|
|
layerState.directionFrame = null;
|
|
layerState.lastDirectionUpdateMs = Date.now();
|
|
updateDirectionOverlay();
|
|
});
|
|
}
|
|
|
|
function cancelDirectionOverlayUpdate() {
|
|
if (layerState.directionFrame !== null)
|
|
window.cancelAnimationFrame(layerState.directionFrame);
|
|
layerState.directionFrame = null;
|
|
layerState.lastDirectionUpdateMs = 0;
|
|
}
|
|
|
|
function updateDirectionOverlay() {
|
|
const root = ensureDirectionOverlay();
|
|
if (
|
|
!root ||
|
|
!layerState.enabled ||
|
|
!layerState.subject?.position ||
|
|
!layerState.results
|
|
) {
|
|
if (root) presentDirection({ hidden: true });
|
|
return;
|
|
}
|
|
|
|
const canvas = layerState.viewer.scene.canvas;
|
|
const width = canvas.clientWidth || canvas.width;
|
|
const height = canvas.clientHeight || canvas.height;
|
|
const sonar = isCyberSonarActive()
|
|
? createCyberSonarSampler(width, height)
|
|
: null;
|
|
const geometry = getKeyholeGeometry(width, height);
|
|
if (!(geometry.radius > 0)) {
|
|
presentDirection({ hidden: true });
|
|
return;
|
|
}
|
|
|
|
// Keep the compass comfortably inside the shader keyhole so its cardinals
|
|
// remain visible around the subject instead of hiding under edge panels.
|
|
const compassRadius = Math.max(
|
|
120,
|
|
Math.min(geometry.radius - 48, geometry.radius * 0.66),
|
|
);
|
|
const cameraHeading = layerState.viewer.camera.heading || 0;
|
|
const headingDeg =
|
|
(Math.round(Cesium.Math.toDegrees(cameraHeading)) + 360) % 360;
|
|
const ring = {
|
|
left: `${geometry.centerX - compassRadius}px`,
|
|
top: `${geometry.centerY - compassRadius}px`,
|
|
width: `${compassRadius * 2}px`,
|
|
height: `${compassRadius * 2}px`,
|
|
'--compass-rotation': `${-headingDeg}deg`,
|
|
};
|
|
const heading = {
|
|
text: t('HDG {value}°', {
|
|
value: String(headingDeg).padStart(3, '0'),
|
|
}),
|
|
left: `${geometry.centerX}px`,
|
|
top: `${geometry.centerY - compassRadius + 39}px`,
|
|
};
|
|
const labels = root.labels.map((label) => {
|
|
const bearing = Cesium.Math.toRadians(label.bearing);
|
|
const angle = bearing - cameraHeading - Cesium.Math.PI_OVER_TWO;
|
|
const labelRadius = compassRadius - 17;
|
|
return {
|
|
...label,
|
|
left: `${geometry.centerX + Math.cos(angle) * labelRadius}px`,
|
|
top: `${geometry.centerY + Math.sin(angle) * labelRadius}px`,
|
|
};
|
|
});
|
|
|
|
const directionalCohort =
|
|
layerState.results.cohorts.find(
|
|
(cohort) => cohort.id === layerState.subject.layerId,
|
|
) ||
|
|
layerState.results.cohorts.find((cohort) => cohort.id === 'military');
|
|
const page = layerState.cohortPages.get(directionalCohort?.id) || 0;
|
|
const military =
|
|
directionalCohort?.summary.nearest.slice(
|
|
page,
|
|
page + AWARENESS_PAGE_SIZE,
|
|
) || [];
|
|
const markers = root.markers.map((marker) => ({ ...marker }));
|
|
for (let index = 0; index < markers.length; index++) {
|
|
const marker = markers[index];
|
|
const item = military[index];
|
|
if (!item?.position) {
|
|
marker.hidden = true;
|
|
continue;
|
|
}
|
|
const direction = Cesium.Cartesian3.subtract(
|
|
item.position,
|
|
layerState.subject.position,
|
|
layerState.DIRECTION_SCRATCH[index],
|
|
);
|
|
if (Cesium.Cartesian3.magnitudeSquared(direction) < 1) {
|
|
marker.hidden = true;
|
|
continue;
|
|
}
|
|
Cesium.Cartesian3.normalize(direction, direction);
|
|
const projection = celestialScreenAngle(
|
|
Cesium.Cartesian3.dot(direction, layerState.viewer.camera.rightWC),
|
|
Cesium.Cartesian3.dot(direction, layerState.viewer.camera.upWC),
|
|
layerState.directionAngles[index],
|
|
);
|
|
if (projection.stable)
|
|
layerState.directionAngles[index] = projection.angle;
|
|
// Every detected contact shares the compass rim. Keeping the bearing
|
|
// markers on one radius makes them read as compass contacts rather than
|
|
// unconstrained labels floating over the map.
|
|
const markerRadius = compassRadius;
|
|
marker.style = {
|
|
left: `${geometry.centerX + Math.cos(projection.angle) * markerRadius}px`,
|
|
top: `${geometry.centerY + Math.sin(projection.angle) * markerRadius}px`,
|
|
opacity: String(projection.opacity),
|
|
};
|
|
const sonarFactor =
|
|
sonar?.at(
|
|
geometry.centerX + Math.cos(projection.angle) * markerRadius,
|
|
geometry.centerY + Math.sin(projection.angle) * markerRadius,
|
|
) ?? 1;
|
|
marker.arrow = {
|
|
opacity: String(sonarFactor),
|
|
transform: `translate(-50%, -50%) rotate(${projection.angle}rad)`,
|
|
};
|
|
const labelStyle = {
|
|
opacity: String(sonar ? sonar.label(sonarFactor) : 1),
|
|
transform: `translate(-50%, -50%) translate(${-Math.cos(projection.angle) * 56}px, ${-Math.sin(projection.angle) * 56}px)`,
|
|
};
|
|
const label = formatAwarenessLabel(item);
|
|
const subjectCartographic = Cesium.Cartographic.fromCartesian(
|
|
layerState.subject.position,
|
|
undefined,
|
|
layerState.SUBJECT_CARTOGRAPHIC_SCRATCH,
|
|
);
|
|
const targetCartographic = Cesium.Cartographic.fromCartesian(
|
|
item.position,
|
|
undefined,
|
|
layerState.TARGET_CARTOGRAPHIC_SCRATCH[index],
|
|
);
|
|
const bearing =
|
|
subjectCartographic && targetCartographic
|
|
? bearingBetweenCoordinates(
|
|
Cesium.Math.toDegrees(subjectCartographic.latitude),
|
|
Cesium.Math.toDegrees(subjectCartographic.longitude),
|
|
Cesium.Math.toDegrees(targetCartographic.latitude),
|
|
Cesium.Math.toDegrees(targetCartographic.longitude),
|
|
)
|
|
: null;
|
|
const bearingText = Number.isFinite(bearing)
|
|
? t('BRG {value}°', {
|
|
value: formatAwarenessDirection(bearing),
|
|
})
|
|
: t('BRG —');
|
|
const courseText = Number.isFinite(item.track)
|
|
? ` · ${t('CRS {value}°', {
|
|
value: formatAwarenessDirection(item.track),
|
|
})}`
|
|
: '';
|
|
marker.caption = {
|
|
text: `${label} · ${formatAwarenessDistance(item.distanceM)}\n${bearingText}${courseText}`,
|
|
style: labelStyle,
|
|
};
|
|
marker.hidden = false;
|
|
}
|
|
presentDirection({ hidden: false, ring, heading, labels, markers });
|
|
}
|
|
|
|
function clearVisual() {
|
|
if (layerState.visual?.entities && layerState.viewer) {
|
|
for (const entity of layerState.visual.entities)
|
|
layerState.viewer.entities.remove(entity);
|
|
// Idle mode renders only on request; a removed ring must not linger.
|
|
governorRequestRender('awareness-visual');
|
|
}
|
|
layerState.visual = null;
|
|
}
|
|
|
|
function renderVisual(subject) {
|
|
if (!layerState.viewer || !subject?.position) return;
|
|
const cartographic = Cesium.Cartographic.fromCartesian(subject.position);
|
|
if (!cartographic) return;
|
|
const groundCenter = Cesium.Cartesian3.fromRadians(
|
|
cartographic.longitude,
|
|
cartographic.latitude,
|
|
0,
|
|
);
|
|
const key = `${subject.layerId}:${subject.id}`;
|
|
if (layerState.visual?.key === key) {
|
|
// Large ellipse geometry is more reliable as a ConstantPositionProperty.
|
|
// Move it only after a meaningful displacement so live tracking does not
|
|
// churn ten large geometries for sub-pixel motion every 750 ms.
|
|
if (
|
|
Cesium.Cartesian3.distance(layerState.visual.center, groundCenter) >=
|
|
250
|
|
) {
|
|
for (const entity of layerState.visual.entities)
|
|
entity.position.setValue(groundCenter);
|
|
Cesium.Cartesian3.clone(groundCenter, layerState.visual.center);
|
|
// Content actually changed — buy exactly one frame instead of holding.
|
|
governorRequestRender('awareness-visual');
|
|
}
|
|
return;
|
|
}
|
|
clearVisual();
|
|
|
|
const entities = [];
|
|
|
|
entities.push(
|
|
layerState.viewer.entities.add({
|
|
position: groundCenter,
|
|
ellipse: {
|
|
semiMajorAxis: AWARENESS_RADIUS_M,
|
|
semiMinorAxis: AWARENESS_RADIUS_M,
|
|
fill: false,
|
|
outline: true,
|
|
outlineColor:
|
|
Cesium.Color.fromCssColorString('#62b5ff').withAlpha(0.72),
|
|
height: CONTEXT_RIM_HEIGHT_M,
|
|
},
|
|
}),
|
|
);
|
|
|
|
layerState.visual = {
|
|
key,
|
|
entities,
|
|
center: Cesium.Cartesian3.clone(groundCenter),
|
|
};
|
|
governorRequestRender('awareness-visual');
|
|
}
|
|
return {
|
|
ensureDirectionOverlay,
|
|
subscribeDirectionOverlay,
|
|
hideDirectionOverlay,
|
|
removeDirectionOverlay,
|
|
scheduleDirectionOverlayUpdate,
|
|
cancelDirectionOverlayUpdate,
|
|
updateDirectionOverlay,
|
|
clearVisual,
|
|
renderVisual,
|
|
};
|
|
}
|