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;