diff --git a/src/agent/worldPacket.js b/src/agent/worldPacket.js index ec8234340..9217bd9b3 100644 --- a/src/agent/worldPacket.js +++ b/src/agent/worldPacket.js @@ -1,4 +1,4 @@ -import { toLonLatH } from '../geo/index.js'; +import { findCamera } from '../render/rendererOf.js'; import { feedProvenanceEnvelope, layerSnapshot, @@ -104,12 +104,12 @@ export function getWorldPacket(options = {}) { // A default parameter only covers undefined; null or NaN would age every // feed against the epoch and report stale data as "just now". const now = Number.isFinite(requestedNow) ? requestedNow : Date.now(); - if (!viewer?.camera?.positionWC) - throw new TypeError('World Packet requires a viewer camera'); + const pose = findCamera(viewer)?.pose(); + if (!pose) throw new TypeError('World Packet requires a viewer camera'); if (!dataManager || typeof dataManager.getAll !== 'function') throw new TypeError('World Packet requires a data manager'); - const eye = toLonLatH(viewer.camera.positionWC); + const eye = { lon: pose.lon, lat: pose.lat, height: pose.height }; // Read the roster once. Voice must not rewalk disabled layers: preserving the // current enabled-only view keeps the model's context budget bounded. const rows = dataManager.getAll(); diff --git a/src/agent/worldPacket.test.mjs b/src/agent/worldPacket.test.mjs index 5df5f8d64..a10b407da 100644 --- a/src/agent/worldPacket.test.mjs +++ b/src/agent/worldPacket.test.mjs @@ -3,6 +3,8 @@ import assert from 'node:assert/strict'; import * as Cesium from 'cesium'; import { getWorldPacket } from './worldPacket.js'; +import { bindRenderer } from '../render/rendererOf.js'; +import { createStubRenderer } from '../render/stub/index.js'; import { createGevActionRunner } from '../voice/gevActions.js'; function withoutVoicePresentation(result) { @@ -63,6 +65,14 @@ function harness() { getCockpitState: () => null, getControlState: () => ({ hud: { visible: 'auto' } }), }; + // The packet reads the eye from the camera port of the renderer bound to + // the scene object. + const renderer = createStubRenderer(); + renderer.camera.setView({ + destination: { lon: -97.74, lat: 30.26, height: 500 }, + orientation: { heading: 0, pitch: Cesium.Math.toRadians(-45), roll: 0 }, + }); + bindRenderer(viewer, renderer); return { viewer, dataManager, styleManager }; } diff --git a/src/data/followed.js b/src/data/followed.js index 69b4c2ed7..2f33ed3fd 100644 --- a/src/data/followed.js +++ b/src/data/followed.js @@ -4,17 +4,13 @@ * * A layer follows through the camera port with a FollowTarget that also * carries what the app shows about it (key, display position, sprite, label). - * Until every layer does, a layer may still track an entity of its own - * through Cesium's `trackedEntity`; that entity is seen here through the - * same fields, read from its entity record. Readers ask this module, never - * `trackedEntity`, so they work either way. A layer that still draws its - * target as an entity follows through the port with `entityFollowTarget`, - * whose presentation fields read that same record. + * A layer that keeps its target as a holder of its own (an entity record) + * follows through the port with `entityFollowTarget`, whose presentation + * fields read that record. Readers ask this module, never the renderer. * * Its readers (the tracked card, Cockpit, the share link's thing view, - * north-up) still read the drawn entity and its `displayPosition`: a port - * target without them is followed by the camera but not shown by them, - * until those readers move with the drawing to the renderer. + * north-up) read the target's `displayPosition`: a port target without one + * is followed by the camera but not shown by them. */ import { findCamera } from '../render/rendererOf.js'; import { readEntityRecord } from './entityRecords.js'; @@ -29,8 +25,8 @@ import { readEntityRecord } from './entityRecords.js'; * @property {object} [sprite] Size of the drawn billboard. * @property {object} [labelModel] * @property {string} [selectionOrigin] - * @property {object} [entity] The tracked entity, for a layer that still - * tracks one itself. + * @property {object} [entity] The holder whose entity record the + * presentation fields read (`entityFollowTarget`). */ /** @type {WeakMap} */ @@ -78,10 +74,7 @@ function entityView(entity) { */ export function followedOf(viewer) { if (!viewer) return null; - const target = findCamera(viewer)?.followed; - if (target) return target; - const entity = viewer.trackedEntity; - return entity ? entityView(entity) : null; + return findCamera(viewer)?.followed ?? null; } /** Whether `viewer`'s camera follows anything. */ @@ -100,8 +93,7 @@ export function onFollowChanged(viewer, cb) { let port = null; let offPort = null; // The port is looked up again on every change: a renderer bound after - // this subscribed replaces the one it listened to. A Cesium port's follow - // also sets `trackedEntity`, so the change still arrives through it. + // this subscribed replaces the one it listened to. const listenToPort = () => { const current = findCamera(viewer); if (current === port) return; @@ -117,20 +109,17 @@ export function onFollowChanged(viewer, cb) { cb(now); } listenToPort(); - const offTracking = viewer.trackedEntityChanged?.addEventListener(check); return () => { offPort?.(); offPort = null; - offTracking?.(); }; } -/** Stop the camera following anything, a layer's own tracking included. */ +/** Stop the camera following anything. */ export function stopFollowing(viewer) { if (!viewer) return; const camera = findCamera(viewer); if (camera?.followed) camera.follow(null); - else if (viewer.trackedEntity) viewer.trackedEntity = undefined; } /** @@ -157,30 +146,22 @@ export function entityFollowTarget(entity, camera) { } /** - * Follow `followed` again after `stopFollowing`: a port target through the - * camera port, a layer's own tracked entity through `trackedEntity`. + * Follow `followed` again after `stopFollowing`, through the camera port. * @param {object} viewer * @param {Followed|null} followed What `followedOf` gave. */ export function resumeFollowing(viewer, followed) { if (!viewer || !followed) return; - if (entityViews.get(followed.entity) === followed) - viewer.trackedEntity = followed.entity; - else findCamera(viewer)?.follow(followed); + findCamera(viewer)?.follow(followed); } /** - * Where `followed` is shown this frame: the layer's display cache, else its - * entity's position at the viewer's time; null when neither answers. + * Where `followed` is shown this frame: the layer's display cache; null + * when it has none, or it answers nothing. * @param {object} viewer * @param {Followed|null} followed */ export function followedPosition(viewer, followed) { const display = followed?.displayPosition; - const shown = typeof display === 'function' ? display() : null; - return ( - shown || - followed?.entity?.position?.getValue?.(viewer?.clock?.currentTime) || - null - ); + return (typeof display === 'function' ? display() : null) || null; } diff --git a/src/data/followed.test.mjs b/src/data/followed.test.mjs index 1c987fae2..ccc0eda13 100644 --- a/src/data/followed.test.mjs +++ b/src/data/followed.test.mjs @@ -14,23 +14,6 @@ import { import { bindRenderer } from '../render/rendererOf.js'; import { createCameraEvents } from '../render/camera/events.js'; -/** A viewer whose `trackedEntity` behaves as Cesium's setter does. */ -function trackingViewer() { - const trackedEntityChanged = new Cesium.Event(); - let tracked; - return { - trackedEntityChanged, - get trackedEntity() { - return tracked; - }, - set trackedEntity(value) { - if (tracked === value) return; - tracked = value; - trackedEntityChanged.raiseEvent(value); - }, - }; -} - /** A camera port that follows, for a viewer bound to a renderer. */ function followingPort() { const events = createCameraEvents({ pose: () => ({}), report: () => {} }); @@ -48,62 +31,37 @@ function followingPort() { }; } -test('a layer’s own tracked entity is seen through its entity record', () => { - const viewer = trackingViewer(); - assert.equal(followedOf(viewer), null); - assert.equal(isFollowing(viewer), false); - const entity = new Cesium.Entity({ id: 'e1', name: 'N1' }); - const record = entityRecord(entity); - record.trackedId = 'flights:abc'; - record.displayPosition = () => ({ x: 1, y: 2, z: 3 }); - record.sprite = { width: 28 }; - viewer.trackedEntity = entity; - const followed = followedOf(viewer); - assert.equal(followed, followedOf(viewer), 'the same view each time'); - assert.equal(followed.key, 'flights:abc'); - assert.equal(followed.name, 'N1'); - assert.deepEqual(followed.displayPosition(), { x: 1, y: 2, z: 3 }); - assert.equal(followed.sprite.width, 28); - assert.equal(followed.entity, entity); - viewer.trackedEntity = new Cesium.Entity({ id: 'plain' }); - assert.equal(followedOf(viewer).key, 'entity:plain', 'no tracked id'); -}); - -test('a port follow comes before any tracked entity, and is the target itself', (t) => { - const viewer = trackingViewer(); +test('what the camera port follows is the target itself', (t) => { + const viewer = {}; + assert.equal(followedOf(viewer), null, 'nothing without a renderer'); const camera = followingPort(); t.after(bindRenderer(viewer, { camera })); - viewer.trackedEntity = new Cesium.Entity({ id: 'helper' }); + assert.equal(followedOf(viewer), null); + assert.equal(isFollowing(viewer), false); const target = { key: 'flights:abc', position: () => null }; camera.follow(target); assert.equal(followedOf(viewer), target); + assert.equal(isFollowing(viewer), true); }); -test('onFollowChanged fires once per change, from either source', (t) => { - const viewer = trackingViewer(); +test('onFollowChanged fires once per change', (t) => { + const viewer = {}; const camera = followingPort(); t.after(bindRenderer(viewer, { camera })); const seen = []; const off = onFollowChanged(viewer, (f) => seen.push(f?.key ?? null)); const target = { key: 'flights:abc' }; - // A port follow on Cesium sets trackedEntity too: still one change. camera.follow(target); - // Ending it, Cesium clears its tracking before the port announces. - viewer.trackedEntity = undefined; + camera.follow(target); camera.follow(null); - const entity = new Cesium.Entity({ id: 'legacy' }); - viewer.trackedEntity = entity; - viewer.trackedEntity = entity; off(); - viewer.trackedEntity = undefined; - assert.deepEqual(seen, ['flights:abc', null, 'entity:legacy']); + camera.follow({ key: 'after' }); + assert.deepEqual(seen, ['flights:abc', null]); }); -test('stopFollowing ends a port follow, or a layer’s own tracking', (t) => { - const viewer = trackingViewer(); - viewer.trackedEntity = new Cesium.Entity({ id: 'legacy' }); +test('stopFollowing ends a port follow', (t) => { + const viewer = {}; stopFollowing(viewer); - assert.equal(viewer.trackedEntity, undefined); const camera = followingPort(); t.after(bindRenderer(viewer, { camera })); camera.follow({ key: 'k' }); @@ -112,19 +70,6 @@ test('stopFollowing ends a port follow, or a layer’s own tracking', (t) => { stopFollowing(null); }); -test('a renderer bound after subscribing is still heard', (t) => { - const viewer = { trackedEntityChanged: new Cesium.Event() }; - const seen = []; - onFollowChanged(viewer, (f) => seen.push(f?.key ?? null)); - const camera = followingPort(); - t.after(bindRenderer(viewer, { camera })); - // Any change re-resolves the port; a Cesium follow raises one. - viewer.trackedEntityChanged.raiseEvent(); - camera.follow({ key: 'k' }); - camera.follow(null); - assert.deepEqual(seen, ['k', null]); -}); - test('an entity follow target reads its entity record live', () => { const entity = new Cesium.Entity({ id: 'drawn', name: 'N2' }); const position = () => ({ x: 1, y: 2, z: 3 }); @@ -142,16 +87,8 @@ test('an entity follow target reads its entity record live', () => { assert.equal(keyed.labelModel.title, 'N2'); }); -test('resumeFollowing follows a port target again, or re-tracks an entity', (t) => { - const viewer = trackingViewer(); - const entity = new Cesium.Entity({ id: 'legacy' }); - viewer.trackedEntity = entity; - const legacy = followedOf(viewer); - stopFollowing(viewer); - resumeFollowing(viewer, legacy); - assert.equal(viewer.trackedEntity, entity); - assert.equal(followedOf(viewer), legacy); - viewer.trackedEntity = undefined; +test('resumeFollowing follows a port target again', (t) => { + const viewer = {}; const camera = followingPort(); t.after(bindRenderer(viewer, { camera })); const target = entityFollowTarget(new Cesium.Entity({ id: 'p' }), {}); @@ -163,13 +100,11 @@ test('resumeFollowing follows a port target again, or re-tracks an entity', (t) assert.equal(camera.followed, target); }); -test('followedPosition prefers the display cache over the entity position', () => { - const at = new Cesium.Cartesian3(4, 5, 6); - const viewer = { clock: { currentTime: Cesium.JulianDate.now() } }; - const entity = new Cesium.Entity({ id: 'e', position: at }); +test('followedPosition reads the display cache', () => { + const entity = new Cesium.Entity({ id: 'e' }); const view = entityFollowTarget(entity, {}); - assert.deepEqual(followedPosition(viewer, view), at); + assert.equal(followedPosition({}, view), null, 'none without a cache'); entityRecord(entity).displayPosition = () => ({ x: 7, y: 8, z: 9 }); - assert.deepEqual(followedPosition(viewer, view), { x: 7, y: 8, z: 9 }); - assert.equal(followedPosition(viewer, null), null); + assert.deepEqual(followedPosition({}, view), { x: 7, y: 8, z: 9 }); + assert.equal(followedPosition({}, null), null); }); diff --git a/src/layers/vessels/lifecycle.js b/src/layers/vessels/lifecycle.js index 06529225e..dce5b8d64 100644 --- a/src/layers/vessels/lifecycle.js +++ b/src/layers/vessels/lifecycle.js @@ -1,5 +1,6 @@ import { VESSEL_OVERLAY_SOURCE_ID } from '../../data/vesselLabels.js'; import { msg, t } from '../../i18n/index.js'; +import { findCamera } from '../../render/rendererOf.js'; import { AIS_FIRST_CONNECT_GRACE_MS, AIS_HEALTHY_STATUSES } from './policy.js'; export function createLifecycle({ @@ -190,9 +191,9 @@ export function createLifecycle({ ); // Vessels are asked for by view, so ask again when the view moves away. removeViewListener(); - const moveEnd = activeViewer?.camera?.moveEnd; - if (typeof moveEnd?.addEventListener === 'function') - state.feed.removeViewListener = moveEnd.addEventListener(() => { + const camera = findCamera(activeViewer); + if (camera) + state.feed.removeViewListener = camera.on('moveEnd', () => { components.ingestion.refreshIfMoved(activeViewer); }); return components.ingestion.loadLivePositions(activeViewer); diff --git a/src/layers/weather/imageryHost.js b/src/layers/weather/imageryHost.js index 29d171411..3d5249817 100644 --- a/src/layers/weather/imageryHost.js +++ b/src/layers/weather/imageryHost.js @@ -1,17 +1,10 @@ -import { msg } from '../../i18n/index.js'; +import { NO_IMAGERY_HOST } from '../../maps/imageryHost.js'; -/** Resolve the visible surface that can own weather imagery without scene mutation. */ -export function resolveImageryHost({ viewer, tileset }) { - if (viewer?.scene?.globe?.show === true) - return { collection: viewer.imageryLayers, kind: 'globe' }; - if (tileset?.imageryLayers) - return { collection: tileset.imageryLayers, kind: 'tileset' }; - return { collection: null, kind: 'none' }; -} - -export const NO_IMAGERY_HOST = msg( - 'Hidden by this map source · choose a globe map', -); +/** + * Resolve the visible surface that can own weather imagery without scene + * mutation: the map stack's imagery host (`src/maps/imageryHost.js`). + */ +export { NO_IMAGERY_HOST, resolveImageryHost } from '../../maps/imageryHost.js'; /** Report imagery suspension without changing or detaching the resolved host. */ export function imageryHostStatus(host) { diff --git a/src/layers/weather/imageryHost.test.mjs b/src/layers/weather/imageryHost.test.mjs index d533538d9..f42c4d8bf 100644 --- a/src/layers/weather/imageryHost.test.mjs +++ b/src/layers/weather/imageryHost.test.mjs @@ -5,6 +5,8 @@ import { imageryHostStatus, NO_IMAGERY_HOST, } from './imageryHost.js'; +import { bindRenderer } from '../../render/rendererOf.js'; +import { createStubRenderer } from '../../render/stub/index.js'; test('only a missing host suspends weather; 3D Tiles has no height gate', () => { assert.equal(imageryHostStatus({ kind: 'tileset' }), null); @@ -12,28 +14,22 @@ test('only a missing host suspends weather; 3D Tiles has no height gate', () => assert.equal(imageryHostStatus({ kind: 'none' }), NO_IMAGERY_HOST); }); -test('visible globe takes precedence over a tileset', () => { - const viewer = { imageryLayers: {}, scene: { globe: { show: true } } }; - assert.deepEqual( - resolveImageryHost({ viewer, tileset: { imageryLayers: {} } }), - { collection: viewer.imageryLayers, kind: 'globe' }, - ); -}); -test('hidden globe uses the supplied tileset imagery collection', () => { - const tileset = { imageryLayers: {} }; - const viewer = { scene: { globe: { show: false } } }; +test('weather drapes on the map stack imagery host', () => { + const renderer = createStubRenderer(); + const viewer = {}; + bindRenderer(viewer, renderer); + const tileset = { id: 'tiles' }; assert.deepEqual(resolveImageryHost({ viewer, tileset }), { - collection: tileset.imageryLayers, + collection: renderer.globe.imagery, + kind: 'globe', + }); + renderer.globe.setGlobeVisible(false); + assert.deepEqual(resolveImageryHost({ viewer, tileset }), { + collection: tileset, kind: 'tileset', }); -}); -test('hidden globe without an imagery-capable tileset has no host', () => { - for (const tileset of [null, {}]) - assert.deepEqual( - resolveImageryHost({ - viewer: { scene: { globe: { show: false } } }, - tileset, - }), - { collection: null, kind: 'none' }, - ); + assert.deepEqual(resolveImageryHost({ viewer, tileset: null }), { + collection: null, + kind: 'none', + }); }); diff --git a/src/maps/imageryHost.js b/src/maps/imageryHost.js index e3086819f..e2b2a60ac 100644 --- a/src/maps/imageryHost.js +++ b/src/maps/imageryHost.js @@ -1,28 +1,36 @@ /** * Where draped imagery can go on the current map stack. A globe stack drapes - * on `viewer.imageryLayers`; a 3D-tiles stack hides the globe, and Cesium - * 1.138 drapes imagery onto the tileset's own `imageryLayers` instead. When - * neither exists there is nowhere to drape and the caller says so. + * on the globe port's imagery; a 3D-tiles stack hides the globe, and the + * renderer drapes that imagery onto the shown base tileset instead. When + * neither is drawn there is nowhere to drape and the caller says so. */ import { msg } from '../i18n/marker.js'; +import { findGlobe } from '../render/rendererOf.js'; /** Guidance shown when the active map stack cannot host draped imagery. */ export const NO_IMAGERY_HOST = msg( 'Hidden by this map source · choose a globe map', ); +const NONE = Object.freeze({ collection: null, kind: 'none' }); + /** - * Resolve the imagery layer collection for the active map stack. + * Resolve the imagery host for the active map stack: the globe port's + * imagery while the globe is shown, else the shown base tileset (the map + * stack's `getImageryHostTileset()`), else none. `collection` names the host + * (one value per host, so a change of host is a change of it). A renderer + * that does not say whether its globe is shown (no `globeVisibility`) has it + * shown whenever no base tileset is. * @param {{ viewer?: object, tileset?: object }} scene * @returns {{ collection: object | null, kind: 'globe' | 'tileset' | 'none' }} */ export function resolveImageryHost({ viewer, tileset } = {}) { - if (viewer?.scene?.globe?.show === true && viewer.imageryLayers) { - return { collection: viewer.imageryLayers, kind: 'globe' }; - } - if (tileset?.imageryLayers && !tileset.isDestroyed?.()) { - return { collection: tileset.imageryLayers, kind: 'tileset' }; - } - return { collection: null, kind: 'none' }; + const globe = findGlobe(viewer); + const shownTileset = + tileset && tileset.isDestroyed?.() !== true ? tileset : null; + const globeShown = globe?.isGlobeVisible?.() ?? (globe && !shownTileset); + if (globe && globeShown) return { collection: globe.imagery, kind: 'globe' }; + if (shownTileset) return { collection: shownTileset, kind: 'tileset' }; + return NONE; } diff --git a/src/maps/imageryHost.test.mjs b/src/maps/imageryHost.test.mjs index edb2c3d0d..731d85eb4 100644 --- a/src/maps/imageryHost.test.mjs +++ b/src/maps/imageryHost.test.mjs @@ -1,39 +1,56 @@ import test from 'node:test'; import assert from 'node:assert/strict'; import { NO_IMAGERY_HOST, resolveImageryHost } from './imageryHost.js'; +import { bindRenderer } from '../render/rendererOf.js'; +import { createStubRenderer } from '../render/stub/index.js'; -test('a shown globe hosts imagery on the viewer collection', () => { - const imageryLayers = { id: 'globe' }; - const host = resolveImageryHost({ - viewer: { scene: { globe: { show: true } }, imageryLayers }, - tileset: { imageryLayers: { id: 'tiles' } }, - }); - assert.deepEqual(host, { collection: imageryLayers, kind: 'globe' }); +/** A scene object bound to a stub renderer, its globe shown or hidden. */ +function scene({ globeShown, capabilities } = {}) { + const renderer = createStubRenderer( + capabilities ? { capabilities } : undefined, + ); + if (globeShown !== undefined) renderer.globe.setGlobeVisible(globeShown); + const viewer = {}; + bindRenderer(viewer, renderer); + return { viewer, renderer }; +} + +test('a shown globe hosts imagery on the globe port', () => { + const { viewer, renderer } = scene({ globeShown: true }); + const host = resolveImageryHost({ viewer, tileset: { id: 'tiles' } }); + assert.deepEqual(host, { collection: renderer.globe.imagery, kind: 'globe' }); }); -test('a hidden globe hands imagery to the tileset collection', () => { - const imageryLayers = { id: 'tiles' }; - const host = resolveImageryHost({ - viewer: { scene: { globe: { show: false } }, imageryLayers: {} }, - tileset: { imageryLayers, isDestroyed: () => false }, +test('a hidden globe hands imagery to the shown base tileset', () => { + const { viewer } = scene({ globeShown: false }); + const tileset = { id: 'tiles', isDestroyed: () => false }; + const host = resolveImageryHost({ viewer, tileset }); + assert.deepEqual(host, { collection: tileset, kind: 'tileset' }); +}); + +test('without globe visibility, the globe hosts unless a tileset is shown', () => { + const { viewer, renderer } = scene({ capabilities: [] }); + assert.equal(renderer.globe.isGlobeVisible, undefined); + const tileset = { id: 'tiles' }; + assert.deepEqual(resolveImageryHost({ viewer, tileset }), { + collection: tileset, + kind: 'tileset', + }); + assert.deepEqual(resolveImageryHost({ viewer, tileset: null }), { + collection: renderer.globe.imagery, + kind: 'globe', }); - assert.deepEqual(host, { collection: imageryLayers, kind: 'tileset' }); }); test('no globe and no tileset means nowhere to drape', () => { - assert.deepEqual( - resolveImageryHost({ - viewer: { scene: { globe: { show: false } }, imageryLayers: {} }, - tileset: null, - }), - { collection: null, kind: 'none' }, - ); + const { viewer } = scene({ globeShown: false }); + assert.deepEqual(resolveImageryHost({ viewer, tileset: null }), { + collection: null, + kind: 'none', + }); assert.deepEqual(resolveImageryHost({}), { collection: null, kind: 'none' }); assert.deepEqual( - resolveImageryHost({ - viewer: { scene: { globe: { show: false } } }, - tileset: { imageryLayers: {}, isDestroyed: () => true }, - }), + resolveImageryHost({ viewer, tileset: { isDestroyed: () => true } }), { collection: null, kind: 'none' }, ); assert.match(NO_IMAGERY_HOST, /globe map/); diff --git a/src/render/stub/index.js b/src/render/stub/index.js index e0e0ba0ac..aefd1f0eb 100644 --- a/src/render/stub/index.js +++ b/src/render/stub/index.js @@ -89,9 +89,69 @@ function uncaught(error) { }); } +/** Size the stub's viewport and its canvas to `size` (CSS pixels). */ +function sizeCanvas(canvas, viewport, size) { + Object.assign(viewport, size); + canvas.width = viewport.width; + canvas.height = viewport.height; + // A page's canvas measures itself; a stand-in reports the viewport. + if (!canvas.ownerDocument) { + canvas.clientWidth = viewport.width; + canvas.clientHeight = viewport.height; + } +} + +/** + * The stub's canvas: in a page (`container` given), a real canvas filling + * the container, which the viewport follows; otherwise a stand-in that + * takes event listeners and measures as the viewport does. + */ +function createCanvas(container, viewport) { + const document = container?.ownerDocument; + if (document) { + const canvas = document.createElement('canvas'); + canvas.style.width = '100%'; + canvas.style.height = '100%'; + canvas.style.display = 'block'; + container.appendChild(canvas); + if (container.clientWidth > 0 && container.clientHeight > 0) + Object.assign(viewport, { + width: container.clientWidth, + height: container.clientHeight, + }); + canvas.width = viewport.width; + canvas.height = viewport.height; + return canvas; + } + const canvas = /** @type {HTMLCanvasElement} */ ( + /** @type {unknown} */ ( + Object.assign(new EventTarget(), { + width: viewport.width, + height: viewport.height, + clientWidth: viewport.width, + clientHeight: viewport.height, + style: {}, + getBoundingClientRect: () => ({ + x: 0, + y: 0, + left: 0, + top: 0, + width: viewport.width, + height: viewport.height, + right: viewport.width, + bottom: viewport.height, + }), + }) + ) + ); + return canvas; +} + /** * @param {object} [options] * @param {Iterable} [options.capabilities] Default: all. + * @param {HTMLElement} [options.container] In a page: the element the stub's + * canvas fills, as a plugin's `CreateOptions.container`. * @param {{width: number, height: number}} [options.viewport] CSS size; default 1280 × 720. * @param {number} [options.time] Scene time, epoch ms. * @returns {import('../contract/renderer').Renderer & {testing: StubTesting}} @@ -1460,14 +1520,7 @@ export function createStubRenderer(options = {}) { // --- Renderer -------------------------------------------------------------- - const canvas = /** @type {HTMLCanvasElement} */ ( - /** @type {unknown} */ ({ - width: viewport.width, - height: viewport.height, - clientWidth: viewport.width, - clientHeight: viewport.height, - }) - ); + const canvas = createCanvas(options.container, viewport); const renderer = { id: 'stub', @@ -1518,6 +1571,13 @@ export function createStubRenderer(options = {}) { return { state: blockers.length ? 'timeout' : 'settled', blockers }; }, resize() { + // In a page, the stub's canvas follows its container's size. + const container = options.container; + if (container?.clientWidth > 0 && container?.clientHeight > 0) + sizeCanvas(canvas, viewport, { + width: container.clientWidth, + height: container.clientHeight, + }); requestRender('resize'); }, releaseUnused() { @@ -1540,6 +1600,7 @@ export function createStubRenderer(options = {}) { // A flight in progress ends cancelled and gives back its input hold. camera.endFlight(); destroyed = true; + if (options.container) canvas.remove?.(); for (const clear of onceTimers) clear(); onceTimers.clear(); sets.clear(); @@ -1588,9 +1649,7 @@ export function createStubRenderer(options = {}) { settled[kind] = value; }, setViewport(size) { - Object.assign(viewport, size); - canvas.width = viewport.width; - canvas.height = viewport.height; + sizeCanvas(canvas, viewport, size); }, /** * Where a drawn item is drawn now (or `aheadMs` from now), ECEF, or @@ -1630,3 +1689,26 @@ export function createStubRenderer(options = {}) { * @property {() => object} effects * @property {(error: Error) => void} emitError */ + +/** + * The stub as a renderer plugin (`RendererPlugin`), for running the whole + * application on it: each renderer it makes fills the container it is given + * with a canvas, as any plugin's does. Nothing runs on its own: the caller + * drives the loop (`testing.tick()`), each frame or as a test needs. + * @param {Parameters[0]} [options] For each + * renderer it makes (`capabilities`, `viewport`, `time`...). + * @param {(renderer: ReturnType) => void} [onCreate] + * Hears each renderer it makes. + * @returns {import('../contract/renderer').RendererPlugin} + */ +export function createStubRendererPlugin(options = {}, onCreate) { + return Object.freeze({ + id: 'stub', + async create({ container, signal }) { + signal?.throwIfAborted(); + const renderer = createStubRenderer({ ...options, container }); + onCreate?.(renderer); + return renderer; + }, + }); +} diff --git a/src/render/viewerAccessAllowList.json b/src/render/viewerAccessAllowList.json index f2c1e3068..0967ef424 100644 --- a/src/render/viewerAccessAllowList.json +++ b/src/render/viewerAccessAllowList.json @@ -1,7 +1 @@ -{ - "src/agent/worldPacket.js": 2, - "src/data/followed.js": 5, - "src/layers/vessels/lifecycle.js": 1, - "src/layers/weather/imageryHost.js": 3, - "src/maps/imageryHost.js": 4 -} +{}