Files
gods-eye-view/src/layers/radio/rendering.js
T
Sameh Khamis b20c80e590 Switch language in place, without a reload
Choosing a language in the picker now applies it at once. The choice is
stored and ?lang is kept in step through replaceState, and the picker keeps
focus.

Code that writes translated text itself re-presents it on a switch:
onLocaleChange() lets an owner listen, removed at teardown, and status
writers hand over a function of the locale (voice cards, scene director,
SDR, draw hints, imagery split, map sources, Bhote Koshi media) so the
words are rebuilt rather than re-sent. The HUD, cockpit, radio, CCTV,
launch, awareness and credit texts follow the same hook, and
applyDocumentTranslations can be applied again without undoing text code
wrote since.

The unsaved-work registry and persistLocaleAndReload existed only to guard
the reload, so they go, with their catalog entries.
2026-11-01 16:47:39 -08:00

408 lines
14 KiB
JavaScript

import * as Cesium from 'cesium';
import { horizonOccluder } from '../../data/iconOrientation.js';
import {
MARKER_LIFT_M,
RADIO_PREFIX,
SELECTED_LIFT_M,
RADIO_GLOBE_INTERACTION_MAX_DISTANCE_M,
RADIO_OVERLAY_SOURCE_ID,
RADIO_OVERLAY_COHORT_LIMIT,
RADIO_OVERLAY_SOURCE_OPTIONS,
DEFAULT_RADIO_FILTER,
} from './policy.js';
export function createRendering({
state: layerState,
services,
parts,
source,
}) {
const { cachedGroundFloor } = services.ground;
const { clearOverlaySource, setOverlaySourceVisible, setOverlayEntries } =
services.overlays;
const { governorRequestRender } = services.render;
function markerPosition(station, liftM = MARKER_LIFT_M) {
const floor = cachedGroundFloor(station.lat, station.lon);
return Cesium.Cartesian3.fromDegrees(
station.lon,
station.lat,
(Number.isFinite(floor) ? floor : 0) + liftM,
);
}
function updateSelectionEntity() {
if (layerState._selectedEntity && layerState._viewer)
layerState._viewer.entities.remove(layerState._selectedEntity);
layerState._selectedEntity = null;
const station = parts.queries.selectedPresentationStation();
if (
!parts.interaction.radioPresentationAllowed() ||
!layerState._viewer ||
!station
) {
scheduleRadioOverlayPublish();
return;
}
const selectionColor = parts.model.radioCategoryColor(
parts.model.radioStationCategoryId(station),
);
const bracketImage = `data:image/svg+xml;charset=utf-8,${encodeURIComponent(parts.labels.radioSelectionBracketSvg(selectionColor))}`;
layerState._selectedEntity = layerState._viewer.entities.add({
id: `${RADIO_PREFIX}selected:${station.id}`,
position: markerPosition(station, SELECTED_LIFT_M),
point: {
pixelSize: 14,
color: Cesium.Color.fromCssColorString(selectionColor),
outlineColor: Cesium.Color.BLACK,
outlineWidth: 2,
disableDepthTestDistance: Number.POSITIVE_INFINITY,
distanceDisplayCondition: new Cesium.DistanceDisplayCondition(
0,
RADIO_GLOBE_INTERACTION_MAX_DISTANCE_M,
),
},
billboard: {
image: bracketImage,
width: 40,
height: 40,
horizontalOrigin: Cesium.HorizontalOrigin.CENTER,
verticalOrigin: Cesium.VerticalOrigin.CENTER,
disableDepthTestDistance: Number.POSITIVE_INFINITY,
distanceDisplayCondition: new Cesium.DistanceDisplayCondition(
0,
RADIO_GLOBE_INTERACTION_MAX_DISTANCE_M,
),
scaleByDistance: new Cesium.NearFarScalar(100_000, 1, 12_000_000, 0.72),
},
});
scheduleRadioOverlayPublish();
}
function clusterPointCollection() {
return layerState._dataSource?.clustering?._clusterPointCollection || null;
}
function publishRadioOverlayEntries() {
layerState._overlayPublishTimer = null;
if (!parts.interaction.radioPresentationAllowed()) {
parts.clustering.resetRadioClusterOverlayIdentities();
layerState._overlayDiagnostics =
parts.clustering.emptyRadioOverlayDiagnostics();
clearOverlaySource(RADIO_OVERLAY_SOURCE_ID);
setOverlaySourceVisible(RADIO_OVERLAY_SOURCE_ID, false);
return;
}
const entries = [];
const station = parts.queries.selectedPresentationStation();
if (station) {
const selectedEntry = parts.labels.createRadioSelectedOverlayEntry(
station,
markerPosition(station, SELECTED_LIFT_M),
);
if (selectedEntry) entries.push(selectedEntry);
}
const clusterCandidates = [];
const clusteredStationIds = new Set();
const points = clusterPointCollection();
for (let index = 0; index < (points?.length || 0); index += 1) {
const point = points.get(index);
if (
!point?.show ||
!point.position ||
!Array.isArray(point.id) ||
point.id.length < 3
)
continue;
const stationIds = point.id
.map((entity) => String(entity?.id || '').slice(RADIO_PREFIX.length))
.filter((id) => {
const station = layerState._stationById.get(id);
return (
station &&
parts.categories.stationMatchesRadioCategory(
station,
layerState._filter,
)
);
})
.sort();
if (stationIds.length < 3) continue;
for (const stationId of stationIds) clusteredStationIds.add(stationId);
const clusteredStations = stationIds.map((id) =>
layerState._stationById.get(id),
);
const category = parts.model.radioClusterCategoryId(
clusteredStations,
layerState._filter,
);
clusterCandidates.push({
id: `${stationIds[0]}:${stationIds.at(-1)}:${stationIds.length}`,
stationIds,
point,
text: parts.model.radioClusterBadgeText(category, stationIds.length),
accent: parts.model.radioCategoryColor(category),
stationCount: stationIds.length,
});
}
const selectedClusterCandidates =
parts.clustering.selectRadioClusterCandidates(clusterCandidates);
layerState._clusterOverlayIdentities =
parts.clustering.reconcileRadioClusterCandidates(
selectedClusterCandidates,
layerState._clusterOverlayIdentities,
() => `stable:${++layerState._clusterOverlayIdentitySequence}`,
);
for (const candidate of layerState._clusterOverlayIdentities) {
const clusterEntry = parts.labels.createRadioClusterOverlayEntry({
...candidate,
position: () => candidate.point.position,
});
if (clusterEntry) entries.push(clusterEntry);
}
const cameraPosition = layerState._viewer?.camera?.positionWC;
const singletonAllowance = Math.min(
parts.clustering.radioSingletonLabelLimit(
layerState._viewer?.camera?.positionCartographic?.height,
),
Math.max(
0,
RADIO_OVERLAY_COHORT_LIMIT - selectedClusterCandidates.length,
),
);
const singletonCandidates = parts.clustering.selectRadioSingletonCandidates(
[...layerState._renderById.values()]
.filter(
(record) =>
record.entity?.show &&
record.station?.id !== station?.id &&
!clusteredStationIds.has(record.station?.id),
)
.map((record) => ({
...record,
distanceM: cameraPosition
? Cesium.Cartesian3.distance(cameraPosition, record.position)
: Number.POSITIVE_INFINITY,
})),
singletonAllowance,
);
for (let index = 0; index < singletonCandidates.length; index += 1) {
const candidate = singletonCandidates[index];
const singletonEntry = parts.labels.createRadioSingletonOverlayEntry({
station: candidate.station,
position: candidate.position,
// Cluster priorities begin at three. Keep clusters authoritative while
// retaining nearest-first singleton ordering inside the ambient lane.
priority: 2 - index / Math.max(1, singletonCandidates.length + 1),
});
if (singletonEntry) entries.push(singletonEntry);
}
setOverlayEntries(
RADIO_OVERLAY_SOURCE_ID,
entries,
RADIO_OVERLAY_SOURCE_OPTIONS,
);
setOverlaySourceVisible(RADIO_OVERLAY_SOURCE_ID, true);
layerState._overlayDiagnostics = {
entryCount: entries.length,
selectedCount: entries.filter((entry) => entry.selected).length,
singletonTexts: entries
.filter((entry) => entry.id.startsWith('station:'))
.map((entry) => entry.title),
singletonIds: entries
.filter((entry) => entry.id.startsWith('station:'))
.map((entry) => entry.id),
clusterTexts: entries
.filter((entry) => entry.id.startsWith('cluster:'))
.map((entry) => entry.title),
clusterIds: entries
.filter((entry) => entry.id.startsWith('cluster:'))
.map((entry) => entry.id),
clusterMemberships: layerState._clusterOverlayIdentities.map(
(candidate) => ({
membershipId: candidate.membershipId,
entryId: `cluster:${candidate.id}`,
}),
),
};
}
function scheduleRadioOverlayPublish() {
if (layerState._overlayPublishTimer)
clearTimeout(layerState._overlayPublishTimer);
const sessionGeneration = layerState._sessionGeneration;
layerState._overlayPublishTimer = setTimeout(() => {
if (sessionGeneration === layerState._sessionGeneration)
publishRadioOverlayEntries();
}, 0);
}
function updateRenderVisibility({ force = true } = {}) {
if (!layerState._viewer || !layerState._dataSource) return;
const cameraPosition = layerState._viewer.camera?.positionWC;
if (
!force &&
!parts.navigation.radioCameraPositionChanged(
layerState._lastHorizonCameraPosition,
cameraPosition,
)
)
return;
layerState._lastHorizonCameraPosition = cameraPosition
? { x: cameraPosition.x, y: cameraPosition.y, z: cameraPosition.z }
: null;
layerState._horizonScanCount += 1;
const occluder = horizonOccluder(layerState._viewer.camera);
let visibilityChanged = false;
for (const record of layerState._renderById.values()) {
const matches = parts.categories.stationMatchesRadioCategory(
record.station,
layerState._filter,
);
const visible = matches && occluder.isPointVisible(record.position);
if (record.entity.show !== visible) visibilityChanged = true;
record.entity.show = visible;
}
if (layerState._selectedEntity) {
const position = layerState._selectedEntity.position?.getValue?.(
Cesium.JulianDate.now(),
);
const selectedVisible = !position || occluder.isPointVisible(position);
if (layerState._selectedEntity.show !== selectedVisible)
visibilityChanged = true;
layerState._selectedEntity.show = selectedVisible;
}
scheduleRadioOverlayPublish();
// The horizon timer can commit AFTER the camera settles and the governor
// parks the scene — a changed show flag needs one frame. (perf wave 2 fix)
if (visibilityChanged) governorRequestRender('radio-horizon');
}
function reconcileStations(stations) {
if (!layerState._tuningActive)
layerState._cancelledTuningPresentationStation = null;
layerState._clusterOverlayIdentities =
parts.clustering.retainRadioClusterIdentitiesForStations(
layerState._clusterOverlayIdentities,
stations,
);
layerState._stations = Object.freeze([...stations]);
layerState._stationById = new Map(
stations.map((station) => [station.id, station]),
);
parts.presentation.buildCategories();
if (
layerState._filter === DEFAULT_RADIO_FILTER &&
!parts.categories.filterRadioStations(stations, DEFAULT_RADIO_FILTER)
.length
) {
layerState._filter = 'all';
}
if (
layerState._selectedId &&
!layerState._stationById.has(layerState._selectedId)
) {
if (layerState._audioStationId === layerState._selectedId)
parts.playback.stopRadioPlayback();
layerState._selectedId = null;
}
if (layerState._dataSource) layerState._dataSource.entities.removeAll();
layerState._renderById.clear();
for (const station of stations) {
const position = markerPosition(station);
const markerColor = parts.model.radioCategoryColor(
parts.model.radioStationCategoryId(station),
);
const entity = layerState._dataSource.entities.add({
id: `${RADIO_PREFIX}${station.id}`,
position,
point: {
pixelSize: 13,
color: Cesium.Color.fromCssColorString(markerColor).withAlpha(0.86),
outlineColor: Cesium.Color.fromCssColorString('#071b25'),
outlineWidth: 1,
disableDepthTestDistance: Number.POSITIVE_INFINITY,
scaleByDistance: new Cesium.NearFarScalar(
100_000,
1.15,
12_000_000,
1,
),
distanceDisplayCondition: new Cesium.DistanceDisplayCondition(
0,
RADIO_GLOBE_INTERACTION_MAX_DISTANCE_M,
),
},
});
layerState._renderById.set(station.id, { station, entity, position });
}
updateSelectionEntity();
updateRenderVisibility();
}
function installClusterStyling() {
if (!layerState._dataSource || layerState._removeClusterListener) return;
const clustering = layerState._dataSource.clustering;
clustering.enabled = true;
clustering.pixelRange = 42;
clustering.minimumClusterSize = 3;
clustering.clusterPoints = true;
clustering.clusterLabels = false;
clustering.clusterBillboards = false;
layerState._removeClusterListener =
clustering.clusterEvent.addEventListener((clusteredEntities, cluster) => {
const clusteredStations = [];
for (const entity of clusteredEntities) {
const stationId = String(entity.id || '').slice(RADIO_PREFIX.length);
const station = layerState._renderById.get(stationId)?.station;
if (station) clusteredStations.push(station);
}
const clusterCategory = parts.model.radioClusterCategoryId(
clusteredStations,
layerState._filter,
);
const clusterColor = Cesium.Color.fromCssColorString(
parts.model.radioCategoryColor(clusterCategory),
);
// Cesium assigns the entity-id array only to the generated cluster label.
// Mirror it to the visible point so clicking either part of the callout
// resolves the first station and remains a direct playback gesture.
cluster.point.id = clusteredEntities;
cluster.billboard.id = clusteredEntities;
cluster.label.show = false;
cluster.label.text = '';
cluster.point.show = true;
cluster.point.pixelSize = Math.min(
26,
12 + Math.log2(clusteredEntities.length) * 1.6,
);
cluster.point.color = clusterColor.withAlpha(0.9);
cluster.point.outlineColor = Cesium.Color.BLACK;
cluster.point.outlineWidth = 2;
cluster.point.disableDepthTestDistance = Number.POSITIVE_INFINITY;
cluster.point.distanceDisplayCondition =
new Cesium.DistanceDisplayCondition(
0,
RADIO_GLOBE_INTERACTION_MAX_DISTANCE_M,
);
scheduleRadioOverlayPublish();
});
}
return {
markerPosition,
updateSelectionEntity,
clusterPointCollection,
publishRadioOverlayEntries,
scheduleRadioOverlayPublish,
updateRenderVisibility,
reconcileStations,
installClusterStyling,
};
}