mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-18 17:22:19 +00:00
The scene renders at CSS resolution and is stretched on a high-density display, so a count marker drawn as a scene sprite looked coarse next to the camera callouts, which the world overlay paints at device density. Paint the markers through the overlay's custom paint lane instead, in the callouts' typeface. Each paint reprojects the group centres; a click is resolved against the rectangles painted in the last frame and still zooms to the group without choosing a camera. A marker that would cover HUD chrome is skipped, as overlay entries are. With no aggregate sprites left, the contact sweep no longer needs to skip them, so that exclusion is removed.
234 lines
9.6 KiB
JavaScript
234 lines
9.6 KiB
JavaScript
import { isTrackingClickGesture } from '../../data/trackingClickGesture.js';
|
|
|
|
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;
|
|
}
|
|
|
|
/**
|
|
* Bind CCTV activation to clean taps. Drag-like and long-press gestures do
|
|
* not reach camera activation or focus dispatch.
|
|
* @param {import('../../input/dispatcher.js').InputDispatcher} input
|
|
* @param {(event: import('../../input/dispatcher.js').ClickEvent) => void} onClick
|
|
* Accepted CCTV click callback.
|
|
* @returns {() => void} Unsubscribe.
|
|
*/
|
|
|
|
function bindCctvWorldClickGesture(input, onClick) {
|
|
return input.onClick((event) => {
|
|
if (!isTrackingClickGesture(event.gesture)) return;
|
|
const cell =
|
|
layerState._enabled &&
|
|
layerState._counts?.pickedCell(event.screenPosition);
|
|
if (cell) {
|
|
parts.navigation.zoomToCell(cell);
|
|
return;
|
|
}
|
|
onClick(event);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* 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, cast before the geometry
|
|
// pass; its range clamp lands a microtask later, before the next frame,
|
|
// rewriting the geometry and asking again for the footprint ground. 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;
|
|
// 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.rendering.refreshCoverageStyles();
|
|
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;
|
|
}
|
|
|
|
/**
|
|
* The camera a scene pick result is, or null: read by the rendering part,
|
|
* which owns the scene objects the pick names.
|
|
* @param {Object|null} picked - Result from a scene pick.
|
|
* @returns {string|null}
|
|
*/
|
|
|
|
function extractPickedCameraId(picked) {
|
|
return parts.rendering.extractPickedCameraId(picked);
|
|
}
|
|
return {
|
|
getActiveRecord,
|
|
bindCctvWorldClickGesture,
|
|
setActiveCamera,
|
|
deactivateActiveCamera,
|
|
cctvEmptyClickDeselects,
|
|
extractPickedCameraId,
|
|
};
|
|
}
|