Files
gods-eye-view/src/render/cesium/ports.js
T
Sameh Khamis e9085e8df3 feat(render): the Cesium renderer passes every conformance check a page can run
- Cesium's own tweens (its flights) step on the renderer's clock, so the
  flight traces compare frame by frame; dispose gives the scene its own
  clock back.
- moveStart and moveEnd are measured each tick on that clock, by the
  shared move detection, a change of the field of view or aspect
  included; Cesium's own events timed them by the system clock.
- A follow of a drawn item tracks where the draw port draws it.
- Pick rays are summed from the eye's axes: Cesium's lose about 1e-9 of
  direction at a near plane of 0.1 m. Ellipsoid picks and the view
  rectangle use them; a canvas with no size has none, as in Cesium.
- The harness always runs the virtual clock and claims 120 checks: 119
  pass on the page and query.heights skips. The five pointer traces
  need a camera controller there, and are recorded from Cesium's own
  controller in Node.
- The package boundaries list the cesium plugin export and the modules
  its groups now import.
2026-11-12 14:59:45 -08:00

769 lines
27 KiB
JavaScript

/**
* @module render/cesium/ports
* @description The Cesium renderer's contract ports, built over a Cesium
* widget or viewer someone else made and configured: frame phases, the
* globe, the draw sets, `setView` and the pose, picks and projection,
* credits, quality and capture.
* Building them puts the loop on demand (no holds yet, and no redraws for
* scene time alone); nothing else in the scene changes until a call.
*
* The conformance renderer (`sceneRenderer.js`) and the application's
* renderer (`appRenderer.js`) both use them, so what conformance
* checks is what the application runs. Members a port does not have are
* absent, never stubbed.
*/
import * as Cesium from 'cesium';
import { createCesiumCamera } from './camera.js';
import { createControlledCamera } from './controlledCamera.js';
import { listenerList, toCartesian, uncaught } from './common.js';
import { createCesiumCredits } from './credits.js';
import { createCesiumDraw } from './draw.js';
import { GPU_ICON_CAPABILITIES } from './gpuIcons.js';
import { createCesiumEffects } from './effects.js';
import { renderNow, willDraw } from './frame.js';
import { createCesiumGlobe } from './globe.js';
import { createCesiumQuery, queryCapabilities } from './query.js';
import { createCesiumQuality, gpuTimerOf } from './quality.js';
import { screenModulationSupported } from './screenModulation.js';
import {
atEndOfTick,
billboardLoadError,
onEngineWorkCompleted,
renderPending,
trimGlobeTiles,
webglContext,
} from './internals.js';
export { listenerList, toCartesian };
export { toColor, toImage } from './draw.js';
/**
* What every Cesium globe does: photoreal tiles, terrain, imagery draped on
* tiles, the split and main-thread tile hooks.
*/
const GLOBE_CAPABILITIES = [
'photoreal',
'terrain',
'imageryOnTiles',
'splitSwipe',
'imageHooks',
// Timed imagery: a layer a frame, prefetched unseen (`imagery.js`).
'imageryFrames',
'surfaceIdentity',
'surfaceShading',
// A MapLibre style's vector tiles, painted as imagery (`vectorBase.js`).
'vectorBase',
'globeVisibility',
];
/**
* What a Cesium scene can do, as contract capabilities; `only` limits them
* to those it lists. Depth picks, height samples and ray casts all need
* depth textures, which `sampleHeightSupported` and `pickPositionSupported`
* report. Styles, bloom and sharpen are post-process stages every scene
* runs; the screen modulation runs on the Cesium version it was tested
* against.
* @param {object} scene
* @param {Iterable<string>} [only]
* @returns {string[]}
*/
export function cesiumCapabilities(scene, only) {
const all = [
'models',
// Cesium scatters drawn models through the atmosphere wherever the
// scene draws fog (its models' atmosphere stage).
'modelAtmosphere',
'quads',
'meshes',
// Raster shells; other field kinds are refused.
'fields',
'followFrame',
// Cesium's AUTODETECT tracking frame (`follow.js`).
'followAutodetect',
'cameraChangeThreshold',
// The zoom-out guard reads the scene's own controller and frame events.
...(scene?.screenSpaceCameraController && scene?.preRender
? ['keepEarthFramed']
: []),
...GPU_ICON_CAPABILITIES,
// Icon sets cluster on screen, on billboards and the GPU (`draw.js`).
'cluster',
'styles',
'bloom',
'sharpen',
// The marker sweep's command swap is tested against one Cesium version.
...(screenModulationSupported() ? ['screenModulation'] : []),
...GLOBE_CAPABILITIES,
...queryCapabilities(scene),
// Frame timing on the GPU, where the context has timer queries.
...(gpuTimerOf(webglContext(scene)) ? ['gpuTiming'] : []),
];
const allowed = only && new Set(only);
return all.filter(
(c) =>
(!allowed || allowed.has(c)) &&
// Visibility reads back only from a globe that keeps it: a scene
// made without one gives no reading.
(c !== 'globeVisibility' || typeof scene?.globe?.show === 'boolean'),
);
}
/**
* @param {object} widget A Cesium `CesiumWidget` or `Viewer`.
* @param {{capabilities: ReadonlySet<string>, credentials?: object,
* cameraController?: Function, now?: () => number}} options
* The renderer's capabilities, which gate the members that need them, and
* the credentials its globe loads photoreal tiles and world data with
* (`googleApiKey`, `googleTokens`, `worldDataToken`). `now` is the clock
* each tick reads (`performance.now` by default; a test's virtual one).
* With
* `cameraController`, the camera port is that controller's over Cesium's
* camera (`controlledCamera.js`); the ports then have `attachInput` and
* `suspendCamera`, which the renderer's input port is wired with.
*/
export function createCesiumPorts(
widget,
{
capabilities,
credentials = {},
cameraController,
now: clockNow = () => performance.now(),
},
) {
const scene = widget.scene;
const camera = scene.camera;
// Cesium's own tweens (its flights) step on the same clock as the ticks:
// a scene's tweens read the system clock unless given a time.
const tweens = scene.tweens;
const updateTweens = tweens?.update;
const clockedTweens = (time) =>
updateTweens.call(tweens, time ?? clockNow() / 1000);
if (updateTweens) tweens.update = clockedTweens;
// An error listener's own throw is uncaught, never reported again.
const rendererListeners = {
error: listenerList(uncaught),
contextLost: listenerList(report),
contextRestored: listenerList(report),
};
/** Hands a listener's throw to the renderer's `error` listeners. */
function report(error) {
if (rendererListeners.error.size === 0) uncaught(error);
else rendererListeners.error.fire(error);
}
// Cesium cannot bring a lost context back, so it never sends
// `contextRestored`.
const contextLost = () => rendererListeners.contextLost.fire();
scene.canvas?.addEventListener?.('webglcontextlost', contextLost);
const frameListeners = {
preUpdate: listenerList(report),
preRender: listenerList(report),
postRender: listenerList(report),
};
let frames = 0;
let rendered = 0;
// Every tick raises preUpdate, drawn or not; the phases of a tick share
// its clock reading. The first tick counts from when the loop was made.
let tickNow = clockNow();
let dt = 0;
// The preUpdate FrameTime of the tick under way: its `rendering` reads
// live until the tick has drawn or not, then holds that answer.
let liveTick = null;
// The time Cesium stamps the frame in `preUpdate` with, while it runs.
let stampTime = null;
const settleTick = (drawn) => {
if (liveTick)
Object.defineProperty(liveTick, 'rendering', {
value: drawn,
enumerable: true,
});
liveTick = null;
};
const tick = () => {
settleTick(false);
// A tick that does not draw settles at its end; one that does, at
// preRender, before this runs.
atEndOfTick(scene, () => void settleTick(false));
const now = clockNow();
dt = (now - tickNow) / 1000;
tickNow = now;
frames += 1;
};
const onPhase = (phase) => (_scene, time) => {
if (frameListeners[phase].size === 0) return;
const t = {
frame: frames,
time: Cesium.JulianDate.toDate(
time ?? widget.clock.currentTime,
).getTime(),
now: tickNow,
dt,
rendering: true,
};
// At preUpdate, Cesium has not decided yet: this applies its test when
// read, so it counts what earlier listeners did (a camera move, a
// request, a hold) but not what later ones will.
if (phase === 'preUpdate') {
Object.defineProperty(t, 'rendering', {
enumerable: true,
configurable: true,
get: () => willDraw(scene, time),
});
liveTick = t;
stampTime = time ?? null;
}
try {
frameListeners[phase].fire(t);
} finally {
stampTime = null;
}
};
// Reasons given before a frame starts drawing are answered by it; one
// given while it draws waits for the next, as Cesium's own request does.
const pendingReasons = [];
let answering = 0;
const drawing = () => {
settleTick(true);
answering = pendingReasons.length;
};
const drew = () => {
rendered += 1;
pendingReasons.splice(0, answering);
answering = 0;
};
let disposed = false;
// The camera controller's steps, around the preUpdate listeners
// (`cameraController` only).
let controlled = null;
const cameraTick = (time) => ({
now: tickNow,
time: Cesium.JulianDate.toDate(time ?? widget.clock.currentTime).getTime(),
});
const removers = [
scene.preUpdate.addEventListener(tick),
scene.preUpdate.addEventListener(
(_scene, time) => void controlled?.before(cameraTick(time)),
),
scene.preUpdate.addEventListener(onPhase('preUpdate')),
scene.preUpdate.addEventListener(
(_scene, time) => void controlled?.after(cameraTick(time)),
),
scene.preRender.addEventListener(drawing),
scene.preRender.addEventListener(onPhase('preRender')),
scene.postRender.addEventListener(drew),
scene.postRender.addEventListener(onPhase('postRender')),
scene.preRender.addEventListener(() => drawPart.beforeRender()),
scene.postRender.addEventListener(() => drawPart.afterRender()),
scene.postRender.addEventListener(() => trimGlobeAfterDraw()),
];
// Holds keep the loop drawing every frame; counted per reason.
const holds = new Map();
function applyHolds() {
const continuous = holds.size > 0;
if (scene.requestRenderMode === !continuous) return;
scene.requestRenderMode = !continuous;
}
// On demand means drawn when asked, held or the view changed: never
// because scene time moved on by itself. With no holds yet, it starts so.
scene.maximumRenderTimeChange = Infinity;
scene.requestRenderMode = true;
let suspended = false;
let targetFps = widget.targetFrameRate > 0 ? widget.targetFrameRate : 0;
// Pending one-shot renders; disposal settles them rather than leave them
// attached to a scene that will not render again.
const pendingRenders = new Set();
/** Resolves after the next drawn frame; rejects after `timeoutMs`, if given. */
function nextPostRender({ timeoutMs } = {}) {
if (disposed) return Promise.resolve();
return new Promise((resolve, reject) => {
let timer;
const settle = (error) => {
off();
clearTimeout(timer);
pendingRenders.delete(done);
if (error) reject(error);
else resolve();
};
const done = () => settle();
const off = scene.postRender.addEventListener(done);
pendingRenders.add(done);
if (timeoutMs !== undefined)
timer = setTimeout(
() => settle(new Error('renderOnce timed out')),
timeoutMs,
);
scene.requestRender();
});
}
const frame = {
on(phase, cb) {
const list = frameListeners[phase];
if (!list) throw new TypeError(`Unknown frame phase: ${phase}`);
return list.on(cb);
},
requestRender(reason = 'unspecified') {
// During a draw the reasons it answers are spoken for: a reason given
// again waits for the next frame.
if (!pendingReasons.includes(reason, answering))
pendingReasons.push(reason);
scene.requestRender();
},
holdContinuous(reason) {
holds.set(reason, (holds.get(reason) ?? 0) + 1);
applyHolds();
let released = false;
return () => {
if (released) return;
released = true;
const left = holds.get(reason) - 1;
if (left > 0) holds.set(reason, left);
else holds.delete(reason);
applyHolds();
// What changed in the last held frame still gets drawn.
if (holds.size === 0) scene.requestRender();
};
},
/** Cesium can idle, so it draws on demand. */
mode: () => 'demand',
diagnostics: () => ({
mode: 'demand',
frames,
rendered,
pendingReasons: [...pendingReasons],
holds: [...holds].flatMap(([reason, n]) => Array(n).fill(reason)),
suspended,
targetFps,
}),
suspend(hidden) {
if (Boolean(hidden) === suspended) return;
suspended = Boolean(hidden);
// The loop's queued callback sees the flag and stops without a tick.
// The latch stays as Cesium keeps it: a resume before that callback
// runs keeps the one loop rather than start a second.
widget.useDefaultRenderLoop = !suspended;
if (!suspended) scene.requestRender();
},
// Draws even when nothing asked for a frame; throws when it fails.
renderNow: () => renderNow(scene, widget.clock.currentTime),
renderOnce: (options) => nextPostRender(options),
setTargetFps(fps) {
targetFps = fps > 0 ? fps : 0;
widget.targetFrameRate = targetFps || undefined;
},
/**
* Moves the clock to `ms` and draws it; in `preUpdate`, the frame under
* way draws at it. Whether the clock then runs on
* is its owner's: the application's clock keeps running if it was (a
* clock on Cesium's real-time step moves to its multiplier step, as
* setting its time does in Cesium).
*/
setTime(ms) {
const clock = widget.clock;
const time = Cesium.JulianDate.fromDate(new Date(ms));
const changed = !Cesium.JulianDate.equals(clock.currentTime, time);
clock.currentTime = time;
// In `preUpdate` the frame under way draws at it: Cesium stamps the
// frame with this object next.
if (stampTime) {
Cesium.JulianDate.clone(time, stampTime);
// Later preUpdate listeners read the frame's time from the tick.
if (liveTick) liveTick.time = ms;
} else if (changed) frame.requestRender('time');
},
time: () => Cesium.JulianDate.toDate(widget.clock.currentTime).getTime(),
};
// --- Draw ------------------------------------------------------------------
const drawPart = createCesiumDraw({
scene,
report,
capabilities,
requestRender: (reason) => frame.requestRender(reason),
});
const { port: draw, sets, tilesets } = drawPart;
// --- Query -----------------------------------------------------------------
const query = createCesiumQuery({
scene,
camera,
draw: drawPart,
capabilities,
});
if (cameraController)
controlled = createControlledCamera({
scene,
controller: cameraController,
query: {
...(capabilities.has('pickPosition')
? { pickPosition: (x, y) => query.pickPosition(x, y) }
: {}),
...(typeof query.sampleHeightNow === 'function'
? { sampleHeightNow: (p, o) => query.sampleHeightNow(p, o) }
: {}),
},
// Where the draw port draws an item, at the scene clock's time.
...(capabilities.has('motionSegments')
? {
itemPosition: (item, aheadMs) =>
drawPart.drawnPosition(item, aheadMs, widget.clock.currentTime),
}
: {}),
requestRender: (reason) => frame.requestRender(reason),
report,
thresholds: capabilities.has('cameraChangeThreshold'),
followFrame: capabilities.has('followFrame'),
});
const cameraPart = controlled
? { port: controlled.port, dispose: () => controlled.dispose() }
: createCesiumCamera({
scene,
camera,
report,
widget,
capabilities,
now: clockNow,
...(capabilities.has('motionSegments')
? {
itemPosition: (item, time) =>
drawPart.drawnPosition(item, 0, time),
}
: {}),
});
const cameraPort = cameraPart.port;
const effectsPart = createCesiumEffects(scene, {
capabilities,
frame,
report,
});
const qualityPart = createCesiumQuality(widget, {
frame,
report,
tickStarted: () => tickNow,
gl: capabilities.has('gpuTiming') ? webglContext(scene) : null,
});
const creditsPart = createCesiumCredits({
display: widget.creditDisplay,
scene,
report,
requestRender: () => frame.requestRender('credits'),
});
const globePart = createCesiumGlobe(widget, {
capabilities,
requestRender: (reason) => frame.requestRender(reason),
report,
credits: creditsPart.port,
credentials,
});
async function capture({ type = 'png' } = {}) {
scene.render(widget.clock.currentTime);
return new Promise((resolve) =>
scene.canvas.toBlob(resolve, `image/${type}`),
);
}
// The 2D canvas frames are read through, made on the first read.
let reader = null;
/**
* The drawn frame's pixels, `crop` in CSS pixels and `scale` relative to
* the canvas's CSS size. Read straight off the canvas: the application
* and conformance widgets keep their drawing buffers, and a read right
* after a draw sees it either way.
*/
function readPixels({ crop, scale = 1 } = {}) {
const canvas = scene.canvas;
const cssWidth = canvas.clientWidth || canvas.width;
const cssHeight = canvas.clientHeight || canvas.height;
const rect = crop ?? { x: 0, y: 0, width: cssWidth, height: cssHeight };
const width = Math.max(1, Math.round(rect.width * scale));
const height = Math.max(1, Math.round(rect.height * scale));
const made =
reader ??
document
.createElement('canvas')
.getContext('2d', { willReadFrequently: true });
// Disposed ports keep nothing to free.
if (!disposed) reader = made;
made.canvas.width = width;
made.canvas.height = height;
// A canvas with no size has drawn nothing: the read is blank.
if (!canvas.width || !canvas.height)
return made.getImageData(0, 0, width, height);
const sx = canvas.width / cssWidth;
const sy = canvas.height / cssHeight;
made.drawImage(
canvas,
rect.x * sx,
rect.y * sy,
rect.width * sx,
rect.height * sy,
0,
0,
width,
height,
);
return made.getImageData(0, 0, width, height);
}
// A release asked for whose globe trim waits for the next drawn frame.
let trimGlobe = false;
/**
* Frees the tiles the last frame did not draw: each 3D tileset trims its
* cache, and a shown globe its own after the next drawn frame. The reader
* pixels are read through goes too.
*/
function releaseUnused() {
if (disposed) return;
for (const tileset of tilesets()) tileset.trimLoadedTiles();
if (scene.globe?.show) trimGlobe = true;
if (reader) {
reader.canvas.width = reader.canvas.height = 0;
reader = null;
}
frame.requestRender('releaseUnused');
}
function trimGlobeAfterDraw() {
if (!trimGlobe) return;
trimGlobe = false;
if (scene.globe?.show) trimGlobeTiles(scene.globe);
}
/** The live model sets, for `whenSettled`. */
const modelSets = () =>
[...sets.values()].filter((r) => r.kind === 'models' && r.host);
/**
* The shown icons' images, for `whenSettled`: `failed` when one could not
* load, `loading` while one still is, otherwise `settled`.
*/
function iconState() {
let loading = false;
for (const record of sets.values()) {
// GPU icons read their images from the shared icon atlas.
if (record.gpu) {
if (!record.host?.show) continue;
const state = record.gpu.imageState();
if (state === 'failed') return 'failed';
if (state === 'loading') loading = true;
continue;
}
const host = record.kind === 'icons' && record.host;
if (!host || !host.show) continue;
for (let i = 0; i < host.length; i++) {
const billboard = host.get(i);
if (!billboard.show || billboard.ready) continue;
if (billboardLoadError(billboard)) return 'failed';
loading = true;
}
}
return loading ? 'loading' : 'settled';
}
/** A hidden globe loads nothing, so it is never what is still loading. */
const globeLoaded = () =>
!scene.globe?.show || scene.globe.tilesLoaded !== false;
/** Whether every shown 3D tileset has loaded what is in view. */
const tilesLoaded = () =>
tilesets().every((tileset) => !tileset.show || tileset.tilesLoaded);
// --- Settling --------------------------------------------------------------
// Idle watches in progress; disposal ends them rather than leave them
// waiting on a scene that will not tick again.
const watching = new Set();
/** How long the loop must stay idle, drawing nothing, to be settled. */
const IDLE_MS = 100;
/** How long without a tick a loop counts as stopped. */
const STALL_MS = 250;
/**
* Watches the loop, without asking for frames, for at least two whole
* ticks and `IDLE_MS`. Resolves `'idle'` if in that time it drew nothing
* of its own accord and `busy()` stayed false; `'busy'` as soon as it did;
* `'ended'` if the ports are disposed or `end` passes first. A draw while
* a hold keeps the loop drawing every frame is the hold's, not the
* scene's own; `busy` is asked at each tick's start, before Cesium decides
* whether it draws.
* @param {number} end
* @param {() => boolean} busy Whether work landed that will draw again.
*/
function watchIdle(end, busy) {
return new Promise((resolve) => {
const from = performance.now();
let ticks = 0;
const offDraw = scene.postRender.addEventListener(() => {
if (scene.requestRenderMode) finish('busy');
});
// Each preUpdate also ends the tick before it.
const offTick = scene.preUpdate.addEventListener(() => {
if (busy()) return finish('busy');
ticks += 1;
if (ticks > 2 && performance.now() - from >= IDLE_MS) finish('idle');
});
const timer = setTimeout(
() => finish('ended'),
Math.max(0, end - performance.now()),
);
watching.add(finish);
function finish(outcome) {
watching.delete(finish);
offDraw();
offTick();
clearTimeout(timer);
resolve(outcome);
}
});
}
async function whenSettled({ timeoutMs = 20000 } = {}) {
const end = performance.now() + timeoutMs;
// Cesium redraws on its own after each request or worker task it
// completes (a terrain picker build after the camera moved, say), which
// no loading flag shows; settled means that has stopped too. Every
// scene in the page redraws for any completion, so another scene's work
// keeps this one from settling: it is drawing.
let completed = 0;
// Whether the last look found the engine still at work.
let busy = false;
// When the loop last ticked: one that stopped (suspended, say) is named
// in a timeout, not one that merely ran out of time mid-frame.
let lastTick = performance.now();
const offTick = scene.preUpdate.addEventListener(
() => (lastTick = performance.now()),
);
const off = onEngineWorkCompleted(Cesium, () => (completed += 1));
try {
let quiet = 0;
while (performance.now() < end) {
completed = 0;
if (disposed) return { state: 'failed', blockers: ['destroyed'] };
// Bounded by the time left: a suspended loop draws nothing.
const drawn = await nextPostRender({
timeoutMs: Math.max(0, end - performance.now()),
}).then(
() => true,
() => false,
);
if (disposed) return { state: 'failed', blockers: ['destroyed'] };
if (!drawn) break;
if (modelSets().some((r) => r.host.failed > 0))
return { state: 'failed', blockers: ['models'] };
const icons = iconState();
if (icons === 'failed') return { state: 'failed', blockers: ['icons'] };
quiet = loaded() && !idleBlocked() ? quiet + 1 : 0;
if (quiet < 3) continue;
// Then the loop left alone must draw nothing by itself for a while:
// a worker's first task can take tens of milliseconds, and what is
// in flight cannot be counted. Something that starts loading
// meanwhile ends the watch too; the next pass sees it, or its
// failure.
const outcome = await watchIdle(end, () => !loaded() || idleBlocked());
if (outcome === 'idle') return { state: 'settled', blockers: [] };
if (outcome !== 'busy') break;
// Work or a draw, unless it was something loading.
busy = loaded();
quiet = 0;
}
if (disposed) return { state: 'failed', blockers: ['destroyed'] };
const blockers = [];
if (!globeLoaded()) blockers.push('globe');
if (!tilesLoaded()) blockers.push('tiles');
if (modelSets().some((r) => r.host.loading > 0)) blockers.push('models');
if (iconState() !== 'settled') blockers.push('icons');
if (drawPart.building()) blockers.push('draw');
if (busy) blockers.push('redraw');
if (performance.now() - lastTick >= STALL_MS) blockers.push('frames');
return { state: 'timeout', blockers };
} finally {
off();
offTick();
}
/** Whether what is in view has loaded, nothing failing. */
function loaded() {
const icons = iconState();
return (
globeLoaded() &&
tilesLoaded() &&
icons === 'settled' &&
!drawPart.building() &&
!modelSets().some((r) => r.host.loading > 0 || r.host.failed > 0)
);
}
/**
* Work since the last look that will draw again, or a draw queued (one a
* hold makes anyway is the hold's).
*/
function idleBlocked() {
busy = completed > 0 || (scene.requestRenderMode && renderPending(scene));
completed = 0;
return busy;
}
}
return {
/** The renderer's own events: `error`, `contextLost`, `contextRestored`. */
on(event, cb) {
return rendererListeners[event]?.on(cb) ?? (() => {});
},
report,
frame,
globe: globePart.port,
draw,
camera: cameraPort,
...(controlled
? {
attachInput: (input) => controlled.attachInput(input),
suspendCamera: (reason) => controlled.suspendCamera(reason),
}
: {}),
credits: creditsPart.port,
query,
effects: effectsPart.port,
quality: qualityPart.port,
capture,
readPixels,
releaseUnused,
whenSettled,
/** Detach from the scene; the widget's owner destroys the widget. */
dispose() {
disposed = true;
for (const finish of [...watching]) finish('ended');
trimGlobe = false;
if (reader) reader.canvas.width = reader.canvas.height = 0;
reader = null;
// The tick under way is no longer seen through: it is not claimed.
settleTick(false);
for (const off of removers) off();
scene.canvas?.removeEventListener?.('webglcontextlost', contextLost);
// Cesium's own tween clock back, unless another set wrapped it since.
if (updateTweens && tweens.update === clockedTweens)
tweens.update = updateTweens;
// A listener that disposes the renderer stops the rest of its event.
for (const list of Object.values(rendererListeners)) list.clear();
for (const list of Object.values(frameListeners)) list.clear();
drawPart.dispose();
cameraPart.dispose();
creditsPart.dispose();
effectsPart.dispose();
globePart.dispose();
qualityPart.dispose();
for (const done of [...pendingRenders]) done();
},
};
}