mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-22 03:02:20 +00:00
Main's work since the last merge runs on the globe contract where this branch draws through it: - Satellites take main's classes, sensors, ground-track bearings and world time through contract points and rings; launches take the world timeline. The satellite's cockpit subject dims, copies positions and refocuses through the contract. - Flights, military and vessels keep main's photos, retry cool-downs, world-clock motion and the ship bridge. Trail seeding in the shared aircraft tracking reads each layer's clock. - Traffic's flow lines and single build draw as ground sets; transit keeps dated credits and the new cities; CCTV opens the nearest camera, and the Quebec overlay projects and tests the horizon through the contract. Bikeshare's manager cleanup moved into its current lifecycle. - Draw keeps main's mark actions across engine switches. - The world clock in src/time is plain numbers again: Julian dates come from src/geo, the frame loop is injected, and the binding to Cesium's viewer clock lives in src/globe/cesium/worldTime.js. Navara's sky and sun follow the world time; live feeds keep the real time. - The cockpit's orbital view, with its sensor zoom, ground focus and satellite switching, stays Cesium-only for now: Navara hides its entry. Its Cesium calls live in src/globe/cesium/orbital.js. The ship bridge's finest-detail waterline sampling is Cesium-only too; Navara samples loaded geometry and detailed terrain. Both are in KNOWN-ISSUES. - Main's tests that built a Cesium scene by hand run on the fake engine. - The boundary manifest is regenerated, the coupling baseline records the orbital and bridge code, and the main-chunk baseline is raised to the merged size: main itself grew its main chunk by 93,959 bytes (gzip -9) since the previous merge base.
207 lines
8.7 KiB
JavaScript
207 lines
8.7 KiB
JavaScript
export function createSelection({
|
|
state: layerState,
|
|
services,
|
|
parts,
|
|
source,
|
|
}) {
|
|
const { CCTV_ACTIVATION_RESULT } = services.activation;
|
|
const { resolvePickId } = services.picking;
|
|
|
|
/**
|
|
* Returns the camera record for the currently active camera. A stale ID falls
|
|
* back to the first record, but an intentional null remains an honest
|
|
* deselected state.
|
|
* @returns {Object|null} Active camera record, or null when none is active.
|
|
*/
|
|
|
|
function getActiveRecord() {
|
|
if (!layerState._activeCameraId) return null;
|
|
if (layerState._recordById.has(layerState._activeCameraId)) {
|
|
return layerState._recordById.get(layerState._activeCameraId);
|
|
}
|
|
// Sync _activeCameraId when falling back to first record to prevent ID mismatch
|
|
const fallback = layerState._records[0] || null;
|
|
if (fallback && fallback.camera?.id) {
|
|
layerState._activeCameraId = fallback.camera.id;
|
|
}
|
|
return fallback;
|
|
}
|
|
|
|
/**
|
|
* Sets the active camera by ID, initializes its projection runtime, refreshes
|
|
* its frame, and updates styles.
|
|
* @param {string} cameraId - ID of the camera to activate.
|
|
* @returns {'activated'|'unchanged'|'not-found'} Discriminated activation result.
|
|
*/
|
|
|
|
function setActiveCamera(cameraId) {
|
|
if (!cameraId || !layerState._recordById.has(cameraId))
|
|
return CCTV_ACTIVATION_RESULT.NOT_FOUND;
|
|
const record = layerState._recordById.get(cameraId);
|
|
const previousActiveRecord = getActiveRecord();
|
|
// Re-selecting the already-active camera is a no-op: re-running the
|
|
// activation path re-probes and rewrites the plane entity's geometry, and
|
|
// that async primitive rebuild visibly flashes the monitor plane (owner
|
|
// field test 2026-07-04 — every click ON the plane picks its own camera).
|
|
// `activationDone` distinguishes a real activation from the enable()-time
|
|
// default `_activeCameraId` assignment, which never ran this path.
|
|
if (
|
|
!parts.model.cctvRecordNeedsActivation(
|
|
cameraId,
|
|
layerState._activeCameraId,
|
|
record,
|
|
)
|
|
) {
|
|
// Browser-only feeds have a separate player; a reselect retries it
|
|
// without re-running activation or touching the projection geometry.
|
|
if (parts.model.isBrowserOverlayCamera(record.camera)) {
|
|
layerState._activeCameraReselection += 1;
|
|
parts.presentation.notifyListeners();
|
|
}
|
|
return CCTV_ACTIVATION_RESULT.UNCHANGED;
|
|
}
|
|
layerState._activeCameraId = cameraId;
|
|
layerState._autoHopSuspended = false;
|
|
layerState._openingCameraProvisional = false;
|
|
// A real activation creates projection work — wake the self-stopping loop.
|
|
parts.projection.startProjectionLoop();
|
|
if (previousActiveRecord && previousActiveRecord !== record) {
|
|
parts.geometry.clearProbeClampOnDeactivation(
|
|
previousActiveRecord,
|
|
(previous) => {
|
|
parts.geometry.applyFrustumGeometry(
|
|
previous,
|
|
parts.ground.groundAltFor(previous),
|
|
);
|
|
},
|
|
);
|
|
}
|
|
// The clicked camera leaves the ambient quota immediately (never graced).
|
|
// Shipped behavior publishes no card for it because the monitor plane is
|
|
// now the active representation; the opt-in protected-card path republishes
|
|
// it synchronously through refreshAmbientCards() below.
|
|
layerState._cardIds.delete(cameraId);
|
|
layerState._cardGraceState.delete(cameraId);
|
|
// Activating the hovered camera consumes the transient pin; the active
|
|
// monitor plane replaces it from this moment.
|
|
if (layerState._hoverCardId === cameraId) parts.hover.clearHoverCard();
|
|
// If the record's geometry refinement is still queued, jump it to the front
|
|
// so the newly active camera resolves before idle neighbors.
|
|
const queueIdx = layerState._geoQueue.indexOf(record);
|
|
if (queueIdx > 0) {
|
|
layerState._geoQueue.splice(queueIdx, 1);
|
|
layerState._geoQueue.unshift(record);
|
|
}
|
|
// §9.1: one obstruction probe per activation, BEFORE the geometry pass so
|
|
// the range clamp lands in the same rewrite. A FIRST-EVER activation (no
|
|
// real ground sample yet) probes from the catalog-prior altitude — if that
|
|
// prior is off, the clamp is measured from a shifted origin, but a
|
|
// re-activation after the one-shot snap lands re-probes from real ground,
|
|
// so it self-corrects.
|
|
parts.geometry.runActivationObstructionProbe(record);
|
|
// Coverage is activation-lazy even while the mode is OFF: the active
|
|
// camera's projection representation must be ready without materializing
|
|
// any idle neighbor. The following geometry rewrite welds these entities to
|
|
// the current sampled positions.
|
|
parts.geometry.ensureActiveCoverageEntities(record);
|
|
parts.projection.ensureProjectionRuntime(record);
|
|
parts.frames.refreshProjectionImage(record, true);
|
|
// FIX B9b: an explicit user (re)select re-arms one real ground sample for the
|
|
// newly-active camera, then freezes. Idle neighbors keep their resolved state.
|
|
// FIX B9c: if tiles are ready this real pass applies + re-resolves
|
|
// immediately; if tiles are still streaming, updateRecordGeometry's fallback
|
|
// guard recomputes purely from the cached real ground (the pose + the probe
|
|
// clamp above still land — no scene queries) and the record stays unresolved
|
|
// until update()'s one-shot tiles-ready completion pass re-grounds it.
|
|
parts.ground.rearmGroundResolution(record);
|
|
parts.geometry.updateRecordGeometry(record);
|
|
// Ground under the plane's footprint (DEM, cached proxy) for cameras
|
|
// without a shipped precompute for this pose — only the camera the user
|
|
// is looking at ever asks.
|
|
void parts.ground.resolveFootprintGround(record);
|
|
record.activationDone = true;
|
|
parts.rendering.refreshCoverageStyles();
|
|
// The active camera's icon always shows; the previously active one
|
|
// competes for its cell again. Its coverage neighbours join the working
|
|
// set and are queued for grounding.
|
|
parts.rendering.refreshHorizonCulling();
|
|
parts.geometryQueue.enqueueViewGeometry();
|
|
// The newly active camera leaves the ambient ring (its monitor plane takes
|
|
// over); the freed slot re-fills on this same pass.
|
|
parts.cards.refreshAmbientCards();
|
|
// ADJUST mode follows the active camera.
|
|
layerState._gizmo?.refresh();
|
|
parts.presentation.notifyListeners();
|
|
return CCTV_ACTIVATION_RESULT.ACTIVATED;
|
|
}
|
|
|
|
/**
|
|
* Clears the active CCTV camera in place without moving the viewer or
|
|
* disabling the layer. The normal selection-refresh path releases the active
|
|
* projection, emphasis, and probe state while ambient cards remain available.
|
|
* @returns {boolean} True when a camera was deactivated.
|
|
*/
|
|
|
|
function deactivateActiveCamera() {
|
|
const record = layerState._activeCameraId
|
|
? layerState._recordById.get(layerState._activeCameraId)
|
|
: null;
|
|
if (!record) return false;
|
|
layerState._activeCameraId = null;
|
|
layerState._autoHopSuspended = true;
|
|
layerState._openingCameraProvisional = false;
|
|
record.activationDone = false;
|
|
parts.geometry.clearProbeClampOnDeactivation(record, (previous) => {
|
|
parts.geometry.applyFrustumGeometry(
|
|
previous,
|
|
parts.ground.groundAltFor(previous),
|
|
);
|
|
});
|
|
parts.rendering.refreshHorizonCulling();
|
|
parts.rendering.refreshCoverageStyles();
|
|
parts.geometryQueue.enqueueViewGeometry();
|
|
parts.cards.refreshAmbientCards();
|
|
layerState._gizmo?.refresh();
|
|
parts.presentation.notifyListeners();
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* True only for a clean click that is empty from CCTV's perspective: an
|
|
* active camera exists, ADJUST does not own the pointer, and the scene pick
|
|
* carries no canonical object ID. Any identified scene object is non-empty,
|
|
* including selectable siblings that do not participate in the pick registry.
|
|
* @param {Object|null} picked - `scene.pick()` result.
|
|
* @param {Object} [context]
|
|
* @param {string|null} [context.activeCameraId]
|
|
* @param {boolean} [context.calibrationMode]
|
|
* @returns {boolean}
|
|
*/
|
|
|
|
function cctvEmptyClickDeselects(
|
|
picked,
|
|
{ activeCameraId = null, calibrationMode = false } = {},
|
|
) {
|
|
if (!activeCameraId || calibrationMode) return false;
|
|
return resolvePickId(picked) === null;
|
|
}
|
|
|
|
/**
|
|
* Extracts a camera ID from a Cesium pick result by checking billboard IDs,
|
|
* primitive IDs, and entity cctvCameraId properties.
|
|
* @param {Object|null} picked - Result from scene.pick().
|
|
* @returns {string|null} Camera ID, or null if the pick is not a CCTV entity.
|
|
*/
|
|
|
|
function extractPickedCameraId(picked) {
|
|
return parts.renderer?.extractPickedCameraId(picked) ?? null;
|
|
}
|
|
return {
|
|
getActiveRecord,
|
|
setActiveCamera,
|
|
deactivateActiveCamera,
|
|
cctvEmptyClickDeselects,
|
|
extractPickedCameraId,
|
|
};
|
|
}
|