Files
gods-eye-view/src/render/cesium/harness.js
T
Sameh Khamis 8b6bbf0f21 Give the Cesium draw port atlases and the clamp state
The shared Cesium ports gain draw.atlas, draw.clampState and
draw.on('clampState'), on both the conformance renderer and the
application's. An icon names an image by atlas slot; it draws once its atlas
holds the slot, and registering an atlas again rebuilds the icon sets that
read from it. A generated image with a key is one texture however many icons
draw it.

clampState is draped unless a shown 3D tileset is in the scene: the port
draws clamped items where it is given them and drapes nothing onto tiles yet,
so over tiles it says overlay. A change is told after the drawn frame that
shows it, never on subscribing.

A new draw.atlas check registers an atlas after its icons and picks them;
it and draw.clampState now run on Cesium.
2026-11-06 17:38:21 -08:00

139 lines
4.5 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.drillPick',
'draw.ids',
'draw.models',
'draw.pick',
'draw.sets',
'effects.crossfade',
'effects.defineStyle',
'effects.styles',
'effects.withoutStyles',
'frame.demand',
'frame.order',
'frame.prediction',
'frame.renderOnce',
'frame.suspend',
'frame.time',
'globe.sky',
'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.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(),
toEcef,
tolerance: DEFAULT_TOLERANCE,
flightPaths: 'endpoints',
...(model ? { assets: { model } } : {}),
};
}