SenrokaiandClaude Opus 5.5
f8582b78d0
2242fe0 gave every star the Sun's photograph in grey, tinted at its temperature and limb-darkened
as 1 - 0.6(1 - mu), and nothing tested any of the three: with the coefficient at 0, the tint
dropped from the material, or the photograph replaced by the tint alone, all 817 tests passed. The
one colour test read scene.starTint, a uniform the scene sets whether or not the material uses it.
The new test enters Proxima and walks the disc material's colour node graph for the tint uniform,
the texture loaded from SUN_TEXTURE_PATH and the coefficient 0.6. Controls, each failing it alone
(1 of 820): the coefficient at 0; at -0.6, a limb brighter than the centre; the tint dropped; the
photograph replaced by the tint. A mutant that keeps the texture node in the graph but multiplies
it by nothing is not caught; the test checks the parts, not the arithmetic between them.
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
1098 lines
51 KiB
TypeScript
1098 lines
51 KiB
TypeScript
import { ComponentFixture, TestBed } from '@angular/core/testing';
|
||
import { Router } from '@angular/router';
|
||
import * as THREE from 'three/webgpu';
|
||
import { afterEach, beforeEach, describe, expect, it, MockInstance, vi } from 'vitest';
|
||
|
||
import { DataLoaderService, StarField } from '../../core/data/data-loader.service';
|
||
import { EngineService, EngineTickCallback } from '../../core/engine/engine.service';
|
||
import { BodyRecord } from '../../shared/models/body.model';
|
||
import { DeepSkyRecord } from '../../shared/models/deepsky.model';
|
||
import { ExoplanetRecord } from '../../shared/models/exoplanet.model';
|
||
import { StarRecord } from '../../shared/models/star.model';
|
||
import { NavigationStore } from '../../shared/state/navigation.store';
|
||
import { LinkBudget } from '../../shared/astro/jump-links';
|
||
import { HudDisplay } from '../hud/hud-dock.component';
|
||
import { GalaxySystemSceneComponent } from './galaxy-system-scene.component';
|
||
import { galacticNormal } from './grid-plane';
|
||
import { catalogueCensus, positionsNote } from './star-readouts';
|
||
import { closestApproachAu, SUN_RADIUS_AU } from './system-framing';
|
||
import { blackbodyColor, SOLAR_EFFECTIVE_TEMPERATURE_K } from '../../shared/astro/stellar';
|
||
import { appearanceForExoplanet } from '../../shared/astro/body-appearance';
|
||
import { planetTexture } from '../../shared/rendering/procedural-planet-texture';
|
||
import { loadCachedTexture, SUN_TEXTURE_PATH } from '../../shared/rendering/texture-catalog';
|
||
import { JumpLinkRenderer } from './jump-link-renderer';
|
||
import { StarFieldRenderer } from './star-field-renderer';
|
||
import { LabeledPoint, StarLabelOverlay } from './star-label-overlay';
|
||
|
||
// jsdom does not implement ResizeObserver; the component only uses it to react to real
|
||
// layout changes, which never happen in this headless test.
|
||
(globalThis as unknown as { ResizeObserver: unknown }).ResizeObserver ??= class {
|
||
observe(): void {}
|
||
unobserve(): void {}
|
||
disconnect(): void {}
|
||
};
|
||
|
||
const SUN: StarRecord = { id: 0, name: 'Sol', x: 0, y: 0, z: 0, magnitude: -26.7, spectralType: 'G2V', colorIndex: 0.656 };
|
||
const ALPHA_CENTAURI: StarRecord = { id: 1, name: 'Alpha Centauri', x: 1.34, y: 0, z: 0, magnitude: 4.4, spectralType: 'G2V', colorIndex: 0.7 };
|
||
// Its id deliberately differs from its place in STARS, so a lookup by id cannot pass for one by index.
|
||
const PROXIMA: StarRecord = { id: 42, name: 'Proxima Centauri', x: 0, y: 1.3, z: 0, magnitude: 11.1, spectralType: 'M5V', colorIndex: 1.8 };
|
||
|
||
// A supergiant nothing publishes a radius for, and a white dwarf with neither a colour nor a type
|
||
// the parser reads, for what the system view draws each star at; last, so the indices above hold.
|
||
const ANTARES: StarRecord = { id: 80519, name: 'Antares', x: -58.54, y: -140.31, z: -75.57, magnitude: 1.06, magnitudeBand: 'V', spectralType: 'M1Ib + B2.5V', colorIndex: 1.865, colorSystem: 'B-V' };
|
||
const PROCYON_B: StarRecord = { id: 37279, name: 'Gl 280B', x: -1.08, y: 3.19, z: 0.34, magnitude: 10.7, magnitudeBand: 'V', spectralType: 'DA', colorIndex: null };
|
||
|
||
// A host only the archive places, at the stand-in magnitude, with no type and no colour.
|
||
const LENS: StarRecord = { id: 1070000536, name: 'KMT-2016-BLG-1107L', x: 6651, y: 0, z: 0, magnitude: 15, spectralType: 'Unknown', colorIndex: null, source: 'exoplanet-archive' };
|
||
|
||
const STARS: StarRecord[] = [SUN, ALPHA_CENTAURI, PROXIMA, ANTARES, PROCYON_B, LENS];
|
||
const STAR_POSITIONS = new Float32Array(STARS.flatMap((star) => [star.x, star.y, star.z]));
|
||
|
||
// Proxima's planet as the archive gives it, with its host's radius, temperature and luminosity.
|
||
const PROXIMA_B: ExoplanetRecord = {
|
||
id: 'Proxima Cen b',
|
||
hostStarId: PROXIMA.id,
|
||
hostStarName: 'Proxima Cen',
|
||
name: 'Proxima Cen b',
|
||
hostStarRadiusSolar: 0.141,
|
||
hostStarTemperatureK: 2900,
|
||
hostStarLuminositySolar: 0.00151,
|
||
orbit: { semiMajorAxisAu: 0.0485, eccentricity: 0.02 }
|
||
};
|
||
|
||
const DEEP_SKY_OBJECT: DeepSkyRecord = {
|
||
id: 'NGC0224',
|
||
name: 'Andromeda Galaxy',
|
||
kind: 'galaxy',
|
||
x: 0,
|
||
y: 0,
|
||
z: 1,
|
||
angularSizeDeg: 2.96,
|
||
magnitude: 3.44,
|
||
distancePc: null,
|
||
distanceMethod: null,
|
||
constellation: 'And',
|
||
messier: 'M31'
|
||
};
|
||
|
||
const EARTH: BodyRecord = {
|
||
id: 'earth',
|
||
systemStarId: SUN.id,
|
||
name: 'Earth',
|
||
kind: 'planet',
|
||
radiusKm: 6371,
|
||
orbit: {
|
||
semiMajorAxisAu: 1,
|
||
eccentricity: 0.0167,
|
||
inclinationDeg: 0,
|
||
longitudeOfAscendingNodeDeg: 0,
|
||
argumentOfPeriapsisDeg: 0,
|
||
meanAnomalyAtEpochDeg: 0,
|
||
epochJd: 2451545.0
|
||
}
|
||
};
|
||
|
||
/** Minimal stand-in for `EngineService` that skips real WebGPU/WebGL initialization entirely,
|
||
* while exposing the same tick-registration hook so tests can drive the render loop by hand. */
|
||
class FakeEngineService {
|
||
private readonly scene = new THREE.Scene();
|
||
private readonly camera = new THREE.PerspectiveCamera(50, 1, 0.1, 1000);
|
||
private readonly orthographic = new THREE.OrthographicCamera(-1, 1, 1, -1, 0.1, 1000);
|
||
private readonly tickCallbacks = new Set<EngineTickCallback>();
|
||
projection: 'perspective' | 'orthographic' = 'perspective';
|
||
|
||
get isInitialized(): boolean {
|
||
return true;
|
||
}
|
||
|
||
async init(): Promise<void> {
|
||
// no-op: no real renderer/context is created in tests.
|
||
}
|
||
|
||
getScene(): THREE.Scene {
|
||
return this.scene;
|
||
}
|
||
|
||
getCamera(): THREE.PerspectiveCamera | THREE.OrthographicCamera {
|
||
return this.projection === 'orthographic' ? this.orthographic : this.camera;
|
||
}
|
||
|
||
getPerspectiveCamera(): THREE.PerspectiveCamera {
|
||
return this.camera;
|
||
}
|
||
|
||
get currentProjection(): 'perspective' | 'orthographic' {
|
||
return this.projection;
|
||
}
|
||
|
||
setProjection(projection: 'perspective' | 'orthographic', distanceToTarget: number): void {
|
||
this.projection = projection;
|
||
this.orthographic.zoom = 1;
|
||
this.orthographic.position.copy(this.camera.position);
|
||
this.orthographic.quaternion.copy(this.camera.quaternion);
|
||
this.frameOrthographic(distanceToTarget);
|
||
}
|
||
|
||
frameOrthographic(distanceToTarget: number): void {
|
||
const halfHeight = Math.max(distanceToTarget, 1e-6) * Math.tan((this.camera.fov * Math.PI) / 360);
|
||
this.orthographic.top = halfHeight;
|
||
this.orthographic.bottom = -halfHeight;
|
||
this.orthographic.left = -halfHeight * this.camera.aspect;
|
||
this.orthographic.right = halfHeight * this.camera.aspect;
|
||
this.orthographic.updateProjectionMatrix();
|
||
}
|
||
|
||
visibleHalfHeight(distanceToTarget: number): number {
|
||
return this.projection === 'orthographic'
|
||
? (this.orthographic.top - this.orthographic.bottom) / (2 * this.orthographic.zoom)
|
||
: distanceToTarget * Math.tan((this.camera.fov * Math.PI) / 360);
|
||
}
|
||
|
||
onTick(callback: EngineTickCallback): () => void {
|
||
this.tickCallbacks.add(callback);
|
||
return () => this.tickCallbacks.delete(callback);
|
||
}
|
||
|
||
start(): void {}
|
||
|
||
stop(): void {}
|
||
|
||
dispose(): void {}
|
||
|
||
resize(): void {}
|
||
|
||
/** The canvas's device pixels per CSS pixel, as the renderer was told. */
|
||
pixelRatio = 1;
|
||
|
||
getRenderer(): { getPixelRatio(): number } {
|
||
return { getPixelRatio: () => this.pixelRatio };
|
||
}
|
||
|
||
/** Test helper: simulates one rendered frame by invoking every registered tick callback. */
|
||
tick(deltaSeconds: number): void {
|
||
for (const callback of this.tickCallbacks) {
|
||
callback(deltaSeconds, 0);
|
||
}
|
||
}
|
||
}
|
||
|
||
class FakeDataLoaderService {
|
||
loadStars(): Promise<StarField> {
|
||
return Promise.resolve({ stars: STARS, positions: STAR_POSITIONS });
|
||
}
|
||
|
||
loadBodies(): Promise<BodyRecord[]> {
|
||
return Promise.resolve([EARTH]);
|
||
}
|
||
|
||
loadExoplanets(): Promise<ExoplanetRecord[]> {
|
||
return Promise.resolve([PROXIMA_B]);
|
||
}
|
||
|
||
loadDeepSky(): Promise<DeepSkyRecord[]> {
|
||
return Promise.resolve([DEEP_SKY_OBJECT]);
|
||
}
|
||
}
|
||
|
||
/** Waits out several macrotask turns so chained promises (bootstrap's awaits) settle. */
|
||
async function flushAsync(turns = 8): Promise<void> {
|
||
for (let i = 0; i < turns; i++) {
|
||
await new Promise((resolve) => setTimeout(resolve, 0));
|
||
}
|
||
}
|
||
|
||
/** Advances the fake render loop (and therefore any in-flight `CameraRigController` tween)
|
||
* by repeatedly ticking a small fixed step, flushing microtasks between frames so any
|
||
* `onComplete` callback's own side effects (e.g. starting the next leg of the flight) run. */
|
||
async function advanceFrames(engine: FakeEngineService, totalSeconds: number, stepSeconds = 0.05): Promise<void> {
|
||
let elapsed = 0;
|
||
while (elapsed < totalSeconds) {
|
||
engine.tick(stepSeconds);
|
||
elapsed += stepSeconds;
|
||
await flushAsync(1);
|
||
}
|
||
}
|
||
|
||
describe('GalaxySystemSceneComponent camera-flight transitions', () => {
|
||
let fixture: ComponentFixture<GalaxySystemSceneComponent>;
|
||
let engine: FakeEngineService;
|
||
let navigationStore: NavigationStore;
|
||
|
||
beforeEach(async () => {
|
||
engine = new FakeEngineService();
|
||
|
||
TestBed.configureTestingModule({
|
||
imports: [GalaxySystemSceneComponent],
|
||
providers: [
|
||
{ provide: DataLoaderService, useClass: FakeDataLoaderService },
|
||
{ provide: Router, useValue: { navigate: vi.fn().mockResolvedValue(true) } }
|
||
]
|
||
}).overrideComponent(GalaxySystemSceneComponent, {
|
||
set: { providers: [{ provide: EngineService, useValue: engine }] }
|
||
});
|
||
|
||
navigationStore = TestBed.inject(NavigationStore);
|
||
fixture = TestBed.createComponent(GalaxySystemSceneComponent);
|
||
fixture.detectChanges(); // triggers ngAfterViewInit -> bootstrap()
|
||
await flushAsync();
|
||
});
|
||
|
||
it('starts in the galaxy view with the system group hidden', () => {
|
||
const component = fixture.componentInstance as unknown as { galaxyGroup: THREE.Group; systemGroup: THREE.Group };
|
||
expect(component.galaxyGroup.visible).toBe(true);
|
||
expect(component.systemGroup.visible).toBe(false);
|
||
expect(navigationStore.viewLevel()).toBe('galaxy');
|
||
});
|
||
|
||
it('clears a selection the catalogue no longer holds instead of chasing it', async () => {
|
||
// A bookmark saved against a Gaia row id that the next refresh renumbered. Before the guard,
|
||
// entering the missing system completed at once, completion re-read the same id, and the
|
||
// two recursed until the stack overflowed.
|
||
navigationStore.selectStar(987654321);
|
||
await flushAsync();
|
||
|
||
expect(navigationStore.selectedStarId()).toBeNull();
|
||
expect(navigationStore.viewLevel()).toBe('galaxy');
|
||
});
|
||
|
||
it('chooses the drawn stars again once the view centre has moved, and not for a small drift', async () => {
|
||
const component = fixture.componentInstance as unknown as { controls: { target: THREE.Vector3 } };
|
||
const refocus = vi.spyOn(StarFieldRenderer.prototype, 'refocus');
|
||
// The first pass always chooses; what is under test is the move after it.
|
||
await advanceFrames(engine, 0.3);
|
||
refocus.mockClear();
|
||
|
||
component.controls.target.set(40, 0, 0);
|
||
await advanceFrames(engine, 0.3);
|
||
expect(refocus).toHaveBeenCalledTimes(1);
|
||
expect(refocus.mock.calls[0][0].centre).toMatchObject({ x: 40, y: 0, z: 0 });
|
||
|
||
component.controls.target.set(42, 0, 0);
|
||
await advanceFrames(engine, 0.3);
|
||
expect(refocus).toHaveBeenCalledTimes(1);
|
||
refocus.mockRestore();
|
||
});
|
||
|
||
describe('the drawn stars, chosen for what the camera shows', () => {
|
||
type ViewScene = { controls: { target: THREE.Vector3; update(): void }; display: { update(change: (display: HudDisplay) => HudDisplay): void } };
|
||
let refocus: MockInstance<StarFieldRenderer['refocus']>;
|
||
|
||
beforeEach(() => {
|
||
refocus = vi.spyOn(StarFieldRenderer.prototype, 'refocus');
|
||
});
|
||
afterEach(() => refocus.mockRestore());
|
||
|
||
/** Swings the camera about the view's centre, around the scene's vertical, by `degrees`. */
|
||
function orbit(component: ViewScene, degrees: number): void {
|
||
const camera = engine.getCamera();
|
||
const target = component.controls.target;
|
||
camera.position.sub(target).applyAxisAngle(new THREE.Vector3(0, 1, 0), THREE.MathUtils.degToRad(degrees)).add(target);
|
||
component.controls.update();
|
||
}
|
||
|
||
it('chooses them for the opening view on the first pass, planet hosts included', async () => {
|
||
await advanceFrames(engine, 0.6);
|
||
|
||
expect(refocus).toHaveBeenCalledTimes(1);
|
||
const [focus] = refocus.mock.calls[0];
|
||
expect(focus.view).toBeDefined();
|
||
// The Sun has Earth and Proxima its b, so both are hosts; the others have nothing catalogued.
|
||
expect(Array.from(focus.hosts ?? [])).toEqual([1, 0, 1, 0, 0, 0]);
|
||
});
|
||
|
||
it('chooses again once the camera has turned half the margin, and not for less', async () => {
|
||
const component = fixture.componentInstance as unknown as ViewScene;
|
||
await advanceFrames(engine, 0.3);
|
||
|
||
orbit(component, 1);
|
||
await advanceFrames(engine, 0.3);
|
||
expect(refocus).toHaveBeenCalledTimes(1);
|
||
|
||
orbit(component, 3);
|
||
await advanceFrames(engine, 0.3);
|
||
expect(refocus).toHaveBeenCalledTimes(2);
|
||
});
|
||
|
||
it('chooses again once a pan has moved the view further than a fifth of the neighbourhood, and not for less', async () => {
|
||
const component = fixture.componentInstance as unknown as ViewScene;
|
||
const camera = engine.getCamera();
|
||
// Camera and centre together, so the camera neither turns nor zooms.
|
||
const pan = (pc: number) => {
|
||
component.controls.target.x += pc;
|
||
camera.position.x += pc;
|
||
component.controls.update();
|
||
};
|
||
await advanceFrames(engine, 0.3);
|
||
|
||
pan(3);
|
||
await advanceFrames(engine, 0.3);
|
||
expect(refocus).toHaveBeenCalledTimes(1);
|
||
|
||
pan(3);
|
||
await advanceFrames(engine, 0.3);
|
||
expect(refocus).toHaveBeenCalledTimes(2);
|
||
});
|
||
|
||
it('chooses again once a zoom has changed the frame by half the margin, and not for less', async () => {
|
||
const component = fixture.componentInstance as unknown as ViewScene;
|
||
const camera = engine.getCamera();
|
||
const dolly = (factor: number) => camera.position.sub(component.controls.target).multiplyScalar(factor).add(component.controls.target);
|
||
await advanceFrames(engine, 0.3);
|
||
|
||
dolly(0.95);
|
||
await advanceFrames(engine, 0.3);
|
||
expect(refocus).toHaveBeenCalledTimes(1);
|
||
|
||
dolly(0.8);
|
||
await advanceFrames(engine, 0.3);
|
||
expect(refocus).toHaveBeenCalledTimes(2);
|
||
});
|
||
|
||
it('chooses again for the plan view, where a small turn moves deep stars furthest', async () => {
|
||
const component = fixture.componentInstance as unknown as ViewScene;
|
||
// About 10 pc of frame either side of the centre.
|
||
engine.getCamera().position.setLength(21.4);
|
||
component.controls.update();
|
||
await advanceFrames(engine, 0.3);
|
||
const beforePlan = refocus.mock.calls.length;
|
||
|
||
component.display.update((display) => ({ ...display, plan: true }));
|
||
TestBed.tick();
|
||
await advanceFrames(engine, 0.3);
|
||
expect(refocus).toHaveBeenCalledTimes(beforePlan + 1);
|
||
|
||
// Harmless under perspective; under the plan it moves a star 250 pc deep by 4 pc, against a 2.5 pc margin.
|
||
orbit(component, 1);
|
||
await advanceFrames(engine, 0.3);
|
||
expect(refocus).toHaveBeenCalledTimes(beforePlan + 2);
|
||
});
|
||
|
||
it('chooses again when the projection changes under a pose that has not moved at all', async () => {
|
||
await advanceFrames(engine, 0.3);
|
||
const before = refocus.mock.calls.length;
|
||
// The same place, direction and frame height, but a box instead of a frustum, which frames other stars.
|
||
const perspective = engine.getPerspectiveCamera();
|
||
const plan = (engine as unknown as { orthographic: THREE.OrthographicCamera }).orthographic;
|
||
plan.position.copy(perspective.position);
|
||
plan.quaternion.copy(perspective.quaternion);
|
||
engine.projection = 'orthographic';
|
||
|
||
await advanceFrames(engine, 0.3);
|
||
|
||
expect(refocus).toHaveBeenCalledTimes(before + 1);
|
||
});
|
||
|
||
it('holds a turn to the narrower side of a portrait frame', async () => {
|
||
const component = fixture.componentInstance as unknown as ViewScene;
|
||
engine.getPerspectiveCamera().aspect = 0.4;
|
||
engine.getPerspectiveCamera().updateProjectionMatrix();
|
||
await advanceFrames(engine, 0.3);
|
||
|
||
// Inside half the margin above and below, past half of it at the sides.
|
||
orbit(component, 2);
|
||
await advanceFrames(engine, 0.3);
|
||
|
||
expect(refocus).toHaveBeenCalledTimes(2);
|
||
});
|
||
|
||
it('keeps up with a flight frame by frame, from the frame it comes back into parsec space', async () => {
|
||
const component = fixture.componentInstance as unknown as ViewScene & { galaxyGroup: THREE.Group; rig: { isAnimating: boolean } };
|
||
navigationStore.selectStar(SUN.id);
|
||
await flushAsync();
|
||
await advanceFrames(engine, 2.5);
|
||
refocus.mockClear();
|
||
|
||
navigationStore.selectStar(null);
|
||
await flushAsync();
|
||
let choicesOnReturningFrame = -1;
|
||
let flightFrames = 0;
|
||
let flightChoices = 0;
|
||
for (let frame = 0; frame < 80; frame++) {
|
||
const wasInSystem = !component.galaxyGroup.visible;
|
||
const before = refocus.mock.calls.length;
|
||
engine.tick(0.05);
|
||
await flushAsync(1);
|
||
if (wasInSystem && component.galaxyGroup.visible) {
|
||
choicesOnReturningFrame = refocus.mock.calls.length - before;
|
||
}
|
||
if (component.galaxyGroup.visible && component.rig.isAnimating) {
|
||
flightFrames++;
|
||
flightChoices += refocus.mock.calls.length - before;
|
||
}
|
||
}
|
||
|
||
// Chosen for the view in the very frame the camera jumps back, not up to a pass later.
|
||
expect(choicesOnReturningFrame).toBe(1);
|
||
// The return zooms out from inside the system to the opening view: more re-choices than one a
|
||
// pass could make, and every one of them for the view.
|
||
expect(flightChoices).toBeGreaterThan(Math.ceil((flightFrames * 0.05) / 0.2));
|
||
expect(refocus.mock.calls.every(([focus]) => focus.view !== undefined)).toBe(true);
|
||
});
|
||
|
||
it('chooses once for the whole sky on the way out to the Galaxy, then leaves them alone', async () => {
|
||
const component = fixture.componentInstance as unknown as ViewScene;
|
||
engine.getCamera().position.set(0, 0, 30000);
|
||
await advanceFrames(engine, 0.3);
|
||
const onArrival = refocus.mock.calls.length;
|
||
expect(refocus.mock.calls.at(-1)![0].view).toBeUndefined();
|
||
|
||
component.controls.target.set(500, 0, 0);
|
||
await advanceFrames(engine, 0.3);
|
||
component.controls.target.set(1500, 0, 0);
|
||
await advanceFrames(engine, 0.3);
|
||
|
||
expect(refocus).toHaveBeenCalledTimes(onArrival);
|
||
expect(refocus.mock.calls.filter(([focus]) => focus.view === undefined)).toHaveLength(1);
|
||
});
|
||
});
|
||
|
||
describe('the local grid of distance rings', () => {
|
||
type GridScene = {
|
||
controls: { target: THREE.Vector3; update(): void };
|
||
display: { update(change: (display: HudDisplay) => HudDisplay): void };
|
||
localGridRadii: readonly number[];
|
||
};
|
||
|
||
it('sizes the rings by how far the frame reaches from the Sun, under either projection', async () => {
|
||
const component = fixture.componentInstance as unknown as GridScene;
|
||
const camera = engine.getCamera();
|
||
// Centred on a point 200 pc out along the galactic plane — where the rings are — seen from
|
||
// 20 pc above it. The rings have to reach it, and one of them has to cross the frame.
|
||
const normal = galacticNormal();
|
||
const centre = new THREE.Vector3(1, 0, 0).projectOnPlane(normal).normalize().multiplyScalar(200);
|
||
component.controls.target.copy(centre);
|
||
camera.position.copy(centre).addScaledVector(normal, 20);
|
||
component.controls.update();
|
||
await advanceFrames(engine, 0.3);
|
||
const underPerspective = [...component.localGridRadii];
|
||
|
||
component.display.update((display) => ({ ...display, plan: true }));
|
||
TestBed.tick();
|
||
await advanceFrames(engine, 0.3);
|
||
|
||
expect(underPerspective.at(-1)).toBeGreaterThanOrEqual(200);
|
||
// The frame is a band about 19 pc either side of 200 pc: rings out to 220 at a step sized to
|
||
// all 220 are 180 and 200, both of them off screen.
|
||
const halfHeight = engine.visibleHalfHeight(20);
|
||
expect(underPerspective.some((radius) => Math.abs(radius - 200) < halfHeight)).toBe(true);
|
||
// The plan view's wheel moves the frame rather than the camera, so "how far out the camera
|
||
// is" means something else there; what the rings have to cover does not.
|
||
expect([...component.localGridRadii]).toEqual(underPerspective);
|
||
});
|
||
|
||
it('measures the span in the plane the rings lie in, not through it', async () => {
|
||
const component = fixture.componentInstance as unknown as GridScene;
|
||
const camera = engine.getCamera();
|
||
// The same 200 pc out along the plane, but lifted 150 pc above it: 250 pc from the Sun as the
|
||
// crow flies, and still 200 pc out among the rings, which is the distance they are drawn at.
|
||
const normal = galacticNormal();
|
||
const centre = new THREE.Vector3(1, 0, 0).projectOnPlane(normal).normalize().multiplyScalar(200).addScaledVector(normal, 150);
|
||
component.controls.target.copy(centre);
|
||
camera.position.copy(centre).addScaledVector(normal, 20);
|
||
component.controls.update();
|
||
await advanceFrames(engine, 0.3);
|
||
|
||
const halfHeight = engine.visibleHalfHeight(20);
|
||
expect([...component.localGridRadii].some((radius) => Math.abs(radius - 200) < halfHeight)).toBe(true);
|
||
});
|
||
|
||
it('leaves the rings alone while the grid is not drawn', async () => {
|
||
const component = fixture.componentInstance as unknown as GridScene;
|
||
const camera = engine.getCamera();
|
||
await advanceFrames(engine, 0.3);
|
||
component.display.update((display) => ({ ...display, grid: false }));
|
||
TestBed.tick();
|
||
await advanceFrames(engine, 0.3);
|
||
const hidden = [...component.localGridRadii];
|
||
|
||
// A zoom this size crosses two round steps, and each crossing rebuilds every ring's vertices.
|
||
camera.position.setLength(camera.position.length() / 8);
|
||
component.controls.update();
|
||
await advanceFrames(engine, 0.3);
|
||
|
||
expect([...component.localGridRadii]).toEqual(hidden);
|
||
});
|
||
|
||
it('drops a ring label that a star name has taken, or that is off screen, and keeps the ladder otherwise', () => {
|
||
const component = fixture.componentInstance as unknown as {
|
||
ringLabelsInTheClear(candidates: readonly LabeledPoint[], camera: THREE.Camera, stars: readonly LabeledPoint[]): LabeledPoint[];
|
||
};
|
||
const camera = engine.getCamera();
|
||
camera.updateMatrixWorld(true);
|
||
const at = (x: number, y: number) => new THREE.Vector3(x, y, 0.5).unproject(camera);
|
||
// Rungs at a twentieth of the screen: well inside the separation two names would keep, and
|
||
// well outside the clearance a ring label keeps from a name, so neither test is a coin toss.
|
||
const near = at(0.1, 0.1);
|
||
const nextRungUp = at(0.1, 0.18);
|
||
const offScreen = at(1.6, 0.1);
|
||
const ladder: LabeledPoint[] = [
|
||
{ id: 'ring-50', name: '50 pc', x: near.x, y: near.y, z: near.z },
|
||
{ id: 'ring-100', name: '100 pc', x: nextRungUp.x, y: nextRungUp.y, z: nextRungUp.z },
|
||
{ id: 'ring-150', name: '150 pc', x: offScreen.x, y: offScreen.y, z: offScreen.z }
|
||
];
|
||
|
||
// A ladder of rings stays whole, though its rungs are closer than two star names would be.
|
||
expect(component.ringLabelsInTheClear(ladder, camera, []).map((label) => label.id)).toEqual(['ring-50', 'ring-100']);
|
||
// A star's name is worth more than a distance.
|
||
const star: LabeledPoint = { id: 7, name: 'Sirius', x: near.x, y: near.y, z: near.z };
|
||
expect(component.ringLabelsInTheClear(ladder, camera, [star]).map((label) => label.id)).toEqual(['ring-100']);
|
||
});
|
||
|
||
it('stays out of the text of a name, not just off its point', () => {
|
||
const component = fixture.componentInstance as unknown as {
|
||
ringLabelsInTheClear(candidates: readonly LabeledPoint[], camera: THREE.Camera, stars: readonly LabeledPoint[]): LabeledPoint[];
|
||
viewportAspect(): number;
|
||
};
|
||
const camera = engine.getCamera();
|
||
camera.updateMatrixWorld(true);
|
||
const aspect = component.viewportAspect();
|
||
const at = (x: number, y: number) => new THREE.Vector3(x / aspect, y, 0.5).unproject(camera);
|
||
// A hand's breadth apart on screen — past any clearance around the point — and on the same
|
||
// line, with the name's text running right through where the ring label starts.
|
||
const ring = at(0.125, -0.123);
|
||
const rung: LabeledPoint = { id: 'ring-50', name: '50 pc', x: ring.x, y: ring.y, z: ring.z };
|
||
const beside = at(0.06, -0.12);
|
||
const rightHand: LabeledPoint = { id: 7, name: 'Alpha Centauri', side: 'right', x: beside.x, y: beside.y, z: beside.z };
|
||
|
||
expect(component.ringLabelsInTheClear([rung], camera, [rightHand])).toEqual([]);
|
||
// The same name hanging the other way leaves that space empty, and the rung with it.
|
||
expect(component.ringLabelsInTheClear([rung], camera, [{ ...rightHand, side: 'left' }])).toEqual([rung]);
|
||
|
||
// And a rung to the left of a name keeps its place: "50 pc" is a third of a star name's
|
||
// width, so it ends well before the name starts, whatever the anchors' spacing suggests.
|
||
const centred = at(0, 0);
|
||
const spanning: LabeledPoint = { id: 8, name: 'Alnitak', side: 'right', x: centred.x, y: centred.y, z: centred.z };
|
||
const toTheLeft = at(-0.25, 0.02);
|
||
const clearRung: LabeledPoint = { id: 'ring-100', name: '100 pc', x: toTheLeft.x, y: toTheLeft.y, z: toTheLeft.z };
|
||
|
||
expect(component.ringLabelsInTheClear([clearRung], camera, [spanning])).toEqual([clearRung]);
|
||
});
|
||
|
||
it('places the ring labels with the star names rather than over them', async () => {
|
||
const component = fixture.componentInstance as unknown as GridScene;
|
||
const update = vi.spyOn(StarLabelOverlay.prototype, 'update');
|
||
const cleared = vi.spyOn(GalaxySystemSceneComponent.prototype as unknown as { ringLabelsInTheClear: (...args: unknown[]) => LabeledPoint[] }, 'ringLabelsInTheClear');
|
||
const camera = engine.getCamera();
|
||
camera.position.set(0, 4, 10);
|
||
component.controls.target.set(0, 0, 0);
|
||
component.controls.update();
|
||
await advanceFrames(engine, 0.3);
|
||
|
||
const labels = (update.mock.calls.at(-1)?.[0] ?? []) as LabeledPoint[];
|
||
const rings = labels.filter((label) => String(label.id).startsWith('ring-'));
|
||
expect(rings.length).toBeGreaterThan(0);
|
||
// Handed over as the clearing pass left them, not as the grid produced them.
|
||
expect(cleared).toHaveBeenCalled();
|
||
expect(rings).toEqual(cleared.mock.results.at(-1)?.value);
|
||
update.mockRestore();
|
||
cleared.mockRestore();
|
||
});
|
||
});
|
||
|
||
it('keeps the stars of a plotted route drawn, and the selected star', async () => {
|
||
const component = fixture.componentInstance as unknown as { routeResult: { set(value: unknown): void } };
|
||
const refocus = vi.spyOn(StarFieldRenderer.prototype, 'refocus');
|
||
await advanceFrames(engine, 0.3);
|
||
|
||
component.routeResult.set({ stars: [{ id: SUN.id, name: 'Sol' }, { id: PROXIMA.id, name: 'Proxima Centauri' }], totalPc: 1.3, neededRangePc: null, gaveUp: false, least: true });
|
||
await advanceFrames(engine, 0.3);
|
||
|
||
// As catalogue indices: the Sun is the first entry of STARS, Proxima the third.
|
||
expect(refocus.mock.calls.at(-1)![0].pinned).toEqual([0, 2]);
|
||
refocus.mockRestore();
|
||
});
|
||
|
||
describe('the jump-link graph', () => {
|
||
type LinkScene = {
|
||
routing: { links(rangePc: number, drawn: Uint32Array, budget?: LinkBudget): Promise<Float32Array>; route(): Promise<never>; dispose(): void };
|
||
display: { update(change: (display: { jumpLinks: boolean }) => unknown): void };
|
||
jumpRangePc: { set(rangePc: number): void };
|
||
routeResult: { set(value: unknown): void };
|
||
controls: { target: THREE.Vector3 };
|
||
starField: { drawnStars: Uint32Array; drawn: Uint32Array };
|
||
};
|
||
/** Real time, since the rebuild waits on a real timer for the range and the drawn stars to settle. */
|
||
const settle = () => new Promise((resolve) => setTimeout(resolve, 300));
|
||
|
||
function linkScene(links: LinkScene['routing']['links']): LinkScene {
|
||
const component = fixture.componentInstance as unknown as LinkScene;
|
||
component.routing = { links, route: () => new Promise<never>(() => undefined), dispose: () => undefined };
|
||
component.display.update((display) => ({ ...display, jumpLinks: true }));
|
||
TestBed.tick();
|
||
return component;
|
||
}
|
||
|
||
/** Makes the next refocus choose a different set: the field is told it draws one star, then the view moves. */
|
||
async function changeDrawnStars(component: LinkScene, targetX: number): Promise<void> {
|
||
component.starField.drawn = Uint32Array.of(0);
|
||
component.controls.target.set(targetX, 0, 0);
|
||
await advanceFrames(engine, 0.3);
|
||
}
|
||
|
||
it('links the stars being drawn, and asks again once a new set of them holds still', async () => {
|
||
const links = vi.fn((_rangePc: number, _drawn: Uint32Array) => Promise.resolve(new Float32Array(0)));
|
||
const component = linkScene(links);
|
||
await settle();
|
||
expect(links).toHaveBeenCalledTimes(1);
|
||
expect(links.mock.calls[0].slice(0, 2)).toEqual([3, component.starField.drawnStars]);
|
||
|
||
await changeDrawnStars(component, 40);
|
||
expect(links).toHaveBeenCalledTimes(1);
|
||
await settle();
|
||
expect(links).toHaveBeenCalledTimes(2);
|
||
expect(links.mock.calls[1][1]).toBe(component.starField.drawnStars);
|
||
expect(links.mock.calls[1][1]).not.toBe(links.mock.calls[0][1]);
|
||
|
||
// A route re-chooses the drawn stars around its pins, and here they come out the same: no new graph.
|
||
component.routeResult.set({ stars: [{ id: SUN.id, name: 'Sol' }], totalPc: 0, neededRangePc: null, gaveUp: false, least: true });
|
||
await advanceFrames(engine, 0.3);
|
||
await settle();
|
||
expect(links).toHaveBeenCalledTimes(2);
|
||
});
|
||
|
||
it('asks for as much of the graph as a million pixels of line make, around where the view is centred', async () => {
|
||
const links = vi.fn((_rangePc: number, _drawn: Uint32Array, _budget?: LinkBudget) => Promise.resolve(new Float32Array(0)));
|
||
Object.defineProperty((fixture.nativeElement as HTMLElement).querySelector('canvas')!, 'clientHeight', { value: 1080 });
|
||
// A screen scaled to 200%: 1080 CSS pixels are 2160 drawn ones, and the lines are drawn in those.
|
||
engine.pixelRatio = 2;
|
||
linkScene(links);
|
||
await settle();
|
||
|
||
const budget = links.mock.calls[0][2];
|
||
// The view opens centred on the Sun: its frame's half-height there, over 1080 drawn pixels, is a pixel's worth of parsecs.
|
||
const halfHeight = engine.getCamera().position.length() * Math.tan((50 * Math.PI) / 360);
|
||
expect(budget?.centre).toEqual({ x: 0, y: 0, z: 0 });
|
||
expect(budget?.lengthPc).toBeCloseTo((1_000_000 * halfHeight) / 1080, 3);
|
||
});
|
||
|
||
it('asks again once the view has zoomed past the budget it asked with, though the drawn stars are the same', async () => {
|
||
// All three stars fit the star budget, so the drawn set never changes: only the budget can.
|
||
const links = vi.fn((_rangePc: number, _drawn: Uint32Array, _budget?: LinkBudget) => Promise.resolve(new Float32Array(0)));
|
||
Object.defineProperty((fixture.nativeElement as HTMLElement).querySelector('canvas')!, 'clientHeight', { value: 1080 });
|
||
const component = linkScene(links);
|
||
await advanceFrames(engine, 0.3);
|
||
await settle();
|
||
const asked = links.mock.calls.length;
|
||
|
||
const camera = engine.getCamera();
|
||
camera.position.sub(component.controls.target).multiplyScalar(0.5).add(component.controls.target);
|
||
await advanceFrames(engine, 0.3);
|
||
await settle();
|
||
|
||
expect(links.mock.calls.length).toBe(asked + 1);
|
||
expect(links.mock.calls.at(-1)![1]).toBe(links.mock.calls[0][1]);
|
||
});
|
||
|
||
it('asks for no graph from inside a system, where distances are in astronomical units', async () => {
|
||
const links = vi.fn((_rangePc: number, _drawn: Uint32Array, _budget?: LinkBudget) => Promise.resolve(new Float32Array(0)));
|
||
navigationStore.selectStar(SUN.id);
|
||
await flushAsync();
|
||
await advanceFrames(engine, 2.5);
|
||
|
||
linkScene(links);
|
||
await settle();
|
||
|
||
expect(links).not.toHaveBeenCalled();
|
||
});
|
||
|
||
it('keeps what it asked for when an older request it replaced is rejected', async () => {
|
||
// Off and on again while a graph is still waiting: the waiting one is replaced, and its
|
||
// rejection must not be taken for the request that replaced it.
|
||
const pending: Array<{ resolve: (segments: Float32Array) => void; reject: (error: Error) => void }> = [];
|
||
const setSegments = vi.spyOn(JumpLinkRenderer.prototype, 'setSegments');
|
||
const component = linkScene(() => new Promise<Float32Array>((resolve, reject) => pending.push({ resolve, reject })));
|
||
await settle();
|
||
component.display.update((display) => ({ ...display, jumpLinks: false }));
|
||
TestBed.tick();
|
||
await settle();
|
||
component.display.update((display) => ({ ...display, jumpLinks: true }));
|
||
TestBed.tick();
|
||
await settle();
|
||
expect(pending).toHaveLength(2);
|
||
|
||
pending[0].reject(new Error('Superseded by a newer request'));
|
||
await flushAsync();
|
||
const graph = new Float32Array(6);
|
||
pending[1].resolve(graph);
|
||
await flushAsync();
|
||
|
||
expect(setSegments).toHaveBeenLastCalledWith(graph);
|
||
setSegments.mockRestore();
|
||
});
|
||
|
||
it('gives a view on the move a new graph at least every quarter second, rather than waiting for it to stop', async () => {
|
||
const links = vi.fn((_rangePc: number, _drawn: Uint32Array) => Promise.resolve(new Float32Array(0)));
|
||
const component = linkScene(links);
|
||
await settle();
|
||
|
||
// A new drawn set about every 150 ms for a second, as an orbit makes one each pass.
|
||
for (let pass = 1; pass <= 7; pass++) {
|
||
await changeDrawnStars(component, pass * 40);
|
||
await new Promise((resolve) => setTimeout(resolve, 120));
|
||
}
|
||
|
||
expect(links.mock.calls.length).toBeGreaterThanOrEqual(3);
|
||
});
|
||
|
||
it('draws a late graph for the range still asked for, and not one for a range left behind', async () => {
|
||
const answers: Array<(segments: Float32Array) => void> = [];
|
||
const setSegments = vi.spyOn(JumpLinkRenderer.prototype, 'setSegments');
|
||
const component = linkScene(() => new Promise<Float32Array>((resolve) => answers.push(resolve)));
|
||
await settle();
|
||
await changeDrawnStars(component, 40);
|
||
await settle();
|
||
expect(answers).toHaveLength(2);
|
||
|
||
// For stars no longer drawn, but at the range still asked for: newer than what is on screen.
|
||
const olderSet = new Float32Array(6);
|
||
answers[0](olderSet);
|
||
await flushAsync();
|
||
expect(setSegments).toHaveBeenLastCalledWith(olderSet);
|
||
|
||
component.jumpRangePc.set(5);
|
||
TestBed.tick();
|
||
await settle();
|
||
expect(answers).toHaveLength(3);
|
||
answers[1](new Float32Array(12));
|
||
await flushAsync();
|
||
expect(setSegments).toHaveBeenLastCalledWith(olderSet);
|
||
|
||
const current = new Float32Array(18);
|
||
answers[2](current);
|
||
await flushAsync();
|
||
expect(setSegments).toHaveBeenLastCalledWith(current);
|
||
setSegments.mockRestore();
|
||
});
|
||
});
|
||
|
||
it('shows the answer to the latest route asked for, whatever order the answers arrive in', async () => {
|
||
type Answer = { route: { stars: number[]; totalPc: number; longestHopPc: number } | null; neededRangePc: number | null; gaveUp: boolean; least: boolean };
|
||
const answers: Array<(answer: Answer) => void> = [];
|
||
const component = fixture.componentInstance as unknown as {
|
||
routing: { route(): Promise<Answer>; links(): Promise<Float32Array>; dispose(): void };
|
||
routePending(): boolean;
|
||
routeResult(): { stars: { id: number }[]; gaveUp: boolean } | null;
|
||
onRouteRequested(request: { fromId: number; toId: number; rangePc: number }): void;
|
||
};
|
||
component.routing = {
|
||
route: () => new Promise<Answer>((resolve) => answers.push(resolve)),
|
||
links: () => Promise.resolve(new Float32Array(0)),
|
||
dispose: () => undefined
|
||
};
|
||
|
||
component.onRouteRequested({ fromId: SUN.id, toId: ALPHA_CENTAURI.id, rangePc: 2 });
|
||
component.onRouteRequested({ fromId: SUN.id, toId: PROXIMA.id, rangePc: 2 });
|
||
expect(component.routePending()).toBe(true);
|
||
|
||
answers[1]({ route: { stars: [SUN.id, PROXIMA.id], totalPc: 1.3, longestHopPc: 1.3 }, neededRangePc: null, gaveUp: false, least: true });
|
||
await flushAsync();
|
||
answers[0]({ route: { stars: [SUN.id, ALPHA_CENTAURI.id], totalPc: 1.34, longestHopPc: 1.34 }, neededRangePc: null, gaveUp: false, least: true });
|
||
await flushAsync();
|
||
|
||
expect(component.routeResult()?.stars.map((star) => star.id)).toEqual([SUN.id, PROXIMA.id]);
|
||
expect(component.routePending()).toBe(false);
|
||
|
||
// "It gave up" travels to the panel, which says something else for it than for "there is none".
|
||
component.onRouteRequested({ fromId: SUN.id, toId: ALPHA_CENTAURI.id, rangePc: 0.5 });
|
||
answers[2]({ route: null, neededRangePc: null, gaveUp: true, least: false });
|
||
await flushAsync();
|
||
expect(component.routeResult()).toMatchObject({ stars: [], gaveUp: true });
|
||
});
|
||
|
||
it('releases the routes panel when a route cannot be worked out, so it can be tried again', async () => {
|
||
const component = fixture.componentInstance as unknown as {
|
||
routing: { route(): Promise<never>; links(): Promise<Float32Array>; dispose(): void };
|
||
routePending(): boolean;
|
||
onRouteRequested(request: { fromId: number; toId: number; rangePc: number }): void;
|
||
};
|
||
const logged = vi.spyOn(console, 'error').mockImplementation(() => undefined);
|
||
component.routing = { route: () => Promise.reject(new Error('worker gone')), links: () => Promise.resolve(new Float32Array(0)), dispose: () => undefined };
|
||
|
||
component.onRouteRequested({ fromId: SUN.id, toId: PROXIMA.id, rangePc: 2 });
|
||
await flushAsync();
|
||
|
||
expect(component.routePending()).toBe(false);
|
||
expect(logged).toHaveBeenCalled();
|
||
logged.mockRestore();
|
||
});
|
||
|
||
it('asks for no more label candidates once the last label it will show is placed', () => {
|
||
// Near the Sun a label candidate past the fifteenth can sit at the far end of the catalogue's
|
||
// brightness order, so asking for one more than is used can cost a walk of the whole order.
|
||
const component = fixture.componentInstance as unknown as {
|
||
spreadLabels(candidates: Iterable<{ id: number; name: string; x: number; y: number; z: number }>, camera: THREE.Camera, keepId: null): unknown[];
|
||
};
|
||
const camera = engine.getCamera();
|
||
camera.updateMatrixWorld(true);
|
||
camera.updateProjectionMatrix();
|
||
let pulled = 0;
|
||
const grid = function* () {
|
||
for (let row = 0; row < 5; row++) {
|
||
for (let column = 0; column < 5; column++) {
|
||
pulled++;
|
||
const point = new THREE.Vector3(-0.8 + column * 0.4, -0.8 + row * 0.4, 0.5).unproject(camera);
|
||
yield { id: row * 5 + column, name: `label-${pulled}`, x: point.x, y: point.y, z: point.z };
|
||
}
|
||
}
|
||
};
|
||
|
||
expect(component.spreadLabels(grid(), camera, null)).toHaveLength(15);
|
||
expect(pulled).toBe(15);
|
||
});
|
||
|
||
it('flies the camera into a selected star system: hides the galaxy group, shows the system group, and switches to AU-scale near/far planes', async () => {
|
||
navigationStore.selectStar(SUN.id);
|
||
await flushAsync();
|
||
|
||
// Approach leg (parsec space) + settle leg (AU space) with margin.
|
||
await advanceFrames(engine, 2.5);
|
||
|
||
const component = fixture.componentInstance as unknown as { galaxyGroup: THREE.Group; systemGroup: THREE.Group };
|
||
expect(component.galaxyGroup.visible).toBe(false);
|
||
expect(component.systemGroup.visible).toBe(true);
|
||
expect(engine.getCamera().near).toBeCloseTo(0.002, 9);
|
||
expect(navigationStore.viewLevel()).toBe('system');
|
||
});
|
||
|
||
it('performs the floating-origin recenter: the camera lands close to the AU-space origin, not out at parsec-scale coordinates', async () => {
|
||
navigationStore.selectStar(ALPHA_CENTAURI.id);
|
||
await flushAsync();
|
||
await advanceFrames(engine, 2.5);
|
||
|
||
// Regardless of how far away (in parsecs) the star was, once we're in system space the
|
||
// camera must be within a few thousand AU of the origin -- never still out at the star's
|
||
// original parsec-scale distance from the Sun.
|
||
const distanceFromOrigin = engine.getCamera().position.length();
|
||
expect(distanceFromOrigin).toBeLessThan(1000);
|
||
expect(distanceFromOrigin).toBeGreaterThan(0);
|
||
});
|
||
|
||
it('flies back out to the galaxy overview and restores parsec-scale near/far planes when the selection is cleared', async () => {
|
||
navigationStore.selectStar(SUN.id);
|
||
await flushAsync();
|
||
await advanceFrames(engine, 2.5);
|
||
expect(navigationStore.viewLevel()).toBe('system');
|
||
|
||
navigationStore.selectStar(null);
|
||
await flushAsync();
|
||
await advanceFrames(engine, 2.5);
|
||
|
||
const component = fixture.componentInstance as unknown as { galaxyGroup: THREE.Group; systemGroup: THREE.Group };
|
||
expect(component.galaxyGroup.visible).toBe(true);
|
||
expect(component.systemGroup.visible).toBe(false);
|
||
// Parsec-scale rather than an exact figure: in galaxy space the depth range scales with how
|
||
// far the camera has pulled back, so what identifies it is the far plane it settles on
|
||
// (5000 pc) versus the AU-space one (20000 AU), not a fixed near plane.
|
||
expect(engine.getCamera().far).toBeCloseTo(5000, 6);
|
||
// The near plane tracks how far back the camera is rather than sitting at a constant, so
|
||
// what identifies galaxy space is that it is a small fraction of that far plane.
|
||
expect(engine.getCamera().near).toBeLessThan(engine.getCamera().far / 1000);
|
||
expect(navigationStore.viewLevel()).toBe('galaxy');
|
||
});
|
||
|
||
it('hopping directly from one system to another exits the first system before entering the second, without settling back in the galaxy view', async () => {
|
||
navigationStore.selectStar(SUN.id);
|
||
await flushAsync();
|
||
await advanceFrames(engine, 2.5);
|
||
expect(navigationStore.viewLevel()).toBe('system');
|
||
|
||
navigationStore.selectStar(ALPHA_CENTAURI.id);
|
||
await flushAsync();
|
||
await advanceFrames(engine, 3.5);
|
||
|
||
const component = fixture.componentInstance as unknown as { currentStarId: number | null };
|
||
expect(navigationStore.viewLevel()).toBe('system');
|
||
expect(component.currentStarId).toBe(ALPHA_CENTAURI.id);
|
||
});
|
||
|
||
it('reports the galactic scale once the camera has pulled back far enough, and comes back', async () => {
|
||
const camera = engine.getCamera();
|
||
|
||
camera.position.set(0, 0, 30000);
|
||
await advanceFrames(engine, 0.3);
|
||
expect(navigationStore.viewLevel()).toBe('galactic');
|
||
|
||
camera.position.set(0, 15, 30);
|
||
await advanceFrames(engine, 0.3);
|
||
expect(navigationStore.viewLevel()).toBe('galaxy');
|
||
});
|
||
|
||
it('widens the depth range as the camera pulls back, instead of holding one range for both scales', async () => {
|
||
const camera = engine.getCamera();
|
||
|
||
await advanceFrames(engine, 0.3);
|
||
const localFar = camera.far;
|
||
|
||
camera.position.set(0, 0, 30000);
|
||
await advanceFrames(engine, 0.3);
|
||
|
||
expect(camera.far).toBeGreaterThan(localFar);
|
||
// A near plane a hundredth of a parsec out has no precision left to spare at this range.
|
||
expect(camera.near).toBeGreaterThan(1);
|
||
});
|
||
|
||
it('flies out to the Galaxy when the scale ladder asks for it', async () => {
|
||
const camera = engine.getCamera();
|
||
fixture.componentInstance.goToLevel('galactic');
|
||
await advanceFrames(engine, 3);
|
||
|
||
expect(camera.position.length()).toBeGreaterThan(10000);
|
||
expect(navigationStore.viewLevel()).toBe('galactic');
|
||
});
|
||
|
||
it('leaves the system first when the scale ladder is used from inside one', async () => {
|
||
navigationStore.selectStar(SUN.id);
|
||
await flushAsync();
|
||
await advanceFrames(engine, 2.5);
|
||
expect(navigationStore.viewLevel()).toBe('system');
|
||
|
||
fixture.componentInstance.goToLevel('galactic');
|
||
await flushAsync();
|
||
// Exit leg, then the return leg, then the galactic flight: the request has to wait out the
|
||
// unit-space unwind rather than firing a parsec-scale flight while the scene is in AU.
|
||
await advanceFrames(engine, 6);
|
||
|
||
const component = fixture.componentInstance as unknown as { currentStarId: number | null; systemGroup: THREE.Group };
|
||
expect(component.currentStarId).toBeNull();
|
||
expect(component.systemGroup.visible).toBe(false);
|
||
expect(navigationStore.viewLevel()).toBe('galactic');
|
||
});
|
||
|
||
it('names what the neighbourhood holds, and where the positions of the stars in it come from', async () => {
|
||
await advanceFrames(engine, 0.3);
|
||
const component = fixture.componentInstance as unknown as { hudSubtitle(): string; hudNote(): string };
|
||
expect(component.hudSubtitle()).toBe(catalogueCensus(STARS));
|
||
expect(component.hudNote()).toBe(positionsNote(STARS));
|
||
expect(component.hudNote()).toContain('1 planet hosts only the NASA Exoplanet Archive places, from its distances');
|
||
});
|
||
|
||
it('offers a star for a route by its classification, and a star with none by its name alone', () => {
|
||
const component = fixture.componentInstance as unknown as {
|
||
starSearchIndex(): { entry: { starId?: number; subtitle: string } }[];
|
||
routeOptions(): { id: number; subtitle: string }[];
|
||
onRouteQuery(query: string): void;
|
||
currentStarOption(): { subtitle: string } | null;
|
||
};
|
||
const optionFor = (query: string, id: number): string | undefined => {
|
||
component.onRouteQuery(query);
|
||
return component.routeOptions().find((option) => option.id === id)?.subtitle;
|
||
};
|
||
expect(optionFor('KMT-2016', LENS.id)).toBe('');
|
||
expect(optionFor('Proxima', PROXIMA.id)).toBe('M5V');
|
||
// Classified for the options shown only: the index holds none, where all 455 571 stars cost 140-230 ms at boot.
|
||
expect(component.starSearchIndex().every(({ entry }) => entry.subtitle === '')).toBe(true);
|
||
navigationStore.selectStar(LENS.id);
|
||
expect(component.currentStarOption()?.subtitle).toBe('');
|
||
navigationStore.selectStar(PROXIMA.id);
|
||
expect(component.currentStarOption()?.subtitle).toBe('M5V');
|
||
});
|
||
|
||
describe('each star at its own size and in its own colour', () => {
|
||
type DrawnStar = {
|
||
starMarkerGeometry: THREE.SphereGeometry;
|
||
starTint: { value: THREE.Color };
|
||
controls: { minDistance: number };
|
||
systemRenderer: { object: THREE.Object3D };
|
||
hudReadouts(): { label: string; value: string; derived?: boolean }[];
|
||
};
|
||
|
||
async function enter(star: StarRecord): Promise<DrawnStar> {
|
||
navigationStore.selectStar(star.id);
|
||
await flushAsync();
|
||
await advanceFrames(engine, 2.5);
|
||
return fixture.componentInstance as unknown as DrawnStar;
|
||
}
|
||
|
||
function expectColour(colour: THREE.Color, [red, green, blue]: readonly number[]): void {
|
||
expect([colour.r, colour.g, colour.b].map((channel) => channel.toFixed(4))).toEqual([red, green, blue].map((channel) => channel.toFixed(4)));
|
||
}
|
||
|
||
it('draws a host at the radius and in the colour the archive gives it, lights its planets in its light, and says how bright it is', async () => {
|
||
const scene = await enter(PROXIMA);
|
||
expect(scene.starMarkerGeometry.parameters.radius).toBeCloseTo(0.141 * SUN_RADIUS_AU, 12);
|
||
expectColour(scene.starTint.value, blackbodyColor(2900));
|
||
const light = scene.systemRenderer.object.children.find((child): child is THREE.PointLight => child instanceof THREE.PointLight)!;
|
||
expectColour(light.color, blackbodyColor(2900, SOLAR_EFFECTIVE_TEMPERATURE_K));
|
||
expect(scene.hudReadouts().find((readout) => readout.label === 'Luminosity')).toEqual({ label: 'Luminosity', value: '0.0015 L☉' });
|
||
expect(scene.hudReadouts().find((readout) => readout.label === 'Radius')?.value).toBe('0.141 solar radii');
|
||
});
|
||
|
||
it("draws the disc as the Sun's photograph in the star's colour, darkened towards the limb", async () => {
|
||
// The disc's three parts, read off the material's node graph: the tint the star's temperature
|
||
// sets, the photograph, and the limb-darkening coefficient, 0.6 as the Sun's. Before, only the
|
||
// tint uniform was read, which the scene sets whether or not the material uses it.
|
||
const scene = await enter(PROXIMA);
|
||
const nodes = new Set<THREE.Node>();
|
||
const walk = (node: THREE.Node): void => {
|
||
if (!nodes.has(node)) {
|
||
nodes.add(node);
|
||
for (const child of node.getChildren()) {
|
||
walk(child);
|
||
}
|
||
}
|
||
};
|
||
walk((scene as unknown as { starMarkerMaterial: THREE.MeshBasicNodeMaterial }).starMarkerMaterial.colorNode!);
|
||
const values = [...nodes].map((node) => (node as { value?: unknown }).value);
|
||
expect(values).toContain(scene.starTint.value);
|
||
expect(values).toContain(loadCachedTexture(SUN_TEXTURE_PATH));
|
||
expect(values).toContain(0.6);
|
||
});
|
||
|
||
it('tints a host in the star field the colour its disc is drawn in, at the temperature the archive gives it', async () => {
|
||
// Proxima's B−V 1.8 reads 3 070 K; its disc is drawn at the archive's 2 900.
|
||
const scene = await enter(PROXIMA);
|
||
const field = (scene as unknown as { starField: { catalogueColors: Float32Array } }).starField.catalogueColors;
|
||
const at = STARS.indexOf(PROXIMA) * 3;
|
||
const disc = scene.starTint.value;
|
||
expect([field[at], field[at + 1], field[at + 2]].map((channel) => channel.toFixed(4))).toEqual([disc.r, disc.g, disc.b].map((channel) => channel.toFixed(4)));
|
||
});
|
||
|
||
it("warms a host's planets by the luminosity the archive gives it, in the system as on their own page", async () => {
|
||
const scene = await enter(PROXIMA);
|
||
const planet = (scene.systemRenderer as unknown as { members: { id: string; marker: THREE.Mesh }[] }).members.find((member) => member.id === PROXIMA_B.id)!;
|
||
// The archive's 1.51×10⁻³ L☉ puts b at 228 K, temperate. The fixture has no measured band, so
|
||
// without it b gets no temperature and another class, as it does in the Sun's light.
|
||
const warmed = appearanceForExoplanet(PROXIMA_B, 0.00151);
|
||
expect(warmed.planetClass).not.toBe(appearanceForExoplanet(PROXIMA_B, null).planetClass);
|
||
expect(warmed.planetClass).not.toBe(appearanceForExoplanet(PROXIMA_B, 1).planetClass);
|
||
expect((planet.marker.material as THREE.MeshStandardMaterial).map).toBe(planetTexture(warmed, { width: 128, height: 64 }));
|
||
});
|
||
|
||
it('keeps the camera three radii out from a supergiant drawn at the radius its type and brightness give', async () => {
|
||
const scene = await enter(ANTARES);
|
||
const radius = scene.starMarkerGeometry.parameters.radius;
|
||
// 410 R☉, 1.9 AU, at M1's 3 730 K: short of the 680 Ohnaka et al. (2013) measure, whose
|
||
// luminosity is 0.4 dex above what V gives at the catalogue's distance.
|
||
expect(radius / SUN_RADIUS_AU).toBeGreaterThan(350);
|
||
expect(radius / SUN_RADIUS_AU).toBeLessThan(480);
|
||
expect(scene.controls.minDistance).toBeCloseTo(closestApproachAu(radius), 9);
|
||
expect(scene.controls.minDistance).toBeGreaterThan(5);
|
||
// Settled where its disc stays inside the ring of its neighbours' names, not pressed up to it.
|
||
expect(engine.getCamera().position.length()).toBeGreaterThan(1.2 * scene.controls.minDistance);
|
||
});
|
||
|
||
it('draws a star nothing gives a size or temperature for as a grey point, not as the Sun', async () => {
|
||
const scene = await enter(PROCYON_B);
|
||
expect(scene.starMarkerGeometry.parameters.radius).toBeLessThan(SUN_RADIUS_AU / 1000);
|
||
expectColour(scene.starTint.value, [1, 1, 1]);
|
||
expect(scene.hudReadouts().some((readout) => readout.label === 'Radius')).toBe(false);
|
||
});
|
||
});
|
||
|
||
it('ignores a new selection while a transition is already in flight, then resolves to the latest requested star once idle', async () => {
|
||
navigationStore.selectStar(SUN.id);
|
||
await flushAsync();
|
||
|
||
// Fire a second selection mid-flight, before the first transition has settled.
|
||
await advanceFrames(engine, 0.3);
|
||
navigationStore.selectStar(PROXIMA.id);
|
||
await flushAsync();
|
||
|
||
await advanceFrames(engine, 6);
|
||
|
||
const component = fixture.componentInstance as unknown as { currentStarId: number | null };
|
||
expect(component.currentStarId).toBe(PROXIMA.id);
|
||
expect(navigationStore.viewLevel()).toBe('system');
|
||
});
|
||
});
|