mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-18 09:12:18 +00:00
Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
d37e8cf17d | ||
|
|
3e1070a2cb |
No files matched your search
@@ -1,4 +0,0 @@
|
|||||||
- ALPR camera badges no longer take depth samples while the overlay paints, or
|
|
||||||
again each time the layer is switched back on. On a terrain globe their
|
|
||||||
height comes from the loaded terrain and is remembered per camera; some
|
|
||||||
badges move a few metres onto the drawn surface (mazy1998, #1706).
|
|
||||||
@@ -0,0 +1,3 @@
|
|||||||
|
- A still-image CCTV camera no longer keeps the scene rendering 60 times a
|
||||||
|
second. Only a video feed holds continuous rendering; a still redraws when a
|
||||||
|
new image arrives (mazy1998, #1710).
|
||||||
@@ -1513,14 +1513,10 @@ tile streamed in; floors resolve before new badges appear (bounded wait), and a
|
|||||||
badge whose cell has not resolved clamps until it does, then moves in place.
|
badge whose cell has not resolved clamps until it does, then moves in place.
|
||||||
Overlay anchors start on the same floor and write marker properties only on
|
Overlay anchors start on the same floor and write marker properties only on
|
||||||
change. Once the camera is still and tiles have settled, each overlay anchor is
|
change. Once the camera is still and tiles have settled, each overlay anchor is
|
||||||
replaced once by the rendered surface under it (accepted only within -30/+40 m
|
replaced once by the rendered surface under it (two depth samples per paint,
|
||||||
of the floor cell), so badges do not float or sink on slopes; wedge corners
|
accepted only within -30/+40 m of the floor cell), so badges do not float or
|
||||||
follow their own floor cells instead of staying level with the apex. The
|
sink on slopes; wedge corners follow their own floor cells instead of staying
|
||||||
surface is read outside the overlay paint, one camera per frame: a terrain
|
level with the apex. Unknown bearings never acquire a wedge. The selected
|
||||||
globe answers from its loaded mesh (`globe.getHeight`) and only photoreal
|
|
||||||
tiles are depth-sampled (`scene.sampleHeight`). Answers are kept per camera
|
|
||||||
until the map source changes, so a refresh or turning the layer off and on
|
|
||||||
samples nothing again. Unknown bearings never acquire a wedge. The selected
|
|
||||||
card's `DIRECTION` wraps after rounding to whole degrees, so a mapped bearing
|
card's `DIRECTION` wraps after rounding to whole degrees, so a mapped bearing
|
||||||
of 359.5° or more reads `0°` rather than `360°`. The row reads
|
of 359.5° or more reads `0°` rather than `360°`. The row reads
|
||||||
`N nearby · M on screen`; when every loaded camera is outside the view it adds
|
`N nearby · M on screen`; when every loaded camera is outside the view it adds
|
||||||
|
|||||||
+57
-139
@@ -4,10 +4,10 @@ import {
|
|||||||
MARKER_ICON_SIZE,
|
MARKER_ICON_SIZE,
|
||||||
SELECTED_MARKER_ICON_SIZE,
|
SELECTED_MARKER_ICON_SIZE,
|
||||||
MARKER_FLOOR_LIFT_M,
|
MARKER_FLOOR_LIFT_M,
|
||||||
REMEMBERED_ANCHORS,
|
ANCHOR_SAMPLES_PER_PAINT,
|
||||||
SURFACE_BELOW_FLOOR_M,
|
SURFACE_BELOW_FLOOR_M,
|
||||||
SURFACE_ABOVE_FLOOR_M,
|
SURFACE_ABOVE_FLOOR_M,
|
||||||
SURFACE_SAMPLES_PER_FRAME,
|
SURFACE_SAMPLES_PER_PAINT,
|
||||||
} from './policy.js';
|
} from './policy.js';
|
||||||
import {
|
import {
|
||||||
MARKER_IMAGE,
|
MARKER_IMAGE,
|
||||||
@@ -19,17 +19,11 @@ import {
|
|||||||
validAlprGroundHeight,
|
validAlprGroundHeight,
|
||||||
} from './visuals.js';
|
} from './visuals.js';
|
||||||
|
|
||||||
const nextAnimationFrame = (step) =>
|
|
||||||
typeof requestAnimationFrame === 'function'
|
|
||||||
? requestAnimationFrame(step)
|
|
||||||
: setTimeout(step, 16);
|
|
||||||
|
|
||||||
/** Per-layer presentation on a caller-owned overlay; Cesium remains the fallback. */
|
/** Per-layer presentation on a caller-owned overlay; Cesium remains the fallback. */
|
||||||
export function createAlprOverlay({
|
export function createAlprOverlay({
|
||||||
state,
|
state,
|
||||||
services,
|
services,
|
||||||
onSurfaceChange = () => {},
|
onSurfaceChange = () => {},
|
||||||
requestFrame = nextAnimationFrame,
|
|
||||||
}) {
|
}) {
|
||||||
let lane,
|
let lane,
|
||||||
removeMapListener,
|
removeMapListener,
|
||||||
@@ -39,12 +33,7 @@ export function createAlprOverlay({
|
|||||||
hits = [],
|
hits = [],
|
||||||
images = [],
|
images = [],
|
||||||
destroyed = false,
|
destroyed = false,
|
||||||
lastCamera = null,
|
lastCamera = null;
|
||||||
sampling = false;
|
|
||||||
// Rendered-surface answers by camera id. Entities are rebuilt by a refresh
|
|
||||||
// and by turning the layer off and on; keeping the answers on them meant
|
|
||||||
// every rebuild sampled the same cameras again.
|
|
||||||
const surfaceAnswers = new Map();
|
|
||||||
const requestPaint = () => {
|
const requestPaint = () => {
|
||||||
if (!destroyed && state.enabled) lane?.requestPaint();
|
if (!destroyed && state.enabled) lane?.requestPaint();
|
||||||
};
|
};
|
||||||
@@ -103,72 +92,38 @@ export function createAlprOverlay({
|
|||||||
entity.gevAlprDisplayPosition = null;
|
entity.gevAlprDisplayPosition = null;
|
||||||
nativeVisible(entity, true);
|
nativeVisible(entity, true);
|
||||||
}
|
}
|
||||||
surfaceAnswers.clear();
|
|
||||||
state.lastAnchorSampleAt = 0;
|
state.lastAnchorSampleAt = 0;
|
||||||
retryUntil = Date.now() + 15000;
|
retryUntil = Date.now() + 15000;
|
||||||
requestPaint();
|
requestPaint();
|
||||||
}
|
}
|
||||||
|
|
||||||
function rememberSurface(record, height, checked) {
|
function anchorFor(record, entity, budget) {
|
||||||
surfaceAnswers.delete(record.id);
|
if (entity.gevAlprCanvasPosition) return entity.gevAlprCanvasPosition;
|
||||||
surfaceAnswers.set(record.id, {
|
|
||||||
latitude: record.latitude,
|
|
||||||
longitude: record.longitude,
|
|
||||||
height,
|
|
||||||
checked,
|
|
||||||
});
|
|
||||||
if (surfaceAnswers.size > REMEMBERED_ANCHORS)
|
|
||||||
surfaceAnswers.delete(surfaceAnswers.keys().next().value);
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Rendered surface height under a camera. A terrain globe answers from its
|
|
||||||
* loaded mesh; only photoreal tiles need `sampleHeight`, which renders depth
|
|
||||||
* and compiles its shaders on first use (a freeze of up to 1.9 s at load).
|
|
||||||
*/
|
|
||||||
function surfaceHeight(record, entity) {
|
|
||||||
const scene = state.viewer.scene;
|
const scene = state.viewer.scene;
|
||||||
const location = Cesium.Cartographic.fromDegrees(
|
const location = Cesium.Cartographic.fromDegrees(
|
||||||
record.longitude,
|
record.longitude,
|
||||||
record.latitude,
|
record.latitude,
|
||||||
);
|
);
|
||||||
if (scene.globe?.show) return scene.globe.getHeight?.(location);
|
// A floor-placed marker anchors where its native badge sits; only a
|
||||||
if (!scene.sampleHeightSupported) return undefined;
|
// marker still waiting for its floor samples the rendered surface, and
|
||||||
try {
|
// each paint samples a few at most (each sample is a depth render).
|
||||||
return scene.sampleHeight(location, [entity]);
|
|
||||||
} catch {
|
|
||||||
/* streaming tiles */
|
|
||||||
return undefined;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/** The anchor a paint can have without sampling, or null while it waits for one. */
|
|
||||||
function anchorFor(record, entity) {
|
|
||||||
if (entity.gevAlprCanvasPosition) return entity.gevAlprCanvasPosition;
|
|
||||||
const scene = state.viewer.scene;
|
|
||||||
const answer = surfaceAnswers.get(record.id);
|
|
||||||
if (
|
|
||||||
answer?.latitude === record.latitude &&
|
|
||||||
answer.longitude === record.longitude
|
|
||||||
) {
|
|
||||||
setAnchor(record, entity, answer.height);
|
|
||||||
if (answer.checked)
|
|
||||||
entity.gevAlprSurfaceCheckedFor = entity.gevAlprCanvasPosition;
|
|
||||||
return entity.gevAlprCanvasPosition;
|
|
||||||
}
|
|
||||||
// A floor-placed marker anchors where its native badge sits. A marker
|
|
||||||
// still waiting for its floor reads the terrain globe, or on photoreal
|
|
||||||
// tiles waits for sampleAnchors().
|
|
||||||
let height;
|
let height;
|
||||||
const floor = services.groundFloor.cachedGroundFloor(
|
const floor = services.groundFloor.cachedGroundFloor(
|
||||||
record.latitude,
|
record.latitude,
|
||||||
record.longitude,
|
record.longitude,
|
||||||
);
|
);
|
||||||
if (validAlprGroundHeight(floor)) height = floor + MARKER_FLOOR_LIFT_M;
|
if (validAlprGroundHeight(floor)) height = floor + MARKER_FLOOR_LIFT_M;
|
||||||
else if (scene.globe.show)
|
else if (scene.sampleHeightSupported) {
|
||||||
height = scene.globe.getHeight?.(
|
if (budget.samples <= 0) return null;
|
||||||
Cesium.Cartographic.fromDegrees(record.longitude, record.latitude),
|
budget.samples -= 1;
|
||||||
);
|
try {
|
||||||
|
height = scene.sampleHeight(location, [entity]);
|
||||||
|
} catch {
|
||||||
|
/* streaming tiles */
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (!validAlprGroundHeight(height) && scene.globe.show)
|
||||||
|
height = scene.globe.getHeight?.(location);
|
||||||
if (!validAlprGroundHeight(height)) return null;
|
if (!validAlprGroundHeight(height)) return null;
|
||||||
setAnchor(record, entity, height);
|
setAnchor(record, entity, height);
|
||||||
return entity.gevAlprCanvasPosition;
|
return entity.gevAlprCanvasPosition;
|
||||||
@@ -203,19 +158,14 @@ export function createAlprOverlay({
|
|||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* Sample the rendered surface for the overlay cameras, outside the paint.
|
* Replace floor anchors with the rendered surface under each overlay camera.
|
||||||
*
|
* Floors come from ~111 m cells, so on a slope a badge could float or sink
|
||||||
* A camera with no floor yet gets its anchor from a sample. An anchored one
|
* by tens of metres. Runs only while the camera is still and tiles have
|
||||||
* is checked against the surface once: floors come from ~111 m cells, so on
|
* settled, a few depth samples per paint, and each anchor at most once;
|
||||||
* a slope a badge could float or sink by tens of metres. Checks run only
|
* samples far outside the floor prior (a roof or a streaming tile) are
|
||||||
* while the camera is still and tiles have settled, and samples far outside
|
* rejected. Returns whether anchors remain to check.
|
||||||
* the floor prior (a roof or a streaming tile) are rejected. Each frame
|
|
||||||
* takes SURFACE_SAMPLES_PER_FRAME samples, so no frame carries the whole
|
|
||||||
* cohort; sampling inside paint() put up to six depth renders in one frame.
|
|
||||||
*/
|
*/
|
||||||
function sampleAnchors() {
|
function refineAnchors(budget) {
|
||||||
sampling = false;
|
|
||||||
if (destroyed || !state.enabled) return;
|
|
||||||
const camera = state.viewer.camera;
|
const camera = state.viewer.camera;
|
||||||
const scene = state.viewer.scene;
|
const scene = state.viewer.scene;
|
||||||
const still =
|
const still =
|
||||||
@@ -238,41 +188,27 @@ export function createAlprOverlay({
|
|||||||
position: Cesium.Cartesian3.clone(camera.positionWC),
|
position: Cesium.Cartesian3.clone(camera.positionWC),
|
||||||
direction: Cesium.Cartesian3.clone(camera.directionWC),
|
direction: Cesium.Cartesian3.clone(camera.directionWC),
|
||||||
};
|
};
|
||||||
const canSample = scene.globe?.show || scene.sampleHeightSupported;
|
if (!scene.sampleHeightSupported) return false;
|
||||||
let samples = SURFACE_SAMPLES_PER_FRAME,
|
let pending = false;
|
||||||
pending = false,
|
|
||||||
progressed = false,
|
|
||||||
moved = false;
|
|
||||||
// Cameras with no anchor come first: they are not on the overlay yet.
|
|
||||||
for (const record of records) {
|
|
||||||
const entity = state.dataSource.entities.getById(record.id);
|
|
||||||
if (!entity || entity.gevAlprCanvasPosition) continue;
|
|
||||||
// The floor may have resolved since the paint that found none.
|
|
||||||
if (anchorFor(record, entity)) moved = true;
|
|
||||||
else if (!canSample || samples <= 0) pending = true;
|
|
||||||
else {
|
|
||||||
samples -= 1;
|
|
||||||
const sample = surfaceHeight(record, entity);
|
|
||||||
if (validAlprGroundHeight(sample)) {
|
|
||||||
setAnchor(record, entity, sample);
|
|
||||||
rememberSurface(record, sample, false);
|
|
||||||
moved = progressed = true;
|
|
||||||
} else pending = true;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
for (const record of records) {
|
for (const record of records) {
|
||||||
const entity = state.dataSource.entities.getById(record.id);
|
const entity = state.dataSource.entities.getById(record.id);
|
||||||
const anchor = entity?.gevAlprCanvasPosition;
|
const anchor = entity?.gevAlprCanvasPosition;
|
||||||
if (!anchor || !canSample || entity.gevAlprSurfaceCheckedFor === anchor)
|
if (!anchor || entity.gevAlprSurfaceCheckedFor === anchor) continue;
|
||||||
continue;
|
if (!still || !surfaceSettled(scene) || budget.samples <= 0) {
|
||||||
if (!still || !surfaceSettled(scene) || samples <= 0) {
|
|
||||||
pending = true;
|
pending = true;
|
||||||
continue;
|
continue;
|
||||||
}
|
}
|
||||||
samples -= 1;
|
budget.samples -= 1;
|
||||||
progressed = true;
|
let sample;
|
||||||
const sample = surfaceHeight(record, entity);
|
try {
|
||||||
let height = Cesium.Cartographic.fromCartesian(anchor).height;
|
sample = scene.sampleHeight(
|
||||||
|
Cesium.Cartographic.fromDegrees(record.longitude, record.latitude),
|
||||||
|
[entity],
|
||||||
|
);
|
||||||
|
} catch {
|
||||||
|
/* streaming tiles */
|
||||||
|
}
|
||||||
|
const current = Cesium.Cartographic.fromCartesian(anchor).height;
|
||||||
const floor = services.groundFloor.cachedGroundFloor(
|
const floor = services.groundFloor.cachedGroundFloor(
|
||||||
record.latitude,
|
record.latitude,
|
||||||
record.longitude,
|
record.longitude,
|
||||||
@@ -282,43 +218,21 @@ export function createAlprOverlay({
|
|||||||
(!validAlprGroundHeight(floor) ||
|
(!validAlprGroundHeight(floor) ||
|
||||||
(sample >= floor - SURFACE_BELOW_FLOOR_M &&
|
(sample >= floor - SURFACE_BELOW_FLOOR_M &&
|
||||||
sample <= floor + SURFACE_ABOVE_FLOOR_M));
|
sample <= floor + SURFACE_ABOVE_FLOOR_M));
|
||||||
if (accepted && Math.abs(sample + MARKER_FLOOR_LIFT_M - height) > 1) {
|
if (accepted && Math.abs(sample + MARKER_FLOOR_LIFT_M - current) > 1)
|
||||||
height = sample + MARKER_FLOOR_LIFT_M;
|
setAnchor(record, entity, sample + MARKER_FLOOR_LIFT_M);
|
||||||
setAnchor(record, entity, height);
|
|
||||||
moved = true;
|
|
||||||
}
|
|
||||||
entity.gevAlprSurfaceCheckedFor = entity.gevAlprCanvasPosition;
|
entity.gevAlprSurfaceCheckedFor = entity.gevAlprCanvasPosition;
|
||||||
// A surface that did not answer is asked again after a rebuild.
|
|
||||||
if (validAlprGroundHeight(sample)) rememberSurface(record, height, true);
|
|
||||||
if (entity.id === state.selectedId)
|
if (entity.id === state.selectedId)
|
||||||
entity.gevAlprDisplayPosition = entity.gevAlprCanvasPosition;
|
entity.gevAlprDisplayPosition = entity.gevAlprCanvasPosition;
|
||||||
}
|
}
|
||||||
if (moved) requestPaint();
|
return pending;
|
||||||
if (!pending || Date.now() >= retryUntil) return;
|
|
||||||
// Take the next ration on the next frame; when nothing could be sampled
|
|
||||||
// (camera moving, tiles streaming, no floor yet) look again in 250 ms.
|
|
||||||
if (progressed) scheduleSampling();
|
|
||||||
else if (!retryTimer)
|
|
||||||
retryTimer = setTimeout(() => {
|
|
||||||
retryTimer = null;
|
|
||||||
scheduleSampling();
|
|
||||||
}, 250);
|
|
||||||
}
|
|
||||||
|
|
||||||
function scheduleSampling() {
|
|
||||||
if (sampling || destroyed) return;
|
|
||||||
sampling = true;
|
|
||||||
requestFrame(sampleAnchors);
|
|
||||||
}
|
}
|
||||||
|
|
||||||
function paint({ ctx, width, height, keyhole, occluder }) {
|
function paint({ ctx, width, height, keyhole, occluder }) {
|
||||||
hits = [];
|
hits = [];
|
||||||
if (!state.enabled || destroyed) return;
|
if (!state.enabled || destroyed) return;
|
||||||
let waiting = false;
|
let unresolved = false;
|
||||||
const painted = [];
|
const painted = [];
|
||||||
const canSample =
|
const budget = { samples: ANCHOR_SAMPLES_PER_PAINT };
|
||||||
state.viewer.scene.globe?.show ||
|
|
||||||
state.viewer.scene.sampleHeightSupported;
|
|
||||||
for (const record of records) {
|
for (const record of records) {
|
||||||
const entity = state.dataSource.entities.getById(record.id);
|
const entity = state.dataSource.entities.getById(record.id);
|
||||||
if (!entity) continue;
|
if (!entity) continue;
|
||||||
@@ -332,14 +246,12 @@ export function createAlprOverlay({
|
|||||||
nativeVisible(entity, true);
|
nativeVisible(entity, true);
|
||||||
continue;
|
continue;
|
||||||
}
|
}
|
||||||
const anchor = anchorFor(record, entity);
|
const anchor = anchorFor(record, entity, budget);
|
||||||
if (!anchor) {
|
if (!anchor) {
|
||||||
nativeVisible(entity, true);
|
nativeVisible(entity, true);
|
||||||
waiting = true;
|
unresolved = true;
|
||||||
continue;
|
continue;
|
||||||
}
|
}
|
||||||
if (canSample && entity.gevAlprSurfaceCheckedFor !== anchor)
|
|
||||||
waiting = true;
|
|
||||||
canvasOwned(entity, true);
|
canvasOwned(entity, true);
|
||||||
if (occluder && !occluder.isPointVisible(anchor)) {
|
if (occluder && !occluder.isPointVisible(anchor)) {
|
||||||
setShown(entity, false);
|
setShown(entity, false);
|
||||||
@@ -423,9 +335,15 @@ export function createAlprOverlay({
|
|||||||
ctx.restore();
|
ctx.restore();
|
||||||
hits.push({ id: record.id, x: origin.x, y: origin.y, radius: size / 2 });
|
hits.push({ id: record.id, x: origin.x, y: origin.y, radius: size / 2 });
|
||||||
}
|
}
|
||||||
// Anchors still to find or to check are sampled after this paint, a few
|
const refining = refineAnchors({
|
||||||
// per frame, never inside it.
|
samples: Math.min(budget.samples, SURFACE_SAMPLES_PER_PAINT),
|
||||||
if (waiting && !retryTimer && Date.now() < retryUntil) scheduleSampling();
|
});
|
||||||
|
if ((unresolved || refining) && !retryTimer && Date.now() < retryUntil) {
|
||||||
|
retryTimer = setTimeout(() => {
|
||||||
|
retryTimer = null;
|
||||||
|
requestPaint();
|
||||||
|
}, 250);
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
return {
|
return {
|
||||||
|
|||||||
@@ -45,10 +45,8 @@ function harness(t, count = 2, { floor = null } = {}) {
|
|||||||
active,
|
active,
|
||||||
removed = 0,
|
removed = 0,
|
||||||
paints = 0;
|
paints = 0;
|
||||||
const frames = [];
|
|
||||||
const overlay = createAlprOverlay({
|
const overlay = createAlprOverlay({
|
||||||
state,
|
state,
|
||||||
requestFrame: (step) => frames.push(step),
|
|
||||||
services: {
|
services: {
|
||||||
groundFloor: { cachedGroundFloor: () => floor },
|
groundFloor: { cachedGroundFloor: () => floor },
|
||||||
overlays: {
|
overlays: {
|
||||||
@@ -108,12 +106,6 @@ function harness(t, count = 2, { floor = null } = {}) {
|
|||||||
entities,
|
entities,
|
||||||
draw,
|
draw,
|
||||||
paint: (occluder) => paint({ ctx, width: 800, height: 600, occluder }),
|
paint: (occluder) => paint({ ctx, width: 800, height: 600, occluder }),
|
||||||
/** Run the sampling step queued for the next animation frame, if any. */
|
|
||||||
frame() {
|
|
||||||
const step = frames.shift();
|
|
||||||
step?.();
|
|
||||||
return Boolean(step);
|
|
||||||
},
|
|
||||||
mapChanged() {
|
mapChanged() {
|
||||||
mapListener({ detail: { status: 'ready' } });
|
mapListener({ detail: { status: 'ready' } });
|
||||||
},
|
},
|
||||||
@@ -251,149 +243,41 @@ test('overlay glyphs and native badges shrink alike with distance', () => {
|
|||||||
assert.ok(Math.abs(markerScale(20_250) - 0.8) < 1e-9);
|
assert.ok(Math.abs(markerScale(20_250) - 0.8) < 1e-9);
|
||||||
});
|
});
|
||||||
|
|
||||||
/** A photoreal scene: no globe, the rendered surface read by depth samples. */
|
|
||||||
function photoreal(h, heightAt = () => 172) {
|
|
||||||
const scene = h.state.viewer.scene;
|
|
||||||
h.state.viewer.camera.directionWC = Cesium.Cartesian3.UNIT_X;
|
|
||||||
scene.globe.show = false;
|
|
||||||
scene.sampleHeightSupported = true;
|
|
||||||
scene.primitives = { length: 0, get: () => null };
|
|
||||||
const sampled = [];
|
|
||||||
scene.sampleHeight = (carto) => {
|
|
||||||
sampled.push(carto);
|
|
||||||
return heightAt(Cesium.Math.toDegrees(carto.latitude));
|
|
||||||
};
|
|
||||||
return sampled;
|
|
||||||
}
|
|
||||||
|
|
||||||
const anchorHeight = (h, id) =>
|
|
||||||
Cesium.Cartographic.fromCartesian(
|
|
||||||
h.entities.getById(id).gevAlprCanvasPosition,
|
|
||||||
).height;
|
|
||||||
|
|
||||||
/** Run sampling frames until none is queued, waiting out the 250 ms look-again. */
|
|
||||||
function settle(t, h) {
|
|
||||||
for (let i = 0; i < 400; i++) if (!h.frame()) t.mock.timers.tick(250);
|
|
||||||
}
|
|
||||||
|
|
||||||
test('a still view replaces floor anchors with the rendered surface, within the floor window', (t) => {
|
test('a still view replaces floor anchors with the rendered surface, within the floor window', (t) => {
|
||||||
// Floors come from ~111 m cells; on a slope a badge floated above the mesh.
|
// Floors come from ~111 m cells; on a slope a badge floated above the mesh.
|
||||||
t.mock.timers.enable({ apis: ['setTimeout', 'Date'] });
|
|
||||||
const h = harness(t, 2, { floor: 150 });
|
const h = harness(t, 2, { floor: 150 });
|
||||||
const sampled = photoreal(h, (latitude) => (latitude > 30.00005 ? 400 : 172));
|
const scene = h.state.viewer.scene;
|
||||||
|
const camera = h.state.viewer.camera;
|
||||||
|
camera.directionWC = Cesium.Cartesian3.UNIT_X;
|
||||||
|
scene.sampleHeightSupported = true;
|
||||||
|
scene.primitives = { length: 0, get: () => null };
|
||||||
|
let samples = 0;
|
||||||
|
scene.sampleHeight = (carto) => {
|
||||||
|
samples++;
|
||||||
|
return Cesium.Math.toDegrees(carto.latitude) > 30.00005 ? 400 : 172;
|
||||||
|
};
|
||||||
h.overlay.sync(h.records);
|
h.overlay.sync(h.records);
|
||||||
h.paint();
|
h.paint();
|
||||||
assert.ok(
|
const height = (id) =>
|
||||||
Math.abs(anchorHeight(h, 'camera:0') - 151.5) < 0.01,
|
Cesium.Cartographic.fromCartesian(
|
||||||
'floor anchor first',
|
h.entities.getById(id).gevAlprCanvasPosition,
|
||||||
);
|
).height;
|
||||||
assert.equal(h.frame(), true, 'the paint queued a sampling frame');
|
|
||||||
assert.equal(
|
assert.equal(
|
||||||
sampled.length,
|
samples,
|
||||||
0,
|
0,
|
||||||
'no depth samples while the camera may still be moving',
|
'no depth samples while the camera may still be moving',
|
||||||
);
|
);
|
||||||
settle(t, h);
|
assert.ok(Math.abs(height('camera:0') - 151.5) < 0.01, 'floor anchor first');
|
||||||
|
h.paint();
|
||||||
assert.ok(
|
assert.ok(
|
||||||
Math.abs(anchorHeight(h, 'camera:0') - 173.5) < 0.01,
|
Math.abs(height('camera:0') - 173.5) < 0.01,
|
||||||
'rendered surface once still',
|
'rendered surface once still',
|
||||||
);
|
);
|
||||||
assert.ok(
|
assert.ok(
|
||||||
Math.abs(anchorHeight(h, 'camera:1') - 151.5) < 0.01,
|
Math.abs(height('camera:1') - 151.5) < 0.01,
|
||||||
'a rooftop-height sample is rejected',
|
'a rooftop-height sample is rejected',
|
||||||
);
|
);
|
||||||
assert.equal(sampled.length, 2);
|
const taken = samples;
|
||||||
h.paint();
|
h.paint();
|
||||||
settle(t, h);
|
assert.equal(samples, taken, 'each anchor is checked once');
|
||||||
assert.equal(sampled.length, 2, 'each anchor is checked once');
|
|
||||||
});
|
|
||||||
|
|
||||||
test('a paint never samples the surface; frames take one sample each', (t) => {
|
|
||||||
// Sampling inside paint() put up to six depth renders into one frame, and
|
|
||||||
// the first of them compiles shaders: a freeze of 0.8 to 1.9 s at load.
|
|
||||||
t.mock.timers.enable({ apis: ['setTimeout', 'Date'] });
|
|
||||||
const h = harness(t, 8);
|
|
||||||
const sampled = photoreal(h);
|
|
||||||
h.overlay.sync(h.records);
|
|
||||||
h.paint();
|
|
||||||
h.paint();
|
|
||||||
assert.equal(sampled.length, 0, 'no sample inside a paint');
|
|
||||||
assert.equal(h.draw.length, 0, 'unanchored cameras keep their native badge');
|
|
||||||
for (let taken = 1; taken <= 8; taken++) {
|
|
||||||
assert.equal(h.frame(), true);
|
|
||||||
assert.equal(sampled.length, taken, 'one sample per frame');
|
|
||||||
}
|
|
||||||
for (const record of h.records)
|
|
||||||
assert.ok(Math.abs(anchorHeight(h, record.id) - 172) < 0.01);
|
|
||||||
h.paint();
|
|
||||||
assert.ok(h.draw.length > 0, 'anchored cameras paint on the overlay');
|
|
||||||
});
|
|
||||||
|
|
||||||
test('a terrain globe is read from its mesh, never depth-sampled', (t) => {
|
|
||||||
t.mock.timers.enable({ apis: ['setTimeout', 'Date'] });
|
|
||||||
const h = harness(t, 3, { floor: 150 });
|
|
||||||
const sampled = photoreal(h);
|
|
||||||
const scene = h.state.viewer.scene;
|
|
||||||
scene.globe.show = true;
|
|
||||||
scene.globe.tilesLoaded = true;
|
|
||||||
let reads = 0;
|
|
||||||
scene.globe.getHeight = () => {
|
|
||||||
reads++;
|
|
||||||
return 172;
|
|
||||||
};
|
|
||||||
h.overlay.sync(h.records);
|
|
||||||
h.paint();
|
|
||||||
settle(t, h);
|
|
||||||
assert.equal(sampled.length, 0);
|
|
||||||
assert.equal(reads, 3);
|
|
||||||
// The same anchor the depth sample gave: the surface plus the marker lift.
|
|
||||||
for (const record of h.records)
|
|
||||||
assert.ok(Math.abs(anchorHeight(h, record.id) - 173.5) < 0.01);
|
|
||||||
});
|
|
||||||
|
|
||||||
test('surface answers outlive rebuilt markers and a re-enable, until the map changes', (t) => {
|
|
||||||
t.mock.timers.enable({ apis: ['setTimeout', 'Date'] });
|
|
||||||
const h = harness(t, 4, { floor: 150 });
|
|
||||||
const sampled = photoreal(h);
|
|
||||||
h.overlay.sync(h.records);
|
|
||||||
h.paint();
|
|
||||||
settle(t, h);
|
|
||||||
assert.equal(sampled.length, 4);
|
|
||||||
const before = h.records.map((record) => anchorHeight(h, record.id));
|
|
||||||
|
|
||||||
// A refresh or a toggle removes the entities and builds new ones.
|
|
||||||
const rebuild = () => {
|
|
||||||
h.overlay.clear();
|
|
||||||
h.entities.removeAll();
|
|
||||||
for (const record of h.records)
|
|
||||||
h.entities.add({
|
|
||||||
id: record.id,
|
|
||||||
billboard: { image: 'fallback', show: true },
|
|
||||||
polyline: { show: true },
|
|
||||||
polygon: { show: true },
|
|
||||||
});
|
|
||||||
h.overlay.sync(h.records);
|
|
||||||
h.paint();
|
|
||||||
settle(t, h);
|
|
||||||
};
|
|
||||||
rebuild();
|
|
||||||
h.state.enabled = false;
|
|
||||||
h.overlay.clear();
|
|
||||||
h.state.enabled = true;
|
|
||||||
rebuild();
|
|
||||||
assert.equal(sampled.length, 4, 'no camera is sampled again');
|
|
||||||
assert.deepEqual(
|
|
||||||
h.records.map((record) => anchorHeight(h, record.id)),
|
|
||||||
before,
|
|
||||||
);
|
|
||||||
|
|
||||||
// A camera that moved is a different question.
|
|
||||||
h.records[0] = { ...h.records[0], latitude: h.records[0].latitude + 0.001 };
|
|
||||||
rebuild();
|
|
||||||
assert.equal(sampled.length, 5);
|
|
||||||
|
|
||||||
h.mapChanged();
|
|
||||||
h.paint();
|
|
||||||
settle(t, h);
|
|
||||||
assert.equal(sampled.length, 9, 'a new map surface is sampled afresh');
|
|
||||||
});
|
});
|
||||||
@@ -66,15 +66,14 @@ export const MAX_CANVAS_FRUSTUMS = 64;
|
|||||||
/** Metres a floor-placed marker sits above its resolved ground cell. */
|
/** Metres a floor-placed marker sits above its resolved ground cell. */
|
||||||
export const MARKER_FLOOR_LIFT_M = 1.5;
|
export const MARKER_FLOOR_LIFT_M = 1.5;
|
||||||
|
|
||||||
/** Rendered-surface samples one frame may take (on photoreal tiles each is a
|
/** Rendered-surface samples one overlay paint may take (each is a depth render). */
|
||||||
* depth render of several milliseconds, so they are spread over frames). */
|
export const ANCHOR_SAMPLES_PER_PAINT = 4;
|
||||||
export const SURFACE_SAMPLES_PER_FRAME = 1;
|
|
||||||
/** Surface answers kept by camera id, so a refresh or re-enable asks nothing. */
|
|
||||||
export const REMEMBERED_ANCHORS = 2048;
|
|
||||||
|
|
||||||
/** Accepted rendered-surface window around a floor cell (a cut or an embankment
|
/** Accepted rendered-surface window around a floor cell (a cut or an embankment
|
||||||
* sits within it; a rooftop or an unstreamed tile usually does not). */
|
* sits within it; a rooftop or an unstreamed tile usually does not). */
|
||||||
export const SURFACE_BELOW_FLOOR_M = 30;
|
export const SURFACE_BELOW_FLOOR_M = 30;
|
||||||
|
/** Rendered-surface refinements per paint while the camera is still. */
|
||||||
|
export const SURFACE_SAMPLES_PER_PAINT = 2;
|
||||||
export const SURFACE_ABOVE_FLOOR_M = 40;
|
export const SURFACE_ABOVE_FLOOR_M = 40;
|
||||||
|
|
||||||
/** OSM attribution may collapse after five seconds; full credit stays in Data attribution. */
|
/** OSM attribution may collapse after five seconds; full credit stays in Data attribution. */
|
||||||
|
|||||||
@@ -144,33 +144,35 @@ export function createFrames({ state: layerState, services, parts, source }) {
|
|||||||
* the double-buffer canvas reference, throttled to PROJECTION_TEXTURE_SWAP_MS.
|
* the double-buffer canvas reference, throttled to PROJECTION_TEXTURE_SWAP_MS.
|
||||||
*
|
*
|
||||||
* @param {Object} record - Camera record with an initialized projection runtime.
|
* @param {Object} record - Camera record with an initialized projection runtime.
|
||||||
|
* @returns {boolean} Whether a new image was put on the plane.
|
||||||
*/
|
*/
|
||||||
|
|
||||||
function refreshProjectionTextures(record) {
|
function refreshProjectionTextures(record) {
|
||||||
const runtime = record?.projection;
|
const runtime = record?.projection;
|
||||||
if (!runtime || runtime.mode === 'video') return;
|
if (!runtime || runtime.mode === 'video') return false;
|
||||||
const now = Date.now();
|
const now = Date.now();
|
||||||
if (
|
if (
|
||||||
now - parts.model.safeNumber(runtime.lastTextureSwapAt, 0) <
|
now - parts.model.safeNumber(runtime.lastTextureSwapAt, 0) <
|
||||||
PROJECTION_TEXTURE_SWAP_MS
|
PROJECTION_TEXTURE_SWAP_MS
|
||||||
)
|
)
|
||||||
return;
|
return false;
|
||||||
|
|
||||||
const planeShowing = !!(runtime.planeEntity?.show && runtime.planeMaterial);
|
const planeShowing = !!(runtime.planeEntity?.show && runtime.planeMaterial);
|
||||||
if (!planeShowing) return;
|
if (!planeShowing) return false;
|
||||||
|
|
||||||
// Only swap when the canvas content actually changed since the last swap.
|
// Only swap when the canvas content actually changed since the last swap.
|
||||||
// Frames land every ~10 s but this runs at 1 Hz — swapping an UNCHANGED
|
// Frames land every ~10 s but this runs at 1 Hz — swapping an UNCHANGED
|
||||||
// canvas re-uploads the texture for nothing, and each material image
|
// canvas re-uploads the texture for nothing, and each material image
|
||||||
// reassignment is a flash opportunity on the live plane (owner field test
|
// reassignment is a flash opportunity on the live plane (owner field test
|
||||||
// 2026-07-04: intermittent white flashes on the monitor plane).
|
// 2026-07-04: intermittent white flashes on the monitor plane).
|
||||||
if (runtime.canvasStamp === runtime.lastSwappedCanvasStamp) return;
|
if (runtime.canvasStamp === runtime.lastSwappedCanvasStamp) return false;
|
||||||
|
|
||||||
const buffer = paintNextProjectionBuffer(runtime);
|
const buffer = paintNextProjectionBuffer(runtime);
|
||||||
if (!buffer) return;
|
if (!buffer) return false;
|
||||||
runtime.lastTextureSwapAt = now;
|
runtime.lastTextureSwapAt = now;
|
||||||
runtime.lastSwappedCanvasStamp = runtime.canvasStamp;
|
runtime.lastSwappedCanvasStamp = runtime.canvasStamp;
|
||||||
runtime.planeMaterial.image = buffer;
|
runtime.planeMaterial.image = buffer;
|
||||||
|
return true;
|
||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
|
|||||||
@@ -123,6 +123,11 @@ export const CCTV_CALIBRATION_STORAGE_KEY_V2 =
|
|||||||
|
|
||||||
export const PROJECTION_TEXTURE_SWAP_MS = 1000;
|
export const PROJECTION_TEXTURE_SWAP_MS = 1000;
|
||||||
|
|
||||||
|
// A still-image projection changes only when a new still is swapped onto the
|
||||||
|
// plane, so the scene renders for this long after a swap (Cesium binds the new
|
||||||
|
// image over the next frames) and is otherwise left idle.
|
||||||
|
export const PROJECTION_SWAP_RENDER_MS = 500;
|
||||||
|
|
||||||
// V2 frustum geometry (design §2a/§6): the far-cap center + corners never sink
|
// V2 frustum geometry (design §2a/§6): the far-cap center + corners never sink
|
||||||
// below groundAlt + this clearance, so a fabricated pitch (-24°) cannot bury
|
// below groundAlt + this clearance, so a fabricated pitch (-24°) cannot bury
|
||||||
// the monitor plane in the 3D tiles. Exported for the unit suite.
|
// the monitor plane in the 3D tiles. Exported for the unit suite.
|
||||||
|
|||||||
@@ -6,6 +6,7 @@ import {
|
|||||||
PLANE_OUTLINE_COLOR,
|
PLANE_OUTLINE_COLOR,
|
||||||
PROJECTION_CANVAS_WIDTH,
|
PROJECTION_CANVAS_WIDTH,
|
||||||
PROJECTION_CANVAS_HEIGHT,
|
PROJECTION_CANVAS_HEIGHT,
|
||||||
|
PROJECTION_SWAP_RENDER_MS,
|
||||||
} from './policy.js';
|
} from './policy.js';
|
||||||
|
|
||||||
export function createProjection({
|
export function createProjection({
|
||||||
@@ -14,7 +15,15 @@ export function createProjection({
|
|||||||
parts,
|
parts,
|
||||||
source,
|
source,
|
||||||
}) {
|
}) {
|
||||||
const { holdContinuousRender, releaseContinuousRender } = services.render;
|
const {
|
||||||
|
holdContinuousRender,
|
||||||
|
releaseContinuousRender,
|
||||||
|
governorRequestRender = () => {},
|
||||||
|
} = services.render;
|
||||||
|
// Until this time (performance.now) the projection loop asks for a frame on
|
||||||
|
// every tick: after a still is swapped onto the plane, and after an edge
|
||||||
|
// that re-arms the loop (activation, projection shown).
|
||||||
|
let renderUntil = 0;
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* Build the protected label associated with one active monitor plane.
|
* Build the protected label associated with one active monitor plane.
|
||||||
@@ -352,12 +361,9 @@ export function createProjection({
|
|||||||
}
|
}
|
||||||
|
|
||||||
function startProjectionLoop() {
|
function startProjectionLoop() {
|
||||||
|
renderUntil = performance.now() + PROJECTION_SWAP_RENDER_MS;
|
||||||
if (layerState._projectionRaf) return;
|
if (layerState._projectionRaf) return;
|
||||||
if (!parts.model.projectionLoopIsNeeded()) return;
|
if (!parts.model.projectionLoopIsNeeded()) return;
|
||||||
// The armed projection loop uploads video textures / runs focus fades per
|
|
||||||
// frame — the scene must render continuously while it runs. Released when
|
|
||||||
// the tick self-stops. (perf wave 2)
|
|
||||||
holdContinuousRender('cctv-projection');
|
|
||||||
|
|
||||||
const tick = () => {
|
const tick = () => {
|
||||||
if (!layerState._viewer || !parts.model.projectionLoopIsNeeded()) {
|
if (!layerState._viewer || !parts.model.projectionLoopIsNeeded()) {
|
||||||
@@ -366,15 +372,30 @@ export function createProjection({
|
|||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
parts.rendering.refreshCctvFocusStyles(performance.now());
|
const now = performance.now();
|
||||||
|
const restyled = parts.rendering.refreshCctvFocusStyles(now);
|
||||||
|
|
||||||
const active = parts.selection.getActiveRecord();
|
const active = parts.selection.getActiveRecord();
|
||||||
|
let video = false;
|
||||||
if (layerState._enabled && layerState._showProjection && active) {
|
if (layerState._enabled && layerState._showProjection && active) {
|
||||||
ensureProjectionRuntime(active);
|
ensureProjectionRuntime(active);
|
||||||
if (active.projection && !active.projection.video) {
|
if (active.projection && !active.projection.video) {
|
||||||
parts.frames.drawProjectionFrame(active);
|
parts.frames.drawProjectionFrame(active);
|
||||||
parts.frames.refreshProjectionTextures(active);
|
if (parts.frames.refreshProjectionTextures(active))
|
||||||
}
|
renderUntil = now + PROJECTION_SWAP_RENDER_MS;
|
||||||
|
} else video = Boolean(active.projection?.video);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Only a video feed changes the scene on every frame, so only video
|
||||||
|
// holds the continuous loop. A still lands about every ten seconds and
|
||||||
|
// a focus fade restyles icons every 80 ms; each asks for the frames it
|
||||||
|
// needs. Holding for stills rendered the scene 60 times a second for as
|
||||||
|
// long as a camera was active. (perf wave 2 held for both.)
|
||||||
|
if (video) holdContinuousRender('cctv-projection');
|
||||||
|
else {
|
||||||
|
releaseContinuousRender('cctv-projection');
|
||||||
|
if (restyled || now < renderUntil)
|
||||||
|
governorRequestRender('cctv-projection');
|
||||||
}
|
}
|
||||||
|
|
||||||
layerState._projectionRaf = requestAnimationFrame(tick);
|
layerState._projectionRaf = requestAnimationFrame(tick);
|
||||||
|
|||||||
@@ -0,0 +1,211 @@
|
|||||||
|
import test from 'node:test';
|
||||||
|
import assert from 'node:assert/strict';
|
||||||
|
import { createProjection } from './projection.js';
|
||||||
|
import { createFrames } from './frames.js';
|
||||||
|
import {
|
||||||
|
PROJECTION_SWAP_RENDER_MS,
|
||||||
|
PROJECTION_TEXTURE_SWAP_MS,
|
||||||
|
} from './policy.js';
|
||||||
|
|
||||||
|
/** The projection loop on a hand-cranked clock, with the render governor's calls recorded. */
|
||||||
|
function harness(t, { video = false, showProjection = true } = {}) {
|
||||||
|
let clock = 1000;
|
||||||
|
const frames = [];
|
||||||
|
const original = {
|
||||||
|
now: performance.now,
|
||||||
|
request: globalThis.requestAnimationFrame,
|
||||||
|
cancel: globalThis.cancelAnimationFrame,
|
||||||
|
};
|
||||||
|
performance.now = () => clock;
|
||||||
|
globalThis.requestAnimationFrame = (step) => frames.push(step);
|
||||||
|
globalThis.cancelAnimationFrame = () => frames.splice(0);
|
||||||
|
t.after(() => {
|
||||||
|
performance.now = original.now;
|
||||||
|
globalThis.requestAnimationFrame = original.request;
|
||||||
|
globalThis.cancelAnimationFrame = original.cancel;
|
||||||
|
});
|
||||||
|
|
||||||
|
const holds = new Set();
|
||||||
|
const calls = { hold: 0, requests: 0, draws: 0 };
|
||||||
|
const record = {
|
||||||
|
camera: { id: 'cam-1' },
|
||||||
|
projection: { video: video ? {} : null, mode: video ? 'video' : 'image' },
|
||||||
|
};
|
||||||
|
const scene = { needed: true, swap: false, restyled: false };
|
||||||
|
const state = {
|
||||||
|
_viewer: {},
|
||||||
|
_enabled: true,
|
||||||
|
_showProjection: showProjection,
|
||||||
|
_projectionRaf: 0,
|
||||||
|
_projectionEntities: [],
|
||||||
|
};
|
||||||
|
const projection = createProjection({
|
||||||
|
state,
|
||||||
|
services: {
|
||||||
|
render: {
|
||||||
|
holdContinuousRender(owner) {
|
||||||
|
calls.hold++;
|
||||||
|
holds.add(owner);
|
||||||
|
},
|
||||||
|
releaseContinuousRender: (owner) => holds.delete(owner),
|
||||||
|
governorRequestRender: () => calls.requests++,
|
||||||
|
},
|
||||||
|
},
|
||||||
|
parts: {
|
||||||
|
model: { projectionLoopIsNeeded: () => scene.needed },
|
||||||
|
rendering: { refreshCctvFocusStyles: () => scene.restyled },
|
||||||
|
selection: { getActiveRecord: () => record },
|
||||||
|
frames: {
|
||||||
|
drawProjectionFrame: () => calls.draws++,
|
||||||
|
refreshProjectionTextures() {
|
||||||
|
const swapped = scene.swap;
|
||||||
|
scene.swap = false;
|
||||||
|
return swapped;
|
||||||
|
},
|
||||||
|
},
|
||||||
|
},
|
||||||
|
source: {},
|
||||||
|
});
|
||||||
|
return {
|
||||||
|
projection,
|
||||||
|
state,
|
||||||
|
record,
|
||||||
|
scene,
|
||||||
|
holds,
|
||||||
|
calls,
|
||||||
|
/** Run `count` animation frames 16 ms apart; returns the frames requested in them. */
|
||||||
|
run(count = 1) {
|
||||||
|
const before = calls.requests;
|
||||||
|
for (let i = 0; i < count; i++) {
|
||||||
|
clock += 16;
|
||||||
|
frames.shift()?.();
|
||||||
|
}
|
||||||
|
return calls.requests - before;
|
||||||
|
},
|
||||||
|
advance(ms) {
|
||||||
|
clock += ms;
|
||||||
|
},
|
||||||
|
get queued() {
|
||||||
|
return frames.length;
|
||||||
|
},
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
test('a still-image camera never holds the continuous render loop', (t) => {
|
||||||
|
const h = harness(t);
|
||||||
|
h.projection.startProjectionLoop();
|
||||||
|
h.run(600);
|
||||||
|
assert.equal(h.calls.hold, 0);
|
||||||
|
assert.equal(h.holds.size, 0);
|
||||||
|
assert.equal(h.calls.draws, 600, 'the loop still polls for a new still');
|
||||||
|
assert.equal(h.queued, 1, 'and stays armed');
|
||||||
|
});
|
||||||
|
|
||||||
|
test('a new still on the plane is rendered, then the scene goes idle again', (t) => {
|
||||||
|
const h = harness(t);
|
||||||
|
h.projection.startProjectionLoop();
|
||||||
|
// Arming the loop (activation, projection shown) renders its first frames.
|
||||||
|
assert.ok(h.run(5) === 5);
|
||||||
|
h.advance(PROJECTION_SWAP_RENDER_MS);
|
||||||
|
assert.equal(h.run(120), 0, 'an unchanged still asks for no frame');
|
||||||
|
|
||||||
|
h.scene.swap = true;
|
||||||
|
assert.equal(h.run(1), 1, 'the tick that swaps the image asks for a frame');
|
||||||
|
const settling = Math.floor(PROJECTION_SWAP_RENDER_MS / 16) - 2;
|
||||||
|
assert.equal(h.run(settling), settling, 'and so do the ticks while it binds');
|
||||||
|
h.advance(PROJECTION_SWAP_RENDER_MS);
|
||||||
|
assert.equal(h.run(120), 0);
|
||||||
|
assert.equal(h.holds.size, 0);
|
||||||
|
});
|
||||||
|
|
||||||
|
test('activating another camera while the loop runs renders its first frames', (t) => {
|
||||||
|
const h = harness(t);
|
||||||
|
h.projection.startProjectionLoop();
|
||||||
|
h.advance(PROJECTION_SWAP_RENDER_MS * 2);
|
||||||
|
assert.equal(h.run(10), 0);
|
||||||
|
h.projection.startProjectionLoop();
|
||||||
|
assert.equal(h.run(10), 10);
|
||||||
|
assert.equal(h.queued, 1, 'still one loop');
|
||||||
|
});
|
||||||
|
|
||||||
|
test('a video camera holds continuous render until it stops being video', (t) => {
|
||||||
|
const h = harness(t, { video: true });
|
||||||
|
h.projection.startProjectionLoop();
|
||||||
|
h.run(3);
|
||||||
|
assert.deepEqual([...h.holds], ['cctv-projection']);
|
||||||
|
assert.equal(h.calls.draws, 0, 'Cesium updates the video texture itself');
|
||||||
|
// The stream failed over to stills.
|
||||||
|
h.record.projection.video = null;
|
||||||
|
h.run(1);
|
||||||
|
assert.equal(h.holds.size, 0);
|
||||||
|
h.record.projection.video = {};
|
||||||
|
h.run(1);
|
||||||
|
assert.deepEqual([...h.holds], ['cctv-projection']);
|
||||||
|
h.projection.stopProjectionLoop();
|
||||||
|
assert.equal(h.holds.size, 0);
|
||||||
|
});
|
||||||
|
|
||||||
|
test('a focus fade asks for a frame only on the ticks that restyle an icon', (t) => {
|
||||||
|
const h = harness(t, { showProjection: false });
|
||||||
|
h.projection.startProjectionLoop();
|
||||||
|
h.advance(PROJECTION_SWAP_RENDER_MS * 2);
|
||||||
|
assert.equal(h.run(10), 0);
|
||||||
|
h.scene.restyled = true;
|
||||||
|
assert.equal(h.run(4), 4);
|
||||||
|
h.scene.restyled = false;
|
||||||
|
assert.equal(h.run(10), 0);
|
||||||
|
assert.equal(h.holds.size, 0);
|
||||||
|
});
|
||||||
|
|
||||||
|
test('the loop releases and stops when it has no work', (t) => {
|
||||||
|
const h = harness(t, { video: true });
|
||||||
|
h.projection.startProjectionLoop();
|
||||||
|
h.run(2);
|
||||||
|
h.scene.needed = false;
|
||||||
|
h.run(1);
|
||||||
|
assert.equal(h.holds.size, 0);
|
||||||
|
assert.equal(h.state._projectionRaf, 0);
|
||||||
|
assert.equal(h.queued, 0);
|
||||||
|
});
|
||||||
|
|
||||||
|
test('refreshProjectionTextures reports whether it put a new image on the plane', (t) => {
|
||||||
|
const previousDocument = globalThis.document;
|
||||||
|
globalThis.document = {
|
||||||
|
createElement: () => ({
|
||||||
|
getContext: () => ({ clearRect() {}, drawImage() {} }),
|
||||||
|
}),
|
||||||
|
};
|
||||||
|
t.after(() => {
|
||||||
|
if (previousDocument === undefined) delete globalThis.document;
|
||||||
|
else globalThis.document = previousDocument;
|
||||||
|
});
|
||||||
|
const frames = createFrames({
|
||||||
|
state: {},
|
||||||
|
services: {},
|
||||||
|
parts: { model: { safeNumber: (value, fallback) => value ?? fallback } },
|
||||||
|
source: {},
|
||||||
|
});
|
||||||
|
const runtime = {
|
||||||
|
mode: 'image',
|
||||||
|
canvas: {},
|
||||||
|
canvasStamp: 1,
|
||||||
|
planeEntity: { show: true },
|
||||||
|
planeMaterial: { image: null },
|
||||||
|
};
|
||||||
|
const record = { projection: runtime };
|
||||||
|
assert.equal(frames.refreshProjectionTextures(record), true);
|
||||||
|
const first = runtime.planeMaterial.image;
|
||||||
|
assert.ok(first);
|
||||||
|
// Unchanged canvas: nothing to render.
|
||||||
|
runtime.lastTextureSwapAt -= PROJECTION_TEXTURE_SWAP_MS;
|
||||||
|
assert.equal(frames.refreshProjectionTextures(record), false);
|
||||||
|
assert.equal(runtime.planeMaterial.image, first);
|
||||||
|
runtime.canvasStamp = 2;
|
||||||
|
assert.equal(frames.refreshProjectionTextures(record), true);
|
||||||
|
assert.notEqual(runtime.planeMaterial.image, first);
|
||||||
|
runtime.planeEntity.show = false;
|
||||||
|
runtime.canvasStamp = 3;
|
||||||
|
runtime.lastTextureSwapAt -= PROJECTION_TEXTURE_SWAP_MS;
|
||||||
|
assert.equal(frames.refreshProjectionTextures(record), false);
|
||||||
|
assert.equal(frames.refreshProjectionTextures({ projection: { mode: 'video' } }), false);
|
||||||
|
});
|
||||||
@@ -61,8 +61,8 @@ export function createRendering({
|
|||||||
!layerState._viewer ||
|
!layerState._viewer ||
|
||||||
!focusPassIsNeeded(target, layerState._activeFocusStyleCount)
|
!focusPassIsNeeded(target, layerState._activeFocusStyleCount)
|
||||||
)
|
)
|
||||||
return;
|
return false;
|
||||||
if (nowMs - layerState._lastFocusStyleAt < 80) return;
|
if (nowMs - layerState._lastFocusStyleAt < 80) return false;
|
||||||
layerState._lastFocusStyleAt = nowMs;
|
layerState._lastFocusStyleAt = nowMs;
|
||||||
const scene = layerState._viewer.scene;
|
const scene = layerState._viewer.scene;
|
||||||
const camera = layerState._viewer.camera;
|
const camera = layerState._viewer.camera;
|
||||||
@@ -82,6 +82,8 @@ export function createRendering({
|
|||||||
baseColorFor: cameraColorFor,
|
baseColorFor: cameraColorFor,
|
||||||
});
|
});
|
||||||
layerState._activeFocusStyleCount = result.activeCount;
|
layerState._activeFocusStyleCount = result.activeCount;
|
||||||
|
// Whether an icon was restyled, so the caller can ask for a frame.
|
||||||
|
return result.writes > 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
|
|||||||
Reference in new issue
Block a user