mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 16:22:20 +00:00
358 lines
12 KiB
JavaScript
358 lines
12 KiB
JavaScript
import test from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import * as Cesium from 'cesium';
|
|
import { readFileSync } from 'node:fs';
|
|
import { TRAIL_VERTEX_LIMIT } from '../layers/transit/trails.js';
|
|
import {
|
|
createContactTrailRenderer,
|
|
trailAlpha,
|
|
} from './contactTrailRenderer.js';
|
|
|
|
function fixture(t, ground = false) {
|
|
for (const key of [
|
|
'HTMLCanvasElement',
|
|
'HTMLImageElement',
|
|
'ImageBitmap',
|
|
'OffscreenCanvas',
|
|
]) {
|
|
const prior = globalThis[key];
|
|
globalThis[key] = class {};
|
|
t.after(() => {
|
|
if (prior === undefined) delete globalThis[key];
|
|
else globalThis[key] = prior;
|
|
});
|
|
}
|
|
const width = Cesium.ContextLimits._maximumAliasedLineWidth;
|
|
Cesium.ContextLimits._maximumAliasedLineWidth = 1;
|
|
t.after(() => {
|
|
Cesium.ContextLimits._maximumAliasedLineWidth = width;
|
|
});
|
|
const primitives = new Cesium.PrimitiveCollection();
|
|
t.after(() => primitives.destroy());
|
|
const groundPrimitives = new Cesium.PrimitiveCollection();
|
|
t.after(() => groundPrimitives.destroy());
|
|
return {
|
|
primitives,
|
|
groundPrimitives,
|
|
frameState: { context: { depthTexture: ground } },
|
|
globe: { show: false },
|
|
};
|
|
}
|
|
test('body clips future subdivisions, head ends at exact marker, and frames retain geometry', (t) => {
|
|
const scene = fixture(t),
|
|
renderer = createContactTrailRenderer(scene);
|
|
const positions = [0, 1, 2].map((i) =>
|
|
Cesium.Cartesian3.fromDegrees(-71, 42 + i * 0.001, 11.5),
|
|
);
|
|
renderer.replaceHistory({
|
|
revision: 1,
|
|
segments: [
|
|
{
|
|
fromSeq: 0,
|
|
toSeq: 1,
|
|
fromT: 0,
|
|
toT: 10000,
|
|
positions: positions.slice(0, 2),
|
|
},
|
|
{
|
|
fromSeq: 0,
|
|
toSeq: 1,
|
|
fromT: 10000,
|
|
toT: 20000,
|
|
positions: positions.slice(1, 3),
|
|
},
|
|
],
|
|
});
|
|
const { body } = renderer.diagnostics();
|
|
assert.equal(body.allowPicking, false);
|
|
// The constructor defers this check until shader preparation. Run the real
|
|
// Cesium validator without WebGL, including a missing-attribute control.
|
|
const source = body.depthFailAppearance.vertexShaderSource;
|
|
body._batchTableAttributeIndices = { color: 0 };
|
|
assert.throws(
|
|
() => Cesium.Primitive._updateColorAttribute(body, source, true),
|
|
/depthFailColor/,
|
|
);
|
|
for (const instance of body.geometryInstances) {
|
|
assert.deepEqual(
|
|
instance.attributes.depthFailColor.value,
|
|
Cesium.ColorGeometryInstanceAttribute.toValue(
|
|
Cesium.Color.fromCssColorString('#5EF08A').withAlpha(0.55),
|
|
),
|
|
);
|
|
}
|
|
body._batchTableAttributeIndices = { color: 0, depthFailColor: 1 };
|
|
assert.doesNotThrow(() =>
|
|
Cesium.Primitive._updateColorAttribute(body, source, true),
|
|
);
|
|
const attributes = new Map(
|
|
body.geometryInstances.map((instance) => [
|
|
instance.id,
|
|
{
|
|
show: new Uint8Array([0]),
|
|
color: new Uint8Array(4),
|
|
depthFailColor: new Uint8Array(4),
|
|
},
|
|
]),
|
|
);
|
|
// Simulate Cesium's completed upload; exercise public attribute writes.
|
|
body._ready = true;
|
|
body.getGeometryInstanceAttributes = (id) => {
|
|
const stored = attributes.get(id),
|
|
accessor = {};
|
|
for (const name of ['show', 'color', 'depthFailColor'])
|
|
Object.defineProperty(accessor, name, {
|
|
get: () => stored[name].slice(),
|
|
set: (value) => {
|
|
stored[name] = value.slice();
|
|
},
|
|
});
|
|
return accessor;
|
|
};
|
|
const marker = Cesium.Cartesian3.lerp(
|
|
positions[1],
|
|
positions[2],
|
|
0.5,
|
|
new Cesium.Cartesian3(),
|
|
);
|
|
const sample = { displayT: 15000, fromSeq: 0, toSeq: 1, fraction: 0.75 };
|
|
for (let i = 0; i < 120; i++) renderer.setDisplaySample(sample, marker);
|
|
assert.deepEqual(
|
|
[...attributes.values()].map((a) => a.show[0]),
|
|
[1, 1, 0, 0],
|
|
);
|
|
for (const a of attributes.values())
|
|
assert.deepEqual(
|
|
a.depthFailColor,
|
|
Cesium.ColorGeometryInstanceAttribute.toValue(
|
|
Cesium.Color.fromCssColorString('#5EF08A').withAlpha(0.55),
|
|
),
|
|
);
|
|
const result = renderer.diagnostics();
|
|
assert.equal(result.body, body);
|
|
assert.equal(result.rebuilds, 1);
|
|
assert.equal(result.headRebuilds, 1, '120 frames retain head geometry');
|
|
assert.equal(result.head.material.uniforms.fraction, 0.5);
|
|
assert.equal(result.head.width, 3);
|
|
assert.equal(result.backing.width, 5);
|
|
assert.ok(Cesium.Cartesian3.equals(result.head.positions.at(-1), marker));
|
|
assert.equal(result.head.positions.length, 2);
|
|
renderer.setDisplaySample(
|
|
{ ...sample, displayT: 5000, fraction: 0.25 },
|
|
positions[0],
|
|
);
|
|
assert.ok(
|
|
[...attributes.values()].every((a) => a.show[0] === 0),
|
|
'rewind hides future geometry again',
|
|
);
|
|
renderer.destroy();
|
|
assert.equal(scene.primitives.length, 0);
|
|
});
|
|
test('trail age curve uses the specified four alpha anchors', () => {
|
|
assert.equal(trailAlpha(0), 0.8);
|
|
assert.equal(trailAlpha(120000), 0.45);
|
|
assert.equal(trailAlpha(600000), 0.2);
|
|
assert.equal(trailAlpha(900000), 0.08);
|
|
assert.ok(Math.abs(trailAlpha(60000) - 0.625) < 1e-10);
|
|
});
|
|
|
|
test('ground body and clipped head stay inside rebuild and frame geometry budgets', async () => {
|
|
Cesium.ApproximateTerrainHeights._terrainHeights = JSON.parse(
|
|
readFileSync(
|
|
new URL(
|
|
import.meta
|
|
.resolve('@cesium/engine/Source/Assets/approximateTerrainHeights.json'),
|
|
),
|
|
),
|
|
);
|
|
const positions = [
|
|
Cesium.Cartesian3.fromDegrees(-97.7431, 30.267),
|
|
Cesium.Cartesian3.fromDegrees(-97.7431, 30.2672),
|
|
];
|
|
const start = performance.now();
|
|
const instances = async (count) =>
|
|
Promise.all(
|
|
Array.from(
|
|
{ length: count },
|
|
async (_, i) =>
|
|
new Cesium.GeometryInstance({
|
|
id: i,
|
|
geometry: await Cesium.GroundPolylineGeometry.createGeometry(
|
|
new Cesium.GroundPolylineGeometry({
|
|
positions,
|
|
width: i % 2 ? 3 : 5,
|
|
granularity: 0,
|
|
}),
|
|
),
|
|
}),
|
|
),
|
|
);
|
|
const pipelineBytes = async (count) => {
|
|
// Match GroundPolylinePrimitive's internal Primitive options and the
|
|
// application's morph-capable scene, including batch IDs and encoding.
|
|
const result = Cesium.PrimitivePipeline.combineGeometry({
|
|
instances: await instances(count),
|
|
projection: new Cesium.GeographicProjection(),
|
|
ellipsoid: Cesium.Ellipsoid.WGS84,
|
|
modelMatrix: Cesium.Matrix4.clone(Cesium.Matrix4.IDENTITY),
|
|
elementIndexUintSupported: true,
|
|
scene3DOnly: false,
|
|
vertexCacheOptimize: false,
|
|
compressVertices: false,
|
|
createPickOffsets: false,
|
|
});
|
|
return result.geometries.reduce(
|
|
(sum, geometry) =>
|
|
sum +
|
|
Object.values(geometry.attributes).reduce(
|
|
(n, a) => n + (a?.values?.byteLength || 0),
|
|
0,
|
|
) +
|
|
geometry.indices.byteLength,
|
|
0,
|
|
);
|
|
};
|
|
const bytes = await pipelineBytes(1);
|
|
const bodyInstances = 2 * (TRAIL_VERTEX_LIMIT - 1);
|
|
const bodyBytes = await pipelineBytes(bodyInstances);
|
|
assert.equal(bytes, 1576, 'measure final encoded and batched geometry');
|
|
assert.equal(bodyBytes, 2014128);
|
|
const instanceReserve = 64 * bodyInstances;
|
|
assert.ok(bodyBytes + instanceReserve <= 2 * 1024 * 1024);
|
|
assert.ok(
|
|
bytes <= 2048,
|
|
'subdivision crossings stay below 2 KiB of head geometry',
|
|
);
|
|
console.log(
|
|
`trail final pipeline: ${bytes} bytes/head crossing, 0 bytes/ordinary head frame, ${bodyBytes} bytes/body (${bodyInstances} instances), ${instanceReserve} bytes instance reserve; geometry CPU ${(performance.now() - start).toFixed(3)} ms`,
|
|
);
|
|
});
|
|
|
|
test('supported scenes drape body and clipped head on 3D tiles and retain head geometry', (t) => {
|
|
const scene = fixture(t, true),
|
|
renderer = createContactTrailRenderer(scene);
|
|
const positions = [
|
|
Cesium.Cartesian3.fromDegrees(-97.7431, 30.267),
|
|
Cesium.Cartesian3.fromDegrees(-97.7431, 30.2672),
|
|
];
|
|
renderer.replaceHistory({
|
|
revision: 1,
|
|
segments: [{ fromSeq: 0, toSeq: 1, fromT: 0, toT: 20000, positions }],
|
|
});
|
|
const first = renderer.diagnostics();
|
|
assert.ok(first.body instanceof Cesium.GroundPolylinePrimitive);
|
|
assert.equal(first.body.classificationType, Cesium.ClassificationType.BOTH);
|
|
assert.ok(scene.groundPrimitives.contains(first.body));
|
|
for (const instance of first.body.geometryInstances)
|
|
assert.ok(instance.geometry instanceof Cesium.GroundPolylineGeometry);
|
|
for (let i = 1; i <= 120; i++)
|
|
renderer.setDisplaySample(
|
|
{ displayT: i * 100, fromSeq: 0, toSeq: 1, fraction: i / 200 },
|
|
positions[1],
|
|
);
|
|
const result = renderer.diagnostics();
|
|
assert.equal(result.body, first.body);
|
|
assert.equal(result.headRebuilds, 1);
|
|
assert.ok(result.headPrimitive instanceof Cesium.GroundPolylinePrimitive);
|
|
assert.equal(result.head.material.uniforms.fraction, 0.6);
|
|
assert.match(result.head.material.shaderSource, /discard/);
|
|
for (const stack of ['Google', 'OSM', 'Bing', 'Google']) {
|
|
scene.globe.show = stack !== 'Google';
|
|
renderer.setDisplaySample(
|
|
{ displayT: 12000, fromSeq: 0, toSeq: 1, fraction: 0.6 },
|
|
positions[1],
|
|
);
|
|
const retained = renderer.diagnostics();
|
|
assert.equal(retained.body, result.body, `${stack}: retained history`);
|
|
assert.equal(retained.headPrimitive, result.headPrimitive);
|
|
for (const primitive of [retained.body, retained.headPrimitive]) {
|
|
assert.equal(
|
|
primitive.classificationType,
|
|
Cesium.ClassificationType.BOTH,
|
|
stack,
|
|
);
|
|
assert.equal(primitive.show, true, stack);
|
|
}
|
|
}
|
|
renderer.setVisible(false);
|
|
assert.equal(result.body.show, false);
|
|
assert.equal(result.headPrimitive.show, false);
|
|
renderer.destroy();
|
|
assert.equal(scene.groundPrimitives.length, 0);
|
|
assert.equal(scene.primitives.length, 0);
|
|
});
|
|
|
|
test('subdivision crossings only write the changed show range and age colors once per second', (t) => {
|
|
const renderer = createContactTrailRenderer(fixture(t));
|
|
const positions = [
|
|
Cesium.Cartesian3.fromDegrees(-71, 42),
|
|
Cesium.Cartesian3.fromDegrees(-71, 42.001),
|
|
];
|
|
renderer.replaceHistory({
|
|
revision: 1,
|
|
segments: Array.from({ length: 100 }, (_, i) => ({
|
|
fromSeq: 0,
|
|
toSeq: 1,
|
|
fromT: i * 500,
|
|
toT: (i + 1) * 500,
|
|
positions,
|
|
})),
|
|
});
|
|
const { body } = renderer.diagnostics();
|
|
const counts = { show: 0, color: 0, depthFailColor: 0 };
|
|
const attributes = new Map(
|
|
body.geometryInstances.map((instance) => {
|
|
const result = {};
|
|
for (const name of Object.keys(counts)) {
|
|
let value = instance.attributes[name].value;
|
|
Object.defineProperty(result, name, {
|
|
get: () => value,
|
|
set(next) {
|
|
value = next;
|
|
counts[name]++;
|
|
},
|
|
});
|
|
}
|
|
return [instance.id, result];
|
|
}),
|
|
);
|
|
body._ready = true;
|
|
body.getGeometryInstanceAttributes = (id) => attributes.get(id);
|
|
const display = (displayT) =>
|
|
renderer.setDisplaySample(
|
|
{ displayT, fromSeq: 0, toSeq: 1, fraction: 0.1 },
|
|
positions[0],
|
|
);
|
|
const reset = () => {
|
|
for (const name of Object.keys(counts)) counts[name] = 0;
|
|
};
|
|
display(100);
|
|
assert.deepEqual(counts, { show: 0, color: 200, depthFailColor: 200 });
|
|
reset();
|
|
display(600);
|
|
assert.deepEqual(counts, { show: 2, color: 0, depthFailColor: 0 });
|
|
reset();
|
|
display(100);
|
|
assert.deepEqual(counts, { show: 2, color: 0, depthFailColor: 0 });
|
|
assert.ok(
|
|
[...attributes.values()].every((a) => a.show[0] === 0),
|
|
'backward seek hides the completed range',
|
|
);
|
|
reset();
|
|
display(1100);
|
|
assert.deepEqual(counts, { show: 4, color: 200, depthFailColor: 200 });
|
|
reset();
|
|
display(1200);
|
|
assert.deepEqual(counts, { show: 0, color: 0, depthFailColor: 0 });
|
|
renderer.setStyle('#FF4538');
|
|
display(1200);
|
|
assert.deepEqual(counts, { show: 0, color: 200, depthFailColor: 200 });
|
|
for (const a of attributes.values())
|
|
assert.deepEqual(
|
|
a.depthFailColor,
|
|
Cesium.ColorGeometryInstanceAttribute.toValue(
|
|
Cesium.Color.fromCssColorString('#FF4538').withAlpha(0.55),
|
|
),
|
|
);
|
|
});
|