From a8f41d30fcba8945d3368ae934013a4983c4a312 Mon Sep 17 00:00:00 2001 From: Sameh Khamis Date: Sat, 7 Nov 2026 00:41:32 -0800 Subject: [PATCH] Keep the camera layer's Cesium picks, entities and projection in its rendering part The camera layer's lifecycle, cards, geometry, hover and selection parts had left the Cesium allow-list but still drove the scene: Cesium camera move events, scene picks and pick objects, entity removal, the activation ray probe and the cards' canvas projection. The move events now come from the camera port and card render requests go through the frame port; the rest moves into the rendering part, which stays listed. The move listeners are attached and released in one place, with a test. --- src/layers/cctv/cards.js | 42 +++++----- src/layers/cctv/geometry.js | 17 +--- src/layers/cctv/hover.js | 10 +-- src/layers/cctv/lifecycle.js | 129 ++++++++++++++--------------- src/layers/cctv/lifecycle.test.mjs | 73 ++++++++++++++++ src/layers/cctv/rendering.js | 122 +++++++++++++++++++++++++-- src/layers/cctv/rendering.test.mjs | 61 ++++++++++++++ src/layers/cctv/selection.js | 48 ++--------- src/layers/cctv/state.js | 7 +- 9 files changed, 348 insertions(+), 161 deletions(-) create mode 100644 src/layers/cctv/lifecycle.test.mjs diff --git a/src/layers/cctv/cards.js b/src/layers/cctv/cards.js index 2aeccf9ca..1cf88ee2e 100644 --- a/src/layers/cctv/cards.js +++ b/src/layers/cctv/cards.js @@ -1,3 +1,4 @@ +import { findFrame } from '../../render/rendererOf.js'; import { createFrameSlot, CCTV_OVERLAY_SOURCE_ID, @@ -8,7 +9,6 @@ import { CCTV_FRAME_CANVAS_H, applyFrameResult, } from '../../data/cctvCards.js'; -import { horizonOccluder } from '../../data/iconOrientation.js'; import { selectCctvLod, applyEvictionGrace } from '../../data/cctvLod.js'; import { CCTV_OVERLAY_SOURCE_OPTIONS, @@ -34,7 +34,7 @@ export function createCards({ state: layerState, services, parts, source }) { } = {}) { layerState._activeCameraCardEnabled = activeCameraCardEnabled === true; if (layerState._enabled) pushAmbientCardEntries(); - layerState._viewer?.scene?.requestRender?.(); + findFrame(layerState._viewer)?.requestRender('cctv-cards'); return { activeCameraCardEnabled: layerState._activeCameraCardEnabled }; } @@ -82,7 +82,6 @@ export function createCards({ state: layerState, services, parts, source }) { ); return; } - const scene = layerState._viewer.scene; // An eye with no geographic position (the earth's centre) measures from 0, 0. const pose = parts.model.eyePose(); const viewerLat = pose ? pose.lat : 0; @@ -91,9 +90,8 @@ export function createCards({ state: layerState, services, parts, source }) { // after its async activation settles). It is published separately in the // protected lane below, and grace never applies to it. const activeId = layerState._activeCameraId; - const occluder = horizonOccluder(layerState._viewer.camera); - const width = scene.canvas.clientWidth || scene.canvas.width || 0; - const height = scene.canvas.clientHeight || scene.canvas.height || 0; + const view = parts.rendering.cardView(); + const { width, height } = view; const marginX = width * CARD_VIEW_MARGIN; const marginY = height * CARD_VIEW_MARGIN; @@ -106,22 +104,20 @@ export function createCards({ state: layerState, services, parts, source }) { let inView = false; let sx = NaN; let sy = NaN; - if (occluder.isPointVisible(record.position)) { - const screen = scene.cartesianToCanvasCoordinates(record.position); - if ( - screen && - Number.isFinite(screen.x) && - Number.isFinite(screen.y) && - screen.x >= -marginX && - screen.x <= width + marginX && - screen.y >= -marginY && - screen.y <= height + marginY - ) { - inView = true; - sx = screen.x; - sy = screen.y; - screenById.set(id, { sx, sy }); - } + const screen = view.screenOf(record.position); + if ( + screen && + Number.isFinite(screen.x) && + Number.isFinite(screen.y) && + screen.x >= -marginX && + screen.x <= width + marginX && + screen.y >= -marginY && + screen.y <= height + marginY + ) { + inView = true; + sx = screen.x; + sy = screen.y; + screenById.set(id, { sx, sy }); } candidates.push({ id, @@ -333,7 +329,7 @@ export function createCards({ state: layerState, services, parts, source }) { slot, applyFrameResult(slot, { ok: !!frame, frame }, Date.now()), ); - layerState._viewer?.scene?.requestRender?.(); + findFrame(layerState._viewer)?.requestRender('cctv-card-frame'); }; image.onload = () => settle(true); image.onerror = () => settle(false); diff --git a/src/layers/cctv/geometry.js b/src/layers/cctv/geometry.js index 463802f37..d596db5b5 100644 --- a/src/layers/cctv/geometry.js +++ b/src/layers/cctv/geometry.js @@ -540,8 +540,7 @@ export function createGeometry({ state: layerState, services, parts, source }) { function runActivationObstructionProbe(record) { record.probeClampRangeM = null; - const scene = layerState._viewer?.scene; - if (!scene || typeof scene.pickFromRay !== 'function') return; + if (!parts.rendering.canPickFromRay()) return; const camera = record.camera; const rangeScale = parts.calibration.normalizeCalibration( camera.calibration, @@ -551,14 +550,8 @@ export function createGeometry({ state: layerState, services, parts, source }) { const mountAlt = parts.ground.groundAltFor(record) + camera.mountHeightM; const mountPos = fromDegrees(camera.lon, camera.lat, mountAlt); const { dir } = frustumFrameEcef(camera, mountPos); - // Exclude everything the layer itself draws so the probe can only hit the - // world (3D tiles), not our own polylines/planes. Icons never draw into - // ray picks. - const exclude = [...layerState._coverageEntities]; - for (const runtime of layerState._projectionEntities) { - if (runtime?.planeEntity) exclude.push(runtime.planeEntity); - } - const hit = parts.rendering.pickFromRay(mountPos, dir, exclude); + // The rendering part sees through everything the layer draws. + const hit = parts.rendering.obstructionHit(mountPos, dir); if (!hit?.position) return; const dist = distance(mountPos, hit.position); record.probeClampRangeM = activationProbeClampRange(camera.rangeM, dist); @@ -666,9 +659,7 @@ export function createGeometry({ state: layerState, services, parts, source }) { function destroyCoverageEntities() { if (!layerState._viewer) return; - for (const entity of layerState._coverageEntities) { - layerState._viewer.entities.remove(entity); - } + parts.rendering.removeCoverageEntities(); layerState._coverageEntities = []; for (const record of layerState._records) { diff --git a/src/layers/cctv/hover.js b/src/layers/cctv/hover.js index cdd3375bf..c90300cb8 100644 --- a/src/layers/cctv/hover.js +++ b/src/layers/cctv/hover.js @@ -10,7 +10,7 @@ export function createHover({ state: layerState, services, parts, source }) { * Throttled MOUSE_MOVE hover pass (owner round 2, item B): pointing at a * camera icon that has no card summons its card immediately. This is * EVENT-DRIVEN picking on a user gesture, not steady-state work — the - * ≥120 ms throttle caps it at ~8 scene.pick calls/s while the pointer is + * ≥120 ms throttle caps it at ~8 scene picks/s while the pointer is * actually moving (a still pointer costs nothing), so it can never approach * per-frame cost. Skipped while the camera is in motion, while ADJUST mode * owns the pointer (gizmo drags), and while the layer is disabled. @@ -29,13 +29,7 @@ export function createHover({ state: layerState, services, parts, source }) { const now = Date.now(); if (now - layerState._hoverLastPickAt < HOVER_PICK_THROTTLE_MS) return; layerState._hoverLastPickAt = now; - let picked = null; - try { - picked = layerState._viewer.scene.pick(position); - } catch { - picked = null; - } - const cameraId = parts.selection.extractPickedCameraId(picked); + const cameraId = parts.rendering.pickCameraIdAt(position); if (cameraId && cameraId === layerState._hoverCardId) { // Still on the hovered camera — keep the card alive. cancelHoverRelease(); diff --git a/src/layers/cctv/lifecycle.js b/src/layers/cctv/lifecycle.js index 4adb3d787..8089dc7cd 100644 --- a/src/layers/cctv/lifecycle.js +++ b/src/layers/cctv/lifecycle.js @@ -97,6 +97,58 @@ export function createLifecycle({ layerState._viewMotionTimer = 0; } + /** + * Listen for the camera's moves on the viewer's camera port: hover picking + * pauses while it moves, and the view pass reruns on an interval until the + * move ends, then once more. A re-init against a new viewer moves the + * listeners to its camera; one against the same viewer keeps them. + */ + function attachViewListeners() { + const viewCamera = findCamera(layerState._viewer); + if ( + layerState._viewListenerCamera && + layerState._viewListenerCamera !== viewCamera + ) { + layerState._horizonCullListener?.(); + layerState._moveStartListener?.(); + layerState._horizonCullListener = null; + layerState._moveStartListener = null; + layerState._cameraMoving = false; + } + layerState._viewListenerCamera = viewCamera; + if (!layerState._horizonCullListener && viewCamera) { + // Ambient cards piggyback the same settle event: moveEnd-driven + // reselection only, never per frame (refreshAmbientCards no-ops while + // the layer is disabled). + layerState._horizonCullListener = viewCamera.on('moveEnd', () => { + layerState._cameraMoving = false; + stopViewMotionTimer(); + settleView(); + }); + } + if (!layerState._moveStartListener && viewCamera) { + // Item B: hover picking pauses while the camera is in motion. A long + // move (cockpit flight, a drag) never settles, so the view pass also + // reruns on an interval until it does. + layerState._moveStartListener = viewCamera.on('moveStart', () => { + layerState._cameraMoving = true; + // enable() starts it for a move already under way. + if (layerState._enabled) startViewMotionTimer(); + }); + } + } + + /** Drop the move listeners; nothing reports the end of a move after it. */ + function detachViewListeners() { + layerState._horizonCullListener?.(); + layerState._horizonCullListener = null; + layerState._moveStartListener?.(); + layerState._moveStartListener = null; + layerState._cameraMoving = false; + layerState._viewListenerCamera = null; + stopViewMotionTimer(); + } + /** Resets all module-scoped runtime state to initial values. */ function clearRuntimeState() { @@ -310,51 +362,7 @@ export function createLifecycle({ // Field-test fix (2026-07-06): horizon-cull on camera settle (pairs with // the icons' always-on-top drawing) + one initial pass so the // first paint is already culled. - // A re-init against a new viewer moves the move listeners to its camera. - if ( - layerState._viewListenerCamera && - layerState._viewListenerCamera !== layerState._viewer.camera - ) { - const previous = layerState._viewListenerCamera; - if (layerState._horizonCullListener) - previous.moveEnd?.removeEventListener( - layerState._horizonCullListener, - ); - if (layerState._moveStartListener) - previous.moveStart?.removeEventListener( - layerState._moveStartListener, - ); - layerState._horizonCullListener = null; - layerState._moveStartListener = null; - layerState._cameraMoving = false; - } - layerState._viewListenerCamera = layerState._viewer.camera; - if (!layerState._horizonCullListener) { - // Ambient cards piggyback the same settle event: moveEnd-driven - // reselection only, never per frame (refreshAmbientCards no-ops while - // the layer is disabled). - layerState._horizonCullListener = () => { - layerState._cameraMoving = false; - stopViewMotionTimer(); - settleView(); - }; - layerState._viewer.camera.moveEnd.addEventListener( - layerState._horizonCullListener, - ); - } - if (!layerState._moveStartListener) { - // Item B: hover picking pauses while the camera is in motion. A long - // move (cockpit flight, a drag) never settles, so the view pass also - // reruns on an interval until it does. - layerState._moveStartListener = () => { - layerState._cameraMoving = true; - // enable() starts it for a move already under way. - if (layerState._enabled) startViewMotionTimer(); - }; - layerState._viewer.camera.moveStart.addEventListener( - layerState._moveStartListener, - ); - } + attachViewListeners(); // A resize or rotation changes what is on screen without moving the // camera. const canvas = layerState._viewer.scene?.canvas; @@ -538,10 +546,10 @@ export function createLifecycle({ /** * Tears down the layer: destroys click handler, projection loop, coverage - * entities, icons, and clears all runtime state and subscribers. - * @param {object} [viewer] - Viewer instance (falls back to stored ref). + * entities, icons, and clears all runtime state and subscribers. It + * releases what init attached, whichever viewer it is handed. */ - destroy(viewer) { + destroy() { services.credits?.hideOsmCredit?.(layerState._viewer, 'cctv'); layerState._sourceAbort?.abort(); if (typeof document !== 'undefined') @@ -557,23 +565,7 @@ export function createLifecycle({ ); layerState._mapStackListener = null; } - const teardownViewer = viewer || layerState._viewer; - if (layerState._horizonCullListener && teardownViewer?.camera?.moveEnd) { - teardownViewer.camera.moveEnd.removeEventListener( - layerState._horizonCullListener, - ); - layerState._horizonCullListener = null; - } - if (layerState._moveStartListener && teardownViewer?.camera?.moveStart) { - teardownViewer.camera.moveStart.removeEventListener( - layerState._moveStartListener, - ); - layerState._moveStartListener = null; - } - // The move listeners are gone; nothing will report the end of a move. - layerState._cameraMoving = false; - layerState._viewListenerCamera = null; - stopViewMotionTimer(); + detachViewListeners(); layerState._viewResizeObserver?.disconnect(); layerState._viewResizeObserver = null; layerState._viewResizeCanvas = null; @@ -601,5 +593,10 @@ export function createLifecycle({ }, }; - return { clearRuntimeState, methods }; + return { + clearRuntimeState, + attachViewListeners, + detachViewListeners, + methods, + }; } diff --git a/src/layers/cctv/lifecycle.test.mjs b/src/layers/cctv/lifecycle.test.mjs new file mode 100644 index 000000000..ae36ba21d --- /dev/null +++ b/src/layers/cctv/lifecycle.test.mjs @@ -0,0 +1,73 @@ +import { test } from 'node:test'; +import assert from 'node:assert/strict'; +import { createLifecycle } from './lifecycle.js'; +import { bindRenderer } from '../../render/rendererOf.js'; +import { fakeCameraPort } from '../../testSupport/fakeCameraPort.mjs'; + +function viewerWithCamera() { + const camera = fakeCameraPort(); + const viewer = {}; + bindRenderer(viewer, { camera: camera.port }); + return { viewer, camera }; +} + +function lifecycleFor(state) { + const passes = []; + const lifecycle = createLifecycle({ + state, + services: { + sprites: {}, + activation: {}, + picking: {}, + focus: {}, + render: {}, + }, + parts: { + rendering: { + refreshHorizonCulling: () => { + passes.push('view'); + return false; + }, + }, + geometryQueue: { enqueueViewGeometry() {} }, + cards: { refreshAmbientCards() {} }, + presentation: { notifyListeners() {} }, + }, + }); + return { lifecycle, passes }; +} + +test('the view listeners follow the camera port and let go on teardown', () => { + const first = viewerWithCamera(); + const state = { _viewer: first.viewer, _enabled: false }; + const { lifecycle, passes } = lifecycleFor(state); + const counts = (camera) => [ + camera.listenerCount('moveStart'), + camera.listenerCount('moveEnd'), + ]; + + lifecycle.attachViewListeners(); + assert.deepEqual(counts(first.camera), [1, 1]); + first.camera.emit('moveStart'); + assert.equal(state._cameraMoving, true, 'hover pauses while moving'); + first.camera.emit('moveEnd'); + assert.equal(state._cameraMoving, false); + assert.deepEqual(passes, ['view'], 'a settled move reruns the view pass'); + + // A re-init on the same viewer keeps its listeners. + lifecycle.attachViewListeners(); + assert.deepEqual(counts(first.camera), [1, 1]); + + // One on a new viewer moves them to its camera. + const second = viewerWithCamera(); + state._viewer = second.viewer; + first.camera.emit('moveStart'); + lifecycle.attachViewListeners(); + assert.equal(state._cameraMoving, false, 'the old move is forgotten'); + assert.deepEqual(counts(first.camera), [0, 0]); + assert.deepEqual(counts(second.camera), [1, 1]); + + lifecycle.detachViewListeners(); + assert.deepEqual(counts(second.camera), [0, 0]); + assert.equal(state._viewListenerCamera, null); +}); diff --git a/src/layers/cctv/rendering.js b/src/layers/cctv/rendering.js index e9581ba5b..a15dd97d6 100644 --- a/src/layers/cctv/rendering.js +++ b/src/layers/cctv/rendering.js @@ -21,6 +21,7 @@ import { writeHoldSegment } from '../../data/iconSegment.js'; import { IconSetPrimitive } from '../../data/iconSetPrimitive.js'; import { iconAtlas } from '../../data/iconAtlas.js'; import { cctvPicks } from './pickState.js'; +import { horizonOccluder } from '../../data/iconOrientation.js'; import { frustumVolumeGeometryData } from '../../data/cctvViewshed.js'; import { entityRecord } from '../../data/entityRecords.js'; import { toColor } from '../../render/cesium/draw.js'; @@ -810,15 +811,121 @@ export function createRendering({ * layer's own entities). * @param {{x: number, y: number, z: number}} origin - ECEF ray origin. * @param {{x: number, y: number, z: number}} direction - Unit ECEF direction. - * @param {Object[]} exclude - Entities to see through. - * @returns {{position?: object}|undefined} + * @returns {{position?: object}|undefined} Undefined as well when the + * scene cannot pick along a ray. */ - function pickFromRay(origin, direction, exclude) { - const scene = layerState._viewer.scene; + function obstructionHit(origin, direction) { + const scene = layerState._viewer?.scene; + if (!scene || typeof scene.pickFromRay !== 'function') return undefined; + // Exclude everything the layer itself draws so the probe can only hit the + // world (3D tiles), not our own polylines/planes. Icons never draw into + // ray picks. + const exclude = [...layerState._coverageEntities]; + for (const runtime of layerState._projectionEntities) { + if (runtime?.planeEntity) exclude.push(runtime.planeEntity); + } return scene.pickFromRay(new Cesium.Ray(origin, direction), exclude); } + /** Whether the scene can pick along a ray (the activation probe needs it). */ + function canPickFromRay() { + return typeof layerState._viewer?.scene?.pickFromRay === 'function'; + } + + /** Removes the layer's coverage entities from the scene. */ + function removeCoverageEntities() { + const viewer = layerState._viewer; + if (!viewer) return; + for (const entity of layerState._coverageEntities) { + viewer.entities.remove(entity); + } + } + + /** + * Extracts a camera ID from a scene pick result by checking icon row IDs, + * primitive IDs, and the camera ids the layer keeps for its coverage entities. + * @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) { + if (!picked) return null; + + const entity = cctvPicks.read(picked.id) + ? picked.id + : cctvPicks.read(picked.primitive?.id) + ? picked.primitive.id + : null; + const value = cctvPicks.read(entity)?.cameraId; + if (value !== undefined) { + const record = + typeof value === 'string' ? layerState._recordById.get(value) : null; + const ownsCoverageEntity = Boolean( + record?.coverageEntities?.includes(entity), + ); + const ownsProjectionEntity = + record?.projection?.planeEntity === entity || + layerState._projectionEntities.some( + (runtime) => + runtime?.cameraId === value && runtime.planeEntity === entity, + ); + if (record && (ownsCoverageEntity || ownsProjectionEntity)) return value; + } + + // Camera icon row IDs are intentionally the upstream camera ID, so a + // sibling may legitimately use the same string. A bare ID match is not + // ownership proof: require that this layer's icon set drew the pick. + const directId = + typeof picked.id === 'string' + ? picked.id + : typeof picked.primitive?.id === 'string' + ? picked.primitive.id + : null; + const record = + directId === null ? null : layerState._recordById.get(directId); + if (!record) return null; + return layerState._icons && picked.iconSet === layerState._icons + ? directId + : null; + } + + /** + * The camera whose icon or coverage is under a screen position (CSS px), + * from one scene pick; null when none is, or the pick throws. + * @param {{x: number, y: number}} position + * @returns {string|null} + */ + function pickCameraIdAt(position) { + let picked = null; + try { + picked = layerState._viewer.scene.pick(position); + } catch { + picked = null; + } + return extractPickedCameraId(picked); + } + + /** + * Where the ambient cards can go this pass: the canvas size, and the + * canvas position of a world point on the near side of the horizon (null + * behind it or off the projection). + * @returns {{width: number, height: number, + * screenOf: (position: object) => ({x: number, y: number}|undefined|null)}} + */ + function cardView() { + const { camera, scene } = layerState._viewer; + const occluder = horizonOccluder(camera); + return { + width: scene.canvas.clientWidth || scene.canvas.width || 0, + height: scene.canvas.clientHeight || scene.canvas.height || 0, + screenOf: (position) => + occluder.isPointVisible(position) + ? scene.cartesianToCanvasCoordinates(position) + : null, + }; + } + /** * Removes (and destroys) a record's viewshed volume primitive, if any. * @param {Object} record - Camera record. @@ -868,7 +975,12 @@ export function createRendering({ projectionTilesReady, frustumCartesians, buildCoverageEntities, - pickFromRay, + obstructionHit, + canPickFromRay, + removeCoverageEntities, + extractPickedCameraId, + pickCameraIdAt, + cardView, destroyViewshedVolume, rebuildViewshedVolume, createCameraIcons, diff --git a/src/layers/cctv/rendering.test.mjs b/src/layers/cctv/rendering.test.mjs index 737e52fd4..523b55b42 100644 --- a/src/layers/cctv/rendering.test.mjs +++ b/src/layers/cctv/rendering.test.mjs @@ -111,3 +111,64 @@ test('icons leave the scene they were added to, whichever viewer tears down', () assert.equal(current.isDestroyed(), true); assert.equal(state._icons, null); }); + +test('the obstruction probe sees through the layer and needs a ray pick', () => { + const coverage = [{ id: 'cov' }]; + const plane = { id: 'plane' }; + const calls = []; + const state = { + _viewer: { + scene: { + pickFromRay(ray, exclude) { + calls.push({ ray, exclude }); + return { position: { x: 1, y: 2, z: 3 } }; + }, + }, + }, + _coverageEntities: coverage, + _projectionEntities: [{ planeEntity: plane }, null, {}], + }; + const rendering = createRendering({ + state, + services: { focus: {} }, + parts: {}, + }); + assert.equal(rendering.canPickFromRay(), true); + const hit = rendering.obstructionHit( + { x: 0, y: 0, z: 0 }, + { x: 1, y: 0, z: 0 }, + ); + assert.deepEqual(hit.position, { x: 1, y: 2, z: 3 }); + assert.deepEqual(calls[0].exclude, [...coverage, plane]); + assert.ok(calls[0].ray instanceof Cesium.Ray); + state._viewer = { scene: {} }; + assert.equal(rendering.canPickFromRay(), false); + assert.equal( + rendering.obstructionHit({ x: 0, y: 0, z: 0 }, { x: 1, y: 0, z: 0 }), + undefined, + ); +}); + +test('cards go only where the horizon lets the camera see', () => { + const eye = Cesium.Cartesian3.fromDegrees(0, 0, 20_000_000); + const front = Cesium.Cartesian3.fromDegrees(0, 0); + const back = Cesium.Cartesian3.fromDegrees(180, 0); + const state = { + _viewer: { + camera: { positionWC: eye }, + scene: { + canvas: { clientWidth: 800, clientHeight: 0, height: 600 }, + cartesianToCanvasCoordinates: () => ({ x: 10, y: 20 }), + }, + }, + }; + const view = createRendering({ + state, + services: { focus: {} }, + parts: {}, + }).cardView(); + assert.equal(view.width, 800); + assert.equal(view.height, 600); + assert.deepEqual(view.screenOf(front), { x: 10, y: 20 }); + assert.equal(view.screenOf(back), null); +}); diff --git a/src/layers/cctv/selection.js b/src/layers/cctv/selection.js index a0102ff1b..25e17afa7 100644 --- a/src/layers/cctv/selection.js +++ b/src/layers/cctv/selection.js @@ -1,5 +1,4 @@ import { isTrackingClickGesture } from '../../data/trackingClickGesture.js'; -import { cctvPicks } from './pickState.js'; export function createSelection({ state: layerState, @@ -198,51 +197,14 @@ export function createSelection({ } /** - * Extracts a camera ID from a scene pick result by checking icon row IDs, - * primitive IDs, and the camera ids the layer keeps for its coverage entities. - * @param {Object|null} picked - Result from scene.pick(). - * @returns {string|null} Camera ID, or null if the pick is not a CCTV entity. + * 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) { - if (!picked) return null; - - const entity = cctvPicks.read(picked.id) - ? picked.id - : cctvPicks.read(picked.primitive?.id) - ? picked.primitive.id - : null; - const value = cctvPicks.read(entity)?.cameraId; - if (value !== undefined) { - const record = - typeof value === 'string' ? layerState._recordById.get(value) : null; - const ownsCoverageEntity = Boolean( - record?.coverageEntities?.includes(entity), - ); - const ownsProjectionEntity = - record?.projection?.planeEntity === entity || - layerState._projectionEntities.some( - (runtime) => - runtime?.cameraId === value && runtime.planeEntity === entity, - ); - if (record && (ownsCoverageEntity || ownsProjectionEntity)) return value; - } - - // Camera icon row IDs are intentionally the upstream camera ID, so a - // sibling may legitimately use the same string. A bare ID match is not - // ownership proof: require that this layer's icon set drew the pick. - const directId = - typeof picked.id === 'string' - ? picked.id - : typeof picked.primitive?.id === 'string' - ? picked.primitive.id - : null; - const record = - directId === null ? null : layerState._recordById.get(directId); - if (!record) return null; - return layerState._icons && picked.iconSet === layerState._icons - ? directId - : null; + return parts.rendering.extractPickedCameraId(picked); } return { getActiveRecord, diff --git a/src/layers/cctv/state.js b/src/layers/cctv/state.js index 23ddc2005..154897d15 100644 --- a/src/layers/cctv/state.js +++ b/src/layers/cctv/state.js @@ -106,7 +106,7 @@ export function createState({ services }) { layerState._viewResizeCanvas = null; - // The camera the moveStart/moveEnd listeners are attached to. + // The camera port the moveStart/moveEnd listeners are on. layerState._viewListenerCamera = null; @@ -185,8 +185,8 @@ export function createState({ services }) { layerState._mapStackListener = null; - // Field-test fix (2026-07-06): camera.moveEnd handle for the horizon-culling - // pass (removed in destroy). Event-driven only — never a per-frame loop, so + // Field-test fix (2026-07-06): the Off of the camera's moveEnd listener for + // the horizon-culling pass (called in destroy). Event-driven only — never a per-frame loop, so // the zero-steady-state-work invariant holds. layerState._horizonCullListener = null; @@ -261,6 +261,7 @@ export function createState({ services }) { layerState._cameraMoving = false; + // The Off of the camera's moveStart listener. layerState._moveStartListener = null; layerState._sourceAbort = null; return layerState;