mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 08:12:24 +00:00
Shapes take their radii in metres; the world annotation ring follows the camera height itself (ringRadiusAt), resizing on preRender. The radial rim preset and depthBias go: the launch pad zone draws a canvas image fill made by the layer. Solid and dashed lines take one depthFail look (solid or dash) in place of depthFailColor and depthFailDash. sonarCadenceHz goes from the quality settings: nothing set it, and the sweep moves every 80 ms. Camera move, look, rotateAround and zoom leave the camera port: the app's pans, in-place turns, globe turns and zooms are setView views summed over the pose (geo/eyeMoves), and the Cesium port places a view by direction and up exactly rather than through heading, pitch and roll. The conformance driver runs those script steps through setView; the lookAt script turns in place where it turned about the frame-local axis, and its reference is recorded again.
3695 lines
125 KiB
JavaScript
3695 lines
125 KiB
JavaScript
/**
|
||
* 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: '<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16"><circle cx="8" cy="8" r="8" fill="#fff"/></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's 'drawn' comes once per change, never while hidden",
|
||
async (h, r) => {
|
||
await overAustin(h, r, 20000);
|
||
const svg = (fill) => ({
|
||
svg: `<svg xmlns="http://www.w3.org/2000/svg" width="8" height="8"><rect width="8" height="8" fill="${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');
|
||
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 (drawnPixels < 20)
|
||
return { skip: 'this renderer draws no icon 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.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.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.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.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' },
|
||
),
|
||
|
||
// --- 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();
|
||
}
|
||
},
|
||
),
|
||
|
||
// --- 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 <data>',
|
||
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',
|
||
'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');
|
||
},
|
||
),
|
||
];
|
||
}
|