mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-18 09:12:18 +00:00
The wind relief now asks the globe port for hillshade surface shading at 0.28 instead of building a globe material itself; the Cesium globe port draws the same view-directed shading, over terrain normals or the globe's curvature, and the unbound provider now lists surfaceShading. The wind layer's canvas flow, bounds, imagery fade and render requests go through the camera, frame and query ports, so src/layers/wind/rendering.js and relief.js leave the Cesium allow list. A refused shading request is taken back so it never shows after Wind is off, and a camera height that is not a number falls back as before. The application layers and standalone catalog entries no longer load the unbound factories themselves: a viewer with no renderer bound needs render/cesium/unbound loaded first. The contract and current-state docs say what the Cesium adapter's fields and surface shading do now.
1212 lines
36 KiB
JavaScript
1212 lines
36 KiB
JavaScript
import test from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import { createWindRendering } from './rendering.js';
|
|
import { NO_IMAGERY_HOST } from '../weather/imageryHost.js';
|
|
import { WEATHER_IMAGERY_Z } from '../weather/imageryOrder.js';
|
|
import {
|
|
createShellCesium,
|
|
createShellScene,
|
|
renderShells,
|
|
} from '../weather/shellFixture.mjs';
|
|
import { createCesiumFields } from '../../render/cesium/drawFields.js';
|
|
import { toLonLatH } from '../../geo/ellipsoid.js';
|
|
|
|
function event() {
|
|
const listeners = new Set();
|
|
return {
|
|
addEventListener(callback) {
|
|
listeners.add(callback);
|
|
return () => listeners.delete(callback);
|
|
},
|
|
emit() {
|
|
for (const callback of [...listeners]) callback();
|
|
},
|
|
get size() {
|
|
return listeners.size;
|
|
},
|
|
};
|
|
}
|
|
|
|
/** Browser/Cesium ownership harness with controllable visibility and scene events. */
|
|
function harness({
|
|
occluded = false,
|
|
reducedMotion = false,
|
|
projected = null,
|
|
createGpuRendering,
|
|
onStatusChange,
|
|
getHost,
|
|
eventTarget,
|
|
shell = false,
|
|
} = {}) {
|
|
const shellScene = shell ? createShellScene() : null;
|
|
const strokes = [];
|
|
const clears = [];
|
|
const textures = [];
|
|
const erasures = [];
|
|
let path = [];
|
|
const context = {
|
|
setTransform() {},
|
|
clearRect() {
|
|
clears.push(true);
|
|
},
|
|
fillRect() {
|
|
if (this.globalCompositeOperation === 'destination-out')
|
|
erasures.push(this.fillStyle);
|
|
},
|
|
beginPath() {
|
|
path = [];
|
|
},
|
|
moveTo(x, y) {
|
|
path.push([x, y]);
|
|
},
|
|
lineTo(x, y) {
|
|
path.push([x, y]);
|
|
},
|
|
stroke() {
|
|
strokes.push(path.slice());
|
|
},
|
|
createImageData(width, height) {
|
|
return { data: new Uint8ClampedArray(width * height * 4) };
|
|
},
|
|
putImageData() {},
|
|
};
|
|
const makeCanvas = () => ({
|
|
style: {},
|
|
dataset: {},
|
|
width: 0,
|
|
height: 0,
|
|
clientWidth: 800,
|
|
clientHeight: 600,
|
|
getContext: () => context,
|
|
toDataURL: () => 'data:image/png;base64,test',
|
|
remove() {
|
|
this.removed = true;
|
|
},
|
|
});
|
|
const canvas = makeCanvas();
|
|
let created = 0;
|
|
const container = {
|
|
clientWidth: 800,
|
|
clientHeight: 600,
|
|
appendChild(node) {
|
|
this.node = node;
|
|
},
|
|
};
|
|
const pending = new Map();
|
|
let sequence = 0;
|
|
const callbacks = {
|
|
get length() {
|
|
return pending.size;
|
|
},
|
|
shift() {
|
|
const next = pending.entries().next().value;
|
|
if (!next) return undefined;
|
|
pending.delete(next[0]);
|
|
return next[1];
|
|
},
|
|
};
|
|
const visibility = event();
|
|
const motion = event();
|
|
const preRender = event();
|
|
const media = {
|
|
matches: reducedMotion,
|
|
addEventListener(type, cb) {
|
|
motion.addEventListener(cb);
|
|
},
|
|
removeEventListener() {},
|
|
};
|
|
globalThis.document = {
|
|
hidden: false,
|
|
createElement() {
|
|
if (!created++) return canvas;
|
|
const item = makeCanvas();
|
|
textures.push(item);
|
|
return item;
|
|
},
|
|
addEventListener(type, cb) {
|
|
this.removeVisibility = visibility.addEventListener(cb);
|
|
},
|
|
removeEventListener() {
|
|
this.removeVisibility?.();
|
|
},
|
|
};
|
|
globalThis.matchMedia = () => media;
|
|
globalThis.requestAnimationFrame = (callback) => {
|
|
pending.set(++sequence, callback);
|
|
return sequence;
|
|
};
|
|
globalThis.cancelled = false;
|
|
globalThis.cancelAnimationFrame = (id) => {
|
|
globalThis.cancelled = true;
|
|
pending.delete(id);
|
|
};
|
|
const imagery = [];
|
|
const removed = [];
|
|
// The viewer's globe port: each layer added, and each removed.
|
|
const imageryLayers = {};
|
|
const globe = {
|
|
imagery: {
|
|
add(spec) {
|
|
let alpha = 1;
|
|
const errors = event();
|
|
const layer = {
|
|
spec,
|
|
errors,
|
|
show: true,
|
|
drapeOn: 'all',
|
|
alphaWrites: 0,
|
|
get alpha() {
|
|
return alpha;
|
|
},
|
|
set alpha(value) {
|
|
alpha = value;
|
|
this.alphaWrites++;
|
|
},
|
|
on: (name, cb) =>
|
|
name === 'tileError' ? errors.addEventListener(cb) : () => {},
|
|
remove() {
|
|
const i = imagery.indexOf(layer);
|
|
if (i >= 0) imagery.splice(i, 1);
|
|
removed.push({ layer, destroy: true });
|
|
},
|
|
};
|
|
imagery.push(layer);
|
|
return layer;
|
|
},
|
|
},
|
|
};
|
|
const viewer = {
|
|
container,
|
|
imageryLayers,
|
|
canvas,
|
|
scene: {
|
|
canvas,
|
|
camera: {
|
|
positionWC: {},
|
|
positionCartographic: { height: 1e6 },
|
|
changed: event(),
|
|
moveEnd: event(),
|
|
percentageChanged: 0.5,
|
|
},
|
|
preRender,
|
|
requestRender() {},
|
|
...(shellScene
|
|
? {
|
|
primitives: shellScene.primitives,
|
|
postRender: shellScene.postRender,
|
|
}
|
|
: {}),
|
|
},
|
|
isDestroyed: () => false,
|
|
};
|
|
const shellCesium = shell ? createShellCesium() : null;
|
|
// The camera, frame and query ports over the doubles above, read live.
|
|
const cameraPort = {
|
|
pose() {
|
|
const camera = viewer.scene.camera;
|
|
return {
|
|
position: camera.positionWC,
|
|
heading: camera.heading,
|
|
pitch: camera.pitch,
|
|
roll: camera.roll,
|
|
height: camera.positionCartographic?.height,
|
|
};
|
|
},
|
|
viewRectangle: () => viewer.scene.camera.viewRectangle?.() ?? null,
|
|
on: (name, cb) =>
|
|
name === 'moveEnd'
|
|
? viewer.scene.camera.moveEnd.addEventListener(cb)
|
|
: () => {},
|
|
};
|
|
const framePort = {
|
|
on: (name, cb) =>
|
|
name === 'preRender' ? preRender.addEventListener(cb) : () => {},
|
|
requestRender: () => viewer.scene.requestRender(),
|
|
};
|
|
// Projections see the point as degrees, as the doubles above were written.
|
|
const project = projected ?? (() => ({ x: 100, y: 100 }));
|
|
const queryPort = {
|
|
isOccluded: () => occluded,
|
|
project: (point) => project(viewer.scene, toLonLatH(point)),
|
|
};
|
|
const fields = shellCesium
|
|
? createCesiumFields({ scene: viewer.scene, cesium: shellCesium })
|
|
: null;
|
|
const draw = fields && { field: (spec) => fields.field(spec) };
|
|
const rendering = createWindRendering({
|
|
container,
|
|
getViewer: () => viewer,
|
|
globeOf: (given) => (given === viewer ? globe : null),
|
|
// The Cesium draw port's raster shells, over the doubles.
|
|
drawOf: (given) => (given === viewer ? draw : null),
|
|
cameraOf: (given) => (given === viewer ? cameraPort : null),
|
|
frameOf: (given) => (given === viewer ? framePort : null),
|
|
queryOf: (given) => (given === viewer ? queryPort : null),
|
|
createGpuRendering,
|
|
onStatusChange,
|
|
getHost,
|
|
eventTarget,
|
|
});
|
|
return {
|
|
rendering,
|
|
canvas,
|
|
container,
|
|
callbacks,
|
|
pending,
|
|
strokes,
|
|
clears,
|
|
textures,
|
|
erasures,
|
|
visibility,
|
|
media,
|
|
motion,
|
|
preRender,
|
|
viewer,
|
|
cesium: shellCesium,
|
|
imagery,
|
|
removed,
|
|
primitives: () => shellScene?.primitives.items ?? [],
|
|
};
|
|
}
|
|
|
|
const FIELD = {
|
|
u: Float32Array.from([10]),
|
|
v: Float32Array.from([0]),
|
|
nx: 1,
|
|
ny: 1,
|
|
lo1: 0,
|
|
la1: 90,
|
|
dx: 360,
|
|
dy: 180,
|
|
};
|
|
|
|
test('wind rendering owns the canvas and particle lifecycle', () => {
|
|
const { rendering, canvas, callbacks, strokes } = harness();
|
|
rendering.attach();
|
|
assert.equal(typeof canvas.getContext('2d'), 'object');
|
|
rendering.setField(FIELD);
|
|
assert.ok(rendering.getParticleCount() >= 200);
|
|
rendering.start();
|
|
callbacks.shift()(16);
|
|
assert.ok(strokes.length > 0, 'a driven frame draws trails');
|
|
rendering.stop();
|
|
assert.equal(globalThis.cancelled, true);
|
|
rendering.clear();
|
|
assert.equal(rendering.getParticleCount(), 0);
|
|
rendering.destroy();
|
|
rendering.destroy();
|
|
assert.equal(canvas.removed, true);
|
|
});
|
|
|
|
test('wind rendering starts before a field and still draws once one arrives', () => {
|
|
const { rendering, callbacks, strokes } = harness();
|
|
rendering.attach();
|
|
rendering.start();
|
|
assert.equal(callbacks.length, 0, 'no animation work before a field arrives');
|
|
rendering.setField(FIELD);
|
|
callbacks.shift()(32);
|
|
assert.ok(strokes.length > 0, 'draws once the field is installed');
|
|
rendering.stop();
|
|
});
|
|
|
|
test('wind rendering skips particles hidden by the globe', () => {
|
|
const { rendering, callbacks, strokes } = harness({ occluded: true });
|
|
rendering.attach();
|
|
rendering.setField(FIELD);
|
|
rendering.start();
|
|
callbacks.shift()(16);
|
|
assert.equal(strokes.length, 0, 'no trail is drawn for an occluded point');
|
|
rendering.stop();
|
|
});
|
|
|
|
// HTML canvas dimension setters erase pixels even on an identical assignment.
|
|
test('steady frames preserve canvas dimensions and resize adjusts the particle budget', () => {
|
|
const { rendering, canvas, callbacks } = harness();
|
|
let resets = 0;
|
|
let width = 0;
|
|
let height = 0;
|
|
Object.defineProperties(canvas, {
|
|
width: {
|
|
get: () => width,
|
|
set: (value) => {
|
|
width = value;
|
|
resets++;
|
|
},
|
|
},
|
|
height: {
|
|
get: () => height,
|
|
set: (value) => {
|
|
height = value;
|
|
resets++;
|
|
},
|
|
},
|
|
});
|
|
rendering.attach();
|
|
rendering.setField({ grid: FIELD, u: FIELD.u, v: FIELD.v });
|
|
rendering.start();
|
|
const initial = resets;
|
|
callbacks.shift()(16);
|
|
callbacks.shift()(32);
|
|
assert.equal(
|
|
resets,
|
|
initial,
|
|
'steady frames must not invoke canvas dimension setters',
|
|
);
|
|
canvas.clientWidth = 320;
|
|
canvas.clientHeight = 240;
|
|
callbacks.shift()(48);
|
|
assert.equal(resets, initial + 2);
|
|
assert.ok(
|
|
rendering.getParticleCount() < 500,
|
|
'small view uses a smaller budget',
|
|
);
|
|
rendering.destroy();
|
|
});
|
|
|
|
test('pause keeps a static field, redraws changed views only, and removes listeners on stop', () => {
|
|
const h = harness();
|
|
h.rendering.attach();
|
|
h.rendering.setField(FIELD);
|
|
h.rendering.start();
|
|
h.callbacks.shift()(16);
|
|
h.rendering.setOptions({ paused: true });
|
|
assert.equal(h.pending.size, 0);
|
|
const painted = h.strokes.length;
|
|
h.preRender.emit();
|
|
h.preRender.emit();
|
|
assert.equal(
|
|
h.strokes.length,
|
|
painted,
|
|
'unchanged paused scene performs no paint',
|
|
);
|
|
h.viewer.scene.camera.heading = 1;
|
|
h.preRender.emit();
|
|
assert.ok(
|
|
h.strokes.length > painted,
|
|
'camera change repaints anchored static marks',
|
|
);
|
|
assert.equal(h.pending.size, 0);
|
|
h.rendering.stop();
|
|
assert.equal(h.preRender.size, 0);
|
|
assert.equal(h.visibility.size, 0);
|
|
h.rendering.destroy();
|
|
});
|
|
|
|
test('reduced motion and hidden documents never retain an animation callback', () => {
|
|
const h = harness({ reducedMotion: true });
|
|
h.rendering.attach();
|
|
h.rendering.setField(FIELD);
|
|
h.rendering.start();
|
|
assert.equal(h.pending.size, 0);
|
|
assert.equal(h.rendering.getDiagnostics().reducedMotion, true);
|
|
h.media.matches = false;
|
|
h.motion.emit();
|
|
assert.equal(h.pending.size, 1);
|
|
globalThis.document.hidden = true;
|
|
h.visibility.emit();
|
|
assert.equal(h.pending.size, 0);
|
|
const painted = h.strokes.length;
|
|
h.preRender.emit();
|
|
assert.equal(h.strokes.length, painted);
|
|
globalThis.document.hidden = false;
|
|
h.visibility.emit();
|
|
assert.equal(h.pending.size, 1);
|
|
h.rendering.clear();
|
|
assert.equal(h.pending.size, 0);
|
|
assert.equal(h.rendering.getParticleCount(), 0);
|
|
h.rendering.destroy();
|
|
});
|
|
|
|
test('scalar imagery builds once, survives pause, replaces cleanly, and releases on clear', () => {
|
|
const h = harness();
|
|
h.rendering.attach();
|
|
h.rendering.setOptions({ overlay: 'speed' });
|
|
h.rendering.setField({ grid: FIELD, u: FIELD.u, v: FIELD.v });
|
|
h.rendering.start();
|
|
assert.equal(h.imagery.length, 1);
|
|
assert.equal(h.textures.length, 1);
|
|
assert.equal(h.imagery[0].spec.kind, 'single-image');
|
|
assert.equal(h.imagery[0].spec.zOrder, WEATHER_IMAGERY_Z.wind);
|
|
assert.equal(h.imagery[0].drapeOn, 'surface');
|
|
h.callbacks.shift()(16);
|
|
h.callbacks.shift()(50);
|
|
h.callbacks.shift()(85);
|
|
assert.equal(h.textures.length, 1, 'no texture generation from frames');
|
|
h.rendering.setOptions({ paused: true });
|
|
assert.equal(h.imagery.length, 1);
|
|
h.rendering.setOptions({ overlay: 'temperature' });
|
|
assert.equal(
|
|
h.imagery.length,
|
|
0,
|
|
'unavailable scalar cannot display the previous field',
|
|
);
|
|
assert.match(h.rendering.getDiagnostics().imageryError, /unavailable/);
|
|
h.rendering.setField({
|
|
grid: FIELD,
|
|
u: FIELD.u,
|
|
v: FIELD.v,
|
|
scalar: {
|
|
kind: 'temperature',
|
|
units: '°C',
|
|
values: new Float32Array([20]),
|
|
},
|
|
});
|
|
assert.equal(h.imagery.length, 1);
|
|
assert.equal(h.pending.size, 0);
|
|
h.rendering.clear();
|
|
assert.equal(h.imagery.length, 0);
|
|
assert.ok(h.removed.every((item) => item.destroy));
|
|
h.rendering.destroy();
|
|
});
|
|
|
|
for (const overlay of ['speed', 'pressure', 'temperature']) {
|
|
test(`${overlay} imagery fades with log camera height and resumes from idle`, () => {
|
|
let camera = null;
|
|
const gpu = {
|
|
supported: () => true,
|
|
setField: () => true,
|
|
updateVisibility: () => camera.positionCartographic.height > 15000,
|
|
setOptions() {},
|
|
clear() {},
|
|
destroy() {},
|
|
getParticleCount: () => 1,
|
|
getDiagnostics: () => ({ ready: true }),
|
|
};
|
|
const h = harness({ createGpuRendering: () => gpu });
|
|
camera = h.viewer.scene.camera;
|
|
const baseAlpha = overlay === 'temperature' ? 1 : 0.85;
|
|
const snapshot = {
|
|
grid: FIELD,
|
|
u: FIELD.u,
|
|
v: FIELD.v,
|
|
scalar: {
|
|
kind: overlay,
|
|
units: overlay === 'pressure' ? 'hPa' : '°C',
|
|
values: Float32Array.from([overlay === 'pressure' ? 1013 : 20]),
|
|
},
|
|
};
|
|
camera.positionCartographic.height = 17_368_000;
|
|
h.rendering.attach();
|
|
h.rendering.setOptions({ overlay });
|
|
h.rendering.setField(snapshot);
|
|
h.rendering.start();
|
|
let layer = h.imagery[0];
|
|
assert.equal(layer.alpha, baseAlpha);
|
|
assert.equal(layer.show, true);
|
|
const writes = layer.alphaWrites;
|
|
h.preRender.emit();
|
|
camera.changed.emit();
|
|
camera.moveEnd.emit();
|
|
assert.equal(
|
|
layer.alphaWrites,
|
|
writes,
|
|
'unchanged height never writes alpha',
|
|
);
|
|
|
|
camera.positionCartographic.height = Math.sqrt(200_000 * 1_200_000);
|
|
h.preRender.emit();
|
|
assert.ok(layer.alpha > 0 && layer.alpha < baseAlpha);
|
|
assert.ok(Math.abs(layer.alpha - baseAlpha / 2) < 1e-12, 'log midpoint');
|
|
const midpointWrites = layer.alphaWrites;
|
|
h.preRender.emit();
|
|
camera.positionCartographic.height *= 1.001;
|
|
h.preRender.emit();
|
|
assert.equal(
|
|
layer.alphaWrites,
|
|
midpointWrites,
|
|
'sub-0.005 changes are skipped',
|
|
);
|
|
camera.positionCartographic.height *= 1.02;
|
|
h.preRender.emit();
|
|
assert.equal(
|
|
layer.alphaWrites,
|
|
midpointWrites + 1,
|
|
'larger changes write alpha',
|
|
);
|
|
|
|
camera.positionCartographic.height = 100_000;
|
|
h.preRender.emit();
|
|
assert.equal(layer.alpha, 0);
|
|
assert.equal(layer.show, false);
|
|
h.rendering.setField({ ...snapshot });
|
|
assert.notEqual(h.imagery[0], layer, 'reinstall replaces the layer');
|
|
layer = h.imagery[0];
|
|
assert.equal(layer.alpha, 0, 'reinstall at low height starts transparent');
|
|
assert.equal(layer.show, false, 'reinstall at low height starts hidden');
|
|
|
|
for (const eventName of ['preRender', 'moveEnd']) {
|
|
camera.positionCartographic.height = 1200;
|
|
h.preRender.emit();
|
|
assert.equal(h.pending.size, 0, 'street-level flow is parked');
|
|
camera.positionCartographic.height = 1_200_000;
|
|
(eventName === 'preRender' ? h.preRender : camera.moveEnd).emit();
|
|
assert.equal(layer.alpha, baseAlpha, 'camera event restores full alpha');
|
|
assert.equal(
|
|
layer.show,
|
|
true,
|
|
'camera event unhides imagery without preRender',
|
|
);
|
|
camera.positionCartographic.height = 200_000;
|
|
(eventName === 'preRender' ? h.preRender : camera.moveEnd).emit();
|
|
assert.equal(layer.alpha, 0, 'lower bound is transparent');
|
|
assert.equal(layer.show, false);
|
|
}
|
|
h.rendering.setOptions({ paused: true });
|
|
camera.positionCartographic.height = 1_200_000;
|
|
h.preRender.emit();
|
|
assert.equal(
|
|
layer.alpha,
|
|
baseAlpha,
|
|
'paused imagery still follows camera height',
|
|
);
|
|
assert.equal(h.pending.size, 0);
|
|
assert.equal(
|
|
h.textures.length,
|
|
2,
|
|
'height changes never rebuild the texture',
|
|
);
|
|
h.rendering.destroy();
|
|
});
|
|
}
|
|
|
|
test('canvas fallback retains scalar base alpha at low camera height', () => {
|
|
const h = harness();
|
|
h.viewer.scene.camera.positionCartographic.height = 1200;
|
|
h.rendering.attach();
|
|
h.rendering.setOptions({ overlay: 'speed' });
|
|
h.rendering.setField({ grid: FIELD, u: FIELD.u, v: FIELD.v });
|
|
h.rendering.start();
|
|
h.preRender.emit();
|
|
assert.equal(h.imagery[0].alpha, 0.85);
|
|
assert.equal(h.imagery[0].show, true);
|
|
h.rendering.destroy();
|
|
});
|
|
|
|
test('projection discontinuities cannot produce long strokes across the viewport', () => {
|
|
let calls = 0;
|
|
const h = harness({
|
|
projected: () => ({ x: calls++ % 2 ? 790 : 10, y: 100 }),
|
|
});
|
|
h.rendering.attach();
|
|
h.rendering.setField(FIELD);
|
|
h.rendering.start();
|
|
h.callbacks.shift()(16);
|
|
assert.equal(h.strokes.length, 0);
|
|
h.rendering.destroy();
|
|
});
|
|
|
|
test('a large camera move immediately refills the newly visible region', () => {
|
|
let center = 0;
|
|
const h = harness({
|
|
projected: (scene, point) => ({
|
|
x: 400 + (((point.lon - center + 540) % 360) - 180) * 20,
|
|
y: 300 + point.lat * 20,
|
|
}),
|
|
});
|
|
h.viewer.scene.camera.viewRectangle = () => ({
|
|
west: center - 10,
|
|
east: center + 10,
|
|
south: -10,
|
|
north: 10,
|
|
});
|
|
h.rendering.attach();
|
|
h.rendering.setField(FIELD);
|
|
h.rendering.start();
|
|
h.callbacks.shift()(16);
|
|
center = 180;
|
|
h.viewer.scene.camera.heading = 1;
|
|
h.preRender.emit();
|
|
h.callbacks.shift()(50);
|
|
const d = h.rendering.getDiagnostics();
|
|
assert.ok(
|
|
d.painted > d.particleCount * 0.9,
|
|
'new hemisphere is populated in the changed-view frame',
|
|
);
|
|
h.rendering.destroy();
|
|
});
|
|
|
|
test('world-anchored wind glyphs remain readable at low FPS without accelerating particles', () => {
|
|
const h = harness({
|
|
projected: (scene, point) => ({
|
|
x: 400 + point.lon * 20,
|
|
y: 300 + point.lat * 20,
|
|
}),
|
|
});
|
|
h.viewer.scene.camera.viewRectangle = () => ({
|
|
west: -5,
|
|
east: 5,
|
|
south: -0.001,
|
|
north: 0.001,
|
|
});
|
|
h.rendering.attach();
|
|
h.rendering.setField(FIELD);
|
|
h.rendering.start();
|
|
const tick = (time) => {
|
|
h.strokes.length = 0;
|
|
h.callbacks.shift()(time);
|
|
return h.strokes[0];
|
|
};
|
|
const length = (path) =>
|
|
Math.hypot(path[1][0] - path[0][0], path[1][1] - path[0][1]);
|
|
const first = tick(16);
|
|
const normal = tick(50);
|
|
const slow = tick(1050);
|
|
assert.ok(
|
|
length(first) > 8,
|
|
'first frame contains an actual directional stroke',
|
|
);
|
|
assert.ok(Math.abs(length(first) - length(normal)) < 0.001);
|
|
assert.ok(
|
|
Math.abs(length(normal) - length(slow)) < 0.001,
|
|
'stroke span does not collapse with capped frame travel',
|
|
);
|
|
assert.ok(
|
|
slow[1][0] - normal[1][0] < length(slow) * 0.06,
|
|
'head still advances only by capped0.1s, not the2s drawn tail',
|
|
);
|
|
const alpha = Number(h.erasures.at(-1).match(/,([^,]+)\)$/)[1]);
|
|
assert.ok(
|
|
alpha > 0.6,
|
|
'one elapsed second decays old pixels, even though motion is capped',
|
|
);
|
|
h.strokes.length = 0;
|
|
h.rendering.setOptions({ paused: true });
|
|
const paused = h.strokes[0];
|
|
assert.ok(
|
|
Math.abs(length(paused) / length(slow) - 1.5) < 0.001,
|
|
'paused arrow has a longer3s world sample',
|
|
);
|
|
assert.deepEqual(paused[1], slow[1], 'pause does not advance the particle');
|
|
assert.equal(h.pending.size, 0);
|
|
h.rendering.destroy();
|
|
});
|
|
|
|
test('GPU flow leaves animation to the renderer, rebuilds only across viewport budgets, and pauses cleanly', () => {
|
|
let builds = 0,
|
|
cleared = 0,
|
|
destroyed = 0;
|
|
const options = [];
|
|
const gpu = {
|
|
supported: () => true,
|
|
updateVisibility: () => true,
|
|
setField(field) {
|
|
assert.equal(field.nx, 1);
|
|
builds++;
|
|
return true;
|
|
},
|
|
setOptions(value) {
|
|
options.push(value.paused);
|
|
},
|
|
clear() {
|
|
cleared++;
|
|
},
|
|
destroy() {
|
|
destroyed++;
|
|
},
|
|
getParticleCount: () => 1,
|
|
getDiagnostics: () => ({ ready: true, pathCount: 1 }),
|
|
};
|
|
const h = harness({ createGpuRendering: () => gpu });
|
|
h.rendering.attach();
|
|
h.rendering.setField({ grid: FIELD, u: FIELD.u, v: FIELD.v });
|
|
h.rendering.start();
|
|
assert.equal(h.rendering.getDiagnostics().renderMode, 'gpu-streamlines');
|
|
assert.equal(h.pending.size, 0, 'the renderer moves the highlight');
|
|
assert.equal(options.at(-1), false);
|
|
assert.equal(h.strokes.length, 0);
|
|
h.viewer.scene.camera.positionWC.x = 10;
|
|
h.preRender.emit();
|
|
assert.equal(
|
|
builds,
|
|
1,
|
|
'camera changes project geometry without rebuilding paths',
|
|
);
|
|
h.rendering.setOptions({ paused: true });
|
|
assert.equal(options.at(-1), true, 'the pause reaches the renderer');
|
|
h.canvas.clientWidth = 390;
|
|
h.preRender.emit();
|
|
assert.equal(builds, 2, 'crossing the narrow viewport boundary rebakes once');
|
|
h.preRender.emit();
|
|
assert.equal(builds, 2);
|
|
assert.equal(h.pending.size, 0);
|
|
h.rendering.destroy();
|
|
assert.equal(h.pending.size, 0);
|
|
assert.equal(h.preRender.size, 0);
|
|
assert.equal(cleared, 1);
|
|
assert.equal(destroyed, 1);
|
|
});
|
|
|
|
for (const paused of [false, true]) {
|
|
test(`GPU readiness notifies the row once even with paused=${paused}`, () => {
|
|
let ready = false;
|
|
let notifications = 0;
|
|
const gpu = {
|
|
supported: () => true,
|
|
updateVisibility: () => true,
|
|
setField: () => {
|
|
ready = false;
|
|
return true;
|
|
},
|
|
setOptions() {},
|
|
clear() {},
|
|
destroy() {},
|
|
getParticleCount: () => 1,
|
|
getDiagnostics: () => ({ ready, pathCount: 1 }),
|
|
};
|
|
const h = harness({
|
|
createGpuRendering: () => gpu,
|
|
onStatusChange: () => {
|
|
notifications++;
|
|
},
|
|
});
|
|
h.viewer.scene.requestRender = () => {};
|
|
h.rendering.attach();
|
|
h.rendering.setOptions({ paused });
|
|
h.rendering.setField(FIELD);
|
|
h.rendering.start();
|
|
h.preRender.emit();
|
|
assert.equal(notifications, 0);
|
|
ready = true;
|
|
h.preRender.emit();
|
|
assert.equal(
|
|
notifications,
|
|
1,
|
|
'worker completion invalidates displayed loading state',
|
|
);
|
|
h.preRender.emit();
|
|
assert.equal(
|
|
notifications,
|
|
1,
|
|
'unchanged readiness does not refresh every frame',
|
|
);
|
|
if (paused)
|
|
assert.equal(h.pending.size, 0, 'paused completion needs no RAF polling');
|
|
h.rendering.setField({ ...FIELD, u: Float32Array.from([11]) });
|
|
h.preRender.emit();
|
|
ready = true;
|
|
h.preRender.emit();
|
|
assert.equal(
|
|
notifications,
|
|
2,
|
|
'a replacement field can settle independently',
|
|
);
|
|
h.rendering.stop();
|
|
ready = false;
|
|
h.preRender.emit();
|
|
assert.equal(notifications, 2, 'stop releases readiness observation');
|
|
h.rendering.destroy();
|
|
});
|
|
}
|
|
|
|
test('scalar snapshots retain identical GPU wind geometry, and so its animation phase', () => {
|
|
let builds = 0;
|
|
const gpu = {
|
|
supported: () => true,
|
|
updateVisibility: () => true,
|
|
setField() {
|
|
builds++;
|
|
return true;
|
|
},
|
|
setOptions() {},
|
|
clear() {},
|
|
destroy() {},
|
|
getParticleCount: () => 1,
|
|
getDiagnostics: () => ({ ready: true, pathCount: 1 }),
|
|
};
|
|
const h = harness({ createGpuRendering: () => gpu });
|
|
const snapshot = (changes = {}) => ({
|
|
model: 'gfs',
|
|
level: '10m',
|
|
units: 'm/s',
|
|
cycle: {
|
|
runIso: '2026-09-15T00:00:00Z',
|
|
validIso: '2026-09-15T03:00:00Z',
|
|
forecastHour: 3,
|
|
},
|
|
grid: { ...FIELD },
|
|
u: Float32Array.from(FIELD.u),
|
|
v: Float32Array.from(FIELD.v),
|
|
...changes,
|
|
});
|
|
h.rendering.attach();
|
|
h.rendering.setField(snapshot());
|
|
h.rendering.start();
|
|
h.rendering.setOptions({ overlay: 'temperature' });
|
|
h.rendering.setField(
|
|
snapshot({
|
|
scalar: {
|
|
kind: 'temperature',
|
|
units: '°C',
|
|
values: Float32Array.from([24]),
|
|
},
|
|
}),
|
|
);
|
|
assert.equal(
|
|
builds,
|
|
1,
|
|
'freshly decoded equal arrays reuse the worker-built primitive',
|
|
);
|
|
assert.equal(h.imagery.length, 1, 'new scalar field is still installed');
|
|
h.rendering.setField(
|
|
snapshot({
|
|
scalar: {
|
|
kind: 'temperature',
|
|
units: '°C',
|
|
values: Float32Array.from([28]),
|
|
},
|
|
}),
|
|
);
|
|
assert.equal(builds, 1, 'revised scalar alone does not rebuild flow');
|
|
assert.equal(
|
|
h.imagery.length,
|
|
1,
|
|
'scalar replacement releases the prior image',
|
|
);
|
|
h.rendering.clear();
|
|
h.rendering.setField(snapshot());
|
|
assert.equal(builds, 2, 'clear invalidates reuse');
|
|
h.rendering.destroy();
|
|
});
|
|
|
|
for (const [label, change] of Object.entries({
|
|
model: { model: 'ifs' },
|
|
cycle: { cycle: { runIso: '2026-09-15T06:00:00Z' } },
|
|
validTime: {
|
|
cycle: { runIso: '2026-09-15T00:00:00Z', validIso: '2026-09-15T04:00:00Z' },
|
|
},
|
|
grid: { grid: { ...FIELD, lo1: -180 } },
|
|
spacing: { grid: { ...FIELD, dx: 180 } },
|
|
revisedU: { u: Float32Array.from([11]) },
|
|
revisedV: { v: Float32Array.from([1]) },
|
|
level: { level: '100m' },
|
|
})) {
|
|
test(`GPU geometry rebuilds on changed ${label}`, () => {
|
|
let builds = 0;
|
|
const gpu = {
|
|
supported: () => true,
|
|
updateVisibility: () => true,
|
|
setField() {
|
|
builds++;
|
|
return true;
|
|
},
|
|
setOptions() {},
|
|
clear() {},
|
|
destroy() {},
|
|
getParticleCount: () => 1,
|
|
getDiagnostics: () => ({ ready: true }),
|
|
};
|
|
const h = harness({ createGpuRendering: () => gpu });
|
|
const original = {
|
|
model: 'gfs',
|
|
level: '10m',
|
|
grid: FIELD,
|
|
u: FIELD.u,
|
|
v: FIELD.v,
|
|
cycle: {
|
|
runIso: '2026-09-15T00:00:00Z',
|
|
validIso: '2026-09-15T03:00:00Z',
|
|
},
|
|
};
|
|
h.rendering.attach();
|
|
h.rendering.setField(original);
|
|
h.rendering.setField({ ...original, ...change });
|
|
assert.equal(builds, 2);
|
|
h.rendering.destroy();
|
|
});
|
|
}
|
|
|
|
for (const eventName of ['preRender', 'moveEnd']) {
|
|
test(`GPU height fade follows camera ${eventName} with no frames of its own`, () => {
|
|
let visible = false;
|
|
let fades = 0;
|
|
const options = [];
|
|
const gpu = {
|
|
supported: () => true,
|
|
setField: () => true,
|
|
updateVisibility() {
|
|
fades++;
|
|
visible = camera.positionCartographic.height > 15000;
|
|
return visible;
|
|
},
|
|
setOptions(value) {
|
|
options.push(value.paused);
|
|
},
|
|
clear() {},
|
|
destroy() {},
|
|
getParticleCount: () => 1,
|
|
getDiagnostics: () => ({ ready: true }),
|
|
};
|
|
const h = harness({ createGpuRendering: () => gpu });
|
|
const camera = h.viewer.scene.camera;
|
|
camera.positionCartographic.height = 1200;
|
|
let renders = 0;
|
|
h.viewer.scene.requestRender = () => renders++;
|
|
h.rendering.attach();
|
|
h.rendering.setField(FIELD);
|
|
h.rendering.start();
|
|
h.preRender.emit();
|
|
assert.equal(h.pending.size, 0);
|
|
assert.equal(renders, 0);
|
|
assert.equal(visible, false);
|
|
assert.equal(camera.percentageChanged, 0.5);
|
|
assert.equal(camera.changed.size, 0);
|
|
|
|
camera.positionCartographic.height = 60000;
|
|
const before = fades;
|
|
(eventName === 'preRender' ? h.preRender : camera.moveEnd).emit();
|
|
assert.ok(fades > before, 'the fade follows the camera');
|
|
assert.equal(visible, true);
|
|
assert.equal(
|
|
renders,
|
|
eventName === 'preRender' ? 0 : 1,
|
|
'moveEnd wakes the parked scene',
|
|
);
|
|
assert.equal(h.pending.size, 0, 'the renderer animates, not the layer');
|
|
h.rendering.setOptions({ paused: true });
|
|
assert.equal(options.at(-1), true);
|
|
h.rendering.setOptions({ paused: false });
|
|
assert.equal(options.at(-1), false);
|
|
h.rendering.stop();
|
|
assert.equal(options.at(-1), true, 'a stopped layer holds the flow still');
|
|
h.rendering.destroy();
|
|
assert.equal(h.pending.size, 0);
|
|
assert.equal(camera.changed.size, 0);
|
|
assert.equal(camera.moveEnd.size, 0);
|
|
assert.equal(camera.percentageChanged, 0.5);
|
|
});
|
|
}
|
|
|
|
test('scalar field becomes a raised shell on 3D Tiles and survives no-host events', () => {
|
|
const eventTarget = new EventTarget();
|
|
let host;
|
|
const h = harness({
|
|
eventTarget,
|
|
shell: true,
|
|
getHost: () =>
|
|
host ?? { collection: h.viewer.imageryLayers, kind: 'globe' },
|
|
});
|
|
h.rendering.attach();
|
|
h.rendering.setOptions({ overlay: 'speed' });
|
|
h.rendering.setField(FIELD);
|
|
h.rendering.start();
|
|
const original = h.imagery[0];
|
|
assert.ok(original);
|
|
assert.equal(h.rendering.getDiagnostics().host, 'globe');
|
|
const tiles = {
|
|
addImageryProvider() {
|
|
throw new Error('nothing drapes on 3D Tiles');
|
|
},
|
|
};
|
|
host = { collection: tiles, kind: 'tileset' };
|
|
eventTarget.dispatchEvent(new Event('gev:map-stack-changed'));
|
|
assert.equal(h.imagery.length, 0);
|
|
assert.equal(h.removed[0].destroy, true);
|
|
// It shows once its geometry and image are ready.
|
|
renderShells(h.cesium, h.viewer.scene);
|
|
const [primitive] = h.primitives();
|
|
const geometry = primitive.options.geometryInstances.geometry.options;
|
|
assert.equal(geometry.height, 5_000);
|
|
assert.ok(
|
|
h.cesium.Rectangle.equals(geometry.rectangle, h.cesium.Rectangle.MAX_VALUE),
|
|
);
|
|
const material = primitive.appearance.material;
|
|
assert.equal(h.textures.length, 2);
|
|
assert.equal(material.uniforms.image, h.textures[1]);
|
|
assert.equal(h.textures[1].width, 360);
|
|
assert.equal(h.textures[1].height, 181);
|
|
assert.equal(material.uniforms.alpha, 0.85);
|
|
assert.equal(primitive.show, true);
|
|
const diagnostics = h.rendering.getDiagnostics();
|
|
assert.equal(diagnostics.host, 'shell');
|
|
assert.equal(diagnostics.imageryActive, true);
|
|
assert.equal(diagnostics.shell.height, 5_000);
|
|
host = { collection: null, kind: 'none' };
|
|
eventTarget.dispatchEvent(new Event('gev:map-stack-changed'));
|
|
assert.equal(primitive.show, false);
|
|
assert.equal(h.rendering.getDiagnostics().imageryError, NO_IMAGERY_HOST);
|
|
h.viewer.scene.camera.moveEnd.emit();
|
|
assert.equal(primitive.show, false, 'camera events keep it hidden');
|
|
host = { collection: tiles, kind: 'tileset' };
|
|
h.rendering.rehome();
|
|
assert.deepEqual(h.primitives(), [primitive]);
|
|
assert.equal(primitive.show, true);
|
|
assert.equal(h.textures.length, 2, 'the retained shell is reused');
|
|
assert.equal(h.rendering.getDiagnostics().imageryError, null);
|
|
host = null;
|
|
h.rendering.rehome();
|
|
assert.equal(primitive.destroyed, true);
|
|
assert.equal(material.destroyed, true);
|
|
assert.equal(h.primitives().length, 0);
|
|
assert.equal(h.imagery.length, 1);
|
|
assert.equal(h.rendering.getDiagnostics().host, 'globe');
|
|
h.rendering.destroy();
|
|
assert.equal(h.imagery.length, 0);
|
|
assert.equal(h.viewer.scene.postRender.size, 0);
|
|
eventTarget.dispatchEvent(new Event('gev:map-stack-changed'));
|
|
assert.equal(h.primitives().length, 0);
|
|
});
|
|
|
|
test('scalar installation with no host reports hidden and installs on restore', () => {
|
|
let host = { collection: null, kind: 'none' };
|
|
const h = harness({ getHost: () => host });
|
|
h.rendering.attach();
|
|
h.rendering.setOptions({ overlay: 'speed' });
|
|
h.rendering.setField(FIELD);
|
|
assert.equal(h.imagery.length, 0);
|
|
assert.equal(h.textures.length, 0);
|
|
assert.equal(
|
|
h.rendering.getDiagnostics().imageryError,
|
|
'Hidden by this map source · choose a globe map',
|
|
);
|
|
host = { collection: h.viewer.imageryLayers, kind: 'globe' };
|
|
h.rendering.rehome();
|
|
assert.equal(h.imagery.length, 1);
|
|
assert.equal(h.rendering.getDiagnostics().imageryError, null);
|
|
h.rendering.destroy();
|
|
});
|
|
|
|
for (const overlay of ['speed', 'temperature', 'pressure']) {
|
|
test(`${overlay} shell alpha follows the height fade in 0.1 steps on moveEnd, install or rehome`, () => {
|
|
const gpu = {
|
|
supported: () => true,
|
|
setField: () => true,
|
|
updateVisibility: () => true,
|
|
setOptions() {},
|
|
clear() {},
|
|
destroy() {},
|
|
getParticleCount: () => 1,
|
|
getDiagnostics: () => ({ ready: true }),
|
|
};
|
|
let kind = 'tileset';
|
|
const h = harness({
|
|
shell: true,
|
|
createGpuRendering: () => gpu,
|
|
getHost: () => ({ collection: h.viewer.imageryLayers, kind }),
|
|
});
|
|
const camera = h.viewer.scene.camera;
|
|
const field = {
|
|
...FIELD,
|
|
scalar: {
|
|
kind: overlay,
|
|
units: overlay === 'pressure' ? 'hPa' : '°C',
|
|
values: Float32Array.of(overlay === 'pressure' ? 1013 : 20),
|
|
},
|
|
};
|
|
camera.positionCartographic.height = Math.sqrt(200_000 * 1_200_000);
|
|
h.rendering.attach();
|
|
h.rendering.setOptions({ overlay });
|
|
h.rendering.setField(field);
|
|
h.rendering.start();
|
|
renderShells(h.cesium, h.viewer.scene);
|
|
assert.equal(h.imagery.length, 0);
|
|
const [primitive] = h.primitives();
|
|
const { uniforms } = primitive.appearance.material;
|
|
assert.equal(uniforms.alpha, overlay === 'temperature' ? 0.5 : 0.4);
|
|
let alpha = uniforms.alpha;
|
|
let writes = 0;
|
|
Object.defineProperty(uniforms, 'alpha', {
|
|
get: () => alpha,
|
|
set(value) {
|
|
alpha = value;
|
|
writes++;
|
|
},
|
|
});
|
|
camera.positionCartographic.height = 100_000;
|
|
h.preRender.emit();
|
|
h.rendering.setOptions({ paused: true });
|
|
assert.equal(writes, 0, 'preRender and pause do not change the shell');
|
|
camera.moveEnd.emit();
|
|
assert.equal(uniforms.alpha, 0);
|
|
assert.equal(primitive.show, false);
|
|
camera.positionCartographic.height = 59_999;
|
|
camera.moveEnd.emit();
|
|
assert.equal(uniforms.alpha, 0, 'the fade still hides the field low down');
|
|
assert.equal(primitive.show, false);
|
|
camera.positionCartographic.height = Math.sqrt(200_000 * 1_200_000);
|
|
camera.moveEnd.emit();
|
|
assert.equal(primitive.show, true);
|
|
writes = 0;
|
|
camera.positionCartographic.height *= 1.01;
|
|
camera.moveEnd.emit();
|
|
assert.equal(writes, 0, 'the same quantization bucket writes nothing');
|
|
camera.positionCartographic.height = 1_200_000;
|
|
h.rendering.rehome();
|
|
assert.equal(uniforms.alpha, overlay === 'temperature' ? 1 : 0.9);
|
|
kind = 'globe';
|
|
h.rendering.rehome();
|
|
assert.equal(primitive.destroyed, true);
|
|
assert.equal(h.imagery[0].spec.kind, 'single-image');
|
|
assert.equal(h.imagery[0].alpha, overlay === 'temperature' ? 1 : 0.85);
|
|
h.rendering.destroy();
|
|
assert.equal(camera.moveEnd.size, 0);
|
|
});
|
|
}
|
|
|
|
for (const overlay of ['speed', 'temperature', 'pressure']) {
|
|
test(`${overlay} canvas fallback shows the shell at street level without changing globe alpha`, () => {
|
|
let kind = 'tileset';
|
|
const h = harness({
|
|
shell: true,
|
|
getHost: () => ({ collection: h.viewer.imageryLayers, kind }),
|
|
});
|
|
const camera = h.viewer.scene.camera;
|
|
camera.positionCartographic.height = 1200;
|
|
h.rendering.attach();
|
|
h.rendering.setOptions({ overlay });
|
|
h.rendering.setField({
|
|
...FIELD,
|
|
scalar: {
|
|
kind: overlay,
|
|
units: overlay === 'pressure' ? 'hPa' : '°C',
|
|
values: Float32Array.of(overlay === 'pressure' ? 1013 : 20),
|
|
},
|
|
});
|
|
h.rendering.start();
|
|
renderShells(h.cesium, h.viewer.scene);
|
|
const [primitive] = h.primitives();
|
|
const textures = h.textures.length;
|
|
const baseAlpha = overlay === 'temperature' ? 1 : 0.85;
|
|
assert.equal(primitive.show, true, 'no height gate on 3D Tiles');
|
|
assert.equal(primitive.appearance.material.uniforms.alpha, baseAlpha);
|
|
camera.moveEnd.emit();
|
|
h.preRender.emit();
|
|
assert.equal(primitive.show, true);
|
|
assert.equal(
|
|
h.textures.length,
|
|
textures,
|
|
'camera changes keep the field texture',
|
|
);
|
|
kind = 'globe';
|
|
h.rendering.rehome();
|
|
assert.equal(primitive.destroyed, true);
|
|
assert.equal(h.imagery[0].show, true);
|
|
assert.equal(h.imagery[0].alpha, baseAlpha);
|
|
h.rendering.destroy();
|
|
});
|
|
}
|
|
|
|
test('globe imagery hides without a host and shows again when one returns; a failed field image says so', () => {
|
|
let host = { collection: {}, kind: 'globe' };
|
|
const h = harness({ getHost: () => host });
|
|
h.rendering.attach();
|
|
h.rendering.setOptions({ overlay: 'speed' });
|
|
h.rendering.setField(FIELD);
|
|
const [layer] = h.imagery;
|
|
assert.equal(layer.show, true);
|
|
host = { collection: null, kind: 'none' };
|
|
h.rendering.rehome();
|
|
assert.equal(layer.show, false, 'hidden, not removed');
|
|
assert.deepEqual(h.imagery, [layer]);
|
|
host = { collection: {}, kind: 'globe' };
|
|
h.rendering.rehome();
|
|
assert.equal(layer.show, true);
|
|
assert.deepEqual(h.imagery, [layer]);
|
|
layer.errors.emit();
|
|
assert.equal(
|
|
h.rendering.getDiagnostics().imageryError,
|
|
'Globe field image unavailable',
|
|
);
|
|
h.rendering.destroy();
|
|
assert.equal(h.imagery.length, 0);
|
|
});
|