mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 08:12:24 +00:00
The launches layer's sites, markers, reticles, mission lines, live orbit rings and pad zone are now renderer draw sets. Picks go through the query port, double-click follow through the camera port (shared with other layers in src/data/stockFollow.js), and per-frame work through the frame port. rendering.js, orbitRendering.js and launchPad.js leave the Cesium list. The Cesium draw port gains what these need: pattern line styles, lines in the inertial frame turned each frame by the set's motion clock, radial-rim fills on clamped ellipses with a depth bias, and parking for hidden lines that cannot settle into a static batch, so a hidden line no longer costs a draw each frame. A roster writes each set once, and a followed live payload shares one position sample with its marker each frame.
280 lines
7.8 KiB
JavaScript
280 lines
7.8 KiB
JavaScript
import test from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import { Event } from 'cesium';
|
|
import { createLaunchHover } from './lifecycle.js';
|
|
import {
|
|
bindFakeCesiumCamera,
|
|
fakeCameraPort,
|
|
} from '../../testSupport/fakeCameraPort.mjs';
|
|
import { bindRenderer } from '../../render/rendererOf.js';
|
|
|
|
function fakeTimers() {
|
|
const timers = new Map();
|
|
let nextId = 1;
|
|
const api = {
|
|
setTimer(fn, ms) {
|
|
const id = nextId++;
|
|
timers.set(id, { fn, ms });
|
|
return id;
|
|
},
|
|
clearTimer(id) {
|
|
timers.delete(id);
|
|
},
|
|
pending: () => [...timers.values()],
|
|
flush() {
|
|
const due = [...timers.entries()];
|
|
timers.clear();
|
|
for (const [, timer] of due) timer.fn();
|
|
},
|
|
};
|
|
return api;
|
|
}
|
|
|
|
function hoverRig({ overMarker }) {
|
|
let at = 0,
|
|
picks = 0,
|
|
enabled = true,
|
|
free = true;
|
|
const timers = fakeTimers();
|
|
const viewer = bindFakeCesiumCamera({
|
|
camera: { moveStart: new Event(), moveEnd: new Event() },
|
|
scene: { canvas: { style: { cursor: '' } } },
|
|
});
|
|
const hover = createLaunchHover({
|
|
viewer,
|
|
enabled: () => enabled,
|
|
launchAt(position) {
|
|
picks++;
|
|
return overMarker(position);
|
|
},
|
|
now: () => at,
|
|
documentRef: { hidden: false },
|
|
pointerFree: () => free,
|
|
setTimer: timers.setTimer,
|
|
clearTimer: timers.clearTimer,
|
|
});
|
|
return {
|
|
hover,
|
|
timers,
|
|
viewer,
|
|
cursor: () => viewer.scene.canvas.style.cursor,
|
|
picks: () => picks,
|
|
setTime: (value) => (at = value),
|
|
setEnabled: (value) => (enabled = value),
|
|
setFree: (value) => (free = value),
|
|
};
|
|
}
|
|
|
|
const onMarker = (position) => position?.x === 1;
|
|
const marker = () => ({ endPosition: { x: 1, y: 1 } });
|
|
const empty = () => ({ endPosition: { x: 9, y: 9 } });
|
|
|
|
test('mission hover runs one trailing check for a pointer that stops on empty space', () => {
|
|
const rig = hoverRig({ overMarker: onMarker });
|
|
rig.hover.move(marker());
|
|
assert.equal(rig.cursor(), 'pointer');
|
|
rig.setTime(50);
|
|
const movement = empty();
|
|
rig.hover.move(movement);
|
|
// Cesium reuses its movement object; the trailing check must use a copy.
|
|
movement.endPosition.x = 1;
|
|
assert.equal(rig.picks(), 1);
|
|
assert.deepEqual(
|
|
rig.timers.pending().map((timer) => timer.ms),
|
|
[70],
|
|
);
|
|
rig.setTime(80);
|
|
rig.hover.move(empty());
|
|
assert.equal(rig.timers.pending().length, 1, 'one trailing check at a time');
|
|
rig.setTime(120);
|
|
rig.timers.flush();
|
|
assert.equal(rig.picks(), 2);
|
|
assert.equal(rig.cursor(), '');
|
|
assert.equal(rig.timers.pending().length, 0);
|
|
rig.hover.destroy();
|
|
});
|
|
|
|
test('mission hover trailing check sets the cursor for a pointer that stops on a mission', () => {
|
|
const rig = hoverRig({ overMarker: onMarker });
|
|
rig.hover.move(empty());
|
|
assert.equal(rig.cursor(), '');
|
|
rig.setTime(50);
|
|
rig.hover.move(marker());
|
|
rig.setTime(120);
|
|
rig.timers.flush();
|
|
assert.equal(rig.picks(), 2);
|
|
assert.equal(rig.cursor(), 'pointer');
|
|
rig.hover.destroy();
|
|
assert.equal(rig.cursor(), '');
|
|
});
|
|
|
|
test('mission hover trailing check is cancelled by reset, destroy, and camera motion', () => {
|
|
for (const cancel of [
|
|
(rig) => rig.hover.reset(),
|
|
(rig) => rig.hover.destroy(),
|
|
(rig) => rig.viewer.camera.moveStart.raiseEvent(),
|
|
]) {
|
|
const rig = hoverRig({ overMarker: onMarker });
|
|
rig.hover.move(empty());
|
|
rig.setTime(50);
|
|
rig.hover.move(marker());
|
|
assert.equal(rig.timers.pending().length, 1);
|
|
cancel(rig);
|
|
assert.equal(rig.timers.pending().length, 0);
|
|
assert.equal(rig.picks(), 1);
|
|
assert.equal(rig.cursor(), '');
|
|
rig.hover.destroy();
|
|
}
|
|
});
|
|
|
|
test('mission hover trailing check rechecks eligibility before picking', () => {
|
|
for (const block of [
|
|
(rig) => rig.setEnabled(false),
|
|
(rig) => rig.setFree(false),
|
|
]) {
|
|
const rig = hoverRig({ overMarker: onMarker });
|
|
rig.hover.move(marker());
|
|
rig.setTime(50);
|
|
rig.hover.move(marker());
|
|
block(rig);
|
|
rig.setTime(120);
|
|
rig.timers.flush();
|
|
assert.equal(rig.picks(), 1);
|
|
assert.equal(rig.cursor(), '');
|
|
rig.hover.destroy();
|
|
}
|
|
});
|
|
|
|
test('mission hover throttles, clears on motion/hidden, and releases listeners', () => {
|
|
let at = 0,
|
|
picks = 0,
|
|
enabled = true;
|
|
const listeners = new Set();
|
|
const doc = {
|
|
hidden: false,
|
|
addEventListener: (_n, fn) => listeners.add(fn),
|
|
removeEventListener: (_n, fn) => listeners.delete(fn),
|
|
};
|
|
const camera = fakeCameraPort();
|
|
const viewer = {
|
|
get canvas() {
|
|
return this.scene?.canvas;
|
|
},
|
|
scene: { canvas: { style: {} } },
|
|
};
|
|
bindRenderer(viewer, { camera: camera.port });
|
|
const hover = createLaunchHover({
|
|
viewer,
|
|
enabled: () => enabled,
|
|
launchAt() {
|
|
picks++;
|
|
return true;
|
|
},
|
|
now: () => at,
|
|
documentRef: doc,
|
|
pointerFree: () => true,
|
|
...fakeTimers(),
|
|
});
|
|
for (at = 0; at < 120; at++) hover.move({ endPosition: {} });
|
|
assert.equal(picks, 1);
|
|
assert.equal(viewer.scene.canvas.style.cursor, 'pointer');
|
|
hover.move({ endPosition: {} });
|
|
assert.equal(picks, 2);
|
|
camera.emit('moveStart');
|
|
at = 500;
|
|
hover.move({ endPosition: {} });
|
|
assert.equal(picks, 2);
|
|
assert.equal(viewer.scene.canvas.style.cursor, '');
|
|
camera.emit('moveEnd');
|
|
hover.move({ endPosition: {} });
|
|
assert.equal(picks, 3);
|
|
doc.hidden = true;
|
|
for (const fn of listeners) fn();
|
|
hover.move({ endPosition: {} });
|
|
assert.equal(picks, 3);
|
|
assert.equal(viewer.scene.canvas.style.cursor, '');
|
|
doc.hidden = false;
|
|
enabled = false;
|
|
hover.move({ endPosition: {} });
|
|
assert.equal(picks, 3);
|
|
hover.destroy();
|
|
assert.equal(listeners.size, 0);
|
|
assert.equal(camera.listenerCount('moveStart'), 0);
|
|
assert.equal(camera.listenerCount('moveEnd'), 0);
|
|
});
|
|
|
|
test('mission hover preserves the cursor of a pointer-owning tool', () => {
|
|
let free = true,
|
|
picks = 0;
|
|
const viewer = bindFakeCesiumCamera({
|
|
camera: { moveStart: new Event(), moveEnd: new Event() },
|
|
scene: { canvas: { style: { cursor: '' } } },
|
|
});
|
|
const hover = createLaunchHover({
|
|
viewer,
|
|
enabled: () => true,
|
|
launchAt() {
|
|
picks++;
|
|
return true;
|
|
},
|
|
documentRef: null,
|
|
pointerFree: () => free,
|
|
});
|
|
hover.move({ endPosition: {} });
|
|
assert.equal(viewer.scene.canvas.style.cursor, 'pointer');
|
|
free = false;
|
|
viewer.scene.canvas.style.cursor = 'crosshair';
|
|
hover.move({ endPosition: {} });
|
|
viewer.camera.moveStart.raiseEvent();
|
|
hover.destroy();
|
|
assert.equal(picks, 1);
|
|
assert.equal(viewer.scene.canvas.style.cursor, 'crosshair');
|
|
});
|
|
|
|
test('mission picks are read by the rendering part, which owns the draw sets', async () => {
|
|
const { createRendering } = await import('./rendering.js');
|
|
const { bindFakeDraw } = await import('../../testSupport/fakeDrawPort.mjs');
|
|
const drilled = [];
|
|
const viewer = {};
|
|
let hits = [];
|
|
const { unbind } = bindFakeDraw(viewer, {
|
|
query: {
|
|
drillPick(x, y, options) {
|
|
drilled.push([x, y, options]);
|
|
return hits;
|
|
},
|
|
},
|
|
});
|
|
const state = { _viewer: viewer };
|
|
const rendering = createRendering({
|
|
state,
|
|
services: { satellites: {} },
|
|
parts: {},
|
|
});
|
|
rendering.attach(viewer);
|
|
const { sites, lines } = rendering.setIds;
|
|
hits = [
|
|
{ set: 'cables:1', id: 'rocket-launch:zzz', surface: false },
|
|
{ set: sites, id: 'rocket-launch:abc', surface: false },
|
|
];
|
|
assert.equal(rendering.launchMarkerAt({ x: 3, y: 4 }), true);
|
|
assert.deepEqual(drilled, [[3, 4, { limit: 12 }]]);
|
|
assert.equal(rendering.launchIdFromPicks(hits), 'abc');
|
|
assert.equal(
|
|
rendering.launchIdFromPicks([
|
|
{ set: lines, id: 'rocket-trajectory:def:0', surface: false },
|
|
]),
|
|
'def',
|
|
);
|
|
assert.equal(
|
|
rendering.launchIdFromPicks([{ set: sites, id: 'x', surface: false }]),
|
|
null,
|
|
);
|
|
hits = [hits[0]];
|
|
assert.equal(rendering.launchMarkerAt({ x: 3, y: 4 }), false);
|
|
state._viewer = null;
|
|
assert.equal(rendering.launchMarkerAt({ x: 3, y: 4 }), false);
|
|
rendering.detach();
|
|
unbind();
|
|
});
|