import assert from 'node:assert/strict'; import * as Cesium from 'cesium'; import test from 'node:test'; import { bindRenderer, drawOf, findDraw } from '../rendererOf.js'; import { createCesiumDraw, FEW_LOOSE_LINES, LONG_SETTLE_FRAMES, MOVING_SHAPES, revealUniform, SETTLE_FRAMES, unboundDrawPart, } from './draw.js'; import { drawHitOf } from './drawHit.js'; import { MODEL_RETRY_MS } from './drawModels.js'; import { spriteDrawOrder } from '../../data/spriteOrder.js'; // Node has no WebGL context to report line-width limits. Cesium.ContextLimits._minimumAliasedLineWidth = 1; Cesium.ContextLimits._maximumAliasedLineWidth = 10; /** A scene with what the draw port touches: primitives and its events. */ function fakeScene() { const added = []; const postRender = new Cesium.Event(); const preRender = new Cesium.Event(); return { added, postRender, preRender, camera: { positionWC: new Cesium.Cartesian3(2e7, 0, 0) }, frameState: { mode: Cesium.SceneMode.SCENE3D }, // Clamped billboards ask the scene to follow the ground. clamped: [], updateHeight(position, update, heightReference) { this.clamped.push(heightReference); return () => {}; }, getHeight: () => undefined, 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, }, destroyed: false, requestRender() { if (this.destroyed) throw new Error('This object was destroyed'); }, isDestroyed() { return this.destroyed; }, }; } test('a viewer of its own, with no renderer bound, draws through a built port', () => { const scene = fakeScene(); const viewer = { scene, isDestroyed: () => destroyed }; let destroyed = false; const draw = drawOf(viewer); assert.equal(findDraw(viewer), draw, 'one per viewer'); const set = draw.points({ id: 'mine' }); set.set([{ id: 'a', pos: { lon: 0, lat: 0 }, pixelSize: 4, color: '#fff' }]); assert.equal(scene.added.length, 1, 'drawn into the viewer’s scene'); assert.equal(scene.added[0].get(0).id.set, 'mine'); // A renderer bound later answers new callers; the sets keep drawing. const unbind = bindRenderer(viewer, { draw: { id: 'renderer' } }); assert.equal(findDraw(viewer).id, 'renderer'); assert.equal(scene.added.length, 1); set.dispose(); assert.equal(scene.added.length, 0); unbind(); // Gone with its viewer, a built port lets go; a set its layer disposes // after that has nothing left to do. const again = drawOf(viewer); assert.notEqual(again, draw); const late = again.points({ id: 'left' }); late.set([]); destroyed = true; scene.destroyed = true; assert.equal(findDraw(viewer), null); late.dispose(); }); test('nothing to draw into, no port', () => { assert.equal(findDraw({ scene: {} }), null); assert.throws(() => drawOf({}), /no renderer to draw with/); }); /** A draw port over a fake scene, with its frame hooks. */ function drawOver(scene = fakeScene()) { const viewer = { scene }; const draw = drawOf(viewer); return { scene, draw, frame() { scene.preRender.raiseEvent(); scene.postRender.raiseEvent(); }, }; } test('a clamped point is a billboard dot that follows the ground; others stay points', () => { const { scene, draw } = drawOver(); const set = draw.points({ id: 'dots', clampTo: 'both' }); set.set([ { id: 'ground', pos: { lon: 10, lat: 20 }, height: 'clampGround', pixelSize: 9, color: '#7fe6ed', outlineColor: '#000', outlineWidth: 2, disableDepthTest: Infinity, }, { id: 'free', pos: { lon: 0, lat: 0 }, pixelSize: 4, color: '#fff' }, ]); const host = scene.added[0]; assert.ok(host instanceof Cesium.PrimitiveCollection, 'both kinds'); const points = host.get(0); const dots = host.get(1); assert.ok(points instanceof Cesium.PointPrimitiveCollection); assert.ok(dots instanceof Cesium.BillboardCollection); const dot = dots.get(0); assert.equal(dot.heightReference, Cesium.HeightReference.CLAMP_TO_GROUND); assert.equal(dot.disableDepthTestDistance, Infinity); assert.equal(dot.scale, 1, 'an outlined dot is drawn at its size'); assert.deepEqual(scene.clamped, [Cesium.HeightReference.CLAMP_TO_GROUND]); assert.deepEqual(dot.id, { set: 'dots', id: 'ground', meta: undefined, }); set.dispose(); }); test('horizonCull hides points past the horizon each frame, and shows them again', () => { const { scene, draw, frame } = drawOver(); const set = draw.points({ id: 'cull', horizonCull: true }); const near = { lon: 0, lat: 0 }; const far = { lon: 180, lat: 0 }; set.set([ { id: 'near', pos: near, pixelSize: 4, color: '#fff' }, { id: 'far', pos: far, pixelSize: 4, color: '#fff' }, { id: 'hidden', pos: near, pixelSize: 4, color: '#fff', show: false }, ]); const host = scene.added[0]; frame(); assert.deepEqual( [0, 1, 2].map((i) => host.get(i).show), [true, false, false], ); scene.camera.positionWC = new Cesium.Cartesian3(-2e7, 0, 0); frame(); assert.deepEqual( [0, 1, 2].map((i) => host.get(i).show), [false, true, false], 'the eye moved round', ); set.setOptions({ horizonCull: false }); assert.deepEqual( [0, 1, 2].map((i) => host.get(i).show), [true, true, false], 'uncull shows what the cull hid, not what was hidden', ); set.dispose(); }); test('draped lines are ground polylines; a rebuild keeps the old ones until the new are ready', () => { const { scene, draw, frame } = drawOver(); const set = draw.lines({ id: 'tracks' }); const line = (id) => ({ id, positions: [ { lon: 0, lat: 0 }, { lon: 1, lat: 1 }, ], widthPx: 2.5, mode: 'draped', style: { kind: 'solid', color: '#7fe6ed' }, }); set.set([line('a')]); const first = scene.added[0]; const ground = first.get(1); assert.ok(ground instanceof Cesium.GroundPolylinePrimitive); assert.equal(ground.classificationType, Cesium.ClassificationType.BOTH); assert.equal(ground.geometryInstances[0].geometry.width, 2.5); assert.deepEqual(ground.geometryInstances[0].id.id, 'a'); // Still not ready: the first build is all there is. set.set([line('a'), line('b')]); assert.deepEqual(scene.added.length, 1, 'an unready host is dropped'); const second = scene.added[0]; Object.defineProperty(second.get(1), 'ready', { value: true }); frame(); assert.equal(second.get(1).show, true, 'shown once ready'); set.set([line('c')]); assert.equal(scene.added.length, 2, 'the ready one stays until…'); const third = scene.added[1].get(1); assert.equal(third.show, false, 'the new one hidden while it builds'); frame(); assert.equal(scene.added.length, 2); Object.defineProperty(third, 'ready', { value: true }); frame(); assert.equal(scene.added.length, 1, '…the new one is ready'); assert.equal(third.show, true, 'and they swap in one frame'); set.dispose(); assert.equal(scene.added.length, 0); }); test('a draped outlined line keeps its outline in its own material', () => withImageClasses(() => { const { scene, draw } = drawOver(); const set = draw.lines({ id: 'edged' }); set.set([ { id: 'a', positions: [ { lon: 0, lat: 0 }, { lon: 1, lat: 1 }, ], widthPx: 6, mode: 'draped', style: { kind: 'solid', color: '#7fe6ed', outline: { color: '#000000', widthPx: 2 }, }, }, ]); const host = scene.added[0]; const grounds = []; for (let i = 0; i < host.length; i++) if (host.get(i) instanceof Cesium.GroundPolylinePrimitive) grounds.push(host.get(i)); assert.equal(grounds.length, 1); const { material } = grounds[0].appearance; assert.equal(material.type, 'PolylineOutline'); assert.equal(material.uniforms.outlineWidth, 2); set.dispose(); })); test('clamped fills are ground primitives packed so none overlap within one', () => { const { scene, draw } = drawOver(); const set = draw.shapes({ id: 'discs' }); const disc = (id, lon, fill = [1, 0, 0, 0.3]) => ({ id, geometry: { kind: 'ellipse', center: { lon, lat: 0 }, semiMajor: 100_000, semiMinor: 100_000, }, fill, height: 'clampGround', }); set.set([disc('a', 0), disc('b', 0.5), disc('c', 30, '#ff0'), disc('x', 60)]); const host = scene.added[0]; const grounds = []; for (let i = 0; i < host.length; i++) if (host.get(i) instanceof Cesium.GroundPrimitive) grounds.push(host.get(i)); assert.deepEqual( grounds.map((g) => g.geometryInstances.map((instance) => instance.id.id)), [['a', 'c', 'x'], ['b']], ); set.dispose(); }); test('a clamped outline is a draped line under its shape’s pick id, a ring each', () => { const { scene, draw } = drawOver(); const set = draw.shapes({ id: 'outlined' }); set.set([ { id: 'o', geometry: { kind: 'polygon', rings: [ [ { lon: 0, lat: 0 }, { lon: 1, lat: 0 }, { lon: 1, lat: 1 }, ], [ { lon: 0.5, lat: 0.2 }, { lon: 0.7, lat: 0.2 }, { lon: 0.7, lat: 0.4 }, ], ], }, fill: [1, 0, 0, 0.3], outline: '#fff', outlineWidth: 3, height: 'clampGround', }, { id: 'r', geometry: { kind: 'rectangle', rect: { west: 2, south: 0, east: 3, north: 1 }, }, outline: '#0f0', outlineOnly: true, height: 'clampGround', }, ]); const host = scene.added[0]; const lines = []; for (let i = 0; i < host.length; i++) if (host.get(i) instanceof Cesium.GroundPolylinePrimitive) lines.push(host.get(i)); assert.deepEqual( lines.map((l) => l.geometryInstances.map((g) => [g.id.id, g.geometry._positions.length]), ), [ [ ['o', 4], ['o', 4], ], [['r', 5]], ], 'closed rings', ); assert.equal(lines[0].geometryInstances[0].geometry.width, 3); set.dispose(); }); test('a pulsing clamped outline pulses its alpha through its material', () => withImageClasses(() => { const { scene, draw, frame } = drawOver(); const set = draw.shapes({ id: 'pulsing-outline' }); set.set([ { id: 'r', geometry: { kind: 'rectangle', rect: { west: 2, south: 0, east: 3, north: 1 }, }, outline: '#00ff00', outlineOnly: true, height: 'clampGround', animate: { property: 'alpha', from: 0.2, to: 0.2, periodMs: 1000 }, }, ]); const host = scene.added[0]; let line; for (let i = 0; i < host.length; i++) if (host.get(i) instanceof Cesium.GroundPolylinePrimitive) line = host.get(i); assert.ok(line.appearance instanceof Cesium.PolylineMaterialAppearance); frame(); const colour = line.appearance.material.uniforms.color; assert.deepEqual( [colour.green, Math.round(colour.alpha * 100) / 100], [1, 0.2], ); set.dispose(); })); test('where the scene cannot drape materials, a clamped image fill lies on the surface', () => withImageClasses(() => { const scene = fakeScene(); scene.context = { depthTexture: false }; const { draw } = drawOver(scene); const set = draw.shapes({ id: 'flat-image' }); set.set([ { id: 'pic', geometry: { kind: 'rectangle', rect: { west: 0, south: 0, east: 0.01, north: 0.01 }, }, fill: { image: 'pic.png' }, height: 'clampGround', }, ]); const found = []; const walk = (primitive) => { if (primitive instanceof Cesium.PrimitiveCollection) for (let i = 0; i < primitive.length; i++) walk(primitive.get(i)); else found.push(primitive); }; scene.added.forEach(walk); const fill = found.find((p) => p instanceof Cesium.Primitive); assert.ok(fill, 'an unclamped primitive'); assert.ok(!found.some((p) => p instanceof Cesium.GroundPrimitive)); assert.equal(fill.appearance.material.type, 'Image'); set.dispose(); })); test('clamped extruded shapes and walls stand on the surface, unclamped', () => { const scene = fakeScene(); scene.globe = { show: true, getHeight: () => 120 }; const { draw } = drawOver(scene); const set = draw.shapes({ id: 'standing' }); set.set([ { id: 'block', geometry: { kind: 'polygon', rings: [ [ { lon: 0, lat: 0 }, { lon: 0.01, lat: 0 }, { lon: 0.01, lat: 0.01 }, ], ], }, fill: '#f00', extrudeHeight: 400, height: 'clampGround', }, { id: 'fence', geometry: { kind: 'wall', positions: [ { lon: 0, lat: 0, height: 10 }, { lon: 0.01, lat: 0, height: 20 }, ], }, fill: '#00f', height: 'clampGround', }, ]); const geometries = new Map(); const walk = (primitive) => { if (!primitive) return; if (primitive instanceof Cesium.PrimitiveCollection) for (let i = 0; i < primitive.length; i++) walk(primitive.get(i)); assert.ok(!(primitive instanceof Cesium.GroundPrimitive), 'not draped'); for (const instance of [primitive.geometryInstances ?? []].flat()) geometries.set(instance.id?.id, instance.geometry); }; scene.added.forEach(walk); const block = geometries.get('block'); assert.ok(block instanceof Cesium.PolygonGeometry); assert.deepEqual( [block._height, block._extrudedHeight].sort((a, b) => a - b), [120, 400], 'from the surface up to its extruded height', ); const fence = geometries.get('fence'); assert.ok(fence instanceof Cesium.WallGeometry); assert.deepEqual(fence._minimumHeights, [120, 120], 'its foot on it'); assert.deepEqual(fence._maximumHeights, [130, 140], 'its heights above it'); set.dispose(); }); test('a set that never picks keeps its ground fills and draped lines out of picks', () => { const { scene, draw } = drawOver(); const fills = draw.shapes({ id: 'cells', pickable: false }); const square = { id: 'a', geometry: { kind: 'rectangle', rect: { west: 0, south: 0, east: 1, north: 1 }, }, fill: [1, 0, 0, 0.3], height: 'clampGround', }; fills.set([square]); const groundOf = (host) => { for (let i = 0; i < host.length; i++) if (host.get(i) instanceof Cesium.GroundPrimitive) return host.get(i); return null; }; const passes = (primitive) => { const seen = []; const update = Cesium.GroundPrimitive.prototype.update; Cesium.GroundPrimitive.prototype.update = function (frameState) { seen.push(frameState.passes.pick ? 'pick' : 'render'); }; try { primitive.update({ passes: { pick: true } }); primitive.update({ passes: { render: true } }); } finally { Cesium.GroundPrimitive.prototype.update = update; } return seen; }; let ground = groundOf(scene.added[0]); assert.equal(ground.allowPicking, false); assert.deepEqual(passes(ground), ['render'], 'no pick pass at all'); // Whether it picks is built into the primitives: a change rebuilds them. fills.setOptions({ pickable: true }); ground = groundOf(scene.added.at(-1)); assert.equal(ground.allowPicking, true); assert.deepEqual(passes(ground), ['pick', 'render']); // Stopping picks drops the old, pickable ground at once, before the new // ground is ready: kept drawing, it would still hide the ground from picks. fills.setOptions({ pickable: false }); assert.equal(scene.added.length, 1, 'only the new host is drawn'); assert.equal(groundOf(scene.added[0]).allowPicking, false); fills.dispose(); const lines = draw.lines({ id: 'edges', pickable: false }); lines.set([ { id: 'e', positions: [ Cesium.Cartesian3.fromDegrees(0, 0), Cesium.Cartesian3.fromDegrees(1, 0), ], widthPx: 2, mode: 'draped', style: { kind: 'solid', color: '#fff' }, }, ]); const host = scene.added.at(-1); let draped = null; for (let i = 0; i < host.length; i++) if (host.get(i) instanceof Cesium.GroundPolylinePrimitive) draped = host.get(i); assert.equal(draped.allowPicking, false); lines.dispose(); assert.equal(scene.added.length, 0); }); test('changing what a set clamps to rebuilds its items', () => { const { scene, draw } = drawOver(); const set = draw.points({ id: 'reclamp', clampTo: 'terrain' }); set.set([ { id: 'p', pos: { lon: 0, lat: 0 }, height: 'clampGround', pixelSize: 4, color: '#fff', }, ]); assert.equal( scene.added[0].get(0).heightReference, Cesium.HeightReference.CLAMP_TO_TERRAIN, ); set.setOptions({ clampTo: 'tiles' }); assert.equal( scene.added[0].get(0).heightReference, Cesium.HeightReference.CLAMP_TO_3D_TILE, ); set.dispose(); }); test('while a rebuild builds, only the old ground waits: the rest goes at once', () => { const { scene, draw, frame } = drawOver(); const set = draw.shapes({ id: 'mixed' }); const disc = (id, height) => ({ id, geometry: { kind: 'ellipse', center: { lon: 0, lat: 0 }, semiMajor: 1000, semiMinor: 1000, }, fill: '#fff', ...(height ? { height } : {}), }); const items = [disc('ground', 'clampGround'), disc('raised')]; set.set(items); const first = scene.added[0]; const ground = first.get(1); assert.ok(ground instanceof Cesium.GroundPrimitive); Object.defineProperty(ground, 'ready', { value: true }); frame(); set.set(items); assert.equal(scene.added.length, 2); assert.equal(first.length, 1, 'the old raised fill is gone'); assert.equal(first.get(0), ground, 'its ground fill waits'); set.dispose(); assert.equal(scene.added.length, 0); }); test('a clamped fill that only shows, hides or changes meta is changed in place', () => { const { scene, draw, frame } = drawOver(); const set = draw.shapes({ id: 'toggles' }); // Apart, so one ground primitive holds them all. const rings = new Map( ['a', 'b', 'c'].map((id, i) => [ id, [ { lon: i, lat: 0 }, { lon: i + 0.1, lat: 0 }, { lon: i + 0.1, lat: 0.1 }, ], ]), ); const fill = (id, show, meta = undefined) => ({ id, geometry: { kind: 'polygon', rings: [rings.get(id)] }, fill: [1, 0, 0, 0.3], height: 'clampGround', show, meta, }); set.set([fill('a', true), fill('b', false)]); const host = scene.added[0]; const groundOf = (h) => { for (let i = 0; i < h.length; i++) if (h.get(i) instanceof Cesium.GroundPrimitive) return h.get(i); return null; }; const ground = groundOf(host); // A hidden one is built too, hidden. const instances = ground.geometryInstances; assert.deepEqual( instances.map((instance) => [ instance.id.id, [...instance.attributes.show.value], ]), [ ['a', [1]], ['b', [0]], ], ); const shows = new Map( instances.map((instance) => [ instance.id, { show: Uint8Array.from(instance.attributes.show.value) }, ]), ); const byItem = (id) => instances.find((i) => i.id.id === id).id; ground.getGeometryInstanceAttributes = (id) => shows.get(id); // Still building: the show waits for the swap. set.upsert([fill('b', true, { n: 1 })]); assert.equal(scene.added[0], host, 'not rebuilt'); assert.deepEqual([...shows.get(byItem('b')).show], [0]); assert.deepEqual(byItem('b').meta, { n: 1 }, 'meta changed in place'); Object.defineProperty(ground, 'ready', { value: true }); frame(); assert.deepEqual([...shows.get(byItem('b')).show], [1]); // Ready: written at once. set.upsert([fill('a', false), fill('b', true, { n: 1 })]); assert.equal(scene.added[0], host, 'still not rebuilt'); assert.deepEqual([...shows.get(byItem('a')).show], [0]); // The same look written out anew is the same look. set.upsert([ { ...fill('a', true), geometry: { kind: 'polygon', rings: [[...rings.get('a')]] }, }, ]); assert.equal(scene.added[0], host); assert.deepEqual([...shows.get(byItem('a')).show], [1]); // An item changed in place is a new look: it rebuilds. const reused = fill('a', true); set.upsert([reused]); assert.equal(scene.added[0], host); reused.geometry.rings[0][0] = { lon: 0.05, lat: 0 }; set.upsert([reused]); assert.notEqual(scene.added.at(-1), host, 'a moved corner rebuilds'); Object.defineProperty(groundOf(scene.added.at(-1)), 'ready', { value: true, }); frame(); const moved = scene.added.at(-1); // A new colour is written in place too. const colours = new Map(); groundOf(moved).getGeometryInstanceAttributes = (id) => { if (!colours.has(id.id)) colours.set(id.id, { color: new Uint8Array(4), show: new Uint8Array([1]), }); return colours.get(id.id); }; set.upsert([{ ...fill('a', true), fill: [0, 1, 0, 0.3] }]); assert.equal(scene.added.at(-1), moved, 'a new colour does not rebuild'); assert.deepEqual([...colours.get('a').color], [0, 255, 0, 76]); // A new item rebuilds. set.upsert([fill('c', true)]); assert.notEqual(scene.added.at(-1), moved, 'a new item rebuilds'); set.dispose(); assert.equal(scene.added.length, 0); }); test('hidden clamped fills wait for nothing, and the hidden ones it cannot build stay out', () => { const { scene, draw, frame } = drawOver(); const set = draw.shapes({ id: 'hide-all' }); const fill = (id, lon, show, extra = {}) => ({ id, geometry: { kind: 'ellipse', center: { lon, lat: 0 }, semiMajor: 1000, semiMinor: 1000, }, fill: '#fff', height: 'clampGround', show, ...extra, }); const groundsIn = (host) => { const found = []; for (let i = 0; i < host.length; i++) if (host.get(i) instanceof Cesium.GroundPrimitive) found.push(host.get(i)); return found; }; set.set([fill('a', 0, true), fill('b', 1, true)]); const first = scene.added[0]; Object.defineProperty(groundsIn(first)[0], 'ready', { value: true }); frame(); // Everything hidden: nothing to wait for, the old fills go at once. set.set([fill('a', 0, false), fill('b', 1, false)]); assert.equal(scene.added.length, 1, 'the old host is gone'); assert.notEqual(scene.added[0], first); // Hidden ones it could not draw shown are left out, as before. assert.doesNotThrow(() => set.set([ fill('a', 0, false, { outline: '#000' }), fill('b', 1, false, { extrudeHeight: 10 }), fill('c', 2, false, { fill: { gradient: 'radial' } }), ]), ); assert.equal(groundsIn(scene.added.at(-1)).length, 0); set.dispose(); assert.equal(scene.added.length, 0); }); test('a show patched while a rebuild waits lands on the new fills, the old ones keep drawing', () => { const { scene, draw, frame } = drawOver(); const set = draw.shapes({ id: 'patch-pending' }); const fill = (id, lon, show, color = '#fff') => ({ id, geometry: { kind: 'ellipse', center: { lon, lat: 0 }, semiMajor: 1000, semiMinor: 1000, }, fill: color, height: 'clampGround', show, }); const groundOf = (host) => { for (let i = 0; i < host.length; i++) if (host.get(i) instanceof Cesium.GroundPrimitive) return host.get(i); return null; }; set.set([fill('a', 0, true), fill('b', 1, true)]); const first = scene.added[0]; Object.defineProperty(groundOf(first), 'ready', { value: true }); frame(); // A new colour rebuilds; the old fills draw until the new ones are ready. set.set([fill('a', 0, true, '#f00'), fill('b', 1, true, '#f00')]); const second = scene.added.at(-1); assert.equal(scene.added.length, 2, 'the old host waits'); const ground = groundOf(second); const shows = new Map( ground.geometryInstances.map((instance) => [ instance.id, { show: Uint8Array.from(instance.attributes.show.value) }, ]), ); ground.getGeometryInstanceAttributes = (id) => shows.get(id); const idOf = (item) => ground.geometryInstances.find((i) => i.id.id === item).id; set.upsert([fill('b', 1, false, '#f00')]); set.upsert([fill('b', 1, true, '#f00')]); set.upsert([fill('a', 0, false, '#f00')]); assert.equal(scene.added.at(-1), second, 'patched, not rebuilt'); assert.deepEqual([...shows.get(idOf('a')).show], [1], 'queued until ready'); Object.defineProperty(ground, 'ready', { value: true }); frame(); assert.equal(scene.added.length, 1, 'swapped'); assert.deepEqual([...shows.get(idOf('a')).show], [0]); assert.deepEqual([...shows.get(idOf('b')).show], [1], 'the last write wins'); // A rebuild after a patch builds the patched show. set.upsert([fill('c', 2, true, '#f00')]); const third = groundOf(scene.added.at(-1)); assert.deepEqual( third.geometryInstances.map((instance) => [ instance.id.id, [...instance.attributes.show.value], ]), [ ['a', [0]], ['b', [1]], ['c', [1]], ], ); set.dispose(); assert.equal(scene.added.length, 0); }); test('clamped shapes refuse what they cannot draw', () => { const { draw } = drawOver(); const set = draw.shapes({ id: 'refuse' }); const disc = { id: 'a', geometry: { kind: 'ellipse', center: { lon: 0, lat: 0 }, semiMajor: 1000, semiMinor: 1000, }, fill: '#fff', height: 'clampGround', }; // A fill that is neither a colour nor an image. assert.throws( () => set.set([{ ...disc, fill: { gradient: 'radial' } }]), /colours only/, ); set.dispose(); }); test('a clamped colour ring whose radius alone changes is drawn alone where it now is', () => withTerrainHeights(() => { const scene = fakeScene(); const { draw, frame } = drawOver(scene); const set = draw.shapes({ id: 'rings' }); // The app follows the camera's height and sends the radius it wants, as // annotation target rings do. const ring = (radius, show = true) => ({ id: 'ring', geometry: { kind: 'ellipse', center: { lon: 0, lat: 0 }, semiMajor: radius, semiMinor: radius, }, fill: [0.5, 0.9, 1, 0.38], height: 'clampGround', show, }); set.set([ring(60)]); const host = scene.added[0]; const radiusIn = (ground) => ground.geometryInstances[0].geometry._semiMajorAxis; const last = () => host.get(host.length - 1); assert.equal(radiusIn(last()), 60); const built = last(); frame(); assert.equal(last(), built, 'nothing built while nothing changes'); // Wider: drawn alone, built in this frame, under its own pick id. set.upsert([ring(120)]); const wider = last(); assert.notEqual(wider, built); assert.equal(wider.asynchronous, false); assert.equal(radiusIn(wider), 120); assert.equal(wider.geometryInstances[0].id.id, 'ring', 'its own pick id'); set.upsert([ring(14)]); assert.equal(radiusIn(last()), 14); assert.equal(scene.added[0], host, 'never a rebuild of the set'); set.dispose(); assert.equal(scene.added.length, 0); })); test('a semi-minor axis longer than the semi-major is drawn as the major axis, a quarter turn on', () => withTerrainHeights(() => { const scene = fakeScene(); const { draw } = drawOver(scene); const set = draw.shapes({ id: 'crossing' }); set.set([ { id: 'r', geometry: { kind: 'ellipse', center: { lon: 0, lat: 0 }, semiMajor: 30, semiMinor: 50, rotation: 0.25, }, fill: [0.5, 0.9, 1, 0.38], height: 'clampGround', }, ]); const host = scene.added[0]; let ground = null; for (let i = 0; i < host.length; i++) if (host.get(i) instanceof Cesium.GroundPrimitive) ground = host.get(i); const geometry = ground.geometryInstances[0].geometry; assert.equal(geometry._semiMajorAxis, 50); assert.equal(geometry._semiMinorAxis, 30); assert.ok(Math.abs(geometry._rotation - (0.25 + Math.PI / 2)) < 1e-12); set.dispose(); })); test('rings that would be drawn alone past the cap rebuild their set, counting those a retiring host draws alone', () => withTerrainHeights(() => { const scene = fakeScene(); const { draw, frame } = drawOver(scene); const set = draw.shapes({ id: 'climbing' }); const ring = (i, radius) => ({ id: `r${i}`, geometry: { kind: 'ellipse', center: { lon: i * 0.1, lat: 0 }, semiMajor: radius, semiMinor: radius, }, fill: [0.5, 0.9, 1, 0.38], height: 'clampGround', }); const all = (radius, from = 0, to = MOVING_SHAPES + 4) => Array.from({ length: to - from }, (_, k) => ring(from + k, radius)); const ready = (host) => { for (let i = 0; i < host.length; i++) if (host.get(i) instanceof Cesium.GroundPrimitive) { Object.defineProperty(host.get(i), 'ready', { value: true }); host.get(i).getGeometryInstanceAttributes = () => ({ show: new Uint8Array([1]), }); } }; const solo = (host) => { let n = 0; for (let i = 0; i < host.length; i++) { const p = host.get(i); if (p instanceof Cesium.GroundPrimitive && p.asynchronous === false) n += 1; } return n; }; set.set(all(30)); const first = scene.added[0]; ready(first); frame(); // The cap moves alone. set.upsert(all(45, 0, MOVING_SHAPES)); assert.equal(solo(first), MOVING_SHAPES); assert.equal(scene.added.at(-1), first); // One more would pass it: the set rebuilds, the old host retiring. set.upsert(all(45, MOVING_SHAPES)); const second = scene.added.at(-1); assert.notEqual(second, first, 'rebuilding, the old host retiring'); ready(second); // While the old host retires, its rings drawn alone still count, so // none more are drawn alone. set.upsert([ring(0, 75)]); assert.equal(solo(second), 0, 'nothing more drawn alone'); set.dispose(); })); test('shapes that only change colour, pulse, show or meta change in place; a pulse runs on the frames', () => withTerrainHeights(() => { const scene = fakeScene(); const asked = []; scene.requestRender = () => asked.push(1); const { draw, frame } = drawOver(scene); const set = draw.shapes({ id: 'fading' }); const ring = [ { lon: 0, lat: 0, height: 10 }, { lon: 0.001, lat: 0, height: 10 }, { lon: 0.001, lat: 0.001, height: 10 }, ]; const pulse = (alpha) => ({ property: 'alpha', from: alpha * 0.6, to: alpha, periodMs: 1000, }); const column = (alpha, extra = {}) => ({ id: 'column', geometry: { kind: 'polygon', rings: [ring] }, fill: [1, 0.7, 0.3, 0.45 * alpha], animate: pulse(0.45 * alpha), extrudeHeight: 100, height: 'absolute', ...extra, }); const cage = (alpha) => ({ id: 'cage', geometry: { kind: 'polygon', rings: [ring] }, outline: [1, 0.7, 0.3, 0.32 * alpha], outlineOnly: true, animate: pulse(0.32 * alpha), extrudeHeight: 100, height: 'absolute', }); const fill = (alpha) => ({ id: 'fill', geometry: { kind: 'polygon', rings: [ring.map(({ lon, lat }) => ({ lon: lon + 1, lat }))], }, fill: [0.4, 1, 0.6, 0.2 * alpha], animate: pulse(0.2 * alpha), height: 'clampGround', }); set.set([column(0), cage(0), fill(0)]); const host = scene.added[0]; const solids = host.get(0); const [columnPrimitive, cagePrimitive] = [solids.get(0), solids.get(1)]; let ground = null; for (let i = 0; i < host.length; i++) if (host.get(i) instanceof Cesium.GroundPrimitive) ground = host.get(i); // A pulsing colour draws translucent, whatever its alpha now. assert.equal(columnPrimitive.appearance.translucent, true); assert.equal(cagePrimitive.appearance.translucent, true); // Ready, with instance attributes to write. const colours = new Map(); const ready = (primitive, key) => { Object.defineProperty(primitive, 'ready', { value: true }); primitive.getGeometryInstanceAttributes = () => { if (!colours.has(key)) colours.set(key, { color: new Uint8Array(4), show: new Uint8Array([1]), }); return colours.get(key); }; }; ready(columnPrimitive, 'column'); ready(cagePrimitive, 'cage'); ready(ground, 'fill'); frame(); // Faded in: the same primitives take it. set.upsert([column(1, { meta: 'm' }), cage(1), fill(1)]); assert.equal(scene.added[0], host, 'not rebuilt'); assert.equal(solids.get(0), columnPrimitive); assert.equal(columnPrimitive.geometryInstances.id.meta, 'm'); // The pulse writes each frame between 60% and all of the alpha, and asks // for the next frame. const seen = { column: [], cage: [], fill: [] }; const realNow = performance.now; let now = 0; performance.now = () => now; try { for (now = 0; now < 1000; now += 50) { asked.length = 0; frame(); assert.ok(asked.length > 0, 'a pulse asks for frames'); for (const key of Object.keys(seen)) seen[key].push(colours.get(key).color[3] / 255); } } finally { performance.now = realNow; } const range = (values) => [Math.min(...values), Math.max(...values)]; const near = (a, b) => Math.abs(a - b) < 0.01; assert.ok( near(range(seen.column)[0], 0.27) && near(range(seen.column)[1], 0.45), `${range(seen.column)}`, ); assert.ok( near(range(seen.cage)[0], 0.192) && near(range(seen.cage)[1], 0.32), `${range(seen.cage)}`, ); assert.ok( near(range(seen.fill)[0], 0.12) && near(range(seen.fill)[1], 0.2), `${range(seen.fill)}`, ); // Hidden in place: its primitives hide, and stop pulsing. set.upsert([column(1, { show: false })]); assert.equal(scene.added[0], host); assert.equal(columnPrimitive.show, false); // An opaque colour drawn translucent is fine in place; a shape that // changes more than its colours rebuilds. set.upsert([column(1, { extrudeHeight: 200 })]); assert.notEqual(scene.added.at(-1), host, 'rebuilt'); set.dispose(); })); test('colour fills carry what their appearance reads, as entities do', () => withImageClasses(() => { const { scene, draw } = drawOver(); const set = draw.shapes({ id: 'formats' }); const ring = [ { lon: 0, lat: 0, height: 10 }, { lon: 0.001, lat: 0, height: 10 }, { lon: 0.001, lat: 0.001, height: 10 }, ]; set.set([ { id: 'column', geometry: { kind: 'polygon', rings: [ring] }, fill: [1, 0.7, 0.3, 0.45], extrudeHeight: 100, height: 'absolute', }, { id: 'disc', geometry: { kind: 'ellipse', center: { lon: 2, lat: 0, height: 10 }, semiMajor: 50, semiMinor: 30, }, fill: '#fff', extrudeHeight: 40, height: 'absolute', }, { id: 'slab', geometry: { kind: 'rectangle', rect: { west: 3, south: 0, east: 3.01, north: 0.01 }, height: 10, }, fill: '#fff', extrudeHeight: 40, height: 'absolute', }, ]); const host = scene.added[0]; const formats = []; const walk = (c) => { for (let i = 0; i < c.length; i++) { const p = c.get(i); if (typeof p.length === 'number' && p.get) walk(p); else if (p instanceof Cesium.Primitive && p.geometryInstances?.geometry) formats.push(p.geometryInstances.geometry._vertexFormat); } }; walk(host); assert.equal(formats.length, 3); // Position and normal only: with texture coordinates too, Cesium packs // them with the normals, and the colour appearance misreads them. for (const format of formats) { assert.equal(format.normal, true); assert.equal(format.st, false); } set.dispose(); })); test('a pulse the Cesium renderer cannot run is refused before anything changes', () => { const { scene, draw } = drawOver(); const set = draw.shapes({ id: 'pulses' }); const disc = (animate) => ({ id: 'a', geometry: { kind: 'ellipse', center: { lon: 0, lat: 0 }, semiMajor: 1000, semiMinor: 1000, }, fill: '#fff', height: 'clampGround', animate, }); set.set([disc(undefined)]); const host = scene.added[0]; assert.throws( () => set.set([disc({ property: 'radius', from: 1, to: 2, periodMs: 1 })]), /pulses alpha only, forever/, ); assert.throws( () => set.upsert([ disc({ property: 'alpha', from: 0, to: 1, periodMs: 1, repeat: 2 }), ]), /pulses alpha only, forever/, ); assert.equal(scene.added[0], host, 'still drawn as it was'); // Behind an item that would rebuild, and in a whole new list, too. const radius = { property: 'radius', from: 1, to: 2, periodMs: 1 }; assert.throws( () => set.upsert([{ ...disc(undefined), id: 'b' }, disc(radius)]), /pulses alpha only, forever/, ); assert.throws(() => set.set([disc(radius)]), /pulses alpha only, forever/); assert.equal(scene.added[0], host, 'still drawn as it was'); assert.doesNotThrow(() => set.upsert([{ ...disc(undefined), id: 'c' }])); // Nor numbers it cannot draw. assert.throws( () => set.upsert([disc({ property: 'alpha', from: 0, to: 1, periodMs: 0 })]), /positive period/, ); set.dispose(); }); test('a pulsing ring outline changes in place; a pulsing shape that draws nothing asks for no frames', () => withImageClasses(() => { const scene = fakeScene(); const asked = []; scene.requestRender = () => asked.push(1); const { draw, frame } = drawOver(scene); const set = draw.shapes({ id: 'rings-pulse' }); const ring = [ { lon: 0, lat: 0, height: 10 }, { lon: 0.001, lat: 0, height: 10 }, { lon: 0.001, lat: 0.001, height: 10 }, ]; const pulse = { property: 'alpha', from: 0.2, to: 0.5, periodMs: 1000 }; const outlined = (extra = {}) => ({ id: 'o', geometry: { kind: 'polygon', rings: [ring] }, outline: [1, 1, 1, 0.5], outlineOnly: true, animate: pulse, height: 'absolute', ...extra, }); set.set([outlined()]); const host = scene.added[0]; set.upsert([outlined({ meta: 'm' })]); assert.equal(scene.added[0], host, 'not rebuilt'); set.set([ { id: 'nothing', geometry: { kind: 'polygon', rings: [ring] }, animate: pulse, height: 'absolute', }, ]); frame(); asked.length = 0; frame(); assert.equal(asked.length, 0, 'nothing drawn, no frames asked'); set.dispose(); })); test('an unclamped shape recoloured before it is drawn rebuilds; frames stop once nothing pulses', () => withTerrainHeights(() => { const scene = fakeScene(); const asked = []; scene.requestRender = () => asked.push(1); const { draw, frame } = drawOver(scene); const set = draw.shapes({ id: 'early' }); const ring = [ { lon: 0, lat: 0, height: 10 }, { lon: 0.001, lat: 0, height: 10 }, { lon: 0.001, lat: 0.001, height: 10 }, ]; const column = (alpha, extra = {}) => ({ id: 'column', geometry: { kind: 'polygon', rings: [ring] }, fill: [1, 0.7, 0.3, alpha], extrudeHeight: 100, height: 'absolute', ...extra, }); set.set([column(0.4)]); const host = scene.added[0]; set.upsert([column(0.5)]); assert.notEqual(scene.added.at(-1), host, 'not yet drawn: rebuilt'); // Pulsing, it asks for frames; hidden, it stops. const pulse = { property: 'alpha', from: 0.2, to: 0.5, periodMs: 1000 }; set.set([column(0.5, { animate: pulse })]); asked.length = 0; frame(); assert.ok(asked.length > 0, 'a pulse asks for frames'); set.set([column(0.5, { animate: pulse, show: false })]); frame(); asked.length = 0; frame(); assert.equal(asked.length, 0, 'nothing pulses, no frames asked'); set.dispose(); })); test('the earthquakes layer draws its discs as ground fills on a viewer of its own', async () => { const { createEarthquakesLayer } = await import('../../layers/earthquakes/index.js'); const scene = fakeScene(); const viewer = { scene }; const row = (stableId, lon, mag) => ({ stableId, usgsId: stableId, lon, lat: 0, depthKm: 10, mag, place: null, time: null, }); const layer = createEarthquakesLayer({ source: { getSnapshot: async () => [row('a', 0, 5), row('b', 0.2, 3)] }, overlayHost: { setEntries() {}, setVisible() {}, clearSource() {} }, }); layer.init(viewer); layer.enable(viewer); assert.equal(await layer.update(viewer), true); const host = scene.added[0]; const grounds = []; for (let i = 0; i < host.length; i++) if (host.get(i) instanceof Cesium.GroundPrimitive) grounds.push(host.get(i)); // Overlapping discs: one batch each, as the entities' batches had them. assert.equal(grounds.length, 2); const [instance] = grounds[0].geometryInstances; assert.ok(instance.geometry instanceof Cesium.EllipseGeometry); assert.equal(instance.id.id, 'earthquake:a'); assert.equal(grounds[0].classificationType, Cesium.ClassificationType.BOTH); layer.destroy(); assert.equal(scene.added.length, 0); }); test('the world annotation renderer draws, fades, hides and lets go of every kind on a viewer of its own', async () => { const { createWorldAnnotationRenderer } = await import('../../annotations/worldAnnotationRenderer.js'); await withImageClasses(() => withTerrainHeights(() => { const scene = fakeScene(); const viewer = { scene }; const renderer = createWorldAnnotationRenderer(viewer); const box = (lon, d) => [ [lon - d, -d], [lon + d, -d], [lon + d, d], [lon - d, d], ]; const marks = [ { id: 'building', type: 'area', color: 'amber', footprintKind: 'building', buildingHeight: 40, anchor: { lon: 0, lat: 0, height: 200 }, ring: box(0, 0.0004), }, { id: 'area', type: 'area', color: 'green', footprintKind: 'area', anchor: { lon: 0.01, lat: 0 }, ring: box(0.01, 0.002), polygons: [[box(0.01, 0.002), box(0.01, 0.0005)]], }, { id: 'synth', type: 'area', color: 'cyan', synthesized: true, anchor: { lon: 0.02, lat: 0 }, ring: box(0.02, 0.002), }, { id: 'route', type: 'route', color: 'red', anchor: { lon: 0, lat: 0.01 }, path: [ { lon: 0, lat: 0.01 }, { lon: 0.01, lat: 0.012 }, ], }, { id: 'arrow', type: 'arrow', color: 'primary', anchor: { lon: 0, lat: 0.02 }, to: { lon: 0.01, lat: 0.02 }, }, { id: 'pin', type: 'pin', color: 'primary', anchor: { lon: 0.03, lat: 0 }, }, { id: 'label', type: 'label', color: 'amber', anchor: { lon: 0.04, lat: 0 }, }, ]; for (const mark of marks) { mark.alpha = 0.25; renderer.add( mark, mark.footprintKind === 'building' ? { sampledGroundHeight: 150 } : {}, ); } assert.ok(scene.added.length >= marks.length, 'every kind drew'); for (const alpha of [0.5, 1]) { for (const mark of marks) mark.alpha = alpha; assert.doesNotThrow(() => renderer.sync()); scene.preRender.raiseEvent(); scene.postRender.raiseEvent(); } for (const mark of marks) mark.hidden = true; renderer.sync(); for (const mark of marks) mark.hidden = false; renderer.sync(); renderer.destroy(); assert.equal(scene.added.length, 0, 'nothing left drawn'); }), ); }); test('the air quality layer draws its stations as ground fills on a viewer of its own', async () => { const { createAirQualityLayer } = await import('../../layers/airQuality/index.js'); const scene = fakeScene(); const viewer = { scene }; const reading = (id, lon) => ({ id, provider: 'eccc', scale: 'AQHI', value: 3, band: 'low', name: id, lat: 45, lon, observedMs: 0, color: '#4cc9f0', label: '3', risk: 'Low health risk', note: null, }); const layer = createAirQualityLayer({ source: { getSnapshot: async () => [reading('a', -75), reading('b', -60)] }, overlayHost: { setEntries() {}, setVisible() {}, clearSource() {} }, }); layer.init(viewer); layer.enable(viewer); assert.equal(await layer.update(viewer), true); const host = scene.added[0]; const grounds = []; for (let i = 0; i < host.length; i++) if (host.get(i) instanceof Cesium.GroundPrimitive) grounds.push(host.get(i)); const instances = grounds.flatMap((ground) => ground.geometryInstances); assert.deepEqual(instances.map((instance) => instance.id.id).sort(), [ 'air-quality:a', 'air-quality:b', ]); assert.ok(instances[0].geometry instanceof Cesium.EllipseGeometry); assert.equal(grounds[0].classificationType, Cesium.ClassificationType.BOTH); layer.destroy(); assert.equal(scene.added.length, 0); }); test('the cyclones layer draws clamped dots, draped tracks and holed cones on a viewer of its own', async () => { const { createCycloneRendering } = await import('../../layers/cyclones/rendering.js'); const { scene, frame } = drawOver(); const rendering = createCycloneRendering({ viewer: { scene }, overlayHost: { setEntries() {}, setVisible() {}, clearSource() {} }, }); const storm = (id, lon) => ({ id, name: id, advisoryNumber: '1', geometryAdvisoryNumber: '1', geometryStatus: 'current', position: { longitude: lon, latitude: 0 }, forecastPoints: [ { position: { longitude: lon, latitude: 1 }, tauHours: 12 }, ], track: { type: 'LineString', coordinates: [ [lon, 0], [lon, 1], ], }, cone: { type: 'Polygon', coordinates: [ [ [lon - 2, -2], [lon + 2, -2], [lon + 2, 2], [lon - 2, 2], [lon - 2, -2], ], [ [lon - 1, -1], [lon + 1, -1], [lon + 1, 1], [lon - 1, -1], ], ], }, }); await rendering.setSnapshot({ storms: [storm('near', 0), storm('far', 180)], }); const all = (host, out = []) => { out.push(host); if (host instanceof Cesium.PrimitiveCollection) for (let i = 0; i < host.length; i++) all(host.get(i), out); return out; }; const primitives = scene.added.flatMap((host) => all(host)); const of = (type) => primitives.filter((p) => p instanceof type); const [dots] = of(Cesium.BillboardCollection); assert.equal(dots.length, 4, 'two centers, two forecast points'); for (let i = 0; i < dots.length; i++) { const dot = dots.get(i); assert.equal(dot.heightReference, Cesium.HeightReference.CLAMP_TO_GROUND); assert.equal(dot.disableDepthTestDistance, Infinity); } const [tracks] = of(Cesium.GroundPolylinePrimitive); assert.equal(tracks.classificationType, Cesium.ClassificationType.BOTH); assert.equal(tracks.geometryInstances.length, 6, 'tracks and ring outlines'); const cones = of(Cesium.GroundPrimitive); const instances = cones.flatMap((cone) => cone.geometryInstances); assert.deepEqual(instances.map((instance) => instance.id.id).sort(), [ 'cyclone:far:cone:0', 'cyclone:near:cone:0', ]); for (const { geometry } of instances) assert.equal(geometry._polygonHierarchy.holes.length, 1, 'the hole stays'); // Past the horizon the dots go; their storms' shapes are the globe's to hide. frame(); const shown = []; for (let i = 0; i < dots.length; i++) shown.push([dots.get(i).id.id, dots.get(i).show]); assert.deepEqual(shown.sort(), [ ['cyclone:far:center', false], ['cyclone:far:forecast:0', false], ['cyclone:near:center', true], ['cyclone:near:forecast:0', true], ]); rendering.destroy(); assert.equal(scene.added.length, 0); }); test('point sets blend as asked and fall off with distance', () => { const { scene, draw } = drawOver(); const set = draw.points({ id: 'falloff', blend: 'translucent' }); set.set([ { id: 'a', pos: { lon: 0, lat: 0, height: 2 }, pixelSize: 6, color: [1, 0, 0, 0.5], scaleByDistance: { near: 200, nearValue: 1.35, far: 1e5, farValue: 0.4 }, fadeByDistance: { near: 200, nearValue: 1, far: 2e5, farValue: 0.15 }, }, { id: 'b', pos: { lon: 1, lat: 0 }, pixelSize: 6, color: '#fff' }, ]); const [points] = scene.added; assert.equal(points.blendOption, Cesium.BlendOption.TRANSLUCENT); const a = points.get(0); assert.ok( Cesium.NearFarScalar.equals( a.scaleByDistance, new Cesium.NearFarScalar(200, 1.35, 1e5, 0.4), ), ); assert.ok( Cesium.NearFarScalar.equals( a.translucencyByDistance, new Cesium.NearFarScalar(200, 1, 2e5, 0.15), ), ); assert.equal(points.get(1).scaleByDistance, undefined, 'none asked'); set.setOptions({ blend: 'opaque' }); assert.equal(scene.added[0].blendOption, Cesium.BlendOption.OPAQUE); set.setOptions({ blend: undefined }); assert.equal( scene.added[0].blendOption, Cesium.BlendOption.OPAQUE_AND_TRANSLUCENT, 'the default, as before', ); set.dispose(); }); test('the bikeshare layer draws its stations as point primitives on a viewer of its own', async () => { const { createState } = await import('../../layers/bikeshare/state.js'); const { createModel } = await import('../../layers/bikeshare/model.js'); const { createRendering } = await import('../../layers/bikeshare/rendering.js'); const { createSelection } = await import('../../layers/bikeshare/selection.js'); const scene = fakeScene(); const viewer = { scene }; const services = { render: { governorRequestRender() {} }, overlays: { setOverlayEntries() {}, setOverlaySourceVisible() {}, clearOverlaySource() {}, }, }; const state = createState({ services }); const parts = {}; const context = { state, services, parts, source: {} }; parts.model = createModel(context); parts.rendering = createRendering(context); parts.selection = createSelection(context); state._viewer = viewer; parts.rendering.attachSets(viewer); state._stationSet.show = true; const info = parts.model.parseStationInformation({ data: { stations: [ { station_id: 'a', name: 'A', lat: 30.26, lon: -97.74, capacity: 20 }, { station_id: 'b', name: 'B', lat: 30.27, lon: -97.75, capacity: 4 }, ], }, }); parts.rendering.ensureCityPoints('austin', info); parts.rendering.applyStatusToPoints( 'austin', parts.model.parseStationStatus({ data: { stations: [ { station_id: 'a', num_bikes_available: 18, num_docks_available: 2 }, ], }, }), ); const points = scene.added.find((host) => host.get(0)?.id?.id === 'austin:a'); assert.ok(points instanceof Cesium.PointPrimitiveCollection); assert.equal(points.blendOption, Cesium.BlendOption.TRANSLUCENT); assert.equal(points.length, 2); const a = points.get(0); assert.match(a.id.set, /^bikeshare:\d+:stations$/); assert.equal(a.disableDepthTestDistance, 2500); assert.equal(a.outlineWidth, 1); assert.ok( a.color.equalsEpsilon( Cesium.Color.fromCssColorString('#00ff88').withAlpha(0.95), 1e-9, ), 'plenty of bikes: green, as before', ); assert.ok( Cesium.Cartesian3.equalsEpsilon( a.position, Cesium.Cartesian3.fromDegrees(-97.74, 30.26, 2), 0, 1e-6, ), ); assert.ok( Cesium.NearFarScalar.equals( a.scaleByDistance, new Cesium.NearFarScalar(200, 1.35, 130000, 0.4), ), ); // Selected: its own dot goes, a cyan one over everything takes its place. parts.selection._selectStation('austin:a'); const stations = scene.added.find( (host) => host.get(0)?.id?.set === a.id.set, ); assert.equal(stations.get(0).show, false); const highlight = scene.added.find((host) => host.get(0)?.id?.set?.endsWith(':selected'), ); const dot = highlight.get(0); assert.ok(Cesium.Color.equals(dot.color, Cesium.Color.CYAN)); assert.equal(dot.pixelSize, 14); assert.equal(dot.outlineWidth, 2); assert.equal(dot.disableDepthTestDistance, Infinity); parts.selection._clearSelection(); parts.rendering.detachSets(); assert.equal(scene.added.length, 0); }); test('the traffic layer draws its dots as one point collection moved, added to and taken from in place on a viewer of its own', async (t) => { const { createState } = await import('../../layers/traffic/state.js'); const { createStyle } = await import('../../layers/traffic/style.js'); const { createModel } = await import('../../layers/traffic/model.js'); const { createAnimation } = await import('../../layers/traffic/animation.js'); const { JAM_DOT_FAR_SCALE } = await import('../../layers/traffic/policy.js'); let now = 10000; t.mock.method(Date, 'now', () => now); const { scene, draw } = drawOver(); const state = createState({ services: {} }); state._enabled = true; state._fadeScaleFar = 8000; state._fadeTransFar = 10000; state._dotSet = draw.points({ id: 'traffic:1:dots', blend: 'translucent' }); const parts = { rendering: { removeHeatLines() {}, rebuildHeatLines() {} }, retention: { easeHeights() {}, finishHeights() {}, clear() {} }, }; const context = { state, services: { render: { holdContinuousRender() {}, releaseContinuousRender() {} }, }, parts, source: {}, }; parts.style = createStyle(context); parts.model = createModel(context); parts.animation = createAnimation(context); parts.style.refreshBucketColors(); const [road] = parts.model.parseRoads({ roads: [ { type: 'primary', oneway: 1, coordinates: [ [-97.74, 30.26], [-97.737, 30.26], ], }, ], }); parts.animation.spawnDotsForRoad(road, 450, 3); const host = scene.added[0]; assert.ok(host instanceof Cesium.PointPrimitiveCollection); assert.equal(host.blendOption, Cesium.BlendOption.TRANSLUCENT); assert.equal(host.length, 3, 'drawn as they join'); const point = host.get(0); assert.equal(point.id.set, 'traffic:1:dots'); assert.ok( Cesium.Color.equals(point.color, Cesium.Color.WHITE.withAlpha(0.85)), 'the simulated white', ); assert.equal(point.disableDepthTestDistance, 0); const before = Cesium.Cartesian3.clone(point.position); now += 500; parts.animation.animate(); assert.equal(scene.added[0], host, 'moved where it is'); assert.equal(host.get(0), point); assert.ok(!Cesium.Cartesian3.equals(point.position, before), 'it moves'); assert.ok( Cesium.NearFarScalar.equals( point.scaleByDistance, new Cesium.NearFarScalar(100, 1.5, 8000, 0.3), ), ); assert.ok( Cesium.NearFarScalar.equals( point.translucencyByDistance, new Cesium.NearFarScalar(100, 1, 10000, 0), ), ); // What the style part changes on a dot reaches its point at the next // frame, on the point it has. const dot = state._dots[0]; parts.style.paintDot(dot, 'jam'); parts.style.emphasizeJamDot(dot); dot.point.outlineColor = Object.freeze([0, 0, 0, 0.5]); dot.point.outlineWidth = 2; now += 16; parts.animation.animate(); assert.equal(host.get(0), point); assert.ok( Cesium.Color.equals( point.color, new Cesium.Color(...state._activeBucketColors.jam), ), 'painted', ); assert.ok( Cesium.NearFarScalar.equals( point.scaleByDistance, new Cesium.NearFarScalar(100, 1.5, 8000, JAM_DOT_FAR_SCALE), ), 'emphasised', ); assert.ok( Cesium.Color.equals(point.outlineColor, new Cesium.Color(0, 0, 0, 0.5)), ); assert.equal(point.outlineWidth, 2); parts.style.showDot(dot, false); now += 16; parts.animation.animate(); assert.equal(point.show, false, 'hidden'); parts.style.showDot(dot, true); now += 16; parts.animation.animate(); assert.equal(point.show, true); parts.animation.spawnDotsForRoad(road, 450, 2); assert.equal(scene.added[0], host, 'joined where it is'); assert.equal(host.length, 5); // A dot that has faded out leaves the collection where it is, as the // retention part takes it. state._dotSet.remove([state._dots[0].point.id]); assert.equal(scene.added[0], host); assert.equal(state._dotSet.size(), 4); parts.animation.clearDots(); state._dotSet.dispose(); assert.equal(scene.added.length, 0); }); test('a rebuilt set keeps its place among the scene primitives, and names its host', () => { const scene = fakeScene(); scene.primitives = new Cesium.PrimitiveCollection(); const { draw } = drawOver(scene); const below = scene.primitives.add(new Cesium.PrimitiveCollection()); const set = draw.points({ id: 'kept' }); set.set([]); const above = scene.primitives.add(new Cesium.PrimitiveCollection()); const order = () => { const out = []; for (let i = 0; i < scene.primitives.length; i++) { const p = scene.primitives.get(i); out.push(p === below ? 'below' : p === above ? 'above' : p.drawSetId); } return out; }; assert.deepEqual(order(), ['below', 'kept', 'above']); set.set([{ id: 'a', pos: { lon: 0, lat: 0 }, pixelSize: 4, color: '#fff' }]); set.upsert([ { id: 'b', pos: { lon: 1, lat: 0 }, pixelSize: 4, color: '#fff' }, ]); assert.deepEqual( order(), ['below', 'kept', 'above'], 'not raised by updates', ); set.dispose(); }); test('sets stack by drawOrder, a higher one earlier, ties as they were made', () => { const scene = fakeScene(); scene.primitives = new Cesium.PrimitiveCollection(); const { draw } = drawOver(scene); const below = scene.primitives.add(new Cesium.PrimitiveCollection()); const order = () => { const out = []; for (let i = 0; i < scene.primitives.length; i++) { const p = scene.primitives.get(i); out.push(p === below ? 'below' : p.drawSetId); } return out; }; const dot = { id: 'a', pos: { lon: 0, lat: 0 }, pixelSize: 4, color: '#fff' }; const plain = draw.points({ id: 'plain' }); plain.set([dot]); const between = scene.primitives.add(new Cesium.PrimitiveCollection()); const high = draw.points({ id: 'high', drawOrder: 2 }); high.set([dot]); const named = () => order().map((n, i) => scene.primitives.get(i) === between ? 'between' : n, ); // Drawn first, so on top; the other primitives keep their places. assert.deepEqual(named(), ['below', 'high', 'between', 'plain']); assert.equal(high.size(), 1, 'not destroyed by the move'); high.setOptions({ drawOrder: 0 }); assert.deepEqual( named(), ['below', 'plain', 'between', 'high'], 'back to 0, it takes its place by when it was made', ); // All at 0, nothing is moved: what others stacked stays. scene.primitives.raiseToTop(below); const added = draw.points({ id: 'added' }); added.set([dot]); assert.deepEqual(named(), ['plain', 'between', 'high', 'below', 'added']); for (const set of [high, plain, added]) set.dispose(); }); test('reordering by drawOrder leaves the other primitives where they are', () => { const scene = fakeScene(); scene.primitives = new Cesium.PrimitiveCollection(); const { draw } = drawOver(scene); const dot = { id: 'a', pos: { lon: 0, lat: 0 }, pixelSize: 4, color: '#fff' }; const [a, b, c] = ['A', 'B', 'C'].map((id) => draw.points({ id })); const x = new Cesium.PrimitiveCollection(); const y = new Cesium.PrimitiveCollection(); c.set([dot]); scene.primitives.add(x); b.set([dot]); scene.primitives.add(y); a.set([dot]); const order = () => { const out = []; for (let i = 0; i < scene.primitives.length; i++) { const p = scene.primitives.get(i); out.push(p === x ? 'X' : p === y ? 'Y' : p.drawSetId); } return out; }; assert.deepEqual(order(), ['C', 'X', 'B', 'Y', 'A']); a.setOptions({ drawOrder: 1 }); assert.deepEqual(order(), ['A', 'X', 'B', 'Y', 'C']); assert.ok(!x.isDestroyed() && !y.isDestroyed()); for (const set of [a, b, c]) set.dispose(); }); test('sprite layers stack flights on top, all under a set at the default order', () => { const scene = fakeScene(); scene.primitives = new Cesium.PrimitiveCollection(); const { draw } = drawOver(scene); const dot = { id: 'a', pos: { lon: 0, lat: 0 }, pixelSize: 4, color: '#fff' }; // Made before every sprite set, and again after them. const highlight = draw.points({ id: 'highlight' }); highlight.set([dot]); const sets = ['flights', 'cctv', 'ais', 'transit'].map((layerId) => { const set = draw.points({ id: layerId, drawOrder: spriteDrawOrder(layerId), }); set.set([dot]); return set; }); const endpoint = draw.points({ id: 'endpoint' }); endpoint.set([dot]); const order = []; for (let i = 0; i < scene.primitives.length; i++) { order.push(scene.primitives.get(i).drawSetId); } // Earlier draws on top. assert.deepEqual(order, [ 'highlight', 'endpoint', 'flights', 'ais', 'transit', 'cctv', ]); // Raised above flights in place, CCTV keeps every other set's slot. sets[1].setOptions({ drawOrder: spriteDrawOrder('flights') + 0.5 }); const after = []; for (let i = 0; i < scene.primitives.length; i++) { after.push(scene.primitives.get(i).drawSetId); } assert.deepEqual(after, [ 'highlight', 'endpoint', 'cctv', 'flights', 'ais', 'transit', ]); for (const set of [highlight, endpoint, ...sets]) set.dispose(); }); test('changing an option rebuilds only the kinds that build it in, in their place', () => { const scene = fakeScene(); scene.primitives = new Cesium.PrimitiveCollection(); const { draw, frame } = drawOver(scene); const below = scene.primitives.add(new Cesium.PrimitiveCollection()); const set = draw.shapes({ id: 'cells' }); set.set([ { id: 'a', geometry: { kind: 'rectangle', rect: { west: 0, south: 0, east: 1, north: 1 }, }, fill: [1, 0, 0, 0.3], height: 'clampGround', }, ]); const above = scene.primitives.add(new Cesium.PrimitiveCollection()); const order = () => { const out = []; for (let i = 0; i < scene.primitives.length; i++) { const p = scene.primitives.get(i); out.push(p === below ? 'below' : p === above ? 'above' : p.drawSetId); } return out; }; // Every ground primitive the set's current host holds, made ready. const ready = () => { for (let i = 0; i < scene.primitives.length; i++) { const host = scene.primitives.get(i); if (host.drawSetId !== 'cells') continue; for (let j = 0; j < host.length; j++) if (host.get(j) instanceof Cesium.GroundPrimitive) Object.defineProperty(host.get(j), 'ready', { value: true }); } frame(); }; ready(); assert.deepEqual(order(), ['below', 'cells', 'above']); set.setOptions({ pickable: false }); assert.deepEqual(order(), ['below', 'cells', 'above'], 'stopping picks'); ready(); set.setOptions({ pickable: true }); assert.deepEqual( order(), ['below', 'cells', 'cells', 'above'], 'the old ground waits beside the new, in the same place', ); ready(); assert.deepEqual(order(), ['below', 'cells', 'above'], 'picking again'); set.dispose(); // Kinds that do not build an option in are not rebuilt for it. const hostOf = (id) => { for (let i = 0; i < scene.primitives.length; i++) if (scene.primitives.get(i).drawSetId === id) return scene.primitives.get(i); return null; }; const dots = draw.points({ id: 'dots' }); dots.set([{ id: 'a', pos: { lon: 0, lat: 0 }, pixelSize: 4, color: '#fff' }]); const dotsHost = hostOf('dots'); dots.setOptions({ pickable: false }); assert.equal(hostOf('dots'), dotsHost, 'points do not build in picks'); dots.setOptions({ blend: 'opaque' }); assert.notEqual(hostOf('dots'), dotsHost, 'points build in their blend'); dots.dispose(); const kept = draw.shapes({ id: 'kept' }); kept.set([]); const keptHost = hostOf('kept'); kept.setOptions({ blend: 'opaque' }); assert.equal(hostOf('kept'), keptHost, 'shapes do not build in a blend'); kept.dispose(); // Models are not loaded again for any of them. const fromGltf = Cesium.Model.fromGltfAsync; let loads = 0; Cesium.Model.fromGltfAsync = () => { loads += 1; return new Promise(() => {}); }; try { const models = draw.models({ id: 'models' }); models.set([ { id: 'm', pos: { lon: 0, lat: 0 }, url: 'model.glb', orientation: { heading: 0, pitch: 0, roll: 0 }, }, ]); models.setOptions({ pickable: false, blend: 'opaque', clampTo: 'terrain' }); assert.equal(loads, 1, 'a model is loaded once'); models.dispose(); } finally { Cesium.Model.fromGltfAsync = fromGltf; } }); test('restyling or moving unclamped points changes them in place; a new clamped one rebuilds', () => { const { scene, draw } = drawOver(); const set = draw.points({ id: 'restyled', blend: 'translucent' }); const dot = (id, lon, extra = {}) => ({ id, pos: { lon, lat: 0, height: 2 }, pixelSize: 6, color: [1, 0, 0, 1], ...extra, }); set.set([dot('a', 0), dot('b', 1)]); const [host] = scene.added; const a = host.get(0); set.upsert([ dot('a', 0, { color: [0, 1, 0, 1], pixelSize: 9, show: false, meta: 7 }), ]); assert.equal(scene.added[0], host, 'the same collection'); assert.equal(host.get(0), a, 'the same point'); assert.ok(Cesium.Color.equals(a.color, Cesium.Color.LIME)); assert.equal(a.pixelSize, 9); assert.equal(a.show, false); assert.equal(a.id.meta, 7, 'picks read the new meta'); assert.equal(set.size(), 2); const b = host.get(1); set.upsert([dot('b', 2)]); assert.equal(scene.added[0], host, 'moved: the same collection'); assert.equal(host.get(1), b, 'the same point'); assert.ok( Cesium.Cartesian3.equalsEpsilon( b.position, Cesium.Cartesian3.fromDegrees(2, 0, 2), 1e-6, ), 'where it now is', ); // Clamped now: a billboard dot, so rebuilt. set.upsert([dot('b', 2, { height: 'clampGround' })]); assert.notEqual(scene.added[0], host, 'clamped: rebuilt'); set.upsert([dot('b', 2)]); const rebuilt = scene.added[0]; set.upsert([dot('c', 3)]); assert.equal(set.size(), 3); assert.equal(scene.added[0], rebuilt, 'a new unclamped item joins'); assert.equal(scene.added[0].length, 3); set.upsert([dot('d', 4, { height: 'clampGround' })]); assert.notEqual(scene.added[0], rebuilt, 'a new clamped item rebuilds'); set.dispose(); }); test('unclamped points join and leave their collection in place, and keep what height queries see through', () => { const { scene, draw, frame } = drawOver(); const part = unboundDrawPart(draw); const set = draw.points({ id: 'population', blend: 'translucent' }); const dot = (id, lon) => ({ id, pos: { lon, lat: 0, height: 2 }, pixelSize: 6, color: [1, 0, 0, 1], }); set.upsert([dot('a', 0)]); const host = scene.added[0]; assert.equal(host.length, 1, 'an empty set takes its first point in place'); assert.equal(host.blendOption, Cesium.BlendOption.TRANSLUCENT); set.upsert([dot('b', 1), dot('c', 2)]); assert.equal(scene.added[0], host); assert.equal(host.length, 3); const ids = () => part.sets.get('population').pickIds.map((pick) => pick.id); assert.deepEqual(ids(), ['a', 'b', 'c']); let version = part.version(); set.upsert([dot('b', 5)]); assert.equal(part.version(), version, 'moved: the same pick ids'); set.remove(['a', 'zz']); assert.equal(scene.added[0], host, 'removed where it is'); assert.ok(part.version() > version, 'removed: pick ids changed'); frame(); assert.equal(host.length, 2); assert.deepEqual(ids(), ['b', 'c']); assert.equal(set.size(), 2); version = part.version(); set.upsert([dot('a', 0)]); assert.ok(part.version() > version, 'added: pick ids changed'); assert.deepEqual(ids(), ['b', 'c', 'a']); // A new id sent twice is drawn once, as the last one. set.upsert([ { ...dot('n', 6), meta: 'first' }, { ...dot('n', 6), meta: 'last' }, ]); const picks = part.sets.get('population').pickIds; assert.deepEqual( picks.filter((pick) => pick.id === 'n').map((pick) => pick.meta), ['last'], ); set.dispose(); }); test('a point moved in place sets only the members of its look that changed', () => { const { scene, draw } = drawOver(); const set = draw.points({ id: 'per-frame' }); const item = { id: 'a', pos: { x: 6378137, y: 0, z: 0 }, pixelSize: 4, color: [1, 1, 1, 0.85], scaleByDistance: { near: 100, nearValue: 1.5, far: 9000, farValue: 0.3 }, fadeByDistance: { near: 100, nearValue: 1, far: 9000, farValue: 0 }, }; set.upsert([item]); const point = scene.added[0].get(0); const written = []; for (const key of ['color', 'scaleByDistance', 'translucencyByDistance']) Object.defineProperty(point, key, { set: () => written.push(key), get: () => undefined, }); item.pos.y = 10; item.pixelSize = 2; set.upsert([item]); assert.deepEqual(written, [], 'nothing made anew for an unchanged look'); assert.equal(point.pixelSize, 2); assert.equal(point.position.y, 10); item.color = [1, 0, 0, 1]; item.scaleByDistance = { ...item.scaleByDistance, far: 12000 }; set.upsert([item]); assert.deepEqual(written, ['color', 'scaleByDistance']); // A colour changed in the caller's own array still reads as changed. item.color[1] = 1; set.upsert([item]); assert.deepEqual(written, ['color', 'scaleByDistance', 'color']); // A frozen colour or curve is kept as it is, and told unchanged by // identity; an equal one sent anew still sets nothing. item.color = Object.freeze([0, 0, 1, 1]); set.upsert([item]); set.upsert([item]); item.color = Object.freeze([0, 0, 1, 1]); set.upsert([item]); assert.deepEqual(written, ['color', 'scaleByDistance', 'color', 'color']); // A frozen curve read through a getter can change, so it is copied and // compared by value. let farValue = 0.3; item.scaleByDistance = Object.freeze( Object.defineProperties( {}, { near: { value: 100, enumerable: true }, nearValue: { value: 1.5, enumerable: true }, far: { value: 12000, enumerable: true }, farValue: { get: () => farValue, enumerable: true }, }, ), ); set.upsert([item]); const writes = written.length; set.upsert([item]); assert.equal(written.length, writes, 'unchanged'); farValue = 0.8; set.upsert([item]); assert.equal(written.at(-1), 'scaleByDistance', 'the change is seen'); set.dispose(); }); test('a position object changed and sent again moves its point', () => { const { scene, draw } = drawOver(); const set = draw.points({ id: 'moved-in-place' }); const item = { id: 'a', pos: { lon: 0, lat: 0 }, pixelSize: 4, color: '#fff', }; set.set([item]); const host = scene.added[0]; item.pos.lon = 90; set.upsert([item]); assert.equal(scene.added[0], host, 'moved where it is'); const at = Cesium.Cartographic.fromCartesian(scene.added[0].get(0).position); assert.ok(Math.abs(Cesium.Math.toDegrees(at.longitude) - 90) < 1e-9); set.dispose(); }); test('a point moved in place is horizon culled where it now is', () => { const { scene, draw, frame } = drawOver(); const set = draw.points({ id: 'culled-moving', horizonCull: true }); const dot = (lon) => ({ id: 'a', pos: { lon, lat: 0, height: 10 }, pixelSize: 4, color: '#fff', }); // The eye is over lon 0. set.set([dot(0)]); const point = scene.added[0].get(0); frame(); assert.equal(point.show, true, 'under the eye'); set.upsert([dot(180)]); assert.equal(scene.added[0].get(0), point, 'the same point'); assert.equal( point.show, false, 'hidden at once, as a frame listener moving it after the cull needs', ); frame(); assert.equal(point.show, false, 'past the horizon'); set.upsert([dot(1)]); assert.equal(point.show, true, 'shown at once'); frame(); assert.equal(point.show, true, 'back in view'); set.dispose(); }); test('an icon moved in place past the horizon is hidden at once', () => { const { scene, draw, frame } = drawOver(); const set = draw.icons({ id: 'culled-icons', horizonCull: true }); const icon = (lon) => ({ id: 'a', pos: { lon, lat: 0, height: 10 }, image: { svg: '' }, size: [8, 8], }); // The eye is over lon 0. set.set([icon(0)]); frame(); const billboard = scene.added[0].get(0); assert.equal(billboard.show, true, 'under the eye'); set.upsert([icon(180)]); assert.equal(scene.added[0].get(0), billboard, 'the same billboard'); assert.equal(billboard.show, false, 'past the horizon, before a frame'); set.upsert([icon(1)]); assert.equal(billboard.show, true); set.dispose(); }); test('points show only within their display range', () => { const { scene, draw } = drawOver(); const set = draw.points({ id: 'ranged' }); const dot = (id, extra = {}) => ({ id, pos: { lon: 0, lat: 0 }, pixelSize: 4, color: '#fff', ...extra, }); set.set([ dot('near', { displayRange: [0, 2e6] }), dot('empty', { displayRange: [5, 5] }), dot('clamped', { displayRange: [0, 1e3], height: 'clampGround' }), ]); const [host] = scene.added; const points = host.get(0); const dots = host.get(1); const near = points.get(0); assert.equal(near.distanceDisplayCondition.near, 0); assert.equal(near.distanceDisplayCondition.far, 2e6); assert.equal(points.get(1).show, false, 'an empty range shows nowhere'); assert.equal(points.get(1).distanceDisplayCondition, undefined); assert.equal(dots.get(0).distanceDisplayCondition.far, 1e3, 'clamped too'); // Changed and dropped in place. set.upsert([dot('near', { displayRange: [10, 20] })]); assert.equal(points.get(0), near); assert.equal(near.distanceDisplayCondition.far, 20); set.upsert([dot('near')]); assert.equal(near.distanceDisplayCondition, undefined, 'dropped'); set.upsert([dot('empty')]); assert.equal(points.get(1).show, true, 'no range shows it'); set.dispose(); }); test('the fire perimeters layer draws holed ground fills and draped fire lines on a viewer of its own', async () => { const { createFirePerimetersLayer } = await import('../../layers/perimeters/index.js'); const scene = fakeScene(); const viewer = { scene }; const outer = [ [-108.1, 35.2], [-108.0, 35.2], [-108.0, 35.3], [-108.1, 35.2], ]; const hole = [ [-108.08, 35.22], [-108.02, 35.22], [-108.02, 35.25], [-108.08, 35.22], ]; const layer = createFirePerimetersLayer({ source: { getSnapshot: async () => [ { stableId: 'a', containedPct: 0, polygons: [[outer, hole]] }, ], }, }); layer.init(viewer); layer.enable(viewer); assert.equal(await layer.update(viewer), true); const all = (host, out = []) => { out.push(host); if (host instanceof Cesium.PrimitiveCollection) for (let i = 0; i < host.length; i++) all(host.get(i), out); return out; }; const primitives = scene.added.flatMap((host) => all(host)); const of = (type) => primitives.filter((p) => p instanceof type); const [fill] = of(Cesium.GroundPrimitive); assert.equal(fill.classificationType, Cesium.ClassificationType.BOTH); const [instance] = fill.geometryInstances; assert.equal(instance.id.id, 'fire-perimeter:a:0'); assert.equal(instance.geometry._polygonHierarchy.holes.length, 1); const [line] = of(Cesium.GroundPolylinePrimitive); assert.equal(line.classificationType, Cesium.ClassificationType.BOTH); assert.equal(line.geometryInstances.length, 1, 'the exterior ring only'); assert.equal(line.geometryInstances[0].geometry.width, 2); assert.equal(line.geometryInstances[0].id.id, 'fire-perimeter:a:0'); layer.destroy(); assert.equal(scene.added.length, 0); }); test('the GNSS layer draws its cells as ground fills that stay out of the pick pass', async (t) => { const { createGnssIntegrityLayer } = await import('../../layers/gnss/index.js'); const scene = fakeScene(); const viewer = { scene }; const row = (hex, lat, degraded) => ({ hex, lat, lon: 30.2, nic: degraded ? 0 : 8, nacp: degraded ? 0 : 10, gpsLost: false, degraded, }); const layer = createGnssIntegrityLayer({ source: { getSnapshot: async () => ({ ageMs: 0, rows: [row('a1', 50.1, true), row('a2', 50.1, true), row('a3', 50.2)], }), }, viewAnchor: () => ({ latitude: 50, longitude: 30 }), }); layer.init(viewer); layer.enable(); assert.equal(await layer.update(), true); const host = scene.added[0]; const grounds = []; for (let i = 0; i < host.length; i++) if (host.get(i) instanceof Cesium.GroundPrimitive) grounds.push(host.get(i)); assert.equal(grounds.length, 1); const [fill] = grounds; assert.equal(fill.allowPicking, false); assert.equal(fill.classificationType, Cesium.ClassificationType.BOTH); const [instance] = fill.geometryInstances; assert.ok(instance.geometry instanceof Cesium.RectangleGeometry); assert.equal(instance.id.id, 'gnss-integrity:280:420'); // A ground primitive draws its stencil in the pick pass even unpickable, // erasing picks of ground geometry under it; these skip that pass. let updates = 0; t.mock.method(Cesium.GroundPrimitive.prototype, 'update', () => updates++); fill.update({ passes: { pick: true } }); assert.equal(updates, 0); fill.update({ passes: { render: true, pick: false } }); assert.equal(updates, 1); t.mock.restoreAll(); layer.destroy(); assert.equal(scene.added.length, 0); }); test('the context layer draws its static range ring as a haloed line on a viewer of its own', async () => { const { createRendering } = await import('../../layers/awareness/rendering.js'); const { createState } = await import('../../layers/awareness/state.js'); withImageClasses(() => { // A viewer whose scene keeps no Cesium primitive collection of its own // (this double's `primitives`) gets the ring without its pulses. const { scene } = drawOver(); const state = createState({ services: {} }); state.viewer = { scene }; const rendering = createRendering({ state, services: { geometry: {}, render: { governorRequestRender() {} }, }, parts: {}, }); const subject = (lon) => ({ layerId: 'military', id: 'a', position: Cesium.Cartesian3.fromDegrees(lon, 0, 9000), }); rendering.renderVisual(subject(0)); const linesOf = (from = scene) => { const [host] = from.added; const lines = []; if (!host) return lines; // Lines that never settle are drawn by the collection alone. const collections = host instanceof Cesium.PolylineCollection ? [host] : Array.from({ length: host.length }, (_, i) => host.get(i)); for (const collection of collections) { if (!(collection instanceof Cesium.PolylineCollection)) continue; for (let j = 0; j < collection.length; j++) lines.push(collection.get(j)); } return lines.sort((x, y) => y.width - x.width); }; const [core] = linesOf(); assert.equal(linesOf().length, 1, 'one line, its halo its outline'); assert.equal(core.width, 4); assert.equal(core.material.type, 'PolylineOutline'); assert.equal(core.material.uniforms.outlineWidth, 1); assert.ok( core.material.uniforms.color.equalsEpsilon( Cesium.Color.fromCssColorString('rgba(98, 181, 255, 0.95)'), 1e-9, ), ); assert.ok( core.material.uniforms.outlineColor.equalsEpsilon( Cesium.Color.fromCssColorString('rgba(4, 12, 16, 0.8)'), 1e-9, ), ); // A closed ring 250 km from the subject's ground point, 2.5 km up. const ground = Cesium.Cartesian3.fromDegrees(0, 0, 2_500); assert.equal(core.positions.length, 129); for (const position of core.positions) { const away = Cesium.Cartesian3.distance(ground, position); assert.ok(Math.abs(away - 250_000) < 2_000, `${away}`); assert.ok( Math.abs(Cesium.Cartographic.fromCartesian(position).height - 2_500) < 1, ); } // Small moves keep the ring; one past 250 m moves it. const first = Cesium.Cartesian3.clone(core.positions[0]); rendering.renderVisual(subject(0.001)); assert.ok(Cesium.Cartesian3.equals(linesOf()[0].positions[0], first)); rendering.renderVisual(subject(0.01)); assert.ok(!Cesium.Cartesian3.equals(linesOf()[0].positions[0], first)); // Re-initialized on another viewer, the same subject's ring moves there. const other = drawOver().scene; state.viewer = { scene: other }; rendering.renderVisual(subject(0.01)); assert.equal(scene.added.length, 0, 'gone from the old viewer'); assert.equal(linesOf(other).length, 1, 'drawn on the new one'); rendering.clearVisual(); assert.equal(linesOf(other).length, 0); rendering.disposeVisual(); assert.equal(other.added.length, 0); }); }); test('the installations layer draws its named markers as outlined point primitives on a viewer of its own', async () => { const { createNamedMarkers, namedPointId } = await import('../../layers/installations/namedMarkers.js'); const scene = fakeScene(); scene.canvas = { clientWidth: 800, clientHeight: 600 }; const viewer = { scene }; const state = { viewer, enabled: false, selectedId: null }; const markers = createNamedMarkers({ state, services: { render: { governorRequestRender() {} } }, parts: { model: { colorFor: () => [1, 165 / 255, 0, 1] }, rendering: { installationSurfaceHeightM: () => 40 }, }, overlayHost: { setEntries() {}, clearSource() {}, setVisible() {} }, }); const records = [ { id: 'a', name: 'A', namedArea: true, areaM2: 2, latitude: 30, longitude: -97, pointOnly: false, }, { id: 'b', name: 'B', namedArea: true, areaM2: 1, latitude: 31, longitude: -98, pointOnly: true, }, ]; markers.sync(records); const host = scene.added.find((h) => h.get?.(0)?.id?.set === markers.setId); assert.ok(host instanceof Cesium.PointPrimitiveCollection); assert.equal(host.show, false, 'hidden while the layer is off'); assert.equal(host.length, 2); const a = host.get(0); assert.equal(a.id.id, namedPointId('a')); assert.deepEqual(a.id.meta, { installationId: 'a' }); assert.equal(a.pixelSize, 7); assert.equal(a.outlineWidth, 1); assert.ok(Cesium.Color.equals(a.outlineColor, Cesium.Color.BLACK)); assert.ok(Cesium.Color.equals(a.color, new Cesium.Color(1, 165 / 255, 0, 1))); assert.equal(a.disableDepthTestDistance, Infinity); assert.ok( Cesium.Cartesian3.equalsEpsilon( a.position, Cesium.Cartesian3.fromDegrees(-97, 30, 40), 0, 1e-6, ), ); assert.ok( Cesium.Cartesian3.equalsEpsilon( host.get(1).position, Cesium.Cartesian3.fromDegrees(-98, 31, 0), 0, 1e-6, ), 'a point-only site sits on the ellipsoid', ); // Selecting a drawn site restyles nothing that moves: the points stay. state.selectedId = 'b'; markers.sync(records); assert.equal(scene.added.includes(host), true); assert.equal(host.get(0), a); // A selected site that is not a named area draws no point. state.selectedId = 'c'; markers.sync([ ...records, { id: 'c', name: 'C', areaM2: 3, latitude: 32, longitude: -99, pointOnly: true, }, ]); const rebuilt = scene.added.find( (h) => h.get?.(0)?.id?.set === markers.setId, ); const c = [0, 1, 2] .map((i) => rebuilt.get(i)) .find((p) => p.id.id === namedPointId('c')); assert.equal(c.show, false); markers.destroy(); assert.equal(scene.added.includes(host), false); }); test('the installations layer draws its site dots, outlines and selected dot on a viewer of its own', async () => { const { createRendering } = await import('../../layers/installations/rendering.js'); const scene = fakeScene(); const viewer = { scene }; const record = (id, lon) => ({ id, name: `Site ${id}`, class: 'base', latitude: 30, longitude: lon, namedArea: false, outlineLines: [ [ [lon, 30], [lon + 0.01, 30], ], ], }); const records = [record('a', -97), record('b', -98)]; const state = { viewer, enabled: true, selectedId: null, records, recordById: new Map(records.map((r) => [r.id, r])), renderedKeys: new Map(), }; const noop = () => {}; const rendering = createRendering({ state, services: { ground: { floorAltitudeM: () => 0, cachedGroundFloor: () => 0 }, anchors: {}, render: { governorRequestRender: noop }, context: { registerEntityContext: noop, removeEntityContextsForLayer: noop, selectEntityContext: noop, getSelectedEntityContext: () => state.selectedId ? { id: state.selectedId } : null, clearSelectedEntityContextForLayer: noop, }, }, parts: { model: { colorFor: (r, alpha = 1) => [1, 165 / 255, 0, alpha], installationSourceLabel: () => 'OpenStreetMap', }, }, }); rendering.attach(viewer); rendering.renderRecords(); const billboards = (setId) => { const out = []; const visit = (node) => { for (let i = 0; i < (node?.length ?? 0); i += 1) { const child = node.get(i); if (child?.id?.set === setId) out.push(child); else if (typeof child?.get === 'function') visit(child); } }; for (const host of scene.added) if (host.id?.set === setId) out.push(host); else visit(host); return out; }; const dotsId = state.sets.dots.id; const dots = billboards(dotsId); assert.equal(dots.length, 2); assert.ok(dots.every((dot) => dot instanceof Cesium.Billboard)); assert.ok( dots.every( (dot) => dot.heightReference === Cesium.HeightReference.CLAMP_TO_GROUND, ), ); assert.ok(dots.every((dot) => dot.id.meta?.installationId)); // Selecting a site hides its dot where it is and draws the selected one // in its own set: no other dot is drawn again. state.selectedId = 'b'; rendering.renderRecords(); const after = billboards(dotsId); assert.equal(after.length, 2); assert.ok( after.every((dot, i) => dot === dots[i]), 'the same billboards', ); assert.equal(after.find((dot) => dot.id.id === 'b').show, false); assert.equal(after.find((dot) => dot.id.id === 'a').show, true); const [selected] = billboards(state.sets.selected.id); assert.ok(selected instanceof Cesium.Billboard); assert.equal(selected.id.id, 'b'); assert.equal(selected.id.meta, dots.find((dot) => dot.id.id === 'b').id.meta); rendering.detach(); assert.equal(scene.added.length, 0, 'gone with the layer'); }); test('the satellites layer draws its dots as one point collection and its rings as depth-fail primitives out of picks', async () => { const { createRendering } = await import('../../layers/satellites/rendering.js'); const { POINT_STYLES, TRACKED_ORBIT_COLOR } = await import('../../layers/satellites/policy.js'); const scene = fakeScene(); const viewer = { scene }; const state = { now: Date.now, _points: new Map(), _orbitPaths: new Map(), _catalog: new Map([[25544, { satrec: {} }]]), _viewer: viewer, _trackedNorad: null, _enabled: false, }; const ring = [ { x: 7e6, y: 0, z: 0 }, { x: 0, y: 7e6, z: 0 }, { x: -7e6, y: 0, z: 0 }, ]; const rendering = createRendering({ state, services: { focus: {} }, parts: { orbits: { computeOrbitPath: () => ring } }, }); rendering._attach(viewer); rendering._addPoint(25544, { x: 7e6, y: 0, z: 0 }, POINT_STYLES.iss); rendering._addPoint(5, { x: 0, y: 7e6, z: 0 }, POINT_STYLES.visual); rendering._preRenderTick({ frame: 1 }); const points = scene.added.find( (host) => host instanceof Cesium.PointPrimitiveCollection, ); assert.equal(points.length, 2); const iss = points.get(0); assert.equal(iss.id.id, '25544'); assert.deepEqual(iss.id.meta, { noradId: 25544 }); assert.equal(iss.pixelSize, 12); assert.equal(iss.scaleByDistance.nearValue, 1.5); assert.equal(iss.scaleByDistance.far, 2e7); // Moved in place, both in one write. rendering._movePoint(25544, { x: 6.9e6, y: 0, z: 0 }); rendering._movePoint(5, { x: 0, y: 6.9e6, z: 0 }); rendering._preRenderTick({ frame: 2 }); assert.equal(points.get(0), iss); assert.equal(iss.position.x, 6.9e6); withImageClasses(() => rendering._showOrbitPath(25544, TRACKED_ORBIT_COLOR)); const all = (host) => host instanceof Cesium.PrimitiveCollection ? Array.from({ length: host.length }, (_, i) => all(host.get(i))).flat() : [host]; const primitive = scene.added .flatMap(all) .find( (host) => host instanceof Cesium.Primitive && host.depthFailAppearance, ); assert.ok(primitive, 'a ring with a dimmed part behind the globe'); assert.equal(primitive.allowPicking, false, 'ring clicks fall through'); rendering._detach(viewer); assert.equal(scene.added.length, 0, 'gone with the layer'); }); test('the ALPR layer draws its badges as icons that follow the ground, restyled in place', async () => { const { alprMarkers, createAlprMarkerSet } = await import('../../layers/alpr/markerState.js'); const { MARKER_IMAGE, SELECTED_IMAGE } = await import('../../layers/alpr/visuals.js'); const scene = fakeScene(); const part = createCesiumDraw({ scene, report: (error) => assert.fail(error), }); const markers = createAlprMarkerSet(); markers.attach(part.port.icons({ id: 'alpr-cameras:1:markers' })); const place = (id, lon, clamped) => { const carrier = markers.add(id); Object.assign(alprMarkers.write(carrier), { position: Cesium.Cartesian3.fromDegrees(lon, 30, clamped ? 0 : 150), clamped, }); return carrier; }; const a = place('alpr:a', -97, true); place('alpr:b', -97.01, false); markers.flush(); const [host] = scene.added; assert.ok(host instanceof Cesium.BillboardCollection); assert.equal(host.length, 2); const badge = host.get(0); assert.equal(badge.id.id, 'alpr:a'); assert.equal(badge.id.set, 'alpr-cameras:1:markers'); assert.equal(badge.heightReference, Cesium.HeightReference.CLAMP_TO_GROUND); assert.equal( host.get(1).heightReference, Cesium.HeightReference.NONE, 'a marker on its floor sits at its height', ); assert.equal(badge.image, MARKER_IMAGE); assert.equal(badge.width, 38); assert.equal(badge.disableDepthTestDistance, Infinity); assert.ok( Cesium.NearFarScalar.equals( badge.scaleByDistance, new Cesium.NearFarScalar(500, 1.15, 40000, 0.45), ), ); // Selection swaps the image on the same billboard: no blink. alprMarkers.write(a).selected = true; markers.changed(a); markers.flush(); assert.equal(scene.added[0], host); assert.equal(host.get(0), badge); assert.equal(badge.image, SELECTED_IMAGE); assert.equal(badge.width, 60); // Under a canvas badge: a faint pick target at the canvas anchor. const anchor = Cesium.Cartesian3.fromDegrees(-97, 30, 172); Object.assign(alprMarkers.write(a), { canvasOwned: true, canvasPosition: anchor, }); markers.changed(a); markers.flush(); assert.equal(host.get(0), badge, 'still the same billboard'); assert.equal(badge.color.alpha, 0.01); assert.equal(badge.heightReference, Cesium.HeightReference.NONE); assert.equal(badge.scaleByDistance, undefined); assert.ok(Cesium.Cartesian3.equalsEpsilon(badge.position, anchor, 0, 1e-6)); // A marker that arrives later joins the same collection. place('alpr:c', -97.02, false); markers.flush(); assert.equal(scene.added[0], host, 'appended, not rebuilt'); assert.equal(host.get(0), badge); assert.equal(host.length, 3); markers.remove(['alpr:b']); assert.equal(scene.added[0], host); assert.equal(host.length, 2); markers.dispose(); assert.equal(scene.added.length, 0); }); /** Run `fn` with the image classes Cesium's materials test uniforms against. */ function withImageClasses(fn) { const names = [ 'HTMLCanvasElement', 'HTMLImageElement', 'ImageBitmap', 'OffscreenCanvas', ]; const real = names.map((name) => globalThis[name]); for (const name of names) globalThis[name] ??= class {}; try { return fn(); } finally { names.forEach((name, i) => (globalThis[name] = real[i])); } } test('lines that change only whether they show, or where an undraped one runs, change in place', () => withImageClasses(() => { const { scene, draw, frame } = drawOver(); const set = draw.lines({ id: 'patched' }); const draped = (id, show = true, meta) => ({ id, positions: [ { lon: 0, lat: 0 }, { lon: 1, lat: 1 }, ], widthPx: 2.5, mode: 'draped', style: { kind: 'solid', color: '#7fe6ed' }, show, meta, }); const stem = (id, height, show = true) => ({ id, positions: [ Cesium.Cartesian3.fromDegrees(0, 0, 0), Cesium.Cartesian3.fromDegrees(0, 0, height), ], widthPx: 2, mode: '3d', style: { kind: 'solid', color: [1, 1, 1, 0.5] }, show, meta: height, }); const attributes = new Map(); const fakeAttributes = (ground) => { ground.getGeometryInstanceAttributes = (id) => { if (!attributes.has(id.id)) attributes.set(id.id, { show: new Uint8Array([1]) }); return attributes.get(id.id); }; }; set.set([draped('a'), draped('b'), stem('s', 100)]); const host = scene.added[0]; const ground = host.get(1); fakeAttributes(ground); // Still building: the show waits for the ground, and the build goes on. set.upsert([draped('a', false)]); assert.equal(scene.added[0], host, 'not rebuilt while its ground builds'); assert.equal(attributes.size, 0); Object.defineProperty(ground, 'ready', { value: true }); frame(); assert.deepEqual([...attributes.get('a').show], [0], 'shown once ready'); set.upsert([draped('b', false)]); assert.equal(scene.added[0], host, 'changed in place once ready'); assert.deepEqual([...attributes.get('b').show], [0]); set.upsert([draped('b', true, 'new')]); assert.deepEqual([...attributes.get('b').show], [1]); const [, idB] = ground.geometryInstances.map((instance) => instance.id); assert.equal(idB.meta, 'new', 'picks read the new meta'); // An undraped line moves and hides in place, and keeps its new meta. // Beside the collection, a static batch once the set settles. const line = host.get(0).get(0).get(0); set.upsert([stem('s', 2500, false)]); assert.equal(scene.added[0], host); assert.equal(host.get(0).get(0).get(0), line); assert.equal(line.show, false); assert.equal(line.id.meta, 2500); assert.ok( Cesium.Cartesian3.equalsEpsilon( line.positions[1], Cesium.Cartesian3.fromDegrees(0, 0, 2500), 1e-6, ), ); // One item that cannot change in place rebuilds them all, and patches // none of the others first. set.upsert([ draped('a'), { ...draped('b'), positions: [ { lon: 0, lat: 0 }, { lon: 2, lat: 2 }, ], }, ]); assert.deepEqual([...attributes.get('a').show], [0], 'not patched'); assert.notEqual(scene.added.at(-1), host, 'a draped line that moves'); const moved = scene.added.at(-1); set.upsert([{ ...stem('s', 2500), widthPx: 3 }]); assert.notEqual(scene.added.at(-1), moved, 'a line that looks different'); // A ground primitive gone from under the set rebuilds too. const third = scene.added.at(-1); third.get(1).destroy(); set.upsert([draped('a', false)]); assert.notEqual(scene.added.at(-1), third, 'its ground destroyed'); set.dispose(); })); /** A solid 3D stem for the settling tests. */ const settleStem = (id, height, extra = {}) => ({ id, positions: [ Cesium.Cartesian3.fromDegrees(0, 0, 0), Cesium.Cartesian3.fromDegrees(0, 0, height), ], widthPx: 2, mode: '3d', style: { kind: 'solid', color: [1, 0, 0, 1] }, meta: height, ...extra, }); /** * A line set over a fake scene with what the settling tests read: its * host, the polyline collection, the static batches beside it, frames to * settle, and a batch's build finished, its instance attributes kept per * batch as a built primitive keeps them. */ function settlingSet(id = 'stems') { const { scene, draw, frame } = drawOver(); const set = draw.lines({ id }); const attributes = new WeakMap(); const attrs = (primitive, itemId) => attributes.get(primitive).get(itemId); return { scene, set, frame, host: () => scene.added[0], polylines: () => scene.added[0].get(0), batches() { const host = scene.added[0]; const found = []; for (let i = 1; i < host.length; i++) found.push(host.get(i)); return found; }, settle() { for (let i = 0; i < SETTLE_FRAMES; i++) frame(); }, built(primitive) { Object.defineProperty(primitive, 'ready', { value: true }); const own = new Map(); attributes.set(primitive, own); primitive.getGeometryInstanceAttributes = (pickId) => { if (!own.has(pickId.id)) { const instance = primitive.geometryInstances.find( (one) => one.id === pickId, ); if (!instance) return undefined; own.set(pickId.id, { show: new Uint8Array(instance.attributes.show.value), color: new Uint8Array(instance.attributes.color.value), }); } return own.get(pickId.id); }; }, attrs, }; } test('unchanged solid 3D lines settle into a static batch, changed there in place', () => withImageClasses(() => { const s = settlingSet(); const { set, frame } = s; const stem = settleStem; const glow = { id: 'glow', positions: stem('g', 1).positions, widthPx: 4, mode: '3d', style: { kind: 'glow', color: '#fff', power: 0.2 }, }; set.set([ stem('a', 100), stem('b', 200, { style: { kind: 'solid', color: [0, 1, 0, 0.5] } }), stem('c', 300, { show: false }), glow, ]); const host = s.host(); const polylines = s.polylines(); assert.ok(polylines instanceof Cesium.PolylineCollection); assert.equal(polylines.length, 4, 'drawn by the collection at once'); for (let i = 0; i < SETTLE_FRAMES - 1; i++) frame(); assert.equal(host.length, 1, 'not before it settles'); frame(); // Opaque and translucent lines draw in passes of their own. const [opaque, translucent] = s.batches(); assert.ok(opaque instanceof Cesium.Primitive); assert.equal(opaque.show, false, 'hidden while it builds'); assert.equal(opaque.appearance.translucent, false); assert.equal(translucent.appearance.translucent, true); assert.deepEqual( opaque.geometryInstances.map((one) => one.id.id), ['a', 'c'], 'every solid line, shown or not; the glow stays in the collection', ); const [a, c] = opaque.geometryInstances; assert.ok(a.geometry instanceof Cesium.PolylineGeometry); assert.equal(a.geometry._width, 2); assert.deepEqual([...c.attributes.show.value], [0]); assert.deepEqual([...a.attributes.color.value], [255, 0, 0, 255]); // Picks name the set and item, through the same pick ids. assert.equal(a.id, polylines.get(0).id); assert.deepEqual(drawHitOf({ primitive: opaque, id: a.id }), { set: 'stems', id: 'a', meta: 100, surface: false, }); // A line in the collection that moves drops the build, which drew it // where it was; one shown, or a glow line changed, does not. set.upsert([stem('c', 300)]); set.upsert([{ ...glow, widthPx: 4, show: false }]); assert.equal(s.host(), host, 'changed in place'); assert.equal(s.batches().length, 2, 'still building'); set.upsert([stem('a', 150)]); assert.equal(s.batches().length, 0, 'dropped'); set.upsert([stem('a', 100)]); s.settle(); const [opaqueAgain, translucentAgain] = s.batches(); s.built(opaqueAgain); s.built(translucentAgain); frame(); assert.equal(opaqueAgain.show, true, 'swapped in once built'); // The glow, hidden, is parked out of the collection, which would draw // it on regardless; the batch took the rest. assert.equal(polylines.length, 0, 'none left in the collection'); // Show, colour and meta change in place on the batch. set.upsert([ stem('a', 100, { show: false }), stem('c', 300, { style: { kind: 'solid', color: [0, 0, 1, 1] } }), ]); assert.equal(s.host(), host); assert.deepEqual([...s.attrs(opaqueAgain, 'a').show], [0]); assert.deepEqual([...s.attrs(opaqueAgain, 'c').color], [0, 0, 255, 255]); assert.equal(polylines.length, 0, 'nothing left the batch'); set.upsert([stem('a', 100, { meta: 'new' })]); assert.deepEqual([...s.attrs(opaqueAgain, 'a').show], [1]); assert.equal(opaqueAgain.geometryInstances[0].id.meta, 'new'); // A line that moves leaves the batch, hidden there, for the // collection; it settles back with the rest. set.upsert([stem('a', 900)]); assert.equal(s.host(), host); assert.deepEqual([...s.attrs(opaqueAgain, 'a').show], [0]); assert.equal(polylines.length, 1); const moved = polylines.get(0); assert.equal(moved.id.id, 'a'); assert.ok( Cesium.Cartesian3.equalsEpsilon( moved.positions[1], Cesium.Cartesian3.fromDegrees(0, 0, 900), 1e-6, ), ); // So does one turned translucent. set.upsert([ stem('c', 300, { style: { kind: 'solid', color: [0, 0, 1, 0.4] } }), ]); assert.equal(polylines.length, 2); // Two lines are few beside a batch: they wait longer. s.settle(); assert.equal(s.batches().length, 2, 'not yet'); for (let i = SETTLE_FRAMES; i < LONG_SETTLE_FRAMES; i++) frame(); const next = s.batches().slice(2); assert.equal(next.length, 2, 'built beside the batches drawing now'); assert.deepEqual( next.flatMap((one) => one.geometryInstances.map((i) => i.id.id)), ['a', 'b', 'c'], ); // A batched line shown or hidden while the next batch builds shows // there as its item now asks, once it is built. set.upsert([ stem('b', 200, { style: { kind: 'solid', color: [0, 1, 0, 0.5] }, show: false, }), ]); assert.deepEqual([...s.attrs(translucentAgain, 'b').show], [0]); assert.equal(s.batches().length, 4, 'the build goes on'); next.forEach(s.built); frame(); assert.deepEqual(s.batches(), next, 'the old batches are gone'); assert.equal(opaqueAgain.isDestroyed(), true); assert.deepEqual([...s.attrs(next[1], 'b').show], [0]); assert.equal(polylines.length, 0); // The glow shown again draws in the collection, in place. set.upsert([glow]); assert.equal(s.host(), host); assert.equal(polylines.length, 1); assert.equal(polylines.get(0).id.id, 'glow'); // A line that looks different is still a rebuild. set.upsert([stem('b', 200, { widthPx: 5 })]); assert.notEqual(s.host(), host); set.dispose(); })); test('many lines left beside a static batch settle as soon as they are unchanged', () => withImageClasses(() => { const s = settlingSet(); const { set } = s; const stems = (height) => Array.from({ length: FEW_LOOSE_LINES + 1 }, (_, i) => settleStem(`s${i}`, height + i), ); set.set(stems(100)); s.settle(); const [first] = s.batches(); s.built(first); s.frame(); set.upsert(stems(500)); assert.equal(s.polylines().length, FEW_LOOSE_LINES + 1, 'all moved'); s.settle(); assert.equal(s.batches().length, 2, 'rebuilding at once'); set.dispose(); })); test('an outlined solid line draws one outline material, recoloured in place, and never settles', () => withImageClasses(() => { const s = settlingSet(); const outlined = (core, halo) => settleStem('ring', 100, { widthPx: 4, style: { kind: 'solid', color: core, outline: { color: halo, widthPx: 1 }, }, }); s.set.set([outlined([0, 0.5, 1, 1], [0, 0, 0, 0.8]), settleStem('a', 200)]); const line = () => { const polylines = s.polylines(); for (let i = 0; i < polylines.length; i++) if (polylines.get(i).id?.id === 'ring') return polylines.get(i); return null; }; const first = line(); const drawnPositions = first.positions; assert.equal(first.material.type, 'PolylineOutline'); assert.equal(first.material.uniforms.outlineWidth, 1); s.set.upsert([outlined([0, 0.5, 1, 0.4], [0, 0, 0, 0.32])]); assert.equal(line(), first, 'the same line'); assert.equal( first.positions, drawnPositions, 'positions sent again where they were are not rewritten', ); assert.equal(first.material.uniforms.color.alpha, 0.4); assert.ok( Math.abs(first.material.uniforms.outlineColor.alpha - 0.32) < 1e-9, ); s.settle(); const [batch] = s.batches(); assert.deepEqual( batch.geometryInstances.map((one) => one.id.id), ['a'], ); s.set.dispose(); })); test('a line that moves by as many points is written into the points it draws; by more, it takes new ones', () => withImageClasses(() => { const s = settlingSet(); const style = { kind: 'solid', color: [0, 0.5, 1, 1], outline: { color: [0, 0, 0, 1], widthPx: 1 }, }; const front = (positions) => ({ id: 'front', positions, widthPx: 4, mode: '3d', style, }); const at = (...heights) => heights.map((h) => ({ ...Cesium.Cartesian3.fromDegrees(0, 0, h) })); // Beside a line that settles, as the ring's fronts are not. s.set.set([front(at(10, 20, 30)), settleStem('a', 200)]); const polylines = s.polylines(); let line = null; for (let i = 0; i < polylines.length; i++) if (polylines.get(i).id?.id === 'front') line = polylines.get(i); const points = line.positions; const objects = [...points]; s.set.upsert([front(at(40, 50, 60))]); assert.equal(line.positions, points, 'the same points'); assert.deepEqual(line.positions, objects, 'each the same object'); const heights = () => line.positions.map((p) => Math.round(Cesium.Cartographic.fromCartesian(p).height), ); assert.deepEqual(heights(), [40, 50, 60]); // Packed triples are written in too. const packed = new Float64Array(9); at(70, 80, 90).forEach((p, i) => packed.set([p.x, p.y, p.z], i * 3)); s.set.upsert([front(packed)]); assert.equal(line.positions, points); assert.deepEqual(heights(), [70, 80, 90]); // As longitudes and latitudes, converted into the same points. s.set.upsert([ front([ { lon: 0, lat: 0, height: 1 }, { lon: 0, lat: 0, height: 2 }, { lon: 0, lat: 0, height: 3 }, ]), ]); assert.equal(line.positions, points); assert.deepEqual(heights(), [1, 2, 3]); s.set.upsert([front(at(5, 6, 7, 8))]); assert.notEqual(line.positions, points, 'more points: new ones'); assert.deepEqual(heights(), [5, 6, 7, 8]); s.set.dispose(); })); test('a line under half a pixel wide, which the collection does not draw, never settles', () => withImageClasses(() => { const s = settlingSet(); s.set.set([ settleStem('thin', 100, { widthPx: 0.25 }), settleStem('a', 200), ]); s.settle(); const [batch] = s.batches(); assert.deepEqual( batch.geometryInstances.map((one) => one.id.id), ['a'], ); s.set.dispose(); })); test('a settling line set keeps what was drawn, not the item a caller changes in place', () => withImageClasses(() => { const s = settlingSet(); const { set } = s; const a = settleStem('a', 100); set.set([a]); const host = s.host(); // In the collection, a colour change takes the polyline's material in // place. set.upsert([{ ...a, style: { kind: 'solid', color: [0, 1, 0, 1] } }]); assert.equal(s.host(), host, 'recoloured in place'); assert.ok( Cesium.Color.equals( s.polylines().get(0).material.uniforms.color, new Cesium.Color(0, 1, 0, 1), ), ); // The same object, changed and sent again, is compared with what was // drawn: a new width rebuilds. const same = { ...a }; set.upsert([same]); same.widthPx = 6; set.upsert([same]); assert.notEqual(s.host(), host, 'rebuilt for the new width'); assert.equal(s.polylines().get(0).width, 6); set.dispose(); })); test('a settling line set rebuilt or gone while its batch builds, or after the viewer went, lets the batch go', () => withImageClasses(() => { const s = settlingSet(); const { set } = s; set.set([settleStem('a', 100), settleStem('b', 200)]); s.settle(); const [building] = s.batches(); assert.ok(building, 'building'); // A rebuild draws a new host; the batch goes with the old one. const old = s.host(); set.set([settleStem('a', 100)]); assert.ok(!s.scene.added.includes(old), 'the old host is gone'); assert.equal(old.get(1), building); assert.equal(s.batches().length, 0); // Its build finishing later changes nothing. s.built(building); s.frame(); assert.equal(building.show, false); s.settle(); const [again] = s.batches(); s.built(again); s.frame(); assert.equal(again.show, true); // A viewer destroyed under the set takes its batch with it: an upsert // after that rebuilds rather than write to it. s.host().destroy(); assert.equal(again.isDestroyed(), true); set.upsert([settleStem('a', 100, { show: false })]); assert.equal(s.polylines().get(0).show, false, 'drawn anew, hidden'); set.dispose(); })); test('a static batch that fails to build is reported once, and its lines stay in the collection', () => withImageClasses(() => { const scene = fakeScene(); const reported = []; const part = createCesiumDraw({ scene, report: (error) => reported.push(error), }); const set = part.port.lines({ id: 'failing' }); set.set([settleStem('a', 100)]); for (let i = 0; i < SETTLE_FRAMES; i++) part.afterRender(); const host = scene.added[0]; const batch = host.get(1); assert.ok(batch, 'building'); // Its build throws, as a primitive whose workers failed does: the // batch keeps the error rather than throw it every frame. batch.update({ passes: { render: true }, mode: Cesium.SceneMode.SCENE3D }); assert.ok(batch.failed, 'kept'); part.afterRender(); assert.deepEqual(reported, [batch.failed]); assert.equal(host.length, 1, 'the build is gone'); assert.equal(host.get(0).length, 1, 'the collection draws the line'); for (let i = 0; i < SETTLE_FRAMES * 2; i++) part.afterRender(); assert.equal(host.length, 1, 'it settles no more'); assert.equal(reported.length, 1); set.dispose(); })); test('a draped line with segment colours and shows draws a ground instance a segment, changed in place', () => withImageClasses(() => { const { scene, draw, frame } = drawOver(); const set = draw.lines({ id: 'segments', pickable: false }); const trail = (alpha, shows) => ({ id: 'trail', positions: [ { lon: 0, lat: 0 }, { lon: 0.001, lat: 0 }, { lon: 0.001, lat: 0 }, { lon: 0.002, lat: 0 }, ], widthPx: 3, mode: 'draped', style: { kind: 'solid', color: '#ffffff' }, segmentColors: [ [0, 1, 0, alpha], [0, 1, 0, alpha], [1, 0, 0, alpha], ], segmentShow: shows, }); set.set([ trail(0.8, [true, false, false]), { id: 'plain', positions: [ { lon: 1, lat: 0 }, { lon: 1.001, lat: 0 }, ], widthPx: 2, mode: 'draped', style: { kind: 'solid', color: '#7fe6ed' }, }, ]); const host = scene.added[0]; const ground = host.get(1); assert.ok(ground instanceof Cesium.GroundPolylinePrimitive); assert.equal(ground.allowPicking, false); // Two segments with length, and the plain line, in one primitive. const instances = ground.geometryInstances; assert.equal(instances.length, 3); const [first, last] = instances; assert.equal(first.id.id, 'trail', 'picks read as the line'); assert.equal(first.id.set, 'segments'); assert.notEqual(first.id, last.id); assert.deepEqual( [...first.attributes.color.value], [0, 255, 0, Math.round(0.8 * 255)], ); assert.deepEqual([...first.attributes.show.value], [1]); assert.deepEqual([...last.attributes.color.value].slice(0, 3), [255, 0, 0]); assert.deepEqual([...last.attributes.show.value], [0]); const attributes = new Map( instances.map((instance) => [ instance.id, { color: Uint8Array.from(instance.attributes.color.value), show: Uint8Array.from(instance.attributes.show.value), }, ]), ); let writes = 0; ground.getGeometryInstanceAttributes = (id) => { writes += 1; return attributes.get(id); }; // Still building: queued, and written as it swaps in. set.upsert([trail(0.5, [true, false, true])]); assert.equal(scene.added[0], host, 'not rebuilt'); assert.equal(writes, 0); Object.defineProperty(ground, 'ready', { value: true }); frame(); assert.equal(attributes.get(last.id).color[3], Math.round(0.5 * 255)); assert.deepEqual([...attributes.get(last.id).show], [1]); // Ready: only what changed is written. writes = 0; set.upsert([trail(0.5, [false, false, true])]); assert.equal(scene.added[0], host); assert.equal(writes, 1); assert.deepEqual([...attributes.get(first.id).show], [0]); writes = 0; set.upsert([trail(0.5, [false, false, true])]); assert.equal(writes, 0, 'nothing changed, nothing written'); // Shown in place after a queued write: the queued one does not return. const again = draw.lines({ id: 'segments-again' }); again.set([trail(0.8, [true, true, true])]); const queued = scene.added.at(-1).get(1); const shows = new Map( queued.geometryInstances.map((instance) => [ instance.id, { color: new Uint8Array(4), show: new Uint8Array([1]) }, ]), ); queued.getGeometryInstanceAttributes = (id) => shows.get(id); again.upsert([trail(0.8, [false, false, false])]); Object.defineProperty(queued, 'ready', { value: true }); again.upsert([trail(0.8, [true, true, true])]); frame(); for (const { show } of shows.values()) assert.deepEqual([...show], [1]); again.dispose(); // A line of no length draws nothing and holds no swap. const none = draw.lines({ id: 'segments-none' }); const still = { ...trail(1, [true]), positions: [ { lon: 3, lat: 0 }, { lon: 3, lat: 0 }, ], segmentColors: ['#fff'], }; none.set([still]); const empty = scene.added.at(-1); assert.ok( empty instanceof Cesium.PolylineCollection, 'no ground primitive', ); // Its looks changing builds nothing either. none.upsert([{ ...still, segmentShow: [false] }]); assert.equal(scene.added.at(-1), empty, 'not rebuilt'); none.upsert([{ ...still, positions: trail(1, []).positions }]); assert.notEqual(scene.added.at(-1), empty, 'drawn once it has length'); none.dispose(); // Height queries see through every segment. const { pickIds } = unboundDrawPart(draw).sets.get('segments'); assert.ok(pickIds.includes(first.id) && pickIds.includes(last.id)); set.dispose(); })); test('a segmented line of any mode and style draws a primitive a segment, recoloured and shown in place', () => withImageClasses(() => { const { draw, scene } = drawOver(); const set = draw.lines({ id: 'pieces' }); const line = (colors, shows, extra = {}) => ({ id: 'p', positions: [ { lon: 0, lat: 0, height: 100 }, { lon: 0.001, lat: 0, height: 100 }, { lon: 0.001, lat: 0, height: 100 }, { lon: 0.002, lat: 0, height: 100 }, ], widthPx: 3, mode: '3d', style: { kind: 'glow', color: '#ffffff', power: 0.2 }, segmentColors: colors, segmentShow: shows, ...extra, }); const red = [1, 0, 0, 1]; const green = [0, 1, 0, 1]; set.set([line([red, red, green], [true, true, false])]); const host = scene.added[0]; const pieces = []; const walk = (p) => { if (p instanceof Cesium.PrimitiveCollection) for (let i = 0; i < p.length; i++) walk(p.get(i)); else if (p instanceof Cesium.Primitive) pieces.push(p); }; walk(host); assert.equal(pieces.length, 2, 'a primitive a segment of length'); const color = (p) => p.appearance.material.uniforms.color; assert.deepEqual( pieces.map((p) => [color(p).red, color(p).green, p.show]), [ [1, 0, true], [0, 1, false], ], ); assert.equal(pieces[0].appearance.material.type, 'PolylineGlow'); const ids = pieces.map((p) => p.geometryInstances.id); assert.equal(ids[0].id, 'p', 'a segment picks as its line'); assert.notEqual(ids[0], ids[1], 'under a pick id of its own'); set.upsert([line([green, green, red], [true, true, true])]); assert.equal(scene.added[0], host, 'not rebuilt'); assert.deepEqual( pieces.map((p) => [color(p).red, color(p).green, p.show]), [ [0, 1, true], [1, 0, true], ], ); // An arrow's head is on its last segment; a revealed line shows only // the pieces it has reached. set.set([ line([red, red, green], [true, true, true], { style: { kind: 'arrow', color: '#fff' }, revealFraction: 0.25, }), ]); pieces.length = 0; walk(scene.added[0]); const drawn = (p) => p.appearance.material.materials?.revealed ?? p.appearance.material; assert.deepEqual( pieces.map((p) => [drawn(p).type, p.show]), [ ['Color', true], ['PolylineArrow', false], ], ); set.dispose(); })); test('a draped line shown after it is ready keeps that show through the swap', () => withImageClasses(() => { const { draw, frame, scene } = drawOver(); const set = draw.lines({ id: 'swapped' }); const draped = (show) => ({ id: 'a', positions: [ { lon: 0, lat: 0 }, { lon: 1, lat: 1 }, ], widthPx: 2.5, mode: 'draped', style: { kind: 'solid', color: '#7fe6ed' }, show, }); set.set([draped(true)]); const ground = scene.added[0].get(1); const show = new Uint8Array([1]); ground.getGeometryInstanceAttributes = () => ({ show }); // Hidden while it builds: queued for the swap. set.upsert([draped(false)]); // Ready, but not yet swapped in, when it is shown again. Object.defineProperty(ground, 'ready', { value: true }); set.upsert([draped(true)]); frame(); assert.deepEqual([...show], [1], 'the newer show, not the queued one'); set.dispose(); })); test('an icon stands off its position by its pixel offset, and back when it has none', () => { const { scene, draw } = drawOver(); const set = draw.icons({ id: 'offset-pins' }); const icon = (pixelOffset) => ({ id: 'a', pos: { lon: 0, lat: 0 }, image: 'pin.png', size: [8, 8], ...(pixelOffset ? { pixelOffset } : {}), }); set.set([icon({ x: 3, y: -4 })]); const pin = () => scene.added[0].get(0); assert.deepEqual([pin().pixelOffset.x, pin().pixelOffset.y], [3, -4]); set.upsert([icon({ x: 0, y: 6 })]); assert.deepEqual([pin().pixelOffset.x, pin().pixelOffset.y], [0, 6]); set.upsert([icon()]); assert.deepEqual([pin().pixelOffset.x, pin().pixelOffset.y], [0, 0]); set.dispose(); }); test('an icon turned about an axis stands along it, restyled in place when the axis changes', () => { const { scene, draw } = drawOver(); const set = draw.icons({ id: 'axis-pins' }); const icon = (alignedAxis) => ({ id: 'a', pos: { lon: 0, lat: 0 }, image: 'pin.png', size: [8, 8], rotationMode: 'axis', alignedAxis, }); set.set([icon({ x: 0, y: 0, z: 2 })]); const pin = () => scene.added[0].get(0); const axis = () => [ pin().alignedAxis.x, pin().alignedAxis.y, pin().alignedAxis.z, ]; assert.deepEqual(axis(), [0, 0, 1], 'normalised'); assert.equal(pin().rotation, 0); const drawn = pin(); set.upsert([icon({ x: 0, y: 1, z: 0 })]); assert.equal(pin(), drawn, 'the same billboard'); assert.deepEqual(axis(), [0, 1, 0]); set.upsert([{ ...icon(undefined), rotationMode: 'screen' }]); assert.deepEqual(axis(), [0, 0, 0], 'upright again'); set.dispose(); }); test('a wall stands up from the ellipsoid to its positions, with or without a fill', () => { const { scene, draw } = drawOver(); const set = draw.shapes({ id: 'walls' }); const wall = (id, fill) => ({ id, geometry: { kind: 'wall', positions: [ { lon: 0, lat: 0, height: 100 }, { lon: 0.01, lat: 0, height: 150 }, ], }, fill, outline: [1, 1, 0, 1], }); set.set([wall('filled', [0, 0, 1, 0.5]), wall('outline', null)]); const geometries = []; const walk = (primitive) => { if (!primitive) return; if (primitive instanceof Cesium.PrimitiveCollection) for (let i = 0; i < primitive.length; i++) walk(primitive.get(i)); for (const instance of [primitive.geometryInstances ?? []].flat()) geometries.push([instance.id?.id, instance.geometry.constructor.name]); }; scene.added.forEach(walk); assert.deepEqual(geometries.sort(), [ ['filled', 'WallGeometry'], ['filled', 'WallOutlineGeometry'], ['outline', 'WallOutlineGeometry'], ]); set.dispose(); }); test('icons blend as their set says', () => { const { scene, draw } = drawOver(); const set = draw.icons({ id: 'pins', blend: 'translucent' }); set.set([ { id: 'a', pos: { lon: 0, lat: 0 }, image: 'pin.png', size: [6, 6], }, ]); assert.equal(scene.added[0].blendOption, Cesium.BlendOption.TRANSLUCENT); set.setOptions({ blend: undefined }); assert.equal( scene.added[0].blendOption, Cesium.BlendOption.OPAQUE_AND_TRANSLUCENT, ); set.dispose(); }); test('icon sets change their billboards in place: restyled, moved, re-imaged, added and removed', () => { const scene = fakeScene(); const part = createCesiumDraw({ scene, report: (error) => assert.fail(error), }); const set = part.port.icons({ id: 'icons:in-place', horizonCull: true }); const record = part.sets.get('icons:in-place'); const icon = (id, lon, extra = {}) => ({ id, pos: { lon, lat: 0 }, image: 'a.png', size: [10, 10], ...extra, }); set.set([icon('a', 0), icon('b', 1)]); const [host] = scene.added; const [a, b] = [host.get(0), host.get(1)]; const version = part.version(); set.upsert([ icon('a', 2, { color: [0, 1, 0, 1], scale: 2, meta: { n: 1 }, rotationMode: 'screen', rotation: 0.5, image: 'b.png', }), ]); assert.equal(scene.added[0], host, 'the same collection'); assert.equal(host.get(0), a, 'the same billboard'); assert.ok(Cesium.Color.equals(a.color, Cesium.Color.LIME)); assert.equal(a.width, 20); assert.equal(a.rotation, 0.5); assert.equal(a.image, 'b.png', 'its image swapped'); assert.equal(b.image, 'a.png', 'the others keep theirs'); assert.deepEqual(a.id.meta, { n: 1 }, 'picks read the new meta'); const moved = Cesium.Cartographic.fromCartesian(a.position); assert.ok(Math.abs(Cesium.Math.toDegrees(moved.longitude) - 2) < 1e-9); assert.equal( part.version(), version, 'changed in place, the pick ids height queries see through are the same', ); // Back to the defaults it dropped. set.upsert([icon('a', 2)]); assert.equal(a.rotation, 0); assert.equal(a.width, 10); set.upsert([icon('c', 3)]); assert.equal(scene.added[0], host, 'a new icon is added to it'); assert.equal(host.length, 3); const added = part.version(); assert.ok(added > version, 'a new pick id for height queries to see'); set.remove(['b']); assert.equal(scene.added[0], host, 'and one removed from it'); assert.equal(host.length, 2); assert.ok(part.version() > added, 'and one gone'); assert.deepEqual( record.pickIds.map((id) => id.id).sort(), ['a', 'c'], 'height queries no longer see through what went', ); assert.deepEqual( record.placed.map((p) => p.primitive), [a, host.get(1)], 'the horizon cull no longer tests it', ); // Hidden in place, then culled with the rest. set.upsert([icon('a', 2, { show: false })]); assert.equal(a.show, false); // A set in the same order patches; a new order rebuilds. set.set([icon('a', 2), icon('c', 3)]); assert.equal(scene.added[0], host); set.set([icon('c', 3), icon('a', 2)]); assert.notEqual(scene.added[0], host, 'reordered: rebuilt'); assert.equal(scene.added[0].get(0).id.id, 'c'); set.clear(); assert.equal(scene.added[0].length, 0); set.dispose(); assert.equal(scene.added.length, 0); }); test('an icon drawn from an atlas slot takes a re-registered slot in place', () => { const scene = fakeScene(); const part = createCesiumDraw({ scene, report: (error) => assert.fail(error), }); const set = part.port.icons({ id: 'icons:atlas' }); const icon = (id, slot, lon) => ({ id, pos: { lon, lat: 0 }, image: { atlas: 'marks', slot }, size: [8, 8], }); set.set([icon('one', 'dot', 0), icon('two', 'ring', 1)]); const [host] = scene.added; assert.equal(host.length, 0, 'nothing to draw until the atlas comes'); part.port.atlas('marks', { dot: 'dot.png' }); assert.equal(scene.added[0], host); const one = host.get(0); assert.equal(one.image, 'dot.png'); part.port.atlas('marks', { dot: 'next.png', ring: 'ring.png' }); assert.equal(scene.added[0], host, 'not rebuilt'); assert.equal(host.get(0), one, 'the same billboard'); assert.equal(one.image, 'next.png'); assert.equal(host.get(1).image, 'ring.png', 'the slot that came draws'); const version = part.version(); part.port.atlas('marks', { dot: 'again.png', ring: 'ring.png' }); assert.equal(scene.added[0], host, 'new images only: not rebuilt'); assert.equal(host.get(0), one, 'the same billboard'); assert.equal(one.image, 'again.png'); assert.equal(part.version(), version, 'the same pick ids'); part.port.atlas('marks', { ring: 'ring.png' }); assert.equal(host.length, 1, 'a slot gone takes its icon down'); assert.ok(part.version() > version, 'one pick id fewer'); assert.equal(host.get(0).id.id, 'two'); // A slot that comes for an icon ahead of one drawn rebuilds, in order. part.port.atlas('marks', { dot: 'dot.png', ring: 'ring.png' }); assert.notEqual(scene.added[0], host); assert.deepEqual( [scene.added[0].get(0).id.id, scene.added[0].get(1).id.id], ['one', 'two'], ); set.dispose(); }); test('an icon set is built anew where changing it in place would draw out of order or keep stale images', () => { const scene = fakeScene(); const part = createCesiumDraw({ scene, report: (error) => assert.fail(error), }); const set = part.port.icons({ id: 'icons:anew' }); const icon = (id, image = 'a.png') => ({ id, pos: { lon: 0, lat: 0 }, image, size: [8, 8], }); set.set([icon('a'), icon('c')]); let host = scene.added[0]; set.set([icon('a'), icon('b'), icon('c')]); assert.notEqual(scene.added[0], host, 'one put between two drawn: rebuilt'); assert.deepEqual( [0, 1, 2].map((i) => scene.added[0].get(i).id.id), ['a', 'b', 'c'], ); // A generated image swaps under a new key; a new canvas under the key it // had cannot change that key's texture, so it rebuilds. const canvas = { width: 8, height: 8 }; set.set([icon('a', { canvas, key: 'one' })]); host = scene.added[0]; const a = host.get(0); set.upsert([icon('a', { canvas, key: 'two' })]); assert.equal(scene.added[0], host, 'a new key swaps in place'); assert.equal(host.get(0), a); set.upsert([icon('a', { canvas: { width: 8, height: 8 }, key: 'two' })]); assert.notEqual(scene.added[0], host, 'a new canvas, same key: rebuilt'); // Its collection keeps what it loaded, so cycling images rebuilds now and // then, holding only what it draws. host = scene.added[0]; let rebuilds = 0; for (let i = 0; i < 200; i++) { set.upsert([icon('a', `cycle-${i}.png`)]); if (scene.added[0] !== host) { rebuilds += 1; host = scene.added[0]; } } assert.ok(rebuilds >= 2 && rebuilds <= 4, `rebuilt ${rebuilds} times`); assert.ok(part.sets.get('icons:anew').imageKeys.size <= 64); set.clear(); assert.notEqual(scene.added[0], host, 'emptied: built anew, empty'); assert.equal(scene.added[0].length, 0); set.dispose(); }); test('icons scale, fade and show by eye distance, and drop the curves in place', () => { const scene = fakeScene(); const part = createCesiumDraw({ scene, report: (error) => assert.fail(error), }); const set = part.port.icons({ id: 'icons:distance' }); const icon = (extra = {}) => ({ id: 'a', pos: { lon: 0, lat: 0 }, image: 'a.png', size: [8, 8], ...extra, }); set.set([ icon({ scaleByDistance: { near: 1e3, nearValue: 1.5, far: 1e6, farValue: 0.5 }, fadeByDistance: { near: 2e3, nearValue: 1, far: 2e6, farValue: 0 }, displayRange: [10, 5e6], }), ]); const [host] = scene.added; const a = host.get(0); assert.ok( Cesium.NearFarScalar.equals( a.scaleByDistance, new Cesium.NearFarScalar(1e3, 1.5, 1e6, 0.5), ), ); assert.ok( Cesium.NearFarScalar.equals( a.translucencyByDistance, new Cesium.NearFarScalar(2e3, 1, 2e6, 0), ), ); assert.equal(a.distanceDisplayCondition.near, 10); assert.equal(a.distanceDisplayCondition.far, 5e6); set.upsert([icon()]); assert.equal(host.get(0), a, 'changed in place'); assert.equal(a.scaleByDistance, undefined); assert.equal(a.translucencyByDistance, undefined); assert.equal(a.distanceDisplayCondition, undefined); set.upsert([ icon({ scaleByDistance: { near: 5, nearValue: 1, far: 5, farValue: 2 }, }), ]); assert.equal(a.scaleByDistance, undefined, 'no curve: left out'); set.upsert([icon({ displayRange: [100, 100] })]); assert.equal(a.show, false, 'an empty range shows it nowhere'); set.dispose(); }); /** * The vessels layer over a fake scene, drawing through the draw port, with * `sprites` as its sprite-order services. */ async function vesselLayerOver(scene, sprites) { const { createVesselLayer } = await import('../../layers/vessels/index.js'); const part = createCesiumDraw({ scene, report: (error) => assert.fail(error), }); const viewer = { scene }; const noop = () => {}; const unbind = bindRenderer(viewer, { draw: part.port, query: { project: () => null, projectMany: (s, out) => out.fill(NaN) }, }); const layer = createVesselLayer({ source: { getSnapshot: async () => ({ records: [] }) }, services: { context: { clearSelectedEntityContextForLayer: noop, registerEntityContext: () => null, }, trails: { createTrail: () => ({ setPositions: noop, clear: noop, destroy: noop }), }, labels: { formatKnots: (knots) => `${knots} kt` }, picking: { unregisterPickOwner: noop }, overlay: { setOverlayEntries: noop, setOverlaySourceVisible: noop, clearOverlaySource: noop, }, geoid: {}, sprites, focus: { focusNowMs: (now) => now, getFocusTarget: () => null, focusPassIsNeeded: () => false, forgetSpriteFocus: noop, }, worldFocus: {}, render: { holdContinuousRender: noop, releaseContinuousRender: noop, governorRequestRender: noop, }, }, }); return { layer, viewer, part, unbind }; } test('the vessels layer draws its ships as one GPU icon set that holds them on course', async () => { const { IconSetPrimitive } = await import('./iconSetPrimitive.js'); const { ICON_CULL_LIFT, ICON_ROTATES } = await import('../../data/iconSet.js'); const spriteOrder = await import('../../data/spriteOrder.js'); const scene = fakeScene(); const { layer, viewer, part, unbind } = await vesselLayerOver( scene, spriteOrder, ); try { layer.testing._setVesselStateForTest({ viewer, icons: null }); layer.testing._reconcileVesselsForTest(viewer, [ { mmsi: '244000001', lat: 51.95, lon: 4.1, heading: 90, speed: 12 }, { mmsi: '244000002', lat: 51.96, lon: 4.2, course: 200, speed: 2 }, ]); const [host] = scene.added; assert.ok(host instanceof IconSetPrimitive, 'one GPU icon set'); assert.match(host.drawSetId, /^ais-vessels:\d+$/); const record = part.sets.get(host.drawSetId); const set = record.gpu.set; assert.equal(set.count, 2); const row = set.row('244000001'); const tau = set.seconds(Cesium.JulianDate.now()); assert.equal(set.course(row, tau), 90, 'held on its heading'); assert.equal(set.course(set.row('244000002'), tau), 200, 'or its course'); assert.equal(set.width(row), 32); assert.ok(Math.abs(set.scale(row) - 0.68) < 1e-6, 'scaled by speed'); assert.equal(set.flags(row) & ICON_ROTATES, ICON_ROTATES); assert.equal(set.flags(row) & ICON_CULL_LIFT, ICON_CULL_LIFT); assert.ok(set.depthTestDistance(row) >= 1e30, 'over depth everywhere'); const at = Cesium.Cartographic.fromCartesian(set.position(row, tau)); assert.ok(Math.abs(Cesium.Math.toDegrees(at.longitude) - 4.1) < 1e-6); assert.ok(Math.abs(Cesium.Math.toDegrees(at.latitude) - 51.95) < 1e-6); const facade = { show: true }; assert.deepEqual(drawHitOf(host._pickObject('244000001', null, facade)), { set: host.drawSetId, id: '244000001', meta: { layer: 'ais-live-vessels', id: '244000001' }, surface: false, }); // A poll that moves one and drops the other writes rows, not a new host. layer.testing._reconcileVesselsForTest(viewer, [ { mmsi: '244000001', lat: 51.95, lon: 4.12, heading: 95, speed: 12 }, ]); assert.equal(scene.added[0], host); assert.equal(set.count, 1); assert.equal(set.course(set.row('244000001'), tau), 95); // The set stacks at the vessels' place in the sprite order. assert.equal(record.spec.drawOrder, spriteOrder.spriteDrawOrder('ais')); // Torn down and drawn again: a new set at the same draw order, with // the old host gone from the scene. layer.destroy(viewer); assert.equal(scene.added.length, 0, 'destroyed: the set goes'); layer.testing._setVesselStateForTest({ viewer, icons: null }); layer.testing._reconcileVesselsForTest(viewer, [ { mmsi: '244000003', lat: 51.9, lon: 4.0, heading: 10, speed: 5 }, ]); assert.equal(scene.added.length, 1); const [again] = scene.added; assert.notEqual(again, host); assert.notEqual(again.drawSetId, host.drawSetId, 'a new set id'); assert.equal(part.sets.has(host.drawSetId), false); assert.equal( part.sets.get(again.drawSetId).spec.drawOrder, spriteOrder.spriteDrawOrder('ais'), ); layer.destroy(viewer); assert.equal(scene.added.length, 0); } finally { unbind(); } }); test('the FIRMS layer draws its fire glows as one GPU icon set on a viewer of its own', async (t) => { const { createRendering } = await import('../../layers/firms/rendering.js'); const { createModel } = await import('../../layers/firms/model.js'); const { createFirmsState } = await import('../../layers/firms/state.js'); const { IconSetPrimitive } = await import('./iconSetPrimitive.js'); const { ICON_CULL_LIFT } = await import('../../data/iconSet.js'); const { GLOW_SPRITE_PX, LOD_LEVELS } = await import('../../layers/firms/policy.js'); // Each glow colour is rasterised on a canvas once. const hadDocument = Object.hasOwn(globalThis, 'document'); const priorDocument = globalThis.document; globalThis.document = { createElement: () => { let stops = []; return { width: 0, height: 0, getContext: () => ({ createRadialGradient: () => ({ addColorStop: (_, color) => stops.push(color), }), fillRect() {}, }), toDataURL: () => `data:image/png;base64,AAAA#${stops.join('|')}`, }; }, }; t.after(() => { if (hadDocument) globalThis.document = priorDocument; else delete globalThis.document; }); const scene = fakeScene(); const viewer = { scene, isDestroyed: () => false }; const sprites = []; const noop = () => {}; const services = { anchors: { fireAnchorHeight: () => 40, warmFireAnchorFloors: async () => false, }, sprites: { spriteDrawOrder: (layerId) => { sprites.push(layerId); return spriteDrawOrder(layerId); }, }, }; const config = { overlayHost: { setVisible: noop, clearSource: noop }, }; const layerState = createFirmsState({ services, config }); layerState._viewer = viewer; layerState._enabled = true; const components = { cards: { rebuildAmbientLabels: noop }, selection: { refreshContextRegistrations: noop }, }; const context = { layerState, services, config, components, feed: null }; components.model = createModel(context); const rendering = createRendering(context); const fire = (index, lon, frp) => ({ index, lat: 30.2, lon, frp, confidence: 0.9, brightness: 340, acqMs: 1, }); layerState._firesByFrp = [fire(0, -97.7, 900), fire(1, -97.6, 4)]; const local = LOD_LEVELS.find((lod) => lod.id === 'local'); rendering.renderDetections(local, null); const [host] = scene.added; assert.ok(host instanceof IconSetPrimitive, 'one GPU icon set'); assert.deepEqual(sprites, ['firms'], 'at the fires’ draw order'); const set = host.set; assert.equal(set.count, 2); const strong = set.row('firms-0'); const weak = set.row('firms-1'); assert.equal(set.flags(strong) & ICON_CULL_LIFT, ICON_CULL_LIFT); assert.ok(set.depthTestDistance(strong) >= 1e30, 'over depth everywhere'); // One raster per colour at the sprite's size, drawn at the fire's size. assert.equal(set.width(strong), GLOW_SPRITE_PX); const drawnPx = (row) => set.width(row) * set.scale(row); assert.ok(Math.abs(drawnPx(strong) - 56) < 1e-4, `${drawnPx(strong)} px`); assert.ok(Math.abs(drawnPx(weak) - 24) < 1e-4, `${drawnPx(weak)} px`); assert.notEqual(set.imageFar(strong), set.imageFar(weak), 'red, not yellow'); const tau = set.seconds(Cesium.JulianDate.now()); const at = Cesium.Cartographic.fromCartesian(set.position(strong, tau)); assert.ok(Math.abs(Cesium.Math.toDegrees(at.longitude) + 97.7) < 1e-6); assert.ok(Math.abs(at.height - 40) < 1e-3, 'at its anchor'); assert.deepEqual( drawHitOf(host._pickObject('firms-0', null, { show: true })), { set: host.drawSetId, id: 'firms-0', meta: { layer: 'firms', id: 'firms-0' }, surface: false, }, ); // A rebuild that keeps one fire writes nothing for it and drops the other. const written = []; const upsert = layerState._icons.upsert.bind(layerState._icons); layerState._icons.upsert = (items) => { written.push(...items.map((item) => item.id)); return upsert(items); }; layerState._firesByFrp = [layerState._firesByFrp[0]]; rendering.renderDetections(local, null); assert.equal(set.count, 1); assert.equal(set.idAt(0), 'firms-0'); assert.deepEqual(written, [], 'the kept fire is not written again'); assert.equal(scene.added[0], host, 'the same host'); // Hidden with the layer, and gone with it. layerState._icons.show = false; assert.equal(host.show, false); rendering.removeDetectionCollections(); assert.equal(scene.added.length, 0); }); test('the Radio layer draws its stations, clusters and selected marker as point and billboard sets', async () => { const { withRadioLayer, radioStationRow } = await import('../../testSupport/radioLayerHarness.mjs'); const { radioLayer, radioStationIdFromPick } = await import('../../data/radio.js'); const { fromDegrees, toLonLatH, WGS84 } = await import('../../geo/ellipsoid.js'); const scene = fakeScene(); const part = createCesiumDraw({ scene, report: (error) => assert.fail(error), }); // A flat projection, 1000 CSS px a degree from (-98, 31) at the top left. const renderer = { draw: part.port, canvas: { clientWidth: 2000, clientHeight: 1000 }, camera: { pose: () => ({ position: fromDegrees(-97, 30, 1e6), height: 1e6 }), on: () => () => {}, }, query: { project(p) { const { lon, lat } = toLonLatH(p, WGS84); return { x: (lon + 98) * 1000, y: (31 - lat) * 1000 }; }, }, }; const station = (n, lon, lat) => radioStationRow({ id: `00000000-0000-4000-8000-0000000000${String(n).padStart(2, '0')}`, name: `Station ${n}`, lon, lat, tags: ['news'], streamUrl: `https://radio.example.com/${n}.mp3`, }); const stations = [ station(1, -97.0, 30.0), station(2, -96.98, 30.0), station(3, -97.0, 29.98), station(4, -96.5, 30.0), ]; await withRadioLayer({ stations, renderer }, async () => { const rows = (pattern) => { const out = []; for (const host of scene.added) { const collections = host instanceof Cesium.PrimitiveCollection ? [host.get(0), host.get(1)] : [host]; for (const collection of collections) for (let i = 0; i < (collection?.length ?? 0); i += 1) { const primitive = collection.get(i); if (pattern.test(primitive.id?.set)) out.push(primitive); } } return out; }; const dots = rows(/^radio:\d+:stations$/); assert.equal(dots.length, 4); assert.ok(dots.every((dot) => dot instanceof Cesium.PointPrimitive)); const lone = dots.find((dot) => dot.show); assert.equal( lone.id.id, `radio:${stations[3].id}`, 'the others are in a cluster', ); assert.equal(lone.pixelSize, 13); assert.equal(lone.outlineWidth, 1); assert.ok(Math.abs(lone.color.alpha - 0.86) < 1e-6); assert.equal(lone.disableDepthTestDistance, Number.POSITIVE_INFINITY); assert.equal(lone.distanceDisplayCondition.far, 50_000_000); assert.equal(lone.scaleByDistance.nearValue, 1.15); assert.equal( radioStationIdFromPick({ primitive: lone, id: lone.id }), stations[3].id, ); const [cluster] = rows(/^radio:\d+:clusters$/); assert.deepEqual( cluster.id.meta.stationIds, stations.slice(0, 3).map((s) => s.id), ); assert.equal(cluster.pixelSize, 12 + Math.log2(3) * 1.6); assert.equal(cluster.outlineWidth, 2); assert.equal( radioStationIdFromPick({ primitive: cluster, id: cluster.id }), stations[0].id, ); radioLayer.selectStation(stations[3].id, { autoplay: false, focus: false }); const [selected] = rows(/^radio:\d+:selected$/); const [bracket] = rows(/^radio:\d+:selected-bracket$/); assert.equal(selected.pixelSize, 14); assert.equal(selected.id.id, `radio:selected:${stations[3].id}`); assert.ok(bracket instanceof Cesium.Billboard); assert.equal(bracket.width, 40); assert.equal(bracket.scaleByDistance.farValue, 0.72); assert.equal( radioStationIdFromPick({ primitive: bracket, id: bracket.id }), stations[3].id, ); }); assert.equal(scene.added.length, 0, 'gone with the layer'); }); test('vessels on a host without the sprite order still draw, at the default draw order', async () => { const scene = fakeScene(); const { layer, viewer, part, unbind } = await vesselLayerOver(scene, {}); const ship = { mmsi: '244000001', lat: 51.95, lon: 4.1, heading: 90 }; layer.testing._setVesselStateForTest({ viewer, icons: null }); layer.testing._reconcileVesselsForTest(viewer, [ship]); assert.equal(scene.added.length, 1, 'drawn'); assert.equal(part.sets.get(scene.added[0].drawSetId).spec.drawOrder, 0); layer.destroy(viewer); unbind(); }); test('an aircraft layer draws its contacts as one GPU icon set moving on the delayed live clock', async () => { const { createAircraftIcons } = await import('../../data/aircraftIconLayer.js'); const { IconSetPrimitive } = await import('./iconSetPrimitive.js'); const { ICON_CULL_LIFT, ICON_RECEDES, ICON_ROTATES } = await import('../../data/iconSet.js'); const { iconAtlas, nearImageSwitchPx } = await import('../../data/iconAtlas.js'); const { aircraftIcon, FLEET_ICON_PX, TRACKED_ICON_PX } = await import('../../data/aircraftIcons.js'); const { aircraftMotionRegime, createMotionRegime, fixEpochMs, julianAt } = await import('../../data/aircraftMotionRegime.js'); const scene = fakeScene(); const part = createCesiumDraw({ scene, report: (error) => assert.fail(error), }); const viewer = { scene }; const unbind = bindRenderer(viewer, { draw: part.port, capabilities: new Set(['columns', 'motionSegments', 'courseGlide']), quality: { get: () => ({ pixelRatio: 2 }) }, }); const now = Date.now(); const delayMs = 30_000; const fixAt = (lon, ms) => ({ time: julianAt(ms), epochMs: ms, position: Cesium.Cartesian3.fromDegrees(lon, 30, 10_000), velocity: 250, track: 90, }); const state = { _viewer: viewer, _icons: null, _iconFocusActive: 0, _positionHistory: new Map([ ['abc123', [fixAt(-97, now - 40_000), fixAt(-96.9, now - 20_000)]], ]), _displayCourse: new Map(), _groundSnap: { forget() {} }, _models: new Map(), _trackedIcao: null, _cockpitContactMode: false, _cockpitNearContacts: new Set(), records: { data: new Map([['abc123', { klass: 'airliner', velocity: 250 }]]), missingPolls: new Map(), forget() {}, }, }; const parts = { motion: { _motionRegime: (history, info, renderTime) => aircraftMotionRegime( history, info, renderTime, { speed: 'velocity', track: 'true_track' }, createMotionRegime(), ), _displayTimeAt: julianAt, _fixEpochMs: fixEpochMs, }, rendering: { _iconKind: (id, klass) => klass, _fleetBillboardScale: () => 1.25, _fleetBillboardColor: () => Cesium.Color.WHITE, _cockpitContactColor: () => Cesium.Color.CYAN, _releaseModel() {}, }, }; const icons = createAircraftIcons({ state, services: { focus: { focusPassIsNeeded: () => false } }, parts, layerId: 'flights', renderDelaySec: delayMs / 1000, courseMaxDps: 3, cockpitContactSizePx: 6, }); try { const setId = icons._createIcons(viewer); assert.match(setId, /^flights-icons:\d+$/); icons._addIcon('abc123'); // Written together once the task ends. await Promise.resolve(); const [host] = scene.added; assert.ok(host instanceof IconSetPrimitive, 'one GPU icon set'); assert.equal(host.drawSetId, setId); const set = part.sets.get(setId).gpu.set; assert.equal(set.count, 1); const row = set.row('abc123'); assert.equal( set.imageFar(row), iconAtlas.slot(aircraftIcon('airliner'), FLEET_ICON_PX), 'the fleet glyph rasterised at 64 px', ); assert.equal( set.imageNear(row), iconAtlas.slot( aircraftIcon('airliner', TRACKED_ICON_PX), TRACKED_ICON_PX, ), 'the near glyph at 192 px', ); assert.equal(set.imageSwitch(row), nearImageSwitchPx(2)); assert.equal(set.width(row), 20); assert.ok(Math.abs(set.scale(row) - 1.25) < 1e-6); const flags = set.flags(row); assert.equal(flags & ICON_ROTATES, ICON_ROTATES); assert.equal(flags & ICON_RECEDES, ICON_RECEDES); assert.equal(flags & ICON_CULL_LIFT, ICON_CULL_LIFT); assert.ok(set.depthTestDistance(row) >= 1e30, 'over depth everywhere'); // Drawn where the layer reads it, between its two fixes. const t = Date.now() - delayMs; const tau = set.seconds(julianAt(t)); const drawn = set.position(row, tau); const read = icons._iconPosition('abc123'); assert.ok(Cesium.Cartesian3.distance(drawn, read) < 0.5, 'same place'); const lon = Cesium.Math.toDegrees( Cesium.Cartographic.fromCartesian(drawn).longitude, ); assert.ok(lon > -97 && lon < -96.9, 'interpolating the fixes'); assert.ok( Math.abs(set.course(row, tau) - icons._iconCourse('abc123')) < 0.01, ); assert.equal(state._icons.expires('abc123'), now - 20_000); assert.deepEqual( drawHitOf(host._pickObject('abc123', null, { show: true })), { set: setId, id: 'abc123', meta: { layer: 'flights', id: 'abc123' }, surface: false, }, ); // A restyle that changes nothing writes nothing; hiding it writes it. const before = part.sets.get(setId).items.get('abc123'); icons._applyIconPresentation('abc123'); await Promise.resolve(); assert.equal(part.sets.get(setId).items.get('abc123'), before); icons._setIconShown('abc123', false); await Promise.resolve(); assert.equal(set.shown(row), false); icons._forgetContact('abc123'); await Promise.resolve(); assert.equal(set.count, 0); icons._disposeIcons(); assert.equal(scene.added.length, 0, 'disposed: the set goes'); } finally { unbind(); } }); test('an extruded outline-only shape draws the volume edges, not a ring at its base', () => { const scene = fakeScene(); const { draw } = drawOver(scene); const set = draw.shapes({ id: 'volumes' }); const ring = [ { lon: 0, lat: 0, height: 100 }, { lon: 0.001, lat: 0, height: 100 }, { lon: 0.001, lat: 0.001, height: 100 }, ]; set.set([ { id: 'cage', geometry: { kind: 'polygon', rings: [ring] }, outline: [1, 0.7, 0.3, 0.32], outlineOnly: true, extrudeHeight: 220, height: 'absolute', }, ]); const edges = scene.added[0].get(0); assert.ok(edges instanceof Cesium.Primitive); assert.ok( [edges.geometryInstances].flat()[0].geometry instanceof Cesium.PolygonOutlineGeometry, ); set.dispose(); }); test('an unclamped shape filled with an image draws a textured primitive and frees its material with its host', () => withImageClasses(() => { const scene = fakeScene(); const draw = createCesiumDraw({ scene, report: (error) => assert.fail(error), }).port; const set = draw.shapes({ id: 'images' }); set.set([ { id: 'image', geometry: { kind: 'rectangle', rect: { west: 2, south: 1, east: 2.1, north: 1.1 }, height: 200, }, fill: { image: 'picture.png', repeat: [2, 3] }, }, ]); const host = scene.added[0]; const primitive = host.get(0); assert.ok(primitive instanceof Cesium.Primitive); const { appearance, geometryInstances } = primitive; assert.ok(appearance instanceof Cesium.MaterialAppearance); assert.equal(appearance.material.type, 'Image'); assert.equal(appearance.material.uniforms.image, 'picture.png'); assert.equal(appearance.isTranslucent(), true, 'its own alpha blends'); assert.deepEqual( appearance.material.uniforms.repeat, new Cesium.Cartesian2(2, 3), ); assert.deepEqual( [appearance.flat, appearance.faceForward, appearance.translucent], [true, true, true], ); assert.ok(geometryInstances.geometry instanceof Cesium.RectangleGeometry); // Texture coordinates for the image, as its appearance reads them. assert.equal(geometryInstances.geometry._vertexFormat.st, true); assert.equal(geometryInstances.id.id, 'image'); assert.equal( drawHitOf({ primitive, id: geometryInstances.id }).set, 'images', ); const material = appearance.material; // As Cesium's collection does, a removed host is destroyed; a // rebuild's old host goes with its material. scene.primitives.remove = (primitive) => { const at = scene.added.indexOf(primitive); if (at >= 0) scene.added.splice(at, 1); primitive.destroy(); return at >= 0; }; set.upsert([ { id: 'image', geometry: { kind: 'rectangle', rect: { west: 2, south: 1, east: 2.2, north: 1.1 }, }, fill: { image: 'picture.png' }, }, ]); assert.equal(material.isDestroyed(), true); const next = scene.added[0].get(0).appearance.material; assert.equal(next.isDestroyed(), false); set.dispose(); assert.equal(scene.added.length, 0); assert.equal(next.isDestroyed(), true); assert.throws( () => draw.shapes({ id: 'patterns' }).set([ { id: 'p', geometry: { kind: 'rectangle', rect: { west: 0, south: 0, east: 1, north: 1 }, }, fill: { gradient: 'radial' }, }, ]), /colours only/, ); })); test('an unclamped image fill takes a new canvas in place; anything else about it rebuilds', () => withImageClasses(() => { const scene = fakeScene(); const draw = createCesiumDraw({ scene, report: (error) => assert.fail(error), }).port; const set = draw.shapes({ id: 'band' }); const canvases = [new HTMLCanvasElement(), new HTMLCanvasElement()]; const band = (k, extra = {}) => ({ id: 'band', geometry: { kind: 'ellipse', center: { lon: 10, lat: 20, height: 2500 }, semiMajor: 50_000, semiMinor: 50_000, }, fill: { image: { canvas: canvases[k % 2], key: `band:${k}` } }, height: 'absolute', ...extra, }); set.set([band(0)]); const host = scene.added[0]; const primitive = host.get(0); const material = primitive.appearance.material; assert.equal(material.uniforms.image, canvases[0]); // Not yet drawn, it rebuilds. set.upsert([band(1)]); assert.notEqual(scene.added[0], host, 'not yet drawn: rebuilt'); const drawn = scene.added[0].get(0); drawn._ready = true; const drawnMaterial = drawn.appearance.material; // Drawn, a new canvas, its show and its meta change in place; with no // drawing context the material takes the canvas itself. set.upsert([band(2, { meta: 'm', show: false })]); assert.equal(scene.added[0].get(0), drawn, 'changed in place'); assert.equal(drawnMaterial.uniforms.image, canvases[0]); assert.equal(drawn.show, false); set.upsert([band(3)]); assert.equal(scene.added[0].get(0), drawn); assert.equal(drawnMaterial.uniforms.image, canvases[1]); assert.equal(drawn.show, true); // The same key is the same image: nothing is written. drawnMaterial.uniforms.image = 'untouched'; set.upsert([band(3)]); assert.equal(drawnMaterial.uniforms.image, 'untouched'); // Another shape or height rebuilds. set.upsert([{ ...band(4), height: 'clampGround' }]); assert.notEqual(scene.added[0].get?.(0), drawn, 'rebuilt'); set.dispose(); })); test('a draped rectangle turns, its image fill with it, on a ground primitive that owns its material', () => withImageClasses(() => { const scene = fakeScene(); const draw = createCesiumDraw({ scene, report: (error) => assert.fail(error), }).port; const set = draw.shapes({ id: 'overlays' }); const overlay = (extra = {}) => ({ id: 'overlay', geometry: { kind: 'rectangle', rect: { west: 2, south: 1, east: 2.1, north: 1.1 }, rotation: 0.4, }, fill: { image: 'overlay.png' }, height: 'clampGround', ...extra, }); const tinted = { id: 'tinted', geometry: { kind: 'rectangle', rect: { west: 2, south: 1, east: 2.1, north: 1.1 }, rotation: -0.2, }, fill: [1, 0, 0, 0.5], height: 'clampGround', }; set.set([overlay(), tinted]); const grounds = () => { const host = scene.added[0]; const out = []; for (let i = 0; i < host.length; i++) if (host.get(i) instanceof Cesium.GroundPrimitive) out.push(host.get(i)); return out; }; const [image, colour] = grounds(); assert.equal( grounds().length, 2, 'the image on a ground primitive of its own', ); const { appearance, geometryInstances } = image; assert.ok(appearance instanceof Cesium.MaterialAppearance); assert.equal(appearance.material.type, 'Image'); assert.equal(appearance.material.uniforms.image, 'overlay.png'); const [instance] = geometryInstances; assert.equal(instance.id.id, 'overlay'); assert.equal(instance.geometry._rotation, 0.4); assert.equal(instance.geometry._stRotation, 0.4, 'the image turns with it'); assert.equal(instance.attributes.color, undefined); assert.equal(colour.geometryInstances[0].geometry._rotation, -0.2); // Hiding it is a change of its show, not a rebuild. const host = scene.added[0]; set.upsert([overlay({ show: false })]); assert.equal(scene.added[0], host, 'not rebuilt'); const material = appearance.material; scene.primitives.remove = (primitive) => { const at = scene.added.indexOf(primitive); if (at >= 0) scene.added.splice(at, 1); primitive.destroy(); return at >= 0; }; set.dispose(); assert.equal(material.isDestroyed(), true, 'its material goes with it'); // Not rotated, it is as before. const plain = draw.shapes({ id: 'plain' }); plain.set([ overlay({ geometry: { kind: 'rectangle', rect: { west: 2, south: 1, east: 2.1, north: 1.1 }, }, }), ]); const [flat] = grounds(); assert.equal(flat.geometryInstances[0].geometry._rotation, 0); plain.dispose(); // An atlas slot fills as the image it holds; one not registered is // refused before anything is built. const made = scene.added.length; assert.throws( () => draw .shapes({ id: 'atlas' }) .set([ overlay(), overlay({ id: 'b', fill: { image: { atlas: 'a', slot: 's' } } }), ]), /atlas a has no slot s registered/, ); assert.equal(scene.added.length, made, 'nothing drawn'); draw.atlas('a', { s: 'slot.png' }); const slotted = draw.shapes({ id: 'atlas-registered' }); slotted.set([ overlay({ id: 'b', fill: { image: { atlas: 'a', slot: 's' } } }), ]); assert.ok(scene.added.length > made, 'drawn from the slot'); slotted.dispose(); })); test('scene data packs draw their geometry and media marker through the Cesium draw port on a viewer of its own', async (t) => { const names = [ 'HTMLCanvasElement', 'HTMLImageElement', 'ImageBitmap', 'OffscreenCanvas', ]; const real = names.map((name) => globalThis[name]); for (const name of names) globalThis[name] ??= class {}; t.after(() => names.forEach((name, i) => (globalThis[name] = real[i]))); const { createPackPresentations } = await import('../../scenes/dataPacks/presentation.js'); const scene = fakeScene(); const viewer = { scene, container: {} }; const targets = new Map(); const presentations = createPackPresentations(viewer, targets, { store: { publish() {} }, overlayHost: { setEntries() {}, clearSource() {} }, }); const bytes = new TextEncoder().encode( JSON.stringify({ type: 'FeatureCollection', features: [ { type: 'Feature', id: 'point', geometry: { type: 'Point', coordinates: [2, 1, 10] }, }, { type: 'Feature', id: 'line', geometry: { type: 'LineString', coordinates: [ [2, 1, 5], [2.1, 1.1, 5], ], }, }, { type: 'Feature', id: 'area', geometry: { type: 'Polygon', coordinates: [ [ [2, 1, 50], [2.1, 1, 50], [2.1, 1.1, 50], [2, 1, 50], ], ], }, }, ], }), ); const pack = { id: 'data', attribution: { text: 'Example', license: 'CC0' } }; const geometry = await presentations.geojson({ pack, asset: { bytes, mimeType: 'application/geo+json' }, signal: new AbortController().signal, }); const [points, lines, shapes] = scene.added; assert.ok(points instanceof Cesium.PointPrimitiveCollection); assert.equal(points.get(0).pixelSize, 12); assert.equal(points.get(0).outlineWidth, 2); assert.ok(Cesium.Color.CYAN.equals(points.get(0).color)); // The collection, beside where its static batch goes. assert.ok(lines.get(0) instanceof Cesium.PolylineCollection); assert.equal(lines.get(0).get(0).width, 4); const fill = shapes.get(0); assert.ok(fill.geometryInstances.geometry instanceof Cesium.PolygonGeometry); assert.equal(fill.appearance.translucent, true); assert.equal(fill.appearance.flat, true); // A click names the feature's set and item, which the targets hold. const line = lines.get(0).get(0); const hit = drawHitOf({ primitive: line, id: line.id }); assert.deepEqual(targets.get(JSON.stringify(['data', 'line'])), { set: hit.set, id: hit.id, }); const media = await presentations.media({ pack: { ...pack, id: 'sound', placement: { anchorId: 'here' } }, anchors: [{ id: 'here', lon: 2, lat: 1, alt: 5 }], asset: { bytes: new Uint8Array(4), mimeType: 'audio/mpeg' }, signal: new AbortController().signal, }); const marker = scene.added[3].get(0); assert.equal(marker.pixelSize, 16); assert.ok(Cesium.Color.fromCssColorString('#ffff00').equals(marker.color)); geometry.dispose(); media.dispose(); assert.equal(scene.added.length, 0); assert.equal(targets.size, 0); }); test('flow lines run their dashes toward the end, draped or not, on the frame clock', () => withImageClasses(() => { const scene = fakeScene(); let asked = 0; const request = scene.requestRender; scene.requestRender = function () { asked += 1; return request.call(this); }; const { draw, frame } = drawOver(scene); const set = draw.lines({ id: 'flowing' }); const style = { kind: 'flow', color: [0.2, 0.8, 1, 0.95], repeat: 64, duty: 0.46, speed: 0.55, }; const positions = [ { lon: 0, lat: 0 }, { lon: 1, lat: 1 }, ]; set.set([ { id: 'route', positions, widthPx: 9, mode: 'draped', style }, { id: 'edge', positions, widthPx: 2, mode: 'draped', clampTo: 'terrain', style: { kind: 'solid', color: '#fff' }, }, { id: 'air', positions, widthPx: 3, mode: '3d', style }, ]); const host = scene.added[0]; const polylines = host.get(0); const solid = host.get(1); const draped = host.get(2); assert.ok(solid.appearance instanceof Cesium.PolylineColorAppearance); assert.equal(solid.classificationType, Cesium.ClassificationType.TERRAIN); assert.ok(draped instanceof Cesium.GroundPolylinePrimitive); assert.ok(draped.appearance instanceof Cesium.PolylineMaterialAppearance); assert.equal(draped.classificationType, Cesium.ClassificationType.BOTH); assert.equal(draped.geometryInstances[0].geometry.width, 9); assert.equal(draped.geometryInstances[0].id.id, 'route'); const material = draped.appearance.material; assert.equal(material.type, 'DrawFlowLine'); assert.equal(material.uniforms.repeat, 64); assert.equal(material.uniforms.duty, 0.46); assert.equal(material.uniforms.speed, 0.55); assert.ok( Cesium.Color.equals( material.uniforms.color, new Cesium.Color(0.2, 0.8, 1, 0.95), ), ); const air = polylines.get(0); assert.equal(air.material.type, 'DrawFlowLine', 'an undraped one too'); // The dashes run on the frame clock. material.uniforms.time = -1; air.material.uniforms.time = -1; asked = 0; frame(); assert.ok(material.uniforms.time >= 0, 'draped: its clock moved'); assert.ok( material.uniforms.time < 1 / 0.55, 'wrapped to one cell, so the uniform keeps its digits', ); assert.ok(air.material.uniforms.time >= 0, 'undraped: its clock moved'); assert.ok(asked > 0, 'and it asks for the frames that follow'); // A shown flow line hides in place once its ground is ready. Object.defineProperty(draped, 'ready', { value: true }); const shown = new Uint8Array([1]); draped.getGeometryInstanceAttributes = () => ({ show: shown }); set.upsert([ { id: 'route', positions, widthPx: 9, mode: 'draped', style, show: false, }, ]); assert.equal(scene.added[0], host, 'changed in place'); assert.deepEqual([...shown], [0]); // Hidden or gone, a set asks for no more frames. set.upsert([ { id: 'air', positions, widthPx: 3, mode: '3d', style, show: false }, ]); asked = 0; frame(); assert.equal(asked, 0, 'its flow lines hidden, it asks for no frames'); set.upsert([{ id: 'air', positions, widthPx: 3, mode: '3d', style }]); asked = 0; frame(); assert.ok(asked > 0, 'shown again, it does'); set.show = false; asked = 0; frame(); assert.equal(asked, 0, 'a hidden set asks for no frames'); set.show = true; set.clear(); asked = 0; frame(); assert.equal(asked, 0, 'an emptied set asks for none'); // Patterns drape too, on a ground polyline of their own. set.set([ { id: 'pattern', positions, widthPx: 1, mode: 'draped', style: { kind: 'pattern', image: 'a.png', repeat: 2 }, }, ]); const grounds = []; const walk = (p) => { if (p instanceof Cesium.PrimitiveCollection) for (let i = 0; i < p.length; i++) walk(p.get(i)); else if (p instanceof Cesium.GroundPolylinePrimitive) grounds.push(p); }; walk(scene.added.at(-1)); assert.equal(grounds.length, 1); assert.equal(grounds[0].appearance.material.type, 'Image'); set.dispose(); })); test('a line with a depth-fail colour draws it behind the surface, and moves in place', () => withImageClasses(() => { const { scene, draw } = drawOver(); const set = draw.lines({ id: 'head' }); const head = (height, extra = {}) => ({ id: 'gev-trail:head', positions: [ Cesium.Cartesian3.fromDegrees(0, 0, 100), Cesium.Cartesian3.fromDegrees(0.01, 0.01, height), ], widthPx: 2.5, mode: 'geodesic', style: { kind: 'solid', color: [1, 0, 1, 0.9] }, depthFail: { kind: 'solid', color: [1, 0, 1, 0.45] }, meta: height, ...extra, }); set.set([ head(200), { id: 'plain', positions: [ Cesium.Cartesian3.fromDegrees(0, 0, 0), Cesium.Cartesian3.fromDegrees(1, 0, 0), ], widthPx: 1, mode: '3d', style: { kind: 'solid', color: '#fff' }, depthFail: null, }, ]); const host = scene.added[0]; assert.ok(host instanceof Cesium.PrimitiveCollection); const polylines = host.get(0); const deep = host.get(1); assert.equal(polylines.length, 1, 'null: drawn as the plain lines are'); assert.equal(polylines.get(0).id.id, 'plain'); const first = deep.get(0); assert.ok(first instanceof Cesium.Primitive); assert.equal(first.geometryInstances.geometry._width, 2.5); const id = first.geometryInstances.id; assert.equal(id.id, 'gev-trail:head'); assert.equal(id.set, 'head'); assert.ok( Cesium.Color.equals( first.depthFailAppearance.material.uniforms.color, new Cesium.Color(1, 0, 1, 0.45), ), ); assert.ok( Cesium.Color.equals( first.appearance.material.uniforms.color, new Cesium.Color(1, 0, 1, 0.9), ), ); // Moved: built anew where it now runs, under the same pick id. set.upsert([head(300)]); assert.equal(scene.added[0], host, 'the set is not rebuilt'); assert.equal(deep.length, 1, 'the old one goes'); const moved = deep.get(0); assert.notEqual(moved, first); assert.equal(moved.geometryInstances.id, id, 'the same pick id'); assert.equal(id.meta, 300, 'with its new meta'); const end = moved.geometryInstances.geometry._positions.at(-1); assert.ok( Cesium.Cartesian3.equalsEpsilon( end, Cesium.Cartesian3.fromDegrees(0.01, 0.01, 300), 1e-6, ), ); // Positions that make no line draw nothing, until they do again. set.upsert([head(300, { positions: [] })]); assert.equal(deep.length, 0); set.upsert([head(400, { show: false })]); assert.equal(deep.length, 1); assert.equal(deep.get(0).show, false, 'hidden as asked'); // A new colour is a new look: rebuilt. set.upsert([ head(400, { depthFail: { kind: 'solid', color: [1, 1, 1, 1] } }), ]); assert.notEqual(scene.added[0], host); set.dispose(); assert.equal(scene.added.length, 0); })); test('a dashed depth-fail style dashes the parts behind the surface, in its colour', () => withImageClasses(() => { const { scene, draw } = drawOver(); const set = draw.lines({ id: 'band' }); const band = (extra = {}) => ({ id: 'band', positions: [ Cesium.Cartesian3.fromDegrees(0, 0, 100), Cesium.Cartesian3.fromDegrees(0.01, 0.01, 100), ], 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, }); set.set([band()]); const host = scene.added[0]; const deep = host.get(1).get(0); const hidden = deep.depthFailAppearance.material; assert.equal(hidden.type, 'PolylineDash'); assert.ok( Cesium.Color.equals( hidden.uniforms.color, new Cesium.Color(0, 1, 1, 0.35), ), ); assert.equal(hidden.uniforms.dashLength, 16); assert.equal(hidden.uniforms.dashPattern, 255, 'the default pattern'); // A move keeps the dash; its fields in another order are the same look. set.upsert([ band({ depthFail: { length: 16, color: [0, 1, 1, 0.35], kind: 'dash' } }), ]); assert.equal(scene.added[0], host, 'not rebuilt'); assert.equal( host.get(1).get(0).depthFailAppearance.material.type, 'PolylineDash', ); const patternedBand = (fields) => band({ depthFail: { kind: 'dash', color: [0, 1, 1, 0.35], ...fields } }); set.upsert([patternedBand({ pattern16: 0xf0f0, length: 8 })]); const patterned = scene.added[0].get(1).get(0).depthFailAppearance.material; assert.equal(patterned.uniforms.dashPattern, 0xf0f0); assert.equal(patterned.uniforms.dashLength, 8); const again = scene.added[0]; set.upsert([patternedBand({ length: 8, pattern16: 0xf0f0 })]); assert.equal(scene.added[0], again, 'the same dash in another order'); // Solid behind the surface: a new look. set.upsert([ band({ depthFail: { kind: 'solid', color: [0, 1, 1, 0.35] } }), ]); assert.notEqual(scene.added[0], host, 'rebuilt'); const solid = scene.added[0].get(1).get(0).depthFailAppearance.material; assert.equal(solid.type, 'Color'); set.dispose(); })); test('a draped flow line still drawing while its rebuilds build keeps flowing', () => withImageClasses(() => { const { scene, draw, frame } = drawOver(); const set = draw.lines({ id: 'reflowing' }); const route = (lon) => ({ id: 'route', positions: [ { lon: 0, lat: 0 }, { lon, lat: 1 }, ], widthPx: 9, mode: 'draped', style: { kind: 'flow', color: '#39d0ff', repeat: 64, duty: 0.46, speed: 1, }, }); set.set([route(1)]); const host = scene.added[0]; const first = host.get(1); Object.defineProperty(first, 'ready', { value: true }); frame(); // Two rebuilds while the first still draws in their place. set.set([route(2)]); set.set([route(3)]); assert.ok(scene.added.includes(host), 'the first still draws'); const material = first.appearance.material; material.uniforms.time = -1; frame(); assert.ok(material.uniforms.time >= 0, 'and keeps its clock'); set.dispose(); })); test('the directions layer draws its markers, flowing route and maneuver dots on a viewer of its own', async (t) => { // Materials check their uniforms against the DOM's image classes. const names = [ 'HTMLCanvasElement', 'HTMLImageElement', 'ImageBitmap', 'OffscreenCanvas', ]; const real = names.map((name) => globalThis[name]); for (const name of names) globalThis[name] ??= class {}; t.after(() => names.forEach((name, i) => (globalThis[name] = real[i]))); { const { createDirectionsLayer } = await import('../../layers/directions/index.js'); const { fakeInput } = await import('../../input/testDoubles.mjs'); const ownership = await import('../../data/inputOwnership.js'); const scene = fakeScene(); scene.pickResult = undefined; scene.pick = () => scene.pickResult; scene.drillPick = () => []; const viewer = { scene, isDestroyed: () => false }; const clicks = fakeInput(viewer); const noop = () => {}; const sprites = []; const overlays = []; const layer = createDirectionsLayer({ source: { getRoute: async () => ({ ok: true, distanceM: 2000, durationS: 200, geometry: [ [-97.74, 30.26], [-97.73, 30.27], [-97.72, 30.27], ], steps: [ { instruction: 'Depart', lat: 30.26, lon: -97.74 }, { instruction: 'Turn left', lat: 30.27, lon: -97.73 }, { instruction: 'Arrive', lat: 30.27, lon: -97.72 }, ], }), }, services: { render: { governorRequestRender: noop, holdContinuousRender: noop, releaseContinuousRender: noop, }, sprites: { spriteDrawOrder: (layerId) => { sprites.push(layerId); return spriteDrawOrder(layerId); }, }, picking: { registerPickOwner: noop, unregisterPickOwner: noop }, overlays: { setOverlayEntries: (source, entries) => overlays.push([source, entries]), setOverlaySourceVisible: noop, clearOverlaySource: noop, }, ground: { GROUND_FLOOR_LIFT_M: 2, cachedGroundFloor: () => 150, warmGroundFloor: noop, resolveGroundFloorCells: async () => {}, }, input: ownership, camera: {}, }, }); ownership.resetPointerOwnership(); // Let go even when an assertion fails, so nothing leaks into later tests. t.after(() => { layer.destroy(viewer); clicks.destroy(); ownership.resetPointerOwnership(); }); layer.init(viewer); layer.enable(viewer); layer.placeEndpoint('a', { lat: 30.26, lon: -97.74 }); layer.placeEndpoint('b', { lat: 30.27, lon: -97.72 }); const hostOf = (suffix) => scene.added.find((host) => host.drawSetId?.endsWith(suffix)); // The route is asked for, then drawn. const deadline = Date.now() + 5000; while (!(hostOf(':route')?.length > 0) && Date.now() < deadline) await new Promise((resolve) => setTimeout(resolve, 5)); // A and B: dots on the ground, drawn over everything. const markers = hostOf(':markers'); assert.ok(markers instanceof Cesium.BillboardCollection); assert.equal(markers.length, 2); const a = markers.get(0); assert.equal(a.id.id, 'directions:marker:A'); assert.equal(a.disableDepthTestDistance, Infinity); assert.equal(a.heightReference, Cesium.HeightReference.CLAMP_TO_GROUND); // The route: the annotation's flowing dashes, draped on everything. const route = hostOf(':route'); const ground = route.get(1); assert.ok(ground instanceof Cesium.GroundPolylinePrimitive); assert.equal(ground.classificationType, Cesium.ClassificationType.BOTH); assert.equal(ground.geometryInstances[0].geometry.width, 9); assert.equal(ground.geometryInstances[0].id.id, 'directions:route'); const flow = ground.appearance.material.uniforms; assert.deepEqual( [flow.repeat, flow.duty, flow.speed, flow.color.alpha], [64, 0.46, 0.55, 0.95], ); // One maneuver dot, at its junction on the ground floor, at the // directions' draw order. const steps = hostOf(':steps'); assert.ok(steps instanceof Cesium.PointPrimitiveCollection); assert.equal(steps.blendOption, Cesium.BlendOption.TRANSLUCENT); assert.deepEqual(sprites, ['directions']); assert.equal(steps.length, 1); const dot = steps.get(0); assert.equal(dot.id.id, 'directions:step:1'); assert.equal(dot.show, true); assert.equal(dot.pixelSize, 8); assert.equal(dot.disableDepthTestDistance, Infinity); const at = Cesium.Cartographic.fromCartesian(dot.position); assert.ok(Math.abs(at.height - 152) < 1e-6, 'floor plus its lift'); // A click on the dot opens its card and enlarges it, in place. scene.pickResult = { primitive: dot, id: dot.id }; clicks.click({ x: 10, y: 10 }); assert.equal(steps.get(0), dot, 'the same point'); assert.equal(dot.pixelSize, 13); const card = overlays.findLast(([source]) => source === 'directions-step'); assert.equal(card[1][0].id, 'directions-step-1'); // Empty map closes it. scene.pickResult = undefined; clicks.click({ x: 10, y: 10 }); assert.equal(dot.pixelSize, 8); layer.disable(viewer); assert.equal(hostOf(':markers').length, 0, 'markers cleared'); layer.destroy(viewer); clicks.destroy(); ownership.resetPointerOwnership(); assert.equal(scene.added.length, 0, 'every set let go'); } }); test('the local ADS-B layer draws its aircraft, 978 MHz rings and trail head on a viewer of its own', async (t) => { // Materials check their uniforms against the DOM's image classes. const names = [ 'HTMLCanvasElement', 'HTMLImageElement', 'ImageBitmap', 'OffscreenCanvas', ]; const real = names.map((name) => globalThis[name]); for (const name of names) globalThis[name] ??= class {}; t.after(() => names.forEach((name, i) => (globalThis[name] = real[i]))); await import('./frame.js'); const { createLocalAdsbLayer } = await import('../../layers/localAdsb/index.js'); const { fakeInput } = await import('../../input/testDoubles.mjs'); const { toLonLatH } = await import('../../geo/ellipsoid.js'); const scene = fakeScene(); // What a frame port over the scene listens to. scene.preUpdate = new Cesium.Event(); scene.forceRender = () => {}; scene.pick = () => undefined; scene.drillPick = () => []; const viewer = { scene, clock: new Cesium.Clock(), isDestroyed: () => false, }; const clicks = fakeInput(viewer); const noop = () => {}; const clock = { now: 100_000 }; const aircraft = (icao, band, lat) => ({ icao, callsign: icao.toUpperCase(), lat, lon: 0, altitudeFt: 10_000, groundSpeedKt: 180, trackDeg: 0, verticalRateFpm: 0, lastPositionAt: clock.now, lastMessageAt: clock.now, messageCount: 3, band, source: 'feed', }); const records = [ aircraft('abc123', '1090', 0), aircraft('a1b2c3', '978', 0.1), ]; const layer = createLocalAdsbLayer({ receiver: { getState: () => ({ aircraft: [] }), subscribe: () => noop, setMode: async () => true, }, feeds: { getState: () => ({ configured: true, feeds: [], records }), subscribe: () => noop, start: noop, stop: noop, }, services: { render: { governorRequestRender: noop }, context: { registerEntityContext: noop, selectEntityContext: (carrier) => ({ id: 'local-adsb:abc123', carrier, }), getSelectedEntityContext: () => ({ id: 'local-adsb:abc123' }), clearSelectedEntityContextForLayer: noop, removeEntityContextsForLayer: noop, }, picking: { registerPickOwner: noop, unregisterPickOwner: noop }, trails: await import('../../data/trailRenderer.js'), }, now: () => clock.now, }); layer.init(viewer); await layer.enable(); await layer.update(); assert.equal(layer.selectAircraft('abc123'), true); const hostOf = (suffix) => scene.added.find((host) => host.drawSetId?.endsWith(suffix)); // Aircraft: magenta icons drawn over depth out to 2,000 km. const markers = hostOf(':markers'); assert.ok(markers instanceof Cesium.BillboardCollection); assert.equal(markers.length, 2); const icon = markers.get(0); assert.equal(icon.id.id, 'local-adsb:abc123'); assert.equal(icon.disableDepthTestDistance, Infinity); assert.equal(icon.distanceDisplayCondition.far, 2_000_000); assert.ok(icon.scaleByDistance instanceof Cesium.NearFarScalar); assert.deepEqual( [icon.scaleByDistance.near, icon.scaleByDistance.nearValue], [1000, 3], ); assert.ok(icon.color.equals(Cesium.Color.fromCssColorString('#ff4fd8'))); // The UAT-only aircraft's ring: an outline, shown as far as it is. const rings = hostOf(':rings'); assert.ok(rings instanceof Cesium.PointPrimitiveCollection); assert.equal(rings.length, 1); const ring = rings.get(0); assert.equal(ring.id.id, 'local-adsb:a1b2c3'); assert.equal(ring.outlineWidth, 1.5); assert.equal(ring.color.alpha, 0); assert.equal(ring.distanceDisplayCondition.far, 2_000_000); // Selected at its fix, the trail and its head have no length yet. const trailHost = () => scene.added.find((host) => host.drawSetId?.startsWith('trail:')); assert.equal(trailHost(), undefined); // A frame flies them on, in place. const before = toLonLatH(icon.position).lat; clock.now += 1_000; scene.preRender.raiseEvent(scene, Cesium.JulianDate.now()); assert.equal(markers.get(0), icon, 'the same billboard'); assert.ok(toLonLatH(icon.position).lat > before); assert.equal(rings.get(0).id.id, 'local-adsb:a1b2c3'); // The head now runs from the fix to the aircraft, dimmed, not hidden, // behind the surface. const deep = trailHost().get(1); assert.equal(deep.length, 1); const line = deep.get(0); assert.ok(line instanceof Cesium.Primitive); assert.match(line.geometryInstances.id.id, /^gev-trail:\d+:head$/); const fail = line.depthFailAppearance.material.uniforms.color; assert.ok( fail.equals(Cesium.Color.fromCssColorString('#ff4fd8').withAlpha(0.45)), ); await layer.disable(); layer.destroy(); clicks.destroy(); assert.equal(hostOf(':markers'), undefined, 'every set let go'); }); /** Run `fn` as if Cesium's approximate terrain heights had loaded. */ function withTerrainHeights(fn) { const heights = Cesium.ApproximateTerrainHeights; const was = heights._terrainHeights; heights._terrainHeights ??= {}; try { return fn(); } finally { heights._terrainHeights = was; } } test('draped glow and dash lines drape with their materials, each on a ground primitive of its own', () => withImageClasses(() => { const { scene, draw } = drawOver(); const set = draw.lines({ id: 'styled', clampTo: 'terrain' }); const positions = [ { lon: 0, lat: 0 }, { lon: 1, lat: 1 }, ]; set.set([ { id: 'core', positions, widthPx: 5, mode: 'draped', style: { kind: 'glow', color: [1, 0.5, 0, 0.9], power: 0.24, taper: 0.7, }, }, { id: 'halo', positions, widthPx: 18, mode: 'draped', clampTo: 'both', style: { kind: 'dash', color: '#d8954e', length: 18 }, }, ]); const host = scene.added[0]; const [glow, dash] = [host.get(1), host.get(2)]; for (const ground of [glow, dash]) { assert.ok(ground instanceof Cesium.GroundPolylinePrimitive); assert.ok(ground.appearance instanceof Cesium.PolylineMaterialAppearance); assert.equal(ground.show, false, 'hidden while it builds'); } assert.equal(glow.classificationType, Cesium.ClassificationType.TERRAIN); assert.equal(dash.classificationType, Cesium.ClassificationType.BOTH); assert.equal(glow.geometryInstances[0].id.id, 'core'); assert.equal(dash.geometryInstances[0].geometry.width, 18); const glowMaterial = glow.appearance.material; assert.equal(glowMaterial.type, 'PolylineGlow'); assert.equal(glowMaterial.uniforms.glowPower, 0.24); assert.equal(glowMaterial.uniforms.taperPower, 0.7); assert.ok(glowMaterial.uniforms.color instanceof Cesium.Color); const dashMaterial = dash.appearance.material; assert.equal(dashMaterial.type, 'PolylineDash'); assert.equal(dashMaterial.uniforms.dashLength, 18); assert.ok( Cesium.Color.equals( dashMaterial.uniforms.gapColor, Cesium.Color.TRANSPARENT, ), ); set.dispose(); })); test('a draped arrow drapes its arrow material on a ground polyline of its own, recoloured in place', () => withImageClasses(() => { const { scene, draw } = drawOver(); const set = draw.lines({ id: 'arrows' }); const arrow = (color) => ({ id: 'to', positions: [ { lon: 0, lat: 0 }, { lon: 0.01, lat: 0.01 }, ], widthPx: 16, mode: 'draped', style: { kind: 'arrow', color }, }); set.set([arrow([0.5, 0.9, 1, 0.95])]); const host = scene.added[0]; const ground = host.get(1); assert.ok(ground instanceof Cesium.GroundPolylinePrimitive); assert.equal(ground.classificationType, Cesium.ClassificationType.BOTH); assert.equal(ground.geometryInstances[0].geometry.width, 16); const material = ground.appearance.material; assert.equal(material.type, 'PolylineArrow'); assert.ok( Cesium.Color.equals( material.uniforms.color, new Cesium.Color(0.5, 0.9, 1, 0.95), ), ); // Faded, it takes its new colour on the material it has. set.upsert([arrow([0.5, 0.9, 1, 0.4])]); assert.equal(scene.added[0], host, 'not rebuilt'); assert.equal(ground.appearance.material, material); assert.equal(material.uniforms.color.alpha, 0.4); set.dispose(); })); test('a split line draws ahead and behind its split with a rim, the split moving in place', () => withImageClasses(() => { const { scene, draw } = drawOver(); const set = draw.lines({ id: 'route', clampTo: 'tiles' }); const positions = new Float64Array([ ...Object.values(Cesium.Cartesian3.fromDegrees(0, 0)), ...Object.values(Cesium.Cartesian3.fromDegrees(0.01, 0.01)), ]); const route = (at, reverse) => ({ id: 'route', positions, widthPx: 5, mode: 'draped', style: { kind: 'split', color: [0.2, 0.6, 1, 1], behind: [0.2, 0.6, 1, 0.3], at, reverse, rim: { shade: 0.22, widthFraction: 0.28 }, }, }); set.set([route(-1)]); const host = scene.added[0]; const line = [...Array(host.length).keys()] .map((i) => host.get(i)) .find((p) => p.appearance?.material?.type === 'DrawSplitLine'); assert.ok(line, 'drawn by the split material'); const uniforms = line.appearance.material.uniforms; assert.deepEqual( [uniforms.splitAt, uniforms.direction, uniforms.rimShade], [-1, 1, 0.22], ); assert.equal(uniforms.rimFraction, 0.28); assert.equal(uniforms.behind.alpha, 0.3); assert.ok(line.appearance.material.isTranslucent()); set.upsert([route(0.4)]); assert.ok(!line.isDestroyed(), 'the same ground primitive'); assert.deepEqual([uniforms.splitAt, uniforms.direction], [0.4, 1]); set.upsert([route(0.6, true)]); assert.deepEqual([uniforms.splitAt, uniforms.direction], [0.6, -1]); set.upsert([route(Number.NaN, true)]); assert.deepEqual( [uniforms.splitAt, uniforms.direction], [-1, 1], 'no split: all ahead', ); assert.throws( () => set.upsert([{ ...route(0.5), mode: 'geodesic' }]), TypeError, 'a split line is draped', ); })); test('a draped line drawn by its own material changes colour in place; a batched one rebuilds', () => withImageClasses(() => { const { scene, draw } = drawOver(); const set = draw.lines({ id: 'pulsing', clampTo: 'tiles' }); const positions = new Float64Array([ ...Object.values(Cesium.Cartesian3.fromDegrees(0, 0)), ...Object.values(Cesium.Cartesian3.fromDegrees(0.01, 0.01)), ]); const jam = (alpha) => ({ id: 'jam', positions, widthPx: 9, mode: 'draped', style: { kind: 'glow', color: [0.9, 0.3, 0.3, alpha], power: 0.25 }, }); const slow = (alpha) => ({ id: 'slow', positions, widthPx: 4, mode: 'draped', style: { kind: 'solid', color: [0.9, 0.7, 0.2, alpha] }, }); set.set([jam(0.55), slow(0.2)]); const host = scene.added[0]; const glow = [...Array(host.length).keys()] .map((i) => host.get(i)) .find((p) => p.appearance?.material?.type === 'PolylineGlow'); assert.equal( glow.classificationType, Cesium.ClassificationType.CESIUM_3D_TILE, ); set.upsert([jam(0.7)]); assert.equal(scene.added[0], host, 'the same host'); assert.equal(glow.appearance.material.uniforms.color.alpha, 0.7); assert.ok(!glow.isDestroyed(), 'the same ground primitive'); // Sent twice in one upsert, the last colour is the one it keeps. set.upsert([jam(0.3), jam(0.7)]); assert.equal(glow.appearance.material.uniforms.color.alpha, 0.7); set.upsert([jam(0.3)]); assert.equal(glow.appearance.material.uniforms.color.alpha, 0.3); // A style object the caller changes and sends again is read anew. const again = jam(0.4); set.upsert([again]); again.style.color[3] = 0.6; set.upsert([again]); assert.equal(glow.appearance.material.uniforms.color.alpha, 0.6); // Another width is another line: rebuilt. set.upsert([{ ...jam(0.7), widthPx: 10 }]); assert.notEqual(scene.added[0], host, 'a new width rebuilds'); const rebuilt = scene.added[0]; set.upsert([slow(0.4)]); assert.notEqual(scene.added[0], rebuilt, 'a batched colour rebuilds'); set.dispose(); })); test('draped glow lines that look alike share one ground primitive and recolour together in place', () => withImageClasses(() => { const { scene, draw } = drawOver(); const set = draw.lines({ id: 'glows', clampTo: 'tiles' }); const at = (lon) => Cesium.Cartesian3.fromDegrees(lon, 0); const glow = (id, lon, alpha, extra = {}) => ({ id, positions: [at(lon), at(lon + 0.01)], widthPx: 9, mode: 'draped', style: { kind: 'glow', color: [0.9, 0.3, 0.3, alpha], power: 0.25 }, ...extra, }); const grounds = () => { const host = scene.added[0]; return [...Array(host.length).keys()] .map((i) => host.get(i)) .filter((p) => p instanceof Cesium.GroundPolylinePrimitive); }; set.set([glow('a', 0, 0.5), glow('b', 1, 0.5), glow('c', 2, 0.5)]); const host = scene.added[0]; const [batch] = grounds(); assert.equal(grounds().length, 1, 'one primitive for the three'); assert.equal(batch.geometryInstances.length, 3); const uniforms = batch.appearance.material.uniforms; // All recoloured alike: in place, on the one material. set.upsert([glow('a', 0, 0.7), glow('b', 1, 0.7), glow('c', 2, 0.7)]); assert.equal(scene.added[0], host, 'in place'); assert.ok(!batch.isDestroyed()); assert.equal(uniforms.color.alpha, 0.7); // A line moved off the batch, sent twice in one upsert, takes its last // colour on a material of its own; its peers keep theirs. const moved = (alpha) => glow('a', 0, alpha, { positions: [at(0.5), at(0.51)] }); withTerrainHeights(() => set.upsert([moved(0.2), moved(0.7)])); assert.equal(scene.added[0], host, 'moved in place'); assert.equal(uniforms.color.alpha, 0.7, 'the peers keep their colour'); // Two recoloured and one not: it would change colour with them, so // the set is rebuilt. set.upsert([glow('a', 0, 0.2), glow('b', 1, 0.2)]); assert.notEqual(scene.added[0], host, 'rebuilt'); assert.equal(grounds().length, 2, 'one for each look'); const rebuilt = scene.added[0]; // Another width is another look: drawn apart. set.upsert([glow('c', 2, 0.7, { widthPx: 4 })]); assert.notEqual(scene.added[0], rebuilt); assert.equal(grounds().length, 2); set.dispose(); })); test('the traffic layer drapes its heat-lines on the tiles and pulses the jam ones in place', async () => { const { createRendering } = await import('../../layers/traffic/rendering.js'); const policy = await import('../../layers/traffic/policy.js'); await withImageClasses(() => { const { scene, draw } = drawOver(); const at = (lon) => Cesium.Cartesian3.fromDegrees(lon, 30.26); const road = (level, lon) => ({ flow: { level }, segmentDist: [100], waypoints: [at(lon), at(lon + 0.001)], }); const state = { _viewer: {}, _liveMode: true, _presetDots: 'off', _heatJam: [], _heatLineCount: 0, _heatSet: draw.lines({ id: 'traffic:1:heat', clampTo: 'tiles' }), }; const rendering = createRendering({ state, services: {}, parts: { style: { heatlineOn: () => true }, animation: { syncRenderDemand() {} }, }, source: {}, }); rendering.rebuildHeatLines([ road(0.2, -97.74), road(0.25, -97.735), road(0.6, -97.73), ]); const host = scene.added[0]; const grounds = [...Array(host.length).keys()] .map((i) => host.get(i)) .filter((p) => p instanceof Cesium.GroundPolylinePrimitive); assert.equal(grounds.length, 2, 'the jam lines glowing, the slow ones'); assert.ok( grounds.every( (p) => p.classificationType === Cesium.ClassificationType.CESIUM_3D_TILE, ), 'draped on the tiles alone', ); const glow = grounds.find( (p) => p.appearance?.material?.type === 'PolylineGlow', ); assert.ok(glow, 'the jam line glows'); assert.equal( glow.appearance.material.uniforms.color.alpha, policy.HEAT_JAM_BASE_ALPHA, ); rendering.pulseHeatLines(260 * (Math.PI / 2)); assert.equal(scene.added[0], host, 'pulsed where it is'); assert.ok(!glow.isDestroyed()); assert.ok( Math.abs( glow.appearance.material.uniforms.color.alpha - (policy.HEAT_JAM_BASE_ALPHA + policy.HEAT_JAM_PULSE_ALPHA), ) < 1e-6, ); rendering.removeHeatLines(); assert.equal(state._heatSet.size(), 0); state._heatSet.dispose(); assert.equal(scene.added.length, 0); }); }); test('where the scene cannot drape, draped lines draw over the surface and hide past the horizon', () => withImageClasses(() => { const scene = fakeScene(); scene.frameState.context = { depthTexture: false }; const { draw, frame } = drawOver(scene); assert.equal(draw.clampState(), 'overlay'); const set = draw.lines({ id: 'heat', clampTo: 'tiles' }); const at = (lon) => Cesium.Cartesian3.fromDegrees(lon, 0, 0); const firstPositions = [at(0), at(0.01)]; set.set([ { id: 'jam', positions: firstPositions, widthPx: 4, mode: 'draped', style: { kind: 'glow', color: [1, 0, 0, 0.8], power: 0.25 }, }, ]); const host = scene.added[0]; const all = []; const walk = (p) => { all.push(p); if (typeof p?.get === 'function' && Number.isFinite(p.length)) for (let i = 0; i < p.length; i++) walk(p.get(i)); }; walk(host); assert.ok( !all.some((p) => p instanceof Cesium.GroundPolylinePrimitive), 'no ground polyline', ); const line = all.find( (p) => p instanceof Cesium.Primitive && p.depthFailAppearance, ); assert.ok(line, 'drawn where the surface hides it too'); const failColor = line.depthFailAppearance.material.uniforms.color; assert.ok(Math.abs(failColor.red - 1) < 1e-6 && failColor.green === 0); // The eye over the line's side of the Earth: shown. scene.camera.positionWC = new Cesium.Cartesian3(2e7, 0, 0); frame(); assert.equal(line.show, true); // The eye over the far side: past the horizon, hidden. scene.camera.positionWC = new Cesium.Cartesian3(-2e7, 0, 0); frame(); assert.equal(line.show, false); // A recolour where it runs (a pulse) takes the colour in place, and the // line stays hidden past the horizon: nothing is built anew. const hostBefore = scene.added[0]; set.upsert([ { id: 'jam', positions: firstPositions, widthPx: 4, mode: 'draped', style: { kind: 'glow', color: [1, 0, 0, 0.4], power: 0.25 }, }, ]); frame(); assert.equal(line.show, false, 'still past the horizon'); const after = []; const walkAfter = (p) => { after.push(p); if (typeof p?.get === 'function' && Number.isFinite(p.length)) for (let i = 0; i < p.length; i++) walkAfter(p.get(i)); }; walkAfter(scene.added[0]); assert.equal(scene.added[0], hostBefore, 'the set is not rebuilt'); assert.ok(after.includes(line), 'the same line draws'); assert.ok( Math.abs(line.appearance.material.uniforms.color.alpha - 0.4) < 1e-6, ); assert.ok( Math.abs(line.depthFailAppearance.material.uniforms.color.alpha - 0.4) < 1e-6, ); // In 2D there is no horizon: it shows as asked. scene.mode = Cesium.SceneMode.SCENE2D; frame(); assert.equal(line.show, true, 'shown in 2D'); scene.mode = Cesium.SceneMode.SCENE3D; scene.camera.positionWC = new Cesium.Cartesian3(2e7, 0, 0); frame(); // Moved, it alone is built anew, still over the surface and culled. set.upsert([ { id: 'jam', positions: [at(0), at(0.02)], widthPx: 4, mode: 'draped', style: { kind: 'glow', color: [1, 0, 0, 0.4], power: 0.25 }, }, ]); assert.equal(scene.added[0], hostBefore, 'patched, not rebuilt'); const moved = []; const walkMoved = (p) => { moved.push(p); if (typeof p?.get === 'function' && Number.isFinite(p.length)) for (let i = 0; i < p.length; i++) walkMoved(p.get(i)); }; walkMoved(scene.added[0]); const rebuilt = moved.find( (p) => p instanceof Cesium.Primitive && p.depthFailAppearance, ); assert.ok(rebuilt && rebuilt !== line, 'built anew where it moved'); assert.ok(!moved.includes(line), 'the old line is gone'); scene.camera.positionWC = new Cesium.Cartesian3(-2e7, 0, 0); frame(); assert.equal(rebuilt.show, false); set.dispose(); assert.equal(scene.added.length, 0); })); test('where the scene cannot drape, an overlay line is culled by its whole arc, and patched by what its positions hold', () => withImageClasses(() => { const scene = fakeScene(); scene.frameState.context = { depthTexture: false }; const { draw, frame } = drawOver(scene); const set = draw.lines({ id: 'arc', clampTo: 'tiles' }); const find = () => { const all = []; const walk = (p) => { all.push(p); if (typeof p?.get === 'function' && Number.isFinite(p.length)) for (let i = 0; i < p.length; i++) walk(p.get(i)); }; walk(scene.added[0]); return all.find( (p) => p instanceof Cesium.Primitive && p.depthFailAppearance, ); }; // Its ends are past the horizon, but the arc runs under the eye. const a = Cesium.Cartesian3.fromDegrees(-80, 0, 0); const b = Cesium.Cartesian3.fromDegrees(80, 0, 0); const positions = new Float64Array([a.x, a.y, a.z, b.x, b.y, b.z]); const item = (style) => ({ id: 'arc', positions, widthPx: 2, mode: 'draped', style: { kind: 'solid', color: style }, }); set.set([item([1, 0, 0, 1])]); scene.camera.positionWC = new Cesium.Cartesian3(2e7, 0, 0); frame(); const line = find(); assert.equal(line.show, true, 'shown: its middle is in view'); // The same buffer, changed in place: built anew where it now runs. const c = Cesium.Cartesian3.fromDegrees(10, 0, 0); positions.set([c.x, c.y, c.z], 3); set.upsert([item([1, 0, 0, 1])]); const moved = find(); assert.notEqual(moved, line, 'built anew'); // Moved past the horizon, then upserted as an ordinary line in view: // it is no longer culled by where the overlay was. const far = new Float64Array(6); const f1 = Cesium.Cartesian3.fromDegrees(179, 0, 0); const f2 = Cesium.Cartesian3.fromDegrees(179.5, 0, 0); far.set([f1.x, f1.y, f1.z, f2.x, f2.y, f2.z]); set.upsert([{ ...item([1, 0, 0, 1]), positions: far }]); frame(); assert.equal(find().show, false, 'past the horizon'); set.upsert([ { id: 'arc', positions: [ Cesium.Cartesian3.fromDegrees(0, 0, 0), Cesium.Cartesian3.fromDegrees(0.5, 0, 0), ], widthPx: 2, mode: '3d', depthFail: { kind: 'solid', color: [1, 0, 0, 1] }, style: { kind: 'solid', color: [1, 0, 0, 1] }, }, ]); const plain = find(); frame(); assert.equal(plain.show, true, 'not culled by the overlay it was'); set.dispose(); })); test('where the scene cannot drape, a segmented draped line runs over its shown segments only', () => withImageClasses(() => { const scene = fakeScene(); scene.frameState.context = { depthTexture: false }; const { draw } = drawOver(scene); const set = draw.lines({ id: 'trail', clampTo: 'tiles' }); const at = (lon) => Cesium.Cartesian3.fromDegrees(lon, 0, 0); const positions = [at(0), at(0.01), at(0.02), at(0.03)]; const red = [1, 0, 0, 1]; const find = () => { const all = []; const walk = (p) => { all.push(p); if (typeof p?.get === 'function' && Number.isFinite(p.length)) for (let i = 0; i < p.length; i++) walk(p.get(i)); }; walk(scene.added[0]); return all.find( (p) => p instanceof Cesium.Primitive && p.depthFailAppearance, ); }; set.set([ { id: 'trail', positions, widthPx: 2, mode: 'draped', style: { kind: 'solid', color: red }, segmentColors: [red, red, red], segmentShow: [true, true, false], }, ]); const line = find(); assert.ok(line, 'drawn over the surface'); const drawn = line.geometryInstances.geometry._positions; assert.equal(drawn.length, 3, 'up to its last shown segment'); assert.ok(Cesium.Cartesian3.equals(drawn[2], positions[2])); set.set([ { id: 'trail', positions, widthPx: 2, mode: 'draped', style: { kind: 'solid', color: red }, segmentColors: [red, red, red], segmentShow: [false, false, false], }, ]); assert.equal(find()?.show ?? false, false, 'hidden with none shown'); set.dispose(); })); test('revealFraction draws a line up to that fraction of its length, and changes in place', () => withImageClasses(() => { const { scene, draw } = drawOver(); const set = draw.lines({ id: 'revealed' }); const at = (lon) => Cesium.Cartesian3.fromDegrees(lon, 0, 0); // Segments a quarter and three quarters of the length. const air = (revealFraction, extra = {}) => ({ id: 'air', positions: [at(0), at(1), at(4)], widthPx: 3, mode: '3d', style: { kind: 'solid', color: '#fff' }, revealFraction, ...extra, }); const ground = (revealFraction) => ({ id: 'ground', positions: [ { lon: 0, lat: 0 }, { lon: 1, lat: 1 }, ], widthPx: 2, mode: 'draped', style: { kind: 'solid', color: '#20e7f2' }, revealFraction, }); set.set([air(0.5), ground(0.25)]); const host = scene.added[0]; const polyline = host.get(0).get(0); assert.equal(polyline.material.type, 'DrawRevealLine_solid'); // Half the length is a third of the way along the second segment, // which a polyline's texture spans from 1/2 to 1. assert.ok( Math.abs(polyline.material.uniforms.reveal - (1 + 1 / 3) / 2) < 1e-3, ); assert.ok( Cesium.Color.equals( polyline.material.materials.revealed.uniforms.color, Cesium.Color.WHITE, ), ); // A revealed draped line draws alone, its texture along its length. const draped = host.get(1); assert.ok(draped instanceof Cesium.GroundPolylinePrimitive); assert.equal(draped.appearance.material.type, 'DrawRevealLine_solid'); assert.equal(draped.appearance.material.uniforms.reveal, 0.25); // Revealed further, in place. Object.defineProperty(draped, 'ready', { value: true }); draped.getGeometryInstanceAttributes = () => ({ show: new Uint8Array([1]), }); set.upsert([air(0.25), ground(0.75)]); assert.equal(scene.added[0], host, 'not rebuilt'); assert.ok(Math.abs(polyline.material.uniforms.reveal - 0.5) < 1e-3); assert.equal(draped.appearance.material.uniforms.reveal, 0.75); // Nothing at 0, everything at 1. set.upsert([air(0), ground(1)]); assert.ok(polyline.material.uniforms.reveal < 0); assert.ok(draped.appearance.material.uniforms.reveal > 1); // Dropping the reveal draws the line whole: a new look, rebuilt. set.upsert([air(undefined)]); assert.notEqual(scene.added.at(-1), host); set.dispose(); })); test('revealFraction reveals flow and depth-fail lines too, their clocks still run', () => withImageClasses(() => { const { scene, draw, frame } = drawOver(); const set = draw.lines({ id: 'revealed-styles' }); const flow = { kind: 'flow', color: '#39d0ff', repeat: 8, duty: 0.5, speed: 1, }; set.set([ { id: 'route', positions: [ { lon: 0, lat: 0 }, { lon: 1, lat: 1 }, ], widthPx: 9, mode: 'draped', style: flow, revealFraction: 0.5, }, { id: 'head', positions: [ Cesium.Cartesian3.fromDegrees(0, 0, 100), Cesium.Cartesian3.fromDegrees(0, 0, 300), ], widthPx: 2, mode: '3d', style: { kind: 'solid', color: '#f0f' }, depthFail: { kind: 'solid', color: [1, 0, 1, 0.45] }, revealFraction: 0.5, }, ]); const host = scene.added[0]; const route = host.get(1).appearance.material; assert.equal(route.type, 'DrawRevealLine_flow'); const clock = route.materials.revealed; assert.equal(clock.type, 'DrawFlowLine'); clock.uniforms.time = -1; frame(); assert.ok(clock.uniforms.time >= 0, 'the revealed flow keeps its clock'); const head = host.get(0).get(1).get(0); assert.equal(head.appearance.material.uniforms.reveal, 0.5); assert.equal(head.depthFailAppearance.material.uniforms.reveal, 0.5); assert.ok( Cesium.Color.equals( head.depthFailAppearance.material.materials.revealed.uniforms.color, new Cesium.Color(1, 0, 1, 0.45), ), ); set.dispose(); })); test('a draped line that moves is drawn where it now is in the same frame, once terrain heights are loaded', () => withImageClasses(() => withTerrainHeights(() => { const { scene, draw, frame } = drawOver(); const set = draw.lines({ id: 'growing' }); const flow = { kind: 'flow', color: '#39d0ff', repeat: 8, duty: 0.5, speed: 1, }; const line = (id, lon, extra = {}) => ({ id, positions: [ { lon: 0, lat: 0 }, { lon, lat: 1 }, ], widthPx: 3, mode: 'draped', style: { kind: 'solid', color: '#20e7f2' }, ...extra, }); set.set([line('a', 1), line('b', 1), line('f', 1, { style: flow })]); const host = scene.added[0]; const batch = host.get(1); const own = host.get(2); const shows = new Map(); const attributesOf = (primitive) => { primitive.getGeometryInstanceAttributes = (id) => { const key = `${primitive.geometryInstances.length}:${id.id}`; if (!shows.has(key)) shows.set(key, { show: new Uint8Array([1]) }); return shows.get(key); }; }; attributesOf(batch); // Moved while its batch still builds: drawn alone, built at once. set.upsert([line('a', 2, { meta: 'moved' })]); assert.equal(scene.added[0], host, 'the set is not rebuilt'); const solo = host.get(host.length - 1); assert.ok(solo instanceof Cesium.GroundPolylinePrimitive); assert.equal(solo.asynchronous, false, 'built in the frame it is drawn'); assert.equal(solo.geometryInstances[0].id.id, 'a'); assert.equal(solo.geometryInstances[0].id.meta, 'moved'); assert.notEqual(solo.show, false, 'shown at once'); const end = solo.geometryInstances[0].geometry._positions.at(-1); assert.ok( Cesium.Cartesian3.equalsEpsilon( end, Cesium.Cartesian3.fromDegrees(2, 1), 1e-6, ), ); // Its place in the batch is hidden once the batch is ready. Object.defineProperty(batch, 'ready', { value: true }); Object.defineProperty(own, 'ready', { value: true }); frame(); assert.deepEqual([...shows.get('2:a').show], [0], 'hidden in the batch'); assert.equal(batch.show, true, 'the batch still draws the rest'); // Moved again: the one built for it is replaced. set.upsert([line('a', 3)]); const again = host.get(host.length - 1); assert.notEqual(again, solo); assert.ok(solo.isDestroyed(), 'the old one goes'); // A flow line moved keeps flowing on its new material. set.upsert([line('f', 2, { style: flow })]); assert.ok(own.isDestroyed(), 'its own primitive replaced'); const moved = host.get(host.length - 1); const clock = moved.appearance.material; assert.equal(clock.type, 'DrawFlowLine'); clock.uniforms.time = -1; frame(); assert.ok(clock.uniforms.time >= 0); // Positions that make no line draw nothing, until they do. const count = host.length; set.upsert([line('a', 0, { positions: [{ lon: 0, lat: 0 }] })]); assert.equal(host.length, count - 1); set.upsert([line('a', 4)]); assert.equal(host.length, count); // A show change on a ready one is in place. const shown = host.get(host.length - 1); Object.defineProperty(shown, 'ready', { value: true }); attributesOf(shown); set.upsert([line('a', 4, { show: false })]); assert.equal(host.get(host.length - 1), shown); assert.deepEqual([...shows.get('1:a').show], [0]); set.dispose(); assert.equal(scene.added.length, 0); }), )); test('a draped line that moves before terrain heights load is rebuilt, as before', () => withImageClasses(() => { const heights = Cesium.ApproximateTerrainHeights; const was = heights._terrainHeights; heights._terrainHeights = undefined; try { const { scene, draw } = drawOver(); const set = draw.lines({ id: 'early' }); const line = (lon) => ({ id: 'a', positions: [ { lon: 0, lat: 0 }, { lon, lat: 1 }, ], widthPx: 3, mode: 'draped', style: { kind: 'solid', color: '#fff' }, }); set.set([line(1)]); const host = scene.added[0]; set.upsert([line(2)]); assert.notEqual(scene.added.at(-1), host, 'rebuilt'); set.dispose(); } finally { heights._terrainHeights = was; } })); test('a clamped point that moves follows the ground where it now is, on the dot it has', () => { const { scene, draw } = drawOver(); const set = draw.points({ id: 'surge' }); const front = (lon, extra = {}) => ({ id: 'front', pos: { lon, lat: 28 }, height: 'clampGround', pixelSize: 11, color: '#e8b47c', outlineColor: [0, 0, 0, 0.85], outlineWidth: 3, ...extra, }); set.set([front(85)]); const host = scene.added[0]; const dot = host.get(0); scene.clamped.length = 0; set.upsert([front(85.01, { meta: 'next', show: false })]); assert.equal(scene.added[0], host, 'not rebuilt'); assert.equal(host.get(0), dot, 'the same dot'); assert.ok( Cesium.Cartesian3.equalsEpsilon( dot.position, Cesium.Cartesian3.fromDegrees(85.01, 28), 1e-6, ), ); assert.equal(dot.heightReference, Cesium.HeightReference.CLAMP_TO_GROUND); assert.ok(scene.clamped.length > 0, 'clamped again where it now is'); assert.equal(dot.id.meta, 'next'); assert.equal(dot.show, false); // A new look is a new dot image: rebuilt. set.upsert([front(85.01, { pixelSize: 14 })]); assert.notEqual(scene.added[0], host); // So is clamping it no more. const clamped = scene.added[0]; set.upsert([front(85.01, { pixelSize: 14, height: undefined })]); assert.notEqual(scene.added[0], clamped); set.dispose(); }); test('a revealed polyline maps its length onto its texture as Cesium draws it', () => { const p = (x) => new Cesium.Cartesian3(x, 0, 0); // Its texture runs evenly over its vertices, neighbours at one place one. assert.equal(revealUniform(0.5, [p(0), p(0), p(1), p(2)]), 0.5); assert.ok(Math.abs(revealUniform(0.25, [p(0), p(1), p(4)]) - 0.5) < 1e-12); assert.equal(revealUniform(0.4), 0.4, 'a ground line: its length'); assert.equal(revealUniform(0, [p(0), p(1)]), -1); assert.equal(revealUniform(1, [p(0), p(1)]), 2); }); test('a set of draped flow lines only asks for the frames they flow on', () => withImageClasses(() => { const scene = fakeScene(); let asked = 0; const request = scene.requestRender; scene.requestRender = function () { asked += 1; return request.call(this); }; const { draw, frame } = drawOver(scene); const set = draw.lines({ id: 'draped-flow' }); set.set([ { id: 'route', positions: [ { lon: 0, lat: 0 }, { lon: 1, lat: 1 }, ], widthPx: 9, mode: 'draped', style: { kind: 'flow', color: '#39d0ff', repeat: 8, duty: 0.5, speed: 1, }, }, ]); asked = 0; frame(); assert.ok(asked > 0, 'it flows on in the frames that follow'); set.dispose(); })); test('a draped line moved while its set rebuilds is no longer drawn where it was', () => withImageClasses(() => withTerrainHeights(() => { const { scene, draw, frame } = drawOver(); const set = draw.lines({ id: 'rebuilding' }); const line = (id, lon) => ({ id, positions: [ { lon: 0, lat: 0 }, { lon, lat: 1 }, ], widthPx: 3, mode: 'draped', style: { kind: 'solid', color: '#fff' }, }); set.set([line('a', 1), line('b', 1)]); const first = scene.added[0]; const ground = first.get(1); Object.defineProperty(ground, 'ready', { value: true }); const shows = new Map(); ground.getGeometryInstanceAttributes = (id) => { if (!shows.has(id.id)) shows.set(id.id, { show: new Uint8Array([1]) }); return shows.get(id.id); }; frame(); // Rebuilt: the first host draws on until the new one is ready. set.set([line('a', 1), line('b', 1), line('c', 1)]); assert.ok(scene.added.includes(first), 'the first still draws'); set.upsert([line('a', 2)]); assert.deepEqual([...shows.get('a').show], [0], 'hidden where it was'); assert.equal(shows.get('b'), undefined, 'the rest still draw there'); set.dispose(); }), )); test('a contact trail draws its history and moving head as depth-fail geodesic lines on a viewer of its own', async () => { const { CHUNK_POINTS, createTrail } = await import('../../data/trailRenderer.js'); withImageClasses(() => { const scene = fakeScene(); const viewer = { scene, isDestroyed: () => false }; const trail = createTrail(viewer, { color: '#00d4ff', width: 2.5 }); // 400 fixes about a kilometre apart: a degree of arc per step keeps // each leg one straight piece. const fixes = Array.from({ length: 400 }, (_, i) => Cesium.Cartesian3.fromDegrees(-97 + i * 0.01, 30, 10000), ); trail.setPositions(fixes); // The lines drawn now: a set that loses a line is built again. const lines = () => { const deep = scene.added[0].get(1); return Array.from({ length: deep.length }, (_, i) => deep.get(i)); }; const positions = (line) => line.geometryInstances.geometry._positions; // The history is cut into lines of CHUNK_POINTS fixes that share their // boundary points, so the trail has no seam; the newest line grows. const cut = lines(); const body = cut[0]; assert.ok(body instanceof Cesium.Primitive); assert.equal(cut.length, 4, 'three full lines and the newest'); for (const line of cut.slice(0, 3)) assert.equal(positions(line).length, CHUNK_POINTS); for (let i = 1; i < cut.length; i++) assert.ok( Cesium.Cartesian3.equalsEpsilon( positions(cut[i - 1]).at(-1), positions(cut[i])[0], 0, 1e-6, ), 'adjacent lines share their boundary point', ); assert.ok( Cesium.Color.equals( body.depthFailAppearance.material.uniforms.color, Cesium.Color.fromCssColorString('#00d4ff').withAlpha(0.4), ), ); // A long leg follows the globe instead of chording through it. trail.setPositions([ Cesium.Cartesian3.fromDegrees(-150, 20, 10000), Cesium.Cartesian3.fromDegrees(-120, 30, 10000), ]); assert.equal(lines().length, 1); assert.equal(positions(lines()[0]).length, 65, 'a lone leg in 64 steps'); // A long leg among short ones still takes a step a degree: the newest // line's 18 short legs take their share of 64 steps, its long one more. trail.setPositions([ ...fixes, Cesium.Cartesian3.fromDegrees(-63, 30, 10000), ]); const newest = positions(lines().at(-1)).length - 1; const longSteps = newest - 18 * Math.ceil(64 / 19); assert.ok(longSteps > 25 && longSteps < 40, `${longSteps}`); // A history of one line, so the head is the set's second. trail.setPositions(fixes.slice(0, 10)); // The head moves every frame alone, under one pick id. const head = (lon) => [ Cesium.Cartesian3.fromDegrees(-120, 30, 10000), Cesium.Cartesian3.fromDegrees(lon, 30, 10000), ]; // Its first head is a new line: the set is built again, once. trail.setHead(head(-119.99)); const host2 = scene.added[0]; const deep2 = host2.get(1); assert.equal(deep2.length, 2); const first = deep2.get(1); const id = first.geometryInstances.id; assert.match(id.id, /^gev-trail:\d+:head$/); const history = deep2.get(0); trail.setHead(head(-119.98)); assert.equal(scene.added[0], host2, 'the set is not rebuilt'); assert.equal(deep2.get(0), history, 'the history is not rebuilt'); assert.notEqual(deep2.get(1), first); assert.equal(deep2.get(1).geometryInstances.id, id); // No head for a while: hidden in place. trail.setHead(null); assert.equal(scene.added[0], host2); assert.equal(deep2.get(0), history); assert.equal(deep2.get(1).show, false); trail.setVisible(false); assert.equal(host2.show, false); trail.destroy(); assert.equal(scene.added.length, 0); }); }); test('a transit trail moves its head, across subdivisions too, and fades its body in place, frame to frame', async () => { const { createContactTrailRenderer } = await import('../../data/contactTrailRenderer.js'); withImageClasses(() => withTerrainHeights(() => { const scene = fakeScene(); const viewer = { scene, isDestroyed: () => false }; const frame = () => { scene.preRender.raiseEvent(); scene.postRender.raiseEvent(); }; const hostOf = (suffix) => scene.added.find((host) => host.drawSetId?.endsWith(suffix)); // Every ground primitive built so far reads as ready, with attributes. const settle = () => { for (const host of scene.added) for (let i = 0; i < host.length; i++) { const part = host.get(i); if (!(part instanceof Cesium.GroundPolylinePrimitive)) continue; if (part.ready) continue; Object.defineProperty(part, 'ready', { value: true }); const attributes = new Map(); part.getGeometryInstanceAttributes = (id) => { if (!attributes.has(id)) attributes.set(id, { color: new Uint8Array(4), show: new Uint8Array([1]), }); return attributes.get(id); }; } frame(); }; const at = (lon) => Cesium.Cartesian3.fromDegrees(lon, 0, 0); const renderer = createContactTrailRenderer(viewer); renderer.replaceHistory({ revision: 1, segments: [ { fromSeq: 0, toSeq: 1, fromT: 0, toT: 10000, positions: [at(0), at(0.0002)], }, { fromSeq: 0, toSeq: 1, fromT: 10000, toT: 20000, positions: [at(0.0002), at(0.0004)], }, ], }); settle(); const sample = (t) => ({ displayT: t, fromSeq: 0, toSeq: 1, fraction: t / 20000, }); renderer.setDisplaySample(sample(5000), at(0.0001)); settle(); const body = hostOf(':body'), head = hostOf(':head'); assert.ok(body && head); // Into the next subdivision: the head moves there in the same frame. const before = scene.added.length; renderer.setDisplaySample(sample(12000), at(0.00024)); assert.equal(scene.added.length, before, 'not built anew'); assert.equal(hostOf(':head'), head); settle(); const lanes = Array.from({ length: head.length }, (_, i) => head.get(i), ).filter((part) => part instanceof Cesium.GroundPolylinePrimitive); assert.equal(lanes.length, 1, 'one line, its dark edge in the same pass'); const added = scene.added.length; // A second and a half of frames within the subdivision. for (let t = 12016; t < 13500; t += 16) renderer.setDisplaySample( sample(t), at(0.0002 + (0.0002 * (t - 10000)) / 10000), ); frame(); assert.equal(scene.added.length, added, 'nothing built anew'); assert.equal(hostOf(':body'), body); assert.equal(hostOf(':head'), head); for (const lane of lanes) { const reveal = lane.appearance.material.uniforms.reveal; assert.ok(Math.abs(reveal - 0.348) < 0.01, `revealed to ${reveal}`); } assert.equal(renderer.diagnostics().rebuilds, 1); assert.equal(renderer.diagnostics().headRebuilds, 2, 'one a subdivision'); renderer.destroy(); }), ); }); test('a segmented line, then plain and moved while its set rebuilds, is hidden segment by segment where it was', () => withImageClasses(() => withTerrainHeights(() => { const { scene, draw, frame } = drawOver(); const set = draw.lines({ id: 'resegmented' }); const line = (id, lon, extra = {}) => ({ id, positions: [ { lon: 0, lat: 0 }, { lon: lon / 2, lat: 0.5 }, { lon, lat: 1 }, ], widthPx: 3, mode: 'draped', style: { kind: 'solid', color: '#fff' }, ...extra, }); set.set([line('a', 1, { segmentShow: [true, true] })]); const first = scene.added[0]; const ground = first.get(1); Object.defineProperty(ground, 'ready', { value: true }); const shows = new Map(); ground.getGeometryInstanceAttributes = (id) => { if (!shows.has(id)) shows.set(id, { show: new Uint8Array([1]) }); return shows.get(id); }; frame(); // Plain now: a new look, rebuilt; then moved before that is ready. set.upsert([line('a', 1)]); assert.ok(scene.added.includes(first), 'the first still draws'); assert.doesNotThrow(() => set.upsert([line('a', 2)])); assert.equal(shows.size, 2, 'both segments'); for (const { show } of shows.values()) assert.deepEqual([...show], [0]); set.dispose(); }), )); /** `Cesium.Model.fromGltfAsync` replaced by loads a test resolves. */ function fakeModelLoads() { const loads = []; const real = Cesium.Model.fromGltfAsync; Cesium.Model.fromGltfAsync = (options) => new Promise((resolve, reject) => { const model = { ...options, modelMatrix: Cesium.Matrix4.clone(options.modelMatrix), ready: false, color: undefined, colorBlendMode: Cesium.ColorBlendMode.HIGHLIGHT, colorBlendAmount: 0.5, environmentMapManager: { enabled: options.environmentMapOptions?.enabled ?? true, }, readyEvent: new Cesium.Event(), errorEvent: new Cesium.Event(), boundingSphere: { radius: 10 * (options.scale ?? 1) }, destroyed: false, destroy() { this.destroyed = true; }, isDestroyed() { return this.destroyed; }, update() {}, }; loads.push({ options, model, resolve: () => resolve(model), reject, ready() { model.ready = true; model.readyEvent.raiseEvent(model); }, }); }); return { loads, restore: () => (Cesium.Model.fromGltfAsync = real) }; } const settle = () => new Promise((resolve) => setTimeout(resolve, 0)); test('models re-pose and restyle in place; only a new url loads again', async () => { const { loads, restore } = fakeModelLoads(); try { const scene = fakeScene(); const part = createCesiumDraw({ scene, report: (error) => assert.fail(error), }); const set = part.port.models({ id: 'planes' }); const ready = []; set.on('ready', (id) => ready.push(id)); const plane = (extra = {}) => ({ id: 'p', pos: { lon: 10, lat: 20, height: 100 }, url: 'a.glb', orientation: { heading: 0, pitch: 0, roll: 0 }, environmentMap: false, meta: { n: 1 }, ...extra, }); set.set([plane()]); assert.equal(loads.length, 1); assert.equal(loads[0].options.environmentMapOptions.enabled, false); assert.equal(loads[0].options.show, false, 'hidden until ready'); const host = scene.added[0]; assert.equal(host.loading, 1, 'loading'); loads[0].resolve(); await settle(); const model = loads[0].model; assert.equal(model.show, false, 'loaded, not yet ready'); loads[0].ready(); assert.deepEqual(ready, ['p'], 'ready once loaded and posed'); assert.equal(model.show, true); assert.equal(host.loading, 0); assert.deepEqual(model.id, { set: 'planes', id: 'p', meta: { n: 1 }, }); // Moved, turned and restyled: the same model, no load, no ready. set.upsert([ plane({ pos: { lon: 11, lat: 21, height: 200 }, orientation: { heading: 1, pitch: 0.1, roll: 0.2 }, tint: [1, 0, 0, 0.5], colorBlend: { mode: 'mix', amount: 0.8 }, shading: 'unlit', environmentMap: true, scale: 2, minPixelSize: 32, maxScale: 50, meta: { n: 2 }, }), ]); assert.equal(loads.length, 1, 'not loaded again'); assert.deepEqual(ready, ['p'], 'no second ready'); const expected = Cesium.Transforms.headingPitchRollToFixedFrame( Cesium.Cartesian3.fromDegrees(11, 21, 200), new Cesium.HeadingPitchRoll(1, 0.1, 0.2), ); assert.ok(Cesium.Matrix4.equalsEpsilon(model.modelMatrix, expected, 1e-6)); assert.deepEqual( [model.color.red, model.color.green, model.color.blue, model.color.alpha], [1, 0, 0, 0.5], ); assert.equal(model.colorBlendMode, Cesium.ColorBlendMode.MIX); assert.equal(model.colorBlendAmount, 0.8); assert.ok(model.customShader instanceof Cesium.CustomShader, 'unlit'); assert.equal(model.environmentMapManager.enabled, true); assert.equal(model.scale, 2); assert.equal(model.minimumPixelSize, 32); assert.equal(model.maximumScale, 50); assert.deepEqual(model.id.meta, { n: 2 }, 'the pick id follows'); set.upsert([ plane({ shading: 'pbr', tint: '#00f', colorBlend: { mode: 'replace' } }), ]); assert.equal(model.customShader, undefined, 'lit again'); assert.equal(model.colorBlendMode, Cesium.ColorBlendMode.REPLACE); set.upsert([plane({ colorBlend: { mode: 'replace' } })]); assert.equal( model.colorBlendMode, Cesium.ColorBlendMode.HIGHLIGHT, 'no tint to blend in: its own colour', ); assert.equal(model.color.alpha, 1); set.upsert([plane({ show: false })]); assert.equal(model.show, false, 'hidden in place'); // A new url loads; the old model draws until the new one is ready. set.upsert([plane({ url: 'b.glb' })]); assert.equal(loads.length, 2); loads[1].resolve(); await settle(); assert.ok(host.contains(model), 'the old model still draws'); loads[1].ready(); assert.equal(host.contains(model), false, 'swapped once ready'); assert.ok(host.contains(loads[1].model)); assert.deepEqual(ready, ['p', 'p']); // Away and back before the other loads: no second load of the first. set.upsert([plane({ url: 'c.glb' })]); set.upsert([plane({ url: 'b.glb', pos: { lon: 12, lat: 22 } })]); assert.equal(loads.length, 3); assert.equal(host.loading, 0, 'the load in between is let go'); const moved = Cesium.Matrix4.getTranslation( loads[1].model.modelMatrix, new Cesium.Cartesian3(), ); assert.ok( Cesium.Cartesian3.distance(moved, Cesium.Cartesian3.fromDegrees(12, 22)) < 1e-3, 'the drawn model kept moving', ); set.remove(['p']); assert.equal(host.length, 0, 'removed'); assert.equal(set.size(), 0); set.dispose(); } finally { restore(); } }); test('a model load superseded or failed settles once', async () => { const { loads, restore } = fakeModelLoads(); try { const scene = fakeScene(); const part = createCesiumDraw({ scene, report: (error) => assert.fail(error), }); const set = part.port.models({ id: 'm' }); const item = (url) => ({ id: 'a', pos: { lon: 0, lat: 0 }, url, orientation: { heading: 0, pitch: 0, roll: 0 }, }); set.set([item('a.glb')]); const host = scene.added[0]; set.upsert([item('b.glb')]); assert.equal(host.loading, 1, 'the first is superseded'); loads[0].resolve(); await settle(); assert.equal(loads[0].model.destroyed, true, 'a stale load is let go'); loads[1].reject(new Error('no such model')); await settle(); assert.equal(host.loading, 0); assert.equal(host.failed, 1, 'kept for whenSettled'); // A model that fails as it loads is let go once its update is done. set.upsert([item('c.glb')]); assert.equal(host.failed, 0, 'a new url clears the failure'); loads[2].resolve(); await settle(); const bad = loads[2].model; bad.errorEvent.raiseEvent(new Error('bad texture')); assert.ok(host.contains(bad), 'not destroyed inside its own update'); assert.equal(host.failed, 1); await settle(); assert.equal(host.contains(bad), false, 'then let go'); set.clear(); assert.equal(host.failed, 0, 'gone with its item'); set.dispose(); } finally { restore(); } }); test('a failed model load fires loadFailed once, after the frame, with why', async () => { const { loads, restore } = fakeModelLoads(); try { const scene = fakeScene(); const part = createCesiumDraw({ scene, report: (error) => assert.fail(error), }); const set = part.port.models({ id: 'm' }); const failed = []; set.on('loadFailed', (id, message) => failed.push([id, message])); const item = (id, url) => ({ id, pos: { lon: 0, lat: 0 }, url, orientation: { heading: 0, pitch: 0, roll: 0 }, }); // A load that rejects (the glTF did not fetch). set.set([item('a', 'a.glb'), item('b', 'b.glb')]); loads[0].reject(new Error('404 for a.glb')); await settle(); assert.deepEqual(failed, [['a', '404 for a.glb']]); // One that fails in its update: told after that update, not inside it. loads[1].resolve(); await settle(); loads[1].model.errorEvent.raiseEvent(new Error('bad texture')); assert.equal(failed.length, 1, 'not inside the model update'); await settle(); assert.deepEqual(failed[1], ['b', 'bad texture']); // A listener may change the set: removing and adding again loads at once. set.remove(['a']); set.upsert([item('a', 'a.glb')]); assert.equal(loads.length, 3, 'added again, loaded again'); // A load superseded before it fails is not told. set.upsert([item('a', 'c.glb')]); loads[2].reject(new Error('late')); await settle(); assert.equal(failed.length, 2, 'a superseded load does not fire'); // Nor one whose item went before the failure was told. loads[3].reject('plain reason'); set.remove(['a']); await settle(); assert.equal(failed.length, 2, 'an item gone does not fire'); set.upsert([item('d', 'd.glb')]); loads[4].reject({}); await settle(); assert.deepEqual(failed[2], ['d', 'the model did not load']); set.dispose(); } finally { restore(); } }); test('a failed model load is tried again on a later update, after a wait', async () => { const { loads, restore } = fakeModelLoads(); const realNow = Date.now; let now = 1_000_000; Date.now = () => now; try { const scene = fakeScene(); const part = createCesiumDraw({ scene, report: (error) => assert.fail(error), }); const set = part.port.models({ id: 'm' }); const item = { id: 'a', pos: { lon: 0, lat: 0 }, url: 'a.glb', orientation: { heading: 0, pitch: 0, roll: 0 }, }; set.upsert([item]); const host = scene.added[0]; loads[0].reject(new Error('network')); await settle(); assert.equal(host.failed, 1); now += MODEL_RETRY_MS - 1; set.upsert([{ ...item }]); assert.equal(loads.length, 1, 'not before the wait'); now += 1; set.upsert([{ ...item }]); assert.equal(loads.length, 2, 'the same url again'); assert.equal(host.failed, 0, 'loading again, not failed'); assert.equal(host.loading, 1); const ready = []; set.on('ready', (id) => ready.push(id)); loads[1].resolve(); await settle(); loads[1].ready(); assert.deepEqual(ready, ['a']); set.upsert([{ ...item }]); assert.equal(loads.length, 2, 'a loaded model is not loaded again'); set.dispose(); } finally { Date.now = realNow; restore(); } }); test('a model past its pixel cap is scaled down each frame; fades and culls too', async () => { const { loads, restore } = fakeModelLoads(); try { const scene = fakeScene(); scene.drawingBufferWidth = 1000; scene.drawingBufferHeight = 500; let metresPerPixel = 0.1; scene.camera.getPixelSize = () => metresPerPixel; const part = createCesiumDraw({ scene, report: (error) => assert.fail(error), }); const set = part.port.models({ id: 'm', horizonCull: true }); const eye = scene.camera.positionWC; const at = Cesium.Cartesian3.fromDegrees(0, 0, 1000); const distance = Cesium.Cartesian3.distance(eye, at); set.set([ { id: 'a', pos: { lon: 0, lat: 0, height: 1000 }, url: 'a.glb', orientation: { heading: 0, pitch: 0, roll: 0 }, scale: 4, maxPixelSize: 100, fadeByDistance: { near: distance - 10, nearValue: 1, far: distance + 10, farValue: 0, }, }, ]); loads[0].resolve(); await settle(); const model = loads[0].model; loads[0].ready(); part.beforeRender(); // Radius 10 m at scale 1: 100 px at 0.1 m/px is 10 m across, scale 0.5. assert.ok(Math.abs(model.scale - 0.5) < 1e-9, `capped: ${model.scale}`); assert.ok(Math.abs(model.color.alpha - 0.5) < 1e-6, 'faded halfway'); metresPerPixel = 10; part.beforeRender(); assert.equal(model.scale, 4, 'under the cap: its own scale'); assert.equal(model.show, true); // Behind the earth from an eye on the far side. scene.camera.positionWC = new Cesium.Cartesian3(-2e7, 0, 0); part.beforeRender(); assert.equal(model.show, false, 'culled past the horizon'); set.dispose(); } finally { restore(); } }); test('a raised polygon outlines its holes as well as its outer ring', () => withImageClasses(() => { const { scene, draw } = drawOver(); const set = draw.shapes({ id: 'raised-holes' }); const at = ([lon, lat]) => ({ lon, lat, height: 100 }); const outer = [ [0, 0], [0.01, 0], [0.01, 0.01], [0, 0.01], ].map(at); // A triangle, so its line has a length of its own. const hole = [ [0.004, 0.004], [0.006, 0.004], [0.005, 0.006], ].map(at); set.set([ { id: 'p', geometry: { kind: 'polygon', rings: [outer, hole], perPositionHeight: true, }, fill: [0, 0.5, 1, 0.3], outline: [0, 0.5, 1, 1], outlineWidth: 1, height: 'absolute', }, ]); const host = scene.added[0]; let outlines = null; for (let i = 0; i < host.length; i++) if (host.get(i) instanceof Cesium.PolylineCollection) outlines = host.get(i); assert.ok(outlines, 'outlined'); assert.equal(outlines.length, 2, 'the outer ring and the hole'); for (const [i, ring] of [outer, hole].entries()) { const line = outlines.get(i); assert.equal(line.positions.length, ring.length + 1, 'closed'); const start = Cesium.Cartesian3.fromDegrees( ring[0].lon, ring[0].lat, ring[0].height, ); assert.ok( Cesium.Cartesian3.equalsEpsilon(line.positions[0], start, 0, 1e-6), `line ${i} runs along its ring`, ); assert.equal(line.width, 1); assert.ok( Cesium.Color.equals( line.material.uniforms.color, new Cesium.Color(0, 0.5, 1, 1), ), ); assert.equal(line.id.set, 'raised-holes'); assert.equal(line.id.id, 'p', 'picks as the polygon'); } set.dispose(); })); test('quads draw a posed plane and its outline, changed in place', () => withImageClasses(() => { const scene = fakeScene(); const part = createCesiumDraw({ scene, report: (error) => assert.fail(error), }); const set = part.port.quads({ id: 'monitors' }); const canvas = { width: 4, height: 4 }; const other = { width: 4, height: 4 }; const center = { x: 6378137, y: 10, z: 20 }; const quad = (extra = {}) => ({ id: 'q', center, orientation: { x: 0, y: 0, z: 0, w: 1 }, size: [40, 20], source: { canvas }, alpha: 0.95, outline: { color: [0.4, 0.9, 1, 0.55], widthPx: 1 }, meta: { camera: 'c1' }, ...extra, }); set.set([quad()]); const host = scene.added[0]; assert.equal(host.length, 2, 'the plane and its outline'); const [fill, outline] = [host.get(0), host.get(1)]; assert.ok(fill.geometryInstances.geometry instanceof Cesium.PlaneGeometry); assert.ok( outline.geometryInstances.geometry instanceof Cesium.PlaneOutlineGeometry, ); assert.deepEqual(fill.geometryInstances.id, { set: 'monitors', id: 'q', meta: { camera: 'c1' }, }); // Scaled to its size about its centre, as a plane entity's matrix is. const scale = Cesium.Matrix4.getScale( fill.modelMatrix, new Cesium.Cartesian3(), ); assert.deepEqual([scale.x, scale.y, scale.z], [40, 20, 1]); const at = Cesium.Matrix4.getTranslation( fill.modelMatrix, new Cesium.Cartesian3(), ); assert.deepEqual({ x: at.x, y: at.y, z: at.z }, center); const material = fill.appearance.material; assert.equal(material.type, 'Image'); assert.equal(material.uniforms.image, canvas); assert.ok(Math.abs(material.uniforms.color.alpha - 0.95) < 1e-12); assert.equal(fill.appearance.translucent, true); // Moved, resized, faded, hidden and given another canvas: the same plane. set.upsert([ quad({ center: { x: 6378137, y: 30, z: 20 }, size: [80, 45], alpha: 0.5, show: false, source: { canvas: other }, meta: { camera: 'c2' }, }), ]); assert.equal(host.get(0), fill, 'changed where it is'); Cesium.Matrix4.getScale(fill.modelMatrix, scale); assert.deepEqual([scale.x, scale.y], [80, 45]); assert.ok( Cesium.Matrix4.equals(fill.modelMatrix, outline.modelMatrix), 'the outline follows', ); assert.equal(fill.show, false); assert.equal(outline.show, false); assert.equal(material.uniforms.image, other, 'the new canvas is read'); assert.ok(Math.abs(material.uniforms.color.alpha - 0.5) < 1e-12); assert.deepEqual(fill.geometryInstances.id.meta, { camera: 'c2' }); // Unpickable, or without an outline: built anew. set.upsert([quad({ outline: null, pickable: false })]); assert.equal(host.length, 1, 'no outline'); assert.notEqual(host.get(0), fill); assert.equal(host.get(0).allowPicking, false); set.remove(['q']); assert.equal(host.length, 0); set.dispose(); assert.equal(scene.added.length, 0); })); test('a video quad keeps frames coming while it plays, read anew at a new size', () => withImageClasses(() => { const realVideo = globalThis.HTMLVideoElement; globalThis.HTMLVideoElement = class extends EventTarget {}; try { const scene = fakeScene(); let renders = 0; scene.requestRender = () => (renders += 1); const part = createCesiumDraw({ scene, report: (error) => assert.fail(error), }); const set = part.port.quads({ id: 'feeds' }); const video = Object.assign(new globalThis.HTMLVideoElement(), { readyState: 4, paused: false, ended: false, videoWidth: 640, videoHeight: 360, }); set.set([ { id: 'v', center: { x: 6378137, y: 0, z: 0 }, orientation: { x: 0, y: 0, z: 0, w: 1 }, size: [16, 9], source: { video }, alpha: 0.95, }, ]); const fill = scene.added[0].get(0); const first = fill.appearance.material; assert.equal(first.uniforms.image, video); part.beforeRender(); renders = 0; part.afterRender(); assert.ok(renders > 0, 'a playing video asks for the next frame'); // Past the frames a new image needs, a paused video asks for none. part.afterRender(); part.afterRender(); video.paused = true; renders = 0; part.afterRender(); assert.equal(renders, 0, 'a paused video draws no more frames'); // A new size: a new material reads it, the old one freed once drawn. video.videoWidth = 1280; video.videoHeight = 720; part.beforeRender(); assert.notEqual(fill.appearance.material, first); assert.equal(fill.appearance.material.uniforms.image, video); assert.equal(first.isDestroyed(), false, 'kept until the frame drew'); part.afterRender(); assert.equal(first.isDestroyed(), true); // Paused, it draws again as it plays, with no frame asked for. renders = 0; video.dispatchEvent(new Event('playing')); assert.equal(renders, 1, 'playing again asks for a frame'); // From the video to a canvas: a material of its own. const sized = fill.appearance.material; const canvas = { width: 4, height: 4 }; const quad = { id: 'v', center: { x: 6378137, y: 0, z: 0 }, orientation: { x: 0, y: 0, z: 0, w: 1 }, size: [16, 9], source: { canvas }, alpha: 0.95, }; set.upsert([{ ...quad, show: false }]); assert.notEqual(fill.appearance.material, sized); assert.equal(fill.appearance.material.uniforms.image, canvas); renders = 0; video.dispatchEvent(new Event('playing')); assert.equal(renders, 0, 'the video it left is no longer heard'); // Hidden, the frames its image needs wait until it shows. part.afterRender(); part.afterRender(); part.afterRender(); set.upsert([quad]); renders = 0; part.afterRender(); assert.ok(renders > 0, 'shown, it asks for the frames its image needs'); set.dispose(); } finally { globalThis.HTMLVideoElement = realVideo; } })); test('meshes draw their triangles in the frame at their origin', () => withImageClasses(() => { const scene = fakeScene(); const part = createCesiumDraw({ scene, report: (error) => assert.fail(error), }); const set = part.port.meshes({ id: 'volumes', pickable: false }); const positions = new Float32Array([0, 0, 0, 10, 0, 0, 0, 10, 0, 0, 0, 10]); const indices = new Uint16Array([0, 1, 2, 0, 1, 3]); const origin = Cesium.Cartesian3.fromDegrees(-97.74, 30.27, 200); const mesh = (extra = {}) => ({ id: 'm', origin: { x: origin.x, y: origin.y, z: origin.z }, positions, indices, color: [0.2, 0.8, 1, 0.2], flat: true, ...extra, }); set.set([mesh()]); const host = scene.added[0]; assert.equal(host.length, 1); const primitive = host.get(0); const geometry = primitive.geometryInstances.geometry; assert.equal( geometry.attributes.position.componentDatatype, Cesium.ComponentDatatype.DOUBLE, ); // In the Earth-fixed frame: the east-north-up offsets about the origin. const frame = Cesium.Transforms.eastNorthUpToFixedFrame(origin); const values = geometry.attributes.position.values; for (let i = 0; i < positions.length; i += 3) { const want = Cesium.Matrix4.multiplyByPoint( frame, new Cesium.Cartesian3(positions[i], positions[i + 1], positions[i + 2]), new Cesium.Cartesian3(), ); assert.ok( Cesium.Cartesian3.equalsEpsilon( new Cesium.Cartesian3(values[i], values[i + 1], values[i + 2]), want, 0, 1e-6, ), `vertex ${i / 3} in place`, ); } assert.equal(geometry.indices, indices); assert.equal(primitive.allowPicking, false, 'an unpickable set'); assert.equal(primitive.appearance.flat, true); assert.equal(primitive.appearance.translucent, true); assert.equal( primitive.appearance.renderState.cull.enabled, false, 'both faces', ); // Hidden: the same primitive. set.upsert([mesh({ show: false })]); assert.equal(host.get(0), primitive); assert.equal(primitive.show, false); // Moved: built anew where it now is. const moved = Cesium.Cartesian3.fromDegrees(-97.73, 30.27, 200); set.upsert([mesh({ origin: { x: moved.x, y: moved.y, z: moved.z } })]); assert.equal(host.length, 1); const rebuilt = host.get(0); assert.notEqual(rebuilt, primitive); const first = rebuilt.geometryInstances.geometry.attributes.position.values; assert.ok( Cesium.Cartesian3.equalsEpsilon( new Cesium.Cartesian3(first[0], first[1], first[2]), moved, 0, 1e-6, ), 'its origin vertex is the new origin', ); // A new colour builds it anew. set.upsert([mesh({ color: '#ff0000' })]); assert.equal(host.length, 1); assert.notEqual(host.get(0), rebuilt); // Lit meshes are closed: their back faces culled. set.upsert([mesh({ flat: false })]); assert.equal(host.get(0).appearance.closed, true); set.clear(); assert.equal(host.length, 0); set.dispose(); })); test('an inertial line with a depth-fail style draws behind the surface too, turned with the sky', () => withImageClasses(() => { const { scene, draw } = drawOver(); const set = draw.lines({ id: 'sky-deep' }); set.set([ { id: 'orbit', positions: [ { x: 7e6, y: 0, z: 0 }, { x: 0, y: 7e6, z: 0 }, ], widthPx: 2, mode: '3d', style: { kind: 'solid', color: '#0ff' }, depthFail: { kind: 'solid', color: '#088' }, frame: 'inertial', }, ]); const found = []; const walk = (p) => { if (p instanceof Cesium.PrimitiveCollection) for (let i = 0; i < p.length; i++) walk(p.get(i)); else if (p instanceof Cesium.Primitive) found.push(p); }; walk(scene.added[0]); assert.equal(found.length, 1); assert.ok(found[0].depthFailAppearance, 'drawn behind the surface'); const expected = Cesium.Matrix3.multiplyByVector( Cesium.Transforms.computeTemeToPseudoFixedMatrix(Cesium.JulianDate.now()), Cesium.Cartesian3.UNIT_X, new Cesium.Cartesian3(), ); const turned = Cesium.Matrix4.multiplyByPointAsVector( found[0].modelMatrix, Cesium.Cartesian3.UNIT_X, new Cesium.Cartesian3(), ); assert.ok(Cesium.Cartesian3.equalsEpsilon(turned, expected, 1e-6)); set.dispose(); })); test('a pattern line draws its image along it, repeated, and an inertial line turns with the sky', () => withImageClasses(() => { const { scene, draw, frame } = drawOver(); const set = draw.lines({ id: 'orbit-rings' }); const ring = [ { x: 7e6, y: 0, z: 0 }, { x: 0, y: 7e6, z: 0 }, { x: -7e6, y: 0, z: 0 }, ]; const pattern = { kind: 'pattern', image: 'marks.png', repeat: 4 }; set.set([ { id: 'fixed', positions: ring, widthPx: 3, mode: '3d', style: pattern }, { id: 'sky', positions: ring, widthPx: 3, mode: '3d', style: pattern, frame: 'inertial', }, ]); const host = scene.added[0]; assert.ok(host instanceof Cesium.PrimitiveCollection); const fixed = host.get(0); const inertial = host.get(1); assert.ok(inertial instanceof Cesium.PolylineCollection); const material = fixed.get(0).material; assert.equal(material.type, 'Image'); assert.equal(material.uniforms.image, 'marks.png'); assert.deepEqual(material.uniforms.repeat, new Cesium.Cartesian2(4, 1)); assert.equal(material.isTranslucent(), true, 'its image has its alpha'); assert.equal(inertial.get(0).id.id, 'sky'); // Turned by sidereal time: the inertial x axis is drawn where the // pseudo-fixed frame puts it now. const turnedTo = () => Cesium.Matrix4.multiplyByPointAsVector( inertial.modelMatrix, Cesium.Cartesian3.UNIT_X, new Cesium.Cartesian3(), ); const expected = Cesium.Matrix3.multiplyByVector( Cesium.Transforms.computeTemeToPseudoFixedMatrix(Cesium.JulianDate.now()), Cesium.Cartesian3.UNIT_X, new Cesium.Cartesian3(), ); assert.ok( Cesium.Cartesian3.equalsEpsilon(turnedTo(), expected, 1e-6), 'turned as Cesium turns TEME', ); const realNow = Date.now; try { const at = realNow(); Date.now = () => at + 3_600_000; frame(); const later = turnedTo(); // An hour turns the frame about 15 degrees about the pole. const angle = Cesium.Cartesian3.angleBetween(later, expected); assert.ok(Math.abs(Cesium.Math.toDegrees(angle) - 15.04) < 0.05); assert.ok(Math.abs(later.z) < 1e-9); } finally { Date.now = realNow; } // Never settled into a static batch; shown and hidden in place. A // hidden line that never settles leaves its collection, which would // draw it on regardless, until it shows again. for (let i = 0; i < SETTLE_FRAMES + 2; i++) frame(); const sky = (show) => ({ id: 'sky', positions: ring, widthPx: 3, mode: '3d', style: pattern, frame: 'inertial', show, }); set.upsert([sky(false), { ...sky(false), id: 'fixed', frame: undefined }]); assert.equal(scene.added[0], host, 'patched, not rebuilt'); assert.equal(inertial.length, 0); assert.equal(fixed.length, 0); set.upsert([sky(true)]); assert.equal(scene.added[0], host); assert.equal(inertial.length, 1); assert.equal(inertial.get(0).show, true); assert.equal(inertial.get(0).id.id, 'sky'); assert.equal(inertial.get(0).material.type, 'Image'); // Built hidden, it starts out of its collection. const later = draw.lines({ id: 'orbit-rings-hidden' }); later.set([{ ...sky(false), id: 'parked' }]); assert.equal(scene.added.at(-1).get(1).length, 0); later.upsert([{ ...sky(true), id: 'parked' }]); assert.equal(scene.added.at(-1).get(1).length, 1); later.dispose(); set.dispose(); assert.equal(scene.added.length, 0); })); test('a clamped ellipse with an image fill drapes its material, finely cut so a round image runs round', () => withImageClasses(() => { const { scene, draw } = drawOver(); const set = draw.shapes({ id: 'pad-zone' }); const zone = { id: 'zone', geometry: { kind: 'ellipse', center: { lon: -80.6, lat: 28.6 }, semiMajor: 500, semiMinor: 500, }, fill: { image: 'zone.png' }, height: 'clampGround', }; set.set([zone]); const host = scene.added[0]; let ground = null; for (let i = 0; i < host.length; i++) if (host.get(i) instanceof Cesium.GroundPrimitive) ground = host.get(i); assert.ok(ground); const { appearance } = ground; assert.ok(appearance instanceof Cesium.MaterialAppearance); assert.equal(appearance.material.type, 'Image'); assert.equal(appearance.material.uniforms.image, 'zone.png'); assert.equal(ground.classificationType, Cesium.ClassificationType.BOTH); const [instance] = ground.geometryInstances; assert.ok(instance.geometry instanceof Cesium.EllipseGeometry); assert.ok( Math.abs(instance.geometry._granularity - Cesium.Math.toRadians(0.08)) < 1e-12, ); assert.equal(instance.id.id, 'zone'); // Hidden and shown in place, once its primitive is ready. Object.defineProperty(ground, 'ready', { value: true }); const shows = { show: Uint8Array.of(1) }; ground.getGeometryInstanceAttributes = () => shows; set.upsert([{ ...zone, show: false }]); assert.equal(scene.added[0], host, 'patched, not rebuilt'); assert.deepEqual([...shows.show], [0]); set.dispose(); })); test('a clamped fill that moves or resizes is drawn where it now is in the same frame, once terrain heights are loaded', () => withTerrainHeights(() => { const { scene, draw, frame } = drawOver(); const set = draw.shapes({ id: 'dragged' }); const box = (id, east, extra = {}) => ({ id, geometry: { kind: 'rectangle', rect: { west: 0, south: 0, east, north: 1 }, }, fill: [0.5, 0.9, 1, 0.12], height: 'clampGround', ...extra, }); set.set([ box('a', 1), box('b', 3, { geometry: { kind: 'rectangle', rect: { west: 2, south: 0, east: 3, north: 1 }, }, }), ]); const host = scene.added[0]; const groundOf = (h) => { for (let i = 0; i < h.length; i++) if (h.get(i) instanceof Cesium.GroundPrimitive) return h.get(i); return null; }; const batch = groundOf(host); const shows = new Map(); const attributesOf = (primitive) => { primitive.getGeometryInstanceAttributes = (id) => { const key = `${primitive.geometryInstances.length}:${id.id}`; if (!shows.has(key)) shows.set(key, { show: new Uint8Array([1]) }); return shows.get(key); }; }; attributesOf(batch); // Resized while its batch still builds: drawn alone, built at once. set.upsert([box('a', 1.5, { meta: 'dragged' })]); assert.equal(scene.added[0], host, 'the set is not rebuilt'); const solo = host.get(host.length - 1); assert.ok(solo instanceof Cesium.GroundPrimitive); assert.equal(solo.asynchronous, false, 'built in the frame it is drawn'); const instance = solo.geometryInstances[0]; assert.equal(instance.id.id, 'a'); assert.equal(instance.id.meta, 'dragged'); assert.equal( instance.id, batch.geometryInstances.find((i) => i.id.id === 'a').id, 'the same pick id', ); assert.ok( Cesium.Rectangle.equalsEpsilon( instance.geometry._rectangle, Cesium.Rectangle.fromDegrees(0, 0, 1.5, 1), 1e-12, ), ); // Its place in the batch is hidden once the batch is ready; the rest draws. Object.defineProperty(batch, 'ready', { value: true }); frame(); assert.deepEqual([...shows.get('2:a').show], [0], 'hidden in the batch'); assert.equal(shows.get('2:b'), undefined, 'the other untouched'); // Moved again: the one built for it is replaced. set.upsert([box('a', 2)]); const again = host.get(host.length - 1); assert.notEqual(again, solo); assert.ok(solo.isDestroyed(), 'the old one goes'); // A show change on a ready one is in place; one not yet drawn is built again. Object.defineProperty(again, 'ready', { value: true }); attributesOf(again); set.upsert([box('a', 2, { show: false })]); assert.equal(host.get(host.length - 1), again); assert.deepEqual([...shows.get('1:a').show], [0]); // A new item: the set rebuilds. set.upsert([box('a', 2), box('z', 3)]); assert.notEqual(scene.added.at(-1), host, 'rebuilt'); set.dispose(); assert.equal(scene.added.length, 0); })); test('a moved clamped fill is hidden where a rebuild in flight still draws it', () => withTerrainHeights(() => { const { scene, draw, frame } = drawOver(); const set = draw.shapes({ id: 'retiring' }); const box = (id, east, fill = [0.5, 0.9, 1, 0.12]) => ({ id, geometry: { kind: 'rectangle', rect: { west: 0, south: 0, east, north: 1 }, }, fill, height: 'clampGround', }); set.set([box('a', 1)]); const first = scene.added[0]; const groundOf = (h) => { for (let i = 0; i < h.length; i++) if (h.get(i) instanceof Cesium.GroundPrimitive) return h.get(i); return null; }; const old = groundOf(first); Object.defineProperty(old, 'ready', { value: true }); frame(); const shown = { show: new Uint8Array([1]) }; old.getGeometryInstanceAttributes = () => shown; // A new item rebuilds; the old host draws on until the new is ready. set.upsert([box('a', 1, [1, 0, 0, 0.5]), box('z', 0.5)]); const second = scene.added.find((p) => p !== first); assert.ok( second && scene.added.includes(first), 'both drawn while it builds', ); // Moved meanwhile: drawn alone in the new host, and gone from the old one. set.upsert([box('a', 2, [1, 0, 0, 0.5])]); assert.ok(second.get(second.length - 1).asynchronous === false); assert.deepEqual( [...shown.show], [0], 'hidden where the old host draws it', ); set.dispose(); })); /** A clamped colour rectangle from 0° to `east`°, for the move tests. */ const groundBox = (id, east, extra = {}) => ({ id, geometry: { kind: 'rectangle', rect: { west: 0, south: 0, east, north: 1 }, }, fill: [0.5, 0.9, 1, 0.12], height: 'clampGround', ...extra, }); /** Every ground primitive in a host built, with a show to read and set. */ const groundsReady = (host) => { for (let i = 0; i < host.length; i++) { const ground = host.get(i); if (!(ground instanceof Cesium.GroundPrimitive)) continue; Object.defineProperty(ground, 'ready', { value: true }); const show = { show: new Uint8Array([1]) }; ground.getGeometryInstanceAttributes = () => show; } }; /** The first ground primitive in a host, or null. */ const firstGround = (host) => { for (let i = 0; i < host.length; i++) if (host.get(i) instanceof Cesium.GroundPrimitive) return host.get(i); return null; }; test('moved clamped fills go back into a rebuilt batch once they have been still for a while', () => withTerrainHeights(() => { const { scene, draw, frame } = drawOver(); const set = draw.shapes({ id: 'settling' }); set.set([groundBox('a', 1), groundBox('b', 2)]); const host = scene.added[0]; groundsReady(host); frame(); set.upsert([groundBox('a', 1.5)]); for (let i = 0; i < SETTLE_FRAMES - 1; i++) frame(); // Moved again before it settled: it waits from there. set.upsert([groundBox('a', 1.6)]); for (let i = 0; i < SETTLE_FRAMES - 1; i++) frame(); assert.deepEqual(scene.added, [host], 'not rebuilt while it moves'); frame(); assert.equal(scene.added.length, 2, 'rebuilt once still'); const rebuilt = scene.added.find((p) => p !== host); const instances = []; for (let i = 0; i < rebuilt.length; i++) if (rebuilt.get(i) instanceof Cesium.GroundPrimitive) instances.push(...rebuilt.get(i).geometryInstances); assert.deepEqual( instances.map((i) => i.id.id).sort(), ['a', 'b'], 'both in the new batches', ); assert.ok( rebuilt.get(0).asynchronous !== false, 'built as a batch, not alone', ); assert.ok( Cesium.Rectangle.equalsEpsilon( instances.find((i) => i.id.id === 'a').geometry._rectangle, Cesium.Rectangle.fromDegrees(0, 0, 1.6, 1), 1e-12, ), 'where it last moved', ); // The host drawing it alone draws until the rebuild is ready. assert.ok(scene.added.includes(host)); for (let i = 0; i < SETTLE_FRAMES * 2; i++) frame(); assert.equal(scene.added.length, 2, 'it settles once'); set.dispose(); })); test('an upsert that would draw more clamped fills alone than MOVING_SHAPES rebuilds instead', () => withTerrainHeights(() => { const { scene, draw, frame } = drawOver(); const set = draw.shapes({ id: 'many', pickable: false }); const ids = Array.from({ length: MOVING_SHAPES + 1 }, (_, i) => `s${i}`); set.set(ids.map((id) => groundBox(id, 1))); const host = scene.added[0]; groundsReady(host); frame(); // A set that does not pick draws one alone without picking. set.upsert([groundBox('s0', 1.5)]); const solo = host.get(host.length - 1); assert.equal(solo.asynchronous, false); assert.equal(solo.allowPicking, false); assert.deepEqual(scene.added, [host]); set.upsert(ids.slice(1, MOVING_SHAPES).map((id) => groundBox(id, 1.5))); assert.deepEqual(scene.added, [host], 'MOVING_SHAPES alone at most'); set.upsert([groundBox(ids.at(-1), 1.5)]); assert.equal(scene.added.length, 2, 'one more rebuilds the set'); set.dispose(); })); test('a clamped fill moved before terrain heights load rebuilds its set', () => { const heights = Cesium.ApproximateTerrainHeights; if (heights.initialized) return; const { scene, draw } = drawOver(); const set = draw.shapes({ id: 'no-heights' }); set.set([groundBox('a', 1)]); const host = scene.added[0]; set.upsert([groundBox('a', 1.5)]); assert.ok( !scene.added.includes(host) || scene.added.length > 1, 'rebuilt, not drawn alone', ); set.dispose(); }); test('a moved clamped fill shows again where the retiring host draws it when the host drawing it alone goes unbuilt', () => withTerrainHeights(() => { const { scene, draw, frame } = drawOver(); const set = draw.shapes({ id: 'twice' }); set.set([groundBox('a', 1)]); const first = scene.added[0]; const old = firstGround(first); Object.defineProperty(old, 'ready', { value: true }); frame(); const shown = { show: new Uint8Array([1]) }; old.getGeometryInstanceAttributes = () => shown; set.upsert([groundBox('a', 1), groundBox('z', 0.5)]); set.upsert([groundBox('a', 2)]); assert.deepEqual([...shown.show], [0], 'hidden while drawn alone'); // A second rebuild drops the host drawing it alone, still building. set.upsert([groundBox('a', 2), groundBox('y', 0.5)]); assert.ok(scene.added.includes(first), 'the retiring host draws on'); assert.equal(scene.added.length, 2); assert.deepEqual([...shown.show], [1], 'drawn where it was, not gone'); set.dispose(); })); /** Ground primitives in a host built, each instance's show kept by id. */ const groundsReadyById = (host, shows = new Map()) => { for (let i = 0; i < host.length; i++) { const ground = host.get(i); if (!(ground instanceof Cesium.GroundPrimitive)) continue; Object.defineProperty(ground, 'ready', { value: true }); ground.getGeometryInstanceAttributes = (id) => { if (!shows.has(id.id)) { const shown = ground.geometryInstances.find((g) => g.id === id) ?.attributes.show.value[0]; shows.set(id.id, { show: new Uint8Array([shown ?? 1]) }); } return shows.get(id.id); }; } return shows; }; test('a hidden clamped fill moved while its set rebuilds stays hidden when a second rebuild comes', () => withTerrainHeights(() => { const { scene, draw, frame } = drawOver(); const set = draw.shapes({ id: 'hidden-twice' }); set.set([ groundBox('a', 1, { show: false }), groundBox('b', 1, { geometry: { kind: 'rectangle', rect: { west: 5, south: 0, east: 6, north: 1 }, }, }), ]); const first = scene.added[0]; const shows = groundsReadyById(first); frame(); const b = (fill) => groundBox('b', 1, { geometry: { kind: 'rectangle', rect: { west: 5, south: 0, east: 6, north: 1 }, }, fill, }); set.upsert([b([1, 0, 0, 0.5])]); set.upsert([groundBox('a', 2, { show: false })]); set.upsert([b([0, 1, 0, 0.5])]); assert.ok(scene.added.includes(first), 'the retiring host draws on'); assert.deepEqual([...shows.get('a').show], [0], 'a stays hidden'); set.dispose(); })); test('clamped fills drawn alone by a host still retiring count toward MOVING_SHAPES', () => withTerrainHeights(() => { const { scene, draw, frame } = drawOver(); const set = draw.shapes({ id: 'cap-retiring' }); const ids = Array.from( { length: MOVING_SHAPES * 2 + 1 }, (_, i) => `s${i}`, ); set.set(ids.map((id) => groundBox(id, 1))); const first = scene.added[0]; groundsReady(first); frame(); // Half the cap moved, then a rebuild while they are drawn alone. set.upsert(ids.slice(0, MOVING_SHAPES).map((id) => groundBox(id, 1.5))); set.upsert([groundBox('new', 1)]); assert.equal(scene.added.length, 2, 'rebuilding, the old host retiring'); const second = scene.added.find((p) => p !== first); const before = second.length; // Others moved while it builds: over the cap counted with the retiring // host's, so the set rebuilds rather than draw them alone. set.upsert([groundBox(ids[MOVING_SHAPES], 1.5)]); assert.ok( !scene.added.includes(second) || second.length === before, 'nothing more drawn alone', ); set.dispose(); })); test('the recent imagery box preview drags its ground fill and dashed edge frame by frame on a viewer of its own', async () => { const { createImageryBoxPreview } = await import('../../layers/recentImagery/rendering.js'); const destroyed = withImageClasses(() => withTerrainHeights(() => { const scene = fakeScene(); const viewer = { scene, isDestroyed: () => false }; let box = { west: -98, south: 30, east: -97.95, north: 30.05 }; const preview = createImageryBoxPreview(viewer, () => box); preview.setVisible(true); const hosts = scene.added.slice(); assert.equal(hosts.length, 2, 'a fill set and an edge set'); const groundIn = (host) => { for (let i = 0; i < host.length; i++) if (host.get(i) instanceof Cesium.GroundPrimitive) return host.get(i); return null; }; const fillHost = hosts.find((h) => groundIn(h)); assert.ok(fillHost, 'the fill is a ground primitive'); // Each move of the drag is drawn in the frame it is made, in place. for (const east of [-97.9, -97.85, -97.8]) { box = { ...box, east }; preview.changed(); const solo = fillHost.get(fillHost.length - 1); assert.ok(solo instanceof Cesium.GroundPrimitive); assert.equal(solo.asynchronous, false); assert.ok( Cesium.Rectangle.equalsEpsilon( solo.geometryInstances[0].geometry._rectangle, Cesium.Rectangle.fromDegrees(-98, 30, east, 30.05), 1e-12, ), ); } assert.deepEqual(scene.added, hosts, 'no set rebuilt'); const edgeHost = hosts.find((h) => h !== fillHost); const edge = edgeHost.get(edgeHost.length - 1); assert.ok(edge instanceof Cesium.GroundPolylinePrimitive); assert.equal(edge.asynchronous, false); assert.equal(edge.appearance.material.type, 'PolylineDash'); return preview.destroy().then(() => scene.added.length); }), ); assert.equal(await destroyed, 0, 'both sets let go'); }); test('icons that only move are moved on the billboards they have, and still restyle', () => { const scene = fakeScene(); const part = createCesiumDraw({ scene, report: (error) => assert.fail(error), }); const set = part.port.icons({ id: 'icons:moving' }); const icon = (lon, extra = {}) => ({ id: 'a', pos: Cesium.Cartesian3.fromDegrees(lon, 10, 20), image: 'a.png', size: [20, 20], color: [1, 0, 0, 1], rotationMode: 'screen', rotation: 0.25, disableDepthTest: Infinity, meta: { lon }, ...extra, }); set.set([icon(0), { ...icon(5), id: 'b' }]); const [host] = scene.added; const a = host.get(0); const version = part.version(); // Only moved: its look is not written again. let restyles = 0; const width = Object.getOwnPropertyDescriptor( Object.getPrototypeOf(a), 'width', ); Object.defineProperty(a, 'width', { get: width.get, set(value) { restyles += 1; width.set.call(this, value); }, configurable: true, }); for (const lon of [1, 2, 3]) set.upsert([icon(lon)]); assert.equal(restyles, 0, 'moved, not restyled'); assert.equal(scene.added[0], host, 'the same collection'); assert.equal(host.get(0), a, 'the same billboard'); const at = Cesium.Cartographic.fromCartesian(a.position); assert.ok(Math.abs(Cesium.Math.toDegrees(at.longitude) - 3) < 1e-9); assert.ok(Math.abs(at.height - 20) < 1e-6); assert.equal(a.rotation, 0.25); assert.ok(Cesium.Color.equals(a.color, Cesium.Color.RED)); assert.deepEqual(a.id.meta, { lon: 3 }, 'picks read the latest meta'); assert.equal(part.version(), version, 'nothing added or removed'); // A look that changes after moves is drawn, then moves go on from it. set.upsert([icon(3, { color: [0, 1, 0, 1], rotation: 1, size: [30, 30] })]); assert.equal(restyles, 1, 'restyled once'); assert.ok(Cesium.Color.equals(a.color, Cesium.Color.LIME)); assert.equal(a.rotation, 1); assert.equal(a.width, 30); set.upsert([icon(4, { color: [0, 1, 0, 1], rotation: 1, size: [30, 30] })]); assert.ok(Cesium.Color.equals(a.color, Cesium.Color.LIME)); assert.equal(a.width, 30); const moved = Cesium.Cartographic.fromCartesian(a.position); assert.ok(Math.abs(Cesium.Math.toDegrees(moved.longitude) - 4) < 1e-9); // Turning on screen as it moves is written with the move, not restyled. set.upsert([icon(5, { color: [0, 1, 0, 1], rotation: 2, size: [30, 30] })]); assert.equal(restyles, 1, 'a screen turn is not a restyle'); assert.equal(a.rotation, 2); set.upsert([icon(5, { color: [0, 1, 0, 1], rotation: 2, size: [31, 30] })]); assert.equal(restyles, 2, 'a new size still restyles'); assert.equal(a.rotation, 2); // A course-turned icon's axis follows where it moves. const course = (lon) => icon(lon, { rotationMode: 'course', course: 90, rotation: undefined }); set.upsert([course(4)]); set.upsert([course(60)]); const north = Cesium.Matrix4.multiplyByPointAsVector( Cesium.Transforms.eastNorthUpToFixedFrame( Cesium.Cartesian3.fromDegrees(60, 10, 20), ), Cesium.Cartesian3.UNIT_Y, new Cesium.Cartesian3(), ); assert.ok(Cesium.Cartesian3.equalsEpsilon(a.alignedAxis, north, 1e-12)); assert.equal(a.rotation, -Cesium.Math.toRadians(90)); // Hidden in place, while it moves. set.upsert([{ ...course(61), show: false }]); assert.equal(a.show, false); set.upsert([{ ...course(62), show: false }]); assert.equal(a.show, false); set.upsert([course(63)]); assert.equal(a.show, true); set.dispose(); }); test('the transit layer draws its vehicles as two icon sets, moving a marker between them, on a viewer of its own', async () => { const { createRendering } = await import('../../layers/transit/rendering.js'); const { createState } = await import('../../layers/transit/state.js'); const scene = fakeScene(); const viewer = { scene }; const noop = () => {}; const registered = []; const services = { overlays: { setOverlayEntries: noop, setOverlaySourceVisible: noop, clearOverlaySource: noop, }, render: { governorRequestRender: noop, holdContinuousRender: noop, releaseContinuousRender: noop, }, sprites: { spriteDrawOrder: (layerId) => { registered.push(layerId); return spriteDrawOrder(layerId); }, }, }; const state = createState({ services }); state._viewer = viewer; const rendering = createRendering({ state, services, parts: { height: { nearGround: () => false }, trails: { update: noop } }, }); rendering.createMarkers(viewer); const [stillId, movingId] = rendering.setIds(); assert.deepEqual(registered, ['transit', 'transit-motion']); const hostOf = (setId) => scene.added.find((h) => h.drawSetId === setId); assert.ok(hostOf(stillId) instanceof Cesium.BillboardCollection); assert.ok(hostOf(movingId) instanceof Cesium.BillboardCollection); assert.equal(hostOf(stillId).show, false, 'hidden until the layer shows'); rendering.showMarkers(); const at = Cesium.Cartesian3.fromDegrees(-71.06, 42.36, 12); const entry = { key: 'mbta:bus', mode: 'bus', toCart: at }; rendering.addMarker(entry.key, entry); entry.marker.show = true; entry.marker.rotation = 0.5; rendering.markDirty(entry); rendering.flushMarkers(); const still = hostOf(stillId); assert.equal(still.length, 1); const billboard = still.get(0); assert.equal(billboard.id.set, stillId); assert.equal(billboard.id.id, entry.key); assert.deepEqual(billboard.id.meta, { layer: 'transit', key: entry.key }); assert.ok(Cesium.Cartesian3.equalsEpsilon(billboard.position, at, 0, 1e-6)); assert.equal(billboard.rotation, 0.5); assert.equal(billboard.show, true); assert.equal(billboard.disableDepthTestDistance, Number.POSITIVE_INFINITY); assert.equal(billboard.width, entry.marker.width); assert.equal( rendering.setNameOf( drawHitOf({ primitive: billboard, id: billboard.id }).set, ), 'still', ); // Moving it moves the billboard it has. entry.marker.position.z += 10; rendering.markDirty(entry); rendering.flushMarkers(); assert.equal(still.get(0), billboard); assert.ok(Math.abs(billboard.position.z - (at.z + 10)) < 1e-6); // Starting to move takes it to the moving set and out of the still one. entry.animated = true; rendering.markDirty(entry); rendering.flushMarkers(); const moving = hostOf(movingId); assert.equal(moving.length, 1); assert.equal(moving.get(0).id.id, entry.key); assert.equal(moving.get(0).id.set, movingId); const stillNow = hostOf(stillId); const keysInStill = []; for (let i = 0; i < stillNow.length; i += 1) keysInStill.push(stillNow.get(i).id?.id); assert.deepEqual(keysInStill, [], 'no longer drawn in the still set'); // Markers taken out in one task go in one removal, at its end. const other = { key: 'mbta:tram', mode: 'tram', toCart: at }; rendering.addMarker(other.key, other); other.animated = true; rendering.markDirty(other); rendering.flushMarkers(); assert.equal(moving.length, 2); const removals = []; const remove = state._movingIcons.remove; state._movingIcons.remove = function (ids) { removals.push([...ids]); return remove.call(this, ids); }; rendering.removeMarker(entry); rendering.removeMarker(other); assert.equal(removals.length, 0, 'not yet'); await Promise.resolve(); assert.deepEqual(removals, [[entry.key, other.key]]); assert.equal(hostOf(movingId).length, 0); rendering.destroyMarkers(viewer); assert.equal(hostOf(stillId), undefined); assert.equal(hostOf(movingId), undefined); }); test('a clustered icon set draws one icon a cluster in place of its members, made again as the camera moves', () => { const scene = fakeScene(); scene.camera.directionWC = new Cesium.Cartesian3(-1, 0, 0); scene.camera.positionCartographic = { height: 1000 }; scene.canvas = { clientWidth: 400, clientHeight: 300 }; // Window positions: a degree of longitude is `spread` pixels. let spread = 1; const transforms = Cesium.SceneTransforms; const project = transforms.worldToWindowCoordinates; transforms.worldToWindowCoordinates = (_, position, result) => { const at = Cesium.Cartographic.fromCartesian(position); result ??= new Cesium.Cartesian2(); result.x = 200 + Cesium.Math.toDegrees(at.longitude) * spread; result.y = 150 - Cesium.Math.toDegrees(at.latitude) * spread; return result; }; try { const part = createCesiumDraw({ scene, report: (error) => { throw error; }, capabilities: new Set(['cluster']), }); const counts = []; const set = part.port.icons({ id: 'clustered', cluster: { pixelRange: 10, minimumSize: 2, icon: (count) => (counts.push(count), undefined), }, }); const icon = (id, lon) => ({ id, pos: { lon, lat: 0 }, image: { svg: '' }, size: [8, 8], meta: { id }, }); set.set([icon('a', 0), icon('b', 2), icon('c', 4)]); part.beforeRender(); const members = scene.added[0]; const clusters = scene.added.at(-1); assert.notEqual( clusters, members, 'cluster icons are a collection of their own', ); assert.deepEqual( [0, 1, 2].map((i) => members.get(i).show), [false, false, false], 'members are not drawn', ); assert.equal(clusters.length, 1); assert.deepEqual(counts, [3]); const { id } = clusters.get(0); assert.deepEqual([id.set, id.id, id.meta], ['clustered', 'a', { id: 'a' }]); assert.deepEqual(id.cluster.ids, ['a', 'b', 'c'], 'seed first'); const mean = Cesium.Cartographic.fromCartesian( new Cesium.Cartesian3( id.cluster.position.x, id.cluster.position.y, id.cluster.position.z, ), ); assert.ok(Math.abs(Cesium.Math.toDegrees(mean.longitude) - 2) < 1e-6); // Not made again while nothing moved. part.beforeRender(); assert.deepEqual(counts, [3]); // The camera moved: apart, each is its own. spread = 100; scene.camera.positionWC = new Cesium.Cartesian3(2e7, 1, 0); part.beforeRender(); assert.equal(clusters.length, 0); assert.deepEqual( [0, 1, 2].map((i) => members.get(i).show), [true, true, true], ); set.dispose(); assert.ok(!scene.added.includes(clusters), 'let go with the set'); } finally { transforms.worldToWindowCoordinates = project; } }); test('a points set takes columns as rows, over the items it holds', () => { const { scene, draw } = drawOver(); const set = draw.points({ id: 'column-dots' }); set.set([ { id: 'a', pos: { lon: 0, lat: 0 }, pixelSize: 4, color: '#fff' }, { id: 'gone', pos: { lon: 1, lat: 0 }, pixelSize: 4, color: '#fff' }, ]); const at = Cesium.Cartesian3.fromDegrees(10, 20); set.setColumns({ ids: ['a'], positions: new Float64Array([at.x, at.y, at.z]), colors: new Uint8Array([255, 0, 0, 255]), shown: new Uint8Array([1]), meta: [{ m: 1 }], }); assert.equal(set.size(), 1, 'rows not named are gone'); const point = scene.added[0].get(0); assert.ok(Cesium.Cartesian3.equalsEpsilon(point.position, at, 0, 1e-6)); assert.deepEqual( [point.color.red, point.color.green, point.color.alpha], [1, 0, 1], ); assert.equal(point.pixelSize, 4, 'kept from the item'); assert.deepEqual(drawHitOf({ id: point.id })?.meta, { m: 1 }); set.dispose(); }); test('a draped line in the sky’s frame drapes where the sky is, again as its clock moves on', () => { const { scene, draw, frame } = drawOver(); const realNow = Date.now; let now = Date.UTC(2026, 0, 1); Date.now = () => now; try { const set = draw.lines({ id: 'sky-track' }); const given = [ Cesium.Cartesian3.fromDegrees(0, 0), Cesium.Cartesian3.fromDegrees(1, 0), ]; set.set([ { id: 'track', positions: given, widthPx: 3, mode: 'draped', style: { kind: 'solid', color: '#fff' }, frame: 'inertial', meta: { m: 1 }, }, ]); const grounds = () => { const found = []; for (const host of scene.added) for (let i = 0; i < (host.length ?? 0); i++) if (host.get(i) instanceof Cesium.GroundPolylinePrimitive) found.push(host.get(i)); return found; }; const start = (ground) => Cesium.Math.toDegrees( Cesium.Cartographic.fromCartesian( ground.geometryInstances[0].geometry._positions[0], ).longitude, ); const [first] = grounds(); assert.ok(first, 'draped'); assert.equal(first.geometryInstances[0].id.id, 'track'); assert.deepEqual(first.geometryInstances[0].id.meta, { m: 1 }); const turned = start(first); assert.ok( Math.abs(turned) > 1, `turned off where it was given (${turned})`, ); // Within a step, nothing is draped again. now += 500; frame(); assert.equal(grounds().at(-1), first); // A minute later the sky has turned a quarter of a degree west. now += 60_000; frame(); const again = grounds().at(-1); assert.notEqual(again, first, 'draped again'); const moved = start(again) - turned; assert.ok(Math.abs(moved + 0.2507) < 0.01, `moved ${moved}°`); assert.equal(set.size(), 1); set.dispose(); } finally { Date.now = realNow; } }); test('image fills pulse their alpha through their material, clamped or not', () => withImageClasses(() => { const { scene, draw, frame } = drawOver(); const set = draw.shapes({ id: 'pulsing-images' }); const animate = { property: 'alpha', from: 0.3, to: 0.3, periodMs: 1000 }; const rect = (west) => ({ kind: 'rectangle', rect: { west, south: 0, east: west + 1, north: 1 }, }); set.set([ { id: 'flat', geometry: rect(0), fill: { image: 'pad.png' }, height: 'absolute', animate, }, { id: 'draped', geometry: rect(4), fill: { image: 'pad.png' }, height: 'clampGround', animate, }, ]); frame(); const materials = []; const walk = (primitive) => { if (primitive instanceof Cesium.PrimitiveCollection) for (let i = 0; i < primitive.length; i++) walk(primitive.get(i)); else if (primitive?.appearance?.material?.type === 'Image') materials.push(primitive.appearance.material); }; scene.added.forEach(walk); assert.equal(materials.length, 2, 'both drawn'); for (const material of materials) assert.equal( Math.round(material.uniforms.color.alpha * 100) / 100, 0.3, 'pulsed', ); set.dispose(); })); test('a material drawing a blob from an atlas slot keeps that blob alive after the slot changes', async () => { const v8 = await import('node:v8'); const vm = await import('node:vm'); v8.setFlagsFromString('--expose-gc'); const gc = vm.runInNewContext('gc'); const create = URL.createObjectURL; URL.createObjectURL = () => `blob:test/${Math.random()}`; const names = [ 'HTMLCanvasElement', 'HTMLImageElement', 'ImageBitmap', 'OffscreenCanvas', ]; const real = names.map((name) => globalThis[name]); for (const name of names) globalThis[name] ??= class {}; try { const scene = fakeScene(); const part = createCesiumDraw({ scene, report: (error) => assert.fail(error), }); const refs = {}; // Made in a function of their own, so nothing here holds the blobs. (() => { const fillBlob = new Blob(['fill']); const lineBlob = new Blob(['line']); refs.fill = new WeakRef(fillBlob); refs.line = new WeakRef(lineBlob); part.port.atlas('pics', { fill: { blob: fillBlob }, line: { blob: lineBlob }, }); })(); const shapes = part.port.shapes({ id: 'blob-fills' }); shapes.set([ { id: 'image', geometry: { kind: 'rectangle', rect: { west: 2, south: 1, east: 2.1, north: 1.1 }, height: 200, }, fill: { image: { atlas: 'pics', slot: 'fill' } }, }, ]); const lines = part.port.lines({ id: 'blob-lines' }); lines.set([ { id: 'pattern', positions: [ { lon: 0, lat: 0, height: 10 }, { lon: 1, lat: 1, height: 10 }, ], widthPx: 2, style: { kind: 'pattern', image: { atlas: 'pics', slot: 'line' }, repeat: 2, }, }, ]); // The slots move on: nothing in the atlas holds the first blobs now. part.port.atlas('pics', { fill: { blob: new Blob(['b']) }, line: { blob: new Blob(['c']) }, }); for (let i = 0; i < 3; i++) { await new Promise((resolve) => setImmediate(resolve)); gc(); } assert.ok(refs.fill.deref(), 'the fill’s material still has its blob'); assert.ok(refs.line.deref(), 'the pattern’s material still has its blob'); shapes.dispose(); lines.dispose(); } finally { URL.createObjectURL = create; names.forEach((name, i) => (globalThis[name] = real[i])); } }); test('a quad that moves from a blob to a URL lets the blob go once its old material is freed', async () => { const v8 = await import('node:v8'); const vm = await import('node:vm'); v8.setFlagsFromString('--expose-gc'); const gc = vm.runInNewContext('gc'); const settle = async () => { for (let i = 0; i < 3; i++) { await new Promise((resolve) => setImmediate(resolve)); gc(); } }; const create = URL.createObjectURL; URL.createObjectURL = () => `blob:test/${Math.random()}`; const names = [ 'HTMLCanvasElement', 'HTMLImageElement', 'ImageBitmap', 'OffscreenCanvas', ]; const real = names.map((name) => globalThis[name]); for (const name of names) globalThis[name] ??= class {}; try { const scene = fakeScene(); const part = createCesiumDraw({ scene, report: (error) => assert.fail(error), }); const set = part.port.quads({ id: 'feeds' }); const quad = (source) => ({ id: 'q', center: { x: 6378137, y: 10, z: 20 }, orientation: { x: 0, y: 0, z: 0, w: 1 }, size: [40, 20], source, }); const refs = {}; // Made in a function of its own, so nothing here holds the blob. (() => { const blob = new Blob(['frame']); refs.blob = new WeakRef(blob); set.set([quad({ image: { blob } })]); })(); await settle(); assert.ok(refs.blob.deref(), 'held while its material draws it'); set.set([quad({ image: 'https://example.test/still.png' })]); await settle(); assert.ok(refs.blob.deref(), 'held while the old material may draw'); part.afterRender(); await settle(); assert.equal(refs.blob.deref(), undefined, 'let go with the old material'); set.dispose(); } finally { URL.createObjectURL = create; names.forEach((name, i) => (globalThis[name] = real[i])); } });