Files
gods-eye-view/src/render/cesium/gpuIcons.test.mjs
T
Sameh Khamis 46cdeba7fa Remove renderer contract members nothing in the application uses
Drops from the contract, the stub, the Cesium renderer and the
conformance suite: agent paths, renderer-propagated orbits and celestial
draws (orbits stay drawn as icons and inertial lines), scalar raster
fields, lodGroup, volume classification, icon eye offsets, the dash gap
colour, box shapes, courseBlendMs (courseGlide covers easing), relief
surface shading, globe clouds and water, sky atmosphere tuning, heightmap
and quantized-mesh terrain, WMTS and ArcGIS imagery, the batched cached
height read, the quality benchmark and the animated-style and overlay
pixel-ratio knobs. Capabilities clouds, water, celestial, agents, orbits
and benchmark go with them.

The lodGroup check becomes a displayRange check across two sets, the
height-query check uses an extruded polygon in place of a box, the shape
scenes draw extruded blocks where they drew boxes, and the fields scene
draws a raster shell. The shape references are recorded again.
2026-11-10 03:27:10 -08:00

794 lines
28 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import assert from 'node:assert/strict';
import * as Cesium from 'cesium';
import test from 'node:test';
import { createCesiumDraw } from './draw.js';
import { drawHitOf } from './drawHit.js';
import { IconSetPrimitive } from './iconSetPrimitive.js';
import { MAX_ICON_SLOTS } from '../../data/iconAtlas.js';
import {
ICON_CULL_LIFT,
ICON_RECEDES,
ICON_ROTATES,
} from '../../data/iconSet.js';
import {
iconCourse,
iconPosition,
motionPosition,
} from '../motion/iconMotion.js';
/** A scene with what the draw port touches, and a frame time to set. */
function fakeScene() {
const added = [];
return {
added,
renders: 0,
camera: { positionWC: new Cesium.Cartesian3(2e7, 0, 0) },
frameState: { time: Cesium.JulianDate.now() },
primitives: {
add: (primitive) => (added.push(primitive), primitive),
remove: (primitive) => {
const at = added.indexOf(primitive);
if (at >= 0) added.splice(at, 1);
return at >= 0;
},
length: 0,
},
requestRender() {
this.renders += 1;
},
isDestroyed: () => false,
};
}
function drawOver(options = {}) {
const scene = fakeScene();
const part = createCesiumDraw({
scene,
report: (error) => assert.fail(error),
...options,
});
return { scene, part, draw: part.port };
}
const AT = Cesium.Cartesian3.fromDegrees(4.1, 51.95, 2);
const ecef = (c) => ({ x: c.x, y: c.y, z: c.z });
const distance = (a, b) => Math.hypot(a.x - b.x, a.y - b.y, a.z - b.z);
const julian = (ms) => Cesium.JulianDate.fromDate(new Date(ms));
/** The record's icon set, and where a row is drawn at epoch ms `ms`. */
function rows(part, id) {
const set = part.sets.get(id).gpu.set;
return {
set,
position: (rowId, ms) =>
set.position(set.row(rowId), set.seconds(julian(ms))),
course: (rowId, ms) => set.course(set.row(rowId), set.seconds(julian(ms))),
};
}
const icon = (id, extra = {}) => ({
id,
pos: ecef(AT),
image: 'ship.png',
size: [32, 32],
...extra,
});
test('a moving item takes its icon set onto the GPU, in its billboards’ place', () => {
const { scene, part, draw } = drawOver();
const set = draw.icons({ id: 'gpu:switch', horizonCull: true });
set.set([icon('a')]);
assert.ok(scene.added[0] instanceof Cesium.BillboardCollection);
set.upsert([icon('b', { motion: { kind: 'hold', courseDeg: 30 } })]);
assert.equal(scene.added.length, 1, 'one host');
const host = scene.added[0];
assert.ok(host instanceof IconSetPrimitive, 'drawn by the GPU icon set');
assert.equal(host.drawSetId, 'gpu:switch', 'named for finding its host');
const { set: rowsOf, course } = rows(part, 'gpu:switch');
assert.equal(rowsOf.count, 2, 'the items it had are rows too');
assert.equal(set.size(), 2);
assert.equal(course('b', Date.now()), 30);
// It stays on the GPU: still items draw as holds where they are.
set.set([icon('c')]);
assert.equal(scene.added[0], host);
assert.equal(rowsOf.count, 1);
assert.ok(distance(rows(part, 'gpu:switch').position('c', 0), AT) < 0.01);
set.remove(['c']);
assert.equal(rowsOf.count, 0);
set.dispose();
assert.equal(scene.added.length, 0, 'disposed: gone from the scene');
});
test('segments draw where the contract’s motion puts them, on the scene clock', () => {
const { part, draw } = drawOver();
const set = draw.icons({ id: 'gpu:motion', motionClock: { kind: 'scene' } });
// Near the set's epoch (now), as live times are: segment times are float32.
const t0 = Date.now();
const fix = ecef(Cesium.Cartesian3.fromDegrees(4.1, 51.95, 12000));
const to = ecef(Cesium.Cartesian3.fromDegrees(4.3, 51.95, 12000));
const motions = {
lerp: { kind: 'lerp', from: fix, to, t0, t1: t0 + 10000 },
arc: {
kind: 'arc',
fix,
t0,
speedMps: 150,
trackDeg: 20,
turnRateDps: 3,
climbMps: 12,
minDtS: -10,
maxDtS: 20,
},
straight: {
kind: 'arc',
fix,
t0,
speedMps: 200,
trackDeg: 90,
turnRateDps: 0,
climbMps: -5,
minDtS: 0,
maxDtS: 10,
},
hold: { kind: 'hold', courseDeg: 45 },
};
set.set(
Object.entries(motions).map(([id, motion]) => ({
...icon(id),
pos: fix,
motion,
})),
);
const { position } = rows(part, 'gpu:motion');
for (const dt of [-30000, -5000, 0, 2500, 8000, 15000, 60000])
for (const [id, motion] of Object.entries(motions)) {
const want = motionPosition(motion, fix, t0 + dt);
const off = distance(position(id, t0 + dt), want);
assert.ok(off < 0.1, `${id} at ${dt} ms: ${off} m off`);
}
});
test('a set’s motion clock is the frame’s scene time, or wall time less its delay', () => {
const { scene, part, draw } = drawOver();
const live = draw.icons({
id: 'gpu:live',
motionClock: { kind: 'live', delayMs: 2000 },
});
live.set([icon('a', { motion: { kind: 'hold' } })]);
const host = part.sets.get('gpu:live').host;
const lag =
Date.now() - Cesium.JulianDate.toDate(host.renderTime({})).getTime();
assert.ok(Math.abs(lag - 2000) < 50, `lags ${lag} ms`);
const sceneSet = draw.icons({
id: 'gpu:scene',
motionClock: { kind: 'scene' },
});
sceneSet.set([icon('a', { motion: { kind: 'hold' } })]);
const frameState = { time: julian(Date.UTC(2020, 0, 1)) };
const sceneHost = part.sets.get('gpu:scene').host;
assert.ok(
Cesium.JulianDate.equals(sceneHost.renderTime(frameState), frameState.time),
);
assert.equal(scene.frameState.time instanceof Cesium.JulianDate, true);
});
test('rows moving on a live clock keep frames coming until their segments end', () => {
const { scene, part, draw } = drawOver();
const set = draw.icons({ id: 'gpu:animate' });
const now = Date.now();
const to = ecef(Cesium.Cartesian3.fromDegrees(4.2, 51.95, 2));
set.set([
icon('a', {
motion: { kind: 'lerp', from: ecef(AT), to, t0: now, t1: now + 60000 },
}),
]);
const before = scene.renders;
part.afterRender();
assert.equal(scene.renders, before + 1, 'still moving: another frame');
set.set([icon('a', { motion: { kind: 'hold' } })]);
const held = scene.renders;
part.afterRender();
assert.equal(scene.renders, held, 'held: no frames asked for');
// A scene clock moves with the scene's own time.
set.setOptions({ motionClock: { kind: 'scene' } });
set.set([
icon('a', {
motion: { kind: 'lerp', from: ecef(AT), to, t0: now, t1: now + 60000 },
}),
]);
const onScene = scene.renders;
part.afterRender();
assert.equal(scene.renders, onScene);
});
test('an item’s look goes into its row: size, scale, tint, focus, flags, proxy, depth and images', () => {
const { part, draw } = drawOver();
const set = draw.icons({ id: 'gpu:look', horizonCull: true });
set.set([
icon('a', {
motion: { kind: 'hold', courseDeg: 10 },
size: [20, 24],
scale: 1.5,
alpha: 0.5,
color: [1, 0, 0, 1],
focus: 0.25,
recede: true,
rotationMode: 'course',
pickProxy: { size: [48, 40] },
disableDepthTest: Infinity,
scaleByDistance: { near: 1000, nearValue: 3, far: 8e6, farValue: 0.5 },
imageLod: { near: 'ship-large.png', switchPx: 60 },
}),
icon('b', { motion: { kind: 'hold' }, show: false }),
]);
const { set: s } = rows(part, 'gpu:look');
const a = s.row('a');
assert.equal(s.width(a), 20);
assert.equal(s.height(a), 24);
assert.equal(s.scale(a), 1.5);
assert.equal(s.alpha(a), 0.5);
assert.ok(Cesium.Color.equals(s.color(a), Cesium.Color.RED));
assert.equal(s.focus(a), 0.25);
assert.equal(s.flags(a) & ICON_ROTATES, ICON_ROTATES);
assert.equal(s.flags(a) & ICON_RECEDES, ICON_RECEDES);
assert.equal(s.flags(a) & ICON_CULL_LIFT, ICON_CULL_LIFT, 'culled lifted');
assert.equal(s.pickProxyWidth(a), 48);
assert.equal(s.pickProxyHeight(a), 40);
assert.ok(s.depthTestDistance(a) >= 1e30, 'over depth everywhere');
assert.equal(s.scaleByDistance(a).nearValue, 3);
assert.equal(s.imageSwitch(a), 60);
assert.notEqual(s.imageNear(a), s.imageFar(a), 'a near image of its own');
assert.equal(s.shown(a), true);
const b = s.row('b');
assert.equal(s.shown(b), false);
assert.equal(s.depthTestDistance(b), 0, 'depth-tested by default');
assert.equal(s.flags(b) & ICON_ROTATES, 0, 'upright by default');
assert.equal(s.focus(b), 1);
assert.equal(s.imageNear(b), s.imageFar(b));
// The cull lift follows the set's horizon cull.
set.setOptions({ horizonCull: false });
assert.equal(s.flags(a) & ICON_CULL_LIFT, 0);
assert.equal(part.sets.get('gpu:look').host._cull(), false);
set.setOptions({ horizonCull: true });
assert.equal(s.flags(a) & ICON_CULL_LIFT, ICON_CULL_LIFT);
assert.equal(part.sets.get('gpu:look').host._cull(), true);
});
test('a row picks as a draw-set item, with the meta its item has now', () => {
const { part, draw } = drawOver();
const set = draw.icons({ id: 'gpu:pick' });
set.set([icon('a', { motion: { kind: 'hold' }, meta: { n: 1 } })]);
const host = part.sets.get('gpu:pick').host;
const facade = { show: true };
const picked = host._pickObject('a', null, facade);
assert.equal(picked.primitive, facade, 'drill picks hide it by its facade');
assert.deepEqual(drawHitOf(picked), {
set: 'gpu:pick',
id: 'a',
meta: { n: 1 },
surface: false,
});
set.upsert([icon('a', { motion: { kind: 'hold' }, meta: { n: 2 } })]);
assert.deepEqual(drawHitOf(picked).meta, { n: 2 });
});
test('a course glides at its rate with courseGlide, and turns at once without it', () => {
const t0 = Date.now();
const glideItem = (rateDps) =>
icon('a', {
motion: { kind: 'hold', courseDeg: 90 },
rotationMode: 'course',
courseGlide: { fromCourseDeg: 0, t0, rateDps },
});
const { part, draw } = drawOver();
const set = draw.icons({ id: 'gpu:glide' });
set.set([glideItem(10)]);
const { course } = rows(part, 'gpu:glide');
assert.ok(Math.abs(course('a', t0 + 3000) - 30) < 0.01, 'at 10°/s');
assert.ok(Math.abs(course('a', t0 + 20000) - 90) < 0.01, 'then on course');
set.set([glideItem(0)]);
assert.ok(Math.abs(course('a', t0 + 20000) - 0) < 0.01, '0°/s holds');
// Without the capability: the glide is ignored and the course turns at once.
const without = drawOver({
capabilities: new Set(['motionSegments', 'columns']),
});
const turned = without.draw.icons({ id: 'gpu:turn' });
const turn = (courseDeg) =>
icon('a', {
motion: { kind: 'hold', courseDeg },
courseGlide: { fromCourseDeg: 180, t0, rateDps: 1 },
});
turned.set([turn(0)]);
const r = rows(without.part, 'gpu:turn');
assert.ok(
Math.abs(r.course('a', Date.now())) < 0.01,
'new: on course at once, its glide ignored',
);
turned.upsert([turn(60)]);
assert.ok(Math.abs(r.course('a', Date.now()) - 60) < 0.01, 'turned at once');
});
test('without motionSegments, motion is ignored: billboards at the item’s place', () => {
const { scene, draw } = drawOver({ capabilities: new Set() });
const set = draw.icons({ id: 'gpu:none' });
set.set([icon('a', { motion: { kind: 'hold' } })]);
assert.ok(scene.added[0] instanceof Cesium.BillboardCollection);
assert.equal(set.setColumns, undefined, 'no columns either');
});
test('GPU icon sets refuse what they cannot draw, changing nothing', () => {
const { part, draw } = drawOver();
const set = draw.icons({ id: 'gpu:refuse' });
set.set([icon('a', { motion: { kind: 'hold' } })]);
for (const extra of [
{ height: 'clampGround' },
{ fadeByDistance: { near: 1, nearValue: 1, far: 2, farValue: 0 } },
{ displayRange: [0, 10] },
{ pixelOffset: { x: 1, y: 0 } },
{ anchor: 'bottom' },
{ rotationMode: 'axis' },
{ rotationMode: 'screen', rotation: 1 },
{ image: { blob: {} } },
])
assert.throws(
() => set.upsert([icon('b', { motion: { kind: 'hold' }, ...extra })]),
/GPU icons have no/,
JSON.stringify(extra),
);
assert.equal(set.size(), 1);
assert.equal(rows(part, 'gpu:refuse').set.count, 1);
// A billboard set refuses to move over when what it holds cannot.
const billboards = draw.icons({ id: 'gpu:stay' });
billboards.set([icon('a', { anchor: 'bottom' })]);
assert.throws(
() => billboards.upsert([icon('b', { motion: { kind: 'hold' } })]),
/anchors/,
);
assert.equal(part.sets.get('gpu:stay').gpu, undefined);
assert.equal(billboards.size(), 1);
});
test('columns update rows by index: positions, courses, shown, scales, tints and meta', () => {
const { part, draw } = drawOver();
const set = draw.icons({ id: 'gpu:columns' });
const b = ecef(Cesium.Cartesian3.fromDegrees(4.2, 51.9, 2));
set.set([icon('a', { meta: 1 }), icon('b', { pos: b, meta: 2 })]);
assert.ok(part.sets.get('gpu:columns').gpu === undefined, 'billboards');
set.setColumns({
ids: ['a', 'b'],
positions: new Float64Array([b.x, b.y, b.z, AT.x, AT.y, AT.z]),
courses: new Float32Array([15, 25]),
shown: new Uint8Array([1, 0]),
scales: new Float32Array([2, 3]),
alphas: new Float32Array([0.5, 1]),
colors: new Uint8Array([255, 0, 0, 255, 0, 0, 255, 255]),
meta: [{ k: 'a' }, { k: 'b' }],
});
const r = rows(part, 'gpu:columns');
const now = Date.now();
assert.ok(distance(r.position('a', now), b) < 0.01, 'a moved to b');
assert.ok(distance(r.position('b', now), AT) < 0.01, 'b moved to a');
assert.equal(r.course('a', now), 15);
assert.equal(r.set.shown(r.set.row('b')), false);
assert.equal(r.set.scale(r.set.row('b')), 3);
assert.equal(r.set.alpha(r.set.row('a')), 0.5);
assert.ok(
Cesium.Color.equals(r.set.color(r.set.row('b')), Cesium.Color.BLUE),
);
const host = part.sets.get('gpu:columns').host;
assert.deepEqual(drawHitOf(host._pickObject('b', null, {})).meta, {
k: 'b',
});
assert.equal(r.set.width(r.set.row('a')), 32, 'the item’s look is kept');
// Dirty runs, for the same ids, rewrite only those rows (end included).
const scales = new Float32Array([4, 5]);
set.setColumns({ ids: ['a', 'b'], scales, dirty: [{ start: 1, end: 1 }] });
assert.equal(r.set.scale(r.set.row('a')), 2, 'not in the run: as it was');
assert.equal(r.set.scale(r.set.row('b')), 5);
// New ids: rows not named go, new ones come (drawn once they have a look).
set.setColumns({
ids: ['b', 'c'],
positions: new Float64Array([AT.x, AT.y, AT.z, b.x, b.y, b.z]),
dirty: [{ start: 0, end: 0 }],
});
assert.equal(set.size(), 2);
assert.equal(r.set.row('a'), -1, 'a went');
assert.ok(distance(r.position('c', now), b) < 0.01, 'c written in full');
assert.equal(r.set.imageFar(r.set.row('c')), -1, 'no image: not drawn');
});
test('a row hidden by its column keeps its segment, and shows where it would be', () => {
const { part, draw } = drawOver();
const set = draw.icons({ id: 'gpu:shown', motionClock: { kind: 'scene' } });
const t0 = Date.now();
const to = ecef(Cesium.Cartesian3.fromDegrees(4.3, 51.95, 2));
const motion = { kind: 'lerp', from: ecef(AT), to, t0, t1: t0 + 10000 };
set.set([icon('m', { motion })]);
set.setColumns({ ids: ['m'], shown: new Uint8Array([0]) });
const r = rows(part, 'gpu:shown');
assert.equal(r.set.shown(0), false);
set.setColumns({ ids: ['m'], shown: new Uint8Array([1]) });
const want = motionPosition(motion, ecef(AT), t0 + 7000);
assert.ok(distance(r.position('m', t0 + 7000), want) < 0.1);
});
test('re-registering an atlas rewrites the GPU rows drawing from it', () => {
const { part, draw } = drawOver();
const set = draw.icons({ id: 'gpu:atlas' });
set.set([
icon('a', {
motion: { kind: 'hold' },
image: { atlas: 'ships', slot: 'x' },
}),
]);
const r = rows(part, 'gpu:atlas');
assert.equal(r.set.imageFar(0), -1, 'not registered yet: not drawn');
const before = part.version();
draw.atlas('ships', { x: 'ship-x.png' });
assert.ok(r.set.imageFar(0) >= 0, 'drawn once it is');
assert.ok(part.version() > before);
});
test('held rows still turning keep frames coming until their course settles', () => {
const { scene, part, draw } = drawOver();
const set = draw.icons({ id: 'gpu:turning' });
const now = Date.now();
set.set([
icon('a', {
motion: { kind: 'hold', courseDeg: 90 },
rotationMode: 'course',
courseGlide: { fromCourseDeg: 0, t0: now, rateDps: 10 },
}),
]);
const before = scene.renders;
part.afterRender();
assert.equal(scene.renders, before + 1, 'gliding: another frame');
// A glide long since over: settled, no frames.
set.set([
icon('a', {
motion: { kind: 'hold', courseDeg: 90 },
rotationMode: 'course',
courseGlide: { fromCourseDeg: 0, t0: now - 60000, rateDps: 10 },
}),
]);
const settled = scene.renders;
part.afterRender();
assert.equal(scene.renders, settled);
});
test('an icon set refuses, changing nothing, images the shared atlas has no room for', () => {
const { part, draw } = drawOver();
const set = draw.icons({ id: 'gpu:atlas-room' });
set.set([icon('a', { motion: { kind: 'hold' } })]);
const many = Array.from({ length: MAX_ICON_SLOTS + 16 }, (_, i) =>
icon(`m${i}`, { image: `room-${i}.png`, motion: { kind: 'hold' } }),
);
assert.throws(() => set.upsert(many), /no room for/);
assert.equal(set.size(), 1);
assert.equal(rows(part, 'gpu:atlas-room').set.count, 1);
});
test('focus fades a billboard icon as it fades a GPU one', () => {
const { scene, draw } = drawOver();
const set = draw.icons({ id: 'gpu:focus-billboard' });
set.set([icon('a', { focus: 0.25, alpha: 0.8 })]);
const billboards = scene.added[0];
assert.ok(billboards instanceof Cesium.BillboardCollection);
assert.ok(Math.abs(billboards.get(0).color.alpha - 0.2) < 1e-6);
set.upsert([icon('a', { focus: 3 })]);
assert.equal(billboards.get(0).color.alpha, 1, 'at most no fade');
});
test('an icon set stays on billboards until an item needs the GPU', () => {
const { scene, part, draw } = drawOver();
const stays = draw.icons({ id: 'gpu:stays' });
stays.set([icon('a', { anchor: 'bottom' })]);
assert.equal(part.sets.get('gpu:stays').gpu, undefined, 'billboards');
// A blend GPU icons do not draw is refused, not ignored.
const additive = draw.icons({ id: 'gpu:additive', blend: 'additive' });
assert.throws(
() => additive.set([icon('a', { motion: { kind: 'hold' } })]),
/additive blend/,
);
assert.ok(scene.added.length >= 1);
});
test('a write that moves a row as it already moves keeps its segment', () => {
const { part, draw } = drawOver();
const set = draw.icons({ id: 'gpu:keep-segment' });
const item = icon('a', { motion: { kind: 'hold', courseDeg: 40 } });
set.set([item]);
const { set: rowsSet } = rows(part, 'gpu:keep-segment');
rowsSet.dirty.segments.clear();
rowsSet.dirty.style.clear();
set.upsert([{ ...item, focus: 0.5, motion: { ...item.motion } }]);
assert.ok(rowsSet.dirty.segments.empty, 'no segment written');
assert.ok(!rowsSet.dirty.style.empty, 'its focus is');
set.upsert([{ ...item, motion: { kind: 'hold', courseDeg: 41 } }]);
assert.ok(!rowsSet.dirty.segments.empty, 'a new course is');
});
test('rows draw where the shared evaluator puts them, with the course it gives', () => {
const t0 = Date.now();
const fix = ecef(Cesium.Cartesian3.fromDegrees(-97.04, 32.9, 10_500));
const to = { x: fix.x + 4000, y: fix.y - 2500, z: fix.z + 1200 };
const items = [
icon('hold', {
motion: { kind: 'hold', courseDeg: 300 },
courseGlide: { fromCourseDeg: 10, t0, rateDps: 7 },
}),
icon('lerp', {
course: 15,
motion: {
kind: 'lerp',
from: fix,
to,
t0: t0 - 3000,
t1: t0 + 9000,
courseSlopeDeg: -40,
},
}),
icon('step', {
motion: { kind: 'lerp', from: fix, to, t0: t0 + 2000, t1: t0 },
}),
icon('arc', {
motion: {
kind: 'arc',
fix,
t0,
speedMps: 240,
trackDeg: 355,
turnRateDps: -3,
climbMps: 12,
minDtS: -30,
maxDtS: 90,
},
courseGlide: { fromCourseDeg: 200, t0: t0 + 1000, rateDps: 4 },
}),
icon('straight', {
motion: {
kind: 'arc',
fix,
t0,
speedMps: 80,
trackDeg: 45,
turnRateDps: 0.003,
minDtS: 0,
maxDtS: 60,
},
courseGlide: { fromCourseDeg: 90, t0, rateDps: 0 },
}),
// An exact half turn: either way is a turn; both read the same one.
icon('half', {
motion: { kind: 'hold', courseDeg: 0.7 },
courseGlide: { fromCourseDeg: 180.7, t0, rateDps: 10 },
}),
];
const { part, draw } = drawOver();
const set = draw.icons({ id: 'gpu:shared', motionClock: { kind: 'scene' } });
set.set(items);
const { position, course } = rows(part, 'gpu:shared');
for (const item of items)
for (const dt of [
-40_000, -1000, 0, 1, 1500, 2001, 5000, 30_000, 200_000,
]) {
const t = t0 + dt;
const drawnAt = position(item.id, t);
const shared = iconPosition(item, t);
assert.ok(
distance(drawnAt, shared) < 0.1,
`${item.id} at ${dt} ms: ${distance(drawnAt, shared)} m apart`,
);
const turn = Math.abs(
((course(item.id, t) - iconCourse(item, t) + 540) % 360) - 180,
);
assert.ok(turn < 1e-3, `${item.id} at ${dt} ms: ${turn}° apart`);
}
});
test('a row takes its item’s motion changed in place', () => {
const { part, draw } = drawOver();
const set = draw.icons({ id: 'gpu:in-place' });
const motion = { kind: 'hold', courseDeg: 0 };
const item = icon('a', { motion, rotationMode: 'course' });
set.set([item]);
motion.courseDeg = 90;
set.upsert([item]);
const { course } = rows(part, 'gpu:in-place');
assert.ok(
Math.abs(course('a', Date.now()) - 90) < 0.01,
'the written copy is not the item, so the change is seen',
);
});
test('an SVG takes the atlas at its own size, other images at the item’s', async () => {
const { iconAtlas } = await import('../../data/iconAtlas.js');
const { svgRasterPx } = await import('./gpuIcons.js');
const svg = (w, h, extra = '') =>
`<svg xmlns="http://www.w3.org/2000/svg" ${extra} width="${w}" height="${h}" viewBox="0 0 10 10"><rect stroke-width="9"/></svg>`;
const b64 = (text) => 'data:image/svg+xml;base64,' + btoa(text);
const enc = (text) =>
'data:image/svg+xml;charset=utf-8,' + encodeURIComponent(text);
assert.equal(svgRasterPx(b64(svg(192, 192, 'stroke-width="3"'))), 192);
assert.equal(
svgRasterPx(
enc(
`<!-- <svg width="4096" height="4096"> -->${svg(32, 32, 'data-x="a>b"')}`,
),
),
32,
'the root, past comments and quoted >',
);
assert.equal(svgRasterPx(enc(svg(1024, 1024))), 256, 'at most 256 px');
assert.equal(svgRasterPx(enc(svg('48px', 30))), 48, 'px, the larger side');
assert.equal(svgRasterPx(enc(svg('50%', 30))), null, 'not pixels');
assert.equal(
svgRasterPx(enc('<svg xmlns="http://www.w3.org/2000/svg"/>')),
null,
'no size',
);
assert.equal(svgRasterPx('ship.png'), null);
assert.equal(svgRasterPx('data:image/svg+xml;base64,@@@'), null);
const { part, draw } = drawOver();
const set = draw.icons({ id: 'gpu:raster' });
const far = b64(svg(64, 64));
const near = b64(svg(192, 192));
set.set([
icon('a', {
image: far,
size: [20, 20],
imageLod: { near, switchPx: 30 },
motion: { kind: 'hold' },
}),
icon('b', {
image: 'gpu-raster.png',
size: [24, 18],
motion: { kind: 'hold' },
}),
icon('c', {
image: { svg: svg(40, 40) },
size: [20, 20],
motion: { kind: 'hold' },
}),
]);
const { set: rowsOf } = rows(part, 'gpu:raster');
const a = rowsOf.row('a');
assert.ok(iconAtlas.has(far, 64) && iconAtlas.has(near, 192));
assert.equal(rowsOf.imageFar(a), iconAtlas.slot(far, 64), 'far at 64 px');
assert.equal(rowsOf.imageNear(a), iconAtlas.slot(near, 192), 'near at 192');
assert.equal(rowsOf.width(a), 20, 'drawn at its size');
assert.equal(
rowsOf.imageFar(rowsOf.row('b')),
iconAtlas.slot('gpu-raster.png', 24),
'a URL at the item’s larger side',
);
assert.ok(
iconAtlas.has(
`data:image/svg+xml;charset=utf-8,${encodeURIComponent(svg(40, 40))}`,
40,
),
'an svg ref at its own',
);
});
test('an image switch in CSS pixels stands for the aircraft layers’ 76 device pixels', async () => {
const { NEAR_IMAGE_DEVICE_PX, nearImageSwitchPx } =
await import('../../data/iconAtlas.js');
assert.equal(NEAR_IMAGE_DEVICE_PX, 76);
assert.equal(nearImageSwitchPx(2), 38);
const display = globalThis.devicePixelRatio;
globalThis.devicePixelRatio = 2;
try {
assert.equal(
nearImageSwitchPx(),
76,
'the scene’s ratio, not the display’s',
);
} finally {
globalThis.devicePixelRatio = display;
}
assert.equal(nearImageSwitchPx(0), 76, 'no ratio: 1');
assert.equal(nearImageSwitchPx(NaN), 76);
const { part, draw } = drawOver();
const set = draw.icons({ id: 'gpu:switch-px' });
set.set([
icon('a', {
motion: { kind: 'hold' },
imageLod: { near: 'near.png', switchPx: nearImageSwitchPx(2) },
}),
]);
const { set: rowsOf } = rows(part, 'gpu:switch-px');
// Stored as given: the shader (not run here) switches past it in CSS
// pixels, the drawn width over the scene's pixel ratio.
assert.equal(rowsOf.imageSwitch(rowsOf.row('a')), 38);
});
test('the atlas holds more than 64 images, every one addressed on WebGL 2', async () => {
const { addressableIconSlots, MIN_ICON_SLOTS } =
await import('../../data/iconAtlas.js');
assert.ok(MAX_ICON_SLOTS > 64);
assert.equal(addressableIconSlots(256), MAX_ICON_SLOTS, 'WebGL 2’s least');
assert.equal(addressableIconSlots(4096), MAX_ICON_SLOTS);
assert.equal(addressableIconSlots(128), MIN_ICON_SLOTS, 'WebGL 1’s least');
assert.equal(addressableIconSlots(200), 120);
const { contextIconSlots } = await import('./iconSetPrimitive.js');
const limits = Cesium.ContextLimits;
const vectors = limits._maximumVertexUniformVectors;
try {
limits._maximumVertexUniformVectors = 4095;
assert.equal(contextIconSlots({}), MAX_ICON_SLOTS);
limits._maximumVertexUniformVectors = 128;
assert.equal(contextIconSlots({}), MIN_ICON_SLOTS);
} finally {
limits._maximumVertexUniformVectors = vectors;
}
assert.equal(contextIconSlots(undefined), MAX_ICON_SLOTS, 'no context');
// A scene whose context addresses fewer refuses past them, as before.
const small = drawOver();
// (No context created here: ContextLimits leave the least.)
small.scene.context = {};
const tight = small.draw.icons({ id: 'gpu:tight-context' });
assert.throws(
() =>
tight.set(
Array.from({ length: MIN_ICON_SLOTS + 1 }, (_, i) =>
icon(`t${i}`, { image: `tight-${i}.png`, motion: { kind: 'hold' } }),
),
),
/no room for .* \(at most 64 in all\)/,
);
assert.equal(addressableIconSlots(0), MIN_ICON_SLOTS, 'no context yet');
assert.equal(addressableIconSlots(NaN), MIN_ICON_SLOTS);
// A set of more images than 64 is drawn, not refused.
const { part, draw } = drawOver();
const set = draw.icons({ id: 'gpu:many-images' });
const items = Array.from({ length: 70 }, (_, i) =>
icon(`i${i}`, { image: `many-${i}.png`, motion: { kind: 'hold' } }),
);
set.set(items);
const { set: rowsOf } = rows(part, 'gpu:many-images');
assert.equal(rowsOf.count, 70);
const slots = new Set(
items.map((item) => rowsOf.imageFar(rowsOf.row(item.id))),
);
assert.equal(slots.size, 70, 'each its own slot');
});
test('a GPU icon set asks the frame port for its atlas frames, under its own reason', async () => {
const { iconAtlas } = await import('../../data/iconAtlas.js');
const onChange = iconAtlas.onChange;
const heard = [];
iconAtlas.onChange = (listener) => (heard.push(listener), () => {});
try {
const reasons = [];
const { scene, draw } = drawOver({
requestRender: (reason) => reasons.push(reason),
});
const set = draw.icons({ id: 'gpu:reason' });
set.set([icon('a', { motion: { kind: 'hold' } })]);
assert.equal(heard.length, 1, 'its host listens for packed images');
const before = scene.renders;
heard[0]();
assert.deepEqual(reasons, ['icons:gpu:reason']);
assert.equal(scene.renders, before, 'through the frame port only');
set.dispose();
// With no frame port, the scene's own request, as before.
const bare = drawOver();
const bareSet = bare.draw.icons({ id: 'gpu:bare' });
bareSet.set([icon('a', { motion: { kind: 'hold' } })]);
assert.equal(heard.length, 2);
const was = bare.scene.renders;
heard[1]();
assert.equal(bare.scene.renders, was + 1);
bareSet.dispose();
} finally {
iconAtlas.onChange = onChange;
}
});