mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 08:12:24 +00:00
render: Cesium draws raster-shell fields; weather shells use the draw port
The Cesium draw port now implements draw.field for the rasterShell kind and advertises the 'fields' capability. The shell surface (a raised rectangle with a detail window, drawn in primitive order without depth writes) moves from the weather layer into src/render/cesium/drawFields.js. A new rectangle or height is drawn invisibly first and swapped in whole, and 'drawn' is told in the frame of the swap. A stage of older content never replaces the drawn one while newer content decodes. A field hidden mid-stage keeps building it. The weather shell (src/layers/weather/shellRendering.js) now drives one field through the draw, camera, frame and globe ports and no longer imports Cesium, so it leaves the Cesium allow list. The wind shell on photoreal hosts also draws through draw.field. The conformance page runs each visual scene on its own, so a kind the Cesium renderer does not draw yet (scalarRaster) fails only its own scene.
This commit is contained in:
1 parent
4fc7d66639
commit
50cb7bd5f4
16 files changed
+1765
-761
No files matched your search
@@ -0,0 +1,645 @@
|
||||
import test from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import * as Cesium from 'cesium';
|
||||
import {
|
||||
createCesiumFields,
|
||||
createShellSurface,
|
||||
orderShells,
|
||||
} from './drawFields.js';
|
||||
import {
|
||||
createShellCesium,
|
||||
createShellScene,
|
||||
renderShells,
|
||||
} from '../../layers/weather/shellFixture.mjs';
|
||||
|
||||
// The detail window uniform; NONE is the empty window.
|
||||
const NONE = { x: 0, y: 0, z: -1, w: -1 };
|
||||
const windowOf = (primitive) => {
|
||||
const { x, y, z, w } = primitive.appearance.material.uniforms.window;
|
||||
return { x, y, z, w };
|
||||
};
|
||||
|
||||
test('surface builds a flat raised rectangle drawn in primitive order without depth writes', () => {
|
||||
const cesium = createShellCesium();
|
||||
const scene = createShellScene();
|
||||
const rectangle = Cesium.Rectangle.fromDegrees(-130, 20, -60, 55);
|
||||
const surface = createShellSurface({
|
||||
scene,
|
||||
cesium,
|
||||
rectangle,
|
||||
height: 6_200,
|
||||
});
|
||||
const template = cesium.templates.get('DrawRasterShell');
|
||||
assert.ok(!(template instanceof cesium.Material), 'plain template');
|
||||
assert.deepEqual(template.fabric.uniforms, {
|
||||
image: Cesium.Material.DefaultImageId,
|
||||
detail: Cesium.Material.DefaultImageId,
|
||||
alpha: 1,
|
||||
window: { type: 'vec4', x: 0, y: 0, z: -1, w: -1 },
|
||||
});
|
||||
const { source } = template.fabric;
|
||||
assert.match(
|
||||
source,
|
||||
/material\.alpha = c\.a \* alpha \* step\(1\.5, float\(imageDimensions\.x\)\);/,
|
||||
'nothing draws before the full-extent image',
|
||||
);
|
||||
assert.match(
|
||||
source,
|
||||
/float useDetail = inside \* step\(1\.5, float\(detailDimensions\.x\)\);/,
|
||||
'the detail image is sampled only once it has arrived',
|
||||
);
|
||||
assert.match(
|
||||
source,
|
||||
/all\(greaterThanEqual\(st, window\.xy\)\) && all\(lessThanEqual\(st, window\.zw\)\)/,
|
||||
);
|
||||
assert.match(
|
||||
source,
|
||||
/mix\(coarse, texture\(detail, clamp\(dst, 0\.0, 1\.0\)\), useDetail\)/,
|
||||
);
|
||||
assert.match(source, /material\.diffuse = czm_gammaCorrect\(c\.rgb\);/);
|
||||
const [primitive] = scene.primitives.items;
|
||||
const appearance = primitive.appearance;
|
||||
assert.equal(appearance.material.options.translucent, false);
|
||||
assert.deepEqual(
|
||||
{ ...appearance.options, material: undefined },
|
||||
{
|
||||
aboveGround: true,
|
||||
flat: true,
|
||||
translucent: false,
|
||||
material: undefined,
|
||||
},
|
||||
);
|
||||
assert.deepEqual(appearance.getRenderState(), {
|
||||
depthTest: { enabled: true },
|
||||
depthMask: false,
|
||||
blending: Cesium.BlendingState.ALPHA_BLEND,
|
||||
});
|
||||
const geometry = primitive.options.geometryInstances.geometry.options;
|
||||
assert.equal(geometry.rectangle, rectangle);
|
||||
assert.equal(geometry.height, 6_200);
|
||||
assert.equal(geometry.granularity, Cesium.Math.toRadians(0.5));
|
||||
assert.equal(
|
||||
geometry.vertexFormat,
|
||||
Cesium.EllipsoidSurfaceAppearance.VERTEX_FORMAT,
|
||||
);
|
||||
assert.equal(primitive.options.asynchronous, true);
|
||||
assert.equal(primitive.options.allowPicking, false);
|
||||
const lower = createShellSurface({
|
||||
scene,
|
||||
cesium,
|
||||
rectangle,
|
||||
height: 5_000,
|
||||
});
|
||||
assert.equal(cesium.templates.size, 1, 'the template registers once');
|
||||
assert.deepEqual(
|
||||
scene.primitives.items.map(
|
||||
(item) => item.options.geometryInstances.geometry.options.height,
|
||||
),
|
||||
[5_000, 6_200],
|
||||
);
|
||||
lower.destroy();
|
||||
surface.destroy();
|
||||
});
|
||||
|
||||
test('a surface applies a new detail window only once its image has drawn; the same window swaps only the image', () => {
|
||||
const cesium = createShellCesium();
|
||||
const scene = createShellScene();
|
||||
const surface = createShellSurface({
|
||||
scene,
|
||||
cesium,
|
||||
rectangle: Cesium.Rectangle.fromDegrees(-130, 20, -60, 55),
|
||||
height: 6_200,
|
||||
});
|
||||
const [primitive] = scene.primitives.items;
|
||||
const { uniforms } = primitive.appearance.material;
|
||||
const render = (count) => renderShells(cesium, scene, count);
|
||||
const image = () => ({ width: 4096, height: 2048 });
|
||||
surface.setImage(image());
|
||||
render();
|
||||
assert.deepEqual(surface.getDiagnostics().detail, {
|
||||
uploaded: false,
|
||||
window: null,
|
||||
});
|
||||
const a = { west: 0.25, south: 0.5, east: 0.5, north: 0.75 };
|
||||
const first = image();
|
||||
surface.setDetail(first, a);
|
||||
assert.equal(uniforms.detail, first);
|
||||
assert.deepEqual(windowOf(primitive), NONE, 'the full-extent image covers');
|
||||
assert.equal(scene.postRender.size, 1, 'renders until the detail has drawn');
|
||||
render(2);
|
||||
assert.deepEqual(windowOf(primitive), NONE);
|
||||
render(1);
|
||||
assert.deepEqual(windowOf(primitive), { x: 0.25, y: 0.5, z: 0.5, w: 0.75 });
|
||||
assert.ok(uniforms.window instanceof Cesium.Cartesian4);
|
||||
assert.deepEqual(surface.getDiagnostics().detail, {
|
||||
uploaded: true,
|
||||
window: a,
|
||||
});
|
||||
assert.equal(scene.postRender.size, 0);
|
||||
|
||||
// A time change in the same window: Cesium keeps drawing the previous
|
||||
// texture until the new one is uploaded, so the window stays.
|
||||
const applied = uniforms.window;
|
||||
const second = image();
|
||||
surface.setDetail(second, { ...a });
|
||||
assert.equal(uniforms.detail, second);
|
||||
assert.equal(uniforms.window, applied, 'only the image is written');
|
||||
assert.equal(surface.getDiagnostics().detail.uploaded, false);
|
||||
render();
|
||||
assert.equal(surface.getDiagnostics().detail.uploaded, true);
|
||||
assert.equal(uniforms.window, applied);
|
||||
const renders = scene.renders;
|
||||
surface.setDetail(second, { ...a });
|
||||
assert.equal(scene.renders, renders, 'an unchanged detail costs nothing');
|
||||
assert.equal(scene.postRender.size, 0);
|
||||
|
||||
// A different window empties at once and applies once its image has drawn.
|
||||
const b = { west: 0.5, south: 0.25, east: 0.75, north: 0.5 };
|
||||
surface.setDetail(image(), b);
|
||||
assert.deepEqual(windowOf(primitive), NONE);
|
||||
render(2);
|
||||
assert.deepEqual(windowOf(primitive), NONE);
|
||||
render(1);
|
||||
assert.deepEqual(windowOf(primitive), { x: 0.5, y: 0.25, z: 0.75, w: 0.5 });
|
||||
|
||||
surface.setDetail(null);
|
||||
assert.equal(uniforms.detail, Cesium.Material.DefaultImageId);
|
||||
assert.deepEqual(windowOf(primitive), NONE);
|
||||
assert.deepEqual(surface.getDiagnostics().detail, {
|
||||
uploaded: false,
|
||||
window: null,
|
||||
});
|
||||
render();
|
||||
assert.deepEqual(
|
||||
{ ...uniforms.detailDimensions },
|
||||
{ type: 'ivec3', x: 1, y: 1 },
|
||||
);
|
||||
// Counted renders alone are not enough: the bound texture must be this image.
|
||||
surface.setDetail(image(), a);
|
||||
for (let i = 0; i < 4; i++) scene.postRender.emit();
|
||||
assert.deepEqual(windowOf(primitive), NONE, 'still the 1×1 default');
|
||||
render(1);
|
||||
assert.deepEqual(windowOf(primitive), { x: 0.25, y: 0.5, z: 0.5, w: 0.75 });
|
||||
surface.destroy();
|
||||
surface.setDetail(image(), b);
|
||||
assert.deepEqual(windowOf(primitive), { x: 0.25, y: 0.5, z: 0.5, w: 0.75 });
|
||||
assert.equal(scene.postRender.size, 0);
|
||||
});
|
||||
|
||||
test("a surface rises by a uniform scale about the Earth's centre", () => {
|
||||
const scene = {
|
||||
primitives: new Cesium.PrimitiveCollection(),
|
||||
postRender: new Cesium.Event(),
|
||||
requestRender() {},
|
||||
};
|
||||
const surface = createShellSurface({
|
||||
scene,
|
||||
cesium: Cesium,
|
||||
rectangle: Cesium.Rectangle.fromDegrees(-130, 20, -60, 55),
|
||||
height: 5_800,
|
||||
});
|
||||
const primitive = scene.primitives.get(0);
|
||||
const identity = primitive.modelMatrix;
|
||||
surface.setLift(0);
|
||||
assert.equal(primitive.modelMatrix, identity, 'no lift, no new matrix');
|
||||
surface.setLift(32_000);
|
||||
const radius = Cesium.Ellipsoid.WGS84.maximumRadius;
|
||||
assert.ok(
|
||||
Math.abs(primitive.modelMatrix[0] * radius - (radius + 32_000)) < 1e-3,
|
||||
);
|
||||
const lifted = primitive.modelMatrix;
|
||||
surface.setLift(32_000);
|
||||
assert.equal(primitive.modelMatrix, lifted, 'the same lift keeps the matrix');
|
||||
surface.destroy();
|
||||
});
|
||||
|
||||
test('real Cesium builds the two-texture material, the opaque-pass appearance and the rectangle primitive', () => {
|
||||
const scene = {
|
||||
primitives: new Cesium.PrimitiveCollection(),
|
||||
postRender: new Cesium.Event(),
|
||||
requestRender() {},
|
||||
};
|
||||
const surface = createShellSurface({
|
||||
scene,
|
||||
cesium: Cesium,
|
||||
rectangle: Cesium.Rectangle.fromDegrees(-130, 20, -60, 55),
|
||||
height: 6_600,
|
||||
});
|
||||
const cached = Cesium.Material._materialCache.getMaterial('DrawRasterShell');
|
||||
assert.ok(cached && !(cached instanceof Cesium.Material));
|
||||
const primitive = scene.primitives.get(0);
|
||||
const material = primitive.appearance.material;
|
||||
assert.ok(primitive instanceof Cesium.Primitive);
|
||||
assert.equal(material.type, 'DrawRasterShell');
|
||||
assert.equal(material.isTranslucent(), false);
|
||||
assert.equal(primitive.appearance.isTranslucent(), false, 'opaque pass');
|
||||
assert.equal(primitive.appearance.getRenderState().depthMask, false);
|
||||
assert.equal(
|
||||
Cesium.Appearance.prototype.getRenderState.call(primitive.appearance)
|
||||
.depthMask,
|
||||
true,
|
||||
'the default opaque render state would write depth',
|
||||
);
|
||||
assert.deepEqual(
|
||||
[material.uniforms.imageDimensions.x, material.uniforms.detailDimensions.x],
|
||||
[1, 1],
|
||||
'Cesium tracks both bound texture sizes',
|
||||
);
|
||||
const shader = material.shaderSource;
|
||||
for (const declaration of [
|
||||
/uniform sampler2D image_\d+;/,
|
||||
/uniform sampler2D detail_\d+;/,
|
||||
/uniform float alpha_\d+;/,
|
||||
/uniform vec4 window_\d+;/,
|
||||
/uniform ivec3 imageDimensions_\d+;/,
|
||||
/uniform ivec3 detailDimensions_\d+;/,
|
||||
])
|
||||
assert.match(shader, declaration);
|
||||
assert.match(shader, /texture\(image_\d+, st\)/);
|
||||
assert.match(shader, /texture\(detail_\d+, clamp\(dst, 0\.0, 1\.0\)\)/);
|
||||
assert.match(shader, /lessThanEqual\(st, window_\d+\.zw\)/);
|
||||
assert.match(shader, /step\(1\.5, float\(detailDimensions_\d+\.x\)\)/);
|
||||
assert.match(
|
||||
shader,
|
||||
/material\.alpha = c\.a \* alpha_\d+ \* step\(1\.5, float\(imageDimensions_\d+\.x\)\);/,
|
||||
'the uniform is renamed, the material field is not',
|
||||
);
|
||||
assert.match(shader, /float useDetail = inside \* step/, 'locals keep names');
|
||||
const detail = { width: 4096, height: 2048 };
|
||||
surface.setDetail(detail, { west: 0.1, south: 0.2, east: 0.3, north: 0.4 });
|
||||
assert.equal(material.uniforms.detail, detail);
|
||||
assert.deepEqual(
|
||||
[material.uniforms.window.z, material.uniforms.window.w],
|
||||
[-1, -1],
|
||||
'no window before the image has drawn',
|
||||
);
|
||||
surface.setDetail(null);
|
||||
assert.equal(material.uniforms.detail, Cesium.Material.DefaultImageId);
|
||||
surface.setAlpha(0.4);
|
||||
assert.equal(material.uniforms.alpha, 0.4);
|
||||
surface.destroy();
|
||||
assert.equal(scene.primitives.length, 0);
|
||||
assert.equal(primitive.isDestroyed(), true);
|
||||
assert.equal(material.isDestroyed(), true);
|
||||
assert.equal(scene.postRender.numberOfListeners, 0);
|
||||
});
|
||||
|
||||
test('shells draw first, in height order, regardless of add order', () => {
|
||||
const scene = createShellScene();
|
||||
const other = { name: 'other' };
|
||||
scene.primitives.add(other);
|
||||
const add = (name, height) => {
|
||||
const primitive = { name };
|
||||
scene.primitives.add(primitive);
|
||||
orderShells(scene.primitives, primitive, height);
|
||||
return primitive;
|
||||
};
|
||||
add('lightning', 6_600);
|
||||
add('radar', 6_200);
|
||||
add('wind', 5_000);
|
||||
const later = { name: 'later' };
|
||||
scene.primitives.add(later);
|
||||
add('regional', 5_800);
|
||||
assert.deepEqual(
|
||||
scene.primitives.items.map(({ name }) => name),
|
||||
['wind', 'regional', 'radar', 'lightning', 'other', 'later'],
|
||||
);
|
||||
const primitives = new Cesium.PrimitiveCollection({
|
||||
destroyPrimitives: false,
|
||||
});
|
||||
const real = (name) => ({ name, update() {}, isDestroyed: () => false });
|
||||
const tileset = primitives.add(real('tileset'));
|
||||
const lightning = primitives.add(real('lightning'));
|
||||
orderShells(primitives, lightning, 6_600);
|
||||
const radar = primitives.add(real('radar'));
|
||||
orderShells(primitives, radar, 6_200);
|
||||
assert.deepEqual(
|
||||
[0, 1, 2].map((i) => primitives.get(i).name),
|
||||
['radar', 'lightning', 'tileset'],
|
||||
'real Cesium collection order',
|
||||
);
|
||||
assert.equal(tileset.name, 'tileset');
|
||||
});
|
||||
|
||||
test('hidden frames do not count towards a pending detail window', () => {
|
||||
const cesium = createShellCesium();
|
||||
const scene = createShellScene();
|
||||
const surface = createShellSurface({
|
||||
scene,
|
||||
cesium,
|
||||
rectangle: Cesium.Rectangle.fromDegrees(-130, 20, -60, 55),
|
||||
height: 6_200,
|
||||
});
|
||||
const [primitive] = scene.primitives.items;
|
||||
const render = (count) => renderShells(cesium, scene, count);
|
||||
const image = () => ({ width: 4096, height: 2048 });
|
||||
surface.setImage(image());
|
||||
const a = { west: 0.25, south: 0.5, east: 0.5, north: 0.75 };
|
||||
surface.setDetail(image(), a);
|
||||
render();
|
||||
assert.deepEqual(windowOf(primitive), { x: 0.25, y: 0.5, z: 0.5, w: 0.75 });
|
||||
// A different window with a same-sized image: the dimensions alone cannot
|
||||
// tell the textures apart, so only shown frames may count.
|
||||
const b = { west: 0.5, south: 0.25, east: 0.75, north: 0.5 };
|
||||
surface.setDetail(image(), b);
|
||||
assert.deepEqual(windowOf(primitive), NONE);
|
||||
for (let i = 0; i < 3; i++) {
|
||||
surface.setShow(false);
|
||||
scene.postRender.emit();
|
||||
surface.setShow(true);
|
||||
}
|
||||
assert.deepEqual(windowOf(primitive), NONE, 'hidden frames counted nothing');
|
||||
render(2);
|
||||
assert.deepEqual(windowOf(primitive), NONE);
|
||||
render(1);
|
||||
assert.deepEqual(windowOf(primitive), { x: 0.5, y: 0.25, z: 0.75, w: 0.5 });
|
||||
});
|
||||
|
||||
function fieldHarness() {
|
||||
const cesium = createShellCesium();
|
||||
const scene = createShellScene();
|
||||
const fields = createCesiumFields({ scene, cesium });
|
||||
const image = () => ({ canvas: { width: 64, height: 32 }, key: 'k' });
|
||||
const render = (count = 4) => renderShells(cesium, scene, count);
|
||||
const live = () => scene.primitives.items.filter((p) => !p.destroyed);
|
||||
return { cesium, scene, fields, image, render, live };
|
||||
}
|
||||
const RECT = { west: -100, south: 20, east: -60, north: 40 };
|
||||
|
||||
test("a raster shell tells 'drawn' once its content is drawn, once per change", () => {
|
||||
const h = fieldHarness();
|
||||
const field = h.fields.field({
|
||||
kind: 'rasterShell',
|
||||
id: 'shell',
|
||||
image: h.image(),
|
||||
rectangle: RECT,
|
||||
heightM: 6_000,
|
||||
alpha: 0.5,
|
||||
});
|
||||
let drawn = 0;
|
||||
field.on('drawn', () => (drawn += 1));
|
||||
const [primitive] = h.live();
|
||||
const { uniforms } = primitive.appearance.material;
|
||||
assert.equal(uniforms.alpha, 0, 'invisible until drawable');
|
||||
h.render();
|
||||
assert.equal(drawn, 1);
|
||||
assert.equal(uniforms.alpha, 0.5);
|
||||
assert.equal(h.scene.postRender.size, 0, 'no frames once drawn');
|
||||
field.update({ alpha: 0.3, liftM: 1_000 });
|
||||
assert.equal(uniforms.alpha, 0.3);
|
||||
assert.notEqual(primitive.modelMatrix, undefined, 'lifted');
|
||||
assert.deepEqual(h.live(), [primitive], 'alpha and lift never rebuild');
|
||||
h.render();
|
||||
assert.equal(drawn, 2);
|
||||
field.show = false;
|
||||
field.update({ alpha: 0.4 });
|
||||
h.render();
|
||||
assert.equal(drawn, 2, 'never while hidden');
|
||||
field.show = true;
|
||||
h.render();
|
||||
assert.equal(drawn, 3, 'told once shown');
|
||||
h.render();
|
||||
assert.equal(drawn, 3);
|
||||
field.dispose();
|
||||
assert.equal(h.live().length, 0);
|
||||
assert.equal(h.scene.postRender.size, 0);
|
||||
});
|
||||
|
||||
test('a raster shell keeps drawing its rectangle until a new one is drawn whole', () => {
|
||||
const h = fieldHarness();
|
||||
const first = h.image();
|
||||
const field = h.fields.field({
|
||||
kind: 'rasterShell',
|
||||
id: 'shell',
|
||||
image: first,
|
||||
rectangle: RECT,
|
||||
heightM: 6_000,
|
||||
});
|
||||
let drawn = 0;
|
||||
field.on('drawn', () => (drawn += 1));
|
||||
h.render();
|
||||
const [old] = h.live();
|
||||
const second = h.image();
|
||||
field.update({
|
||||
image: second,
|
||||
rectangle: { west: -120, south: 10, east: -50, north: 50 },
|
||||
});
|
||||
const [, staged] = h.live();
|
||||
assert.equal(old.appearance.material.uniforms.alpha, 1, 'the old one draws');
|
||||
assert.equal(staged.appearance.material.uniforms.alpha, 0);
|
||||
assert.equal(staged.appearance.material.uniforms.image, second.canvas);
|
||||
h.render();
|
||||
assert.equal(old.destroyed, true, 'swapped in one frame');
|
||||
assert.deepEqual(h.live(), [staged]);
|
||||
assert.equal(staged.appearance.material.uniforms.alpha, 1);
|
||||
assert.equal(drawn, 2);
|
||||
// Back to the drawn rectangle before a staged one is drawn: it goes.
|
||||
field.update({ rectangle: RECT });
|
||||
assert.equal(h.live().length, 2);
|
||||
field.update({ rectangle: { west: -120, south: 10, east: -50, north: 50 } });
|
||||
assert.deepEqual(h.live(), [staged]);
|
||||
field.dispose();
|
||||
});
|
||||
|
||||
test('a raster shell draws its detail in its own rectangle, in texture coordinates', () => {
|
||||
const h = fieldHarness();
|
||||
const field = h.fields.field({
|
||||
kind: 'rasterShell',
|
||||
id: 'shell',
|
||||
image: h.image(),
|
||||
rectangle: RECT,
|
||||
heightM: 6_000,
|
||||
});
|
||||
h.render();
|
||||
const [primitive] = h.live();
|
||||
const detail = h.image();
|
||||
field.update({
|
||||
detail: {
|
||||
image: detail,
|
||||
rectangle: { west: -90, south: 25, east: -80, north: 30 },
|
||||
},
|
||||
});
|
||||
assert.deepEqual(windowOf(primitive), NONE, 'the full image covers it');
|
||||
h.render();
|
||||
assert.equal(primitive.appearance.material.uniforms.detail, detail.canvas);
|
||||
assert.deepEqual(windowOf(primitive), {
|
||||
x: 0.25,
|
||||
y: 0.25,
|
||||
z: 0.5,
|
||||
w: 0.5,
|
||||
});
|
||||
field.update({ detail: null });
|
||||
assert.deepEqual(windowOf(primitive), NONE);
|
||||
field.dispose();
|
||||
});
|
||||
|
||||
test('a raster shell hidden while a new rectangle stages still swaps it in', () => {
|
||||
const h = fieldHarness();
|
||||
const field = h.fields.field({
|
||||
kind: 'rasterShell',
|
||||
id: 'shell',
|
||||
image: h.image(),
|
||||
rectangle: RECT,
|
||||
heightM: 6_000,
|
||||
});
|
||||
let drawn = 0;
|
||||
field.on('drawn', () => (drawn += 1));
|
||||
h.render();
|
||||
const [old] = h.live();
|
||||
field.show = false;
|
||||
field.update({
|
||||
image: h.image(),
|
||||
rectangle: { west: -120, south: 10, east: -50, north: 50 },
|
||||
});
|
||||
h.render();
|
||||
const [staged] = h.live();
|
||||
assert.equal(old.destroyed, true, 'drawn invisibly and swapped in');
|
||||
assert.notEqual(staged, old);
|
||||
assert.equal(staged.show, false, 'and kept hidden');
|
||||
assert.equal(drawn, 1, 'never told while hidden');
|
||||
field.show = true;
|
||||
h.render();
|
||||
assert.equal(staged.show, true);
|
||||
assert.equal(drawn, 2);
|
||||
field.dispose();
|
||||
});
|
||||
|
||||
test("a raster shell tells 'drawn' for a detail only once its window is placed", () => {
|
||||
const h = fieldHarness();
|
||||
const field = h.fields.field({
|
||||
kind: 'rasterShell',
|
||||
id: 'shell',
|
||||
image: h.image(),
|
||||
rectangle: RECT,
|
||||
heightM: 6_000,
|
||||
});
|
||||
h.render();
|
||||
const [primitive] = h.live();
|
||||
const windows = [];
|
||||
field.on('drawn', () => windows.push(windowOf(primitive)));
|
||||
field.update({
|
||||
detail: {
|
||||
image: h.image(),
|
||||
rectangle: { west: -90, south: 25, east: -80, north: 30 },
|
||||
},
|
||||
});
|
||||
h.render();
|
||||
assert.deepEqual(windows, [{ x: 0.25, y: 0.25, z: 0.5, w: 0.5 }]);
|
||||
field.dispose();
|
||||
});
|
||||
|
||||
test("a raster shell tells 'drawn' in the frame its new rectangle replaces the old", () => {
|
||||
const h = fieldHarness();
|
||||
const field = h.fields.field({
|
||||
kind: 'rasterShell',
|
||||
id: 'shell',
|
||||
image: h.image(),
|
||||
rectangle: RECT,
|
||||
heightM: 6_000,
|
||||
});
|
||||
h.render();
|
||||
const [old] = h.live();
|
||||
let drawnAt = null;
|
||||
let render = 0;
|
||||
field.on('drawn', () => (drawnAt = render));
|
||||
field.update({ rectangle: { west: -120, south: 10, east: -50, north: 50 } });
|
||||
let swappedAt = null;
|
||||
for (render = 1; render <= 6; render++) {
|
||||
h.render(1);
|
||||
if (old.destroyed && swappedAt === null) swappedAt = render;
|
||||
}
|
||||
assert.ok(swappedAt > 1, 'staged while uploading');
|
||||
assert.equal(drawnAt, swappedAt, 'nothing comes between the swap and drawn');
|
||||
field.dispose();
|
||||
});
|
||||
|
||||
test('a raster shell hidden after a new rectangle stages still builds and swaps it', () => {
|
||||
const h = fieldHarness();
|
||||
const field = h.fields.field({
|
||||
kind: 'rasterShell',
|
||||
id: 'shell',
|
||||
image: h.image(),
|
||||
rectangle: RECT,
|
||||
heightM: 6_000,
|
||||
});
|
||||
let drawn = 0;
|
||||
field.on('drawn', () => (drawn += 1));
|
||||
h.render();
|
||||
const [old] = h.live();
|
||||
field.update({ rectangle: { west: -120, south: 10, east: -50, north: 50 } });
|
||||
field.show = false;
|
||||
h.render();
|
||||
const [staged] = h.live();
|
||||
assert.equal(old.destroyed, true);
|
||||
assert.notEqual(staged, old);
|
||||
assert.equal(staged.show, false);
|
||||
assert.equal(h.scene.postRender.size, 0, 'no frames once built');
|
||||
assert.equal(drawn, 1);
|
||||
field.show = true;
|
||||
h.render();
|
||||
assert.equal(drawn, 2);
|
||||
field.dispose();
|
||||
});
|
||||
|
||||
test('a raster shell never swaps in a stage superseded by content still decoding', async (t) => {
|
||||
const pending = [];
|
||||
const Image = globalThis.Image;
|
||||
globalThis.Image = class {
|
||||
decode() {
|
||||
return new Promise((resolve, reject) =>
|
||||
pending.push({ resolve, reject }),
|
||||
);
|
||||
}
|
||||
};
|
||||
t.after(() => (globalThis.Image = Image));
|
||||
const reported = [];
|
||||
const cesium = createShellCesium();
|
||||
const scene = createShellScene();
|
||||
const fields = createCesiumFields({
|
||||
scene,
|
||||
cesium,
|
||||
report: (error) => reported.push(error),
|
||||
});
|
||||
const live = () => scene.primitives.items.filter((p) => !p.destroyed);
|
||||
const field = fields.field({
|
||||
kind: 'rasterShell',
|
||||
id: 'shell',
|
||||
image: { canvas: { width: 64, height: 32 } },
|
||||
rectangle: RECT,
|
||||
heightM: 6_000,
|
||||
});
|
||||
renderShells(cesium, scene);
|
||||
const [old] = live();
|
||||
field.update({
|
||||
image: { canvas: { width: 64, height: 32 } },
|
||||
rectangle: { west: -120, south: 10, east: -50, north: 50 },
|
||||
});
|
||||
assert.equal(live().length, 2);
|
||||
field.update({ image: 'https://example.test/next.png' });
|
||||
assert.deepEqual(live(), [old], 'the superseded stage goes');
|
||||
pending[0].reject(new Error('no image'));
|
||||
await new Promise((resolve) => setTimeout(resolve, 0));
|
||||
renderShells(cesium, scene);
|
||||
assert.deepEqual(live(), [old], 'what it drew stays');
|
||||
assert.equal(reported.length, 1);
|
||||
field.dispose();
|
||||
});
|
||||
|
||||
test('the Cesium fields refuse kinds they cannot draw and live ids', () => {
|
||||
const h = fieldHarness();
|
||||
assert.throws(
|
||||
() => h.fields.field({ kind: 'scalarRaster', id: 'x' }),
|
||||
/no scalarRaster fields/,
|
||||
);
|
||||
const spec = {
|
||||
kind: 'rasterShell',
|
||||
id: 'shell',
|
||||
image: h.image(),
|
||||
rectangle: RECT,
|
||||
heightM: 1,
|
||||
};
|
||||
const field = h.fields.field(spec);
|
||||
assert.throws(() => h.fields.field(spec), /is live/);
|
||||
field.dispose();
|
||||
h.fields.field(spec).dispose();
|
||||
});
|
||||
Reference in new issue
Block a user