mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-17 16:52:20 +00:00
The scenario counted every sampleHeight call in a task as the placer's pass, so a single sample from elsewhere in the app that landed in the same task pushed a full pass to 17. Calls that are neither a fixture point nor the one camera estimate are now counted apart.
687 lines
23 KiB
JavaScript
687 lines
23 KiB
JavaScript
import assert from 'node:assert/strict';
|
|
import { readFileSync } from 'node:fs';
|
|
import * as geo from '../src/geo/index.js';
|
|
import { GROUND_SURFACE_GLSL } from '../src/globe/navara/ground/surface.js';
|
|
import {
|
|
assertKeylessPreview,
|
|
createStrict,
|
|
localPreview,
|
|
openPage,
|
|
TILES_FIXTURE_PATH,
|
|
tilesFixtureRoutes,
|
|
waitForCameraAtRest,
|
|
waitForEngine,
|
|
} from './qa-strict-harness.mjs';
|
|
|
|
const base = localPreview(process.argv[2]);
|
|
const report = process.argv.includes('--report');
|
|
const { extras: fixture } = JSON.parse(
|
|
readFileSync(new URL('./fixtures/tiles3d/tileset.json', import.meta.url)),
|
|
);
|
|
base.search = `?engine=cesium&welcome=0&qaTileset=${encodeURIComponent(TILES_FIXTURE_PATH)}`;
|
|
base.hash = `v=2&lat=${fixture.origin.lat}&lon=${fixture.origin.lon}&alt=1100&heading=0&pitch=-90&roll=0&map=photoreal&l=`;
|
|
let releaseTiles;
|
|
let pendingTiles;
|
|
const holdTiles = () => {
|
|
pendingTiles = new Promise((resolve) => {
|
|
releaseTiles = resolve;
|
|
});
|
|
};
|
|
holdTiles();
|
|
const routes = tilesFixtureRoutes(base.origin).map((route) => ({
|
|
...route,
|
|
async respond(request) {
|
|
if (route.pattern.endsWith('.glb')) await pendingTiles;
|
|
return route.respond(request);
|
|
},
|
|
}));
|
|
routes.push({
|
|
pattern: `${base.origin}/api/overpass/status`,
|
|
respond: () => ({
|
|
contentType: 'application/json',
|
|
body: '{"configured":true}',
|
|
}),
|
|
});
|
|
const strict = createStrict({
|
|
origin: base.origin,
|
|
layers: ['osm-places'],
|
|
routes,
|
|
});
|
|
|
|
await strict.run({}, async (browser) => {
|
|
const { page, errors } = await openPage(browser, { shaderErrors: true });
|
|
await page.setCacheEnabled(false);
|
|
let readsBefore = { ...strict.ledger.routes };
|
|
await page.goto(base.href, { waitUntil: 'domcontentloaded' });
|
|
for (const kind of ['cesium', 'navara']) {
|
|
if (kind === 'navara') {
|
|
readsBefore = { ...strict.ledger.routes };
|
|
holdTiles();
|
|
await strict.pick(page, kind, { settle: false });
|
|
}
|
|
try {
|
|
await page.waitForFunction(
|
|
(kind) => {
|
|
const engine = window.__godsEyeView?.engine;
|
|
return (
|
|
engine?.kind === kind &&
|
|
engine.maps.photorealActive() &&
|
|
!engine.surface.tilesLoaded()
|
|
);
|
|
},
|
|
{ timeout: 90000 },
|
|
kind,
|
|
);
|
|
await strict.passed(
|
|
page,
|
|
'osm-places',
|
|
'tilesLoaded is false while GLBs are held',
|
|
);
|
|
} finally {
|
|
releaseTiles();
|
|
}
|
|
await waitForEngine(page, kind);
|
|
await page.evaluate(
|
|
async (destination) => {
|
|
const { engine, styleManager } = window.__godsEyeView;
|
|
styleManager.orbitController.stop();
|
|
engine.camera.cancelFlight();
|
|
await engine.maps.setTerrain({ kind: 'ellipsoid' });
|
|
engine.camera.setView({
|
|
destination,
|
|
orientation: { heading: 0, pitch: -Math.PI / 2, roll: 0 },
|
|
});
|
|
engine.render.request('qa-tiles-fixture');
|
|
},
|
|
geo.cartesian3.fromDegrees(fixture.origin.lon, fixture.origin.lat, 1100),
|
|
);
|
|
await loaded(page);
|
|
await waitForCameraAtRest(page);
|
|
if (!report)
|
|
for (const route of routes.slice(0, 5))
|
|
assert.ok(
|
|
strict.ledger.routes[route.pattern] >
|
|
(readsBefore[route.pattern] ?? 0),
|
|
`${kind} intercepted ${new URL(route.pattern).pathname}`,
|
|
);
|
|
await strict.passed(
|
|
page,
|
|
'osm-places',
|
|
report
|
|
? 'fixture tiles ready for measurement'
|
|
: 'tilesLoaded becomes true; all five files served by same-origin routes',
|
|
);
|
|
|
|
const readings = await page.evaluate(
|
|
({ probes, clampStarts }) => {
|
|
const { surface } = window.__godsEyeView.engine;
|
|
return Object.fromEntries(
|
|
Object.entries(probes).map(([id, p]) => [
|
|
id,
|
|
{
|
|
sampled: surface.sampleHeight(p.cartographic),
|
|
clamped: surface.clampToHeight(clampStarts[id]),
|
|
},
|
|
]),
|
|
);
|
|
},
|
|
{
|
|
probes: fixture.probes,
|
|
clampStarts: Object.fromEntries(
|
|
Object.entries(fixture.probes).map(([id, p]) => [
|
|
id,
|
|
geo.cartesian3.fromDegrees(p.lon, p.lat, p.height + 300),
|
|
]),
|
|
),
|
|
},
|
|
);
|
|
const heights = Object.fromEntries(
|
|
Object.entries(readings).map(([id, reading]) => {
|
|
const p = fixture.probes[id];
|
|
return [
|
|
id,
|
|
{
|
|
expectedHeightM: p.height,
|
|
sampledHeightM: reading.sampled ?? null,
|
|
clampedHeightM: reading.clamped
|
|
? geo.cartographic.fromCartesian(reading.clamped).height
|
|
: null,
|
|
clampDistanceM: reading.clamped
|
|
? geo.cartesian3.distance(reading.clamped, p.position)
|
|
: null,
|
|
},
|
|
];
|
|
}),
|
|
);
|
|
console.log(
|
|
`${report ? 'REPORT' : 'HEIGHTS'} ${kind} ${JSON.stringify(heights)}`,
|
|
);
|
|
if (kind === 'navara')
|
|
console.log(
|
|
'NOTE navara: the default 3D Tiles height offset is a known package limitation; the adapter sets model.height=0 (height tolerance ±0.5 m).',
|
|
);
|
|
if (!report) {
|
|
for (const [id, p] of Object.entries(heights)) {
|
|
assert.ok(
|
|
Number.isFinite(p.sampledHeightM) &&
|
|
Math.abs(p.sampledHeightM - p.expectedHeightM) <= 0.5,
|
|
`${kind} ${id}: ${JSON.stringify(p)}`,
|
|
);
|
|
assert.ok(
|
|
Number.isFinite(p.clampDistanceM) && p.clampDistanceM <= 0.5,
|
|
`${kind} ${id} clamp: ${JSON.stringify(p)}`,
|
|
);
|
|
}
|
|
assert.ok(
|
|
Math.abs(
|
|
heights.block50.sampledHeightM - heights.plate.sampledHeightM - 50,
|
|
) <= 0.5,
|
|
);
|
|
await strict.passed(
|
|
page,
|
|
'osm-places',
|
|
'known plate, 50 m, 200 m and sloping roof heights; clamps land on each surface',
|
|
heights,
|
|
);
|
|
}
|
|
|
|
const drapes = [];
|
|
for (const surface of ['tiles', 'terrain']) {
|
|
if (surface === 'terrain') {
|
|
await page.evaluate(async () => {
|
|
const { engine, mapStackController } = window.__godsEyeView;
|
|
await mapStackController.setStack('osm');
|
|
await engine.maps.setTerrain({ kind: 'ellipsoid' });
|
|
});
|
|
await loaded(page);
|
|
await waitForCameraAtRest(page);
|
|
}
|
|
const p = fixture.probes.block50;
|
|
const position = geo.cartesian3.fromDegrees(
|
|
p.lon,
|
|
p.lat,
|
|
surface === 'tiles' ? p.height : 0,
|
|
);
|
|
for (const drape of ['tiles', 'terrain']) {
|
|
await page.evaluate(
|
|
({ lon, lat, drape }) => {
|
|
const { engine } = window.__godsEyeView;
|
|
const set = engine.ground.createSet({
|
|
id: 'qa-drape',
|
|
kind: 'cell',
|
|
drape,
|
|
pickable: false,
|
|
});
|
|
set.replace([
|
|
{
|
|
west: lon - 0.0003,
|
|
east: lon + 0.0003,
|
|
south: lat - 0.0003,
|
|
north: lat + 0.0003,
|
|
fill: [1, 0, 1, 1],
|
|
},
|
|
]);
|
|
set.commit();
|
|
window.qaDrape = set;
|
|
},
|
|
{ ...p, drape },
|
|
);
|
|
try {
|
|
await page.waitForFunction(
|
|
() => {
|
|
window.__godsEyeView.engine.render.request('qa-drape');
|
|
return window.qaDrape.ready();
|
|
},
|
|
{ timeout: 30000 },
|
|
);
|
|
// Build first, then compare the same ready primitive hidden/shown.
|
|
// Map imagery and classification shaders may still be arriving before ready.
|
|
await page.evaluate(() => window.qaDrape.show(false));
|
|
await loaded(page);
|
|
const before = await pixels(page, position);
|
|
await page.evaluate(() => window.qaDrape.show(true));
|
|
const shown = await pixels(page, position);
|
|
await page.evaluate(() => window.qaDrape.show(false));
|
|
const after = await pixels(page, position);
|
|
const baseline = before.rgb;
|
|
const rgb = shown.rgb;
|
|
const restored = after.rgb;
|
|
const drawn = rgb[0] > 180 && rgb[1] < 80 && rgb[2] > 180;
|
|
const sample = { surface, drape, baseline, rgb, restored, drawn };
|
|
if (report && kind === 'navara')
|
|
sample.depths = {
|
|
baseline: before.depths,
|
|
shown: shown.depths,
|
|
restored: after.depths,
|
|
};
|
|
drapes.push(sample);
|
|
console.log(
|
|
`${report ? 'REPORT' : 'DRAPE'} ${kind} ${JSON.stringify(sample)}`,
|
|
);
|
|
if (!report) {
|
|
assert.ok(
|
|
!(baseline[0] > 180 && baseline[1] < 80 && baseline[2] > 180),
|
|
`${kind} hidden drape is already magenta: ${JSON.stringify(sample)}`,
|
|
);
|
|
assert.ok(
|
|
baseline.every((v, i) => Math.abs(v - restored[i]) < 15),
|
|
`${kind} unstable drape baseline: ${JSON.stringify(sample)}`,
|
|
);
|
|
assert.equal(
|
|
drawn,
|
|
surface === drape,
|
|
`${kind} ${drape} on ${surface}: ${JSON.stringify(sample)}`,
|
|
);
|
|
if (surface !== drape)
|
|
assert.ok(
|
|
rgb.every((v, i) => Math.abs(v - baseline[i]) < 15),
|
|
`${kind} ${drape} on ${surface} changes the other surface: ${JSON.stringify(sample)}`,
|
|
);
|
|
}
|
|
} finally {
|
|
await page.evaluate(() => {
|
|
window.qaDrape.destroy();
|
|
delete window.qaDrape;
|
|
});
|
|
}
|
|
}
|
|
}
|
|
await strict.passed(
|
|
page,
|
|
'osm-places',
|
|
report
|
|
? 'diagnostic height and drape measurements collected; values not asserted'
|
|
: 'drape tiles and terrain draw only on their respective surface (pixels)',
|
|
{ heights, drapes },
|
|
);
|
|
await page.evaluate(() =>
|
|
window.__godsEyeView.mapStackController.setStack('photoreal'),
|
|
);
|
|
await loaded(page);
|
|
await waitForCameraAtRest(page);
|
|
if (!report) await checkPoints(page, kind);
|
|
await assertKeylessPreview(page);
|
|
console.log(
|
|
report
|
|
? `REPORT ${kind} complete (measurements only)`
|
|
: `PASS ${kind} fixture heights, clamp, drapes, tilesLoaded and surface-points budget`,
|
|
);
|
|
}
|
|
if (report) console.log(`REPORT browser errors ${JSON.stringify(errors)}`);
|
|
else assert.deepEqual(errors, []);
|
|
// No Google tiles, credits or Cesium ion; the page's web fonts (allowed by
|
|
// the map policy) come from Google's font hosts on every run.
|
|
assert.deepEqual(
|
|
Object.keys(strict.ledger.external).filter(
|
|
(host) =>
|
|
/google|gstatic|cesium\.com/i.test(host) &&
|
|
!/^fonts\.(googleapis|gstatic)\.com$/i.test(host),
|
|
),
|
|
[],
|
|
);
|
|
});
|
|
|
|
async function loaded(page) {
|
|
await page.waitForFunction(
|
|
() => {
|
|
const { engine } = window.__godsEyeView;
|
|
engine.render.request('qa-tiles-fixture');
|
|
return engine.surface.tilesLoaded();
|
|
},
|
|
{ polling: 100, timeout: 90000 },
|
|
);
|
|
}
|
|
|
|
// Read actual canvas pixels during postRender; Cesium discards them afterwards.
|
|
async function pixels(page, position) {
|
|
const input = {
|
|
position,
|
|
diagnostic: report ? readNavaraDrape.toString() : null,
|
|
classification: GROUND_SURFACE_GLSL,
|
|
};
|
|
const sample = await page.evaluate(async (input) => {
|
|
const { position, diagnostic, classification } = input;
|
|
const { engine } = window.__godsEyeView;
|
|
const readDepths =
|
|
diagnostic && engine.kind === 'navara'
|
|
? new Function(`return (${diagnostic})`)()
|
|
: null;
|
|
let depths;
|
|
const canvas = document.createElement('canvas');
|
|
canvas.width = canvas.height = 5;
|
|
const context = canvas.getContext('2d', { willReadFrequently: true });
|
|
for (let frame = 0; frame < 2; frame++)
|
|
await new Promise((resolve, reject) => {
|
|
const off = engine.frames.postRender.addEventListener(() => {
|
|
off();
|
|
const point = engine.projector.worldToWindow(position);
|
|
const scale = engine.host.canvas.width / engine.host.size().width;
|
|
context.clearRect(0, 0, 5, 5);
|
|
context.drawImage(
|
|
engine.host.canvas,
|
|
Math.round(point.x * scale) - 2,
|
|
Math.round(point.y * scale) - 2,
|
|
5,
|
|
5,
|
|
0,
|
|
0,
|
|
5,
|
|
5,
|
|
);
|
|
try {
|
|
if (readDepths)
|
|
depths = readDepths(engine, point, classification);
|
|
} catch (error) {
|
|
reject(error);
|
|
return;
|
|
}
|
|
resolve();
|
|
});
|
|
engine.render.request('qa-drape-pixels');
|
|
});
|
|
const data = context.getImageData(0, 0, 5, 5).data;
|
|
const rgb = [0, 1, 2].map(
|
|
(channel) =>
|
|
data.reduce(
|
|
(sum, value, i) => sum + (i % 4 === channel ? value : 0),
|
|
0,
|
|
) / 25,
|
|
);
|
|
return { rgb, depths };
|
|
}, input);
|
|
if (sample.depths) {
|
|
const place =
|
|
sample.depths.position &&
|
|
geo.cartographic.fromCartesian(sample.depths.position);
|
|
const detail =
|
|
place &&
|
|
(await page.evaluate(
|
|
(place) =>
|
|
window.__godsEyeView.engine.surface.sampleHeightDetailed(place),
|
|
place,
|
|
));
|
|
sample.depths.source = detail?.source ?? null;
|
|
sample.depths.height = detail?.height ?? null;
|
|
}
|
|
return sample;
|
|
}
|
|
|
|
// Runs in the page, after rendering. Read the centre of the same 5x5 colour
|
|
// sample, using the ground effect's actual uniforms and shader when shown.
|
|
function readNavaraDrape(engine, point, classification) {
|
|
const view = engine.extensions.navara.view;
|
|
const ctx = view.viewContext;
|
|
const renderer = ctx.getRenderer();
|
|
const mrt = ctx.findEffect('mrt');
|
|
const effect = ctx.findEffect('gevGround')?.effect;
|
|
const names = ['tAllDepth', 'tSurfaceDepth', 'tGlobeDepth'];
|
|
const textures = effect
|
|
? names.map((name) => effect.uniforms.get(name).value)
|
|
: [
|
|
mrt.depthBuffer,
|
|
ctx.getRenderTarget().depthTexture,
|
|
mrt.globeDepthBuffer,
|
|
];
|
|
if (effect)
|
|
classification = effect
|
|
.getFragmentShader()
|
|
.match(/float groundSurfaceType\([\s\S]*?\n}/)?.[0];
|
|
if (!classification) throw new Error('Missing ground classification shader');
|
|
const scale = engine.host.canvas.width / engine.host.size().width;
|
|
const canvasPixel = [
|
|
Math.round(point.x * scale),
|
|
Math.round(point.y * scale),
|
|
];
|
|
const size = textures[0].image;
|
|
const pixel = [
|
|
Math.floor(
|
|
((canvasPixel[0] + 0.5) * size.width) / engine.host.canvas.width,
|
|
),
|
|
Math.floor(
|
|
((engine.host.canvas.height - canvasPixel[1] - 0.5) * size.height) /
|
|
engine.host.canvas.height,
|
|
),
|
|
];
|
|
// Use the installed SDK's depth-copy pass and Three packing. Four RGBA8
|
|
// pixels preserve the three depths and the shader's classification result.
|
|
const copy = new mrt.raw.globeDepthCopyPass.constructor();
|
|
const previous = renderer.getRenderTarget();
|
|
try {
|
|
copy.setSize(4, 1);
|
|
const material = copy.fullscreenMaterial;
|
|
material.uniforms = Object.fromEntries(
|
|
names.map((name, i) => [name, { value: textures[i] }]),
|
|
);
|
|
material.uniforms.pixel = { value: pixel };
|
|
material.fragmentShader = `
|
|
#include <packing>
|
|
uniform sampler2D tAllDepth;
|
|
uniform sampler2D tSurfaceDepth;
|
|
uniform sampler2D tGlobeDepth;
|
|
uniform ivec2 pixel;
|
|
${classification}
|
|
void main() {
|
|
float depth = unpackRGBAToDepth(texelFetch(tAllDepth, pixel, 0));
|
|
float surface = texelFetch(tSurfaceDepth, pixel, 0).r;
|
|
float globe = unpackRGBAToDepth(texelFetch(tGlobeDepth, pixel, 0));
|
|
int column = int(gl_FragCoord.x);
|
|
gl_FragColor = column == 3
|
|
? vec4(groundSurfaceType(depth, surface, globe) / 255.0, 0.0, 0.0, 1.0)
|
|
: packDepthToRGBA(column == 0 ? depth : column == 1 ? surface : globe);
|
|
}
|
|
`;
|
|
copy.render(renderer);
|
|
const bytes = new Uint8Array(16);
|
|
renderer.readRenderTargetPixels(copy.renderTarget, 0, 0, 4, 1, bytes);
|
|
const gl = renderer.getContext();
|
|
const error = gl.getError();
|
|
if (error !== gl.NO_ERROR)
|
|
throw new Error(`Depth diagnostic WebGL error: ${error}`);
|
|
const unpack = (offset) =>
|
|
bytes[offset] / 256 +
|
|
bytes[offset + 1] / 65536 +
|
|
bytes[offset + 2] / 16777216 +
|
|
bytes[offset + 3] / (255 * 16777216);
|
|
const screen = {
|
|
x: (canvasPixel[0] + 0.5) / scale,
|
|
y: (canvasPixel[1] + 0.5) / scale,
|
|
};
|
|
const ray = engine.camera.pickRay(screen);
|
|
const hit = engine.surface.raycast({ ...ray, far: view.camera.raw.far });
|
|
return {
|
|
pixel,
|
|
bindings: effect ? 'ground' : 'mrt',
|
|
allDepth: unpack(0),
|
|
sceneDepth: unpack(4),
|
|
globeDepth: unpack(8),
|
|
classification: ['none', 'terrain', 'tiles'][bytes[12]],
|
|
buffer: ['none', 'globe', 'scene'][bytes[12]],
|
|
position: hit?.position ?? engine.camera.pickEllipsoid(screen),
|
|
shownTileAtRay: Boolean(hit),
|
|
photorealActive: engine.maps.photorealActive(),
|
|
textures: textures.map((texture) => ({
|
|
id: texture.id,
|
|
width: texture.image.width,
|
|
height: texture.image.height,
|
|
})),
|
|
};
|
|
} finally {
|
|
renderer.setRenderTarget(previous);
|
|
copy.dispose();
|
|
}
|
|
}
|
|
|
|
async function checkPoints(page, kind) {
|
|
await page.evaluate(async (points) => {
|
|
const { engine, viewer, dataManager } = window.__godsEyeView;
|
|
const layer = dataManager.layers.get('osm-places').module;
|
|
layer.setResults([], null);
|
|
await dataManager.setEnabled('osm-places', true);
|
|
// Reattach this real layer once so its mover commits can be observed.
|
|
layer.detachRenderer();
|
|
const createSet = engine.movers.createSet;
|
|
const sampleHeight = engine.surface.sampleHeight;
|
|
const target =
|
|
engine.kind === 'cesium'
|
|
? viewer.scene._picking._pickOffscreenView.pickFramebuffer
|
|
: engine.extensions.navara.view._renderer;
|
|
const method = engine.kind === 'cesium' ? 'begin' : 'render';
|
|
const render = target[method];
|
|
if (typeof render !== 'function')
|
|
throw new Error('Missing pick-render counter hook');
|
|
const stats = (window.qaPoints = {
|
|
passes: [],
|
|
positions: [],
|
|
samples: 0,
|
|
renders: 0,
|
|
});
|
|
let pass = null,
|
|
passStart = 0,
|
|
sampling = false;
|
|
target[method] = function (...args) {
|
|
if (sampling) {
|
|
pass.renders++;
|
|
stats.renders++;
|
|
}
|
|
return render.apply(this, args);
|
|
};
|
|
engine.surface.sampleHeight = function (...args) {
|
|
if (!pass) {
|
|
passStart = performance.now();
|
|
pass = {
|
|
samples: 0,
|
|
renders: 0,
|
|
ms: 0,
|
|
startsMs: [],
|
|
cameraEstimate: !points.some(
|
|
(p) =>
|
|
Math.abs(p.cartographic.longitude - args[0].longitude) < 1e-10 &&
|
|
Math.abs(p.cartographic.latitude - args[0].latitude) < 1e-10,
|
|
),
|
|
};
|
|
stats.passes.push(pass);
|
|
// A placement callback samples synchronously, without yielding.
|
|
queueMicrotask(() => {
|
|
pass = null;
|
|
});
|
|
}
|
|
// Only the placer's samples count against its budget: the fixture's
|
|
// points and one estimate of the ground under the camera. Other code
|
|
// that samples in the same task is counted apart.
|
|
const isPoint = points.some(
|
|
(p) =>
|
|
Math.abs(p.cartographic.longitude - args[0].longitude) < 1e-10 &&
|
|
Math.abs(p.cartographic.latitude - args[0].latitude) < 1e-10,
|
|
);
|
|
if (!isPoint && pass.estimated) {
|
|
pass.other = (pass.other ?? 0) + 1;
|
|
return sampleHeight.apply(this, args);
|
|
}
|
|
if (!isPoint) pass.estimated = true;
|
|
pass.samples++;
|
|
stats.samples++;
|
|
const start = performance.now();
|
|
pass.startsMs.push(start - passStart);
|
|
sampling = true;
|
|
try {
|
|
return sampleHeight.apply(this, args);
|
|
} finally {
|
|
sampling = false;
|
|
pass.ms += performance.now() - start;
|
|
}
|
|
};
|
|
engine.movers.createSet = function (options) {
|
|
const set = createSet.call(this, options);
|
|
if (options.id !== 'osm-places') return set;
|
|
const write = set.set,
|
|
commit = set.commit;
|
|
const positions = [];
|
|
set.set = function (index, fields) {
|
|
if (fields.position) positions[index] = { ...fields.position };
|
|
return write.call(this, index, fields);
|
|
};
|
|
set.commit = function () {
|
|
const result = commit.call(this);
|
|
stats.positions = positions.map((p) => ({ ...p }));
|
|
return result;
|
|
};
|
|
return set;
|
|
};
|
|
window.qaRestorePoints = () => {
|
|
engine.surface.sampleHeight = sampleHeight;
|
|
engine.movers.createSet = createSet;
|
|
target[method] = render;
|
|
};
|
|
layer.attachRenderer({ engine });
|
|
layer.setResults(
|
|
points.map((p, i) => ({ id: String(i), lon: p.lon, lat: p.lat })),
|
|
{ kind: 'fixture', label: 'Roof points', area: 'Austin' },
|
|
);
|
|
}, fixture.points);
|
|
try {
|
|
const expected = fixture.points.map((p) =>
|
|
geo.cartesian3.fromDegrees(p.lon, p.lat, p.height + 2),
|
|
);
|
|
await page.waitForFunction(
|
|
(expected) => {
|
|
const positions = window.qaPoints.positions;
|
|
return (
|
|
positions.length === expected.length &&
|
|
positions.every(
|
|
(p, i) =>
|
|
Math.hypot(
|
|
p.x - expected[i].x,
|
|
p.y - expected[i].y,
|
|
p.z - expected[i].z,
|
|
) <= 0.5,
|
|
)
|
|
);
|
|
},
|
|
{ polling: 100, timeout: 30000 },
|
|
expected,
|
|
);
|
|
const result = await page.evaluate(() => ({
|
|
...window.qaPoints,
|
|
drawn: window.__godsEyeView.engine.movers
|
|
.list()
|
|
.find((s) => s.id === 'osm-places'),
|
|
}));
|
|
assert.equal(result.drawn.count, fixture.points.length);
|
|
assert.equal(result.drawn.shown, true);
|
|
assert.ok(
|
|
result.samples >= fixture.points.length && result.passes.length > 1,
|
|
);
|
|
assert.ok(
|
|
result.passes.every((p) => p.samples <= 16 && p.renders <= 16),
|
|
JSON.stringify(result.passes),
|
|
);
|
|
// The 4 ms limit is checked between points: one expensive sample (and
|
|
// its initial camera estimate) may finish after the deadline.
|
|
assert.ok(
|
|
result.passes.every((p) =>
|
|
p.startsMs.slice(p.cameraEstimate ? 2 : 1).every((ms) => ms < 4),
|
|
),
|
|
JSON.stringify(result.passes),
|
|
);
|
|
if (kind === 'cesium')
|
|
assert.ok(
|
|
result.renders >= fixture.points.length,
|
|
'count actual offscreen pick renders',
|
|
);
|
|
else assert.equal(result.renders, 0, 'tile sampling uses CPU rays');
|
|
await strict.passed(
|
|
page,
|
|
'osm-places',
|
|
'40 roof points committed at surface + 2 m; 16 samples/pick renders and 4 ms soft budget per pass',
|
|
result,
|
|
);
|
|
} finally {
|
|
await page.evaluate(async () => {
|
|
window.qaRestorePoints();
|
|
const { dataManager } = window.__godsEyeView;
|
|
await dataManager.setEnabled('osm-places', false);
|
|
dataManager.layers.get('osm-places').module.setResults([], null);
|
|
});
|
|
}
|
|
}
|