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: () => () => {},
+ };
+}