diff --git a/src/layers/weather/display.js b/src/layers/weather/display.js index 13e117570..dab84e548 100644 --- a/src/layers/weather/display.js +++ b/src/layers/weather/display.js @@ -140,14 +140,3 @@ export function insideExtent({ west, south, east, north }, lon, lat) { if (lat < south || lat > north) return false; return west < east ? lon >= west && lon <= east : lon >= west || lon <= east; } - -/** Plain text for a Cesium credit, which otherwise reads its text as HTML. */ -export function escapeCreditText(value) { - return value.replace( - /[&<>"']/g, - (ch) => - ({ '&': '&', '<': '<', '>': '>', '"': '"', "'": ''' })[ - ch - ], - ); -} diff --git a/src/layers/weather/display.test.mjs b/src/layers/weather/display.test.mjs index 1f171b6f9..a5548e1aa 100644 --- a/src/layers/weather/display.test.mjs +++ b/src/layers/weather/display.test.mjs @@ -1,11 +1,11 @@ import test from 'node:test'; import assert from 'node:assert/strict'; import * as Cesium from 'cesium'; -import { GeographicTilingScheme } from 'cesium'; import { createWeatherLayer } from './index.js'; import { createWeatherRendering } from './rendering.js'; -import { weatherDisplay, insideExtent, escapeCreditText } from './display.js'; -import { createShellCesium, createShellScene } from './shellFixture.mjs'; +import { weatherDisplay, insideExtent } from './display.js'; +import { createShellScene } from './shellFixture.mjs'; +import { fakeGlobePort } from '../../testSupport/fakeGlobePort.mjs'; import { formatScaleLabel } from '../../ui/unitLabels.js'; import { bindFakeCesiumCamera } from '../../testSupport/fakeCameraPort.mjs'; @@ -581,10 +581,6 @@ test('display validation bounds text, legend shape, colours and extents', () => assert.equal(insideExtent(wrap.extent, -100, 10), true); assert.equal(insideExtent(wrap.extent, 50, 10), false); assert.equal(insideExtent(wrap.extent, -100, 81), false); - assert.equal( - escapeCreditText(`"A" & 'B'`), - '<b>"A" & 'B'</b>', - ); }); function mockCanvas() { @@ -598,35 +594,11 @@ function mockCanvas() { return canvas; } -/** A globe viewer whose imagery collection records providers. */ +/** A globe viewer whose globe port records the layers added. */ function globeViewer() { - const providers = []; - const layers = []; - const collection = { - addImageryProvider(provider) { - providers.push(provider); - const layer = { imageryProvider: provider, alpha: 1, show: true }; - layers.push(layer); - return layer; - }, - contains: (layer) => layers.includes(layer), - remove(layer) { - layers.splice(layers.indexOf(layer), 1); - return true; - }, - get length() { - return layers.length; - }, - get: (index) => layers[index], - indexOf: (layer) => layers.indexOf(layer), - lower() {}, - raise() {}, - raiseToTop() {}, - isDestroyed: () => false, - }; const listeners = new Set(); const viewer = { - imageryLayers: collection, + imageryLayers: {}, camera: { moveEnd: { addEventListener: () => () => {} }, flyTo() {}, @@ -644,26 +616,20 @@ function globeViewer() { }, }; bindFakeCesiumCamera(viewer); - class Provider { - constructor(options) { - this.options = options; - this.tilingScheme = new GeographicTilingScheme(); - this.errorEvent = new Cesium.Event(); - } - requestImage() { - return undefined; - } - } - const cesium = { - ...createShellCesium(), - UrlTemplateImageryProvider: Provider, - GeographicTilingScheme, - Event: Cesium.Event, - Credit: Cesium.Credit, - Rectangle: Cesium.Rectangle, + const globe = fakeGlobePort(); + const owed = []; + const credits = { + addStatic(credit) { + const entry = { ...credit }; + owed.push(entry); + return () => owed.splice(owed.indexOf(entry), 1); + }, }; const options = { - cesium, + globeOf: () => globe, + creditsOf: () => credits, + cameraOf: () => null, + toBitmap: (canvas) => canvas, fetchImpl: async () => ({ ok: true, headers: new Headers(), @@ -677,7 +643,7 @@ function globeViewer() { for (let i = 0; i < 2; i++) for (const fn of [...listeners]) fn(); await flush(); }; - return { viewer, providers, options, settle }; + return { viewer, providers: globe.added, owed, options, settle }; } /** Show a frame of `manifest` and return the rendering and its globe. */ @@ -693,7 +659,8 @@ async function shownFrame(manifest) { return { ...globe, rendering }; } -const creditOf = (providers) => providers.at(-1).credit.html; +/** The credit the shown frame owes. */ +const creditOf = (h) => h.owed.at(-1)?.text; test('the imagery credit uses the source credit as plain text, else the built-in one', async () => { for (const product of ['radar', 'lightning', 'clouds-regional', 'clouds']) { @@ -703,7 +670,7 @@ test('the imagery credit uses the source credit as plain text, else the built-in product, ...(display ? { display } : {}), }); - assert.equal(creditOf(h.providers), BUILT_IN[product].credit, product); + assert.equal(creditOf(h), BUILT_IN[product].credit, product); h.rendering.clear(); } const h = await shownFrame({ @@ -712,8 +679,9 @@ test('the imagery credit uses the source credit as plain text, else the built-in display: { credit: 'Example & partners' }, }); assert.equal( - creditOf(h.providers), - 'Example <network> & partners', + creditOf(h), + 'Example & partners', + 'plain text: the credits port escapes it', ); h.rendering.clear(); } @@ -726,7 +694,7 @@ test('a refreshed manifest updates the credit of the frame already shown', async product, display: { credit: 'First credit' }, }); - assert.equal(creditOf(h.providers), 'First credit'); + assert.equal(creditOf(h), 'First credit'); const again = (display) => h.rendering.setFrame( { ...base, product, ...(display ? { display } : {}) }, @@ -734,22 +702,22 @@ test('a refreshed manifest updates the credit of the frame already shown', async ); assert.equal(await again({ credit: 'Second credit' }), true); assert.equal(h.providers.length, 1, 'the frame is not restaged'); - assert.equal(creditOf(h.providers), 'Second credit'); + assert.equal(creditOf(h), 'Second credit'); assert.equal(await again(), true); - assert.equal(creditOf(h.providers), BUILT_IN[product].credit); + assert.equal(creditOf(h), BUILT_IN[product].credit); h.rendering.updateSnapshot({ ...base, product, display: { credit: 'Third credit' }, }); - assert.equal(creditOf(h.providers), 'Third credit'); + assert.equal(creditOf(h), 'Third credit'); // Another product's manifest leaves this frame alone. h.rendering.updateSnapshot({ ...base, product: 'radar', display: { credit: 'Other' }, }); - assert.equal(creditOf(h.providers), 'Third credit'); + assert.equal(creditOf(h), 'Third credit'); h.rendering.clear(); } }); @@ -790,7 +758,7 @@ test('a refreshed manifest leaves the shown snapshot for a host switch to restag display: { credit: 'Second credit' }, }; rendering.updateSnapshot(refreshed); - assert.equal(creditOf(globe.providers), 'Second credit'); + assert.equal(creditOf(globe), 'Second credit'); host = { collection: {}, kind: 'tileset' }; assert.equal(rendering.rehome(), true); await flush(); @@ -799,15 +767,12 @@ test('a refreshed manifest leaves the shown snapshot for a host switch to restag assert.equal(rendering.rehome(), true); await globe.settle(); assert.equal(globe.providers.length, 2); - const { west, south, east, north } = first.bounds; - assert.ok( - Cesium.Rectangle.equals( - globe.providers.at(-1).options.rectangle, - Cesium.Rectangle.fromDegrees(west, south, east, north), - ), + assert.deepEqual( + globe.providers.at(-1).spec.rectangle, + first.bounds, 'the restaged frame keeps the bounds it was staged from', ); - assert.equal(creditOf(globe.providers), 'Second credit'); + assert.equal(creditOf(globe), 'Second credit'); rendering.clear(); }); @@ -847,7 +812,7 @@ test('a refresh during a host-switch restage keeps the newest credit', async () rendering.updateSnapshot({ ...first, display: { credit: 'Third credit' } }); await globe.settle(); assert.equal(globe.providers.length, 2); - assert.equal(creditOf(globe.providers), 'Third credit'); + assert.equal(creditOf(globe), 'Third credit'); rendering.clear(); }); @@ -879,7 +844,7 @@ test('a refresh while a frame loads survives a later host switch', async () => { rendering.updateSnapshot({ ...first, display: { credit: 'Second credit' } }); await globe.settle(); assert.equal(await shown, true); - assert.equal(creditOf(globe.providers), 'Second credit'); + assert.equal(creditOf(globe), 'Second credit'); host = { collection: {}, kind: 'tileset' }; assert.equal(rendering.rehome(), true); await flush(); @@ -887,7 +852,7 @@ test('a refresh while a frame loads survives a later host switch', async () => { assert.equal(rendering.rehome(), true); await globe.settle(); assert.equal(globe.providers.length, 2); - assert.equal(creditOf(globe.providers), 'Second credit'); + assert.equal(creditOf(globe), 'Second credit'); rendering.clear(); }); @@ -906,7 +871,7 @@ test('a refresh before a frame is installed gives it the newest credit', async ( }); await globe.settle(); assert.equal(await shown, true); - assert.equal(creditOf(globe.providers), 'Second credit', product); + assert.equal(creditOf(globe), 'Second credit', product); rendering.clear(); } }); @@ -933,13 +898,13 @@ test('a layer refresh with the same latest frame updates the imagery credit', as const first = layer.update(); await globe.settle(); await first; - assert.equal(creditOf(globe.providers), 'First credit'); + assert.equal(creditOf(globe), 'First credit'); manifest = { ...manifest, display: { credit: 'Second credit' } }; await layer.update(); assert.equal(globe.providers.length, 1, 'the frame is not restaged'); - assert.equal(creditOf(globe.providers), 'Second credit'); + assert.equal(creditOf(globe), 'Second credit'); manifest = { ...base, product: 'lightning' }; await layer.update(); - assert.equal(creditOf(globe.providers), BUILT_IN.lightning.credit); + assert.equal(creditOf(globe), BUILT_IN.lightning.credit); layer.destroy(); }); diff --git a/src/layers/weather/imageryOrder.js b/src/layers/weather/imageryOrder.js index 49e1dea77..dc65fd47e 100644 --- a/src/layers/weather/imageryOrder.js +++ b/src/layers/weather/imageryOrder.js @@ -1,17 +1,12 @@ -const priorities = new WeakMap(); - -/** Scalar context, infrared, radar, then lightning: independent of enable order. */ -export function orderWeatherImagery(collection, layer, priority) { - priorities.set(layer, priority); - if (typeof collection.raiseToTop !== 'function') return; - const weather = []; - for (let i = 0; i < collection.length; i++) { - const item = collection.get(i); - if (priorities.has(item)) weather.push(item); - } - const ordered = [...weather].sort( - (a, b) => priorities.get(a) - priorities.get(b), - ); - if (weather.every((item, i) => item === ordered[i])) return; - for (const item of ordered) collection.raiseToTop(item); -} +/** + * Draw order of the weather imagery through the globe port: scalar context + * (wind), infrared, radar, then lightning, independent of enable order, and + * above the port's other layers (zOrder 0). + */ +export const WEATHER_IMAGERY_Z = Object.freeze({ + wind: 1, + clouds: 2, + 'clouds-regional': 2, + radar: 3, + lightning: 4, +}); diff --git a/src/layers/weather/imageryOrder.test.mjs b/src/layers/weather/imageryOrder.test.mjs index dcf0edb79..bd90679ee 100644 --- a/src/layers/weather/imageryOrder.test.mjs +++ b/src/layers/weather/imageryOrder.test.mjs @@ -1,72 +1,28 @@ import test from 'node:test'; import assert from 'node:assert/strict'; -import { orderWeatherImagery } from './imageryOrder.js'; +import { WEATHER_IMAGERY_Z } from './imageryOrder.js'; +import { fakeGlobePort } from '../../testSupport/fakeGlobePort.mjs'; -test('weather compositing remains consistent when scalar, observation and history arrive out of order', () => { - const base = { name: 'basemap' }, - radar = { name: 'radar' }, - cloud = { name: 'cloud' }, - wind = { name: 'wind' }, - lightning = { name: 'lightning' }; - const items = [base]; - const collection = { - get length() { - return items.length; - }, - get: (i) => items[i], - raiseToTop(layer) { - items.push(...items.splice(items.indexOf(layer), 1)); - }, - }; - for (const [layer, priority] of [ - [radar, 2], - [cloud, 1], - [lightning, 3], - [wind, 0], - ]) { - items.push(layer); - orderWeatherImagery(collection, layer, priority); - } - assert.deepEqual(items, [base, wind, cloud, radar, lightning]); - const next = { name: 'new radar history frame' }; - items.push(next); - orderWeatherImagery(collection, next, 2); - assert.deepEqual(items, [base, wind, cloud, radar, next, lightning]); -}); - -test('tileset imagery collection preserves scalar, infrared, radar and lightning order', async () => { - const { ImageryLayerCollection, ImageryLayer } = await import('cesium'); - const tileset = { imageryLayers: new ImageryLayerCollection() }; - const layers = Array.from({ length: 4 }, () => new ImageryLayer()); - for (const priority of [3, 2, 0, 1]) { - tileset.imageryLayers.add(layers[priority]); - orderWeatherImagery(tileset.imageryLayers, layers[priority], priority); - } - assert.deepEqual( - layers.map((_, i) => tileset.imageryLayers.get(i)), - layers, - ); - tileset.imageryLayers.destroy(); -}); - -test('already ordered imagery adds and repeated ordering cause no collection churn', () => { - const items = []; - let raises = 0; - const collection = { - get length() { - return items.length; - }, - get: (i) => items[i], - raiseToTop(layer) { - raises++; - items.push(...items.splice(items.indexOf(layer), 1)); - }, - }; - for (const priority of [0, 1, 1, 2, 3]) { - const layer = {}; - items.push(layer); - orderWeatherImagery(collection, layer, priority); - orderWeatherImagery(collection, layer, priority); - } - assert.equal(raises, 0); +test('wind, infrared, radar, then lightning, above zOrder 0, whatever the enable order', () => { + const globe = fakeGlobePort(); + const add = (name) => + globe.imagery.add({ + kind: 'xyz', + url: `https://${name}.invalid/{z}/{x}/{y}`, + zOrder: WEATHER_IMAGERY_Z[name], + }); + const lightning = add('lightning'); + const overlay = globe.imagery.add({ kind: 'xyz', url: 'https://o.invalid' }); + const radar = add('radar'); + const wind = add('wind'); + const clouds = add('clouds'); + const regional = add('clouds-regional'); + assert.deepEqual(globe.layers, [ + overlay, + wind, + clouds, + regional, + radar, + lightning, + ]); }); diff --git a/src/layers/weather/index.js b/src/layers/weather/index.js index 65b154848..f43d6b177 100644 --- a/src/layers/weather/index.js +++ b/src/layers/weather/index.js @@ -1,5 +1,6 @@ import * as Cesium from 'cesium'; import { createWeatherRendering } from './rendering.js'; +import { createWeatherShell } from './shellRendering.js'; import { imageryHostStatus } from './imageryHost.js'; import { weatherDisplay, insideExtent } from './display.js'; import { @@ -284,7 +285,7 @@ export function createWeatherLayer({ viewer = nextViewer; rendering = createRendering({ viewer, - cesium, + createShell: (options) => createWeatherShell({ ...options, cesium }), getHost, onChange: notify, }); diff --git a/src/layers/weather/rasterTiles.js b/src/layers/weather/rasterTiles.js index cba2b7a0c..1c4c78bda 100644 --- a/src/layers/weather/rasterTiles.js +++ b/src/layers/weather/rasterTiles.js @@ -1,50 +1,29 @@ -/** Tile a bounded decoded canvas without network requests or scene state. */ -export function createRasterTileProvider({ - cesium, - texture, - credit, - createCanvas, - rectangle = cesium.Rectangle.MAX_VALUE, - tilingScheme = new cesium.GeographicTilingScheme({ rectangle }), - maximumLevel = 2, - tileSize = 256, -}) { - return { - tilingScheme, - rectangle, - tileWidth: tileSize, - tileHeight: tileSize, - minimumLevel: 0, - maximumLevel, - ready: true, - tileDiscardPolicy: undefined, - credit, - errorEvent: new cesium.Event(), - hasAlphaChannel: true, - getTileCredits: () => undefined, - pickFeatures: () => undefined, - requestImage(x, y, level) { - const tile = createCanvas(); - tile.width = tile.height = tileSize; - const ctx = tile.getContext('2d'); - const width = - texture.width / tilingScheme.getNumberOfXTilesAtLevel(level); - const height = - texture.height / tilingScheme.getNumberOfYTilesAtLevel(level); - ctx.imageSmoothingEnabled = true; - ctx.drawImage( - texture, - x * width, - y * height, - width, - height, - 0, - 0, - tileSize, - tileSize, - ); - // ImageryLayer consumes requestImage results as promises. - return Promise.resolve(tile); - }, - }; +/** + * Draw one tile of the geographic scheme (two level-zero tiles) from a + * decoded mosaic covering `bounds` (degrees), without network requests or + * scene state. The part of a tile outside the mosaic stays transparent. + * @param {CanvasImageSource & {width: number, height: number}} texture + * @param {{west: number, south: number, east: number, north: number}} bounds + * @param {{x: number, y: number, level: number}} tile + * @param {HTMLCanvasElement} canvas Sized to the tile. + */ +export function drawMosaicTile(texture, bounds, { x, y, level }, canvas) { + const size = 180 / 2 ** level; + const west = -180 + x * size; + const north = 90 - y * size; + const perLon = texture.width / (bounds.east - bounds.west); + const perLat = texture.height / (bounds.north - bounds.south); + const ctx = canvas.getContext('2d'); + ctx.imageSmoothingEnabled = true; + ctx.drawImage( + texture, + (west - bounds.west) * perLon, + (bounds.north - north) * perLat, + size * perLon, + size * perLat, + 0, + 0, + canvas.width, + canvas.height, + ); } diff --git a/src/layers/weather/rasterTiles.test.mjs b/src/layers/weather/rasterTiles.test.mjs index 5efcf11c0..20eb1b984 100644 --- a/src/layers/weather/rasterTiles.test.mjs +++ b/src/layers/weather/rasterTiles.test.mjs @@ -1,7 +1,6 @@ import test from 'node:test'; import assert from 'node:assert/strict'; -import * as Cesium from 'cesium'; -import { createRasterTileProvider } from './rasterTiles.js'; +import { drawMosaicTile } from './rasterTiles.js'; import { createFieldRaster } from '../wind/fields.js'; // A small canvas double exposes the uploaded raster and exact drawImage crop. @@ -31,7 +30,17 @@ function createCanvas() { return canvas; } -test('real Cesium geographic provider crops level 0/1 tiles from a decoded canvas with preserved pixels', async () => { +/** A tile canvas of `size`, drawn by `drawMosaicTile`. */ +function drawTile(texture, bounds, tile, size = 256) { + const canvas = createCanvas(); + canvas.width = canvas.height = size; + drawMosaicTile(texture, bounds, tile, canvas); + return canvas; +} + +const WORLD = { west: -180, south: -90, east: 180, north: 90 }; + +test('a world mosaic crops level 0/1 geographic tiles with preserved pixels', () => { const raster = createFieldRaster( { nx: 8, @@ -50,42 +59,18 @@ test('real Cesium geographic provider crops level 0/1 tiles from a decoded canva 720, 362, ); - const credit = new Cesium.Credit('NOAA GFS'); const texture = { width: raster.width, height: raster.height, rgba: raster.rgba, }; - const provider = createRasterTileProvider({ - cesium: Cesium, - texture, - credit, - createCanvas, - }); - assert.ok(provider.tilingScheme instanceof Cesium.GeographicTilingScheme); - assert.equal(provider.rectangle, Cesium.Rectangle.MAX_VALUE); - assert.equal(provider.minimumLevel, 0); - assert.equal(provider.maximumLevel, 2); - assert.equal(provider.tileWidth, 256); - assert.equal(provider.tileHeight, 256); - assert.equal(provider.ready, true); - assert.equal(provider.hasAlphaChannel, true); - assert.equal(provider.credit, credit); - assert.ok(provider.errorEvent instanceof Cesium.Event); - assert.equal(provider.tileDiscardPolicy, undefined); - assert.equal(provider.getTileCredits(0, 0, 0), undefined); - assert.equal(provider.pickFeatures(0, 0, 0, 0, 0), undefined); for (const [x, y, level, crop, cell] of [ [0, 0, 0, [0, 0, 360, 362, 0, 0, 256, 256], [90, 91]], [1, 0, 0, [360, 0, 360, 362, 0, 0, 256, 256], [450, 91]], [0, 0, 1, [0, 0, 180, 181, 0, 0, 256, 256], [45, 45]], [3, 1, 1, [540, 181, 180, 181, 0, 0, 256, 256], [585, 226]], ]) { - const pending = provider.requestImage(x, y, level); - assert.ok(pending instanceof Promise, 'ImageryLayer consumes a promise'); - const tile = await pending; - assert.equal(tile.width, 256); - assert.equal(tile.height, 256); + const tile = drawTile(texture, WORLD, { x, y, level }); assert.equal(tile.getContext('2d').imageSmoothingEnabled, true); assert.deepEqual(tile.crop, crop); const offset = (cell[1] * 720 + cell[0]) * 4; @@ -96,60 +81,29 @@ test('real Cesium geographic provider crops level 0/1 tiles from a decoded canva } }); -test('bounded decoded mosaic crops both roots and higher levels without resampling its extent', async () => { +test('a bounded mosaic maps each tile by degrees; outside it stays clear', () => { const texture = { width: 2048, height: 1024 }; - const rectangle = Cesium.Rectangle.fromDegrees(-180, -60, 180, 60); - const scheme = new Cesium.GeographicTilingScheme({ - rectangle, - numberOfLevelZeroTilesX: 2, - numberOfLevelZeroTilesY: 1, - }); - const credit = new Cesium.Credit('NOAA'); - const provider = createRasterTileProvider({ - cesium: Cesium, - texture, - rectangle, - tilingScheme: scheme, - maximumLevel: 3, - credit, - createCanvas, - }); - assert.equal(provider.rectangle, rectangle); - assert.equal(provider.maximumLevel, 3); - assert.equal(provider.credit, credit); - assert.equal(provider.hasAlphaChannel, true); + const bounds = { west: -180, south: -60, east: 180, north: 60 }; for (const [x, y, level, crop] of [ - [0, 0, 0, [0, 0, 1024, 1024, 0, 0, 256, 256]], - [1, 0, 0, [1024, 0, 1024, 1024, 0, 0, 256, 256]], - [7, 3, 2, [1792, 768, 256, 256, 0, 0, 256, 256]], + // 180° square tiles reach past the mosaic's 60° edges. + [0, 0, 0, [0, -256, 1024, 1536, 0, 0, 256, 256]], + [1, 0, 0, [1024, -256, 1024, 1536, 0, 0, 256, 256]], + [7, 1, 2, [1792, 128, 256, 384, 0, 0, 256, 256]], ]) { - const pending = provider.requestImage(x, y, level); - assert.ok(pending instanceof Promise); - const tile = await pending; + const tile = drawTile(texture, bounds, { x, y, level }); assert.equal(tile.source, texture); assert.deepEqual(tile.crop, crop); } }); -test('512-pixel crops preserve source extent at root and clamped draping levels', async () => { +test('512-pixel tiles preserve the source extent at every level', () => { const texture = { width: 2048, height: 1024 }; - const provider = createRasterTileProvider({ - cesium: Cesium, - texture, - createCanvas, - tileSize: 512, - maximumLevel: 3, - }); - assert.equal(provider.tileWidth, 512); - assert.equal(provider.tileHeight, 512); for (const [x, y, level, crop] of [ [0, 0, 0, [0, 0, 1024, 1024, 0, 0, 512, 512]], [3, 1, 1, [1536, 512, 512, 512, 0, 0, 512, 512]], [7, 3, 2, [1792, 768, 256, 256, 0, 0, 512, 512]], ]) { - const tile = await provider.requestImage(x, y, level); - assert.equal(tile.width, 512); - assert.equal(tile.height, 512); + const tile = drawTile(texture, WORLD, { x, y, level }, 512); assert.equal(tile.source, texture); assert.deepEqual(tile.crop, crop); } diff --git a/src/layers/weather/rendering.js b/src/layers/weather/rendering.js index 9dc7deab0..d66d19ab6 100644 --- a/src/layers/weather/rendering.js +++ b/src/layers/weather/rendering.js @@ -1,11 +1,10 @@ import { weatherTileUrl } from './source.js'; -import { orderWeatherImagery } from './imageryOrder.js'; +import { WEATHER_IMAGERY_Z } from './imageryOrder.js'; import { imageryHostStatus } from './imageryHost.js'; -import { createRasterTileProvider } from './rasterTiles.js'; -import { withTileRequestHook } from '../../render/cesium/tileRequests.js'; -import { createWeatherShell } from './shellRendering.js'; -import { weatherDisplay, escapeCreditText } from './display.js'; +import { drawMosaicTile } from './rasterTiles.js'; +import { weatherDisplay } from './display.js'; import { msg } from '../../i18n/index.js'; +import { findCamera, findCredits, findGlobe } from '../../render/rendererOf.js'; import { readResponseBytesCapped } from '../../sources/httpBody.js'; import { acquireInfraredMosaic, @@ -19,11 +18,49 @@ const MAX_PREFETCH_TILES = 8; // How often a staged frame waiting out its quiet interval rechecks readiness. export const READY_WAKE_MS = 150; -/** Globe imagery: own at most a displayed and a staging frame. Use native Cesium - * tile scheduling, projection and texture disposal; the application clock is never touched. */ +/** + * A degrees rectangle's overlap with another, or null; either may cross the + * antimeridian (`west > east`), as a view rectangle can. + */ +export function rectangleOverlap(a, b) { + let aEast = a.east; + let aWest = a.west; + let bEast = b.east; + let bWest = b.west; + if (aEast < aWest && bEast > 0) aEast += 360; + else if (bEast < bWest && aEast > 0) bEast += 360; + if (aEast < aWest && bWest < 0) bWest += 360; + else if (bEast < bWest && aWest < 0) aWest += 360; + const wrap = (lon) => + lon >= -180 && lon <= 180 ? lon : ((((lon + 180) % 360) + 360) % 360) - 180; + const west = wrap(Math.max(aWest, bWest)); + const east = wrap(Math.min(aEast, bEast)); + if ((a.west < a.east || b.west < b.east) && east <= west) return null; + const south = Math.max(a.south, b.south); + const north = Math.min(a.north, b.north); + if (south >= north) return null; + return { west, south, east, north }; +} + +/** A tile of the geographic scheme (two level-zero tiles), in degrees. */ +export function geographicTile(x, y, level) { + const size = 180 / 2 ** level; + const west = -180 + x * size; + const north = 90 - y * size; + return { west, south: north - size, east: west + size, north }; +} + +/** HTTP statuses a weather tile is fetched again for, rather than failing. */ +const RETRY_STATUSES = [429, 503]; + +/** Globe imagery through the renderer's globe port: own at most a displayed + * and a staging frame; the application clock is never touched. */ function createGlobeRendering({ viewer, - cesium, + globeOf, + cameraOf, + creditsOf, + toBitmap, getHost, onChange, timeoutMs, @@ -84,30 +121,18 @@ function createGlobeRendering({ } function prefetchTiles(snapshot, time) { - const { west, south, east, north } = snapshot.bounds; - const bounds = cesium.Rectangle.fromDegrees(west, south, east, north); - const view = viewer.camera?.computeViewRectangle?.( - viewer.scene.globe?.ellipsoid, - ); - const coverage = view - ? cesium.Rectangle.intersection(bounds, view) - : bounds; + const bounds = snapshot.bounds; + const view = cameraOf(viewer)?.viewRectangle?.(); + const coverage = view ? rectangleOverlap(bounds, view) : bounds; if (!coverage) return []; - const scheme = new cesium.GeographicTilingScheme(); const template = weatherTileUrl(snapshot.product, time, { size: profile(snapshot.product).tileSize, }); const urls = []; for (let z = 0; z <= 1; z++) { - for (let y = 0; y < scheme.getNumberOfYTilesAtLevel(z); y++) { - for (let x = 0; x < scheme.getNumberOfXTilesAtLevel(z); x++) { - if ( - !cesium.Rectangle.intersection( - coverage, - scheme.tileXYToRectangle(x, y, z), - ) - ) - continue; + for (let y = 0; y < 2 ** z; y++) { + for (let x = 0; x < 2 ** (z + 1); x++) { + if (!rectangleOverlap(coverage, geographicTile(x, y, z))) continue; urls.push( template.replace('{z}', z).replace('{x}', x).replace('{y}', y), ); @@ -121,17 +146,31 @@ function createGlobeRendering({ function creditText(snapshot) { const sourceCredit = weatherDisplay(snapshot).credit; return sourceCredit !== undefined - ? escapeCreditText(sourceCredit) + ? sourceCredit : snapshot.product === 'lightning' ? 'NOAA/NWS lightning density · derived from Vaisala NLDN/GLD360' : snapshot.product === 'radar' ? 'NOAA nowCOAST · NWS/OAR MRMS' : 'NOAA nowCOAST · NESDIS GOES / global satellite partners'; } + /** + * The frame's credit is owed while its layer is drawn (shown, even + * transparent while it stages), through the renderer's credits port. + */ + function syncCredit(frame) { + const text = + (!frame.closed && frame.layer?.show === true && frame.credit) || null; + if (frame.creditShown === text) return; + frame.offCredit?.(); + frame.offCredit = null; + frame.creditShown = text; + if (text) frame.offCredit = creditsOf(viewer)?.addStatic({ text }) ?? null; + } function setCredit(frame) { const text = creditText(frame.creditSnapshot ?? frame.snapshot); - if (frame.credit?.html === text) return false; - frame.credit = new cesium.Credit(text, false); + if (frame.credit === text) return false; + frame.credit = text; + if (frame.layer) syncCredit(frame); return true; } /** @@ -145,7 +184,7 @@ function createGlobeRendering({ for (const frame of new Set([current, incoming, ...retiring])) { if (!frame || frame.product !== snapshot.product) continue; frame.creditSnapshot = snapshot; - if (frame.credit && setCredit(frame)) changed = true; + if (frame.credit !== undefined && setCredit(frame)) changed = true; } if (changed) viewer.scene.requestRender(); } @@ -163,18 +202,9 @@ function createGlobeRendering({ frame.offCamera?.(); clearTimeout(frame.timeout); clearTimeout(frame.wake); - for (const request of frame.requests) request.cancel?.(); - frame.requests.clear(); - frame.retries.clear(); - if (!frame.layer) return; - const collection = frame.collection; - if ( - collection && - !collection.isDestroyed?.() && - collection.contains(frame.layer) - ) - collection.remove(frame.layer, true); - else if (!frame.layer.isDestroyed?.()) frame.layer.destroy?.(); + syncCredit(frame); + // Removing the layer cancels its tile requests in flight. + frame.layer?.remove(); } function cancelIncoming() { if (!incoming) return; @@ -183,13 +213,17 @@ function createGlobeRendering({ remove(previous); previous.resolve(false); } + /** + * Follow the host: a globe host draws the frame, any other hides it (the + * globe drapes nothing while hidden) and drops what was staging for it. + */ function rehome() { const host = getHost(); - const { collection } = host; + const { kind } = host; const hidden = frameHidden || imageryHostStatus(host) !== null; const changed = - (current && current.collection !== collection) || - (incoming && incoming.collection !== collection); + (current && current.kind !== kind) || + (incoming && incoming.kind !== kind); const visibilityChanged = current && current.layer.show === hidden; if (changed || imageryHostStatus(host) !== null) { cancelPrefetch(); @@ -199,14 +233,8 @@ function createGlobeRendering({ if (current) { if (!hidden && current.layer.alpha !== alpha) current.layer.alpha = alpha; if (visibilityChanged) current.layer.show = !hidden; - } - if (current && current.collection !== collection) { - current.collection?.remove(current.layer, false); - current.collection = collection; - if (collection) { - collection.add(current.layer); - orderWeatherImagery(collection, current.layer, current.priority); - } + current.kind = kind; + syncCredit(current); } if (changed || visibilityChanged) viewer.scene.requestRender(); return Boolean(changed || visibilityChanged); @@ -265,8 +293,10 @@ function createGlobeRendering({ rehome(); cancelIncoming(); const host = getHost(); - const { collection, kind } = host; + const { kind } = host; if (imageryHostStatus(host)) return false; + const globe = globeOf(viewer); + if (!globe) return false; const nextProfile = profile(snapshot.product); if ( current?.time === time && @@ -279,7 +309,7 @@ function createGlobeRendering({ } lastError = null; const { west, south, east, north } = snapshot.bounds; - const rectangle = cesium.Rectangle.fromDegrees(west, south, east, north); + const rectangle = { west, south, east, north }; const global = snapshot.product === 'clouds'; const frame = { snapshot, @@ -290,17 +320,8 @@ function createGlobeRendering({ ? { fetched: false, decodeMs: null, cached: false } : undefined, controller: new AbortController(), - collection, kind, - priority: - snapshot.product === 'lightning' - ? 3 - : snapshot.product === 'radar' - ? 2 - : 1, product: snapshot.product, - requests: new Set(), - retries: new Map(), deferred: new Set(), pending: 0, loaded: 0, @@ -332,6 +353,7 @@ function createGlobeRendering({ frame.loadMs = now() - frame.startedAt; frame.layer.alpha = alpha; frame.layer.show = !frameHidden; + syncCredit(frame); viewer.scene.requestRender(); if (previous) { retiring.add(previous); @@ -375,103 +397,83 @@ function createGlobeRendering({ viewer.scene.requestRender(); return; } - const tilingScheme = new cesium.GeographicTilingScheme( - global - ? { - rectangle, - numberOfLevelZeroTilesX: 2, - numberOfLevelZeroTilesY: 1, - } - : undefined, - ); setCredit(frame); - const credit = frame.credit; - const source = global - ? createRasterTileProvider({ - cesium, - texture, - rectangle, - tilingScheme, - maximumLevel: GLOBAL_TILE_MAXIMUM_LEVEL, - tileSize: nextProfile.tileSize, - credit, - createCanvas, - }) - : new cesium.UrlTemplateImageryProvider({ - url: weatherTileUrl(snapshot.product, time, { - size: nextProfile.tileSize, - }), - tilingScheme, - rectangle, - tileWidth: nextProfile.tileSize, - tileHeight: nextProfile.tileSize, - maximumLevel: nextProfile.maximumLevel, - enablePickFeatures: false, - credit, - }); - const provider = withTileRequestHook(source, { - // Cesium reads a provider's credit every frame; a refreshed manifest - // can replace it without restaging the imagery. - credit: () => frame.credit, - requestImage: ({ x, y, level, request }, issue) => { - if (frame.closed) return undefined; - const result = issue(); - const tileKey = `${level}/${x}/${y}`; - if (!result) { - // Scheduler admission is part of readiness, not a successful tile. - frame.deferred.add(tileKey); - frame.lastActivity = now(); - return result; - } - frame.deferred.delete(tileKey); - frame.pending++; + const tileSize = nextProfile.tileSize; + /** Readiness accounting: each own tile the renderer issues or defers. */ + const admit = (tile, issue) => { + if (frame.closed) return undefined; + const result = issue(); + const tileKey = `${tile.level}/${tile.x}/${tile.y}`; + if (!result) { + // Scheduler admission is part of readiness, not a successful tile. + frame.deferred.add(tileKey); frame.lastActivity = now(); - if (request) frame.requests.add(request); - return Promise.resolve(result) - .then((image) => { - // Cesium decodes tiles as ImageBitmaps already flipped, since WebGL - // ignores UNPACK_FLIP_Y for them; a canvas upload flips again. - if (!frame.closed && snapshot.product === 'clouds-regional') - image = processInfraredImage(image, infrared, createCanvas, { - flipY: - typeof ImageBitmap !== 'undefined' && - image instanceof ImageBitmap, - }); - frame.retries.delete(tileKey); - frame.loaded++; - return image; - }) - .finally(() => { - frame.pending--; - frame.lastActivity = now(); - frame.requests.delete(request); - if (!frame.closed) viewer.scene.requestRender(); - }); - }, - }); - frame.offError = provider.errorEvent.addEventListener((error) => { - if (frame.closed) return; - const status = error?.error?.statusCode; - // Cesium retries synchronously after this event; no delay hook is exposed. - const tileKey = `${error.level}/${error.x}/${error.y}`; - const retries = frame.retries.get(tileKey) ?? 0; - error.retry = false; - if ((status === 429 || status === 503) && retries < 3) { - frame.retries.set(tileKey, retries + 1); - error.retry = true; - return; + return result; } + frame.deferred.delete(tileKey); + frame.pending++; + frame.lastActivity = now(); + return Promise.resolve(result) + .then((image) => { + frame.loaded++; + return image; + }) + .finally(() => { + frame.pending--; + frame.lastActivity = now(); + if (!frame.closed) viewer.scene.requestRender(); + }); + }; + const spec = global + ? { + kind: 'canvas', + tiling: 'geographic', + rectangle, + maxLevel: GLOBAL_TILE_MAXIMUM_LEVEL, + tileSize, + drawTile: (tile, canvas) => + drawMosaicTile(texture, rectangle, tile, canvas), + admit, + zOrder: WEATHER_IMAGERY_Z[snapshot.product], + } + : { + kind: 'xyz', + url: weatherTileUrl(snapshot.product, time, { size: tileSize }), + tiling: 'geographic', + rectangle, + tileSize, + maxLevel: nextProfile.maximumLevel, + retryStatuses: RETRY_STATUSES, + admit, + ...(snapshot.product === 'clouds-regional' + ? { + // The transfer runs on the upright tile the renderer + // decoded. + // Closed frames do not process late images. + tileTransform: (_tile, image) => + frame.closed + ? image + : toBitmap( + processInfraredImage(image, infrared, createCanvas), + ), + } + : {}), + zOrder: WEATHER_IMAGERY_Z[snapshot.product], + }; + // A shown, transparent layer lets the renderer request staging tiles + // while the last complete observation stays visible underneath it. + frame.layer = globe.imagery.add(spec); + frame.layer.drapeOn = 'surface'; + frame.layer.alpha = 0; + syncCredit(frame); + frame.offError = frame.layer.on('tileError', () => { + if (frame.closed) return; frame.failed = true; lastError = msg('Some weather tiles unavailable'); onChange(); }); - // A shown, transparent layer lets Cesium request staging tiles while the last - // complete observation stays visible underneath it. - frame.layer = collection.addImageryProvider(provider); - frame.layer.alpha = 0; - orderWeatherImagery(collection, frame.layer, frame.priority); let settled = 0; - frame.offCamera = viewer.camera?.moveEnd?.addEventListener(() => { + frame.offCamera = cameraOf(viewer)?.on('moveEnd', () => { // Tiles abandoned by a previous viewport are no longer admission work. frame.deferred.clear(); frame.lastActivity = now(); @@ -488,7 +490,7 @@ function createGlobeRendering({ frame.deferred.size === 0 && now() - frame.lastActivity >= 200; if ( - ((frame.kind === 'globe' && viewer.scene.globe.tilesLoaded) || + ((frame.kind === 'globe' && globe.isSettled('imagery')) || ownReady) && frame.pending === 0 ) { @@ -586,7 +588,12 @@ function createGlobeRendering({ * A host switch tears one renderer down and restages the last frame on the other. */ export function createWeatherRendering({ viewer, - cesium, + createShell, + globeOf = findGlobe, + cameraOf = findCamera, + creditsOf = findCredits, + toBitmap = (canvas) => + globalThis.createImageBitmap(canvas, { premultiplyAlpha: 'none' }), getHost = () => ({ collection: viewer.imageryLayers, kind: 'globe' }), onChange = () => {}, timeoutMs = 25_000, @@ -594,11 +601,9 @@ export function createWeatherRendering({ fetchImpl = (...args) => globalThis.fetch(...args), decodeImage, createCanvas = () => document.createElement('canvas'), - createShell = createWeatherShell, }) { const shared = { viewer, - cesium, getHost, onChange, timeoutMs, @@ -607,7 +612,13 @@ export function createWeatherRendering({ decodeImage, createCanvas, }; - const globe = createGlobeRendering(shared); + const globe = createGlobeRendering({ + ...shared, + globeOf, + cameraOf, + creditsOf, + toBitmap, + }); let shell = null; let active = null; let alpha = 0.7; diff --git a/src/layers/weather/weather.test.mjs b/src/layers/weather/weather.test.mjs index f65298e04..8381fbe66 100644 --- a/src/layers/weather/weather.test.mjs +++ b/src/layers/weather/weather.test.mjs @@ -6,7 +6,10 @@ import { createWeatherClock } from './clock.js'; import * as Cesium from 'cesium'; import { Color, ImageryLayerCollection, GeographicTilingScheme } from 'cesium'; import { NO_IMAGERY_HOST } from './imageryHost.js'; -import { orderWeatherImagery } from './imageryOrder.js'; +import { createWeatherShell } from './shellRendering.js'; +import { WEATHER_IMAGERY_Z } from './imageryOrder.js'; +import { fakeGlobePort } from '../../testSupport/fakeGlobePort.mjs'; +import { createCesiumGlobe } from '../../render/cesium/globe.js'; import { createShellCesium, createShellScene, @@ -95,74 +98,99 @@ const mockResponse = () => ({ headers: new Headers(), arrayBuffer: async () => new ArrayBuffer(1), }); +/** A camera port over a fake viewer's Cesium-shaped camera. */ +const cameraOver = (viewer) => + viewer.camera && { + on: (event, cb) => + event === 'moveEnd' + ? viewer.camera.moveEnd?.addEventListener(cb) + : () => {}, + viewRectangle() { + const rect = viewer.camera.computeViewRectangle?.(); + if (!rect) return null; + const deg = Cesium.Math.toDegrees; + return { + west: deg(rect.west), + south: deg(rect.south), + east: deg(rect.east), + north: deg(rect.north), + }; + }, + }; + +/** A credits port recording what is owed now. */ +function fakeCredits() { + const owed = []; + return { + owed, + addStatic(credit) { + const entry = { ...credit }; + owed.push(entry); + return () => { + const i = owed.indexOf(entry); + if (i >= 0) owed.splice(i, 1); + }; + }, + list: () => owed.slice(), + on: () => () => {}, + }; +} + +/** + * Each layer added through the globe port, as a test drives it: `spec`, + * the tile it answers with (`response`), `requestImage` through the + * layer's hooks, and tile errors through `errorEvent.emit`. + */ +function layerDriver(layer, createCanvas) { + const box = { response: null, requestArgs: undefined }; + return { + layer, + spec: layer.spec, + box, + get response() { + return box.response; + }, + set response(value) { + box.response = value; + }, + get requestArgs() { + return box.requestArgs; + }, + requestImage(x, y, level, request) { + const tile = { x, y, level }; + return layer.request(tile, () => { + box.requestArgs = [x, y, level, request]; + if (layer.spec.kind === 'canvas') { + const canvas = createCanvas(); + canvas.width = canvas.height = layer.spec.tileSize; + layer.spec.drawTile(tile, canvas); + return Promise.resolve(canvas); + } + return box.response?.promise; + }); + }, + errorEvent: { + get size() { + return layer.listenerCount('tileError'); + }, + emit(error) { + const status = error?.error?.statusCode; + layer.fail({ + tile: { x: error.x, y: error.y, level: error.level }, + ...(Number.isFinite(status) ? { status } : {}), + }); + }, + }, + }; +} + function renderingHarness(options = {}) { - const layers = []; const providers = []; const postRender = event(); let renderRequests = 0; - // `providers` lists what Cesium is handed, in order. The layer may hand it - // a hook over this provider, so per-test state lives in one box both see. - class Provider { - constructor(options) { - this.options = options; - this.tilingScheme = new GeographicTilingScheme(); - this.errorEvent = event(); - this.box = { response: null, requestArgs: undefined }; - } - get response() { - return this.box.response; - } - set response(value) { - this.box.response = value; - } - get requestArgs() { - return this.box.requestArgs; - } - requestImage(...args) { - this.box.requestArgs = args; - return this.response?.promise; - } - } - const collection = { - add(layer) { - layers.push(layer); - return layer; - }, - addImageryProvider(provider) { - if (!providers.includes(provider)) providers.push(provider); - const layer = { imageryProvider: provider, alpha: 1, show: true }; - layers.push(layer); - return layer; - }, - contains(layer) { - return layers.includes(layer); - }, - remove(layer, destroy) { - const index = layers.indexOf(layer); - if (index < 0) return false; - layers.splice(index, 1); - layer.destroyed = destroy; - return true; - }, - get length() { - return layers.length; - }, - get(index) { - return layers[index]; - }, - lower(layer) { - const i = layers.indexOf(layer); - if (i > 0) [layers[i - 1], layers[i]] = [layers[i], layers[i - 1]]; - }, - raiseToTop(layer) { - const i = layers.indexOf(layer); - if (i >= 0) layers.push(...layers.splice(i, 1)); - }, - isDestroyed: () => false, - }; const viewer = { clock: { untouched: true }, - imageryLayers: collection, + imageryLayers: { isDestroyed: () => false }, scene: { postRender, primitives: createShellScene().primitives, @@ -172,10 +200,20 @@ function renderingHarness(options = {}) { }, }, }; + const globe = fakeGlobePort({ + settled: () => viewer.scene.globe.tilesLoaded, + }); + const createCanvas = options.createCanvas ?? mockCanvas; + const add = globe.imagery.add; + globe.imagery.add = (spec, index) => { + const layer = add(spec, index); + providers.push(layerDriver(layer, createCanvas)); + return layer; + }; + const credits = fakeCredits(); const cesium = { ...createShellCesium(), Color, - UrlTemplateImageryProvider: Provider, GeographicTilingScheme, Event: Cesium.Event, Credit: Cesium.Credit, @@ -183,10 +221,15 @@ function renderingHarness(options = {}) { }; const rendering = createWeatherRendering({ viewer, - cesium, + globeOf: () => globe, + cameraOf: cameraOver, + creditsOf: () => credits, + toBitmap: (canvas) => canvas, + createShell: (shellOptions) => + createWeatherShell({ ...shellOptions, cesium }), fetchImpl: async () => mockResponse(), decodeImage: async () => ({ width: 2048, height: 1024, close() {} }), - createCanvas: mockCanvas, + createCanvas, ...options, }); const settle = () => { @@ -197,8 +240,10 @@ function renderingHarness(options = {}) { rendering, viewer, cesium, + globe, + credits, providers, - layers, + layers: globe.layers, postRender, settle, shells: () => viewer.scene.primitives.items, @@ -412,10 +457,10 @@ test('weather stages invisibly, waits for pending tiles and render readiness, an 0.7, 'new layer is visible before retirement', ); - assert.equal(layer.destroyed, undefined); + assert.equal(layer.removed, false); h.postRender.emit(); assert.equal(h.layers.length, 1); - assert.equal(layer.destroyed, true); + assert.equal(layer.removed, true); assert.equal(h.providers[0].errorEvent.size, 0); assert.equal(h.rendering.getDiagnostics().time, times[1]); assert.deepEqual(h.viewer.clock, { untouched: true }); @@ -429,15 +474,14 @@ test('superseded stages cancel requests and cannot resurrect after a late tile r const tile = deferred(); const oldProvider = h.providers[0]; oldProvider.response = tile; - let cancellations = 0; - const requested = oldProvider.requestImage(0, 0, 0, { - cancel() { - cancellations++; - }, - }); + const requested = oldProvider.requestImage(0, 0, 0, {}); const second = h.rendering.setFrame(snapshot, times[1]); assert.equal(await first, false); - assert.equal(cancellations, 1); + assert.equal( + oldProvider.layer.removed, + true, + 'removing the layer cancels its requests in flight', + ); assert.equal(h.layers.length, 1); assert.equal(oldProvider.errorEvent.size, 0); tile.resolve({}); @@ -683,16 +727,15 @@ test('external abort cancels a staged renderer request and releases its observer }); const tile = deferred(); h.providers[0].response = tile; - let cancellations = 0; - const requested = h.providers[0].requestImage(0, 0, 0, { - cancel() { - cancellations++; - }, - }); + const requested = h.providers[0].requestImage(0, 0, 0, {}); const before = h.renders(); controller.abort(); assert.equal(await stage, false); - assert.equal(cancellations, 1); + assert.equal( + h.providers[0].layer.removed, + true, + 'removing the layer cancels its requests in flight', + ); assert.equal(h.layers.length, 0); assert.equal(h.postRender.size, 0); assert.equal(h.providers[0].errorEvent.size, 0); @@ -790,12 +833,12 @@ test('global infrared is acquired before staging and cropped from one processed }); decode.resolve({ width: 2048, height: 1024 }); await flush(); - const provider = h.layers[0].imageryProvider; - assert.equal(provider.maximumLevel, 3); - assert.equal(provider.tileWidth, 256); - assert.equal(provider.tileHeight, 256); - assert.equal(provider.tilingScheme.getNumberOfXTilesAtLevel(0), 2); - assert.deepEqual(provider.tilingScheme.rectangle, provider.rectangle); + const provider = h.providers[0]; + assert.equal(provider.spec.kind, 'canvas'); + assert.equal(provider.spec.maxLevel, 3); + assert.equal(provider.spec.tileSize, 256); + assert.equal(provider.spec.tiling, 'geographic'); + assert.deepEqual(provider.spec.rectangle, snapshot.bounds); const first = await provider.requestImage(0, 0, 0); const next = await provider.requestImage(1, 0, 0); assert.equal(first.source, next.source); @@ -909,7 +952,7 @@ test('history loading updates an existing info line and preserves summary status h.layer.destroy(); }); -test('no host cancels a globe stage, detaches the layer and restores it in weather order', async () => { +test('no host cancels a globe stage and hides the frame; weather keeps its order', async () => { let host; const h = renderingHarness({ getHost: () => host }); host = { collection: h.viewer.imageryLayers, kind: 'globe' }; @@ -917,25 +960,34 @@ test('no host cancels a globe stage, detaches the layer and restores it in weath h.settle(); assert.equal(await stage, true); const radar = h.layers[0]; - const cloud = h.viewer.imageryLayers.add({ name: 'cloud' }); - const lightning = h.viewer.imageryLayers.add({ name: 'lightning' }); - orderWeatherImagery(h.viewer.imageryLayers, lightning, 3); - orderWeatherImagery(h.viewer.imageryLayers, cloud, 1); + const other = (zOrder) => + h.globe.imagery.add({ kind: 'xyz', url: 'https://o.invalid', zOrder }); + const cloud = other(WEATHER_IMAGERY_Z.clouds); + const lightning = other(WEATHER_IMAGERY_Z.lightning); + const overlay = other(undefined); + assert.equal(radar.drapeOn, 'surface'); + assert.deepEqual(h.layers, [overlay, cloud, radar, lightning]); + assert.deepEqual(h.credits.owed, [{ text: 'NOAA nowCOAST · NWS/OAR MRMS' }]); const incoming = h.rendering.setFrame(snapshot, times[1]); host = { collection: null, kind: 'none' }; assert.equal(h.rendering.rehome(), true); assert.equal(await incoming, false); - assert.deepEqual(h.layers, [cloud, lightning]); + assert.deepEqual(h.layers, [overlay, cloud, radar, lightning]); + assert.equal(radar.show, false, 'nothing draws without a host'); + assert.deepEqual(h.credits.owed, [], 'nor is its credit owed'); assert.equal(await h.rendering.setFrame(snapshot, times[2]), false); assert.equal(h.rendering.getDiagnostics().error, NO_IMAGERY_HOST); assert.equal(h.rendering.getDiagnostics().time, times[0]); host = { collection: h.viewer.imageryLayers, kind: 'globe' }; h.rendering.rehome(); - assert.deepEqual(h.layers, [cloud, radar, lightning]); + assert.equal(radar.show, true); + assert.equal(h.credits.owed.length, 1); + assert.deepEqual(h.layers, [overlay, cloud, radar, lightning]); assert.equal(h.rendering.getDiagnostics().error, null); h.rendering.clear(); - assert.deepEqual(h.layers, [cloud, lightning]); - assert.equal(radar.destroyed, true); + assert.deepEqual(h.layers, [overlay, cloud, lightning]); + assert.equal(radar.removed, true); + assert.deepEqual(h.credits.owed, []); }); const shellDecode = async () => ({ width: 4096, height: 2048, close() {} }); @@ -1054,7 +1106,7 @@ test('host switches tear one renderer down and restage the retained frame on the host = { collection: tiles, kind: 'tileset' }; assert.equal(h.rendering.rehome(), true); assert.equal(h.layers.length, 0); - assert.equal(layer.destroyed, true); + assert.equal(layer.removed, true); assert.equal(tiles.length, 0); assert.equal( h.rendering.getDiagnostics().time, @@ -1089,7 +1141,7 @@ test('host switches tear one renderer down and restage the retained frame on the assert.equal(diagnostics.time, times[1]); assert.equal(diagnostics.infrared, 'full'); assert.equal(h.layers[0].alpha, 0.4); - assert.equal(h.layers[0].imageryProvider.tileWidth, 256); + assert.equal(h.layers[0].spec.tileSize, 256); h.rendering.clear(); assert.equal(h.layers.length, 0); assert.equal(h.postRender.size, 0); @@ -1176,14 +1228,10 @@ test('a stage without a current frame is cancelled on host change and detached f h.settle(); await ready; const layer = h.layers[0]; - let destroyed = false; - layer.destroy = () => { - destroyed = true; - }; host = { collection: null, kind: 'none' }; h.rendering.rehome(); h.rendering.clear(); - assert.equal(destroyed, true); + assert.equal(layer.removed, true); }); for (const product of ['clouds', 'clouds-regional', 'radar', 'lightning']) { @@ -1194,56 +1242,33 @@ for (const product of ['clouds', 'clouds-regional', 'radar', 'lightning']) { }); const stage = h.rendering.setFrame({ ...snapshot, product }, times[0]); await flush(); - const layer = collection.get(0); - assert.equal(layer.colorToAlpha, undefined); + const layer = h.layers[0]; + assert.equal(layer.spec.colorToAlpha, undefined); assert.equal(layer.alpha, 0); h.rendering.clear(); assert.equal(await stage, false); }); } -for (const statusCode of [429, 503]) { - test(`${statusCode} retries up to three times without failing a healthy frame`, async () => { - let now = 0; - const h = renderingHarness({ now: () => now }); - h.viewer.scene.globe.tilesLoaded = false; - const stage = h.rendering.setFrame(snapshot, times[0]); - h.providers[0].response = deferred(); - const rejected = h.providers[0].requestImage(0, 0, 0, {}); - h.providers[0].response.reject(new Error('throttled')); - await assert.rejects(rejected, /throttled/); - for (let timesRetried = 0; timesRetried < 3; timesRetried++) { - const error = { - error: { statusCode }, - x: 0, - y: 0, - level: 0, - timesRetried, - retry: false, - }; - h.providers[0].errorEvent.emit(error); - assert.equal(error.retry, true); - assert.equal(h.rendering.getDiagnostics().error, null); - } - h.settle(); - assert.equal(h.rendering.getDiagnostics().loading, true); - h.providers[0].response = deferred(); - const retried = h.providers[0].requestImage(0, 0, 0, {}); - h.providers[0].response.resolve({}); - await retried; - now = 250; - h.settle(); - assert.equal(await stage, true); - const exhausted = h.rendering.setFrame(snapshot, times[1]); - const error = { error: { statusCode }, timesRetried: 3, retry: false }; - for (let i = 0; i < 4; i++) h.providers[1].errorEvent.emit(error); - h.settle(); - assert.equal(error.retry, false); - assert.equal(await exhausted, false); - assert.equal(h.rendering.getDiagnostics().time, times[0]); - h.rendering.clear(); - }); -} +test('throttled tiles are fetched again by the renderer; a tile that still fails fails the frame', async () => { + let now = 0; + const h = renderingHarness({ now: () => now }); + const stage = h.rendering.setFrame(snapshot, times[0]); + assert.deepEqual(h.providers[0].spec.retryStatuses, [429, 503]); + h.providers[0].response = deferred(); + const loaded = h.providers[0].requestImage(0, 0, 0, {}); + h.providers[0].response.resolve({}); + await loaded; + now = 250; + h.settle(); + assert.equal(await stage, true); + const exhausted = h.rendering.setFrame(snapshot, times[1]); + h.providers[1].errorEvent.emit({ error: { statusCode: 429 }, x: 0, y: 0 }); + h.settle(); + assert.equal(await exhausted, false); + assert.equal(h.rendering.getDiagnostics().time, times[0]); + h.rendering.clear(); +}); test('404 fails a frame without retry', async () => { const h = renderingHarness(); @@ -1315,12 +1340,20 @@ test('host restore through update stages latest after a no-host start', async () h.layer.destroy(); }); -test('real Cesium global infrared provider supports the globe host', async () => { - const collection = new Cesium.ImageryLayerCollection(); - const h = renderingHarness({ - cesium: Cesium, - getHost: () => ({ collection, kind: 'globe' }), - }); +test('the global infrared mosaic draws through the real Cesium globe port', async () => { + const scene = { + imageryLayers: new Cesium.ImageryLayerCollection(), + globe: { show: true, tilesLoaded: true }, + primitives: { length: 0, get: () => undefined }, + }; + const { port } = createCesiumGlobe( + { scene }, + { + capabilities: new Set(['imageHooks', 'imageryOnTiles']), + requestRender: () => {}, + }, + ); + const h = renderingHarness({ globeOf: () => port }); const stage = h.rendering.setFrame( { ...snapshot, @@ -1330,7 +1363,7 @@ test('real Cesium global infrared provider supports the globe host', async () => times[0], ); await flush(); - const layer = collection.get(0); + const layer = scene.imageryLayers.get(0); const provider = layer.imageryProvider; assert.ok(provider.tilingScheme instanceof Cesium.GeographicTilingScheme); assert.equal(provider.maximumLevel, 3); @@ -1345,44 +1378,12 @@ test('real Cesium global infrared provider supports the globe host', async () => ), ); assert.equal(layer.colorToAlpha, undefined); - assert.ok(provider.requestImage(0, 0, 0) instanceof Promise); + assert.equal(layer.alpha, 0, 'staged transparent'); h.rendering.clear(); + assert.equal(scene.imageryLayers.length, 0); assert.equal(await stage, false); }); -for (const statusCode of [429, 503]) { - test(`${statusCode} retries belong to tiles, regardless of the layer-wide counter`, async () => { - const h = renderingHarness(); - const stage = h.rendering.setFrame(snapshot, times[0]); - const provider = h.providers[0]; - const fail = (x, timesRetried = 0) => { - const error = { x, y: 0, level: 2, timesRetried, error: { statusCode } }; - provider.errorEvent.emit(error); - return error.retry; - }; - // A shared counter may exceed three even though these are first failures. - for (let x = 0; x < 4; x++) assert.equal(fail(x, x + 4), true); - provider.response = { promise: Promise.resolve({}) }; - await provider.requestImage(0, 0, 2); - for (let i = 0; i < 3; i++) - assert.equal(fail(0), true, 'own success reset the count'); - for (let i = 0; i < 2; i++) { - await provider.requestImage(2, 0, 2); - assert.equal(fail(1), true); - } - await provider.requestImage(3, 0, 2); - assert.equal( - fail(1), - false, - 'four failures exhaust this tile despite other successes', - ); - h.settle(); - assert.equal(await stage, false); - assert.equal(provider.errorEvent.size, 0); - h.rendering.clear(); - }); -} - for (const [id, product] of [ ['weather-radar', 'radar'], ['weather-satellite', 'clouds-regional'], @@ -1514,10 +1515,9 @@ for (const outcome of [ if (outcome === 'supersede') assert.equal(await h.rendering.setFrame(snapshot, times[0]), true); if (outcome === 'rehome') { - host = { - collection: renderingHarness().viewer.imageryLayers, - kind: 'globe', - }; + host = { collection: null, kind: 'none' }; + h.rendering.rehome(); + host = { collection: h.viewer.imageryLayers, kind: 'globe' }; h.rendering.rehome(); } assert.equal(await pending, false); @@ -1535,7 +1535,7 @@ for (const outcome of [ await flush(); if (outcome !== 'fetch failure') assert.equal(closed, 1); } - assert.equal(host.collection.length, 1); + assert.equal(h.layers.length, 1); h.rendering.clear(); assert.equal(h.postRender.size, 0); }); @@ -1548,12 +1548,7 @@ test('regional transfer preserves deferrals, original Request, rejection and can times[0], ); const provider = h.providers[0]; - let cancelled = 0; - const request = { - cancel() { - cancelled++; - }, - }; + const request = {}; assert.equal(provider.requestImage(1, 2, 3, request), undefined); assert.deepEqual(provider.requestArgs, [1, 2, 3, request]); const image = { width: 256, height: 256 }; @@ -1570,13 +1565,13 @@ test('regional transfer preserves deferrals, original Request, rejection and can provider.response = deferred(); const late = provider.requestImage(0, 0, 0, request); h.rendering.clear(); - assert.equal(cancelled, 1); + assert.equal(provider.layer.removed, true, 'its requests are cancelled'); provider.response.resolve(image); assert.equal(await late, image, 'closed frames do not process late images'); assert.equal(await stage, false); }); -test('regional tiles decoded as flipped ImageBitmaps are drawn back upright', async () => { +test('regional tiles are processed upright, as the renderer hands them over', async () => { const hadBitmap = Object.hasOwn(globalThis, 'ImageBitmap'); const previous = globalThis.ImageBitmap; globalThis.ImageBitmap = class ImageBitmap { @@ -1590,11 +1585,10 @@ test('regional tiles decoded as flipped ImageBitmaps are drawn back upright', as times[0], ); const provider = h.providers[0]; - // Cesium decodes with imageOrientation 'flipY'; the canvas upload flips again. + // `tileTransform` is given the tile upright, whatever it was decoded as. provider.response = { promise: Promise.resolve(new ImageBitmap()) }; const bitmapTile = await provider.requestImage(0, 0, 0, {}); - assert.deepEqual(bitmapTile.drawnWith, [1, 0, 0, -1, 0, 256]); - // An HTMLImageElement fallback is not pre-flipped. + assert.equal(bitmapTile.drawnWith, null); provider.response = { promise: Promise.resolve({ width: 256, height: 256 }), }; @@ -1632,11 +1626,11 @@ for (const kind of ['globe']) { assert.equal(await full, true); assert.equal(h.layers.length, 2); assert.equal(h.layers[1].alpha, 0.7); - assert.equal(previous.destroyed, undefined); + assert.equal(previous.removed, false); assert.equal(h.rendering.getDiagnostics().infrared, 'full'); h.postRender.emit(); assert.equal(h.layers.length, 1); - assert.equal(previous.destroyed, true); + assert.equal(previous.removed, true); h.rendering.clear(); assert.equal(h.postRender.size, 0); }); @@ -1764,7 +1758,7 @@ test('a delayed installation failure retains the replacement and does not throw assert.equal(await stage, true); } const third = h.rendering.setFrame(snapshot, times[2]); - h.viewer.imageryLayers.addImageryProvider = () => { + h.globe.imagery.add = () => { throw new Error('upload unavailable'); }; assert.doesNotThrow(() => h.postRender.emit()); @@ -2355,12 +2349,13 @@ for (const product of ['radar', 'clouds-regional', 'lightning']) { positionCartographic: { height: 60_000 }, }; const pending = h.rendering.setFrame({ ...snapshot, product }, times[0]); - const options = collection.get(0).imageryProvider.options; - assert.equal(options.tileWidth, 256); - assert.equal(options.tileHeight, 256); - assert.equal(options.maximumLevel, 6); + const { spec } = h.layers[0]; + assert.equal(spec.kind, 'xyz'); + assert.equal(spec.tileSize, 256); + assert.equal(spec.maxLevel, 6); + assert.equal(spec.tiling, 'geographic'); assert.equal( - new URL(options.url, 'https://example.test').searchParams.get('size'), + new URL(spec.url, 'https://example.test').searchParams.get('size'), '256', ); assert.equal(h.rendering.getDiagnostics().host, 'globe'); diff --git a/src/layers/wind/rendering.js b/src/layers/wind/rendering.js index 462e9aca0..83dec7dc0 100644 --- a/src/layers/wind/rendering.js +++ b/src/layers/wind/rendering.js @@ -3,7 +3,8 @@ import { WEATHER_SHELL_HEIGHTS, } from '../weather/shellRendering.js'; import { createWindRelief } from './relief.js'; -import { orderWeatherImagery } from '../weather/imageryOrder.js'; +import { WEATHER_IMAGERY_Z } from '../weather/imageryOrder.js'; +import { findGlobe } from '../../render/rendererOf.js'; import { NO_IMAGERY_HOST } from '../weather/imageryHost.js'; import { msg } from '../../i18n/index.js'; import { createWindGpuRendering } from './gpuRendering.js'; @@ -69,6 +70,7 @@ export function createWindRendering({ }), eventTarget = globalThis.window, createGpuRendering = createWindGpuRendering, + globeOf = findGlobe, onStatusChange, } = {}) { let canvas = null; @@ -87,7 +89,6 @@ export function createWindRendering({ let reducedMotion = false; let imagery = null; let shell = null; - let imageryCollection = null; let imageryKind = null; let imageryError = null; let imageryErrorRemove = null; @@ -297,13 +298,10 @@ export function createWindRendering({ function removeImagery() { imageryErrorRemove?.(); imageryErrorRemove = null; - if (imagery && imageryCollection && !imageryCollection.isDestroyed?.()) - imageryCollection.remove(imagery, true); - else if (imagery && !imagery.isDestroyed?.()) imagery.destroy?.(); + imagery?.remove(); imagery = null; shell?.destroy(); shell = null; - imageryCollection = null; imageryKind = null; } function updateImageryFade(camera, settled = false) { @@ -336,7 +334,7 @@ export function createWindRendering({ return; } if (Math.abs(imagery.alpha - alpha) > 0.005) imagery.alpha = alpha; - const show = alpha > 0; + const show = alpha > 0 && getHost().kind !== 'none'; if (imagery.show !== show) imagery.show = show; } function installImagery() { @@ -344,21 +342,18 @@ export function createWindRendering({ imageryError = null; const viewer = viewerReady(); if (!snapshot || overlay === 'none' || !viewer) return; - const { collection, kind } = getHost(); + const { kind } = getHost(); if (kind === 'none') { imageryError = NO_IMAGERY_HOST; return; } + const globe = kind === 'tileset' ? null : globeOf(viewer); const raster = createFieldRaster(snapshot, overlay); if (!raster) { imageryError = fieldUnavailableText(overlay); return; } - if ( - kind === 'tileset' - ? !cesium.Primitive - : !collection || !cesium.SingleTileImageryProvider - ) { + if (kind === 'tileset' ? !cesium.Primitive : !globe) { imageryError = msg('Globe imagery unavailable'); return; } @@ -384,21 +379,19 @@ export function createWindRendering({ viewer.scene?.requestRender?.(); return; } - const provider = new cesium.SingleTileImageryProvider({ + imagery = globe.imagery.add({ + kind: 'single-image', url: texture.toDataURL('image/png'), - tileWidth: raster.width, - tileHeight: raster.height, - rectangle: cesium.Rectangle.MAX_VALUE, + rectangle: { west: -180, south: -90, east: 180, north: 90 }, + zOrder: WEATHER_IMAGERY_Z.wind, }); - imagery = collection.addImageryProvider(provider); - orderWeatherImagery(collection, imagery, 0); - imageryCollection = collection; + imagery.drapeOn = 'surface'; imageryKind = kind; // Temperature colors carry quantitative meaning; double transparency // blends orange heat into blue ocean and obscures useful gradients. imagery.alpha = overlay === 'temperature' ? 1 : 0.85; if (gpuActive) updateImageryFade(viewer.scene.camera, true); - imageryErrorRemove = provider.errorEvent?.addEventListener(() => { + imageryErrorRemove = imagery.on('tileError', () => { imageryError = msg('Globe field image unavailable'); }); viewer.scene?.requestRender?.(); @@ -410,7 +403,7 @@ export function createWindRendering({ function rehome() { if (!snapshot || overlay === 'none') return; - const { collection, kind } = getHost(); + const { kind } = getHost(); const wasHidden = imageryError === NO_IMAGERY_HOST; if ((imagery || shell) && kind !== 'none' && kind !== imageryKind) { installImagery(); @@ -419,13 +412,11 @@ export function createWindRendering({ } // A host without imagery hides the retained shell until a host returns. if (shell && kind === 'none') shell.setShow(false); - if (imagery && collection !== imageryCollection) { - imageryCollection?.remove(imagery, false); - imageryCollection = collection; - if (collection) { - collection.add(imagery); - orderWeatherImagery(collection, imagery, 0); - } + // Globe imagery stays on the globe, which draws nothing while hidden; + // it is hidden too until a host returns. + const show = kind !== 'none' && imagery?.alpha > 0; + if (imagery && imagery.show !== show) { + imagery.show = show; viewerReady()?.scene?.requestRender?.(); } if ((gpuActive || kind === 'tileset') && kind !== 'none') diff --git a/src/layers/wind/rendering.test.mjs b/src/layers/wind/rendering.test.mjs index d05d42351..f34825527 100644 --- a/src/layers/wind/rendering.test.mjs +++ b/src/layers/wind/rendering.test.mjs @@ -4,6 +4,7 @@ import * as Cesium from 'cesium'; import { createWindRendering } from './rendering.js'; import { NO_IMAGERY_HOST } from '../weather/imageryHost.js'; +import { WEATHER_IMAGERY_Z } from '../weather/imageryOrder.js'; import { createShellCesium, createShellScene, @@ -140,28 +141,37 @@ function harness({ }; const imagery = []; const removed = []; - const imageryLayers = { - addImageryProvider(provider) { - let alpha = 1; - const layer = { - provider, - show: true, - alphaWrites: 0, - get alpha() { - return alpha; - }, - set alpha(value) { - alpha = value; - this.alphaWrites++; - }, - }; - imagery.push(layer); - return layer; - }, - remove(layer, destroy) { - const i = imagery.indexOf(layer); - if (i >= 0) imagery.splice(i, 1); - removed.push({ layer, destroy }); + // The viewer's globe port: each layer added, and each removed. + const imageryLayers = {}; + const globe = { + imagery: { + add(spec) { + let alpha = 1; + const errors = event(); + const layer = { + spec, + errors, + show: true, + drapeOn: 'all', + alphaWrites: 0, + get alpha() { + return alpha; + }, + set alpha(value) { + alpha = value; + this.alphaWrites++; + }, + on: (name, cb) => + name === 'tileError' ? errors.addEventListener(cb) : () => {}, + remove() { + const i = imagery.indexOf(layer); + if (i >= 0) imagery.splice(i, 1); + removed.push({ layer, destroy: true }); + }, + }; + imagery.push(layer); + return layer; + }, }, }; const viewer = { @@ -214,6 +224,7 @@ function harness({ cesium, container, getViewer: () => viewer, + globeOf: (given) => (given === viewer ? globe : null), createGpuRendering, onStatusChange, getHost, @@ -397,7 +408,9 @@ test('scalar imagery builds once, survives pause, replaces cleanly, and releases h.rendering.start(); assert.equal(h.imagery.length, 1); assert.equal(h.textures.length, 1); - assert.equal(h.imagery[0].provider.options.tileWidth, 360); + assert.equal(h.imagery[0].spec.kind, 'single-image'); + assert.equal(h.imagery[0].spec.zOrder, WEATHER_IMAGERY_Z.wind); + assert.equal(h.imagery[0].drapeOn, 'surface'); h.callbacks.shift()(16); h.callbacks.shift()(50); h.callbacks.shift()(85); @@ -1145,7 +1158,7 @@ for (const overlay of ['speed', 'temperature', 'pressure']) { kind = 'globe'; h.rendering.rehome(); assert.equal(primitive.destroyed, true); - assert.equal(h.imagery[0].provider.options.tileWidth, 360); + assert.equal(h.imagery[0].spec.kind, 'single-image'); assert.equal(h.imagery[0].alpha, overlay === 'temperature' ? 1 : 0.85); h.rendering.destroy(); assert.equal(camera.moveEnd.size, 0); @@ -1193,3 +1206,28 @@ for (const overlay of ['speed', 'temperature', 'pressure']) { h.rendering.destroy(); }); } + +test('globe imagery hides without a host and shows again when one returns; a failed field image says so', () => { + let host = { collection: {}, kind: 'globe' }; + const h = harness({ getHost: () => host }); + h.rendering.attach(); + h.rendering.setOptions({ overlay: 'speed' }); + h.rendering.setField(FIELD); + const [layer] = h.imagery; + assert.equal(layer.show, true); + host = { collection: null, kind: 'none' }; + h.rendering.rehome(); + assert.equal(layer.show, false, 'hidden, not removed'); + assert.deepEqual(h.imagery, [layer]); + host = { collection: {}, kind: 'globe' }; + h.rendering.rehome(); + assert.equal(layer.show, true); + assert.deepEqual(h.imagery, [layer]); + layer.errors.emit(); + assert.equal( + h.rendering.getDiagnostics().imageryError, + 'Globe field image unavailable', + ); + h.rendering.destroy(); + assert.equal(h.imagery.length, 0); +}); diff --git a/src/render/cesium/globe.test.mjs b/src/render/cesium/globe.test.mjs index cf2d21a1c..f1f3350db 100644 --- a/src/render/cesium/globe.test.mjs +++ b/src/render/cesium/globe.test.mjs @@ -577,3 +577,16 @@ test('a scene with no globe drapes on its base tileset', () => { port.imagery.add({ kind: 'xyz', url: url('a') }); assert.equal(tileset.imageryLayers.length, 1); }); + +test('a provider that fails to build is told as an error of its root tile', async () => { + const { port } = setup(); + const layer = port.imagery.add({ + kind: 'single-image', + url: 'data:image/png;base64,AAAA', + }); + const errors = []; + layer.on('tileError', (error) => errors.push(error)); + await new Promise((resolve) => setTimeout(resolve, 50)); + assert.deepEqual(errors, [{ tile: { x: 0, y: 0, level: 0 } }]); + layer.remove(); +}); diff --git a/src/render/cesium/imagery.js b/src/render/cesium/imagery.js index eaf618484..de082f2f8 100644 --- a/src/render/cesium/imagery.js +++ b/src/render/cesium/imagery.js @@ -194,12 +194,26 @@ const decodeTile = (blob) => * flipped, as Cesium's own bitmaps are. */ async function transformTile(spec, tile, image) { + // Straight alpha throughout, as Cesium uploads its own tiles: WebGL does + // not premultiply an ImageBitmap, so one premultiplied here stays so. + const straight = { + premultiplyAlpha: 'none', + colorSpaceConversion: 'default', + }; const upright = await createImageBitmap( image, - isBitmap(image) ? FLIPPED : {}, + isBitmap(image) ? { ...FLIPPED, ...straight } : straight, ); - const result = await spec.tileTransform(tile, upright); - return createImageBitmap(result, FLIPPED); + // The input is the hook's until it settles; a bitmap it returns is the + // renderer's, spent once copied. + let result; + try { + result = await spec.tileTransform(tile, upright); + return await createImageBitmap(result, { ...FLIPPED, ...straight }); + } finally { + if (isBitmap(result) && result !== upright) result.close(); + upright.close(); + } } /** A hook's synchronous throw as a failed tile, never a throw into the frame. */ @@ -527,7 +541,16 @@ export function createCesiumImagery( record.provider = hooked; return hooked; }); - record.providerPromise.catch(() => {}); + // A provider that fails to build (its metadata, or a single image) + // loads no tile: told as an error of the layer's root tile. + record.providerPromise.catch((error) => { + if (record.removed || listeners.tileError.size === 0) return; + const status = error?.statusCode; + listeners.tileError.fire({ + tile: { x: 0, y: 0, level: 0 }, + ...(Number.isFinite(status) ? { status } : {}), + }); + }); } else { record.provider = hookProvider(made, spec, ctx); watchErrors(made); diff --git a/src/render/cesiumAllowList.json b/src/render/cesiumAllowList.json index 701f02b46..3f73505ac 100644 --- a/src/render/cesiumAllowList.json +++ b/src/render/cesiumAllowList.json @@ -184,8 +184,6 @@ "src/layers/vessels/state.js", "src/layers/vessels/tracking.js", "src/layers/weather/index.js", - "src/layers/weather/rasterTiles.js", - "src/layers/weather/rendering.js", "src/layers/weather/shellRendering.js", "src/layers/wind/gpuRendering.js", "src/layers/wind/index.js", diff --git a/src/testSupport/fakeGlobePort.mjs b/src/testSupport/fakeGlobePort.mjs new file mode 100644 index 000000000..aab20466d --- /dev/null +++ b/src/testSupport/fakeGlobePort.mjs @@ -0,0 +1,106 @@ +/** + * A globe port for tests of code that drapes imagery through the renderer's + * globe port (`src/render/contract/globe.d.ts`): it records each layer and + * its spec, orders layers by `zOrder` as the contract says, and lets a test + * drive tile requests through a layer's hooks and raise its tile errors. + */ + +/** + * @param {{settled?: (kind: string) => boolean}} [options] + * `settled`: what `isSettled` answers. + */ +export function fakeGlobePort({ settled = () => true } = {}) { + /** Live layers, bottom to top. */ + const layers = []; + /** Every layer ever added, in the order added. */ + const added = []; + let split = 0; + let globeVisible = true; + + function add(spec, index) { + const listeners = { tileError: new Set(), frameReady: new Set() }; + const layer = { + spec, + alpha: 1, + show: true, + split: 'none', + drapeOn: 'all', + lit: true, + removed: false, + on(event, cb) { + listeners[event]?.add(cb); + return () => listeners[event]?.delete(cb); + }, + raise() { + const i = layers.indexOf(layer); + if (i < 0 || i === layers.length - 1) return; + layers.splice(i, 1); + layers.splice(i + 1, 0, layer); + }, + lower() { + const i = layers.indexOf(layer); + if (i <= 0) return; + layers.splice(i, 1); + layers.splice(i - 1, 0, layer); + }, + remove() { + if (layer.removed) return; + layer.removed = true; + layers.splice(layers.indexOf(layer), 1); + listeners.tileError.clear(); + listeners.frameReady.clear(); + }, + /** + * Ask for a tile as the renderer would: `admit` decides, and an issued + * request runs `fetch` (the renderer's own fetch) then `tileTransform`. + * @param {{x: number, y: number, level: number}} tile + * @param {() => Promise | undefined} fetch + */ + request(tile, fetch) { + const issue = () => { + const started = fetch(); + if (!started || !spec.tileTransform) return started; + return Promise.resolve(started).then((image) => + spec.tileTransform(tile, image), + ); + }; + return spec.admit ? spec.admit(tile, issue) : issue(); + }, + /** Tell the layer's `tileError` listeners. */ + fail(error) { + for (const cb of [...listeners.tileError]) cb(error); + }, + listenerCount: (event) => listeners[event]?.size ?? 0, + }; + let at = index; + if (at === undefined) { + const z = Number.isFinite(spec.zOrder) ? spec.zOrder : 0; + at = layers.length; + while (at > 0 && (layers[at - 1].spec.zOrder ?? 0) > z) at -= 1; + } + layers.splice(Math.max(0, Math.min(at, layers.length)), 0, layer); + added.push(layer); + return layer; + } + + return { + layers, + added, + imagery: { + add, + list: () => layers.slice(), + getSplit: () => split, + setSplit: (x01) => { + split = Math.min(1, Math.max(0, Number(x01))); + }, + }, + isSettled: (kind) => settled(kind), + setGlobeVisible(visible) { + globeVisible = Boolean(visible); + }, + get globeVisible() { + return globeVisible; + }, + on: () => () => {}, + }; +}