Files
gods-eye-view/src/render/cesium/harness.js
T
Sameh Khamis 10dcab837b Drape glow and dash lines, reveal lines by length, and move draped lines and clamped points every frame
The Cesium draw port now drapes glow and dash lines as well as solid and
flow ones, each with its own ground primitive.

revealFraction is the fraction of the line's length, measured along the
line. Both renderers cut there: Cesium discards fragments past the cut in
the line's material, so the hidden part neither draws nor picks; the stub
cuts the line before drawing and picking.

A draped line whose positions change is rebuilt the same frame, on a ground
primitive of its own, once terrain heights are loaded; until then it is
rebuilt as before. A clamped dot whose look is unchanged is moved in place.

The stub now picks lines. A new shared conformance check, draw.lines.drape,
covers draped glow and dash lines, the reveal cut, a draped line growing
every frame, and a clamped point moving every frame.
2026-11-07 06:52:46 -08:00

159 lines
5.0 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
/**
* @module render/cesium/harness
* @description The Cesium renderer as the conformance suite's renderer under
* test, in the `/dev/conformance/` page.
*
* `CESIUM_CHECKS` lists the checks of the ports the Cesium renderer has.
* Each migration adds the checks of the members it brings, so the suite
* shows how far the renderer is through the contract; every other check is
* left out of the run rather than failed. Camera flights are checked in
* Node instead (`cameraPort.test.mjs`): a page's frames come on the real
* clock at the display's rate, where the reference traces step 1/60 s.
*/
import { DEFAULT_TOLERANCE } from '../conformance/index.js';
import { toEcef } from '../stub/math.js';
import { createCesiumSceneRenderer, pointerFeedOf } from './sceneRenderer.js';
/** @type {ReadonlySet<string>} */
export const CESIUM_CHECKS = new Set([
'camera.trace.setView angles',
'camera.trace.setView keeps the position when only orientation is given',
'camera.trace.lookAt sweep and release',
'camera.trace.move, look, rotate and zoom',
'camera.trace.commands inside a lookAt frame',
'camera.trace.changed fires by each listener’s threshold',
'camera.moveEnd',
'camera.controls.holds',
'camera.controls.settings',
'camera.follow',
'camera.trace.flyTo with a duration of 0 completes inside the call',
'camera.trace.flyTo where the camera already is completes inside the call',
'camera.viewRectangle',
'camera.fov',
'camera.trace.view and projection matrices',
'credits',
'credits.listenerRules',
'draw.atlas',
'draw.clampState',
'draw.columns',
'draw.columns.shown',
'draw.drillPick',
'draw.icons.distance',
'draw.icons.update',
'draw.lines.styles',
'draw.lines.drape',
'draw.ids',
'draw.models',
'draw.motion',
'draw.motion.arc',
'draw.motion.climb',
'draw.motion.live',
'draw.motion.shared',
'draw.pick',
'draw.points.update',
'draw.lodGroup',
'draw.sets',
'effects.crossfade',
'effects.defineStyle',
'effects.styles',
'effects.withoutStyles',
'frame.demand',
'frame.order',
'frame.prediction',
'frame.renderOnce',
'frame.suspend',
'frame.time',
'globe.imagery',
'globe.sky',
'globe.split',
'globe.withoutImageHooks',
'input.behaviours',
'input.clickPick',
'input.lease',
'input.lease.grab',
'input.lease.press',
'query.heights',
'query.heights.sets',
'query.projectMany',
'query.rays',
'query.withoutCapability',
'quality',
'quality.signals',
'renderer.listeners',
'renderer.readPixels',
'renderer.releaseUnused',
'renderer.whenSettled',
]);
/** A frame fails the check rather than hang it when frames stop. */
const FRAME_TIMEOUT_MS = 5000;
/**
* One frame of the page: it resolves once the render loop's tick for the
* next animation frame (drawn or not, or none while suspended) has run, so
* loads and timers progress between frames. Cesium's loop asks for its
* animation frame before this does, so its tick runs first. It asks for no
* render itself: a check's own `requestRender` is what makes a tick draw.
*/
function nextFrame() {
return new Promise((resolve, reject) => {
const timer = setTimeout(
() => reject(new Error('no animation frame came')),
FRAME_TIMEOUT_MS,
);
requestAnimationFrame(() => {
clearTimeout(timer);
setTimeout(resolve, 0);
});
});
}
/**
* @param {{name?: string, model?: string}} [options] `model`: a glTF URL
* for the model checks.
* @returns {import('../conformance/index.js').ConformanceHarness}
*/
export function createCesiumHarness({ name = 'cesium', model } = {}) {
return {
name,
async create({ viewport, capabilities }) {
const container = document.createElement('div');
container.style.cssText = `position:fixed;left:0;top:0;width:${viewport.width}px;height:${viewport.height}px`;
document.body.append(container);
let renderer;
try {
renderer = await createCesiumSceneRenderer({ container, capabilities });
} catch (error) {
container.remove();
throw error;
}
const destroy = renderer.destroy;
const { canvas } = renderer;
renderer.destroy = () => {
try {
destroy();
} finally {
// Free the context now: a full run makes more widgets than the
// browser keeps contexts for.
(canvas.getContext('webgl2') ?? canvas.getContext('webgl'))
?.getExtension('WEBGL_lose_context')
?.loseContext();
container.remove();
}
};
return renderer;
},
frame: nextFrame,
// Events as the renderer's handler delivers them: the checks send ones
// no real pointer can (a click with no press), so not DOM events.
pointer: (r, type, x, y, extra) => pointerFeedOf(r)(type, x, y, extra),
now: () => performance.now(),
// What a live motion clock reads.
wallTime: () => Date.now(),
toEcef,
tolerance: DEFAULT_TOLERANCE,
flightPaths: 'endpoints',
...(model ? { assets: { model } } : {}),
};
}