mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-19 17:52:21 +00:00
The icon set was created shown, and the pass that hides cameras beyond the horizon and thins crowded areas runs only from enable(), after init has waited on the health check. Every frame drawn in that wait showed the whole catalogue. The set now starts hidden; enable() culls, then shows it.
379 lines
12 KiB
JavaScript
379 lines
12 KiB
JavaScript
// src/layers/cctv/rendering.test.mjs
|
|
// Icon colors under focus de-emphasis (#1200): the focus pass fades each icon
|
|
// from the same base color the coverage refresh assigns, so a video-feed camera
|
|
// stays violet while it dims instead of falling back to the idle cyan.
|
|
// Teardown lets go of the icon set of the viewer that drew it.
|
|
import { test } from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import { createRendering } from './rendering.js';
|
|
import {
|
|
ACTIVE_CAMERA_COLOR,
|
|
IDLE_CAMERA_COLOR,
|
|
LIVE_CAMERA_COLOR,
|
|
} from './policy.js';
|
|
import { isVideoFeedType } from '../../sources/cctvTypes.js';
|
|
import * as Cesium from 'cesium';
|
|
import { bindFakeDraw } from '../../testSupport/fakeDrawPort.mjs';
|
|
import { fakeCameraPort } from '../../testSupport/fakeCameraPort.mjs';
|
|
import { bindRenderer } from '../../render/rendererOf.js';
|
|
|
|
const FOCUS_FACTOR = 0.5;
|
|
|
|
function assertKeepsColor(icons, id, base, label) {
|
|
assert.deepEqual(icons.item(id).color, base, `${label}: base color kept`);
|
|
assert.equal(icons.focus(id), FOCUS_FACTOR, `${label}: focus`);
|
|
}
|
|
|
|
test('focus de-emphasis fades each icon from its own color', () => {
|
|
const record = (id, feedType) => ({
|
|
camera: { id, feedType },
|
|
position: { x: 6378137, y: 0, z: 0 },
|
|
});
|
|
const idleVideo = record('idle-hls', 'hls');
|
|
const idleStill = record('idle-image', 'image');
|
|
const activeVideo = record('active-hls', 'hls');
|
|
const viewer = {};
|
|
const camera = fakeCameraPort({
|
|
pose: { position: { x: 6378137 + 1000, y: 0, z: 0 } },
|
|
});
|
|
const projected = [];
|
|
const { draw, unbind } = bindFakeDraw(viewer, {
|
|
camera: camera.port,
|
|
query: {
|
|
project: (position) => {
|
|
projected.push(position);
|
|
return { x: 10, y: 20 };
|
|
},
|
|
},
|
|
});
|
|
const state = {
|
|
_enabled: true,
|
|
_viewer: viewer,
|
|
_records: [idleVideo, idleStill, activeVideo],
|
|
_activeCameraId: activeVideo.camera.id,
|
|
_activeFocusStyleCount: 0,
|
|
_lastFocusStyleAt: -Infinity,
|
|
};
|
|
const distances = [];
|
|
const focus = {
|
|
focusNowMs: (nowMs) => nowMs,
|
|
getFocusTarget: () => ({}),
|
|
focusPassIsNeeded: () => true,
|
|
advanceSpriteFocus: (meta, input) => {
|
|
distances.push(input.cameraDistance);
|
|
return { factor: FOCUS_FACTOR, active: true, transitioning: false };
|
|
},
|
|
focusAlphaNeedsWrite: () => true,
|
|
};
|
|
const { createCameraIcons, addCameraIcon, refreshCctvFocusStyles } =
|
|
createRendering({
|
|
state,
|
|
services: { focus },
|
|
parts: {
|
|
model: {
|
|
isVideoFeedType,
|
|
isVideoFeedCamera: (camera) =>
|
|
isVideoFeedType(camera.feedType) || Boolean(camera.browserMediaUrl),
|
|
},
|
|
},
|
|
source: {},
|
|
});
|
|
try {
|
|
const setId = createCameraIcons(viewer);
|
|
for (const r of state._records) addCameraIcon(r);
|
|
|
|
refreshCctvFocusStyles(1000);
|
|
|
|
const icons = state._icons;
|
|
assertKeepsColor(icons, 'idle-hls', LIVE_CAMERA_COLOR, 'idle video');
|
|
assertKeepsColor(icons, 'idle-image', IDLE_CAMERA_COLOR, 'idle still');
|
|
assertKeepsColor(icons, 'active-hls', ACTIVE_CAMERA_COLOR, 'active video');
|
|
assert.equal(state._activeFocusStyleCount, 3);
|
|
assert.equal(projected.length, 3, 'each shown icon is projected');
|
|
assert.deepEqual(distances, [1000, 1000, 1000], 'from the eye');
|
|
// What the set draws: depth-test-free, held at the mount, shrinking
|
|
// with distance as before.
|
|
const drawn = draw.set(setId).items.get('idle-hls');
|
|
assert.equal(drawn.disableDepthTest, Infinity);
|
|
assert.deepEqual(drawn.motion, { kind: 'hold' });
|
|
assert.deepEqual(drawn.pos, idleVideo.position);
|
|
assert.deepEqual(drawn.size, [24, 24]);
|
|
assert.deepEqual(drawn.scaleByDistance, {
|
|
near: 350,
|
|
nearValue: 1.25,
|
|
far: 4_000_000,
|
|
farValue: 0.42,
|
|
});
|
|
assert.equal(drawn.focus, FOCUS_FACTOR);
|
|
assert.equal(draw.set(setId).spec.horizonCull, true);
|
|
// Hidden until enable() has culled and thinned the cameras: the layer
|
|
// waits on its health check between drawing them and that pass.
|
|
assert.equal(draw.set(setId).show, false);
|
|
} finally {
|
|
unbind();
|
|
}
|
|
});
|
|
|
|
test('the icons go with the viewer that drew them, whichever tears down', () => {
|
|
const first = {};
|
|
const second = {};
|
|
const one = bindFakeDraw(first);
|
|
const two = bindFakeDraw(second);
|
|
const state = { _viewer: first };
|
|
const { createCameraIcons, destroyCameraIcons } = createRendering({
|
|
state,
|
|
services: { focus: {} },
|
|
parts: {},
|
|
source: {},
|
|
});
|
|
try {
|
|
const old = createCameraIcons(first);
|
|
state._viewer = second;
|
|
const current = createCameraIcons(second);
|
|
assert.notEqual(old, current);
|
|
assert.equal(one.draw.sets.get(old).disposed, true, 'a re-init lets go');
|
|
assert.equal(two.draw.sets.get(current).disposed, false);
|
|
|
|
destroyCameraIcons();
|
|
assert.equal(two.draw.sets.get(current).disposed, true);
|
|
assert.equal(state._icons, null);
|
|
} finally {
|
|
one.unbind();
|
|
two.unbind();
|
|
}
|
|
});
|
|
|
|
test('the obstruction probe casts one ray through the query port', async () => {
|
|
const calls = [];
|
|
const viewer = {};
|
|
const unbind = bindRenderer(viewer, {
|
|
query: {
|
|
rayCast: async (ray, options) => {
|
|
calls.push({ ray, options });
|
|
return { x: 1, y: 2, z: 3 };
|
|
},
|
|
},
|
|
});
|
|
const state = { _viewer: viewer };
|
|
const rendering = createRendering({
|
|
state,
|
|
services: { focus: {} },
|
|
parts: {},
|
|
});
|
|
try {
|
|
assert.equal(rendering.canPickFromRay(), true);
|
|
const origin = { x: 0, y: 0, z: 0 };
|
|
const direction = { x: 1, y: 0, z: 0 };
|
|
assert.deepEqual(await rendering.obstructionHit(origin, direction), {
|
|
x: 1,
|
|
y: 2,
|
|
z: 3,
|
|
});
|
|
// The layer's own sets are not ground: the cast sees through them
|
|
// without naming them.
|
|
assert.deepEqual(calls, [
|
|
{ ray: { origin, direction }, options: { against: 'surface' } },
|
|
]);
|
|
} finally {
|
|
unbind();
|
|
}
|
|
state._viewer = {};
|
|
assert.equal(rendering.canPickFromRay(), false);
|
|
assert.equal(
|
|
await rendering.obstructionHit({ x: 0, y: 0, z: 0 }, { x: 1, y: 0, z: 0 }),
|
|
null,
|
|
);
|
|
});
|
|
|
|
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 viewer = {};
|
|
const camera = fakeCameraPort({
|
|
pose: { position: { x: eye.x, y: eye.y, z: eye.z } },
|
|
});
|
|
const unbind = bindRenderer(viewer, {
|
|
camera: camera.port,
|
|
canvas: { clientWidth: 800, clientHeight: 0, height: 600 },
|
|
query: { project: () => ({ x: 10, y: 20 }) },
|
|
});
|
|
try {
|
|
const view = createRendering({
|
|
state: { _viewer: viewer },
|
|
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);
|
|
} finally {
|
|
unbind();
|
|
}
|
|
});
|
|
|
|
test('the projection tiles are ready only when drawn and settled', () => {
|
|
const viewer = {};
|
|
let globeVisible = true;
|
|
let settled = true;
|
|
const unbind = bindRenderer(viewer, {
|
|
globe: {
|
|
isGlobeVisible: () => globeVisible,
|
|
isSettled: (kind) => kind === 'tiles' && settled,
|
|
},
|
|
});
|
|
try {
|
|
const { projectionTilesReady } = createRendering({
|
|
state: { _viewer: viewer },
|
|
services: { focus: {} },
|
|
parts: {},
|
|
});
|
|
assert.equal(projectionTilesReady(), false, 'a globe stack hides them');
|
|
globeVisible = false;
|
|
assert.equal(projectionTilesReady(), true);
|
|
settled = false;
|
|
assert.equal(projectionTilesReady(), false, 'still streaming');
|
|
} finally {
|
|
unbind();
|
|
}
|
|
const bare = createRendering({
|
|
state: { _viewer: {} },
|
|
services: { focus: {} },
|
|
parts: {},
|
|
});
|
|
assert.equal(bare.projectionTilesReady(), false, 'no globe, no tiles');
|
|
});
|
|
|
|
test('a view pass writes only the icons it changes, in one write', () => {
|
|
const viewer = {};
|
|
const eye = Cesium.Cartesian3.fromDegrees(0, 0, 2000);
|
|
const down = Cesium.Cartesian3.normalize(
|
|
Cesium.Cartesian3.negate(eye, new Cesium.Cartesian3()),
|
|
new Cesium.Cartesian3(),
|
|
);
|
|
const camera = fakeCameraPort({
|
|
pose: {
|
|
position: { x: eye.x, y: eye.y, z: eye.z },
|
|
direction: { x: down.x, y: down.y, z: down.z },
|
|
up: { x: 0, y: 0, z: 1 },
|
|
fovy: Math.PI / 3,
|
|
aspectRatio: 4 / 3,
|
|
near: 0.1,
|
|
far: 5e8,
|
|
},
|
|
});
|
|
const { draw, unbind } = bindFakeDraw(viewer, {
|
|
camera: camera.port,
|
|
canvas: { clientWidth: 800, clientHeight: 600 },
|
|
});
|
|
const record = (id, lon) => {
|
|
const p = Cesium.Cartesian3.fromDegrees(lon, 0, 10);
|
|
return {
|
|
camera: { id, lat: 0, lon },
|
|
position: { x: p.x, y: p.y, z: p.z },
|
|
};
|
|
};
|
|
// One in view, one far off it.
|
|
const near = record('near', 0);
|
|
const far = record('far', 1);
|
|
const state = {
|
|
_enabled: true,
|
|
_viewer: viewer,
|
|
_records: [near, far],
|
|
_viewRecords: [],
|
|
_healthById: new Map(),
|
|
_scratchViewScreen: { x: 0, y: 0 },
|
|
};
|
|
const rendering = createRendering({
|
|
state,
|
|
services: { focus: {} },
|
|
parts: {
|
|
model: { isVideoFeedType: () => false, isVideoFeedCamera: () => false },
|
|
drawSets: { roleOfSet: () => null },
|
|
},
|
|
source: {},
|
|
});
|
|
try {
|
|
const setId = rendering.createCameraIcons(viewer);
|
|
for (const r of state._records) rendering.addCameraIcon(r);
|
|
const set = draw.set(setId);
|
|
const writes = set.writes;
|
|
|
|
assert.equal(rendering.refreshHorizonCulling(), true);
|
|
assert.equal(set.writes, writes + 1, 'one write for the pass');
|
|
assert.equal(set.items.get('near').show, true);
|
|
assert.equal(set.items.get('far').show, false);
|
|
|
|
assert.equal(rendering.refreshHorizonCulling(), false);
|
|
assert.equal(set.writes, writes + 1, 'an unchanged view writes nothing');
|
|
|
|
// Another layer on the same viewer draws its icons in a set of its own.
|
|
const other = createRendering({
|
|
state: { _viewer: viewer },
|
|
services: { focus: {} },
|
|
parts: {},
|
|
source: {},
|
|
});
|
|
const otherId = other.createCameraIcons(viewer);
|
|
assert.notEqual(otherId, setId);
|
|
assert.equal(
|
|
rendering.extractPickedCameraId({ set: otherId, id: 'near' }),
|
|
null,
|
|
"the other layer's icon is not this layer's camera",
|
|
);
|
|
} finally {
|
|
unbind();
|
|
}
|
|
});
|
|
|
|
test('a pose with no perspective field of view is projected by the renderer', () => {
|
|
const viewer = {};
|
|
const camera = fakeCameraPort({
|
|
pose: { position: { x: 7e6, y: 0, z: 0 }, fovy: undefined },
|
|
});
|
|
const asked = [];
|
|
const { draw, unbind } = bindFakeDraw(viewer, {
|
|
camera: camera.port,
|
|
canvas: { clientWidth: 800, clientHeight: 600 },
|
|
query: {
|
|
project: (position) => {
|
|
asked.push(position.y);
|
|
return position.y === 0 ? { x: 400, y: 300 } : null;
|
|
},
|
|
},
|
|
});
|
|
// On the ground under the eye, in cells of their own.
|
|
const record = (id, y) => ({
|
|
camera: { id, lat: 0, lon: y / 1000 },
|
|
position: { x: 6378137, y, z: 0 },
|
|
});
|
|
const state = {
|
|
_enabled: true,
|
|
_viewer: viewer,
|
|
_records: [record('on', 0), record('off', 1000)],
|
|
_viewRecords: [],
|
|
_healthById: new Map(),
|
|
_scratchViewScreen: { x: 0, y: 0 },
|
|
};
|
|
const rendering = createRendering({
|
|
state,
|
|
services: { focus: {} },
|
|
parts: {
|
|
model: { isVideoFeedType: () => false, isVideoFeedCamera: () => false },
|
|
},
|
|
source: {},
|
|
});
|
|
try {
|
|
const setId = rendering.createCameraIcons(viewer);
|
|
for (const r of state._records) rendering.addCameraIcon(r);
|
|
rendering.refreshHorizonCulling();
|
|
const set = draw.set(setId);
|
|
assert.deepEqual(asked.sort(), [0, 1000]);
|
|
assert.equal(set.items.get('on').show, true);
|
|
assert.equal(set.items.get('off').show, false);
|
|
} finally {
|
|
unbind();
|
|
}
|
|
});
|