mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-17 08:42:21 +00:00
Add raster imagery to the globe contract and draw FIRMS heat and Recent Imagery through it
engine.imagery draws raster layers over the globe: Web Mercator tile templates and single images or canvases stretched over a rectangle, with alpha, show, a left/right split against the engine's split position and an order. A layer's source can be replaced in place. - Cesium puts one ImageryLayer per layer on the globe's imagery stack, or on the shown 3D tileset's when the globe is hidden, and moves it when the surface changes; the Recent Imagery request gate moved here. - Navara draws them in one screen pass after tone mapping that samples up to eight layers by geodetic position from mipmapped textures and a tile atlas, under the other drapes and engine.ground. - The fake engine keeps each layer's state. The FIRMS far-zoom heat raster and Recent Imagery now draw through it, so FIRMS' heat seam and both its backends, and Recent Imagery's Cesium and Navara renderers and tile plan, go. Against HEAD, Cesium's pixels are identical in all four compared scenes; Navara's orbital heat changes by a mean of 3.8 from new mipmapping, slightly towards Cesium. The contract suite passes on both engines (Cesium 68/68, Navara 71/71). engine.maps.addOverlay stays a Navara-only extension for Sea Marks and Ski Pistes until imagery has a finer tile path for oblique global views.
This commit is contained in:
1 parent
1559bd57f4
commit
406dd9122e
52 files changed
+4171
-1988
No files matched your search
@@ -5,13 +5,15 @@
|
||||
// engine clock's frame latch on viewer.clock.onTick (clock.js), attached at
|
||||
// creation so it runs before onTick listeners added later. Mover sets and
|
||||
// lines join the scene in one engine-owned collection each, with the first
|
||||
// set or line; ground sets join scene.groundPrimitives the same way.
|
||||
// set or line; ground sets join scene.groundPrimitives the same way, and
|
||||
// imagery layers the imagery stack of the shown surface.
|
||||
|
||||
import { createCesiumCamera } from './camera.js';
|
||||
import { createCesiumClock } from './clock.js';
|
||||
import { createCesiumCredits } from './credits.js';
|
||||
import { createCesiumFrames } from './frames.js';
|
||||
import { createCesiumGround } from './ground.js';
|
||||
import { createCesiumImagery } from './imagery.js';
|
||||
import { createCesiumInput } from './input.js';
|
||||
import { createCesiumLines } from './lines.js';
|
||||
import { createCesiumMaps } from './maps.js';
|
||||
@@ -33,9 +35,11 @@ import { createCesiumSurface } from './surface.js';
|
||||
* moverFactories?: object,
|
||||
* lineFactories?: object,
|
||||
* groundFactories?: object,
|
||||
* imageryFactories?: object,
|
||||
* }} [options] `requestRender` defaults to the render governor; `appClock`
|
||||
* to the page's app clock; the `create*`/`load*` options and the mover and
|
||||
* line and ground factories (movers.js, lines.js, ground.js) are test seams.
|
||||
* line, ground and imagery factories (movers.js, lines.js, ground.js,
|
||||
* imagery.js) are test seams.
|
||||
*
|
||||
* `render.setContinuous` takes a hold on the app's singleton renderGovernor
|
||||
* (src/renderGovernor.js), which governs the one viewer it was installed on;
|
||||
@@ -60,6 +64,11 @@ export function createCesiumEngine(viewer, options = {}) {
|
||||
requestRender,
|
||||
...(options.groundFactories ? { factories: options.groundFactories } : {}),
|
||||
});
|
||||
const maps = createCesiumMaps(viewer, {
|
||||
...options,
|
||||
credits: credits.credits,
|
||||
requestRender,
|
||||
});
|
||||
// Picks name the mover set, line or ground set they hit, with its pickId.
|
||||
const picker = createCesiumPicker(viewer, {
|
||||
identify: (picked) =>
|
||||
@@ -83,11 +92,15 @@ export function createCesiumEngine(viewer, options = {}) {
|
||||
}),
|
||||
input: createCesiumInput(viewer, { ...options, picker: picker.picker }),
|
||||
credits,
|
||||
maps: createCesiumMaps(viewer, {
|
||||
...options,
|
||||
credits: credits.credits,
|
||||
// Before the maps: its layers leave the tilesets before they go.
|
||||
imagery: createCesiumImagery(viewer, {
|
||||
requestRender,
|
||||
tilesets: maps.tilesets,
|
||||
...(options.imageryFactories
|
||||
? { factories: options.imageryFactories }
|
||||
: {}),
|
||||
}),
|
||||
maps,
|
||||
};
|
||||
let destroyed = false;
|
||||
return {
|
||||
|
||||
@@ -0,0 +1,349 @@
|
||||
// engine.imagery on Cesium: one ImageryLayer per layer, on the imagery
|
||||
// stack of the surface the map shows — the globe's imagery layers, or the
|
||||
// shown 3D tileset's own (Cesium drapes imagery on tiles there), as
|
||||
// src/maps/imageryHost.js resolves it for the shell. Layers sit above the
|
||||
// base imagery, in their order among the engine's layers (higher on top,
|
||||
// then creation); imagery added by others stays where it was put. A tiles
|
||||
// source is a UrlTemplateImageryProvider in Web Mercator, an image source a
|
||||
// one-tile provider over its rectangle (as SingleTileImageryProvider, but
|
||||
// from the canvas or image itself, without a PNG round trip). The engine
|
||||
// follows the surface on every frame while it holds a layer: on a switch
|
||||
// each layer is built again on the new stack, never re-parented.
|
||||
|
||||
import * as Cesium from 'cesium';
|
||||
import { createImageryRegistry, isPixelImage } from '../imagery.js';
|
||||
|
||||
const SPLIT = { none: 'NONE', left: 'LEFT', right: 'RIGHT' };
|
||||
const NO_HOST = Object.freeze({ collection: null, surface: 'none' });
|
||||
/** Delay before the one frame that retries tiles a provider deferred. */
|
||||
export const TILE_RETRY_DELAY_MS = 250;
|
||||
|
||||
const rectangleOf = ({ west, south, east, north }) =>
|
||||
Cesium.Rectangle.fromDegrees(west, south, east, north);
|
||||
|
||||
const defaultCanvas = (width, height) =>
|
||||
Object.assign(document.createElement('canvas'), { width, height });
|
||||
|
||||
// RGBA bytes on a canvas Cesium can upload.
|
||||
function drawable(image, createCanvas) {
|
||||
if (!isPixelImage(image)) return image;
|
||||
const canvas = createCanvas(image.width, image.height);
|
||||
const context = canvas.getContext('2d');
|
||||
const pixels = context.createImageData(image.width, image.height);
|
||||
pixels.data.set(image.data);
|
||||
context.putImageData(pixels, 0, 0);
|
||||
return canvas;
|
||||
}
|
||||
|
||||
// One image over `rectangle`: SingleTileImageryProvider's tiling (one
|
||||
// geographic tile at level 0), handing Cesium the image itself.
|
||||
function singleImageProvider(image, rectangle, credit) {
|
||||
const tilingScheme = new Cesium.GeographicTilingScheme({
|
||||
rectangle,
|
||||
numberOfLevelZeroTilesX: 1,
|
||||
numberOfLevelZeroTilesY: 1,
|
||||
});
|
||||
return {
|
||||
tilingScheme,
|
||||
rectangle,
|
||||
tileWidth: image.width,
|
||||
tileHeight: image.height,
|
||||
minimumLevel: 0,
|
||||
maximumLevel: 0,
|
||||
tileDiscardPolicy: undefined,
|
||||
credit: credit ? new Cesium.Credit(credit) : undefined,
|
||||
errorEvent: new Cesium.Event(),
|
||||
hasAlphaChannel: true,
|
||||
proxy: undefined,
|
||||
getTileCredits: () => undefined,
|
||||
pickFeatures: () => undefined,
|
||||
// ImageryLayer consumes requestImage results as promises.
|
||||
requestImage: () => Promise.resolve(image),
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Gate a provider's `requestImage` to `limit` requests in flight. Returning
|
||||
* `undefined` tells Cesium to retry on a later frame, but under
|
||||
* `requestRenderMode` there is no later frame unless something asks — and a
|
||||
* deferral must never ask for one itself: the retried tile would defer again
|
||||
* and ask again, keeping the scene rendering every frame. So a request that
|
||||
* finds the gate full asks for nothing (the request holding the slot asks
|
||||
* for one frame when it settles), and a request the provider itself
|
||||
* deferred goes through one coalesced delayed retry.
|
||||
*/
|
||||
export function admitTileRequests(provider, admission, requestRender, retry) {
|
||||
const original = provider.requestImage.bind(provider);
|
||||
provider.requestImage = (x, y, level, request) => {
|
||||
if (admission.inFlight >= admission.limit) return undefined;
|
||||
admission.inFlight += 1;
|
||||
const release = () => {
|
||||
admission.inFlight -= 1;
|
||||
};
|
||||
let promise;
|
||||
try {
|
||||
promise = original(x, y, level, request);
|
||||
} catch (error) {
|
||||
release();
|
||||
throw error;
|
||||
}
|
||||
if (!promise) {
|
||||
release();
|
||||
retry.schedule();
|
||||
return undefined;
|
||||
}
|
||||
return Promise.resolve(promise).finally(() => {
|
||||
release();
|
||||
requestRender('imagery-tiles');
|
||||
});
|
||||
};
|
||||
return provider;
|
||||
}
|
||||
|
||||
const defaultFactories = Object.freeze({
|
||||
tiles: (options) => new Cesium.UrlTemplateImageryProvider(options),
|
||||
layer: (provider, options) => new Cesium.ImageryLayer(provider, options),
|
||||
loadImage: (url) => Cesium.Resource.fetchImage({ url }),
|
||||
});
|
||||
|
||||
/**
|
||||
* @param {Cesium.Viewer} viewer
|
||||
* @param {{ requestRender?: (reason: string) => void,
|
||||
* tilesets?: () => object[], createCanvas?: (width: number, height: number) => object,
|
||||
* factories?: object, setTimeout?: Function, clearTimeout?: Function }} [options]
|
||||
* `tilesets` are the 3D tilesets the map may show (maps.js); a shown one
|
||||
* with imagery layers hosts the imagery while the globe is hidden.
|
||||
* `createCanvas`, `factories` (the tile provider, the layer, the image
|
||||
* load) and the timers are test seams.
|
||||
* @returns {{ imagery: import('../contract.js').GlobeImagery, destroy: () => void }}
|
||||
*/
|
||||
export function createCesiumImagery(
|
||||
viewer,
|
||||
{
|
||||
requestRender = () => viewer.scene.requestRender(),
|
||||
tilesets = () => [],
|
||||
createCanvas = defaultCanvas,
|
||||
factories = {},
|
||||
setTimeout: after = (run, ms) => globalThis.setTimeout(run, ms),
|
||||
clearTimeout: cancel = (id) => globalThis.clearTimeout(id),
|
||||
} = {},
|
||||
) {
|
||||
const make = { ...defaultFactories, ...factories };
|
||||
const { scene } = viewer;
|
||||
const entries = new Set();
|
||||
let removeWatch = null;
|
||||
|
||||
function host() {
|
||||
if (scene.globe?.show === true && viewer.imageryLayers)
|
||||
return { collection: viewer.imageryLayers, surface: 'globe' };
|
||||
const tileset = tilesets().find(
|
||||
(candidate) =>
|
||||
candidate?.show === true &&
|
||||
candidate.imageryLayers &&
|
||||
!candidate.isDestroyed?.(),
|
||||
);
|
||||
return tileset
|
||||
? { collection: tileset.imageryLayers, surface: 'tiles' }
|
||||
: NO_HOST;
|
||||
}
|
||||
|
||||
const usable = (collection) => collection && !collection.isDestroyed?.();
|
||||
function detach(entry) {
|
||||
const { layer, collection } = entry;
|
||||
entry.layer = null;
|
||||
entry.collection = null;
|
||||
if (!layer) return;
|
||||
if (usable(collection) && collection.contains(layer))
|
||||
collection.remove(layer, true);
|
||||
else if (!layer.isDestroyed?.()) layer.destroy?.();
|
||||
}
|
||||
|
||||
// Above every engine layer under it in draw order, below every one over
|
||||
// it; at the top when none is over it.
|
||||
function place(entry, layer, collection) {
|
||||
let index = collection.length;
|
||||
for (const other of entries) {
|
||||
if (other === entry || other.collection !== collection || !other.layer)
|
||||
continue;
|
||||
const over =
|
||||
other.state.options.order > entry.state.options.order ||
|
||||
(other.state.options.order === entry.state.options.order &&
|
||||
other.state.seq > entry.state.seq);
|
||||
if (over) index = Math.min(index, collection.indexOf(other.layer));
|
||||
}
|
||||
collection.add(layer, index);
|
||||
}
|
||||
|
||||
function providerFor(entry, source) {
|
||||
if (source.kind === 'tiles') {
|
||||
const provider = make.tiles({
|
||||
url: source.url,
|
||||
subdomains: [...source.subdomains],
|
||||
minimumLevel: source.minLevel,
|
||||
maximumLevel: source.maxLevel,
|
||||
tileWidth: source.tileSize,
|
||||
tileHeight: source.tileSize,
|
||||
tilingScheme: new Cesium.WebMercatorTilingScheme(),
|
||||
rectangle: rectangleOf(source.rectangle),
|
||||
hasAlphaChannel: !source.opaque,
|
||||
enablePickFeatures: false,
|
||||
...(source.credit ? { credit: source.credit } : {}),
|
||||
});
|
||||
return source.maxRequests
|
||||
? admitTileRequests(
|
||||
provider,
|
||||
{ limit: source.maxRequests, inFlight: 0 },
|
||||
requestRender,
|
||||
entry.retry,
|
||||
)
|
||||
: provider;
|
||||
}
|
||||
return singleImageProvider(
|
||||
drawable(entry.image, createCanvas),
|
||||
rectangleOf(source.rectangle),
|
||||
source.credit,
|
||||
);
|
||||
}
|
||||
|
||||
function applyLook(entry) {
|
||||
const { layer, state } = entry;
|
||||
if (!layer) return;
|
||||
layer.alpha = state.alpha;
|
||||
layer.show = state.shown;
|
||||
layer.splitDirection =
|
||||
Cesium.SplitDirection?.[SPLIT[state.split]] ?? layer.splitDirection;
|
||||
}
|
||||
|
||||
// The layer for the current source on the current host, in place of the
|
||||
// one drawn (at its index, so a new source keeps its stack position).
|
||||
function mount(entry) {
|
||||
const { collection } = host();
|
||||
const source = entry.state.source;
|
||||
if (!usable(collection) || (source.kind === 'image' && !entry.image)) {
|
||||
detach(entry);
|
||||
return;
|
||||
}
|
||||
const layer = make.layer(providerFor(entry, source), {
|
||||
alpha: entry.state.alpha,
|
||||
show: entry.state.shown,
|
||||
});
|
||||
const previous = entry.layer;
|
||||
if (previous && entry.collection === collection) {
|
||||
collection.add(layer, collection.indexOf(previous));
|
||||
collection.remove(previous, true);
|
||||
} else {
|
||||
detach(entry);
|
||||
place(entry, layer, collection);
|
||||
}
|
||||
entry.layer = layer;
|
||||
entry.collection = collection;
|
||||
applyLook(entry);
|
||||
requestRender('imagery');
|
||||
}
|
||||
|
||||
// An image source: its image now, or once its URL has loaded.
|
||||
function load(entry) {
|
||||
const source = entry.state.source;
|
||||
entry.loading = null;
|
||||
if (source.kind !== 'image' || source.image) {
|
||||
entry.image = source.image;
|
||||
mount(entry);
|
||||
return;
|
||||
}
|
||||
entry.image = null;
|
||||
const pending = Promise.resolve(make.loadImage(source.url));
|
||||
entry.loading = pending;
|
||||
pending.then(
|
||||
(image) => {
|
||||
if (entry.loading !== pending || entry.state.destroyed) return;
|
||||
entry.loading = null;
|
||||
entry.image = image;
|
||||
mount(entry);
|
||||
},
|
||||
(error) => {
|
||||
if (entry.loading !== pending) return;
|
||||
entry.loading = null;
|
||||
console.warn('[Imagery] image failed to load:', error);
|
||||
},
|
||||
);
|
||||
}
|
||||
|
||||
// Follow the surface: a layer whose stack is not the current one is
|
||||
// built again there (none: it waits without a layer).
|
||||
const follow = () => {
|
||||
const { collection } = host();
|
||||
for (const entry of entries)
|
||||
if (entry.collection !== collection && (entry.layer || collection))
|
||||
mount(entry);
|
||||
};
|
||||
const watch = () => {
|
||||
if (!removeWatch && scene.preRender)
|
||||
removeWatch = scene.preRender.addEventListener(follow);
|
||||
};
|
||||
const unwatch = () => {
|
||||
if (entries.size || !removeWatch) return;
|
||||
removeWatch();
|
||||
removeWatch = null;
|
||||
};
|
||||
|
||||
const registry = createImageryRegistry(
|
||||
(state) => {
|
||||
let retryTimer = null;
|
||||
const entry = {
|
||||
state,
|
||||
layer: null,
|
||||
collection: null,
|
||||
image: null,
|
||||
loading: null,
|
||||
// One timer per layer: any number of provider deferrals while it is
|
||||
// armed share the same single retry frame.
|
||||
retry: {
|
||||
schedule() {
|
||||
if (retryTimer !== null) return;
|
||||
retryTimer = after(() => {
|
||||
retryTimer = null;
|
||||
if (!state.destroyed) requestRender('imagery-retry');
|
||||
}, TILE_RETRY_DELAY_MS);
|
||||
},
|
||||
cancel() {
|
||||
if (retryTimer !== null) cancel(retryTimer);
|
||||
retryTimer = null;
|
||||
},
|
||||
},
|
||||
};
|
||||
entries.add(entry);
|
||||
watch();
|
||||
load(entry);
|
||||
return {
|
||||
source: () => load(entry),
|
||||
look() {
|
||||
applyLook(entry);
|
||||
requestRender('imagery-look');
|
||||
},
|
||||
ready: () => Boolean(entry.layer?.ready),
|
||||
destroy() {
|
||||
entries.delete(entry);
|
||||
entry.loading = null;
|
||||
entry.retry.cancel();
|
||||
detach(entry);
|
||||
unwatch();
|
||||
requestRender('imagery-destroy');
|
||||
},
|
||||
};
|
||||
},
|
||||
{
|
||||
// The scene's own: the shell's swipe controls set it too.
|
||||
readSplit: () =>
|
||||
Number.isFinite(scene.splitPosition) ? scene.splitPosition : 0.5,
|
||||
splitPosition(fraction) {
|
||||
scene.splitPosition = fraction;
|
||||
requestRender('imagery-split');
|
||||
},
|
||||
surface: () => host().surface,
|
||||
},
|
||||
);
|
||||
return {
|
||||
imagery: registry.imagery,
|
||||
destroy: () => registry.destroyAll(),
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,345 @@
|
||||
import test from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import * as Cesium from 'cesium';
|
||||
import { TILE_RETRY_DELAY_MS, createCesiumImagery } from './imagery.js';
|
||||
|
||||
const BOX = { west: -97.8, south: 30.2, east: -97.7, north: 30.3 };
|
||||
const tiles = (extra = {}) => ({
|
||||
kind: 'tiles',
|
||||
url: 'https://gibs-{s}.example/{z}/{y}/{x}.png',
|
||||
maxLevel: 12,
|
||||
rectangle: BOX,
|
||||
...extra,
|
||||
});
|
||||
const pixels = (width = 4, height = 2) => ({
|
||||
width,
|
||||
height,
|
||||
data: new Uint8ClampedArray(width * height * 4),
|
||||
});
|
||||
|
||||
/** A tile provider whose requests stay pending until the test settles them. */
|
||||
class PendingProvider {
|
||||
constructor(options) {
|
||||
this.options = options;
|
||||
this.calls = [];
|
||||
this.pending = [];
|
||||
// What a Cesium ImageryLayer reads of its provider.
|
||||
this.tilingScheme =
|
||||
options.tilingScheme ?? new Cesium.WebMercatorTilingScheme();
|
||||
this.rectangle = options.rectangle ?? this.tilingScheme.rectangle;
|
||||
this.tileWidth = this.tileHeight = 256;
|
||||
this.minimumLevel = 0;
|
||||
this.maximumLevel = options.maximumLevel ?? 18;
|
||||
this.errorEvent = new Cesium.Event();
|
||||
}
|
||||
requestImage(x, y, level) {
|
||||
this.calls.push([x, y, level]);
|
||||
return new Promise((resolve) => this.pending.push(resolve));
|
||||
}
|
||||
}
|
||||
|
||||
function manualTimers() {
|
||||
const pending = new Map();
|
||||
let next = 1;
|
||||
return {
|
||||
pending,
|
||||
setTimeout(run, ms) {
|
||||
const id = next++;
|
||||
pending.set(id, { run, ms });
|
||||
return id;
|
||||
},
|
||||
clearTimeout: (id) => pending.delete(id),
|
||||
flush() {
|
||||
const entries = [...pending.values()];
|
||||
pending.clear();
|
||||
for (const entry of entries) entry.run();
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
function fixture({ requestImage } = {}) {
|
||||
const preRender = new Cesium.Event();
|
||||
const viewer = {
|
||||
imageryLayers: new Cesium.ImageryLayerCollection(),
|
||||
scene: { globe: { show: true }, preRender, splitPosition: 0.5 },
|
||||
};
|
||||
const renders = [];
|
||||
const timers = manualTimers();
|
||||
const tileset = {
|
||||
show: false,
|
||||
imageryLayers: new Cesium.ImageryLayerCollection(),
|
||||
isDestroyed: () => false,
|
||||
};
|
||||
const providers = [];
|
||||
const { imagery, destroy } = createCesiumImagery(viewer, {
|
||||
requestRender: (reason) => renders.push(reason),
|
||||
tilesets: () => [tileset],
|
||||
createCanvas: (width, height) => ({
|
||||
width,
|
||||
height,
|
||||
getContext: () => ({
|
||||
createImageData: (w, h) => ({ data: new Uint8ClampedArray(w * h * 4) }),
|
||||
putImageData() {},
|
||||
}),
|
||||
}),
|
||||
factories: {
|
||||
tiles(options) {
|
||||
const provider = new PendingProvider(options);
|
||||
if (requestImage) provider.requestImage = requestImage;
|
||||
providers.push(provider);
|
||||
return provider;
|
||||
},
|
||||
},
|
||||
setTimeout: timers.setTimeout,
|
||||
clearTimeout: timers.clearTimeout,
|
||||
});
|
||||
const globe = viewer.imageryLayers;
|
||||
const frame = () => preRender.raiseEvent();
|
||||
return {
|
||||
viewer,
|
||||
imagery,
|
||||
destroy,
|
||||
globe,
|
||||
tileset,
|
||||
providers,
|
||||
renders,
|
||||
timers,
|
||||
frame,
|
||||
tileFrames: () => renders.filter((r) => r === 'imagery-tiles').length,
|
||||
};
|
||||
}
|
||||
|
||||
const layersOf = (collection) =>
|
||||
Array.from({ length: collection.length }, (_, i) => collection.get(i));
|
||||
|
||||
test('a tiles layer is one Web Mercator template provider bounded to its rectangle', () => {
|
||||
const f = fixture();
|
||||
const layer = f.imagery.createLayer({
|
||||
id: 'a',
|
||||
source: tiles({ credit: 'NASA GIBS', opaque: true, maxLevel: 9 }),
|
||||
alpha: 0.8,
|
||||
split: 'left',
|
||||
});
|
||||
const [drawn] = layersOf(f.globe);
|
||||
const { options } = drawn.imageryProvider;
|
||||
assert.equal(options.url, 'https://gibs-{s}.example/{z}/{y}/{x}.png');
|
||||
assert.deepEqual(options.subdomains, ['a', 'b', 'c']);
|
||||
assert.equal(options.maximumLevel, 9);
|
||||
assert.equal(options.hasAlphaChannel, false, 'opaque tiles have no alpha');
|
||||
assert.equal(options.credit, 'NASA GIBS');
|
||||
assert.ok(options.tilingScheme instanceof Cesium.WebMercatorTilingScheme);
|
||||
assert.ok(
|
||||
Cesium.Rectangle.equalsEpsilon(
|
||||
options.rectangle,
|
||||
Cesium.Rectangle.fromDegrees(-97.8, 30.2, -97.7, 30.3),
|
||||
1e-12,
|
||||
),
|
||||
);
|
||||
assert.equal(drawn.alpha, 0.8);
|
||||
assert.equal(drawn.splitDirection, Cesium.SplitDirection.LEFT);
|
||||
assert.equal(layer.ready(), true);
|
||||
layer.setAlpha(0.25);
|
||||
layer.show(false);
|
||||
layer.setSplit('right');
|
||||
assert.deepEqual(layersOf(f.globe), [drawn], 'a restyle keeps the layer');
|
||||
assert.deepEqual(
|
||||
[drawn.alpha, drawn.show, drawn.splitDirection],
|
||||
[0.25, false, Cesium.SplitDirection.RIGHT],
|
||||
);
|
||||
// A new source replaces the layer at its place, keeping the look.
|
||||
f.imagery.createLayer({ id: 'over', source: tiles(), order: 1 });
|
||||
layer.setSource(tiles({ url: 'https://other.example/{z}/{x}/{y}.png' }));
|
||||
const [replaced, over] = layersOf(f.globe);
|
||||
assert.equal(drawn.isDestroyed(), true);
|
||||
assert.equal(
|
||||
replaced.imageryProvider.options.url,
|
||||
'https://other.example/{z}/{x}/{y}.png',
|
||||
);
|
||||
assert.equal(over.imageryProvider.options.url, tiles().url);
|
||||
assert.deepEqual([replaced.alpha, replaced.show], [0.25, false]);
|
||||
f.destroy();
|
||||
assert.equal(f.globe.length, 0);
|
||||
});
|
||||
|
||||
test('an image layer is one geographic tile of the image itself over its rectangle', async () => {
|
||||
const f = fixture();
|
||||
const image = pixels(8, 4);
|
||||
f.imagery.createLayer({ id: 'heat', source: { kind: 'image', image } });
|
||||
const provider = f.globe.get(0).imageryProvider;
|
||||
assert.ok(provider.tilingScheme instanceof Cesium.GeographicTilingScheme);
|
||||
assert.deepEqual(
|
||||
[
|
||||
provider.tileWidth,
|
||||
provider.tileHeight,
|
||||
provider.maximumLevel,
|
||||
provider.tilingScheme.getNumberOfXTilesAtLevel(0),
|
||||
provider.tilingScheme.getNumberOfYTilesAtLevel(0),
|
||||
],
|
||||
[8, 4, 0, 1, 1],
|
||||
);
|
||||
assert.ok(
|
||||
Cesium.Rectangle.equalsEpsilon(
|
||||
provider.rectangle,
|
||||
Cesium.Rectangle.fromDegrees(-180, -90, 180, 90),
|
||||
1e-12,
|
||||
),
|
||||
);
|
||||
const drawn = await provider.requestImage(0, 0, 0);
|
||||
assert.equal(drawn.width, 8, 'RGBA bytes go on a canvas');
|
||||
assert.equal(typeof drawn.getContext, 'function');
|
||||
});
|
||||
|
||||
test('layers sit over the base imagery in their order, then creation; others stay put', () => {
|
||||
const f = fixture();
|
||||
const base = new Cesium.ImageryLayer(new PendingProvider({}));
|
||||
f.globe.add(base);
|
||||
f.imagery.createLayer({ id: 'high', source: tiles(), order: 5 });
|
||||
f.imagery.createLayer({ id: 'low', source: tiles(), order: -1 });
|
||||
f.imagery.createLayer({ id: 'mid', source: tiles() });
|
||||
f.imagery.createLayer({ id: 'mid-later', source: tiles() });
|
||||
assert.deepEqual(
|
||||
f.imagery.list().map(({ id }) => id),
|
||||
['low', 'mid', 'mid-later', 'high'],
|
||||
);
|
||||
const layers = layersOf(f.globe);
|
||||
assert.equal(layers[0], base);
|
||||
assert.equal(layers.length, 5);
|
||||
// Each engine layer's provider was made in creation order.
|
||||
const created = ['high', 'low', 'mid', 'mid-later'];
|
||||
const drawnOrder = layers
|
||||
.slice(1)
|
||||
.map((layer) => created[f.providers.indexOf(layer.imageryProvider)]);
|
||||
assert.deepEqual(drawnOrder, ['low', 'mid', 'mid-later', 'high']);
|
||||
});
|
||||
|
||||
test('the layers follow the surface: the globe, a shown tileset, none, and back', () => {
|
||||
const f = fixture();
|
||||
const layer = f.imagery.createLayer({
|
||||
id: 'a',
|
||||
source: tiles(),
|
||||
alpha: 0.6,
|
||||
split: 'left',
|
||||
});
|
||||
assert.equal(f.imagery.surface(), 'globe');
|
||||
f.viewer.scene.globe.show = false;
|
||||
f.tileset.show = true;
|
||||
assert.equal(f.imagery.surface(), 'tiles');
|
||||
f.frame();
|
||||
assert.equal(f.globe.length, 0, 'the globe stack is left empty');
|
||||
const [onTiles] = layersOf(f.tileset.imageryLayers);
|
||||
assert.deepEqual(
|
||||
[onTiles.alpha, onTiles.splitDirection],
|
||||
[0.6, Cesium.SplitDirection.LEFT],
|
||||
);
|
||||
f.tileset.show = false;
|
||||
assert.equal(f.imagery.surface(), 'none');
|
||||
f.frame();
|
||||
assert.equal(f.tileset.imageryLayers.length, 0);
|
||||
assert.equal(layer.ready(), false, 'no surface: nothing drawn');
|
||||
f.viewer.scene.globe.show = true;
|
||||
f.frame();
|
||||
assert.equal(f.globe.length, 1);
|
||||
assert.equal(layer.ready(), true);
|
||||
layer.destroy();
|
||||
assert.equal(f.globe.length, 0);
|
||||
assert.equal(f.viewer.scene.preRender.numberOfListeners, 0, 'unwatched');
|
||||
});
|
||||
|
||||
test('the split position is the scene’s, set by the engine or the shell', () => {
|
||||
const f = fixture();
|
||||
assert.equal(f.imagery.splitPosition(), 0.5);
|
||||
f.imagery.setSplitPosition(0.3);
|
||||
assert.equal(f.viewer.scene.splitPosition, 0.3);
|
||||
// The shell's swipe writes the scene too: the engine reads it.
|
||||
f.viewer.scene.splitPosition = 0.7;
|
||||
assert.equal(f.imagery.splitPosition(), 0.7);
|
||||
f.imagery.setSplitPosition(0.3);
|
||||
assert.equal(f.viewer.scene.splitPosition, 0.3);
|
||||
});
|
||||
|
||||
test('above maxRequests a tile request defers silently; its settlement asks for one frame', async () => {
|
||||
const f = fixture();
|
||||
f.imagery.createLayer({ id: 'a', source: tiles({ maxRequests: 1 }) });
|
||||
const provider = f.globe.get(0).imageryProvider;
|
||||
const first = provider.requestImage(0, 0, 1);
|
||||
assert.ok(first instanceof Promise);
|
||||
for (let i = 1; i <= 120; i += 1)
|
||||
assert.equal(provider.requestImage(i, 0, 1), undefined);
|
||||
assert.equal(
|
||||
f.providers[0].calls.length,
|
||||
1,
|
||||
'deferred requests never go out',
|
||||
);
|
||||
assert.equal(f.tileFrames(), 0, 'a deferral asks for no frame');
|
||||
assert.equal(f.timers.pending.size, 0);
|
||||
f.providers[0].pending[0]('tile');
|
||||
await first;
|
||||
assert.equal(f.tileFrames(), 1, 'the settlement asks for the retry frame');
|
||||
assert.ok(provider.requestImage(200, 0, 1) instanceof Promise);
|
||||
});
|
||||
|
||||
test('provider deferrals share one delayed retry frame per layer; destroy disarms it', () => {
|
||||
let throwNext = false;
|
||||
const f = fixture({
|
||||
requestImage() {
|
||||
if (throwNext) throw new Error('boom');
|
||||
return undefined;
|
||||
},
|
||||
});
|
||||
const layer = f.imagery.createLayer({
|
||||
id: 'a',
|
||||
source: tiles({ maxRequests: 1 }),
|
||||
});
|
||||
const provider = f.globe.get(0).imageryProvider;
|
||||
for (let i = 0; i < 40; i += 1)
|
||||
assert.equal(provider.requestImage(i, 0, 0), undefined);
|
||||
assert.equal(f.timers.pending.size, 1);
|
||||
assert.equal([...f.timers.pending.values()][0].ms, TILE_RETRY_DELAY_MS);
|
||||
f.timers.flush();
|
||||
assert.equal(
|
||||
f.renders.filter((reason) => reason === 'imagery-retry').length,
|
||||
1,
|
||||
);
|
||||
// A throwing provider releases its slot too.
|
||||
throwNext = true;
|
||||
assert.throws(() => provider.requestImage(0, 0, 0), /boom/);
|
||||
throwNext = false;
|
||||
provider.requestImage(0, 0, 0);
|
||||
assert.equal(f.timers.pending.size, 1, 'the next deferral arms a timer');
|
||||
layer.destroy();
|
||||
assert.equal(f.timers.pending.size, 0, 'destroy disarms the retry');
|
||||
});
|
||||
|
||||
test('an image URL draws once it has loaded; a newer source wins', async () => {
|
||||
const loads = [];
|
||||
const preRender = new Cesium.Event();
|
||||
const viewer = {
|
||||
imageryLayers: new Cesium.ImageryLayerCollection(),
|
||||
scene: { globe: { show: true }, preRender },
|
||||
};
|
||||
const { imagery } = createCesiumImagery(viewer, {
|
||||
requestRender() {},
|
||||
factories: {
|
||||
loadImage: (url) =>
|
||||
new Promise((resolve) => loads.push({ url, resolve })),
|
||||
},
|
||||
});
|
||||
const layer = imagery.createLayer({
|
||||
id: 'event',
|
||||
source: { kind: 'image', url: 'before.webp', rectangle: BOX },
|
||||
});
|
||||
assert.equal(viewer.imageryLayers.length, 0);
|
||||
assert.equal(layer.ready(), false);
|
||||
layer.setSource({ kind: 'image', url: 'after.webp', rectangle: BOX });
|
||||
loads[0].resolve({ width: 2, height: 2, name: 'before' });
|
||||
await Promise.resolve();
|
||||
assert.equal(viewer.imageryLayers.length, 0, 'a superseded load is dropped');
|
||||
loads[1].resolve({ width: 2, height: 2, name: 'after' });
|
||||
await new Promise((resolve) => setImmediate(resolve));
|
||||
assert.equal(viewer.imageryLayers.length, 1);
|
||||
const image = await viewer.imageryLayers
|
||||
.get(0)
|
||||
.imageryProvider.requestImage(0, 0, 0);
|
||||
assert.equal(image.name, 'after');
|
||||
assert.equal(layer.ready(), true);
|
||||
});
|
||||
@@ -66,7 +66,7 @@ const dispose = (value) => {
|
||||
* credits?: object,
|
||||
* loadPhotorealTileset?: (credentials: object) => Promise<{ tileset: object | null, errors: Error[] }>,
|
||||
* }} [options] `tilesetRef` names the startup Google tileset the app added.
|
||||
* @returns {{ maps: object, destroy: () => void }}
|
||||
* @returns {{ maps: object, tilesets: () => object[], destroy: () => void }}
|
||||
*/
|
||||
export function createCesiumMaps(
|
||||
viewer,
|
||||
@@ -221,6 +221,8 @@ export function createCesiumMaps(
|
||||
|
||||
return {
|
||||
maps,
|
||||
/** Every tileset the map may show (engine.imagery drapes on a shown one). */
|
||||
tilesets,
|
||||
destroy() {
|
||||
if (destroyed) return;
|
||||
destroyed = true;
|
||||
|
||||
Reference in new issue
Block a user