mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-18 17:22:19 +00:00
- Clicks: when two tools want the globe's clicks, the newest takes them and the older is told and turns itself off; a click is decided when it arrives, and ambient selection fires only when no tool holds the pointer. The "map is busy" paths and their strings are removed. - Recession: the limb fade is shared (src/render/recession.js) and reaches icon and model sets through SetSpec.recede; tuning applies on the next frame. - Display panel groups are published through src/ui/displayGroups.js; the Weather group and src/viewWeather.js are removed. - Draw port: a set whose icons only move is moved in place, and models that did not change are not restyled each frame, so moving fleets cost what they did when drawn directly; an untinted, fully opaque model is drawn without a colour. - Conformance: input.lease.lost checks the new lease inside onLost and reports a throwing onLost; draw.sets.recede covers model sets. - QA scripts read the renderer host instead of internals the seam replaced.
861 lines
31 KiB
JavaScript
861 lines
31 KiB
JavaScript
import test from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import {
|
|
DepthSnapshot,
|
|
SURFACE_FIRST_ANSWER_MS,
|
|
SURFACE_FORGET_MS,
|
|
SURFACE_MAX_FRAME_STEP_MS,
|
|
SURFACE_OCCLUSION_MIN_MARGIN_M,
|
|
SURFACE_REAPPEAR_MS,
|
|
SURFACE_RETEST_MS,
|
|
SurfaceOcclusion,
|
|
depthToViewDistance,
|
|
projectContact,
|
|
surfaceHidesContact,
|
|
surfaceOcclusionMargin,
|
|
unpackDepth,
|
|
} from './detectionOcclusion.js';
|
|
import {
|
|
depthImage,
|
|
packDepth,
|
|
viewDistanceToDepth,
|
|
} from '../render/cesium/fixtures/fakeDepthScene.mjs';
|
|
|
|
test('the margin is 3 m near the camera and 2% of the range beyond 150 m', () => {
|
|
assert.equal(surfaceOcclusionMargin(10), SURFACE_OCCLUSION_MIN_MARGIN_M);
|
|
assert.equal(surfaceOcclusionMargin(150), 3);
|
|
assert.equal(surfaceOcclusionMargin(500), 10);
|
|
assert.equal(surfaceOcclusionMargin(5000), 100);
|
|
assert.equal(surfaceOcclusionMargin(0), 3);
|
|
assert.equal(surfaceOcclusionMargin(Number.NaN), 3);
|
|
});
|
|
|
|
test('looking down on a contact, the margin is what a 2 m rise on its line of sight takes', () => {
|
|
// 1 km away, seen from 30 degrees up: 2 m of rise is 4 m along the ray.
|
|
assert.ok(Math.abs(surfaceOcclusionMargin(1000, 0.5) - 4) < 1e-9);
|
|
// Straight down: the 3 m floor.
|
|
assert.equal(surfaceOcclusionMargin(1000, 1), SURFACE_OCCLUSION_MIN_MARGIN_M);
|
|
// Grazing, level or from below: never more than 2% of the range.
|
|
assert.equal(surfaceOcclusionMargin(1000, 0.01), 20);
|
|
assert.equal(surfaceOcclusionMargin(1000, 0), 20);
|
|
assert.equal(surfaceOcclusionMargin(1000, -0.3), 20);
|
|
assert.equal(surfaceOcclusionMargin(1000, Number.NaN), 20);
|
|
assert.equal(surfaceOcclusionMargin(100, 0.05), 3);
|
|
// A low wall 15 m in front of a street 1 km off, seen from 25 degrees up,
|
|
// stands about 6 m above the vehicle's line of sight: it hides it.
|
|
const sin25 = Math.sin((25 * Math.PI) / 180);
|
|
assert.equal(surfaceHidesContact(1000, 985, sin25), true);
|
|
assert.equal(surfaceHidesContact(1000, 985), false, 'unknown angle: 2%');
|
|
assert.equal(surfaceHidesContact(1000, 996, sin25), false, 'its own road');
|
|
});
|
|
|
|
test('a surface hides a contact only when nearer by more than the margin', () => {
|
|
// 500 m away: margin 10 m.
|
|
assert.equal(surfaceHidesContact(500, 489), true, 'a facade 11 m in front');
|
|
assert.equal(surfaceHidesContact(500, 491), false, 'its own road or dot');
|
|
assert.equal(surfaceHidesContact(500, 500), false);
|
|
assert.equal(surfaceHidesContact(500, 520), false, 'the ground behind it');
|
|
// Close range keeps the 3 m floor.
|
|
assert.equal(surfaceHidesContact(60, 56), true);
|
|
assert.equal(surfaceHidesContact(60, 58), false);
|
|
});
|
|
|
|
test('nothing drawn, or no distance, never hides a contact', () => {
|
|
assert.equal(surfaceHidesContact(500, undefined), false);
|
|
assert.equal(surfaceHidesContact(500, Number.NaN), false);
|
|
assert.equal(surfaceHidesContact(Number.NaN, 10), false);
|
|
});
|
|
|
|
test('packed depth unpacks most significant byte first', () => {
|
|
assert.equal(unpackDepth([0, 0, 0, 0], 0), 0);
|
|
assert.equal(unpackDepth([255, 0, 0, 0], 0), 1);
|
|
assert.equal(unpackDepth([9, 9, 51, 0, 0, 0], 2), 0.2);
|
|
for (const depth of [0.000123, 0.25, 0.5, 0.987654321]) {
|
|
const round = unpackDepth(packDepth(depth), 0);
|
|
assert.ok(Math.abs(round - depth) < 1e-9, `${depth} -> ${round}`);
|
|
}
|
|
});
|
|
|
|
test('logarithmic depth decodes to metres in front of the camera', () => {
|
|
const near = 0.1;
|
|
const far = 10_000_000;
|
|
// depth = log2(z - near + 1) / log2(far - near + 1)
|
|
for (const z of [0.5, 12, 480, 25_000, 3_000_000]) {
|
|
const depth = Math.log2(z - near + 1) / Math.log2(far - near + 1);
|
|
const decoded = depthToViewDistance(depth, near, far, true);
|
|
assert.ok(Math.abs(decoded - z) / z < 1e-9, `${z} -> ${decoded}`);
|
|
}
|
|
});
|
|
|
|
test('standard perspective depth decodes to metres in front of the camera', () => {
|
|
const near = 1;
|
|
const far = 5000;
|
|
// depth = far * (z - near) / (z * (far - near))
|
|
for (const z of [1.5, 40, 900, 4999]) {
|
|
const depth = (far * (z - near)) / (z * (far - near));
|
|
const decoded = depthToViewDistance(depth, near, far, false);
|
|
assert.ok(Math.abs(decoded - z) / z < 1e-9, `${z} -> ${decoded}`);
|
|
}
|
|
assert.ok(
|
|
Math.abs(depthToViewDistance(0.5, 1, 5000, false) - 10000 / 5001) < 1e-9,
|
|
'half depth sits just past twice the near plane',
|
|
);
|
|
});
|
|
|
|
test('the ends of the depth range, and a bad range, mean nothing was drawn', () => {
|
|
for (const log of [true, false]) {
|
|
assert.ok(Number.isNaN(depthToViewDistance(0, 1, 100, log)));
|
|
assert.ok(Number.isNaN(depthToViewDistance(1, 1, 100, log)));
|
|
assert.ok(Number.isNaN(depthToViewDistance(Number.NaN, 1, 100, log)));
|
|
assert.ok(Number.isNaN(depthToViewDistance(0.5, -1, 100, log)));
|
|
assert.ok(Number.isNaN(depthToViewDistance(0.5, 100, 100, log)));
|
|
}
|
|
// No near plane: standard depth has nothing to decode against.
|
|
assert.ok(Number.isNaN(depthToViewDistance(0.5, 0, 100, false)));
|
|
});
|
|
|
|
test('log depth with no near plane decodes as log2(1 + d) / log2(far + 1)', () => {
|
|
const depth = Math.log2(1 + 400) / Math.log2(100_000 + 1);
|
|
assert.ok(
|
|
Math.abs(depthToViewDistance(depth, 0, 100_000, true) - 400) < 1e-6,
|
|
);
|
|
});
|
|
|
|
const IDENTITY = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
|
|
|
|
/** A point `distance` metres ahead, `side` of the way to the frame edge. */
|
|
const ahead = (distance, side = 0, up = 0) => ({
|
|
x: side * distance,
|
|
y: up * distance,
|
|
z: -distance,
|
|
});
|
|
|
|
test('a contact projects to its place in the frame, from the bottom-left corner', () => {
|
|
const out = { u: -1, v: -1, threshold: -1 };
|
|
// 90 degree field of view: the frame edge is as far out as the point is ahead.
|
|
assert.equal(projectContact(IDENTITY, 1, 1, ahead(500), out), true);
|
|
assert.deepEqual([out.u, out.v], [0.5, 0.5]);
|
|
assert.equal(
|
|
projectContact(IDENTITY, 1, 1, ahead(500, -0.5, 0.5), out),
|
|
true,
|
|
);
|
|
assert.deepEqual([out.u, out.v], [0.25, 0.75]);
|
|
// A wider horizontal field of view pulls the same point towards the middle.
|
|
assert.equal(
|
|
projectContact(IDENTITY, 2, 1, ahead(500, -0.5, 0.5), out),
|
|
true,
|
|
);
|
|
assert.deepEqual([out.u, out.v], [0.375, 0.75]);
|
|
});
|
|
|
|
test('the threshold is the margin rule restated as a view distance', () => {
|
|
const out = { u: 0, v: 0, threshold: 0 };
|
|
// Straight ahead, distance and view distance are the same thing.
|
|
projectContact(IDENTITY, 1, 1, ahead(500), out);
|
|
assert.ok(Math.abs(out.threshold - 490) < 1e-9, '500 m less 2%');
|
|
projectContact(IDENTITY, 1, 1, ahead(60), out);
|
|
assert.ok(Math.abs(out.threshold - 57) < 1e-9, '60 m less the 3 m floor');
|
|
// Off axis the ray is longer than the view distance; the rule holds along
|
|
// the ray, so a surface at view distance d sits d * range / viewDistance out.
|
|
const corner = ahead(400, -0.9, 0.9);
|
|
const range = Math.hypot(corner.x, corner.y, corner.z);
|
|
projectContact(IDENTITY, 1, 1, corner, out);
|
|
for (const surfaceView of [out.threshold - 0.01, out.threshold + 0.01]) {
|
|
const alongRay = (surfaceView * range) / 400;
|
|
assert.equal(
|
|
surfaceHidesContact(range, alongRay),
|
|
surfaceView < out.threshold,
|
|
);
|
|
}
|
|
assert.ok(Math.abs(out.threshold - 400 * 0.98) < 1e-9);
|
|
});
|
|
|
|
test('the threshold uses how steeply the camera looks down on the contact', () => {
|
|
// A street on a sphere the size of the Earth, under a camera 1 km up and
|
|
// 1 km back along the surface, looking straight at it: 45 degrees down.
|
|
const R = 6_371_000;
|
|
const street = { x: 0, y: 0, z: R };
|
|
const camera = { x: 0, y: -1000, z: R + 1000 };
|
|
// Camera axes: x along world x, looking along (0, 1, -1) / sqrt 2.
|
|
const s = Math.SQRT1_2;
|
|
const forward = [0, s, -s];
|
|
const up = [0, s, s];
|
|
const right = [1, 0, 0];
|
|
const t = (axis) =>
|
|
-(axis[0] * camera.x + axis[1] * camera.y + axis[2] * camera.z);
|
|
// Rows: right, up, -forward (the camera looks down its -Z).
|
|
const back = forward.map((c) => -c);
|
|
const view = [
|
|
right[0],
|
|
up[0],
|
|
back[0],
|
|
0,
|
|
right[1],
|
|
up[1],
|
|
back[1],
|
|
0,
|
|
right[2],
|
|
up[2],
|
|
back[2],
|
|
0,
|
|
t(right),
|
|
t(up),
|
|
t(back),
|
|
1,
|
|
];
|
|
const out = { u: 0, v: 0, threshold: 0 };
|
|
assert.equal(projectContact(view, 1, 1, street, out), true);
|
|
assert.ok(Math.abs(out.u - 0.5) < 1e-9 && Math.abs(out.v - 0.5) < 1e-9);
|
|
const range = Math.SQRT2 * 1000;
|
|
// 2 m of rise at 45 degrees is 2.83 m along the ray: the 3 m floor, not
|
|
// 2% of 1414 m (28 m).
|
|
assert.ok(Math.abs(out.threshold - (range - 3)) < 1e-6, `${out.threshold}`);
|
|
});
|
|
|
|
test('off the middle of the frame, with the camera turned, the threshold matches the world-space rule', () => {
|
|
// Rotations about the three axes, then a camera placed and turned freely;
|
|
// the threshold must equal the margin rule worked out in world space.
|
|
const rot = (ax, ay, az) => {
|
|
const [cx, sx, cy, sy, cz, sz] = [
|
|
Math.cos(ax),
|
|
Math.sin(ax),
|
|
Math.cos(ay),
|
|
Math.sin(ay),
|
|
Math.cos(az),
|
|
Math.sin(az),
|
|
];
|
|
// Rows of Rz * Ry * Rx.
|
|
return [
|
|
[cz * cy, cz * sy * sx - sz * cx, cz * sy * cx + sz * sx],
|
|
[sz * cy, sz * sy * sx + cz * cx, sz * sy * cx - cz * sx],
|
|
[-sy, cy * sx, cy * cx],
|
|
];
|
|
};
|
|
const R = 6_371_000;
|
|
let checked = 0;
|
|
for (let k = 0; k < 200; k++) {
|
|
// A deterministic spread of poses.
|
|
const a = (n) => Math.sin(k * 12.9898 + n * 78.233) * 3;
|
|
const m = rot(a(1), a(2), a(3)); // world-to-camera rotation
|
|
const lat = a(4) / 3;
|
|
const lon = a(5);
|
|
const contact = {
|
|
x: R * Math.cos(lat) * Math.cos(lon),
|
|
y: R * Math.cos(lat) * Math.sin(lon),
|
|
z: R * Math.sin(lat),
|
|
};
|
|
// Camera 300 to 2300 m from the contact, in a direction above or below it.
|
|
const d = [a(6), a(7), a(8)];
|
|
const dl = Math.hypot(...d) || 1;
|
|
const dist = 1300 + 1000 * Math.sin(k);
|
|
const cam = {
|
|
x: contact.x + (d[0] / dl) * dist,
|
|
y: contact.y + (d[1] / dl) * dist,
|
|
z: contact.z + (d[2] / dl) * dist,
|
|
};
|
|
const t = m.map(
|
|
(row) => -(row[0] * cam.x + row[1] * cam.y + row[2] * cam.z),
|
|
);
|
|
const view = [
|
|
m[0][0],
|
|
m[1][0],
|
|
m[2][0],
|
|
0,
|
|
m[0][1],
|
|
m[1][1],
|
|
m[2][1],
|
|
0,
|
|
m[0][2],
|
|
m[1][2],
|
|
m[2][2],
|
|
0,
|
|
t[0],
|
|
t[1],
|
|
t[2],
|
|
1,
|
|
];
|
|
const out = { u: 0, v: 0, threshold: 0 };
|
|
if (!projectContact(view, 2, 2, contact, out)) continue;
|
|
checked++;
|
|
const toCam = [cam.x - contact.x, cam.y - contact.y, cam.z - contact.z];
|
|
const range = Math.hypot(...toCam);
|
|
const sinElevation =
|
|
(toCam[0] * contact.x + toCam[1] * contact.y + toCam[2] * contact.z) /
|
|
(range * R);
|
|
const viewDistance = -(
|
|
m[2][0] * contact.x +
|
|
m[2][1] * contact.y +
|
|
m[2][2] * contact.z +
|
|
t[2]
|
|
);
|
|
const expected =
|
|
viewDistance * (1 - surfaceOcclusionMargin(range, sinElevation) / range);
|
|
assert.ok(
|
|
Math.abs(out.threshold - expected) < 1e-6,
|
|
`pose ${k}: ${out.threshold} vs ${expected}`,
|
|
);
|
|
}
|
|
assert.ok(checked > 20, `${checked} poses in frame`);
|
|
});
|
|
|
|
test('behind the camera or outside the frame there is nothing to test', () => {
|
|
const out = { u: 7, v: 7, threshold: 7 };
|
|
assert.equal(
|
|
projectContact(IDENTITY, 1, 1, { x: 0, y: 0, z: 500 }, out),
|
|
false,
|
|
);
|
|
assert.equal(
|
|
projectContact(IDENTITY, 1, 1, { x: 0, y: 0, z: 0 }, out),
|
|
false,
|
|
);
|
|
assert.equal(projectContact(IDENTITY, 1, 1, ahead(500, -1.2), out), false);
|
|
assert.equal(projectContact(IDENTITY, 1, 1, ahead(500, 0, 1.01), out), false);
|
|
assert.equal(
|
|
projectContact(IDENTITY, 1, 1, ahead(500, 1), out),
|
|
false,
|
|
'u = 1',
|
|
);
|
|
assert.deepEqual(out, { u: 7, v: 7, threshold: 7 }, 'left untouched');
|
|
});
|
|
|
|
test('a contact is projected with the camera it is given', () => {
|
|
// Camera 1000 m up the +Z axis looking down -Z: view = translate(0, 0, -1000).
|
|
const view = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, -1000, 1];
|
|
const out = { u: 0, v: 0, threshold: 0 };
|
|
assert.equal(
|
|
projectContact(view, 1, 1, { x: -250, y: 0, z: 500 }, out),
|
|
true,
|
|
);
|
|
assert.equal(out.u, 0.25);
|
|
assert.equal(projectContact(view, 1, 1, { x: 0, y: 0, z: 1500 }, out), false);
|
|
});
|
|
|
|
/**
|
|
* A snapshot from a camera at the origin looking down -Z with a 90 degree
|
|
* field of view. By default one depth range in which the left half of the
|
|
* frame is a wall `wall` metres away and the right half is ground `ground`
|
|
* metres away.
|
|
*/
|
|
function snapshotWithWall({
|
|
wall = 400,
|
|
ground = 500,
|
|
logDepth = true,
|
|
size = 8,
|
|
frustums,
|
|
images,
|
|
} = {}) {
|
|
const ranges = frustums || [{ near: 1, far: 100_000 }];
|
|
const layers = images || [
|
|
depthImage(size, size, (column) =>
|
|
viewDistanceToDepth(
|
|
column < size / 2 ? wall : ground,
|
|
ranges[0].near,
|
|
ranges[0].far,
|
|
logDepth,
|
|
),
|
|
),
|
|
];
|
|
const bytes = new Uint8Array(size * size * 4 * layers.length);
|
|
layers.forEach((image, i) => bytes.set(image.data, i * size * size * 4));
|
|
return new DepthSnapshot({
|
|
width: size,
|
|
height: size,
|
|
bytes,
|
|
frustums: ranges,
|
|
logDepth,
|
|
view: IDENTITY,
|
|
tanHalfFovX: 1,
|
|
tanHalfFovY: 1,
|
|
});
|
|
}
|
|
|
|
test('a contact behind a drawn wall is hidden; one on drawn ground, or in front of the wall, is not', () => {
|
|
for (const logDepth of [true, false]) {
|
|
const snapshot = snapshotWithWall({ logDepth });
|
|
assert.equal(snapshot.hides(ahead(500, -0.5)), true);
|
|
assert.equal(snapshot.hides(ahead(500, 0.5)), false);
|
|
assert.equal(snapshot.hides(ahead(300, -0.5)), false);
|
|
// 2% of 405 m is 8.1 m: 5 m behind the wall is still the wall's own face.
|
|
assert.equal(snapshot.hides(ahead(405, -0.5)), false);
|
|
assert.equal(snapshot.hides(ahead(412, -0.5)), true);
|
|
assert.equal(snapshot.hides(ahead(500, -1.5)), null, 'outside the frame');
|
|
}
|
|
});
|
|
|
|
test('rows are read bottom to top', () => {
|
|
const size = 8;
|
|
const image = depthImage(size, size, (_column, row) =>
|
|
viewDistanceToDepth(row < size / 2 ? 400 : 500, 1, 100_000, true),
|
|
);
|
|
const snapshot = snapshotWithWall({ images: [image] });
|
|
assert.equal(snapshot.hides(ahead(500, 0, -0.5)), true, 'below centre');
|
|
assert.equal(snapshot.hides(ahead(500, 0, 0.5)), false, 'above centre');
|
|
});
|
|
|
|
test('the nearest depth range that drew something answers', () => {
|
|
const size = 4;
|
|
const frustums = [
|
|
{ near: 1, far: 1000 },
|
|
{ near: 999, far: 1_000_000 },
|
|
];
|
|
// Near range: a wall 400 m away on the left, nothing on the right.
|
|
const nearImage = depthImage(size, size, (column) =>
|
|
column < 2 ? viewDistanceToDepth(400, 1, 1000, true) : 1,
|
|
);
|
|
// Far range: ground 20 km away everywhere.
|
|
const farImage = depthImage(size, size, () =>
|
|
viewDistanceToDepth(20_000, 999, 1_000_000, true),
|
|
);
|
|
const snapshot = snapshotWithWall({
|
|
size,
|
|
frustums,
|
|
images: [nearImage, farImage],
|
|
});
|
|
assert.ok(Math.abs(snapshot.surfaceViewDistance(0, 0) - 400) < 0.01);
|
|
assert.ok(Math.abs(snapshot.surfaceViewDistance(3, 0) - 20_000) < 1);
|
|
assert.equal(snapshot.hides(ahead(15_000, -0.5)), true);
|
|
assert.equal(snapshot.hides(ahead(15_000, 0.5)), false);
|
|
assert.equal(snapshot.hides(ahead(30_000, 0.5)), true);
|
|
});
|
|
|
|
test('where nothing was drawn a contact is visible', () => {
|
|
const size = 4;
|
|
const snapshot = snapshotWithWall({
|
|
size,
|
|
images: [depthImage(size, size, () => 1)],
|
|
});
|
|
assert.ok(Number.isNaN(snapshot.surfaceViewDistance(1, 1)));
|
|
assert.equal(snapshot.hides(ahead(500)), false);
|
|
});
|
|
|
|
/**
|
|
* A probe that answers when told to. `hidden` decides each test's answer at
|
|
* the time it is resolved.
|
|
*/
|
|
function manualProbe() {
|
|
const inFlight = [];
|
|
return {
|
|
accepting: true,
|
|
started: 0,
|
|
inFlight,
|
|
add(contact) {
|
|
if (!this.accepting) return false;
|
|
this.started++;
|
|
contact.pending = true;
|
|
inFlight.push(contact);
|
|
return true;
|
|
},
|
|
/** Deliver every answer in flight. */
|
|
answer(hidden, now) {
|
|
for (const contact of inFlight.splice(0)) {
|
|
contact.pending = false;
|
|
contact.answered = true;
|
|
if (hidden) contact.lastHiddenAt = now;
|
|
}
|
|
},
|
|
};
|
|
}
|
|
|
|
const anywhere = { x: 0, y: 0, z: -500 };
|
|
|
|
test('a contact is drawn until an answer says it is hidden, then hidden at once', () => {
|
|
const probe = manualProbe();
|
|
const occlusion = new SurfaceOcclusion(probe);
|
|
occlusion.beginFrame(1000);
|
|
assert.equal(occlusion.isHidden('traffic', 'a', anywhere), false);
|
|
assert.equal(probe.started, 1, 'a new contact is tested straight away');
|
|
occlusion.beginFrame(1016);
|
|
assert.equal(occlusion.isHidden('traffic', 'a', anywhere), false);
|
|
assert.equal(probe.started, 1, 'one test in flight per contact');
|
|
probe.answer(true, occlusion.now);
|
|
occlusion.beginFrame(1032);
|
|
assert.equal(occlusion.isHidden('traffic', 'a', anywhere), true);
|
|
assert.equal(occlusion.testedCount, 1);
|
|
assert.equal(occlusion.hiddenCount, 1);
|
|
// The same source id on another layer is another contact.
|
|
assert.equal(occlusion.isHidden('transit', 'a', anywhere), false);
|
|
});
|
|
|
|
test('with a working probe a new contact is held back until its first answer, and no longer than the limit', () => {
|
|
const probe = manualProbe();
|
|
probe.mode = 'async';
|
|
const occlusion = new SurfaceOcclusion(probe);
|
|
occlusion.beginFrame(0);
|
|
// New to the view: tested at once, and not drawn while the answer is out.
|
|
assert.equal(occlusion.isHidden('traffic', 'street', anywhere), true);
|
|
assert.equal(occlusion.isHidden('traffic', 'roofed', anywhere), true);
|
|
assert.equal(occlusion.isHidden('traffic', 'unanswered', anywhere), true);
|
|
assert.equal(probe.started, 3);
|
|
const [street, roofed] = probe.inFlight.splice(0, 2);
|
|
street.pending = false;
|
|
street.answered = true;
|
|
roofed.pending = false;
|
|
roofed.answered = true;
|
|
roofed.lastHiddenAt = occlusion.now;
|
|
occlusion.beginFrame(16);
|
|
assert.equal(
|
|
occlusion.isHidden('traffic', 'street', anywhere),
|
|
false,
|
|
'drawn from its first answer',
|
|
);
|
|
assert.equal(
|
|
occlusion.isHidden('traffic', 'roofed', anywhere),
|
|
true,
|
|
'never drawn at all',
|
|
);
|
|
// The third answer never comes. It is drawn once the limit has passed.
|
|
const firstSeen = occlusion.now - 16;
|
|
const drawn = [];
|
|
for (let wall = 32; wall < 1000; wall += 16) {
|
|
occlusion.beginFrame(wall);
|
|
drawn.push([
|
|
occlusion.now - firstSeen,
|
|
!occlusion.isHidden('traffic', 'unanswered', anywhere),
|
|
]);
|
|
}
|
|
for (const [age, shown] of drawn)
|
|
assert.equal(shown, age >= SURFACE_FIRST_ANSWER_MS, `at ${age} ms`);
|
|
|
|
// No working probe: a new contact is drawn at once, as before.
|
|
for (const mode of ['off', 'sync', undefined]) {
|
|
const idle = manualProbe();
|
|
idle.mode = mode;
|
|
const plain = new SurfaceOcclusion(idle);
|
|
plain.beginFrame(0);
|
|
assert.equal(plain.isHidden('traffic', 'a', anywhere), false, String(mode));
|
|
}
|
|
});
|
|
|
|
test('a contact is retested at most every retest interval and at least every half of it', () => {
|
|
const probe = manualProbe();
|
|
const occlusion = new SurfaceOcclusion(probe);
|
|
const starts = [];
|
|
let before = 0;
|
|
for (let now = 0; now <= 2000; now += 4) {
|
|
probe.answer(false, now);
|
|
occlusion.beginFrame(now);
|
|
occlusion.isHidden('traffic', 'a', anywhere);
|
|
if (probe.started !== before) {
|
|
starts.push(now);
|
|
before = probe.started;
|
|
}
|
|
}
|
|
const gaps = starts.slice(1).map((at, i) => at - starts[i]);
|
|
assert.ok(gaps.length >= 9);
|
|
assert.ok(
|
|
gaps.every((gap) => gap <= SURFACE_RETEST_MS),
|
|
`${gaps}`,
|
|
);
|
|
assert.ok(
|
|
gaps.every((gap) => gap >= SURFACE_RETEST_MS / 2),
|
|
`${gaps}`,
|
|
);
|
|
assert.ok(new Set(gaps).size > 3, 'not all on the same beat');
|
|
});
|
|
|
|
test('contacts that appear together drift apart instead of all testing on the same frames', () => {
|
|
const probe = manualProbe();
|
|
const occlusion = new SurfaceOcclusion(probe);
|
|
const perFrame = [];
|
|
for (let frame = 0; frame < 240; frame++) {
|
|
const now = frame * 16;
|
|
probe.answer(false, now);
|
|
occlusion.beginFrame(now);
|
|
const before = probe.started;
|
|
for (let id = 0; id < 600; id++)
|
|
occlusion.isHidden('traffic', id, anywhere);
|
|
perFrame.push(probe.started - before);
|
|
}
|
|
assert.equal(perFrame[0], 600, 'every new contact is tested at once');
|
|
const settled = perFrame.slice(120);
|
|
assert.ok(Math.max(...settled) < 200, `peak ${Math.max(...settled)}`);
|
|
assert.ok(Math.min(...settled) > 0);
|
|
});
|
|
|
|
test('with more contacts than the probe takes per frame, the retests slow down and none is starved', () => {
|
|
// A probe that takes 256 tests a frame, 2,400 contacts in view, 30 fps.
|
|
const inFlight = [];
|
|
let taken = 0;
|
|
const probe = {
|
|
maxPerFrame: 256,
|
|
add(contact) {
|
|
if (taken >= 256) return false;
|
|
taken++;
|
|
contact.pending = true;
|
|
inFlight.push(contact);
|
|
return true;
|
|
},
|
|
};
|
|
const occlusion = new SurfaceOcclusion(probe);
|
|
const tests = new Array(2400).fill(0);
|
|
const lastStart = new Array(2400).fill(0);
|
|
let longestGap = 0;
|
|
for (let frame = 0; frame < 300; frame++) {
|
|
const now = frame * 33;
|
|
for (const contact of inFlight.splice(0)) contact.pending = false;
|
|
taken = 0;
|
|
occlusion.beginFrame(now);
|
|
for (let id = 0; id < 2400; id++) {
|
|
const before = taken;
|
|
occlusion.isHidden('traffic', id, anywhere);
|
|
if (taken !== before) {
|
|
tests[id]++;
|
|
if (frame > 60) longestGap = Math.max(longestGap, now - lastStart[id]);
|
|
lastStart[id] = now;
|
|
}
|
|
}
|
|
}
|
|
assert.ok(
|
|
Math.min(...tests) >= 8,
|
|
`fewest tests for one contact: ${Math.min(...tests)}`,
|
|
);
|
|
assert.ok(occlusion.retestMs > SURFACE_RETEST_MS);
|
|
assert.ok(longestGap <= occlusion.retestMs + 33, `longest gap ${longestGap}`);
|
|
assert.ok(occlusion.reappearMs >= 3 * occlusion.retestMs);
|
|
// A view the budget covers easily keeps the normal pace.
|
|
const few = new SurfaceOcclusion(probe);
|
|
for (let frame = 0; frame < 10; frame++) {
|
|
taken = 0;
|
|
few.beginFrame(frame * 16);
|
|
for (let id = 0; id < 300; id++) few.isHidden('traffic', id, anywhere);
|
|
}
|
|
assert.equal(few.retestMs, SURFACE_RETEST_MS);
|
|
assert.equal(few.reappearMs, SURFACE_REAPPEAR_MS);
|
|
});
|
|
|
|
test('a hidden contact comes back only after the reappear time without a hidden answer', () => {
|
|
const probe = manualProbe();
|
|
const occlusion = new SurfaceOcclusion(probe);
|
|
occlusion.beginFrame(0);
|
|
occlusion.isHidden('traffic', 'a', anywhere);
|
|
const hiddenAt = occlusion.now;
|
|
probe.answer(true, hiddenAt);
|
|
// Visible answers from now on; the contact still waits out the time.
|
|
let reappeared = null;
|
|
for (let wall = 16; wall < 2000 && reappeared === null; wall += 16) {
|
|
probe.answer(false, occlusion.now);
|
|
occlusion.beginFrame(wall);
|
|
if (!occlusion.isHidden('traffic', 'a', anywhere))
|
|
reappeared = occlusion.now;
|
|
}
|
|
assert.ok(reappeared - hiddenAt >= SURFACE_REAPPEAR_MS);
|
|
assert.ok(reappeared - hiddenAt < SURFACE_REAPPEAR_MS + 17);
|
|
});
|
|
|
|
test('a contact on an edge, answering either way in turn, stays hidden', () => {
|
|
const probe = manualProbe();
|
|
const occlusion = new SurfaceOcclusion(probe);
|
|
const drawn = [];
|
|
let answers = 0;
|
|
for (let wall = 0; wall < 4000; wall += 16) {
|
|
if (probe.inFlight.length > 0)
|
|
probe.answer(answers++ % 2 === 0, occlusion.now);
|
|
occlusion.beginFrame(wall);
|
|
drawn.push(!occlusion.isHidden('traffic', 'a', anywhere));
|
|
}
|
|
// Drawn only until the first answer arrives.
|
|
assert.equal(drawn.lastIndexOf(true), 0);
|
|
});
|
|
|
|
test('when the probe stops answering, hidden contacts are drawn again and stay drawn', () => {
|
|
const probe = manualProbe();
|
|
const occlusion = new SurfaceOcclusion(probe);
|
|
occlusion.beginFrame(0);
|
|
occlusion.isHidden('traffic', 'a', anywhere);
|
|
const hiddenAt = occlusion.now;
|
|
probe.answer(true, hiddenAt);
|
|
// No depth any more: the probe takes no tests and answers nothing.
|
|
probe.accepting = false;
|
|
const drawn = [];
|
|
for (let wall = 16; wall < 3000; wall += 16) {
|
|
occlusion.beginFrame(wall);
|
|
drawn.push([
|
|
occlusion.now - hiddenAt,
|
|
!occlusion.isHidden('traffic', 'a', anywhere),
|
|
]);
|
|
}
|
|
for (const [age, shown] of drawn)
|
|
assert.equal(shown, age >= SURFACE_REAPPEAR_MS, `at ${age} ms`);
|
|
// A probe that never accepted anything hides nothing.
|
|
const dead = new SurfaceOcclusion({ add: () => false });
|
|
dead.beginFrame(0);
|
|
assert.equal(dead.isHidden('traffic', 'a', anywhere), false);
|
|
});
|
|
|
|
test('a change of pace does not bring back a hidden that has run out', () => {
|
|
// 2,400 contacts with a 256-a-frame probe: the hide time is longer at 33 ms
|
|
// frames than at 16 ms ones.
|
|
const inFlight = [];
|
|
let taken = 0;
|
|
const probe = {
|
|
maxPerFrame: 256,
|
|
add(contact) {
|
|
if (taken >= 256) return false;
|
|
taken++;
|
|
contact.pending = true;
|
|
inFlight.push(contact);
|
|
return true;
|
|
},
|
|
};
|
|
const occlusion = new SurfaceOcclusion(probe);
|
|
let wall = 0;
|
|
const paint = (step) => {
|
|
wall += step;
|
|
for (const contact of inFlight.splice(0)) contact.pending = false;
|
|
taken = 0;
|
|
occlusion.beginFrame(wall);
|
|
let watched = false;
|
|
for (let id = 0; id < 2400; id++) {
|
|
const hidden = occlusion.isHidden('traffic', id, anywhere);
|
|
if (id === 0) watched = hidden;
|
|
}
|
|
return watched;
|
|
};
|
|
for (let i = 0; i < 30; i++) paint(16);
|
|
// One hidden answer for contact 0, then visible answers only.
|
|
occlusion.contacts.get('traffic').get(0).lastHiddenAt = occlusion.now;
|
|
const states = [];
|
|
for (let i = 0; i < 80; i++) states.push(paint(16));
|
|
assert.equal(states[0], true);
|
|
assert.equal(states.at(-1), false, 'ran out at the fast pace');
|
|
// The frames slow down, which lengthens the hide time for new answers.
|
|
const slow = [];
|
|
for (let i = 0; i < 40; i++) slow.push(paint(33));
|
|
assert.ok(occlusion.reappearMs > SURFACE_REAPPEAR_MS);
|
|
assert.ok(
|
|
slow.every((hidden) => hidden === false),
|
|
'and stays out',
|
|
);
|
|
});
|
|
|
|
test('a pause in painting does not run the hidden time out', () => {
|
|
const probe = manualProbe();
|
|
const occlusion = new SurfaceOcclusion(probe);
|
|
occlusion.beginFrame(0);
|
|
occlusion.isHidden('traffic', 'a', anywhere);
|
|
probe.answer(true, occlusion.now);
|
|
occlusion.beginFrame(16);
|
|
assert.equal(occlusion.isHidden('traffic', 'a', anywhere), true);
|
|
// Nothing is painted for a minute (a hidden tab, an idle scene). On the
|
|
// first frame back the contact is still hidden: no answer could have come.
|
|
const before = occlusion.now;
|
|
occlusion.beginFrame(60_016);
|
|
assert.equal(occlusion.now - before, SURFACE_MAX_FRAME_STEP_MS);
|
|
assert.equal(occlusion.isHidden('traffic', 'a', anywhere), true);
|
|
// A clock that jumps backwards moves nothing.
|
|
occlusion.beginFrame(100);
|
|
assert.equal(occlusion.now - before, SURFACE_MAX_FRAME_STEP_MS);
|
|
});
|
|
|
|
test('prune forgets contacts that are no longer drawn; clear forgets everything', () => {
|
|
const probe = manualProbe();
|
|
const occlusion = new SurfaceOcclusion(probe);
|
|
let wall = 0;
|
|
/** Paint frames for `ms` of painted time, drawing the given contacts. */
|
|
const paint = (ms, ids) => {
|
|
for (const end = occlusion.now + ms; occlusion.now < end;) {
|
|
wall += 50;
|
|
occlusion.beginFrame(wall);
|
|
for (const id of ids) occlusion.isHidden('traffic', id, anywhere);
|
|
}
|
|
};
|
|
paint(100, ['gone', 'here']);
|
|
paint(SURFACE_FORGET_MS + 50, ['here']);
|
|
occlusion.prune();
|
|
assert.deepEqual([...occlusion.contacts.get('traffic').keys()], ['here']);
|
|
paint(SURFACE_FORGET_MS + 50, []);
|
|
occlusion.prune();
|
|
assert.equal(occlusion.contacts.size, 0);
|
|
|
|
occlusion.isHidden('traffic', 'again', anywhere);
|
|
occlusion.clear();
|
|
assert.equal(occlusion.contacts.size, 0);
|
|
assert.equal(occlusion.testedCount, 0);
|
|
});
|
|
|
|
test('a contact back in view after a while waits for a fresh answer, like a new one', () => {
|
|
const probe = manualProbe();
|
|
probe.mode = 'async';
|
|
const occlusion = new SurfaceOcclusion(probe);
|
|
let wall = 0;
|
|
const step = () => occlusion.beginFrame((wall += 16));
|
|
step();
|
|
occlusion.isHidden('traffic', 'a', anywhere);
|
|
probe.answer(false, occlusion.now);
|
|
step();
|
|
assert.equal(occlusion.isHidden('traffic', 'a', anywhere), false);
|
|
// Out of view for a moment shorter than a retest: drawn straight away.
|
|
for (let i = 0; i < 5; i++) step();
|
|
assert.equal(occlusion.isHidden('traffic', 'a', anywhere), false);
|
|
// Out of view for longer (the camera swung away and back): the old
|
|
// "visible" may now be behind a building. Held back, and tested at once.
|
|
const started = probe.started;
|
|
for (let i = 0; i < 30; i++) step();
|
|
assert.equal(occlusion.isHidden('traffic', 'a', anywhere), true);
|
|
assert.equal(probe.started, started + 1);
|
|
probe.answer(true, occlusion.now);
|
|
step();
|
|
assert.equal(occlusion.isHidden('traffic', 'a', anywhere), true);
|
|
|
|
// It leaves with a test in flight, and comes back. That test's answer was
|
|
// about the previous view: when it lands, it must not end the hold-back.
|
|
const other = new SurfaceOcclusion(probe);
|
|
probe.answer(false, 0);
|
|
other.beginFrame((wall += 16));
|
|
other.isHidden('traffic', 'b', anywhere);
|
|
assert.equal(probe.inFlight.length, 1, 'tested, unanswered');
|
|
for (let i = 0; i < 30; i++) other.beginFrame((wall += 16));
|
|
const before = probe.started;
|
|
assert.equal(other.isHidden('traffic', 'b', anywhere), true);
|
|
assert.equal(probe.started, before + 1, 'tested afresh at once');
|
|
const [stale] = probe.inFlight.splice(0, 1);
|
|
stale.pending = false;
|
|
stale.answered = true;
|
|
other.beginFrame((wall += 16));
|
|
assert.equal(
|
|
other.isHidden('traffic', 'b', anywhere),
|
|
true,
|
|
'the old answer did not end the hold-back',
|
|
);
|
|
probe.answer(false, other.now);
|
|
other.beginFrame((wall += 16));
|
|
assert.equal(other.isHidden('traffic', 'b', anywhere), false);
|
|
});
|
|
|
|
test('at a stretched retest pace, new contacts are held back longer for their first answer', () => {
|
|
const probe = manualProbe();
|
|
probe.mode = 'async';
|
|
probe.maxPerFrame = 100;
|
|
const occlusion = new SurfaceOcclusion(probe);
|
|
occlusion.beginFrame(0);
|
|
for (let id = 0; id < 2000; id++) occlusion.isHidden('traffic', id, anywhere);
|
|
occlusion.beginFrame(33);
|
|
// 2000 contacts at 100 a frame and 33 ms frames: a retest every 1.3 s.
|
|
assert.ok(occlusion.retestMs > 1000, `${occlusion.retestMs}`);
|
|
assert.equal(occlusion.firstAnswerMs, occlusion.retestMs * 2);
|
|
assert.ok(occlusion.firstAnswerMs > SURFACE_FIRST_ANSWER_MS);
|
|
// A contact the probe has not reached yet is still held back past the
|
|
// usual limit, and drawn once the stretched one has run out.
|
|
probe.accepting = false;
|
|
let wall = 33;
|
|
const ages = [];
|
|
const firstSeen = occlusion.now;
|
|
occlusion.isHidden('traffic', 'late', anywhere);
|
|
while (occlusion.now - firstSeen < occlusion.firstAnswerMs + 100) {
|
|
occlusion.beginFrame((wall += 33));
|
|
for (let id = 0; id < 2000; id++)
|
|
occlusion.isHidden('traffic', id, anywhere);
|
|
ages.push([
|
|
occlusion.now - firstSeen,
|
|
occlusion.isHidden('traffic', 'late', anywhere),
|
|
]);
|
|
}
|
|
const limit = occlusion.firstAnswerMs;
|
|
assert.ok(
|
|
ages.some(([age, hidden]) => age > SURFACE_FIRST_ANSWER_MS + 50 && hidden),
|
|
'held past 400 ms',
|
|
);
|
|
for (const [age, hidden] of ages)
|
|
if (age >= limit) assert.equal(hidden, false, `at ${age} ms`);
|
|
});
|