Files
gods-eye-view/scripts/qa-tiles-fixture.test.mjs
T
German Khokhlov 02ad2d045a Compare the 3D Tiles fixture's numbers within floating-point tolerance
The tileset's transform and probe points come from trigonometry whose last
bits differ between arm64 and x64, so a fixture written on one failed the
byte comparison on the other. The numbers now match to 1e-12 of their size;
the meshes and the served files are still compared byte for byte.
2026-11-11 15:55:12 +04:00

626 lines
21 KiB
JavaScript

import test from 'node:test';
import assert from 'node:assert/strict';
import { readFileSync } from 'node:fs';
import { Cesium3DTileset } from 'cesium';
import { Core, initSync } from '@navaramap/engine';
import { GLTFLoader } from 'three/addons/loaders/GLTFLoader.js';
import { Group, Raycaster, Vector3 } from 'three';
import { DepthCopyPass } from 'postprocessing';
import * as geo from '../src/geo/index.js';
import { buildTilesFixture } from './build-tiles3d-fixture.mjs';
import { localTilesetPath, qaTilesetUrl } from '../src/maps/qaTileset.js';
import { createDefaultMapSources } from '../src/maps/defaultSources.js';
import { MapSourceController } from '../src/maps/controller.js';
import { createFakeEngine } from '../src/globe/testing/fakeEngine.js';
import { createNavaraMaps } from '../src/globe/navara/maps.js';
import { createNavaraSurface } from '../src/globe/navara/surface.js';
import { GROUND_SURFACE_GLSL } from '../src/globe/navara/ground/surface.js';
import {
assertKeylessPreview,
TILES_FIXTURE_PATH,
tilesFixtureRoutes,
} from './qa-strict-harness.mjs';
function globals(t, values) {
for (const [name, value] of Object.entries(values)) {
const old = Object.getOwnPropertyDescriptor(globalThis, name);
Object.defineProperty(globalThis, name, {
configurable: true,
writable: true,
value,
});
t.after(() => {
if (old) Object.defineProperty(globalThis, name, old);
else delete globalThis[name];
});
}
}
const committedFixture = (name) =>
readFileSync(new URL(`./fixtures/tiles3d/${name}`, import.meta.url));
// The tileset's numbers come from trigonometry whose last bits differ
// between CPUs (the fixture was written on arm64, CI runs x64), so they
// match to 1e-12 of their size; the meshes are exact.
function assertClose(actual, expected, path) {
if (typeof expected === 'number') {
assert.equal(typeof actual, 'number', path);
assert.ok(
Math.abs(actual - expected) <=
1e-12 * Math.max(1, Math.abs(actual), Math.abs(expected)),
`${path}: ${actual} != ${expected}`,
);
} else if (expected && typeof expected === 'object') {
assert.deepEqual(Object.keys(actual).sort(), Object.keys(expected).sort());
for (const key of Object.keys(expected))
assertClose(actual[key], expected[key], `${path}.${key}`);
} else assert.equal(actual, expected, path);
}
test('fixture is reproducible, self-contained and under 200 KB', () => {
const files = buildTilesFixture();
assert.equal(files.size, 5);
assert.ok(
[...files.values()].reduce((sum, bytes) => sum + bytes.length, 0) < 200_000,
);
for (const [name, bytes] of files)
if (name.endsWith('.json'))
assertClose(JSON.parse(committedFixture(name)), JSON.parse(bytes), name);
else assert.deepEqual(committedFixture(name), bytes);
const tileset = JSON.parse(files.get('tileset.json'));
for (const child of tileset.root.children)
assert.ok(files.has(child.content.uri));
assert.equal(tileset.extras.points.length, 40);
});
test('independent glTF loader and triangle rays recover the authored heights', async () => {
const files = buildTilesFixture();
const probes = [
['plate', 0, -170, 0],
['block50', -160, 0, 50],
['block200', 0, 170, 200],
['roof', 180, 0, 84],
['roof', 140, 30, 84],
['roof', 160, 0, 100],
];
for (const [name, east, north, height] of probes) {
const bytes = files.get(`${name}.glb`);
const gltf = await new GLTFLoader().parseAsync(
bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength),
'',
);
gltf.scene.updateMatrixWorld(true);
const ray = new Raycaster(
new Vector3(east, 1000, -north),
new Vector3(0, -1, 0),
);
const hits = ray.intersectObject(gltf.scene, true);
assert.ok(hits.length, name);
assert.ok(
Math.abs(hits[0].point.y - height) < 1e-5,
`${name}: ${hits[0].point.y}`,
);
}
});
// Exercise the installed WASM tile loader, then the same glTF transforms
// consumed by Three's renderModel/setTransform path, without WebGL or fetch.
async function loadedNavaraTiles(t, adapter) {
initSync({
module: readFileSync(
new URL(
'../node_modules/@navaramap/engine/navara_wasm_bg.wasm',
import.meta.url,
),
),
});
const files = buildTilesFixture();
const fixture = JSON.parse(files.get('tileset.json'));
const core = new Core('tiles-fixture');
t.after(() => core.free());
core.resize(1280, 800, 1);
core.setFrustum(60, 1, 1e8);
core.start();
core.changeCamera(
new Float64Array([
fixture.extras.origin.lon,
fixture.extras.origin.lat,
1100,
]),
-90,
0,
0,
);
const view = {
addSource: (desc) => {
const id = core.addSource(desc);
return { id, delete: () => core.deleteSource(id) };
},
addLayer: (desc) => {
const id = core.addLayer({ ...desc, source: desc.source.id });
return { id, delete: () => core.deleteLayer(id) };
},
forceUpdate() {},
};
if (adapter) {
globals(t, { location: new URL('http://localhost:4303') });
const owner = createNavaraMaps(view, {
setInterval: () => 1,
clearInterval() {},
});
await owner.maps.setPhotorealTiles({ tilesetUrl: TILES_FIXTURE_PATH });
} else {
const source = view.addSource({
type: '3d-tiles',
url: 'http://localhost:4303/tileset.json',
});
view.addLayer({ type: '3d-tiles', source, model: { maxSse: 16 } });
}
const roots = [];
for (let frame = 0; frame < 60 && roots.length < 4; frame++) {
core.update(frame * 16);
const events = core.readEvents();
if (!events) continue;
for (const request of events.take_data_requested()) {
const bytes = files.get(new URL(request.url).pathname.split('/').at(-1));
assert.ok(bytes, `unexpected fixture request: ${request.url}`);
core.setBufferU8(request.handle, request.bits, bytes.length, (buffer) =>
buffer.set(bytes),
);
}
for (const event of events.take_renderable_feature_added()) {
const model = event.feature.model;
if (!model) continue;
const bytes = core.getBufferU8(model.bin).slice();
const gltf = await new GLTFLoader().parseAsync(bytes.buffer, '');
const root = new Group();
const m = model.transform;
root.position.set(m.tx, m.ty, m.tz);
root.quaternion.set(m.qx, m.qy, m.qz, m.qw);
root.scale.set(m.sx, m.sy, m.sz);
root.add(gltf.scene);
root.updateMatrixWorld(true);
roots.push(root);
core.markFeatureIsRendered('model', event.bits);
}
}
assert.equal(roots.length, 4, 'all four real tile contents loaded');
const { surface } = createNavaraSurface(
{ sampleTerrainHeight: () => undefined },
{ tileRoots: () => roots, isIdle: () => true, retainTileGeometry() {} },
);
t.after(() => {
for (const root of roots)
root.traverse((object) => {
object.geometry?.dispose();
object.material?.dispose();
});
});
return { fixture, roots, surface };
}
test('Navara default tile height shifts the rendered transform by one ECEF metre', async (t) => {
const { fixture, roots, surface } = await loadedNavaraTiles(t, false);
for (const root of roots) {
assert.equal(root.position.x, fixture.root.transform[12] - 1);
assert.equal(root.position.y, fixture.root.transform[13]);
assert.equal(root.position.z, fixture.root.transform[14]);
}
for (const [id, expected] of Object.entries({
plate: 0.11864,
block50: 50.11837,
block200: 200.11864,
roof: 83.32621,
}))
assert.ok(
Math.abs(
surface.sampleHeight(fixture.extras.probes[id].cartographic) - expected,
) < 0.001,
id,
);
});
test('Navara map source preserves authored rendered vertices, sampled heights and clamps', async (t) => {
const { fixture, roots, surface } = await loadedNavaraTiles(t, true);
for (const root of roots)
assert.deepEqual(
root.position.toArray(),
fixture.root.transform.slice(12, 15),
);
for (const p of [
...Object.values(fixture.extras.probes),
...fixture.extras.points,
]) {
const normal = geo.ellipsoid.WGS84.geodeticSurfaceNormalCartographic(
p.cartographic,
{},
);
const origin = geo.cartesian3.fromDegrees(p.lon, p.lat, p.height + 300);
const ray = new Raycaster(
new Vector3(origin.x, origin.y, origin.z),
new Vector3(-normal.x, -normal.y, -normal.z),
);
const hit = ray.intersectObjects(roots, true)[0];
assert.ok(hit, 'rendered mesh is under the authored probe');
assert.ok(geo.cartesian3.distance(hit.point, p.position) < 1e-6);
assert.ok(Math.abs(surface.sampleHeight(p.cartographic) - p.height) < 1e-6);
assert.ok(
geo.cartesian3.distance(surface.clampToHeight(origin), p.position) < 1e-6,
);
}
});
test('QA URL switch is inert by default and rejects nonlocal or malformed paths', (t) => {
const location = new URL('http://localhost:4303/');
globals(t, { location });
assert.equal(qaTilesetUrl(), null);
assert.equal(createDefaultMapSources().defaultId, 'esri-imagery');
location.searchParams.set('qaTileset', TILES_FIXTURE_PATH);
assert.equal(qaTilesetUrl(), TILES_FIXTURE_PATH);
for (const value of [
'https://example.com/tileset.json',
'http://localhost:4303/tileset.json',
'//example.com/x',
'/\\example.com/x',
'relative.json',
'/x\n',
'/x?key=test',
'/x#fragment',
]) {
assert.throws(() => localTilesetPath(value), /page origin/);
for (const engineKind of ['cesium', 'navara'])
assert.throws(
() => createDefaultMapSources({ engineKind, tilesetUrl: value }),
/page origin/,
);
}
});
test('controller passes local URL to Navara and owns the Cesium factory result', async (t) => {
globals(t, { location: new URL('http://localhost:4303/') });
const tileset = { url: TILES_FIXTURE_PATH, show: true, destroy: t.mock.fn() };
const factory = t.mock.method(
Cesium3DTileset,
'fromUrl',
async () => tileset,
);
for (const engineKind of ['navara', 'cesium']) {
const registry = createDefaultMapSources({
engineKind,
tilesetUrl: TILES_FIXTURE_PATH,
});
const engine = createFakeEngine({ kind: engineKind });
const controller = new MapSourceController({ registry, engine });
await controller.setStack('photoreal');
const source = engine.maps.current().photoreal;
assert.equal(source.tilesetUrl, TILES_FIXTURE_PATH);
assert.equal(source.tileset, engineKind === 'cesium' ? tileset : undefined);
assert.equal(factory.mock.callCount(), engineKind === 'cesium' ? 1 : 0);
controller.destroy();
engine.destroy();
}
assert.equal(factory.mock.calls[0].arguments[0], TILES_FIXTURE_PATH);
assert.equal(tileset.destroy.mock.callCount(), 1);
});
test('Navara accepts the local 3D source without a key or Google credit, and rejects remote paths', async (t) => {
globals(t, { location: new URL('http://localhost:4303/') });
const sources = [],
credits = [];
const view = {
addSource: (desc) => {
sources.push(desc);
return { delete() {} };
},
addLayer: () => ({ id: 'fixture', delete() {} }),
forceUpdate() {},
attribution: {
add: (items) => credits.push(...items),
remove() {},
show: t.mock.fn(),
},
};
const owner = createNavaraMaps(view, {
setInterval: () => 1,
clearInterval() {},
});
t.after(owner.destroy);
await owner.maps.setPhotorealTiles({ tilesetUrl: TILES_FIXTURE_PATH });
assert.deepEqual(sources, [
{ type: '3d-tiles', url: `http://localhost:4303${TILES_FIXTURE_PATH}` },
]);
assert.equal(owner.maps.photorealActive(), true);
assert.deepEqual(credits, []);
assert.equal(view.attribution.show.mock.callCount(), 0);
await assert.rejects(
owner.maps.setPhotorealTiles({
tilesetUrl: '//example.com/tileset.json',
googleApiKey: 'unused',
}),
/page origin/,
);
assert.equal(sources.length, 1);
await owner.maps.setPhotorealTiles(null);
assert.equal(owner.maps.photorealActive(), false);
});
test('strict keyless assertion permits only the opted-in fixture and its real tileset URL', async (t) => {
const location = new URL(
`http://localhost:4303/?qaTileset=${encodeURIComponent(TILES_FIXTURE_PATH)}`,
);
const source = {
tilesetUrl: TILES_FIXTURE_PATH,
tileset: { resource: { url: TILES_FIXTURE_PATH } },
};
const app = {
engine: {
maps: {
current: () => ({ photoreal: source }),
photorealActive: () => true,
},
},
};
const window = { __godsEyeView: app };
globals(t, { window, location });
const page = { evaluate: async (fn, ...args) => fn(...args) };
await assertKeylessPreview(page);
source.tileset.resource.url = 'https://example.com/tileset.json';
await assert.rejects(assertKeylessPreview(page), /Keyless/);
source.tileset.resource.url = TILES_FIXTURE_PATH;
location.search = '';
await assert.rejects(assertKeylessPreview(page), /Keyless/);
location.searchParams.set('qaTileset', TILES_FIXTURE_PATH);
source.tilesetUrl = '/another/tileset.json';
await assert.rejects(assertKeylessPreview(page), /Keyless/);
source.tilesetUrl = TILES_FIXTURE_PATH;
window.__GOOGLE_MAPS_API_KEY__ = 'key';
await assert.rejects(assertKeylessPreview(page), /Keyless/);
delete window.__GOOGLE_MAPS_API_KEY__;
app.tileset = { url: '/another/tileset.json' };
await assert.rejects(assertKeylessPreview(page), /Keyless/);
});
test('harness exposes exactly the five binary-safe fixture routes on the preview origin', () => {
const routes = tilesFixtureRoutes('http://localhost:4303');
assert.equal(routes.length, 5);
const names = new Set();
for (const route of routes) {
const url = new URL(route.pattern);
assert.equal(url.origin, 'http://localhost:4303');
assert.ok(!route.pattern.includes('*'));
const answer = route.respond();
const name = url.pathname.split('/').at(-1);
names.add(name);
assert.deepEqual(answer.body, committedFixture(name));
assert.equal(
answer.contentType,
url.pathname.endsWith('.glb') ? 'model/gltf-binary' : 'application/json',
);
}
assert.deepEqual([...names].sort(), [...buildTilesFixture().keys()].sort());
});
// Load only the page callbacks, without launching the command-line scenario.
const scenario = readFileSync(
new URL('./qa-tiles-fixture.mjs', import.meta.url),
'utf8',
);
const diagnosticSource = scenario.slice(
scenario.indexOf('function readNavaraDrape('),
scenario.indexOf('async function checkPoints('),
);
const readNavaraDrape = new Function(`return (${diagnosticSource})`)();
const pixelsSource = scenario.slice(
scenario.indexOf('async function pixels('),
scenario.indexOf('// Runs in the page, after rendering.'),
);
const reportPixels = new Function(
'geo',
'report',
'readNavaraDrape',
'GROUND_SURFACE_GLSL',
`return (${pixelsSource})`,
)(geo, true, readNavaraDrape, GROUND_SURFACE_GLSL);
function depthDiagnostic(t) {
const copies = [];
class Copy extends DepthCopyPass {
constructor() {
super();
this.disposed = false;
this.renderTarget.addEventListener('dispose', () => {
this.disposed = true;
});
copies.push(this);
}
}
const bytes = new Uint8Array(16);
// Exact RGBA depths: 0.25 composed, 0.25 scene, 0.5 globe; tile classification.
bytes.set([64, 0, 0, 0, 64, 0, 0, 0, 128, 0, 0, 0, 2, 0, 0, 255]);
let error = 0;
const gl = { NO_ERROR: 0, getError: () => error };
const textures = Array.from({ length: 3 }, (_, id) => ({
id,
image: { width: 1280, height: 800 },
}));
const previous = {};
const renderer = {
getContext: () => gl,
getRenderTarget: () => previous,
render: t.mock.fn(),
readRenderTargetPixels: (_, x, y, width, height, buffer) =>
buffer.set(bytes),
setRenderTarget: t.mock.fn(),
};
let effect = {
uniforms: new Map(
['tAllDepth', 'tSurfaceDepth', 'tGlobeDepth'].map((name, i) => [
name,
{ value: textures[i] },
]),
),
getFragmentShader: () => GROUND_SURFACE_GLSL,
};
const ctx = {
getRenderer: () => renderer,
findEffect: (key) =>
key === 'gevGround'
? { effect }
: {
depthBuffer: textures[0],
globeDepthBuffer: textures[2],
raw: { globeDepthCopyPass: { constructor: Copy } },
},
getRenderTarget: () => ({ depthTexture: textures[1] }),
};
let tiles = true;
const position = geo.cartesian3.fromDegrees(-97.7, 30.2, 50);
let listener;
const engine = {
kind: 'navara',
extensions: {
navara: { view: { viewContext: ctx, camera: { raw: { far: 1e8 } } } },
},
host: {
canvas: { width: 2560, height: 1600 },
size: () => ({ width: 1280, height: 800 }),
},
projector: { worldToWindow: () => ({ x: 120, y: 70 }) },
camera: {
pickRay: t.mock.fn(() => ({
origin: { x: 1, y: 2, z: 3 },
direction: { x: 0, y: 0, z: -1 },
})),
pickEllipsoid: () => position,
},
surface: {
raycast: t.mock.fn(() => (tiles ? { position } : undefined)),
sampleHeightDetailed: t.mock.fn(() => ({
height: tiles ? 50 : 0,
source: tiles ? 'tiles' : 'terrain',
})),
},
maps: { photorealActive: () => tiles },
frames: {
postRender: {
addEventListener: (fn) => {
listener = fn;
return () => {};
},
},
},
render: { request: () => queueMicrotask(() => listener()) },
};
const color = Uint8ClampedArray.from(
{ length: 100 },
(_, i) => [231, 226, 223, 255][i % 4],
);
globals(t, {
window: { __godsEyeView: { engine } },
document: {
createElement: () => ({
getContext: () => ({
clearRect() {},
drawImage() {},
getImageData: () => ({ data: color }),
}),
}),
},
});
return {
engine,
copies,
renderer,
previous,
position,
textures,
page: { evaluate: async (fn, ...args) => fn(...args) },
hideGround() {
effect = null;
},
removeTiles() {
tiles = false;
bytes.set([128, 0, 0, 0, 255, 255, 255, 255, 128, 0, 0, 0, 1, 0, 0, 255]);
},
fail() {
error = 'INVALID_OPERATION';
},
};
}
test('drape report distinguishes depths and shown tile rays when colour is identical', async (t) => {
const h = depthDiagnostic(t);
const shown = await reportPixels(h.page, h.position);
assert.deepEqual(shown.rgb, [231, 226, 223]);
assert.equal(shown.depths.allDepth, 0.25);
assert.equal(shown.depths.sceneDepth, 0.25);
assert.equal(shown.depths.globeDepth, 0.5);
assert.equal(shown.depths.buffer, 'scene');
assert.equal(shown.depths.classification, 'tiles');
assert.equal(shown.depths.source, 'tiles');
assert.equal(shown.depths.shownTileAtRay, true);
assert.equal(shown.depths.bindings, 'ground');
assert.deepEqual(shown.depths.pixel, [120, 729]);
assert.deepEqual(h.engine.camera.pickRay.mock.calls[0].arguments[0], {
x: 120.25,
y: 70.25,
});
assert.equal(h.engine.surface.raycast.mock.calls[0].arguments[0].far, 1e8);
const place =
h.engine.surface.sampleHeightDetailed.mock.calls[0].arguments[0];
assert.ok(Math.abs(place.longitude - geo.math.toRadians(-97.7)) < 1e-10);
assert.ok(Math.abs(place.latitude - geo.math.toRadians(30.2)) < 1e-10);
h.hideGround();
h.removeTiles();
const hidden = await reportPixels(h.page, h.position);
assert.deepEqual(hidden.rgb, shown.rgb);
assert.equal(hidden.depths.allDepth, 0.5);
assert.equal(hidden.depths.sceneDepth, 1);
assert.equal(hidden.depths.globeDepth, 0.5);
assert.equal(hidden.depths.buffer, 'globe');
assert.equal(hidden.depths.classification, 'terrain');
assert.equal(hidden.depths.source, 'terrain');
assert.equal(hidden.depths.shownTileAtRay, false);
assert.equal(hidden.depths.photorealActive, false);
assert.equal(hidden.depths.bindings, 'mrt');
assert.equal(h.copies.length, 4);
assert.ok(h.copies.every((copy) => copy.disposed));
assert.equal(
h.copies[0].fullscreenMaterial.uniforms.tGlobeDepth.value,
h.textures[2],
);
assert.equal(
h.renderer.setRenderTarget.mock.calls.at(-1).arguments[0],
h.previous,
);
});
test('drape report rejects a failed GPU read and releases temporary resources', async (t) => {
const h = depthDiagnostic(t);
h.fail();
await assert.rejects(
reportPixels(h.page, h.position),
/WebGL error: INVALID_OPERATION/,
);
assert.equal(h.copies.length, 1);
assert.ok(h.copies[0].disposed);
assert.equal(
h.renderer.setRenderTarget.mock.calls.at(-1).arguments[0],
h.previous,
);
});
test('drape report never reads native Navara state on Cesium', async (t) => {
const h = depthDiagnostic(t);
h.engine.kind = 'cesium';
Object.defineProperty(h.engine, 'extensions', {
get() {
throw new Error('Native read');
},
});
const sample = await reportPixels(h.page, h.position);
assert.deepEqual(sample.rgb, [231, 226, 223]);
assert.equal(sample.depths, undefined);
assert.equal(h.copies.length, 0);
});