/**
* Checks for every port but the camera: shape, the frame loop, draw sets,
* queries, input, the globe, effects, credits, quality and the renderer.
* Each check reads and drives the renderer through the contract alone.
*/
import {
CAPABILITIES,
CONTRACT_VERSION,
QUALITY_KEYS,
checkPortShape,
checkRendererShape,
} from '../../contract/index.js';
import { AUSTIN, SCRIPT_VIEWPORT } from '../cameraScripts.js';
import { deepEqual, equal, near, nearVec, ok, throws } from '../expect.js';
import { iconPosition } from '../../motion/iconMotion.js';
/** 1 × 1 PNGs (red, green, blue), so imagery checks load nothing from the network. */
const PIXEL_PNGS = [
'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR4nGP4z8DwHwAFAAH/iZk9HQAAAABJRU5ErkJggg==',
'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR4nGNg+M/wHwAEAQH/cetH5QAAAABJRU5ErkJggg==',
'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR4nGNgYPj/HwADAgH/5ncLrgAAAABJRU5ErkJggg==',
];
const PIXEL_PNG = PIXEL_PNGS[0];
const DOT = {
svg: '',
};
/** A white square, solid to its edges. */
const SQUARE = {
svg: '',
};
async function fresh(h) {
return h.create({ viewport: SCRIPT_VIEWPORT });
}
/** Looks straight down on Austin from `height` metres. */
async function overAustin(h, r, height = 2000) {
r.camera.setView({
destination: { ...AUSTIN, height },
orientation: { heading: 0, pitch: -Math.PI / 2, roll: 0 },
});
await h.frame(r);
}
/**
* Waits until what is drawn has loaded (icon images, tiles, models), as a
* query answers from what is loaded. Where the renderer draws synchronously it
* settled at once.
*/
async function settled(r) {
const result = await r.whenSettled({ timeoutMs: 20000 });
equal(result.state, 'settled', `settled (${result.blockers.join(', ')})`);
}
/**
* Settles, then watches `ticks` ticks and returns what they did: preUpdate's
* `['u', rendering]` and a draw's `['r']`. An engine may still draw on its
* own once in a while after settling (roundoff in its camera bookkeeping,
* say), so a watch that saw a draw is tried again, up to `tries` times; one
* that always draws fails every try.
*/
async function idleWatch(h, r, ticks, tries = 3) {
let seen = [];
const off = [
r.frame.on('preUpdate', (t) => seen.push(['u', t.rendering])),
r.frame.on('postRender', () => seen.push(['r'])),
];
try {
for (let i = 0; i < tries; i++) {
await settled(r);
seen = [];
for (let k = 0; k < ticks; k++) await h.frame(r);
if (!seen.some(([kind]) => kind === 'r')) break;
}
return seen;
} finally {
for (const f of off) f();
}
}
async function drawn(h, r, frames = 2) {
for (let i = 0; i < frames; i++) {
r.frame.requestRender('conformance');
await h.frame(r);
}
}
/**
* The listener rules on one subscription list: subscription order, one
* removed during delivery does not run, one added during delivery waits for
* the next event, and a throw goes to `error` while the rest still run.
* `subscribe(cb)` returns its Off; `fire()` raises one event.
*/
async function listenerRules(r, where, subscribe, fire) {
const errors = [];
const offError = r.on('error', (e) => errors.push(e));
const seen = [];
const offs = [];
let offRemoved = () => {};
let added = false;
offs.push(
subscribe(() => {
seen.push('first');
offRemoved();
if (!added) {
added = true;
offs.push(subscribe(() => seen.push('added')));
}
}),
);
offs.push(
subscribe(() => {
throw new Error('listener failure');
}),
);
offRemoved = subscribe(() => seen.push('removed'));
offs.push(offRemoved);
offs.push(subscribe(() => seen.push('last')));
await fire();
deepEqual(
seen,
['first', 'last'],
`${where}: in order; removed during delivery does not run; added waits`,
);
ok(errors.length >= 1, `${where}: the throw went to error`);
seen.length = 0;
await fire();
deepEqual(
seen,
['first', 'last', 'added'],
`${where}: one added during delivery runs from the next event`,
);
for (const off of offs) off();
offError();
}
/** A check over a fresh renderer, destroyed afterwards. */
function check(id, title, run, extra = {}) {
return {
id,
port: id.split('.')[0],
title,
...extra,
async run(h) {
const r = await fresh(h);
try {
if (extra.capability && !r.capabilities.has(extra.capability))
return { skip: `no ${extra.capability}` };
return await run(h, r);
} finally {
r.destroy();
}
},
};
}
const POINTER_TYPES = [
'down',
'move',
'up',
'click',
'dblclick',
'wheel',
'pinch',
];
const SET_KINDS = [
['icons', null],
['points', null],
['lines', null],
['shapes', null],
['models', 'models'],
['quads', 'quads'],
['meshes', 'meshes'],
];
/** A plain style that swaps colour channels by its intensity. */
const swapStyle = (id) => ({
id,
params: [],
animated: false,
shader: {
glsl: `uniform sampler2D colorTexture;
uniform float intensity;
in vec2 v_textureCoordinates;
void main() {
vec4 c = texture(colorTexture, v_textureCoordinates);
out_FragColor = vec4(mix(c.rgb, c.gbr, intensity), 1.0);
}`,
wgsl: `@fragment
fn fs_main(@location(0) uv: vec2f) -> @location(0) vec4f {
let c = textureSample(colorTexture, colorSampler, uv);
return vec4f(mix(c.rgb, c.gbr, params.intensity), 1.0);
}`,
},
});
/** A style that mirrors the image left to right: it moves every pixel. */
const mirrorStyle = (id) => ({
id,
params: [],
animated: false,
shader: {
glsl: `uniform sampler2D colorTexture;
uniform float intensity;
in vec2 v_textureCoordinates;
void main() {
vec2 uv = v_textureCoordinates;
vec2 mirrored = vec2(1.0 - uv.x, uv.y);
out_FragColor = vec4(texture(colorTexture, mix(uv, mirrored, step(0.5, intensity))).rgb, 1.0);
}`,
wgsl: `@fragment
fn fs_main(@location(0) uv: vec2f) -> @location(0) vec4f {
let mirrored = vec2f(1.0 - uv.x, uv.y);
let at = mix(uv, mirrored, step(0.5, params.intensity));
return vec4f(textureSample(colorTexture, colorSampler, at).rgb, 1.0);
}`,
},
});
export function portChecks() {
return [
// --- Shape -------------------------------------------------------------
check(
'renderer.shape',
'every port has exactly the members its capabilities allow',
(h, r) => {
deepEqual(checkRendererShape(r), [], 'renderer shape');
equal(r.contractVersion, CONTRACT_VERSION, 'contract version');
for (const c of r.capabilities)
ok(CAPABILITIES.includes(c), `known capability ${c}`);
for (const [kind, capability] of SET_KINDS) {
if (capability && !r.capabilities.has(capability)) continue;
const set = r.draw[kind]({ id: `shape:${kind}` });
deepEqual(
checkPortShape(set, 'drawSet', r.capabilities),
[],
`${kind} set shape`,
);
set.dispose();
}
const layer = r.globe.imagery.add({
kind: 'xyz',
url: 'https://example.invalid/{z}/{x}/{y}.png',
});
deepEqual(
checkPortShape(layer, 'imageryLayer', r.capabilities),
[],
'imagery layer shape',
);
layer.remove();
const flight = r.camera.flyTo(
{ ...AUSTIN, height: 1e6 },
{ durationS: 1 },
);
deepEqual(
checkPortShape(flight, 'flight', r.capabilities),
[],
'flight shape',
);
r.camera.cancelFlight();
const lease = r.input.claimPointer('conformance');
deepEqual(
checkPortShape(lease, 'lease', r.capabilities),
[],
'lease shape',
);
lease.release();
},
),
check(
'renderer.listeners',
'listener order, removal during delivery and a throwing listener',
async (h, r) => {
const errors = [];
r.on('error', (e) => errors.push(e));
const seen = [];
let offB = () => {};
r.frame.on('preUpdate', () => {
seen.push('a');
offB();
r.frame.on('preUpdate', () => seen.push('late'));
});
offB = r.frame.on('preUpdate', () => seen.push('b'));
r.frame.on('preUpdate', () => {
throw new Error('listener failure');
});
r.frame.on('preUpdate', () => seen.push('c'));
await h.frame(r);
deepEqual(
seen,
['a', 'c'],
'removed during delivery does not run; added during delivery waits',
);
equal(errors.length, 1, 'the throw went to error');
// The error list keeps the rules too. While an error is delivered,
// A removes B and subscribes the same callback again: B does not run
// for that error, and runs from the next one.
const errorSeen = [];
const b = () => errorSeen.push('b');
let offErrorB = () => {};
let resubscribed = false;
r.on('error', () => {
errorSeen.push('a');
if (resubscribed) return;
resubscribed = true;
offErrorB();
offErrorB = r.on('error', b);
});
offErrorB = r.on('error', b);
r.frame.on('preUpdate', () => {
throw new Error('another failure');
});
seen.length = 0;
await h.frame(r);
ok(
seen.includes('late'),
'a listener added during delivery runs from the next frame',
);
deepEqual(
errorSeen,
['a', 'a', 'b'],
'an error listener removed during delivery does not run; subscribed again, it waits',
);
},
),
check(
'renderer.listenerRules',
'every subscription list follows the listener rules',
async (h, r) => {
await overAustin(h, r);
const lists = [
[
'frame.on(postRender)',
(cb) => r.frame.on('postRender', cb),
() => drawn(h, r, 1),
],
[
'camera.on(flightEnd)',
(cb) => r.camera.on('flightEnd', cb),
() => r.camera.flyTo({ ...AUSTIN, height: 2000 }, { durationS: 0 }),
],
[
'camera.onCommand',
(cb) => r.camera.onCommand(cb),
() =>
r.camera.setView({ destination: { ...AUSTIN, height: 2000 } }),
],
[
'quality.signals.on(frame)',
(cb) => r.quality.signals.on('frame', cb),
() => drawn(h, r, 1),
],
];
// A move between two far-apart views raises one of each camera event.
let flip = false;
const moveCamera = async () => {
await h.frame(r);
flip = !flip;
r.camera.setView({
destination: { ...AUSTIN, height: flip ? 400000 : 2000 },
});
for (let i = 0; i < 40; i++) await h.frame(r);
};
for (const event of ['changed', 'moveStart', 'moveEnd'])
lists.push([
`camera.on(${event})`,
(cb) => r.camera.on(event, cb),
moveCamera,
]);
if (h.pointer)
lists.push([
'input.on(move)',
(cb) => r.input.on('move', cb),
() => h.pointer(r, 'move', 10, 10),
]);
for (const [where, subscribe, fire] of lists)
await listenerRules(r, where, subscribe, fire);
},
),
check(
'credits.listenerRules',
'credits.on(change) follows the listener rules',
async (h, r) => {
const credits = [];
try {
await listenerRules(
r,
'credits.on(change)',
(cb) => r.credits.on('change', cb),
() => {
credits.push(r.credits.addStatic({ text: 'Conformance data' }));
},
);
} finally {
for (const off of credits) off();
}
},
),
// --- Frame -------------------------------------------------------------
check(
'frame.order',
'phases run preUpdate → preRender → postRender in a drawing frame',
async (h, r) => {
const seen = [];
r.frame.on('postRender', () => seen.push('postRender'));
r.frame.on('preRender', () => seen.push('preRender'));
r.frame.on('preUpdate', () => seen.push('preUpdate'));
r.frame.requestRender('order');
await h.frame(r);
deepEqual(
seen,
['preUpdate', 'preRender', 'postRender'],
'phase order',
);
},
),
check(
'frame.demand',
'on demand: preUpdate every tick, drawing only when asked or held',
async (h, r) => {
if (r.frame.mode() === 'continuous')
return { skip: 'continuous engine' };
await drawn(h, r, 3);
// A renderer still loading is not idle.
deepEqual(
await idleWatch(h, r, 1),
[['u', false]],
'an idle tick runs preUpdate and draws nothing',
);
const seen = [];
r.frame.on('preUpdate', (t) => seen.push(['u', t.rendering]));
r.frame.on('postRender', () => seen.push(['r']));
r.frame.requestRender('one');
ok(
r.frame.diagnostics().pendingReasons.includes('one'),
'the reason is pending',
);
await h.frame(r);
deepEqual(seen, [['u', true], ['r']], 'a request draws one frame');
deepEqual(
r.frame.diagnostics().pendingReasons,
[],
'and that frame answers it',
);
// What that frame started loading (tiles it now needs) may draw on
// its own; once that is done the loop is idle again.
deepEqual(await idleWatch(h, r, 1), [['u', false]], 'and only one');
const a = r.frame.holdContinuous('a');
const b = r.frame.holdContinuous('b');
deepEqual(
[...r.frame.diagnostics().holds].sort(),
['a', 'b'],
'holds listed',
);
seen.length = 0;
await h.frame(r);
await h.frame(r);
equal(
seen.filter(([k]) => k === 'r').length,
2,
'a hold draws every frame',
);
a();
a();
seen.length = 0;
await h.frame(r);
equal(seen.filter(([k]) => k === 'r').length, 1, 'one hold still out');
b();
equal(
(await idleWatch(h, r, 2)).filter(([k]) => k === 'r').length,
0,
'no holds, no frames',
);
},
),
check(
'frame.prediction',
'preUpdate rendering says whether the tick draws, whatever came before',
async (h, r) => {
if (r.frame.mode() === 'continuous')
return { skip: 'continuous engine' };
await settled(r);
// An earlier listener asks for frames and takes and gives back
// holds; the prediction, read after it, must match each tick.
const script = ['idle', 'request', 'idle', 'hold', 'idle', 'release'];
let step = 0;
let release = null;
r.frame.on('preUpdate', () => {
const op = script[step++ % script.length];
if (op === 'request') r.frame.requestRender('prediction');
if (op === 'hold') release = r.frame.holdContinuous('prediction');
if (op === 'release') release?.();
});
const predicted = new Map();
const drew = new Set();
r.frame.on('preUpdate', (t) => predicted.set(t.frame, t.rendering));
r.frame.on('postRender', (t) => drew.add(t.frame));
for (let i = 0; i < 4 * script.length; i++) await h.frame(r);
release?.();
const wrong = [...predicted]
.filter(([frame, rendering]) => rendering !== drew.has(frame))
.map(([frame, rendering]) => `${frame}:${rendering}`);
deepEqual(wrong, [], 'ticks predicted wrongly (frame:prediction)');
ok(
[...predicted.values()].some((x) => x) &&
[...predicted.values()].some((x) => !x),
'both kinds of tick were seen',
);
},
),
check(
'frame.time',
'scene time is set and reported in FrameTime',
async (h, r) => {
const t0 = Date.UTC(2026, 5, 21, 12);
r.frame.setTime(t0);
equal(r.frame.time(), t0, 'time()');
let seen = null;
r.frame.on('preUpdate', (t) => (seen = t));
await h.frame(r);
equal(seen.time, t0, 'FrameTime.time');
ok(seen.dt > 0, 'dt is positive');
ok(Number.isInteger(seen.frame), 'frame is a count');
// Set in preUpdate, it is the time the frame under way draws at.
const t1 = t0 + 3_600_000;
let drawnAt = null;
const offUpdate = r.frame.on('preUpdate', () => r.frame.setTime(t1));
let laterAt = null;
const offLater = r.frame.on('preUpdate', (t) => (laterAt = t.time));
const offRender = r.frame.on('preRender', (t) => (drawnAt = t.time));
const once = r.frame.renderOnce();
await h.frame(r);
await once;
offUpdate();
offLater();
offRender();
equal(laterAt, t1, 'later preUpdate listeners see it');
equal(drawnAt, t1, 'a time set in preUpdate is that frame’s time');
equal(r.frame.time(), t1, 'and time() reports it');
},
),
check(
'frame.renderOnce',
'renderOnce resolves after a drawn frame; renderNow draws now',
async (h, r) => {
let drawnFrames = 0;
r.frame.on('postRender', () => (drawnFrames += 1));
const once = r.frame.renderOnce();
await h.frame(r);
await once;
ok(drawnFrames >= 1, 'renderOnce drew a frame');
const before = drawnFrames;
r.frame.renderNow();
equal(drawnFrames, before + 1, 'renderNow drew synchronously');
},
),
check('frame.suspend', 'a suspended loop does not tick', async (h, r) => {
let ticks = 0;
r.frame.on('preUpdate', () => (ticks += 1));
r.frame.suspend(true);
ok(r.frame.diagnostics().suspended, 'suspended');
await h.frame(r);
equal(ticks, 0, 'no ticks while hidden');
r.frame.suspend(false);
await h.frame(r);
equal(ticks, 1, 'ticking again');
}),
// --- Draw --------------------------------------------------------------
check('draw.sets', 'set, upsert, remove, clear and size', (h, r) => {
const set = r.draw.points({ id: 'conf:points' });
const p = (id, lon) => ({
id,
pos: { lon, lat: AUSTIN.lat, height: 0 },
pixelSize: 8,
color: '#ff0000',
});
set.set([p('a', -97.74), p('b', -97.73)]);
equal(set.size(), 2, 'set');
set.upsert([p('b', -97.72), p('c', -97.71)]);
equal(set.size(), 3, 'upsert adds and replaces');
set.remove(['a', 'missing']);
equal(set.size(), 2, 'remove ignores unknown ids');
set.set([p('d', -97.7)]);
equal(set.size(), 1, 'set replaces every item');
set.clear();
equal(set.size(), 0, 'clear');
set.dispose();
}),
check(
'draw.ids',
'set ids are unique among live sets and free again once disposed',
(h, r) => {
const a = r.draw.icons({ id: 'conf:dup' });
throws(
() => r.draw.lines({ id: 'conf:dup' }),
'a second live set with the id',
);
a.dispose();
const b = r.draw.lines({ id: 'conf:dup' });
equal(b.id, 'conf:dup', 'the id is free after dispose');
a.dispose();
throws(
() => r.draw.points({ id: 'conf:dup' }),
'disposing the old handle again leaves the newer set live',
);
b.dispose();
},
),
check(
'draw.pick',
'a drawn icon is picked under its projection with its set, id and meta',
async (h, r) => {
await overAustin(h, r);
const set = r.draw.icons({ id: 'conf:pick' });
const pos = h.toEcef({ ...AUSTIN, height: 0 });
set.set([
{ id: 'one', pos, image: DOT, size: [24, 24], meta: { n: 1 } },
]);
await drawn(h, r);
await settled(r);
const s = r.query.project(pos);
ok(s, 'the icon projects');
const hit = r.query.pick(s.x, s.y);
ok(hit, 'a hit');
equal(hit.set, 'conf:pick', 'Hit.set');
equal(hit.id, 'one', 'Hit.id');
deepEqual(hit.meta, { n: 1 }, 'Hit.meta');
equal(hit.surface, false, 'not the surface');
for (const purpose of ['hover', 'select'])
equal(
r.query.pick(s.x, s.y, { purpose })?.id,
'one',
`a ${purpose} pick finds an icon too`,
);
set.setOptions({ pickable: false });
await drawn(h, r);
const after = r.query.pick(s.x, s.y);
ok(
!after || after.set !== 'conf:pick',
'an unpickable set is not picked',
);
set.setOptions({ pickable: true });
set.show = false;
await drawn(h, r);
const hidden = r.query.pick(s.x, s.y);
ok(!hidden || hidden.set !== 'conf:pick', 'a hidden set is not picked');
set.dispose();
},
),
check(
'draw.drillPick',
'drillPick returns every item under the pointer',
async (h, r) => {
await overAustin(h, r);
const set = r.draw.points({ id: 'conf:drill' });
const pos = h.toEcef({ ...AUSTIN, height: 0 });
set.set([
{ id: 'a', pos, pixelSize: 20, color: '#f00' },
{ id: 'b', pos, pixelSize: 20, color: '#0f0' },
]);
await drawn(h, r);
const s = r.query.project(pos);
const ids = r.query
.drillPick(s.x, s.y)
.filter((x) => x.set === 'conf:drill')
.map((x) => x.id)
.sort();
deepEqual(ids, ['a', 'b'], 'both hits');
equal(r.query.drillPick(s.x, s.y, { limit: 1 }).length, 1, 'limit');
equal(
r.query.drillPick(s.x, s.y, { limit: 0 }).length,
0,
'a limit of 0 picks nothing',
);
ok(
r.query.drillPick(s.x, s.y).every((hit) => hit.surface === false),
'never the surface',
);
deepEqual(
r.query.drillPick(s.x + 120, s.y + 120),
[],
'nothing over the bare globe',
);
// An unpickable set over them is looked through, never named.
const cover = r.draw.points({
id: 'conf:drill-cover',
pickable: false,
});
cover.set([{ id: 'c', pos, pixelSize: 30, color: '#00f' }]);
await drawn(h, r);
const through = r.query.drillPick(s.x, s.y, { limit: 2 });
ok(
through.every((hit) => hit.set === 'conf:drill'),
'an unpickable set is not named',
);
equal(through.length, 2, 'the items under it are');
cover.dispose();
set.dispose();
// Nearest first: stacked under a downward eye, the highest is nearest.
const stack = r.draw.points({ id: 'conf:drill-stack' });
stack.set(
[0, 300, 600].map((height) => ({
id: `h${height}`,
pos: h.toEcef({ ...AUSTIN, height }),
pixelSize: 20,
color: '#f0f',
})),
);
await drawn(h, r);
const top = r.query.project(h.toEcef({ ...AUSTIN, height: 600 }));
const all = r.query
.drillPick(top.x, top.y)
.filter((x) => x.set === 'conf:drill-stack')
.map((x) => x.id);
deepEqual(all, ['h600', 'h300', 'h0'], 'nearest first');
const bounded = r.query
.drillPick(top.x, top.y, { limit: 2 })
.map((x) => x.id);
ok(bounded.length <= 2, 'no more than the limit');
deepEqual(bounded, all.slice(0, bounded.length), 'the nearest of them');
stack.dispose();
},
),
check(
'draw.field.rasterShell',
"a shell draws its image, and its 'drawn' comes once per change, never while hidden",
async (h, r) => {
await overAustin(h, r, 20000);
// Around Austin, below the eye, which the shell covers whole; where
// it projects is in the units `readPixels` crops in.
const below = r.query.project(h.toEcef({ ...AUSTIN, height: 0 }));
ok(below, 'the ground below projects');
const middle = async () => {
await settled(r);
r.frame.renderNow();
return r.readPixels({
crop: {
x: Math.round(below.x) - 6,
y: Math.round(below.y) - 6,
width: 13,
height: 13,
},
}).data;
};
// How many pixels are clearly bluer than they were.
const bluer = (now, was) => {
let n = 0;
for (let i = 0; i < now.length; i += 4)
if (now[i + 2] - was[i + 2] > 40 && now[i] - was[i] < 20) n++;
return n;
};
const readsPixels = h.pixels !== false;
const empty = readsPixels ? await middle() : null;
const svg = (fill) => ({
svg: ``,
});
const errors = [];
const offError = r.on('error', (e) => errors.push(e));
const field = r.draw.field({
kind: 'rasterShell',
id: 'conf:shell',
image: svg('#0a84ff'),
rectangle: { west: -98.5, south: 29.5, east: -97, north: 31 },
heightM: 8000,
alpha: 0.6,
});
let drawnCount = 0;
const off = field.on('drawn', () => (drawnCount += 1));
// Frames until 'drawn' has come `want` times, for at most 20 s.
const until = async (want) => {
const deadline = Date.now() + 20000;
while (drawnCount < want && Date.now() < deadline)
await drawn(h, r, 1);
};
try {
await until(1);
equal(drawnCount, 1, 'drawn once made');
if (readsPixels)
ok(
bluer(await middle(), empty) >= 150,
'the shell draws its image over the frame',
);
await drawn(h, r, 4);
equal(drawnCount, 1, 'not again while nothing changes');
field.update({ image: svg('#ff3b30') });
await until(2);
equal(drawnCount, 2, 'drawn after a new image');
field.update({ alpha: 0.3 });
await until(3);
equal(drawnCount, 3, 'drawn after a new alpha');
field.show = false;
field.update({ liftM: 500 });
await drawn(h, r, 6);
equal(drawnCount, 3, 'never while hidden');
field.show = true;
await until(4);
equal(drawnCount, 4, 'drawn once shown again');
await drawn(h, r, 4);
equal(drawnCount, 4, 'and only once');
deepEqual(errors, [], 'no errors');
await listenerRules(
r,
"field.on('drawn')",
(cb) => field.on('drawn', cb),
async () => {
const want = drawnCount + 1;
field.update({ alpha: drawnCount % 2 ? 0.4 : 0.5 });
await until(want);
},
);
} finally {
off();
offError();
field.dispose();
}
},
{ capability: 'fields' },
),
check(
'draw.field.windStreamlines',
"streamlines' 'drawn' comes once per change, never while hidden",
async (h, r) => {
await overAustin(h, r, 2000000);
const width = 8;
const height = 5;
const errors = [];
const offError = r.on('error', (e) => errors.push(e));
const field = r.draw.field({
kind: 'windStreamlines',
id: 'conf:wind',
u: new Float32Array(width * height).fill(12),
v: new Float32Array(width * height).fill(4),
width,
height,
rectangle: { west: -180, south: -80, east: 180, north: 80 },
pathBudget: 200,
steps: 8,
style: { color: '#80c9e6', widthPx: 2 },
heightM: 12000,
alpha: 1,
});
let drawnCount = 0;
const off = field.on('drawn', () => (drawnCount += 1));
// Frames until 'drawn' has come `want` times, for at most 20 s.
const until = async (want) => {
const deadline = Date.now() + 20000;
while (drawnCount < want && Date.now() < deadline)
await drawn(h, r, 1);
};
try {
await until(1);
equal(drawnCount, 1, 'drawn once made');
await drawn(h, r, 4);
equal(drawnCount, 1, 'not again while nothing changes');
field.update({ alpha: 0.5 });
await until(2);
equal(drawnCount, 2, 'drawn after a new alpha');
field.update({ paused: true });
await until(3);
equal(drawnCount, 3, 'drawn once paused');
field.show = false;
field.update({ alpha: 0.4 });
await drawn(h, r, 6);
equal(drawnCount, 3, 'never while hidden');
field.show = true;
await until(4);
equal(drawnCount, 4, 'drawn once shown again');
deepEqual(errors, [], 'no errors');
} finally {
off();
offError();
field.dispose();
}
},
{ capability: 'fields' },
),
check(
'draw.drawOrder',
'of sets drawn over depth, the higher draw order is on top and picked',
async (h, r) => {
await overAustin(h, r);
const pos = h.toEcef({ ...AUSTIN, height: 0 });
const icon = (id) => ({
id,
pos,
image: DOT,
size: [24, 24],
disableDepthTest: Infinity,
});
const first = r.draw.icons({ id: 'conf:order-first' });
// Made after it, but drawn over it.
const second = r.draw.icons({ id: 'conf:order-second', drawOrder: 2 });
first.set([icon('a')]);
second.set([icon('b')]);
await drawn(h, r);
await settled(r);
const s = r.query.project(pos);
ok(s, 'the icons project');
const sets = () =>
r.query
.drillPick(s.x, s.y)
.filter((x) => x.set.startsWith('conf:order-'))
.map((x) => x.set);
equal(r.query.pick(s.x, s.y)?.set, 'conf:order-second', 'the higher');
deepEqual(
sets(),
['conf:order-second', 'conf:order-first'],
'topmost first',
);
first.setOptions({ drawOrder: 3 });
await drawn(h, r);
equal(
r.query.pick(s.x, s.y)?.set,
'conf:order-first',
'raised, the pick flips',
);
deepEqual(
sets(),
['conf:order-first', 'conf:order-second'],
'and the drill',
);
// Of one order, they keep the order they were made in.
first.setOptions({ drawOrder: 0 });
second.setOptions({ drawOrder: 0 });
await drawn(h, r);
equal(
r.query.pick(s.x, s.y)?.set,
'conf:order-first',
'equal ones as they were made',
);
first.dispose();
second.dispose();
},
),
check(
'query.pickBeforeStyles',
'picks answer against the scene as drawn before styles',
async (h, r) => {
await overAustin(h, r);
const set = r.draw.icons({ id: 'conf:pick-styled' });
// Off centre, so a style that mirrors the image moves it.
const pos = h.toEcef({
lon: AUSTIN.lon + 0.004,
lat: AUSTIN.lat,
height: 0,
});
set.set([{ id: 'one', pos, image: DOT, size: [24, 24] }]);
await drawn(h, r);
await settled(r);
const s = r.query.project(pos);
ok(s, 'the icon projects');
const off = r.effects.defineStyle(mirrorStyle('conf:mirror'));
r.effects.setStyle('conf:mirror');
r.effects.setStyleIntensity('conf:mirror', 1);
await drawn(h, r);
equal(r.effects.diagnostics().style, 'conf:mirror', 'the style is on');
const hit = r.query.pick(s.x, s.y);
equal(
hit?.set,
'conf:pick-styled',
'picked where it is, not where it shows',
);
equal(hit?.id, 'one', 'Hit.id');
r.effects.setStyle(null);
off();
set.dispose();
},
{ capability: 'styles' },
),
check(
'effects.screenModulation',
'a sector draws its pass, asks for a frame, and leaves picks alone',
async (h, r) => {
await overAustin(h, r);
const set = r.draw.icons({ id: 'conf:pick-swept' });
const pos = h.toEcef({
lon: AUSTIN.lon + 0.004,
lat: AUSTIN.lat,
height: 0,
});
const passes = () => r.effects.diagnostics().passes;
// The sweep stands 100 px left of the icon and points up, so the
// icon is outside the band, dimmed all the way.
const sector = (s) => ({
center: { x: s.x - 100, y: s.y },
angle: 0,
width: 0.3,
radius: 400,
floor: 0,
strength: 0.6,
color: '#00ff88',
});
// Whether one tick after `change`, with nothing else asked of it,
// draws: from idle, which is asserted first.
const drawsOnItsOwn = async (change) => {
deepEqual(await idleWatch(h, r, 1), [['u', false]], 'idle first');
let rendered = false;
const off = r.frame.on('postRender', () => (rendered = true));
try {
change();
await h.frame(r);
} finally {
off();
}
return rendered;
};
const demand = r.frame.mode() !== 'continuous';
try {
set.set([{ id: 'one', pos, image: DOT, size: [24, 24] }]);
await drawn(h, r);
await settled(r);
const s = r.query.project(pos);
ok(s, 'the icon projects');
const before = r.query.pick(s.x, s.y);
equal(before?.id, 'one', 'the icon picks');
equal(passes().includes('screenModulation'), false, 'off at first');
const setSector = () => r.effects.screenModulation(sector(s));
if (demand)
ok(await drawsOnItsOwn(setSector), 'setting asks for a frame');
else setSector();
await drawn(h, r);
ok(passes().includes('screenModulation'), 'the pass draws');
const hit = r.query.pick(s.x, s.y);
deepEqual(
[hit?.set, hit?.id],
[before.set, before.id],
'a dimmed icon picks as before',
);
const clear = () => r.effects.screenModulation(null);
if (demand)
ok(await drawsOnItsOwn(clear), 'clearing asks for a frame');
else clear();
await drawn(h, r);
equal(passes().includes('screenModulation'), false, 'gone on null');
} finally {
r.effects.screenModulation(null);
set.dispose();
}
},
{ capability: 'screenModulation' },
),
check(
'effects.screenModulation.pixels',
'a marker in the band draws, one outside it dims to the floor, a radius of 0 dims every one',
async (h, r) => {
await overAustin(h, r);
const set = r.draw.icons({ id: 'conf:swept-pixels' });
const pos = h.toEcef({
lon: AUSTIN.lon + 0.004,
lat: AUSTIN.lat,
height: 0,
});
const icon = { id: 'one', pos, image: DOT, size: [24, 24] };
let s = null;
// The patch of the frame around the icon, once what is set has drawn.
const patch = async () => {
await drawn(h, r, 3);
await settled(r);
r.frame.renderNow();
return r.readPixels({
crop: {
x: Math.round(s.x) - 6,
y: Math.round(s.y) - 6,
width: 13,
height: 13,
},
}).data;
};
// How many pixels of `a` differ clearly from `b`.
const differ = (a, b) => {
let n = 0;
for (let i = 0; i < a.length; i += 4)
if (
Math.abs(a[i] - b[i]) +
Math.abs(a[i + 1] - b[i + 1]) +
Math.abs(a[i + 2] - b[i + 2]) >
90
)
n++;
return n;
};
// The sweep stands 100 px left of the icon. Pointing right, the
// band's middle on the icon's bearing, it covers it; pointing left,
// not.
const sector = (extra) => ({
center: { x: s.x - 100, y: s.y },
angle: Math.PI / 2 - 0.3,
width: 0.6,
radius: 400,
floor: 0,
strength: 0,
color: '#ffffff',
...extra,
});
try {
set.set([icon]);
await drawn(h, r);
await settled(r);
s = r.query.project(pos);
ok(s, 'the icon projects');
const shown = await patch();
set.set([]);
const empty = await patch();
const drawnPixels = differ(shown, empty);
if (h.pixels === false)
return { skip: 'this harness reads no drawn pixels' };
ok(drawnPixels >= 20, 'the icon draws into pixels');
set.set([icon]);
r.effects.screenModulation(sector());
ok(
differ(await patch(), empty) >= drawnPixels * 0.8,
'in the band the icon draws',
);
r.effects.screenModulation(sector({ angle: Math.PI * 1.5 }));
ok(
differ(await patch(), empty) <= drawnPixels * 0.1,
'outside the band it dims to a floor of 0',
);
r.effects.screenModulation(sector({ radius: 0 }));
ok(
differ(await patch(), empty) <= drawnPixels * 0.1,
'a radius of 0 dims it to the floor',
);
r.effects.screenModulation(sector({ radius: 0, floor: 1 }));
ok(
differ(await patch(), empty) >= drawnPixels * 0.8,
'at a floor of 1 nothing dims',
);
r.effects.screenModulation(sector({ strength: 1, color: '#ff0000' }));
const tinted = await patch();
let red = 0;
for (let i = 0; i < tinted.length; i += 4)
if (tinted[i] > 180 && tinted[i + 1] < 90 && tinted[i + 2] < 90)
red++;
ok(red >= drawnPixels * 0.5, 'a strength of 1 draws it in `color`');
r.effects.screenModulation(null);
ok(
differ(await patch(), shown) <= drawnPixels * 0.1,
'cleared, it draws as before',
);
} finally {
r.effects.screenModulation(null);
set.dispose();
}
},
{ capability: 'screenModulation' },
),
check(
'effects.withoutScreenModulation',
'without screenModulation the effects port has no such member',
async (h) => {
const r = await h.create({
viewport: SCRIPT_VIEWPORT,
capabilities: CAPABILITIES.filter((c) => c !== 'screenModulation'),
});
if (!r) return { skip: 'this harness cannot drop capabilities' };
try {
equal(r.effects.screenModulation, undefined, 'no member');
ok(
!r.effects.diagnostics().passes.includes('screenModulation'),
'no pass',
);
} finally {
r.destroy();
}
},
),
check(
'draw.motion',
'icons move by their segments on the set\u2019s motion clock',
async (h, r) => {
await overAustin(h, r, 8000);
const t0 = r.frame.time();
const from = h.toEcef({
lon: AUSTIN.lon - 0.02,
lat: AUSTIN.lat,
height: 0,
});
const to = h.toEcef({
lon: AUSTIN.lon + 0.02,
lat: AUSTIN.lat,
height: 0,
});
const set = r.draw.icons({
id: 'conf:motion',
motionClock: { kind: 'scene' },
});
set.set([
{
id: 'mover',
pos: from,
image: DOT,
size: [16, 16],
motion: { kind: 'lerp', from, to, t0, t1: t0 + 10000 },
},
]);
const pickAt = (p) => {
const s = r.query.project(p);
return r.query
.drillPick(s.x, s.y)
.some((x) => x.set === 'conf:motion');
};
r.frame.setTime(t0 + 5000);
await drawn(h, r);
const mid = {
x: (from.x + to.x) / 2,
y: (from.y + to.y) / 2,
z: (from.z + to.z) / 2,
};
ok(pickAt(mid), 'picked halfway at half time');
ok(!pickAt(from), 'not still at the start');
r.frame.setTime(t0 + 60000);
await drawn(h, r);
ok(pickAt(to), 'holds at the end');
set.dispose();
},
{ capability: 'motionSegments' },
),
check(
'draw.motion.arc',
'an arc turns in the fix\u2019s tangent plane and coasts no longer than maxDtS',
async (h, r) => {
await overAustin(h, r, 8000);
const t0 = r.frame.time();
const fixAt = { ...AUSTIN, height: 0 };
const fix = h.toEcef(fixAt);
const segment = {
kind: 'arc',
fix,
t0,
speedMps: 50,
trackDeg: 90,
turnRateDps: 3,
minDtS: 0,
maxDtS: 20,
};
const set = r.draw.icons({
id: 'conf:arc',
motionClock: { kind: 'scene' },
});
set.set([
{
id: 'turner',
pos: fix,
image: DOT,
size: [16, 16],
motion: segment,
},
]);
// The contract's formula, on the fix's own east and north axes.
const lon = (fixAt.lon * Math.PI) / 180;
const lat = (fixAt.lat * Math.PI) / 180;
const east = { x: -Math.sin(lon), y: Math.cos(lon), z: 0 };
const north = {
x: -Math.sin(lat) * Math.cos(lon),
y: -Math.sin(lat) * Math.sin(lon),
z: Math.cos(lat),
};
const at = (dtS) => {
const track = (segment.trackDeg * Math.PI) / 180;
const w = (segment.turnRateDps * Math.PI) / 180;
const v = segment.speedMps;
const e = (v / w) * (Math.cos(track) - Math.cos(track + w * dtS));
const n = (v / w) * (Math.sin(track + w * dtS) - Math.sin(track));
return {
x: fix.x + east.x * e + north.x * n,
y: fix.y + east.y * e + north.y * n,
z: fix.z + east.z * e + north.z * n,
};
};
const pickAt = (p) => {
const s = r.query.project(p);
return r.query.drillPick(s.x, s.y).some((x) => x.set === 'conf:arc');
};
r.frame.setTime(t0 + 20000);
await drawn(h, r);
ok(pickAt(at(20)), 'on the arc at 20 s');
const straight = {
x: fix.x + east.x * 1000,
y: fix.y + east.y * 1000,
z: fix.z + east.z * 1000,
};
ok(!pickAt(straight), 'not where a straight track would be');
r.frame.setTime(t0 + 60000);
await drawn(h, r);
ok(pickAt(at(20)), 'coasts no further than maxDtS');
set.dispose();
},
{ capability: 'motionSegments' },
),
check(
'draw.motion.live',
'a live motion clock runs delayMs behind wall time',
async (h, r) => {
if (!h.wallTime) return { skip: 'no wall time in this harness' };
await overAustin(h, r, 8000);
const w = h.wallTime(r);
const from = h.toEcef({ ...AUSTIN, lon: AUSTIN.lon - 0.02, height: 0 });
const to = h.toEcef({ ...AUSTIN, lon: AUSTIN.lon + 0.02, height: 0 });
const along = (f) => ({
x: from.x + (to.x - from.x) * f,
y: from.y + (to.y - from.y) * f,
z: from.z + (to.z - from.z) * f,
});
const set = r.draw.icons({
id: 'conf:live',
motionClock: { kind: 'live', delayMs: 2000 },
});
// Halfway at wall time minus the delay; 70% at wall time itself.
set.set([
{
id: 'mover',
pos: from,
image: DOT,
size: [16, 16],
motion: { kind: 'lerp', from, to, t0: w - 7000, t1: w + 3000 },
},
]);
// Scene time an hour away: a live set must not read it.
r.frame.setTime(w - 3600000);
await drawn(h, r, 1);
const pickAt = (p) => {
const s = r.query.project(p);
return r.query.drillPick(s.x, s.y).some((x) => x.set === 'conf:live');
};
ok(pickAt(along(0.5)), 'drawn delayMs behind wall time');
ok(!pickAt(along(0.7)), 'not at wall time');
ok(!pickAt(from), 'not held at the start by the scene clock');
// A second of frames later it has moved on by the wall time passed.
await drawn(h, r, 60);
const passed = h.wallTime(r) - w;
ok(passed > 0, 'wall time passed');
// The segment holds at its end, however much wall time passed.
ok(
pickAt(along(Math.min(1, 0.5 + passed / 10000))),
'moves on with wall time',
);
set.dispose();
},
{ capability: 'motionSegments' },
),
check(
'draw.motion.climb',
'an arc climbs at climbMps, and a negative minDtS runs it backward',
async (h, r) => {
await overAustin(h, r, 30000);
const t0 = r.frame.time();
const fixAt = { ...AUSTIN, height: 12000 };
const fix = h.toEcef(fixAt);
const lon = (fixAt.lon * Math.PI) / 180;
const lat = (fixAt.lat * Math.PI) / 180;
const east = { x: -Math.sin(lon), y: Math.cos(lon), z: 0 };
const north = {
x: -Math.sin(lat) * Math.cos(lon),
y: -Math.sin(lat) * Math.sin(lon),
z: Math.cos(lat),
};
const up = {
x: Math.cos(lat) * Math.cos(lon),
y: Math.cos(lat) * Math.sin(lon),
z: Math.sin(lat),
};
// The contract's formula: the turn in the tangent plane, the climb up.
const at = (seg, dtS, climbs = true) => {
const track = (seg.trackDeg * Math.PI) / 180;
const w = (seg.turnRateDps * Math.PI) / 180;
const v = seg.speedMps;
const straight = Math.abs(w) < 1e-4;
const e = straight
? v * dtS * Math.sin(track)
: (v / w) * (Math.cos(track) - Math.cos(track + w * dtS));
const n = straight
? v * dtS * Math.cos(track)
: (v / w) * (Math.sin(track + w * dtS) - Math.sin(track));
const u = climbs ? seg.climbMps * dtS : 0;
return {
x: fix.x + east.x * e + north.x * n + up.x * u,
y: fix.y + east.y * e + north.y * n + up.y * u,
z: fix.z + east.z * e + north.z * n + up.z * u,
};
};
const segments = {
straight: {
kind: 'arc',
fix,
t0,
speedMps: 200,
trackDeg: 90,
turnRateDps: 0,
climbMps: 1000,
minDtS: -10,
maxDtS: 10,
},
turning: {
kind: 'arc',
fix,
t0,
speedMps: 150,
trackDeg: 0,
turnRateDps: 3,
climbMps: 1500,
minDtS: 0,
maxDtS: 20,
},
};
const set = r.draw.icons({
id: 'conf:climb',
motionClock: { kind: 'scene' },
});
const find = (id, p) => {
const s = r.query.project(p);
return r.query
.drillPick(s.x, s.y)
.find((x) => x.set === 'conf:climb' && x.id === id);
};
const apart = (a, b) => {
const sa = r.query.project(a);
const sb = r.query.project(b);
return Math.hypot(sa.x - sb.x, sa.y - sb.y);
};
for (const [id, seg, sceneDtS, dtS, name] of [
['straight', segments.straight, 30, 10, 'climbed, clamped to maxDtS'],
['straight', segments.straight, -30, -10, 'run backward to minDtS'],
['turning', segments.turning, 8, 8, 'turning and climbing at 8 s'],
]) {
set.set([{ id, pos: fix, image: DOT, size: [16, 16], motion: seg }]);
r.frame.setTime(t0 + sceneDtS * 1000);
await drawn(h, r);
const want = at(seg, dtS);
const flat = at(seg, dtS, false);
ok(apart(want, flat) > 20, `${name}: the test can tell`);
const hit = find(id, want);
ok(hit, `${name}: picked where the formula puts it`);
if (hit?.position)
nearVec(
hit.position,
want,
50,
`${name}: at the formula's position`,
);
ok(!find(id, flat), `${name}: not at the fix's height`);
}
set.dispose();
},
{ capability: 'motionSegments' },
),
check(
'draw.motion.shared',
'icons are drawn where the shared motion evaluator puts them',
async (h, r) => {
await overAustin(h, r, 30000);
const t0 = r.frame.time();
const fix = h.toEcef({ ...AUSTIN, height: 9000 });
const to = h.toEcef({
...AUSTIN,
lon: AUSTIN.lon + 0.03,
height: 9000,
});
const items = [
{
id: 'arc',
pos: fix,
image: DOT,
size: [16, 16],
motion: {
kind: 'arc',
fix,
t0,
speedMps: 180,
trackDeg: 200,
turnRateDps: -2.5,
climbMps: 100,
minDtS: -20,
maxDtS: 15,
},
},
{
id: 'step',
pos: fix,
image: DOT,
size: [16, 16],
// No span: at `from` until t0, at `to` after it.
motion: { kind: 'lerp', from: fix, to, t0: t0 + 4000, t1: t0 },
},
];
const set = r.draw.icons({
id: 'conf:shared',
motionClock: { kind: 'scene' },
});
set.set(items);
const find = (id, p) => {
const s = r.query.project(p);
return r.query
.drillPick(s.x, s.y)
.find((x) => x.set === 'conf:shared' && x.id === id);
};
const apart = (a, b) => {
const sa = r.query.project(a);
const sb = r.query.project(b);
return Math.hypot(sa.x - sb.x, sa.y - sb.y);
};
// Each sample against where the item is at another of them: the
// evaluator's answer, and not the other.
const samples = [-30, 9, 40];
for (const [k, dtS] of samples.entries()) {
const t = t0 + dtS * 1000;
const other = t0 + samples[(k + 1) % samples.length] * 1000;
r.frame.setTime(t);
await drawn(h, r);
for (const item of items) {
const want = iconPosition(item, t);
const elsewhere = iconPosition(item, other);
if (apart(want, elsewhere) < 20) continue;
const hit = find(item.id, want);
ok(hit, `${item.id} at ${dtS} s: picked there`);
if (hit?.position)
nearVec(hit.position, want, 50, `${item.id} at ${dtS} s: there`);
ok(
!find(item.id, elsewhere),
`${item.id} at ${dtS} s: not elsewhere`,
);
}
}
set.dispose();
},
{ capability: 'motionSegments' },
),
check(
'draw.displayRange',
'one thing drawn near and far in two sets shows each over its own range',
async (h, r) => {
const pos = h.toEcef({ ...AUSTIN, height: 0 });
const near = r.draw.points({ id: 'conf:lod-near' });
const far = r.draw.icons({ id: 'conf:lod-far' });
const members = (nearRange, farRange) => {
near.set([
{
id: 'a',
pos,
pixelSize: 20,
color: '#f00',
displayRange: nearRange,
},
]);
far.set([
{
id: 'a',
pos,
image: DOT,
size: [20, 20],
displayRange: farRange,
},
]);
};
const shown = () => {
const s = r.query.project(pos);
return r.query
.drillPick(s.x, s.y)
.filter(
(x) => x.set === 'conf:lod-near' || x.set === 'conf:lod-far',
);
};
members([0, 10000], [10000, Infinity]);
for (const [height, set] of [
[2000, 'conf:lod-near'],
[50000, 'conf:lod-far'],
]) {
await overAustin(h, r, height);
await drawn(h, r);
const hits = shown();
deepEqual(
hits.map((x) => x.set),
[set],
`at ${height} m only ${set} is drawn`,
);
equal(hits[0]?.id, 'a', `at ${height} m the hit names the item`);
}
members([0, 100000], [1000, Infinity]);
await drawn(h, r);
deepEqual(
shown()
.map((x) => x.set)
.sort(),
['conf:lod-far', 'conf:lod-near'],
'overlapping ranges show both',
);
near.dispose();
far.dispose();
},
),
check(
'draw.clampState',
'clampState says whether clamped items drape or overlay',
(h, r) => {
ok(
['draped', 'overlay'].includes(r.draw.clampState()),
'draped or overlay',
);
const off = r.draw.on('clampState', () => {});
equal(typeof off, 'function', 'on returns an Off');
off();
off();
},
),
check(
'draw.atlas',
'icons draw slots of an atlas registered after them, and are picked',
async (h, r) => {
await overAustin(h, r);
const set = r.draw.icons({ id: 'conf:atlas' });
const at = (lon) => h.toEcef({ lon, lat: AUSTIN.lat, height: 0 });
// A generated slot too, where there is a canvas that draws in 2D.
const canvas = globalThis.document?.createElement('canvas');
const g = canvas?.getContext?.('2d');
const slots = { svg: ['dot', DOT, AUSTIN.lon - 0.002] };
if (g) {
canvas.width = canvas.height = 16;
g.fillStyle = '#fff';
g.fillRect(0, 0, 16, 16);
slots.canvas = [
'square',
{ canvas, key: 'conf:square' },
AUSTIN.lon + 0.002,
];
}
set.set(
Object.entries(slots).map(([id, [slot, , lon]]) => ({
id,
pos: at(lon),
image: { atlas: 'conf:atlas', slot },
size: [24, 24],
})),
);
await drawn(h, r);
r.draw.atlas(
'conf:atlas',
Object.fromEntries(
Object.values(slots).map(([slot, image]) => [slot, image]),
),
);
await drawn(h, r);
await settled(r);
for (const [id, [, , lon]] of Object.entries(slots)) {
const s = r.query.project(at(lon));
ok(s, `${id} projects`);
equal(r.query.pick(s.x, s.y)?.id, id, `${id} slot drawn and picked`);
}
set.dispose();
},
),
check(
'draw.icons.images',
'icons draw every kind of image (URL, SVG, blob, keyed canvas and an atlas slot of each), on billboards and moving alike, and are picked',
async (h, r) => {
await overAustin(h, r);
const kinds = {
url: PIXEL_PNG,
svg: DOT,
blob: { blob: new Blob([DOT.svg], { type: 'image/svg+xml' }) },
};
const canvas = globalThis.document?.createElement('canvas');
const g = canvas?.getContext?.('2d');
if (g) {
canvas.width = canvas.height = 16;
g.fillStyle = '#fff';
g.fillRect(0, 0, 16, 16);
kinds.canvas = { canvas, key: 'conf:images-square' };
}
r.draw.atlas('conf:images', kinds);
const images = Object.entries(kinds).flatMap(([kind, image]) => [
[kind, image],
[`atlas-${kind}`, { atlas: 'conf:images', slot: kind }],
]);
// Two sets: still icons, and icons that recede (drawn as moving
// ones are, where a renderer draws them apart).
const rows = [
['still', {}, AUSTIN.lat + 0.004],
['receding', { recede: true }, AUSTIN.lat - 0.004],
];
const at = (i, lat) =>
h.toEcef({
lon: AUSTIN.lon + (i - (images.length - 1) / 2) * 0.0012,
lat,
height: 0,
});
const sets = rows.map(([name, extra, lat]) => {
const set = r.draw.icons({ id: `conf:images-${name}` });
set.set(
images.map(([id, image], i) => ({
id,
pos: at(i, lat),
image,
size: [20, 20],
...extra,
})),
);
return set;
});
await drawn(h, r);
await settled(r);
await drawn(h, r);
for (const [name, , lat] of rows)
images.forEach(([id], i) => {
const s = r.query.project(at(i, lat));
ok(s, `${name} ${id} projects`);
const hit = r.query.pick(s.x, s.y);
deepEqual(
[hit?.set, hit?.id],
[`conf:images-${name}`, id],
`${name} ${id} drawn and picked`,
);
});
for (const set of sets) set.dispose();
},
),
check(
'draw.icons.cluster',
'icons close on screen draw as one cluster, picked as its members seed first at its position; apart again, each is its own',
async (h, r) => {
await overAustin(h, r, 2000);
const counts = [];
const set = r.draw.icons({
id: 'conf:cluster',
cluster: {
pixelRange: 20,
minimumSize: 3,
icon: (count) => {
counts.push(count);
return DOT;
},
},
});
const at = (dx, dy) =>
h.toEcef({
lon: AUSTIN.lon + 0.0008 + dx * 0.0003,
lat: AUSTIN.lat + 0.0006 + dy * 0.0003,
height: 0,
});
const members = [
['a', at(0, 0)],
['b', at(1, 0)],
['c', at(0, 1)],
['d', at(1, 1)],
];
const far = h.toEcef({
lon: AUSTIN.lon - 0.003,
lat: AUSTIN.lat - 0.002,
height: 0,
});
set.set([
...members.map(([id, pos]) => ({
id,
pos,
image: DOT,
size: [16, 16],
meta: { m: id },
})),
{ id: 'far', pos: far, image: DOT, size: [16, 16] },
]);
await drawn(h, r);
await settled(r);
await drawn(h, r);
ok(counts.includes(4), 'the icon is drawn for its count');
const mean = members.reduce(
(m, [, p]) => ({
x: m.x + p.x / members.length,
y: m.y + p.y / members.length,
z: m.z + p.z / members.length,
}),
{ x: 0, y: 0, z: 0 },
);
const s = r.query.project(mean);
ok(s, 'the cluster projects');
const hit = r.query.pick(s.x, s.y);
deepEqual(
[hit?.set, hit?.id, hit?.meta],
['conf:cluster', 'a', { m: 'a' }],
'pick gives the seed, with its own meta',
);
ok(hit?.position, 'at a position');
nearVec(hit.position, mean, 1, 'the cluster’s position');
const drilled = r.query
.drillPick(s.x, s.y)
.filter((x) => x.set === 'conf:cluster');
deepEqual(
drilled.map((x) => [x.id, x.meta?.m]),
members.map(([id]) => [id, id]),
'drillPick gives every member, seed first',
);
const sf = r.query.project(far);
equal(r.query.pick(sf.x, sf.y)?.id, 'far', 'an icon on its own');
await overAustin(h, r, 300);
r.camera.setView({
destination: {
lon: AUSTIN.lon + 0.00095,
lat: AUSTIN.lat + 0.00075,
height: 300,
},
orientation: { heading: 0, pitch: -Math.PI / 2, roll: 0 },
});
await drawn(h, r);
await settled(r);
await drawn(h, r);
for (const [id, pos] of members) {
const m = r.query.project(pos);
ok(m, `${id} projects`);
deepEqual(
r.query
.drillPick(m.x, m.y)
.filter((x) => x.set === 'conf:cluster')
.map((x) => x.id),
[id],
`${id} on its own once apart`,
);
}
set.dispose();
},
{ capability: 'cluster' },
),
check(
'draw.icons.update',
'an upserted icon keeps drawing, as it now is, from the next frame: picked at its new size with its new meta, even while a new image loads; a removed one is gone',
async (h, r) => {
await overAustin(h, r);
const set = r.draw.icons({ id: 'conf:icons-update' });
const pos = h.toEcef({ ...AUSTIN, height: 0 });
const icon = (extra = {}) => ({
id: 'one',
pos,
image: DOT,
size: [16, 16],
meta: { n: 1 },
...extra,
});
set.set([icon()]);
await drawn(h, r);
await settled(r);
const s = r.query.project(pos);
ok(s, 'the icon projects');
equal(r.query.pick(s.x, s.y)?.id, 'one', 'drawn and picked');
const off = () => r.query.pick(s.x + 20, s.y);
ok(off()?.set !== 'conf:icons-update', 'not picked 20 px off');
// Not settled again: a restyle keeps drawing, with no reload.
set.upsert([
icon({ size: [64, 64], color: '#00ff00', meta: { n: 2 } }),
]);
await drawn(h, r);
const hit = off();
equal(hit?.id, 'one', 'picked at its new size in the next frame');
deepEqual(hit?.meta, { n: 2 }, 'with its new meta');
// A new image keeps the icon drawn while it loads.
set.upsert([
icon({
size: [64, 64],
meta: { n: 3 },
image: { svg: DOT.svg.replace('#fff', '#ff0') },
}),
]);
await drawn(h, r);
equal(off()?.id, 'one', 'a new image: still drawn in the next frame');
await settled(r);
deepEqual(off()?.meta, { n: 3 }, 'and drawn with it once loaded');
set.remove(['one']);
await drawn(h, r);
const gone = r.query.pick(s.x, s.y);
ok(!gone || gone.set !== 'conf:icons-update', 'removed: not picked');
set.dispose();
},
),
check(
'draw.icons.distance',
'icons scale, fade and show by eye distance',
async (h, r) => {
await overAustin(h, r);
const set = r.draw.icons({ id: 'conf:icons-distance' });
const pos = h.toEcef({ ...AUSTIN, height: 0 });
const icon = (extra = {}) => ({
id: 'one',
pos,
image: DOT,
size: [16, 16],
...extra,
});
set.set([icon()]);
await drawn(h, r);
await settled(r);
const s = r.query.project(pos);
ok(s, 'the icon projects');
const at = (dx) => r.query.pick(s.x + dx, s.y);
const mine = (hit) => hit?.set === 'conf:icons-distance';
ok(mine(at(0)) && !mine(at(20)), 'drawn at its size');
// The eye is 2 km off: held at the curve's near value.
const curve = (value) => ({
near: 1e4,
nearValue: value,
far: 1e7,
farValue: value,
});
set.upsert([icon({ scaleByDistance: curve(4) })]);
await drawn(h, r);
await settled(r);
ok(mine(at(20)), 'scaled up by distance: picked 20 px off');
set.upsert([icon({ fadeByDistance: curve(0) })]);
await drawn(h, r);
ok(!mine(at(0)), 'faded out by distance: not drawn');
set.upsert([icon({ displayRange: [0, 100] })]);
await drawn(h, r);
ok(!mine(at(0)), 'out of its display range: not drawn');
set.upsert([icon({ displayRange: [0, 1e6] })]);
await drawn(h, r);
ok(mine(at(0)), 'in its display range: drawn');
set.dispose();
},
),
check(
'draw.lines.depthFail',
'a line dashed behind the surface draws, moves in place and changes back to solid',
async (h, r) => {
await overAustin(h, r);
const lines = r.draw.lines({ id: 'conf:line-dash' });
const at = (dLon, height) =>
h.toEcef({ lon: AUSTIN.lon + dLon, lat: AUSTIN.lat, height });
const band = (height, extra = {}) => ({
id: 'band',
positions: [at(-0.002, 50), at(0.002, height)],
widthPx: 3,
mode: 'geodesic',
style: { kind: 'dash', color: [1, 1, 0, 0.9], length: 16 },
depthFail: { kind: 'dash', color: [0, 1, 1, 0.35], length: 16 },
...extra,
});
lines.set([band(-200)]);
await drawn(h, r);
equal(lines.size(), 1, 'held');
lines.upsert([band(-100)]);
await drawn(h, r);
equal(lines.size(), 1, 'moved in place, not added');
lines.upsert([
band(-100, { depthFail: { kind: 'solid', color: [0, 1, 1, 0.35] } }),
]);
await drawn(h, r);
equal(lines.size(), 1, 'solid behind the surface again');
lines.dispose();
},
),
check(
'draw.lines.settled',
'solid lines in space left unchanged for many frames still pick, hide, recolour and move in place',
async (h, r) => {
await overAustin(h, r);
const at = (dLon, dLat, height = 300) =>
h.toEcef({ lon: AUSTIN.lon + dLon, lat: AUSTIN.lat + dLat, height });
const lines = r.draw.lines({ id: 'conf:line-settled' });
const mine = (pos, id) => {
const s = r.query.project(pos);
return Boolean(
s &&
r.query
.drillPick(s.x, s.y)
.some((hit) => hit.set === 'conf:line-settled' && hit.id === id),
);
};
const until = async (test) => {
for (let i = 0; i < 300; i++) {
await drawn(h, r, 1);
if (test()) return true;
}
return false;
};
const line = (id, dLat, extra = {}) => ({
id,
positions: [at(-0.003, dLat), at(0.003, dLat)],
widthPx: 8,
mode: '3d',
style: { kind: 'solid', color: [1, 0.4, 0.1, 1] },
...extra,
});
lines.set([
line('a', 0.002),
line('b', -0.002, {
style: { kind: 'solid', color: [0.1, 0.6, 1, 0.6] },
}),
]);
ok(await until(() => mine(at(0, 0.002), 'a')), 'drawn');
// Long enough for a renderer to draw unchanged lines another way.
await drawn(h, r, 120);
ok(mine(at(0, 0.002), 'a'), 'still picks once settled');
ok(mine(at(0, -0.002), 'b'), 'a translucent one too');
lines.upsert([line('a', 0.002, { show: false })]);
await drawn(h, r);
ok(!mine(at(0, 0.002), 'a'), 'hidden in place');
ok(mine(at(0, -0.002), 'b'), 'the other still drawn');
lines.upsert([
line('a', 0.002, {
style: { kind: 'solid', color: [0.2, 1, 0.2, 1] },
}),
]);
ok(await until(() => mine(at(0, 0.002), 'a')), 'shown and recoloured');
await drawn(h, r, 120);
lines.upsert([line('b', -0.004)]);
ok(
await until(
() => mine(at(0, -0.004), 'b') && !mine(at(0, -0.002), 'b'),
),
'moved',
);
equal(lines.size(), 2, 'held');
lines.dispose();
await drawn(h, r);
ok(!mine(at(0, 0.002), 'a'), 'gone with its set');
},
),
check(
'draw.shapes.drapedRotation',
'a draped rectangle with an image fill draws turned by its rotation, picks there, and hides in place',
async (h, r) => {
await overAustin(h, r);
const at = (dLon, dLat = 0) =>
h.toEcef({ lon: AUSTIN.lon + dLon, lat: AUSTIN.lat + dLat });
const shapes = r.draw.shapes({ id: 'conf:overlay' });
const mine = (pos) => {
const s = r.query.project(pos);
return Boolean(
s &&
r.query
.drillPick(s.x, s.y)
.some(
(hit) => hit.set === 'conf:overlay' && hit.id === 'overlay',
),
);
};
// Wide east to west; a quarter turn stands it north to south.
const overlay = (rotation, extra = {}) => ({
id: 'overlay',
geometry: {
kind: 'rectangle',
rect: {
west: AUSTIN.lon - 0.004,
south: AUSTIN.lat - 0.001,
east: AUSTIN.lon + 0.004,
north: AUSTIN.lat + 0.001,
},
...(rotation === undefined ? {} : { rotation }),
},
fill: { image: PIXEL_PNG },
height: 'clampGround',
...extra,
});
const until = async (test) => {
for (let i = 0; i < 300; i++) {
await drawn(h, r, 1);
if (test()) return true;
}
return false;
};
shapes.set([overlay(undefined)]);
// A draped fill can reach the pick pass tile by tile, so wait for
// both ends, as the turned case below waits for its own.
ok(await until(() => mine(at(0))), 'unturned, it draws');
ok(await until(() => mine(at(0.003))), 'unturned, it is wide');
ok(!mine(at(0, 0.003)), 'unturned, it is not tall');
shapes.set([overlay(Math.PI / 2)]);
ok(
await until(() => mine(at(0, 0.003)) && !mine(at(0.003))),
'a quarter turn stands it north to south',
);
ok(mine(at(0)), 'turned about its centre');
shapes.upsert([overlay(Math.PI / 2, { show: false })]);
await drawn(h, r);
ok(!mine(at(0)), 'hidden');
shapes.upsert([overlay(Math.PI / 2)]);
ok(await until(() => mine(at(0, 0.003))), 'shown again');
equal(shapes.size(), 1, 'held');
shapes.dispose();
await drawn(h, r);
ok(!mine(at(0)), 'gone with its set');
},
),
check(
'draw.shapes.clamped',
'clamped shapes of every kind draw: outlined, outline only, extruded and walls, and the filled ones are picked',
async (h, r) => {
await overAustin(h, r, 3000);
const shapes = r.draw.shapes({ id: 'conf:clamped-shapes' });
const box = (dLon, dLat, d = 0.0012) => ({
west: AUSTIN.lon + dLon - d,
south: AUSTIN.lat + dLat - d,
east: AUSTIN.lon + dLon + d,
north: AUSTIN.lat + dLat + d,
});
shapes.set([
{
id: 'outlined',
geometry: { kind: 'rectangle', rect: box(-0.004, 0.002) },
fill: [1, 0, 0, 0.6],
outline: '#ffffff',
outlineWidth: 3,
height: 'clampGround',
},
{
id: 'rim',
geometry: { kind: 'rectangle', rect: box(0.004, 0.002) },
outline: '#00ff00',
outlineWidth: 3,
outlineOnly: true,
height: 'clampGround',
},
{
id: 'tower',
geometry: {
kind: 'ellipse',
center: { lon: AUSTIN.lon - 0.004, lat: AUSTIN.lat - 0.003 },
semiMajor: 120,
semiMinor: 120,
},
fill: '#0000ff',
outline: '#ffffff',
extrudeHeight: 300,
height: 'clampGround',
},
{
id: 'fence',
geometry: {
kind: 'wall',
positions: [
{
lon: AUSTIN.lon + 0.003,
lat: AUSTIN.lat - 0.003,
height: 40,
},
{
lon: AUSTIN.lon + 0.005,
lat: AUSTIN.lat - 0.003,
height: 40,
},
],
},
fill: '#ffff00',
height: 'clampGround',
},
]);
equal(shapes.size(), 4, 'every kind is taken');
await settled(r);
await drawn(h, r);
for (const [id, lon, lat, height] of [
['outlined', AUSTIN.lon - 0.004, AUSTIN.lat + 0.002, 0],
['tower', AUSTIN.lon - 0.004, AUSTIN.lat - 0.003, 300],
]) {
const s = r.query.project(h.toEcef({ lon, lat, height }));
ok(s, `${id} projects`);
ok(
r.query
.drillPick(s.x, s.y)
.some(
(hit) => hit.set === 'conf:clamped-shapes' && hit.id === id,
),
`${id} drawn and picked`,
);
}
shapes.dispose();
},
),
check(
'draw.shapes.resize',
'a clamped ellipse whose radius alone is upserted draws at the new radius, growing and shrinking',
async (h, r) => {
const shapes = r.draw.shapes({ id: 'conf:rings' });
const ring = (radius) => ({
id: 'ring',
geometry: {
kind: 'ellipse',
center: { lon: AUSTIN.lon, lat: AUSTIN.lat },
semiMajor: radius,
semiMinor: radius,
},
fill: [0.5, 0.9, 1, 0.6],
height: 'clampGround',
});
// Metres east of the centre, at its latitude.
const east = (m) =>
h.toEcef({
lon:
AUSTIN.lon +
m / (111320 * Math.cos((AUSTIN.lat * Math.PI) / 180)),
lat: AUSTIN.lat,
});
const covers = (m) => {
const s = r.query.project(east(m));
return Boolean(
s &&
r.query
.drillPick(s.x, s.y)
.some((hit) => hit.set === 'conf:rings' && hit.id === 'ring'),
);
};
const until = async (test) => {
for (let i = 0; i < 300; i++) {
await drawn(h, r, 1);
if (test()) return true;
}
return false;
};
await overAustin(h, r, 4000);
shapes.set([ring(200)]);
ok(
await until(() => covers(150) && !covers(260)),
'at 200 m it reaches 150 m, not 260 m',
);
shapes.upsert([ring(400)]);
ok(
await until(() => covers(300) && !covers(460)),
'at 400 m it reaches 300 m, not 460 m',
);
shapes.upsert([ring(200)]);
ok(await until(() => covers(150) && !covers(260)), 'back at 200 m');
shapes.dispose();
await drawn(h, r);
ok(!covers(0), 'gone with its set');
},
),
check(
'draw.lines.styles',
'flow lines draw draped and in space, and a line with a depth-fail colour moves every frame, without stopping the frame or picks',
async (h, r) => {
await overAustin(h, r);
const lines = r.draw.lines({ id: 'conf:line-styles' });
const at = (dLon, height = 0) =>
h.toEcef({ lon: AUSTIN.lon + dLon, lat: AUSTIN.lat, height });
const flow = {
kind: 'flow',
color: [0.2, 0.8, 1, 0.95],
repeat: 8,
duty: 0.5,
speed: 1,
};
const head = (height) => ({
id: 'head',
positions: [at(-0.002, 50), at(0.002, height)],
widthPx: 3,
mode: '3d',
style: { kind: 'solid', color: '#ff00ff' },
depthFail: { kind: 'solid', color: [1, 0, 1, 0.45] },
});
lines.set([
{
id: 'route',
positions: [at(-0.003), at(0), at(0.003)],
widthPx: 9,
mode: 'draped',
clampTo: 'both',
style: flow,
},
{
id: 'air',
positions: [at(-0.003, 200), at(0.003, 200)],
widthPx: 4,
mode: '3d',
style: flow,
},
head(100),
]);
equal(lines.size(), 3, 'every line held');
for (let i = 0; i < 4; i++) {
lines.upsert([head(100 + 50 * i)]);
await drawn(h, r, 1);
}
equal(lines.size(), 3, 'moved in place, not added');
lines.upsert([{ ...head(300), show: false }]);
await drawn(h, r);
const points = r.draw.points({ id: 'conf:line-styles-points' });
const pos = at(0, 0);
points.set([{ id: 'p', pos, pixelSize: 16, color: '#ff0000' }]);
await drawn(h, r);
const s = r.query.project(pos);
ok(s, 'the point projects');
equal(
r.query
.drillPick(s.x, s.y)
.find((hit) => hit.set === 'conf:line-styles-points')?.id,
'p',
'picks still find what is drawn among the lines',
);
lines.clear();
await drawn(h, r);
equal(lines.size(), 0, 'cleared');
points.dispose();
lines.dispose();
},
),
check(
'draw.lines.outline',
'a solid line’s outline is `widthPx` in all, half on each side, inside the line’s width',
async (h, r) => {
await overAustin(h, r);
const lines = r.draw.lines({ id: 'conf:line-outline' });
const at = (dLon) =>
h.toEcef({ lon: AUSTIN.lon + dLon, lat: AUSTIN.lat, height: 200 });
// 20 px wide with an outline of 8: 4 px of red each side of 12 px
// of green. Read as 8 px each side, it would leave 4 px of green.
lines.set([
{
id: 'l',
positions: [at(-0.004), at(0.004)],
widthPx: 20,
mode: '3d',
style: {
kind: 'solid',
color: '#00ff00',
outline: { color: '#ff0000', widthPx: 8 },
},
},
]);
await drawn(h, r);
await settled(r);
r.frame.renderNow();
const s = r.query.project(at(0));
ok(s, 'the line projects');
const half = 30;
const image = r.readPixels({
crop: {
x: Math.round(s.x) - 2,
y: Math.round(s.y) - half,
width: 5,
height: 2 * half + 1,
},
});
// The middle column, top to bottom: r(ed), g(reen) or - (neither).
let column = '';
for (let row = 0; row < image.height; row++) {
const i = (row * image.width + 2) * 4;
const [red, green, blue] = image.data.slice(i, i + 3);
column +=
red > 160 && green < 100 && blue < 100
? 'r'
: green > 160 && red < 100 && blue < 100
? 'g'
: '-';
}
lines.dispose();
if (h.pixels === false)
return { skip: 'this harness reads no drawn pixels' };
const runs = column.match(/r+|g+/g) ?? [];
const sides = runs.filter((run) => run[0] === 'r');
const core = runs.find((run) => run[0] === 'g') ?? '';
equal(sides.length, 2, `an outline each side (${column})`);
for (const side of sides)
ok(
side.length >= 3 && side.length <= 5,
`4 px of outline each side, not ${side.length} (${column})`,
);
ok(
core.length >= 10 && core.length <= 14,
`12 px of line between them, not ${core.length} (${column})`,
);
},
),
check(
'draw.sets.blend',
'a set’s blend draws its items as it says, changed live: none blends translucent items; opaque ignores alpha; translucent blends; additive adds colour, still behind what is nearer',
async (h, r) => {
if (h.pixels === false)
return { skip: 'this harness reads no drawn pixels' };
await overAustin(h, r);
const rect = (dLon, dLat, d) => ({
west: AUSTIN.lon + dLon - d,
south: AUSTIN.lat + dLat - d,
east: AUSTIN.lon + dLon + d,
north: AUSTIN.lat + dLat + d,
});
// Green under it all; blue nearer the eye over the second spot.
const under = r.draw.shapes({ id: 'conf:blend-under' });
under.set([
{
id: 'green',
geometry: { kind: 'rectangle', rect: rect(0, 0, 0.003), height: 0 },
fill: '#00ff00',
height: 'absolute',
},
{
id: 'blue',
geometry: {
kind: 'rectangle',
rect: rect(0.0015, 0, 0.0004),
height: 300,
},
fill: '#0000ff',
height: 'absolute',
},
]);
const spotA = h.toEcef({ ...AUSTIN, height: 50 });
const spotB = h.toEcef({
lon: AUSTIN.lon + 0.0015,
lat: AUSTIN.lat,
height: 50,
});
const pixel = (pos) => {
r.frame.renderNow();
const s = r.query.project(pos);
const image = r.readPixels({
crop: {
x: Math.round(s.x) - 1,
y: Math.round(s.y) - 1,
width: 3,
height: 3,
},
});
const i = (1 * image.width + 1) * 4;
return [...image.data.slice(i, i + 3)];
};
const kinds = {
points: (alpha) => [
{ id: 'a', pos: spotA, pixelSize: 24, color: [1, 0, 0, alpha] },
{ id: 'b', pos: spotB, pixelSize: 24, color: [1, 0, 0, alpha] },
],
icons: (alpha) => [
{
id: 'a',
pos: spotA,
image: SQUARE,
size: [24, 24],
color: [1, 0, 0, alpha],
},
{
id: 'b',
pos: spotB,
image: SQUARE,
size: [24, 24],
color: [1, 0, 0, alpha],
},
],
lines: (alpha) => [
{
id: 'l',
positions: [
h.toEcef({
lon: AUSTIN.lon - 0.001,
lat: AUSTIN.lat,
height: 50,
}),
h.toEcef({
lon: AUSTIN.lon + 0.0025,
lat: AUSTIN.lat,
height: 50,
}),
],
widthPx: 24,
mode: '3d',
style: { kind: 'solid', color: [1, 0, 0, alpha] },
},
],
shapes: (alpha) =>
[
['a', 0],
['b', 0.0015],
].map(([id, dLon]) => ({
id,
geometry: {
kind: 'rectangle',
rect: rect(dLon, 0, 0.0002),
height: 50,
},
fill: [1, 0, 0, alpha],
height: 'absolute',
})),
};
await drawn(h, r);
await settled(r);
const [, green] = pixel(spotA);
ok(green > 150, `the green under it draws (${green})`);
const show = (rgb) => `(${rgb.join(', ')})`;
try {
for (const [kind, items] of Object.entries(kinds)) {
const set = r.draw[kind]({ id: `conf:blend-${kind}` });
try {
set.set(items(0.5));
await drawn(h, r);
await settled(r);
let a = pixel(spotA);
ok(
a[0] > 60 && a[1] > 40 && a[1] < green - 30,
`${kind}, no blend: half red over green ${show(a)}`,
);
set.setOptions({ blend: 'opaque' });
await drawn(h, r);
a = pixel(spotA);
ok(
a[0] > 150 && a[1] < 60,
`${kind}, opaque: red, its alpha ignored ${show(a)}`,
);
set.setOptions({ blend: 'translucent' });
await drawn(h, r);
a = pixel(spotA);
ok(
a[0] > 60 && a[1] > 40 && a[1] < green - 30,
`${kind}, translucent: half red over green ${show(a)}`,
);
set.setOptions({ blend: 'additive' });
await drawn(h, r);
a = pixel(spotA);
ok(
a[0] > 60 && a[1] > green - 30,
`${kind}, additive: red added to green ${show(a)}`,
);
const b = pixel(spotB);
ok(
b[0] < 60 && b[2] > 150,
`${kind}, additive: behind the nearer blue ${show(b)}`,
);
set.set(items(1));
set.setOptions({ blend: 'translucent' });
await drawn(h, r);
a = pixel(spotA);
ok(
a[0] > 150 && a[1] < 60,
`${kind}, translucent at alpha 1: red ${show(a)}`,
);
} finally {
set.dispose();
}
}
} finally {
under.dispose();
}
},
),
check(
'draw.lines.drape',
'draped glow, dash and arrow lines draw and pick; a revealed line draws only its first part; a draped line and a clamped point that move every frame are drawn where they now are in the next frame',
async (h, r) => {
await overAustin(h, r);
const at = (dLon, dLat = 0) =>
h.toEcef({ lon: AUSTIN.lon + dLon, lat: AUSTIN.lat + dLat });
const lines = r.draw.lines({ id: 'conf:line-drape' });
const mine = (pos, id) => {
const s = r.query.project(pos);
return Boolean(
s &&
r.query
.drillPick(s.x, s.y)
.some((hit) => hit.set === 'conf:line-drape' && hit.id === id),
);
};
lines.set([
{
id: 'glow',
positions: [at(-0.003, 0.002), at(0.003, 0.002)],
widthPx: 12,
mode: 'draped',
style: { kind: 'glow', color: [1, 0.6, 0.2, 1], power: 0.25 },
},
{
id: 'dash',
positions: [at(-0.003, -0.002), at(0.003, -0.002)],
widthPx: 12,
mode: 'draped',
style: {
kind: 'dash',
color: [1, 0.6, 0.2, 1],
length: 16,
},
},
{
id: 'reveal',
positions: [at(-0.003), at(0.003)],
widthPx: 12,
mode: 'draped',
style: { kind: 'solid', color: '#20e7f2' },
revealFraction: 0.5,
},
{
id: 'arrow',
positions: [at(-0.003, -0.004), at(0.003, -0.004)],
widthPx: 16,
mode: 'draped',
style: { kind: 'arrow', color: [0.5, 0.9, 1, 0.95] },
},
]);
await drawn(h, r);
await settled(r);
await drawn(h, r);
ok(mine(at(0, 0.002), 'glow'), 'a draped glow line picks');
ok(mine(at(0, -0.002), 'dash'), 'a draped dash line picks');
ok(mine(at(-0.002, -0.004), 'arrow'), 'a draped arrow picks');
ok(mine(at(-0.0015), 'reveal'), 'revealed: its first half draws');
ok(!mine(at(0.0015), 'reveal'), 'revealed: its second half does not');
lines.upsert([
{
id: 'reveal',
positions: [at(-0.003), at(0.003)],
widthPx: 12,
mode: 'draped',
style: { kind: 'solid', color: '#20e7f2' },
revealFraction: 1,
},
]);
await drawn(h, r);
ok(mine(at(0.0015), 'reveal'), 'revealed whole: all of it draws');
// A draped line growing every frame. Its first moves may take a
// few frames while the renderer readies itself to build it at once.
const growing = (end) => ({
id: 'growing',
positions: [at(-0.003, 0.004), at(end, 0.004)],
widthPx: 12,
mode: 'draped',
style: { kind: 'solid', color: '#ff00ff' },
});
lines.upsert([growing(-0.002)]);
let ready = false;
for (let i = 0; i < 300 && !ready; i++) {
lines.upsert([growing(-0.002 + (i % 2) * 1e-6)]);
await drawn(h, r, 1);
ready = mine(at(-0.0025, 0.004), 'growing');
}
ok(ready, 'the growing line draws');
const points = r.draw.points({ id: 'conf:line-drape-point' });
const front = (dLon) => ({
id: 'front',
pos: { lon: AUSTIN.lon + dLon, lat: AUSTIN.lat + 0.003, height: 0 },
height: 'clampGround',
pixelSize: 16,
color: '#ff0000',
// On the surface it would be half under it.
disableDepthTest: Infinity,
});
const point = (dLon) => {
const s = r.query.project(at(dLon, 0.003));
return Boolean(
s &&
r.query
.drillPick(s.x, s.y)
.some((hit) => hit.set === 'conf:line-drape-point'),
);
};
points.set([front(-0.002)]);
await drawn(h, r);
await settled(r);
await drawn(h, r);
ok(point(-0.002), 'the clamped point draws');
for (let i = 1; i <= 4; i++) {
const end = -0.002 + i * 0.001;
lines.upsert([growing(end)]);
points.upsert([front(-0.002 + i * 0.001)]);
await drawn(h, r, 1);
ok(
mine(at(end - 0.0004, 0.004), 'growing'),
`grown, frame ${i}: drawn to its new end`,
);
ok(
point(-0.002 + i * 0.001),
`moved, frame ${i}: the point is there`,
);
ok(
i < 2 || !point(-0.002 + (i - 2) * 0.001),
`moved, frame ${i}: not where it was`,
);
}
equal(lines.size(), 5, 'every line held');
points.dispose();
lines.dispose();
},
),
check(
'draw.lines.segments',
'a draped line takes segment colours and shows, changed every frame in place, without stopping the frame or picks',
async (h, r) => {
await overAustin(h, r);
const lines = r.draw.lines({
id: 'conf:line-segments',
pickable: false,
});
const at = (dLon) =>
h.toEcef({ lon: AUSTIN.lon + dLon, lat: AUSTIN.lat, height: 0 });
const trail = (frame) => ({
id: 'trail',
positions: [at(-0.003), at(-0.001), at(0.001), at(0.003)],
widthPx: 5,
mode: 'draped',
clampTo: 'both',
style: { kind: 'solid', color: '#ffffff' },
segmentColors: [0, 1, 2].map((i) => [
0.2,
0.9,
0.5,
((frame + i) % 4) / 4 + 0.2,
]),
segmentShow: [0, 1, 2].map((i) => i <= frame % 3),
});
lines.set([trail(0)]);
await settled(r);
for (let i = 1; i < 5; i++) {
lines.upsert([trail(i)]);
await drawn(h, r, 1);
}
equal(lines.size(), 1, 'changed in place, not added');
const points = r.draw.points({ id: 'conf:line-segments-points' });
const pos = at(0);
points.set([{ id: 'p', pos, pixelSize: 16, color: '#ff0000' }]);
await drawn(h, r);
const s = r.query.project(pos);
ok(s, 'the point projects');
equal(
r.query
.drillPick(s.x, s.y)
.find((hit) => hit.set === 'conf:line-segments-points')?.id,
'p',
'picks still find what is drawn over the line',
);
points.dispose();
lines.dispose();
},
),
check(
'draw.lines.segmentStyles',
'every line mode and style takes segment colours and shows: a hidden segment is not picked, a shown one picks as its line',
async (h, r) => {
await overAustin(h, r, 3000);
const lines = r.draw.lines({ id: 'conf:segment-styles' });
const kinds = [
['3d', { kind: 'glow', color: '#ffffff', power: 0.3 }],
['geodesic', { kind: 'dash', color: '#ffffff', length: 16 }],
['draped', { kind: 'arrow', color: '#ffffff' }],
['3d', { kind: 'pattern', image: PIXEL_PNG, repeat: 4 }],
[
'draped',
{
kind: 'solid',
color: '#ffffff',
outline: { color: '#000000', widthPx: 4 },
},
],
];
// Off the canvas's centre row: the Cesium port does not pick draped
// lines at its exact centre.
const lat = (k) =>
AUSTIN.lat + 0.0008 + (k - (kinds.length - 1) / 2) * 0.0015;
const at = (k, dLon) =>
h.toEcef({
lon: AUSTIN.lon + dLon,
lat: lat(k),
height: kinds[k][0] === 'draped' ? 0 : 20,
});
const ends = [-0.006, -0.002, 0.002, 0.006];
const line = (k, shows) => ({
id: `l${k}`,
positions: ends.map((d) => at(k, d)),
widthPx: 12,
mode: kinds[k][0],
style: kinds[k][1],
segmentColors: ['#ff0000', '#00ff00', '#0000ff'],
segmentShow: shows,
});
lines.set(kinds.map((_, k) => line(k, [true, false, true])));
await settled(r);
await drawn(h, r);
const pickAt = (k, dLon) => {
const s = r.query.project(at(k, dLon));
ok(s, `line ${k} projects`);
return r.query
.drillPick(s.x, s.y)
.filter((hit) => hit.set === 'conf:segment-styles')
.map((hit) => hit.id);
};
kinds.forEach(([mode, style], k) => {
const what = `${mode} ${style.kind}`;
deepEqual(pickAt(k, -0.004), [`l${k}`], `${what}: shown segment`);
deepEqual(pickAt(k, 0), [], `${what}: hidden segment`);
});
lines.upsert(kinds.map((_, k) => line(k, [false, true, true])));
equal(lines.size(), kinds.length, 'changed in place, not added');
await drawn(h, r);
kinds.forEach(([mode, style], k) => {
const what = `${mode} ${style.kind}`;
deepEqual(pickAt(k, -0.004), [], `${what}: now hidden`);
deepEqual(pickAt(k, 0), [`l${k}`], `${what}: now shown`);
});
lines.dispose();
},
),
check(
'draw.points.update',
'an upserted point is drawn where it now is once drawn again, and shows only within its display range',
async (h, r) => {
await overAustin(h, r);
const set = r.draw.points({ id: 'conf:points-update' });
const a = h.toEcef({ ...AUSTIN, height: 0 });
const b = h.toEcef({ lon: AUSTIN.lon + 0.004, lat: AUSTIN.lat });
const point = (pos, extra = {}) => ({
id: 'one',
pos,
pixelSize: 16,
color: '#ff0000',
meta: { n: 1 },
...extra,
});
set.set([point(a)]);
await drawn(h, r);
const sa = r.query.project(a);
const sb = r.query.project(b);
ok(sa && sb, 'both places project');
const mine = (s) =>
r.query.pick(s.x, s.y)?.set === 'conf:points-update';
ok(mine(sa) && !mine(sb), 'drawn where it was put');
set.upsert([point(b, { meta: { n: 2 } })]);
await drawn(h, r);
ok(!mine(sa), 'moved: gone from where it was');
deepEqual(
r.query.pick(sb.x, sb.y)?.meta,
{ n: 2 },
'moved: picked where it now is, with its new meta',
);
// The eye is 2 km off.
set.upsert([point(b, { displayRange: [0, 100] })]);
await drawn(h, r);
ok(!mine(sb), 'out of its display range: not drawn');
set.upsert([point(b, { displayRange: [0, 1e6] })]);
await drawn(h, r);
ok(mine(sb), 'in its display range: drawn');
set.upsert([point(b, { displayRange: [1e4, 1e6] })]);
await drawn(h, r);
ok(!mine(sb), 'nearer than its display range: not drawn');
set.dispose();
},
),
check(
'draw.points.population',
'points added and removed one by one draw and pick on their own, the others staying where they are',
async (h, r) => {
await overAustin(h, r);
const set = r.draw.points({
id: 'conf:points-population',
blend: 'translucent',
});
const at = (k) =>
h.toEcef({ lon: AUSTIN.lon + 0.003 * k, lat: AUSTIN.lat });
const point = (k) => ({
id: `p${k}`,
pos: at(k),
pixelSize: 16,
color: [1, 0, 0, 0.9],
meta: { k },
});
const picked = (k) => {
const s = r.query.project(at(k));
const hit = s && r.query.pick(s.x, s.y);
return hit?.set === 'conf:points-population' ? hit.meta?.k : null;
};
set.upsert([point(0)]);
set.upsert([point(1), point(-1)]);
await drawn(h, r);
deepEqual([picked(-1), picked(0), picked(1)], [-1, 0, 1], 'all drawn');
set.remove(['p0']);
await drawn(h, r);
deepEqual(
[picked(-1), picked(0), picked(1)],
[-1, null, 1],
'removed: only that one is gone',
);
equal(set.size(), 2, 'two left');
set.upsert([point(0)]);
await drawn(h, r);
equal(picked(0), 0, 'added again: drawn again');
set.dispose();
},
),
check(
'draw.columns',
'column updates are rows: sized, picked, removed',
async (h, r) => {
await overAustin(h, r);
const set = r.draw.icons({ id: 'conf:columns' });
const a = h.toEcef({
lon: AUSTIN.lon - 0.003,
lat: AUSTIN.lat,
height: 0,
});
const b = h.toEcef({
lon: AUSTIN.lon + 0.003,
lat: AUSTIN.lat,
height: 0,
});
set.set([
{ id: 'a', pos: a, image: DOT, size: [16, 16] },
{ id: 'b', pos: b, image: DOT, size: [16, 16] },
]);
set.setColumns({
ids: ['a', 'b'],
positions: new Float64Array([b.x, b.y, b.z, a.x, a.y, a.z]),
meta: [{ k: 'a' }, { k: 'b' }],
});
await drawn(h, r);
equal(set.size(), 2, 'size');
const sa = r.query.project(a);
const hit = r.query
.drillPick(sa.x, sa.y)
.find((x) => x.set === 'conf:columns');
equal(hit?.id, 'b', 'b moved to a’s place');
deepEqual(hit?.meta, { k: 'b' }, 'meta from the columns');
set.remove(['a']);
equal(set.size(), 1, 'removed');
set.dispose();
},
{ capability: 'columns' },
),
check(
'draw.columns.shown',
'a row hidden by its column keeps its motion and resumes where it would be',
async (h, r) => {
if (!r.capabilities.has('motionSegments'))
return { skip: 'no motionSegments' };
await overAustin(h, r, 8000);
const t0 = r.frame.time();
const from = h.toEcef({ ...AUSTIN, lon: AUSTIN.lon - 0.02, height: 0 });
const to = h.toEcef({ ...AUSTIN, lon: AUSTIN.lon + 0.02, height: 0 });
const along = (f) => ({
x: from.x + (to.x - from.x) * f,
y: from.y + (to.y - from.y) * f,
z: from.z + (to.z - from.z) * f,
});
const set = r.draw.icons({
id: 'conf:shown',
motionClock: { kind: 'scene' },
});
set.set([
{
id: 'mover',
pos: from,
image: DOT,
size: [16, 16],
motion: { kind: 'lerp', from, to, t0, t1: t0 + 10000 },
},
]);
const pickAt = (p) => {
const s = r.query.project(p);
return r.query
.drillPick(s.x, s.y)
.some((x) => x.set === 'conf:shown');
};
const shown = (on) =>
set.setColumns({ ids: ['mover'], shown: new Uint8Array([on]) });
r.frame.setTime(t0 + 2000);
await drawn(h, r);
ok(pickAt(along(0.2)), 'moving before it is hidden');
shown(0);
r.frame.setTime(t0 + 4000);
await drawn(h, r);
ok(!pickAt(along(0.4)), 'hidden');
r.frame.setTime(t0 + 7000);
shown(1);
await drawn(h, r);
ok(pickAt(along(0.7)), 'shown again where its segment puts it now');
ok(!pickAt(from), 'not restarted');
set.dispose();
},
{ capability: 'columns' },
),
check(
'draw.models',
'a model set says when a model is ready',
async (h, r) => {
if (!h.assets?.model) return { skip: 'no model asset in this harness' };
const set = r.draw.models({ id: 'conf:models' });
const ready = [];
set.on('ready', (id) => ready.push(id));
set.set([
{
id: 'm',
pos: { ...AUSTIN, height: 0 },
url: h.assets.model,
orientation: { heading: 0, pitch: 0, roll: 0 },
},
]);
for (let i = 0; i < 600 && !ready.length; i++) await drawn(h, r, 1);
deepEqual(ready, ['m'], 'ready');
set.dispose();
},
{ capability: 'models' },
),
check(
'draw.models.loadFailed',
'a model set says when a model fails to load, and loads it when added again',
async (h, r) => {
if (!h.assets?.model || !h.assets?.missingModel)
return { skip: 'no missing model asset in this harness' };
const set = r.draw.models({ id: 'conf:models.loadFailed' });
const ready = [];
const failed = [];
set.on('ready', (id) => ready.push(id));
set.on('loadFailed', (id, message) => failed.push([id, message]));
const model = (id, url) => ({
id,
pos: { ...AUSTIN, height: 0 },
url,
orientation: { heading: 0, pitch: 0, roll: 0 },
});
const until = async (done) => {
for (let i = 0; i < 600 && !done(); i++) await drawn(h, r, 1);
};
set.set([
model('bad', h.assets.missingModel),
model('good', h.assets.model),
]);
await until(() => failed.length >= 1 && ready.length >= 1);
deepEqual(ready, ['good'], 'the good one is ready');
deepEqual(
failed.map(([id]) => id),
['bad'],
'the missing one failed',
);
ok(
typeof failed[0]?.[1] === 'string' && failed[0][1].length > 0,
'with a message',
);
equal(set.size(), 2, 'the failed item stays in the set');
// Removed and added again, it is tried at once, and fails again.
set.remove(['bad']);
set.upsert([model('bad', h.assets.missingModel)]);
await until(() => failed.length >= 2);
deepEqual(
failed.map(([id]) => id),
['bad', 'bad'],
'tried again when added again',
);
// Pointed at a url that loads, it is ready.
set.upsert([model('bad', h.assets.model)]);
await until(() => ready.length >= 2);
deepEqual(ready, ['good', 'bad'], 'a good url loads');
equal(failed.length, 2, 'no failure for a good url');
set.dispose();
},
{ capability: 'models' },
),
check(
'draw.models.update',
'a model moves, turns and restyles in place; only a new url loads it again',
async (h, r) => {
if (!h.assets?.model) return { skip: 'no model asset in this harness' };
await overAustin(h, r);
const set = r.draw.models({ id: 'conf:models.update' });
const ready = [];
set.on('ready', (id) => ready.push(id));
const here = h.toEcef({ ...AUSTIN, height: 0 });
const there = h.toEcef({
lon: AUSTIN.lon + 0.004,
lat: AUSTIN.lat,
height: 0,
});
const model = (pos, extra = {}) => ({
id: 'm',
pos,
url: h.assets.model,
orientation: { heading: 0, pitch: 0, roll: 0 },
minPixelSize: 96,
...extra,
});
const untilReady = async (count) => {
for (let i = 0; i < 600 && ready.length < count; i++)
await drawn(h, r, 1);
};
const picked = (pos) => {
const s = r.query.project(pos);
return (
s !== null &&
r.query.drillPick(s.x, s.y).some((hit) => hit.set === set.id)
);
};
set.set([model(here)]);
await untilReady(1);
deepEqual(ready, ['m'], 'ready once loaded');
await drawn(h, r);
await settled(r);
ok(picked(here), 'picked where it is');
set.upsert([
model(there, {
orientation: { heading: 1.2, pitch: 0.1, roll: 0.2 },
scale: 2,
shading: 'unlit',
tint: '#00ff00',
colorBlend: { mode: 'mix', amount: 0.5 },
environmentMap: false,
meta: { n: 2 },
}),
]);
await drawn(h, r, 4);
await settled(r);
deepEqual(ready, ['m'], 'moved and restyled without loading again');
ok(picked(there), 'picked where it moved to');
ok(!picked(here), 'not where it was');
const s = r.query.project(there);
const hit = r.query.drillPick(s.x, s.y).find((x) => x.set === set.id);
deepEqual(hit?.meta, { n: 2 }, 'its new meta');
set.upsert([model(there, { url: `${h.assets.model}?again` })]);
await untilReady(2);
deepEqual(ready, ['m', 'm'], 'a new url loads again');
await drawn(h, r);
await settled(r);
ok(picked(there), 'the new model is drawn');
equal(set.size(), 1, 'one model');
set.dispose();
},
{ capability: 'models' },
),
check(
'draw.models.tint',
'a model’s tint and colour blend change live',
async (h, r) => {
if (!h.assets?.model) return { skip: 'no model asset in this harness' };
await overAustin(h, r);
const set = r.draw.models({ id: 'conf:models.tint' });
const ready = [];
set.on('ready', (id) => ready.push(id));
const pos = h.toEcef({ ...AUSTIN, height: 0 });
const model = (extra) => ({
id: 'm',
pos,
url: h.assets.model,
orientation: { heading: 0, pitch: 0, roll: 0 },
minPixelSize: 160,
environmentMap: false,
...extra,
});
set.set([model({ shading: 'pbr' })]);
for (let i = 0; i < 600 && !ready.length; i++) await drawn(h, r, 1);
deepEqual(ready, ['m'], 'ready');
const s = r.query.project(pos);
// How many pixels of a patch at the model's centre `like` holds.
const count = async (like) => {
await drawn(h, r, 3);
await settled(r);
r.frame.renderNow();
const image = r.readPixels({
crop: {
x: Math.round(s.x) - 4,
y: Math.round(s.y) - 4,
width: 9,
height: 9,
},
});
let n = 0;
for (let i = 0; i < image.data.length; i += 4)
if (like(image.data[i], image.data[i + 1], image.data[i + 2])) n++;
return n;
};
const red = (r0, g, b) => r0 > 180 && g < 70 && b < 70;
const blue = (r0, g, b) => b > 180 && r0 < 70 && g < 70;
set.upsert([
model({
shading: 'unlit',
tint: '#ff0000',
colorBlend: { mode: 'replace' },
}),
]);
ok((await count(red)) >= 40, 'replaced by a red tint');
set.upsert([
model({
shading: 'unlit',
tint: '#0000ff',
colorBlend: { mode: 'replace' },
}),
]);
ok((await count(blue)) >= 40, 'the tint changes live');
set.upsert([
model({
shading: 'unlit',
tint: '#0000ff',
colorBlend: { mode: 'mix', amount: 0 },
}),
]);
equal(await count(blue), 0, 'mixed in at none, its own colour');
deepEqual(ready, ['m'], 'restyled without loading again');
set.dispose();
},
{ capability: 'models' },
),
check(
'draw.models.blend',
'a model set’s blend changes live, without loading again: additive adds the model’s colour to what is under it',
async (h, r) => {
if (!h.assets?.model) return { skip: 'no model asset in this harness' };
if (h.pixels === false)
return { skip: 'this harness reads no drawn pixels' };
await overAustin(h, r);
const d = 0.003;
const under = r.draw.shapes({ id: 'conf:models.blend-under' });
under.set([
{
id: 'green',
geometry: {
kind: 'rectangle',
rect: {
west: AUSTIN.lon - d,
south: AUSTIN.lat - d,
east: AUSTIN.lon + d,
north: AUSTIN.lat + d,
},
height: 0,
},
fill: '#00ff00',
height: 'absolute',
},
]);
const set = r.draw.models({ id: 'conf:models.blend' });
const ready = [];
set.on('ready', (id) => ready.push(id));
const pos = h.toEcef({ ...AUSTIN, height: 50 });
set.set([
{
id: 'm',
pos,
url: h.assets.model,
orientation: { heading: 0, pitch: 0, roll: 0 },
minPixelSize: 160,
environmentMap: false,
shading: 'unlit',
tint: '#ff0000',
colorBlend: { mode: 'replace' },
},
]);
try {
for (let i = 0; i < 600 && !ready.length; i++) await drawn(h, r, 1);
deepEqual(ready, ['m'], 'ready');
const s = r.query.project(pos);
const count = async (like) => {
await drawn(h, r, 3);
await settled(r);
r.frame.renderNow();
const image = r.readPixels({
crop: {
x: Math.round(s.x) - 4,
y: Math.round(s.y) - 4,
width: 9,
height: 9,
},
});
let n = 0;
for (let i = 0; i < image.data.length; i += 4)
if (like(image.data[i], image.data[i + 1], image.data[i + 2]))
n++;
return n;
};
const red = (r0, g, b) => r0 > 180 && g < 70 && b < 70;
const yellow = (r0, g, b) => r0 > 180 && g > 150 && b < 70;
ok((await count(red)) >= 40, 'no blend: red over green');
set.setOptions({ blend: 'additive' });
ok((await count(yellow)) >= 40, 'additive: red added to green');
equal(await count(red), 0, 'additive: none red alone');
set.setOptions({ blend: 'translucent' });
ok((await count(red)) >= 40, 'translucent at alpha 1: red');
set.setOptions({ blend: 'opaque' });
ok((await count(red)) >= 40, 'opaque: red');
deepEqual(ready, ['m'], 'never loaded again');
} finally {
set.dispose();
under.dispose();
}
},
{ capability: 'models' },
),
// --- Query -------------------------------------------------------------
check(
'query.projectMany',
'projectMany agrees with project; NaN behind the eye',
async (h, r) => {
await overAustin(h, r, 5000);
const points = [
h.toEcef({ ...AUSTIN, height: 0 }),
h.toEcef({ lon: AUSTIN.lon + 0.01, lat: AUSTIN.lat, height: 0 }),
h.toEcef({ ...AUSTIN, height: 1e6 }),
];
const source = new Float64Array(points.flatMap((p) => [p.x, p.y, p.z]));
const out = new Float32Array(points.length * 2);
r.query.projectMany(source, out);
for (let i = 0; i < 2; i++) {
const s = r.query.project(points[i]);
near(out[i * 2], s.x, 0.01, `x ${i}`);
near(out[i * 2 + 1], s.y, 0.01, `y ${i}`);
}
equal(r.query.project(points[2]), null, 'project behind the eye');
ok(
Number.isNaN(out[4]) && Number.isNaN(out[5]),
'projectMany behind the eye',
);
},
),
check(
'query.rays',
'pickRay starts at the eye; pickEllipsoid lies on its ray; pickGlobe agrees',
async (h, r) => {
await overAustin(h, r, 5000);
await settled(r);
const eye = r.camera.pose().position;
const ray = r.query.pickRay(640, 360);
nearVec(ray.origin, eye, 1e-3, 'ray origin');
near(
Math.hypot(ray.direction.x, ray.direction.y, ray.direction.z),
1,
1e-9,
'unit direction',
);
const ground = r.query.pickEllipsoid(640, 360);
ok(ground, 'center of the view meets the ellipsoid');
const t =
(ground.x - eye.x) * ray.direction.x +
(ground.y - eye.y) * ray.direction.y +
(ground.z - eye.z) * ray.direction.z;
nearVec(
ground,
{
x: eye.x + ray.direction.x * t,
y: eye.y + ray.direction.y * t,
z: eye.z + ray.direction.z * t,
},
0.01,
'on the ray',
);
const s = r.query.project(ground);
nearVec(s, { x: 640, y: 360 }, 0.5, 'projects back to the pixel');
// A bare globe: the globe surface is the ellipsoid.
nearVec(
r.query.pickGlobe(ray),
ground,
0.5,
'pickGlobe meets the globe there',
);
const up = { origin: eye, direction: ray.direction };
up.direction = {
x: -ray.direction.x,
y: -ray.direction.y,
z: -ray.direction.z,
};
equal(r.query.pickGlobe(up), null, 'a ray away from the globe misses');
},
),
check(
'query.heights',
'heights: a cached height now, async samples per point, misses as null',
async (h, r) => {
if (!h.scriptHeights)
return { skip: 'no scripted heights in this harness' };
h.scriptHeights(r, (point) => (point.lon > 0 ? null : 123.5));
const [hit, miss] = await r.query.sampleHeight([
{ ...AUSTIN },
{ lon: 10, lat: 10 },
]);
near(hit.height, 123.5, 0.01, 'sampled height');
ok(hit.confidence > 0 && hit.confidence <= 1, 'confidence in (0, 1]');
ok(['tiles', 'terrain', 'ellipsoid'].includes(hit.source), 'source');
ok(['visible', 'finest'].includes(hit.lod), 'lod');
equal(miss, null, 'a miss is null');
h.scriptHeights(r, (point, against) =>
against === 'tiles' ? 300 : 123.5,
);
const there = { lon: AUSTIN.lon + 0.5, lat: AUSTIN.lat };
const [terrain] = await r.query.sampleHeight([there], {
against: 'terrain',
});
const [tiles] = await r.query.sampleHeight([there], {
against: 'tiles',
});
near(terrain.height, 123.5, 0.01, 'terrain');
near(tiles.height, 300, 0.01, 'tiles, not the terrain answer');
h.scriptHeights(r, (point) => (point.lon > 0 ? null : 123.5));
const [plain] = await r.query.sampleHeight([{ ...AUSTIN }], {
mostDetailed: true,
});
equal(
plain.lod === 'finest',
r.capabilities.has('finestHeights'),
'finest only with finestHeights',
);
const [clamped] = await r.query.clampToSurface([
h.toEcef({ ...AUSTIN, height: 5000 }),
]);
nearVec(
clamped,
h.toEcef({ ...AUSTIN, height: 123.5 }),
0.05,
'clamped onto the surface',
);
},
{ capability: 'sampleHeight' },
),
check(
'query.heights.sets',
'draw sets are not ground to height queries unless they ask to be',
async (h, r) => {
await overAustin(h, r);
await drawn(h, r);
await settled(r);
const point = { ...AUSTIN };
const before = await r.query.sampleHeight([point]);
const shapes = r.draw.shapes({ id: 'conf:not-ground' });
shapes.set([
{
id: 'tower',
geometry: {
kind: 'polygon',
rings: [
[
[-0.001, -0.001],
[0.001, -0.001],
[0.001, 0.001],
[-0.001, 0.001],
].map(([dLon, dLat]) => ({
lon: AUSTIN.lon + dLon,
lat: AUSTIN.lat + dLat,
height: 0,
})),
],
},
extrudeHeight: 1000,
fill: '#888',
},
]);
const points = r.draw.points({ id: 'conf:not-ground-points' });
points.set([
{
id: 'p',
pos: { ...AUSTIN, height: 800 },
pixelSize: 40,
color: '#f00',
},
]);
await drawn(h, r);
await settled(r);
const after = await r.query.sampleHeight([point]);
equal(after[0] === null, before[0] === null, 'answered as before');
if (after[0] && before[0])
near(
after[0].height,
before[0].height,
0.5,
'the same height with sets drawn over the point',
);
ok(after[0]?.source !== 'set', 'not answered from a set');
shapes.dispose();
points.dispose();
},
{ capability: 'sampleHeight' },
),
check(
'query.withoutCapability',
'without sampleHeight the height members answer null',
async (h) => {
const r = await h.create({
viewport: SCRIPT_VIEWPORT,
capabilities: CAPABILITIES.filter(
(c) => !['sampleHeight', 'pickPosition', 'rayCast'].includes(c),
),
});
if (!r) return { skip: 'this harness cannot drop capabilities' };
try {
equal(
r.query.sampleHeightNow({ ...AUSTIN }),
null,
'sampleHeightNow',
);
deepEqual(
await r.query.sampleHeight([{ ...AUSTIN }]),
[null],
'sampleHeight',
);
equal(r.query.pickPosition(640, 360), null, 'pickPosition');
equal(
await r.query.rayCast(r.query.pickRay(640, 360)),
null,
'rayCast',
);
} finally {
r.destroy();
}
},
),
check(
'query.occlusionTest',
'an occlusion test takes points and leaves the unanswered pending',
async (h) => {
const r = await h.create({ viewport: SCRIPT_VIEWPORT });
try {
const test = r.query.occlusionTest();
ok(
['async', 'sync', 'off'].includes(test.mode),
'mode is async, sync or off',
);
ok(test.maxPerFrame > 0, 'takes at least one point a frame');
const point = { pending: false, answered: false, lastHiddenAt: 0 };
test.beginFrame(0);
const taken = test.add(point, h.toEcef({ ...AUSTIN, height: 10 }));
equal(typeof taken, 'boolean', 'add says whether it took the point');
if (taken && test.mode === 'async')
ok(point.pending || point.answered, 'a point taken is under test');
test.endFrame();
test.reset();
test.destroy();
} finally {
r.destroy();
}
},
{ capability: 'occlusionTest' },
),
// --- Input -------------------------------------------------------------
check(
'input.lease',
'a lease leaves ambient subscribers only move and up; a new claim ends the old',
async (h, r) => {
if (!h.pointer) return { skip: 'no pointer in this harness' };
const ambient = [];
for (const type of POINTER_TYPES)
r.input.on(type, () => ambient.push(type));
const seen = [];
r.input.on('click', () => seen.push('ambient'));
const lease = r.input.claimPointer('tool');
for (const type of POINTER_TYPES) await h.pointer(r, type, 640, 360);
deepEqual(ambient, ['move', 'up'], 'ambient under a lease');
seen.length = 0;
r.input.on('click', () => seen.push('tool'), { lease });
ok(!r.input.isPointerFree(), 'taken');
await h.pointer(r, 'click', 640, 360);
deepEqual(seen, ['tool'], 'only the lease holder hears the click');
const next = r.input.claimPointer('other');
ok(!lease.current, 'the old lease ended');
ok(next.current, 'the new one is current');
seen.length = 0;
await h.pointer(r, 'click', 640, 360);
deepEqual(seen, [], 'neither the ambient nor the ended lease');
next.release();
ok(r.input.isPointerFree(), 'free again');
await h.pointer(r, 'click', 640, 360);
deepEqual(seen, ['ambient'], 'ambient again');
},
),
check(
'input.lease.grab',
'a lease with grab takes only the presses it grabs; wheel and the rest stay free',
async (h, r) => {
if (!h.pointer) return { skip: 'no pointer in this harness' };
const heard = [];
for (const type of POINTER_TYPES) {
r.input.on(type, () => heard.push(`ambient:${type}`));
}
const errors = [];
r.on('error', (e) => errors.push(e));
let throwing = false;
const lease = r.input.claimPointer('draw', {
grab: (down) => {
if (throwing) throw new Error('conformance grab');
return down.type === 'down' && down.position.x < 640;
},
});
for (const type of POINTER_TYPES)
r.input.on(type, () => heard.push(`tool:${type}`), { lease });
const press = async (x) => {
heard.length = 0;
for (const type of ['down', 'move', 'up', 'click'])
await h.pointer(r, type, x, 360);
return heard.slice();
};
deepEqual(
await press(100),
[
'tool:down',
'ambient:move',
'tool:move',
'ambient:up',
'tool:up',
'tool:click',
],
'a grabbed press is the tool’s; move and up go to both',
);
heard.length = 0;
await h.pointer(r, 'wheel', 100, 360, { delta: 1 });
deepEqual(
heard,
['ambient:wheel'],
'wheel is never grabbed, even after a grabbed press',
);
heard.length = 0;
await h.pointer(r, 'pinch', 100, 360, { delta: 1.1 });
deepEqual(heard, ['ambient:pinch'], 'nor is pinch');
deepEqual(
await press(1000),
[
'ambient:down',
'ambient:move',
'tool:move',
'ambient:up',
'tool:up',
'ambient:click',
],
'a press left alone goes to the others',
);
ok(lease.current, 'the lease stays out');
ok(!r.input.isPointerFree(), 'the pointer is not free');
throwing = true;
deepEqual(
(await press(100)).filter((x) => x.endsWith(':down')),
['ambient:down'],
'a throwing grab leaves the press to the others',
);
equal(errors.length, 1, 'and is reported');
lease.release();
},
),
check(
'input.lease.press',
'every event of a press goes where its down went, whatever the lease does meanwhile',
async (h, r) => {
if (!h.pointer) return { skip: 'no pointer in this harness' };
const heard = [];
for (const type of ['down', 'click', 'dblclick'])
r.input.on(type, () => heard.push(`ambient:${type}`));
const left = (down) => down.type === 'down' && down.position.x < 640;
const listen = (lease, name) => {
for (const type of ['down', 'up', 'click', 'dblclick'])
r.input.on(type, () => heard.push(`${name}:${type}`), { lease });
};
const at = async (x, ...types) => {
for (const type of types) await h.pointer(r, type, x, 360);
};
let lease = r.input.claimPointer('a', { grab: left });
listen(lease, 'a');
r.input.on('up', () => lease.release(), { lease });
heard.length = 0;
await at(100, 'down', 'up', 'click');
deepEqual(
heard,
['a:down', 'a:up'],
'a lease that ends on up takes the click with it: no one hears it',
);
heard.length = 0;
await at(1000, 'down');
lease = r.input.claimPointer('b', { grab: () => true });
listen(lease, 'b');
await at(1000, 'up', 'click');
deepEqual(
heard,
['ambient:down', 'b:up', 'ambient:click'],
'a press left to the others stays theirs when a lease is claimed mid-press (up goes to both)',
);
heard.length = 0;
await at(100, 'down', 'up', 'click', 'down', 'up', 'click', 'dblclick');
deepEqual(
heard.filter((x) => !x.endsWith(':up')),
['b:down', 'b:click', 'b:down', 'b:click', 'b:dblclick'],
'a grabbed double-click is the lease’s',
);
lease.release();
lease = r.input.claimPointer('c', { grab: left });
listen(lease, 'c');
heard.length = 0;
await at(100, 'down', 'up', 'click');
await at(1000, 'click');
deepEqual(
heard.filter((x) => !x.endsWith(':up')),
['c:down', 'c:click', 'ambient:click'],
'a click with no press of its own is decided afresh',
);
lease.release();
let latest = r.input.claimPointer('d', { grab: () => true });
r.input.on(
'down',
() => {
heard.push('d:down');
latest = r.input.claimPointer('e', { grab: () => false });
},
{ lease: latest },
);
r.input.on('down', () => heard.push('latest:down'), {
lease: () => latest,
});
heard.length = 0;
await at(100, 'down');
deepEqual(
heard,
['d:down'],
'a lease claimed during delivery does not inherit the press',
);
latest.release();
let replacement = null;
const first = r.input.claimPointer('f', {
grab: () => {
replacement = r.input.claimPointer('g');
return true;
},
});
listen(first, 'f');
heard.length = 0;
await at(100, 'down');
listen(replacement, 'g');
await at(100, 'up', 'click');
deepEqual(
heard.filter((x) => !x.endsWith(':up')),
[],
'a press grabbed by a lease its grab replaced belongs to that ended lease: no one',
);
replacement.release();
const downs = [];
lease = r.input.claimPointer('h', {
grab: (down) => {
downs.push(down);
return down.button === 0 && down.position.x < 640;
},
});
listen(lease, 'h');
const step = (type, x, button = 0) =>
h.pointer(r, type, x, 360, { button });
heard.length = 0;
await step('down', 100);
await step('move', 300);
await step('up', 300);
await step('move', 1000);
await step('click', 1000);
deepEqual(
heard.filter((x) => !x.endsWith(':up')),
['h:down', 'ambient:click'],
'after a drag, a later click is a press of its own',
);
heard.length = 0;
await step('down', 100);
await step('move', 300);
await step('up', 300);
await step('click', 1000);
deepEqual(
heard.filter((x) => !x.endsWith(':up')),
['h:down', 'ambient:click'],
'a click straight after a drag, elsewhere, is a press of its own',
);
heard.length = 0;
await step('down', 100, 0);
await step('down', 100, 2);
await step('up', 100, 0);
await step('click', 100, 0);
await step('up', 100, 2);
await step('click', 100, 2);
deepEqual(
heard.filter((x) => !x.endsWith(':up')),
['h:down', 'ambient:down', 'h:click', 'ambient:click'],
'each button’s press is its own',
);
heard.length = 0;
await at(100, 'down', 'up', 'click');
await at(1000, 'dblclick');
deepEqual(
heard.filter((x) => !x.endsWith(':up')),
['h:down', 'h:click', 'ambient:dblclick'],
'a double-click elsewhere is not the click’s',
);
heard.length = 0;
await at(100, 'down');
await at(1000, 'dblclick');
await at(100, 'up', 'click');
deepEqual(
heard.filter((x) => !x.endsWith(':up')),
['h:down', 'ambient:dblclick', 'h:click'],
'a stray double-click during a press leaves the press its owner\u2019s',
);
downs.length = 0;
await at(100, 'click');
equal(downs.length, 1, 'an isolated click asks grab');
equal(downs[0]?.type, 'down', 'as a down');
ok(
!('pick' in downs[0]) &&
!('drill' in downs[0]) &&
!('ground' in downs[0]),
'with no pick',
);
lease.release();
},
),
check(
'input.clickPick',
'a click carries one pick shared by every subscriber',
async (h, r) => {
if (!h.pointer) return { skip: 'no pointer in this harness' };
await overAustin(h, r);
const set = r.draw.icons({ id: 'conf:click' });
const pos = h.toEcef({ ...AUSTIN, height: 0 });
set.set([{ id: 'x', pos, image: DOT, size: [24, 24] }]);
await drawn(h, r);
const s = r.query.project(pos);
const hits = [];
r.input.on('click', (ev) => hits.push(ev.pick()));
r.input.on('click', (ev) => hits.push(ev.pick()));
await h.pointer(r, 'click', s.x, s.y);
equal(hits.length, 2, 'both subscribers');
equal(hits[0]?.id, 'x', 'the hit');
equal(hits[0], hits[1], 'the same pick object');
set.dispose();
},
),
check(
'input.behaviours',
'stock behaviours are listed and suppression is counted',
(h, r) => {
for (const name of ['select', 'dblclickFollow']) {
const b = r.input.behaviours[name];
ok(b && typeof b.suppress === 'function', `${name} listed`);
if (!b.enabled) continue;
const one = b.suppress();
const two = b.suppress();
ok(!b.enabled, `${name} suppressed`);
one();
one();
ok(!b.enabled, `${name} still suppressed`);
two();
ok(b.enabled, `${name} back`);
}
},
),
// --- Globe -------------------------------------------------------------
check(
'globe.imagery',
'imagery layers keep order, raise and lower, and leave on remove',
(h, r) => {
const a = r.globe.imagery.add({
kind: 'xyz',
url: 'https://a.invalid/{z}/{x}/{y}.png',
});
const b = r.globe.imagery.add({
kind: 'xyz',
url: 'https://b.invalid/{z}/{x}/{y}.png',
});
const ours = () =>
r.globe.imagery
.list()
.filter((l) => l === a || l === b)
.map((l) => (l === a ? 'a' : 'b'));
deepEqual(ours(), ['a', 'b'], 'added in order');
a.raise();
deepEqual(ours(), ['b', 'a'], 'raised');
a.lower();
deepEqual(ours(), ['a', 'b'], 'lowered');
a.alpha = 0.5;
equal(a.alpha, 0.5, 'alpha');
equal(b.drapeOn, 'all', 'drapes on whatever is drawn by default');
equal(b.lit, true, 'lit by default');
b.drapeOn = 'surface';
b.lit = false;
equal(b.drapeOn, 'surface', 'drapeOn is settable');
equal(b.lit, false, 'lit is settable');
a.remove();
deepEqual(ours(), ['b'], 'the removed layer is the one gone');
b.remove();
deepEqual(ours(), [], 'both removed');
},
),
check(
'globe.imagery.frames',
'timed frames follow scene time, or setFrameTime on their own clock',
async (h, r) => {
await overAustin(h, r, 2000000);
const t0 = r.frame.time();
const frames = [0, 60000, 120000].map((dt, i) => ({
time: t0 + dt,
url: PIXEL_PNGS[i],
}));
const ready = [];
// Frames decode in real time: wait on the clock, drawing meanwhile.
const waitFor = async (time, ms = 5000) => {
const until = Date.now() + ms;
while (!ready.includes(time) && Date.now() < until) {
await drawn(h, r, 1);
await new Promise((done) => setTimeout(done, 10));
}
return ready.includes(time);
};
const settle = () => waitFor(Symbol('nothing'), 300);
const scene = r.globe.imagery.add({
kind: 'single-image',
url: PIXEL_PNG,
});
scene.on('frameReady', (time) => ready.push(time));
scene.setFrames({ kind: 'frames', frames });
r.frame.setTime(t0 + 50000);
ok(await waitFor(t0 + 60000), 'the frame nearest scene time is ready');
await settle();
ready.length = 0;
r.frame.setTime(t0 + 55000);
scene.setFrameTime(t0 + 130000);
await settle();
deepEqual(
ready,
[],
'the same frame is not ready twice, and setFrameTime does nothing on the scene clock',
);
scene.remove();
ready.length = 0;
const own = r.globe.imagery.add({
kind: 'single-image',
url: PIXEL_PNG,
});
own.on('frameReady', (time) => ready.push(time));
own.setFrames({ kind: 'frames', frames }, { clock: 'own' });
own.setFrameTime(t0 + 130000);
ok(await waitFor(t0 + 120000), 'setFrameTime on its own clock');
await settle();
ready.length = 0;
r.frame.setTime(t0 + 5000);
await settle();
deepEqual(ready, [], 'scene time does not move its own clock');
own.remove();
ready.length = 0;
const paused = r.globe.imagery.add({
kind: 'single-image',
url: PIXEL_PNG,
});
paused.on('frameReady', (time) => ready.push(time));
r.frame.suspend(true);
paused.setFrames({ kind: 'frames', frames });
r.frame.setTime(t0 + 1000);
r.frame.setTime(t0 + 61000);
await settle();
deepEqual(ready, [], 'nothing is ready while the loop is suspended');
r.frame.suspend(false);
ok(
await waitFor(t0 + 60000),
'the frame shown is ready once it is drawn',
);
equal(ready[0], t0 + 60000, 'and frames never drawn are not announced');
paused.remove();
ready.length = 0;
const first = r.globe.imagery.add({
kind: 'single-image',
url: PIXEL_PNG,
});
const second = r.globe.imagery.add({
kind: 'single-image',
url: PIXEL_PNG,
});
first.on('frameReady', () => {
ready.push('first');
second.remove();
});
second.on('frameReady', () => ready.push('second'));
first.setFrames({ kind: 'frames', frames });
second.setFrames({ kind: 'frames', frames });
r.frame.setTime(t0 + 120000);
await waitFor('first');
await settle();
ok(
!ready.includes('second'),
'a layer removed while another announces says nothing',
);
first.remove();
},
{ capability: 'imageryFrames' },
),
check(
'globe.withoutImageHooks',
'without imageHooks, a spec with main-thread tile hooks throws',
async (h) => {
const r = await h.create({
viewport: SCRIPT_VIEWPORT,
capabilities: CAPABILITIES.filter((c) => c !== 'imageHooks'),
});
if (!r) return { skip: 'this harness cannot drop capabilities' };
try {
const url = 'https://example.invalid/{z}/{x}/{y}.png';
throws(
() =>
r.globe.imagery.add({
kind: 'xyz',
url,
tileTransform: (t, i) => i,
}),
'tileTransform',
);
throws(
() =>
r.globe.imagery.add({
kind: 'xyz',
url,
admit: (t, issue) => issue(),
}),
'admit',
);
throws(
() => r.globe.imagery.add({ kind: 'canvas', drawTile: () => {} }),
'canvas imagery',
);
const plain = r.globe.imagery.add({ kind: 'xyz', url });
ok(plain, 'a plain layer is added');
plain.remove();
} finally {
r.destroy();
}
},
),
check(
'globe.split',
'the split position round-trips',
(h, r) => {
r.globe.imagery.setSplit(0.3);
near(r.globe.imagery.getSplit(), 0.3, 1e-9, 'split');
},
{ capability: 'splitSwipe' },
),
check(
'globe.visible',
'the globe surface reads back as it was shown or hidden',
(h, r) => {
r.globe.setGlobeVisible(false);
equal(r.globe.isGlobeVisible(), false, 'hidden');
r.globe.setGlobeVisible(true);
equal(r.globe.isGlobeVisible(), true, 'shown');
},
{ capability: 'globeVisibility' },
),
check(
'globe.surfaceVersion',
'the surface version changes with what heights answer against, only',
async (h, r) => {
await overAustin(h, r);
await drawn(h, r);
const first = r.globe.surfaceVersion();
equal(typeof first, 'number', 'a number');
r.camera.setView({
destination: { ...AUSTIN, height: 9000 },
orientation: { heading: 1, pitch: -1, roll: 0 },
});
await drawn(h, r, 4);
equal(
r.globe.surfaceVersion(),
first,
'steady across frames and moves',
);
r.globe.setGlobeVisible(false);
await drawn(h, r);
const hidden = r.globe.surfaceVersion();
ok(hidden !== first, 'the globe hidden changes it');
equal(
r.globe.isSettled('surface'),
false,
'with no globe and no tiles there is no surface to settle',
);
r.globe.setGlobeVisible(true);
await drawn(h, r);
ok(r.globe.surfaceVersion() !== hidden, 'shown again changes it');
},
{ capability: 'surfaceIdentity' },
),
check(
'globe.surfaceShading',
'hillshade shading is set, restrengthened and cleared, drawing each time',
async (h, r) => {
await overAustin(h, r, 20000);
const errors = [];
const off = r.on('error', (e) => errors.push(e));
const draws = [];
const offDraw = r.frame.on('postRender', () => draws.push(1));
try {
for (const shading of [
{ kind: 'hillshade', strength: 0.28 },
{ kind: 'hillshade', strength: 0.5 },
null,
]) {
const before = draws.length;
r.globe.setSurfaceShading(shading);
await h.frame(r);
await h.frame(r);
ok(
draws.length > before,
`drawn after ${shading?.strength ?? 'clearing'}`,
);
}
deepEqual(errors, [], 'no errors');
} finally {
off();
offDraw();
}
},
{ capability: 'surfaceShading' },
),
check(
'globe.sky',
'sky settings round-trip and keep unchanged keys',
(h, r) => {
const before = r.globe.sky.get();
r.globe.sky.set({ stars: !before.stars, milkyWay: 0.25 });
const after = r.globe.sky.get();
equal(after.stars, !before.stars, 'stars');
near(after.milkyWay, 0.25, 1e-9, 'milkyWay');
equal(after.atmosphere, before.atmosphere, 'atmosphere unchanged');
},
),
// --- Effects, credits, quality ---------------------------------------
check(
'effects.styles',
'a style is set, tuned and cleared; diagnostics follow',
(h, r) => {
// The app defines its styles on a renderer with none of its own.
const off = r.effects.styles().length
? null
: r.effects.defineStyle(swapStyle('conf:plain'));
const styles = r.effects.styles();
ok(styles.length > 0, 'styles listed');
const changes = [];
r.effects.on('change', (d) => changes.push(d));
r.effects.setStyle(styles[0].id);
equal(r.effects.diagnostics().style, styles[0].id, 'style active');
r.effects.setStyleIntensity(styles[0].id, 0.5);
r.effects.setStyle(null);
equal(r.effects.diagnostics().style, null, 'cleared');
ok(changes.length >= 2, 'change events');
r.effects.setStyleIntensity(styles[0].id, 0);
off?.();
},
{ capability: 'styles' },
),
check(
'effects.defineStyle',
'The application defines a style: listed, set, replaced and removed',
(h, r) => {
const definition = {
id: 'conf:tint',
params: [{ key: 'amount', min: 0, max: 1, default: 0.5 }],
animated: false,
shader: {
glsl: `uniform sampler2D colorTexture;
uniform float intensity;
uniform float amount;
in vec2 v_textureCoordinates;
void main() {
vec4 c = texture(colorTexture, v_textureCoordinates);
out_FragColor = vec4(mix(c.rgb, c.rgb * vec3(1.0, amount, amount), intensity), 1.0);
}`,
wgsl: `@fragment
fn fs_main(@location(0) uv: vec2f) -> @location(0) vec4f {
let c = textureSample(colorTexture, colorSampler, uv);
let tinted = c.rgb * vec3f(1.0, params.amount, params.amount);
return vec4f(mix(c.rgb, tinted, params.intensity), 1.0);
}`,
},
};
const off = r.effects.defineStyle(definition);
equal(typeof off, 'function', 'an Off, with a GLSL and a WGSL source');
const listed = r.effects.styles().filter((s) => s.id === 'conf:tint');
equal(listed.length, 1, 'listed once');
deepEqual(listed[0].params, definition.params, 'with its parameters');
r.effects.setStyle('conf:tint', { amount: 0.2 });
equal(r.effects.diagnostics().style, 'conf:tint', 'set');
const offAgain = r.effects.defineStyle({
...definition,
animated: true,
});
equal(
r.effects.styles().filter((s) => s.id === 'conf:tint').length,
1,
'a second definition replaces the first',
);
equal(
r.effects.diagnostics().style,
'conf:tint',
'the style stays on through its replacement',
);
off();
ok(
r.effects.styles().some((s) => s.id === 'conf:tint'),
'the replaced definition’s Off leaves the new one',
);
offAgain();
ok(!r.effects.styles().some((s) => s.id === 'conf:tint'), 'removed');
equal(r.effects.diagnostics().style, null, 'and turned off');
offAgain();
},
{ capability: 'styles' },
),
check(
'effects.crossfade',
'a replaced style draws until its intensity is 0',
(h, r) => {
const define = (id) => r.effects.defineStyle(swapStyle(id));
const offs = [define('conf:a'), define('conf:b')];
const drawn = () =>
r.effects
.diagnostics()
.passes.filter((p) => p === 'style:conf:a' || p === 'style:conf:b')
.sort();
try {
r.effects.setStyle('conf:a');
deepEqual(drawn(), ['style:conf:a'], 'the style draws');
r.effects.setStyleIntensity('conf:b', 0);
r.effects.setStyle('conf:b');
deepEqual(
drawn(),
['style:conf:a'],
'the new style at 0 draws nothing yet',
);
r.effects.setStyleIntensity('conf:a', 0.6);
r.effects.setStyleIntensity('conf:b', 0.4);
deepEqual(
drawn(),
['style:conf:a', 'style:conf:b'],
'both draw mid-fade',
);
r.effects.setStyleIntensity('conf:a', 0);
deepEqual(drawn(), ['style:conf:b'], 'the old one stops at 0');
r.effects.setStyle('conf:a');
r.effects.setStyle('conf:b');
r.effects.setStyleIntensity('conf:a', 1);
deepEqual(
drawn(),
['style:conf:b'],
'a style replaced at 0 does not fade',
);
r.effects.setStyleIntensity('conf:a', 0);
r.effects.setStyleIntensity('conf:a', 1);
deepEqual(
drawn(),
['style:conf:b'],
'a faded-out style does not come back by intensity alone',
);
r.effects.setStyle(null);
deepEqual(drawn(), ['style:conf:b'], 'cleared, it fades');
r.effects.setStyleIntensity('conf:b', 0);
deepEqual(drawn(), [], 'and stops');
} finally {
for (const off of offs) off?.();
}
},
{ capability: 'styles' },
),
check(
'effects.withoutStyles',
'without styles, styles() is empty',
async (h) => {
const r = await h.create({
viewport: SCRIPT_VIEWPORT,
capabilities: CAPABILITIES.filter((c) => c !== 'styles'),
});
if (!r) return { skip: 'this harness cannot drop capabilities' };
try {
deepEqual(r.effects.styles(), [], 'styles()');
equal(
r.effects.defineStyle({
id: 'x',
params: [],
animated: false,
shader: { glsl: 'void main() {}' },
}),
null,
'defineStyle() answers null',
);
} finally {
r.destroy();
}
},
),
check(
'credits',
'a static credit is listed until its Off, with change events',
(h, r) => {
const events = [];
r.credits.on('change', (list) => events.push(list.length));
const base = r.credits.list().length;
const credit = {
text: 'Conformance ',
href: 'https://example.invalid/data',
logoUrl: 'https://example.invalid/logo.png',
inline: true,
};
const off = r.credits.addStatic(credit);
deepEqual(
r.credits.list().find((c) => c.text === credit.text),
credit,
'listed as given, text left as text',
);
off();
equal(r.credits.list().length, base, 'removed');
deepEqual(events, [base + 1, base], 'change events');
},
),
check(
'quality',
'knobs name real keys; set applies supported keys and returns the rest',
async (h, r) => {
const knobs = r.quality.knobs();
for (const k of knobs)
ok(QUALITY_KEYS.includes(k.key), `known key ${k.key}`);
const supported = new Set(knobs.map((k) => k.key));
// A value each knob accepts and that differs from its default.
const valueFor = (k) => {
if (k.kind === 'boolean') return !k.default;
if (k.kind === 'enum')
return k.options.find((o) => o !== k.default) ?? k.default;
if (k.kind === 'number') return k.default === k.min ? k.max : k.min;
return k.default;
};
const wanted = Object.fromEntries(
knobs.map((k) => [k.key, valueFor(k)]),
);
const patch = {
...Object.fromEntries(QUALITY_KEYS.map((k) => [k, 0.5])),
...wanted,
};
const ignored = r.quality.set(patch);
await drawn(h, r, 1);
const applied = r.quality.get();
for (const [key, value] of Object.entries(wanted))
deepEqual(applied[key], value, `${key} applied`);
deepEqual(
[...ignored].sort(),
QUALITY_KEYS.filter((k) => !supported.has(k)).sort(),
'ignored keys',
);
ok(
['none', 'frame', 'perPass'].includes(r.quality.signals.gpuTiming),
'gpuTiming',
);
const facts = r.quality.device();
ok(facts && typeof facts === 'object', 'device facts');
},
),
check(
'renderer.whenSettled',
'whenSettled names what is still loading',
async (h, r) => {
const result = await r.whenSettled({ timeoutMs: 5000 });
ok(['settled', 'timeout', 'failed'].includes(result.state), 'state');
ok(Array.isArray(result.blockers), 'blockers');
equal(
result.state === 'settled',
result.blockers.length === 0,
'settled exactly when nothing blocks',
);
},
),
check(
'renderer.readPixels',
'readPixels reads the drawn frame, cropped and scaled, at once',
async (h, r) => {
await overAustin(h, r);
r.frame.renderNow();
const full = r.readPixels();
equal(full.width, SCRIPT_VIEWPORT.width, 'the canvas’s CSS width');
equal(full.height, SCRIPT_VIEWPORT.height, 'the canvas’s CSS height');
equal(full.data.length, full.width * full.height * 4, 'RGBA bytes');
const part = r.readPixels({
crop: { x: 10, y: 20, width: 40, height: 30 },
scale: 0.5,
});
deepEqual(
[part.width, part.height, part.data.length],
[20, 15, 20 * 15 * 4],
'a crop, scaled',
);
},
),
check(
'renderer.releaseUnused',
'releaseUnused keeps what is in view drawn and picked',
async (h, r) => {
await overAustin(h, r);
const set = r.draw.points({ id: 'conf:release' });
const pos = h.toEcef({ ...AUSTIN, height: 0 });
set.set([{ id: 'kept', pos, pixelSize: 20, color: '#f00' }]);
await drawn(h, r);
r.releaseUnused();
await drawn(h, r);
const s = r.query.project(pos);
ok(s, 'the point projects');
equal(r.query.pick(s.x, s.y)?.id, 'kept', 'still picked');
set.dispose();
},
),
check(
'quality.signals.gpuTiming',
'with gpuTiming, drawn frames come to carry their GPU time; without it they never do',
async (h, r) => {
const timed = r.capabilities.has('gpuTiming');
equal(
r.quality.signals.gpuTiming !== 'none',
timed,
'gpuTiming says whether frames are timed',
);
equal(r.quality.device().gpuTimer, timed, 'device facts agree');
const signals = [];
const off = r.quality.signals.on('frame', (s) => signals.push(s));
for (let i = 0; i < 30 && !signals.some((s) => 'gpuMs' in s); i++)
await drawn(h, r, 1);
off();
const gpu = signals.filter((s) => 'gpuMs' in s);
if (timed) {
ok(gpu.length > 0, 'a GPU time came back within 30 frames');
ok(
gpu.every((s) => Number.isFinite(s.gpuMs) && s.gpuMs >= 0),
'GPU times are milliseconds',
);
} else equal(gpu.length, 0, 'no GPU time without gpuTiming');
if (!timed) return;
const without = await h.create({
viewport: SCRIPT_VIEWPORT,
capabilities: CAPABILITIES.filter((c) => c !== 'gpuTiming'),
});
if (!without) return;
try {
equal(without.quality.signals.gpuTiming, 'none', 'none without it');
} finally {
without.destroy();
}
},
),
check(
'quality.signals',
'frame signals arrive for drawn frames',
async (h, r) => {
const signals = [];
r.quality.signals.on('frame', (s) => signals.push(s));
await drawn(h, r, 2);
ok(signals.length >= 1, 'signals');
ok(signals[0].width > 0 && signals[0].height > 0, 'size');
},
),
];
}