Starry sky and the application viewer move into the Cesium adapter

src/sky/starrySky.js and src/app/viewer.js are Cesium through and
through, so they move into the adapter as src/render/cesium/starrySky.js
and applicationViewer.js; the ./application/viewer export points there.
The celestial ring's precise ICRF rotation reaches the shell through a
Cesium-free registry (src/sky/icrf.js) that the sky provides as it
loads; the application's renderer loads it, and so does
./render/cesium/unbound. Both files leave the Cesium allow-list.
This commit is contained in:
Sameh Khamis committed 2026-11-09 12:31:46 -08:00
1 parent a8a9cc73a4
commit e6d9ec0636
17 files changed
+110 -38

No files matched your search

+247
View File
@@ -0,0 +1,247 @@
import test from 'node:test';
import assert from 'node:assert/strict';
import * as Cesium from 'cesium';
import {
MILKY_WAY_INTENSITY,
STARRY_SKY_CESIUM_VERSION,
SKY_ROTATION_EPSILON_SECONDS,
StarrySky,
computeSkyRotation,
icrfToFixedAxes,
isSkyRotationCurrent,
} from './starrySky.js';
import * as neutral from '../../sky/icrf.js';
const close = (actual, expected, epsilon = 1e-9) =>
assert.ok(Math.abs(actual - expected) <= epsilon, `${actual} vs ${expected}`);
test('the sky-box adapter was validated against this engine version', () => {
assert.equal(
Cesium.VERSION,
STARRY_SKY_CESIUM_VERSION,
'engine upgrades require revalidating the Scene#skyBox contract',
);
});
test('the ICRF rotation is preferred and TEME fills in while tables load', () => {
const time = Cesium.JulianDate.fromIso8601('2026-10-19T00:00:00Z');
const icrf = Cesium.Matrix3.fromRotationZ(0.3);
const teme = Cesium.Matrix3.fromRotationZ(0.2);
const { Transforms } = Cesium;
const original = { ...Transforms };
try {
Transforms.computeIcrfToFixedMatrix = (_, result) =>
Cesium.Matrix3.clone(icrf, result);
Transforms.computeTemeToPseudoFixedMatrix = () =>
assert.fail('TEME not needed');
const precise = computeSkyRotation(time, new Cesium.Matrix3());
assert.equal(precise.precise, true);
assert.ok(Cesium.Matrix3.equals(precise.matrix, icrf));
Transforms.computeIcrfToFixedMatrix = () => undefined;
Transforms.computeTemeToPseudoFixedMatrix = (_, result) =>
Cesium.Matrix3.clone(teme, result);
const approximate = computeSkyRotation(time, new Cesium.Matrix3());
assert.equal(approximate.precise, false);
assert.ok(Cesium.Matrix3.equals(approximate.matrix, teme));
} finally {
Object.assign(Transforms, original);
}
});
test('the TEME fallback keeps the celestial pole on the Earth axis', () => {
// TEME only spins about Z; ICRF differs from it by precession (~0.36° by
// 2026), so the fallback sky is right up to a fraction of a degree.
const time = Cesium.JulianDate.fromIso8601('2026-10-19T00:00:00Z');
const teme = Cesium.Transforms.computeTemeToPseudoFixedMatrix(time);
const pole = Cesium.Matrix3.multiplyByVector(
teme,
Cesium.Cartesian3.UNIT_Z,
new Cesium.Cartesian3(),
);
assert.ok(Math.abs(pole.z - 1) < 1e-9);
});
test('the rotation is reused only within the clock epsilon', () => {
const time = Cesium.JulianDate.fromIso8601('2026-10-19T00:00:00Z');
const later = (seconds) =>
Cesium.JulianDate.addSeconds(time, seconds, new Cesium.JulianDate());
assert.equal(isSkyRotationCurrent(undefined, time), false);
assert.equal(isSkyRotationCurrent(time, later(0.5)), true);
assert.equal(isSkyRotationCurrent(time, later(-0.5)), true);
assert.equal(
isSkyRotationCurrent(time, later(SKY_ROTATION_EPSILON_SECONDS)),
false,
);
});
test('the sky draws nothing when hidden, outside 3D, or in a pick pass', () => {
const sky = new StarrySky({ requestRender: () => {} });
const frameState = (overrides) => ({
mode: Cesium.SceneMode.SCENE3D,
passes: { render: true },
...overrides,
});
sky._loading = true; // keep the test off the network
sky.show = false;
assert.equal(sky.update(frameState()), undefined);
sky.show = true;
assert.equal(
sky.update(frameState({ mode: Cesium.SceneMode.SCENE2D })),
undefined,
);
assert.equal(
sky.update(frameState({ passes: { render: false, pick: true } })),
undefined,
);
// Nothing has loaded yet, so even a render pass has no command.
sky._cubeMap = { destroy() {} }; // no WebGL context in this unit test
assert.equal(sky.update(frameState()), undefined);
assert.equal(sky.isDestroyed(), false);
assert.equal(sky.destroy(), undefined);
assert.equal(sky.isDestroyed(), true);
});
const frame = () => new Promise((resolve) => setImmediate(resolve));
for (const iso of ['1970-01-01T00:00:00Z', '2060-01-01T00:00:00Z']) {
test(`a clock outside the IAU 2006 tables (${iso}) settles on TEME instead of re-rendering every frame`, async () => {
const time = Cesium.JulianDate.fromIso8601(iso);
let renders = 0;
let preloads = 0;
const original = Cesium.Transforms.preloadIcrfFixed;
Cesium.Transforms.preloadIcrfFixed = (interval) => {
preloads += 1;
return original(interval);
};
try {
const sky = new StarrySky({ requestRender: () => (renders += 1) });
for (let i = 0; i < 20; i += 1) {
sky._updateRotation(time); // what update() does once per frame
await frame();
}
assert.ok(
renders <= 1 && preloads <= 1,
`20 frames at a frozen clock -> ${preloads} preloads, ${renders} render requests (expected <= 1 each)`,
);
} finally {
Cesium.Transforms.preloadIcrfFixed = original;
}
});
}
test('the Milky Way glow scales with its visibility, for styles that hide it', () => {
const sky = new StarrySky({ requestRender: () => {} });
close(sky._milkyWayUniforms.u_intensity(), MILKY_WAY_INTENSITY);
sky.milkyWayVisibility = 0;
assert.equal(sky._milkyWayUniforms.u_intensity(), 0);
sky.destroy();
});
test('destroy releases both the background and model environment maps', () => {
const sky = new StarrySky({ requestRender: () => {} });
let destroyed = 0;
sky._cubeMap = {
destroy: () => {
destroyed++;
},
};
sky._milkyWayCubeMap = {
destroy: () => {
destroyed++;
},
};
sky.destroy();
assert.equal(destroyed, 2);
assert.equal(sky._cubeMap, undefined);
assert.equal(sky._milkyWayCubeMap, undefined);
sky.destroy();
assert.equal(destroyed, 2);
});
test('a render update uploads six opaque black environment faces only once', () => {
const uploads = [];
const gl = {
...Cesium.WebGLConstants,
createTexture: () => ({}),
activeTexture() {},
bindTexture() {},
texParameteri() {},
pixelStorei() {},
texImage2D: (...args) => uploads.push(args),
deleteTexture() {},
};
const previous = Cesium.ContextLimits._maximumCubeMapSize;
Cesium.ContextLimits._maximumCubeMapSize = 16;
const sky = new StarrySky({ requestRender: () => {} });
sky._loading = true;
const state = {
context: { _gl: gl },
mode: Cesium.SceneMode.SCENE3D,
passes: { render: true },
};
try {
sky.update(state);
const environment = sky._cubeMap;
assert.ok(environment instanceof Cesium.CubeMap);
assert.equal(uploads.length, 6);
assert.equal(new Set(uploads.map((args) => args[0])).size, 6);
for (const args of uploads) {
assert.equal(args[3], 1);
assert.equal(args[4], 1);
assert.deepEqual([...args[8]], [0, 0, 0, 255]);
}
sky.update(state);
assert.equal(sky._cubeMap, environment);
assert.equal(uploads.length, 6);
sky.destroy();
assert.equal(environment.isDestroyed(), true);
} finally {
if (!sky.isDestroyed()) sky.destroy();
Cesium.ContextLimits._maximumCubeMapSize = previous;
}
});
test('the precise frame is given as its axes once its tables answer', (t) => {
const matrix = Cesium.Matrix3.fromRowMajorArray([1, 2, 3, 4, 5, 6, 7, 8, 9]);
let asked = null;
t.mock.method(Cesium.Transforms, 'computeIcrfToFixedMatrix', (time, out) => {
asked = time;
return Cesium.Matrix3.clone(matrix, out);
});
const ms = Date.UTC(2026, 10, 7);
assert.deepEqual(icrfToFixedAxes(ms), {
x: { x: 1, y: 4, z: 7 },
y: { x: 2, y: 5, z: 8 },
z: { x: 3, y: 6, z: 9 },
});
assert.ok(
Cesium.JulianDate.equals(asked, Cesium.JulianDate.fromDate(new Date(ms))),
);
Cesium.Transforms.computeIcrfToFixedMatrix.mock.mockImplementation(
() => undefined,
);
assert.equal(icrfToFixedAxes(ms), null);
});
test('loading the sky provides its precise rotation to Cesium-free code', () => {
const ms = Date.parse('2026-10-19T00:00:00Z');
const original = Cesium.Transforms.computeIcrfToFixedMatrix;
Cesium.Transforms.computeIcrfToFixedMatrix = (_time, result) =>
Cesium.Matrix3.clone(Cesium.Matrix3.fromRotationZ(0.3), result);
try {
const axes = neutral.icrfToFixedAxes(ms);
assert.notEqual(axes, null);
assert.deepEqual(axes, icrfToFixedAxes(ms));
} finally {
Cesium.Transforms.computeIcrfToFixedMatrix = original;
}
});
test('the neutral rotation answers null with nothing provided', () => {
neutral.provideIcrfToFixed(null);
try {
assert.equal(neutral.icrfToFixedAxes(0), null);
} finally {
neutral.provideIcrfToFixed(icrfToFixedAxes);
}
});