mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 08:12:24 +00:00
Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>
332 lines
12 KiB
JavaScript
332 lines
12 KiB
JavaScript
import * as Cesium from 'cesium';
|
|
import { horizonOccluder } from '../../data/iconOrientation.js';
|
|
import { isHeadingEstimated } from './headingConfidence.js';
|
|
import {
|
|
ACTIVE_CAMERA_COLOR,
|
|
IDLE_CAMERA_COLOR,
|
|
ACTIVE_COVERAGE_CENTER,
|
|
IDLE_COVERAGE_CENTER_MUTED,
|
|
ACTIVE_COVERAGE_CENTER_DEPTHFAIL,
|
|
ACTIVE_COVERAGE_EDGE,
|
|
IDLE_COVERAGE_EDGE_MUTED,
|
|
ACTIVE_COVERAGE_EDGE_DEPTHFAIL,
|
|
} from './policy.js';
|
|
|
|
export function createRendering({
|
|
state: layerState,
|
|
services,
|
|
parts,
|
|
source,
|
|
}) {
|
|
const {
|
|
focusNowMs,
|
|
getFocusTarget,
|
|
focusPassIsNeeded,
|
|
advanceSpriteFocus,
|
|
focusAlphaNeedsWrite,
|
|
} = services.focus;
|
|
|
|
/**
|
|
* Focus modulation rides the layer's existing animation loop; no additional
|
|
* scene listener is installed. Only camera-icon alpha changes here — coverage
|
|
* geometry and monitor-plane styling retain their established cadence.
|
|
*/
|
|
|
|
function refreshCctvFocusStyles(nowMs) {
|
|
nowMs = focusNowMs(nowMs);
|
|
const target = getFocusTarget();
|
|
if (
|
|
!layerState._enabled ||
|
|
!layerState._viewer ||
|
|
!focusPassIsNeeded(target, layerState._activeFocusStyleCount)
|
|
)
|
|
return;
|
|
if (nowMs - layerState._lastFocusStyleAt < 80) return;
|
|
layerState._lastFocusStyleAt = nowMs;
|
|
const scene = layerState._viewer.scene;
|
|
const camera = layerState._viewer.camera;
|
|
const result = applyCctvFocusDeemphasis({
|
|
records: layerState._records,
|
|
target,
|
|
previousActiveCount: layerState._activeFocusStyleCount,
|
|
nowMs,
|
|
screenPositionFor: (position) =>
|
|
Cesium.SceneTransforms.worldToWindowCoordinates(
|
|
scene,
|
|
position,
|
|
layerState._scratchFocusScreen,
|
|
),
|
|
cameraDistanceFor: (position) =>
|
|
Cesium.Cartesian3.distance(camera.positionWC, position),
|
|
baseColorFor: (record) =>
|
|
record.camera.id === layerState._activeCameraId
|
|
? ACTIVE_CAMERA_COLOR
|
|
: IDLE_CAMERA_COLOR,
|
|
});
|
|
layerState._activeFocusStyleCount = result.activeCount;
|
|
}
|
|
|
|
/**
|
|
* Apply the gated CCTV focus pass through the production color path.
|
|
* @param {object} input
|
|
* @returns {{writes:number,transitioning:boolean,activeCount:number,ran:boolean}}
|
|
*/
|
|
|
|
function applyCctvFocusDeemphasis({
|
|
records,
|
|
target,
|
|
previousActiveCount = 0,
|
|
nowMs,
|
|
screenPositionFor,
|
|
cameraDistanceFor,
|
|
baseColorFor,
|
|
params,
|
|
}) {
|
|
if (!focusPassIsNeeded(target, previousActiveCount)) {
|
|
return { writes: 0, transitioning: false, activeCount: 0, ran: false };
|
|
}
|
|
let writes = 0;
|
|
let transitioning = false;
|
|
let activeCount = 0;
|
|
for (const record of records || []) {
|
|
const bb = record.billboard;
|
|
if (!bb) continue;
|
|
const position = bb.position;
|
|
// CCTV never publishes a tracked focus target, so every icon is ambient.
|
|
const focus = advanceSpriteFocus(bb, {
|
|
// Keep hidden icons in the state/release pass so the active count cannot
|
|
// drop while a stale dim alpha remains waiting to reappear.
|
|
screenPosition:
|
|
bb.show === false || !position ? null : screenPositionFor(position),
|
|
cameraDistance: position ? cameraDistanceFor(position) : Number.NaN,
|
|
nowMs,
|
|
target,
|
|
params,
|
|
spriteHalfWidthPx: (bb.width || 24) * (bb.scale || 1) * 0.5,
|
|
spriteHalfHeightPx: (bb.height || 24) * (bb.scale || 1) * 0.5,
|
|
});
|
|
transitioning ||= focus.transitioning;
|
|
if (focus.active) activeCount += 1;
|
|
const base = baseColorFor(record);
|
|
const alpha = base.alpha * focus.factor;
|
|
if (focusAlphaNeedsWrite(bb.color?.alpha, alpha, params)) {
|
|
// Order-independent narrow amendment to always-visible icons: CCTV
|
|
// contacts retain a non-zero floor while yielding near the tracked target.
|
|
bb.color = base.withAlpha(alpha);
|
|
writes += 1;
|
|
}
|
|
}
|
|
return { writes, transitioning, activeCount, ran: true };
|
|
}
|
|
|
|
/**
|
|
* Updates visual styles (colors, widths, visibility) for all camera billboards,
|
|
* coverage polylines, viewshed volumes, and projection entities based on which
|
|
* camera is active, whether the layer is enabled, and the current
|
|
* coverage-mode/projection toggle states.
|
|
*/
|
|
/**
|
|
* Field-test fix (2026-07-06): horizon-culls camera billboards, mirroring the
|
|
* flights layer's EllipsoidalOccluder pass. With the Cesium globe hidden
|
|
* (Google-3D regime) nothing writes far-side depth, and the billboards are now
|
|
* always-on-top (`disableDepthTestDistance: INFINITY` — the far-zoom submerge
|
|
* fix), so without this pass London's cluster would shine through the planet
|
|
* from a US viewpoint. Pure math over ≤ catalog-size points; runs on
|
|
* camera.moveEnd + init only (event-driven — no steady-state work).
|
|
*/
|
|
|
|
function refreshHorizonCulling() {
|
|
if (
|
|
!layerState._viewer ||
|
|
layerState._viewer.isDestroyed() ||
|
|
!layerState._records.length
|
|
)
|
|
return;
|
|
const occluder = horizonOccluder(layerState._viewer.camera);
|
|
for (const record of layerState._records) {
|
|
const bb = record.billboard;
|
|
if (!bb) continue;
|
|
const visible = occluder.isPointVisible(bb.position);
|
|
if (bb.show !== visible) bb.show = visible;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Hides every per-record CCTV visual without recomputing coverage membership or
|
|
* styles. Disabling makes every visibility branch false, so a direct sweep is
|
|
* sufficient; live viewshed primitives still require explicit destruction.
|
|
*
|
|
* @param {Object[]} records CCTV runtime records.
|
|
* @param {(record: Object) => void} destroyVolume Viewshed teardown callback.
|
|
* @param {string|null} [activeCameraId=null] Active camera whose activation probe must be re-armed.
|
|
*/
|
|
|
|
function hideCctvRecordVisuals(
|
|
records,
|
|
destroyVolume,
|
|
activeCameraId = null,
|
|
) {
|
|
for (const record of Array.isArray(records) ? records : []) {
|
|
if (record) {
|
|
record.probeClampRangeM = null;
|
|
if (record.camera?.id === activeCameraId) record.activationDone = false;
|
|
}
|
|
for (const entity of record?.coverageEntities || []) entity.show = false;
|
|
if (record?.viewshedPrimitive) destroyVolume?.(record);
|
|
if (record?.projection?.planeEntity)
|
|
record.projection.planeEntity.show = false;
|
|
}
|
|
}
|
|
|
|
function hideCctvVisuals() {
|
|
hideCctvRecordVisuals(
|
|
layerState._records,
|
|
parts.geometry.destroyViewshedVolume,
|
|
layerState._activeCameraId,
|
|
);
|
|
parts.projection.clearProjectionOverlay();
|
|
if (layerState._billboards) layerState._billboards.show = false;
|
|
parts.projection.pauseInactiveProjectionFeeds(null);
|
|
}
|
|
|
|
/** Applies coverage visibility/style state and lazily builds eligible sets. */
|
|
|
|
function refreshCoverageStyles() {
|
|
const activeRecord = parts.selection.getActiveRecord();
|
|
parts.geometry.ensureActiveCoverageEntities(activeRecord);
|
|
const activeId = activeRecord?.camera.id || null;
|
|
const coverageVisible =
|
|
parts.geometry.buildCoverageVisibleSet(activeRecord);
|
|
const coverageOn = layerState._coverageMode !== 'off';
|
|
const viewshedOn = layerState._coverageMode === 'viewshed';
|
|
if (coverageOn) {
|
|
parts.geometry.ensureVisibleCoverageEntities(
|
|
layerState._records,
|
|
coverageVisible,
|
|
);
|
|
}
|
|
for (const record of layerState._records) {
|
|
const isActive = record.camera.id === activeId;
|
|
if (record.billboard) {
|
|
record.billboard.color = isActive
|
|
? ACTIVE_CAMERA_COLOR
|
|
: IDLE_CAMERA_COLOR;
|
|
record.billboard.scale = isActive ? 1.25 : 1.0;
|
|
// disableDepthTestDistance stays POSITIVE_INFINITY for every billboard
|
|
// (set at creation) — see the field-test far-zoom submerge fix there.
|
|
}
|
|
|
|
if (
|
|
layerState._enabled &&
|
|
isActive &&
|
|
(layerState._showProjection ||
|
|
parts.model.isVideoFeedType(record.camera.feedType))
|
|
) {
|
|
parts.projection.ensureProjectionRuntime(record);
|
|
}
|
|
// One live plane in the world at a time (§2c): only the active camera's
|
|
// far cap carries the monitor plane; idle neighbors get the faint
|
|
// wireframe only.
|
|
const planeShowing = !!(
|
|
layerState._enabled &&
|
|
layerState._showProjection &&
|
|
isActive
|
|
);
|
|
|
|
const inVisibleSet = coverageVisible.has(record.camera.id);
|
|
// A synthetic bearing (headingConfidence 'low', no human calibration)
|
|
// draws its wireframe dashed so a guessed facing is visibly provisional
|
|
// rather than rendering identically to a surveyed one (#639). Colors,
|
|
// widths, and the active/idle emphasis are unchanged.
|
|
const bearingEstimated = isHeadingEstimated(record.camera);
|
|
const lineMaterial = (color) =>
|
|
bearingEstimated
|
|
? new Cesium.PolylineDashMaterialProperty({ color })
|
|
: color;
|
|
for (const entity of record.coverageEntities || []) {
|
|
// The frustum wireframe is part of the projection representation —
|
|
// force it on for the active camera and let it read through geometry
|
|
// via depthFailMaterial (polylines have no disableDepthTestDistance).
|
|
entity.show = !!(
|
|
layerState._enabled &&
|
|
((coverageOn && inVisibleSet) || planeShowing)
|
|
);
|
|
if (!entity.polyline) continue;
|
|
// Viewshed mode swaps the cyan/green scheme for the camera's own hue so
|
|
// adjacent cones read as distinct coverage claims (design §3b); the
|
|
// active camera keeps its width/alpha emphasis in both schemes.
|
|
const hue = viewshedOn ? record.viewshedColors : null;
|
|
if (entity._coverageRole === 'cap') {
|
|
entity.polyline.material = lineMaterial(
|
|
hue
|
|
? isActive
|
|
? hue.lineActive
|
|
: hue.line
|
|
: isActive
|
|
? ACTIVE_COVERAGE_CENTER
|
|
: IDLE_COVERAGE_CENTER_MUTED,
|
|
);
|
|
entity.polyline.width = isActive ? 2.2 : 1.0;
|
|
entity.polyline.depthFailMaterial = planeShowing
|
|
? hue
|
|
? hue.line.withAlpha(0.26)
|
|
: ACTIVE_COVERAGE_CENTER_DEPTHFAIL
|
|
: undefined;
|
|
} else {
|
|
entity.polyline.material = lineMaterial(
|
|
hue
|
|
? isActive
|
|
? hue.lineActive
|
|
: hue.line.withAlpha(0.6)
|
|
: isActive
|
|
? ACTIVE_COVERAGE_EDGE
|
|
: IDLE_COVERAGE_EDGE_MUTED,
|
|
);
|
|
entity.polyline.width = isActive ? 1.8 : 0.9;
|
|
entity.polyline.depthFailMaterial = planeShowing
|
|
? hue
|
|
? hue.line.withAlpha(0.18)
|
|
: ACTIVE_COVERAGE_EDGE_DEPTHFAIL
|
|
: undefined;
|
|
}
|
|
}
|
|
|
|
// Viewshed volume lifecycle: exists iff enabled + viewshed mode + in the
|
|
// visible set. Rebuild on active-tint flips (rare); otherwise leave the
|
|
// primitive alone so idle refreshes never churn geometry.
|
|
const wantVolume = !!(
|
|
layerState._enabled &&
|
|
viewshedOn &&
|
|
inVisibleSet &&
|
|
record.frustumPositions
|
|
);
|
|
if (wantVolume) {
|
|
if (
|
|
!record.viewshedPrimitive ||
|
|
record.viewshedActiveTint !== isActive
|
|
) {
|
|
parts.geometry.rebuildViewshedVolume(record, isActive);
|
|
}
|
|
} else if (record.viewshedPrimitive) {
|
|
parts.geometry.destroyViewshedVolume(record);
|
|
}
|
|
|
|
if (record.projection) {
|
|
parts.projection.setPlaneVisible(record.projection, planeShowing);
|
|
}
|
|
}
|
|
|
|
if (layerState._billboards)
|
|
layerState._billboards.show = !!layerState._enabled;
|
|
parts.projection.pauseInactiveProjectionFeeds(activeId);
|
|
}
|
|
return {
|
|
refreshCctvFocusStyles,
|
|
applyCctvFocusDeemphasis,
|
|
refreshHorizonCulling,
|
|
hideCctvRecordVisuals,
|
|
hideCctvVisuals,
|
|
refreshCoverageStyles,
|
|
};
|
|
}
|