mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-18 01:02:23 +00:00
feat(satellites): render on Navara
Render satellite fleets and selected targets through mover banks and orbit lines. Enable the celestial HUD on Navara and keep native follow explicitly in ENU. Add deterministic interaction, share, orbit, motion and cleanup acceptance QA. Record complete targeted acceptance and remaining shared cross-shell tile failures.
This commit is contained in:
1 parent
000ef99464
commit
6bdb995fe3
25 files changed
+727
-53
No files matched your search
@@ -1,3 +1,4 @@
|
||||
import * as geo from '../../geo/index.js';
|
||||
import { createControls } from './controls.js';
|
||||
import { createCatalog } from './catalog.js';
|
||||
import { createLabels } from './labels.js';
|
||||
@@ -43,6 +44,36 @@ export function createSatellitesLayer({ services, source }) {
|
||||
parts.lifecycle.methods,
|
||||
parts.ingestion.methods,
|
||||
{
|
||||
qaDrawn() {
|
||||
if (!state._renderer) return null;
|
||||
const plain = (p) => (p ? { x: p.x, y: p.y, z: p.z } : null);
|
||||
return {
|
||||
enabled: state._enabled,
|
||||
points: [...state._points].map(([id, point]) => ({
|
||||
id,
|
||||
position: plain(point.position),
|
||||
show: state._enabled && state._params.showPoints && point.show,
|
||||
size: point.pixelSize,
|
||||
alpha: point.color.alpha,
|
||||
})),
|
||||
tracked: plain(getRenderer().trackedPosition?.(state._trackedEntity)),
|
||||
rings: [...state._orbitPaths].map(([id, path]) => ({
|
||||
id,
|
||||
show: path.primitive.show,
|
||||
anchors: Array.from({ length: 8 }, (_, i) =>
|
||||
plain(
|
||||
geo.matrix4.multiplyByPoint(
|
||||
path.primitive.modelMatrix,
|
||||
path.basePositions[
|
||||
Math.floor((i * (path.basePositions.length - 1)) / 8)
|
||||
],
|
||||
geo.cartesian3.create(),
|
||||
),
|
||||
),
|
||||
),
|
||||
})),
|
||||
};
|
||||
},
|
||||
satelliteVisualsVisible: parts.controls.satelliteVisualsVisible,
|
||||
satelliteCatalogModeChanged: parts.controls.satelliteCatalogModeChanged,
|
||||
createIssOverlayEntry: parts.labels.createIssOverlayEntry,
|
||||
|
||||
@@ -31,8 +31,11 @@ export function createInteraction({
|
||||
if (
|
||||
layerState._trackedNorad &&
|
||||
layerState._viewer &&
|
||||
getRenderer().follow.current() &&
|
||||
getRenderer().follow.current() !== layerState._trackedEntity
|
||||
((getRenderer().follow.current() &&
|
||||
getRenderer().follow.current() !== layerState._trackedEntity) ||
|
||||
(getRenderer().kind === 'navara' &&
|
||||
!getRenderer().follow.current() &&
|
||||
!getRenderer().follow.releasing()))
|
||||
) {
|
||||
parts.tracking._clearTracking(true, {
|
||||
origin:
|
||||
@@ -56,8 +59,7 @@ export function createInteraction({
|
||||
return;
|
||||
|
||||
// Check if it's a satellite point (id is NORAD catalog number)
|
||||
const prim = picked.primitive;
|
||||
if (prim && prim.id != null) {
|
||||
if (Number.isFinite(getRenderer().pickedNorad(picked))) {
|
||||
const noradId = getRenderer().pickedNorad(picked);
|
||||
if (!isNaN(noradId) && layerState._catalog.has(noradId)) {
|
||||
parts.tracking._cancelPendingTrackingRestore();
|
||||
|
||||
@@ -54,7 +54,8 @@ export function createSatellitesCesiumRenderer(engine, { viewer } = {}) {
|
||||
createTracked({ position, viewFrom }) {
|
||||
return viewer.entities.add({
|
||||
position: new Cesium.CallbackProperty(position, false),
|
||||
viewFrom,
|
||||
viewFrom: new Cesium.Cartesian3(viewFrom.x, viewFrom.y, viewFrom.z),
|
||||
trackingReferenceFrame: Cesium.TrackingReferenceFrame.ENU,
|
||||
point: {
|
||||
pixelSize: 14,
|
||||
color: Cesium.Color.YELLOW,
|
||||
@@ -64,13 +65,26 @@ export function createSatellitesCesiumRenderer(engine, { viewer } = {}) {
|
||||
},
|
||||
});
|
||||
},
|
||||
trackedPosition: (entity) =>
|
||||
entity?.position?.getValue(viewer.clock.currentTime),
|
||||
removeTracked: (entity) => viewer?.entities.remove(entity),
|
||||
follow: {
|
||||
start: (entity) => {
|
||||
viewer.trackedEntity = entity;
|
||||
if (engine) {
|
||||
engine.camera.follow({
|
||||
native: entity,
|
||||
position: () => entity.position.getValue(viewer.clock.currentTime),
|
||||
viewFrom: () => entity.viewFrom.getValue(viewer.clock.currentTime),
|
||||
});
|
||||
} else {
|
||||
viewer.camera?.cancelFlight();
|
||||
viewer.trackedEntity = entity;
|
||||
}
|
||||
},
|
||||
release: () => {
|
||||
if (viewer) viewer.trackedEntity = undefined;
|
||||
const current = engine?.camera.following();
|
||||
if (current && current.native === viewer?.trackedEntity) current.stop();
|
||||
else if (viewer) viewer.trackedEntity = undefined;
|
||||
},
|
||||
current: () => viewer?.trackedEntity,
|
||||
onChanged: (listener) =>
|
||||
|
||||
@@ -0,0 +1,54 @@
|
||||
import test from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import * as Cesium from 'cesium';
|
||||
import * as geo from '../../../geo/index.js';
|
||||
import { createSatellitesCesiumRenderer } from './cesium.js';
|
||||
|
||||
test('native satellite viewFrom fills the scratch vector used by EntityView', () => {
|
||||
const viewer = { entities: new Cesium.EntityCollection() };
|
||||
const renderer = createSatellitesCesiumRenderer(null, { viewer });
|
||||
const viewFrom = geo.cartesian3.create(-450000, -450000, 350000);
|
||||
const entity = renderer.createTracked({
|
||||
position: () => geo.cartesian3.fromDegrees(0, 0, 420000),
|
||||
viewFrom,
|
||||
});
|
||||
assert.equal(
|
||||
entity.trackingReferenceFrame,
|
||||
Cesium.TrackingReferenceFrame.ENU,
|
||||
);
|
||||
const scratch = new Cesium.Cartesian3();
|
||||
const value = entity.viewFrom.getValue(Cesium.JulianDate.now(), scratch);
|
||||
assert.equal(value, scratch);
|
||||
assert.deepEqual(
|
||||
[scratch.x, scratch.y, scratch.z],
|
||||
[viewFrom.x, viewFrom.y, viewFrom.z],
|
||||
);
|
||||
renderer.removeTracked(entity);
|
||||
assert.equal(viewer.entities.values.length, 0);
|
||||
});
|
||||
|
||||
test('native satellite follow goes through the shared camera contract', () => {
|
||||
let options;
|
||||
const viewer = {
|
||||
entities: new Cesium.EntityCollection(),
|
||||
clock: { currentTime: Cesium.JulianDate.now() },
|
||||
};
|
||||
const engine = {
|
||||
camera: {
|
||||
follow: (spec) => {
|
||||
options = spec;
|
||||
},
|
||||
},
|
||||
};
|
||||
const renderer = createSatellitesCesiumRenderer(engine, { viewer });
|
||||
const position = geo.cartesian3.fromDegrees(0, 0, 20200000);
|
||||
const offset = geo.cartesian3.create(-1800000, -1800000, 1400000);
|
||||
const entity = renderer.createTracked({
|
||||
position: () => position,
|
||||
viewFrom: offset,
|
||||
});
|
||||
renderer.follow.start(entity);
|
||||
assert.equal(options.native, entity);
|
||||
assert.equal(options.position(), position);
|
||||
assert.deepEqual({ ...options.viewFrom() }, { ...offset });
|
||||
});
|
||||
@@ -0,0 +1,355 @@
|
||||
// Satellite points, rigid orbit rings and follow through the globe contract.
|
||||
import * as geo from '../../../geo/index.js';
|
||||
import { createMoverBank } from '../../aircraft/render/navara.js';
|
||||
import { createEngineLayerView } from '../../shared/render/engineView.js';
|
||||
import { selectionDispatcherFor } from '../../../data/selectionDispatcher.js';
|
||||
import { WHITE, constantRgba } from '../../shared/color.js';
|
||||
|
||||
const YELLOW = constantRgba(1, 1, 0);
|
||||
export function createSatellitesNavaraRenderer(engine) {
|
||||
const banks = new Map();
|
||||
const points = new Map();
|
||||
const tracked = new Set();
|
||||
const orbits = new Set();
|
||||
const dirty = new Set();
|
||||
let destroyed = false;
|
||||
let inFrame = false;
|
||||
let queued = false;
|
||||
let visible = true;
|
||||
let sequence = 0;
|
||||
let releasing = false;
|
||||
let starting = null;
|
||||
const rgba = new Float64Array(4);
|
||||
const fields = {
|
||||
position: null,
|
||||
color: rgba,
|
||||
scale: 1,
|
||||
show: true,
|
||||
pickId: null,
|
||||
};
|
||||
const positionField = { position: null };
|
||||
const colorField = { color: rgba };
|
||||
const showField = { show: true };
|
||||
const flush = () => {
|
||||
queued = false;
|
||||
for (const bank of dirty) bank.commit();
|
||||
dirty.clear();
|
||||
};
|
||||
const onCommit = (bank) => {
|
||||
dirty.add(bank);
|
||||
if (!inFrame && !queued) {
|
||||
queued = true;
|
||||
queueMicrotask(flush);
|
||||
}
|
||||
};
|
||||
const frame = (run) => {
|
||||
inFrame = true;
|
||||
try {
|
||||
return run();
|
||||
} finally {
|
||||
inFrame = false;
|
||||
flush();
|
||||
}
|
||||
};
|
||||
const layerView = createEngineLayerView(engine, {
|
||||
layerId: 'satellites',
|
||||
wrap: frame,
|
||||
isDestroyed: () => destroyed,
|
||||
});
|
||||
const copyColor = (color) => {
|
||||
rgba[0] = color.red;
|
||||
rgba[1] = color.green;
|
||||
rgba[2] = color.blue;
|
||||
rgba[3] = color.alpha;
|
||||
};
|
||||
const write = (point, set, index) => {
|
||||
copyColor(point.values.color);
|
||||
fields.position = point.values.position;
|
||||
fields.show = point.values.show;
|
||||
fields.pickId = point.id;
|
||||
set.set(index, fields);
|
||||
};
|
||||
const bankFor = (point) => {
|
||||
const v = point.values;
|
||||
const scale = v.scaleByDistance;
|
||||
const outline = v.outlineColor;
|
||||
const depth =
|
||||
v.disableDepthTestDistance === Infinity
|
||||
? 'always'
|
||||
: v.disableDepthTestDistance > 0
|
||||
? { disableWithinM: v.disableDepthTestDistance }
|
||||
: 'normal';
|
||||
const key = [
|
||||
point.family,
|
||||
v.pixelSize,
|
||||
v.outlineWidth,
|
||||
outline.red,
|
||||
outline.green,
|
||||
outline.blue,
|
||||
outline.alpha,
|
||||
...Object.values(scale ?? {}),
|
||||
v.disableDepthTestDistance,
|
||||
].join(':');
|
||||
let entry = banks.get(key);
|
||||
if (!entry) {
|
||||
const id = ++sequence;
|
||||
const bank = createMoverBank(engine, {
|
||||
options: (capacity, generation) => ({
|
||||
id: `satellites-points-${id}-${generation}`,
|
||||
kind: 'point',
|
||||
capacity,
|
||||
pickable: true,
|
||||
depthTest: depth,
|
||||
order: point.family === 'tracked' ? 100 : 0,
|
||||
point: {
|
||||
sizePx: v.pixelSize,
|
||||
outlinePx: v.outlineWidth,
|
||||
outlineColor: [
|
||||
outline.red,
|
||||
outline.green,
|
||||
outline.blue,
|
||||
outline.alpha,
|
||||
],
|
||||
scaleByDistance: scale
|
||||
? [scale.near, scale.nearValue, scale.far, scale.farValue]
|
||||
: null,
|
||||
},
|
||||
}),
|
||||
write,
|
||||
onCommit,
|
||||
});
|
||||
entry = { bank, family: point.family };
|
||||
banks.set(key, entry);
|
||||
bank.setVisible(point.family === 'tracked' || visible);
|
||||
}
|
||||
return entry.bank;
|
||||
};
|
||||
const createPoint = (spec, family = 'fleet') => {
|
||||
const point = {
|
||||
id: spec.id,
|
||||
family,
|
||||
gevBank: null,
|
||||
gevIndex: -1,
|
||||
values: {
|
||||
position: geo.cartesian3.clone(spec.position),
|
||||
color: spec.color ?? WHITE,
|
||||
show: spec.show !== false,
|
||||
pixelSize: spec.pixelSize ?? 1,
|
||||
outlineColor: spec.outlineColor ?? WHITE,
|
||||
outlineWidth: spec.outlineWidth ?? 0,
|
||||
scaleByDistance: spec.scaleByDistance ?? null,
|
||||
disableDepthTestDistance: spec.disableDepthTestDistance ?? 0,
|
||||
},
|
||||
};
|
||||
Object.defineProperties(point, {
|
||||
position: {
|
||||
get: () => point.values.position,
|
||||
set(value) {
|
||||
geo.cartesian3.clone(value, point.values.position);
|
||||
positionField.position = point.values.position;
|
||||
point.gevBank?.update(point, positionField);
|
||||
},
|
||||
},
|
||||
color: {
|
||||
get: () => point.values.color,
|
||||
set(value) {
|
||||
point.values.color = value;
|
||||
copyColor(value);
|
||||
point.gevBank?.update(point, colorField);
|
||||
},
|
||||
},
|
||||
show: {
|
||||
get: () => point.values.show,
|
||||
set(value) {
|
||||
if (point.values.show === Boolean(value)) return;
|
||||
point.values.show = Boolean(value);
|
||||
showField.show = point.values.show;
|
||||
point.gevBank?.update(point, showField);
|
||||
},
|
||||
},
|
||||
});
|
||||
for (const key of [
|
||||
'pixelSize',
|
||||
'outlineWidth',
|
||||
'outlineColor',
|
||||
'scaleByDistance',
|
||||
'disableDepthTestDistance',
|
||||
])
|
||||
Object.defineProperty(point, key, {
|
||||
get: () => point.values[key],
|
||||
set(value) {
|
||||
if (point.values[key] === value) return;
|
||||
point.values[key] = value;
|
||||
bankFor(point).add(point);
|
||||
},
|
||||
});
|
||||
bankFor(point).add(point);
|
||||
return point;
|
||||
};
|
||||
const collection = {
|
||||
get show() {
|
||||
return visible;
|
||||
},
|
||||
set show(value) {
|
||||
visible = Boolean(value);
|
||||
for (const entry of banks.values())
|
||||
if (entry.family === 'fleet') entry.bank.setVisible(visible);
|
||||
},
|
||||
add(spec) {
|
||||
const point = createPoint(spec);
|
||||
points.set(point.id, point);
|
||||
return point;
|
||||
},
|
||||
remove(point) {
|
||||
if (!points.delete(point.id)) return false;
|
||||
point.gevBank?.remove(point);
|
||||
return true;
|
||||
},
|
||||
removeAll() {
|
||||
for (const point of points.values()) point.gevBank?.remove(point);
|
||||
points.clear();
|
||||
},
|
||||
};
|
||||
const follow = {
|
||||
start(entity) {
|
||||
starting = entity;
|
||||
try {
|
||||
const followLabel = {
|
||||
id: entity.gevTrackedId,
|
||||
model: () => entity.gevLabelModel,
|
||||
position: () => entity.gevDisplayPosition?.() ?? entity.sample(),
|
||||
};
|
||||
entity.follow = engine.camera.follow({
|
||||
position: entity.sample,
|
||||
viewFrom: () => entity.viewFrom,
|
||||
label: followLabel,
|
||||
});
|
||||
} finally {
|
||||
starting = null;
|
||||
}
|
||||
},
|
||||
release() {
|
||||
releasing = true;
|
||||
try {
|
||||
engine.camera.following()?.stop();
|
||||
} finally {
|
||||
releasing = false;
|
||||
}
|
||||
},
|
||||
releasing: () => releasing,
|
||||
current() {
|
||||
if (starting) return starting;
|
||||
const current = engine.camera.following();
|
||||
for (const entity of tracked)
|
||||
if (entity.follow === current && current) return entity;
|
||||
return current;
|
||||
},
|
||||
onChanged: (listener) =>
|
||||
engine.camera.followChanged.addEventListener(listener),
|
||||
};
|
||||
return {
|
||||
kind: 'navara',
|
||||
engine,
|
||||
view: layerView.view,
|
||||
createPoints: () => collection,
|
||||
removePoints: () => collection.removeAll(),
|
||||
project: (position, result) =>
|
||||
engine.projector.worldToWindow(position, result),
|
||||
onFrame: (listener) =>
|
||||
layerView.view.on('preRender', () => {
|
||||
listener();
|
||||
for (const entity of tracked) {
|
||||
const position = entity.sample();
|
||||
if (position) entity.point.position = position;
|
||||
}
|
||||
}),
|
||||
createOrbit({ positions, width, color }) {
|
||||
const line = engine.lines.createLine({
|
||||
id: `satellites-orbit-${++sequence}`,
|
||||
widthPx: width,
|
||||
color: [color.red, color.green, color.blue, 0.6],
|
||||
depthFailAlpha: 0.35 / 0.6,
|
||||
arc: 'geodesic',
|
||||
});
|
||||
line.setPositions(positions);
|
||||
const primitive = {
|
||||
line,
|
||||
modelMatrix: geo.matrix4.clone(geo.matrix4.IDENTITY),
|
||||
visible: true,
|
||||
get show() {
|
||||
return this.visible;
|
||||
},
|
||||
set show(value) {
|
||||
this.visible = Boolean(value);
|
||||
line.show(this.visible);
|
||||
},
|
||||
};
|
||||
orbits.add(primitive);
|
||||
return primitive;
|
||||
},
|
||||
commitOrbit: (primitive) =>
|
||||
primitive.line.setModelMatrix(primitive.modelMatrix),
|
||||
removeOrbit(primitive) {
|
||||
primitive.line.destroy();
|
||||
orbits.delete(primitive);
|
||||
},
|
||||
createTracked({ id, position, viewFrom }) {
|
||||
const entity = {
|
||||
id: `satellites:${id}`,
|
||||
sample: position,
|
||||
viewFrom,
|
||||
follow: null,
|
||||
position: { getValue: position },
|
||||
point: createPoint(
|
||||
{
|
||||
id,
|
||||
position: position(),
|
||||
pixelSize: 14,
|
||||
color: YELLOW,
|
||||
outlineColor: WHITE,
|
||||
outlineWidth: 2,
|
||||
disableDepthTestDistance: Infinity,
|
||||
},
|
||||
'tracked',
|
||||
),
|
||||
};
|
||||
tracked.add(entity);
|
||||
return entity;
|
||||
},
|
||||
trackedPosition: (entity) => entity?.point.position,
|
||||
removeTracked(entity) {
|
||||
entity.point.gevBank?.remove(entity.point);
|
||||
tracked.delete(entity);
|
||||
if (entity.follow && engine.camera.following() === entity.follow)
|
||||
follow.release();
|
||||
},
|
||||
follow,
|
||||
listenClick(listener) {
|
||||
const dispatcher = selectionDispatcherFor(engine);
|
||||
if (!dispatcher)
|
||||
throw new Error('Satellite selection dispatcher unavailable');
|
||||
const remove = dispatcher.register('satellites', {
|
||||
owns: (id) => points.has(Number(id)),
|
||||
onClick: listener,
|
||||
});
|
||||
return { destroy: remove };
|
||||
},
|
||||
pickedNorad: (picked) => Number(picked?.id ?? picked?.primitive?.id),
|
||||
isTrackedPick: (picked, entity) =>
|
||||
Boolean(
|
||||
entity &&
|
||||
Number(picked?.id ?? picked?.primitive?.id) === entity.point.id,
|
||||
),
|
||||
destroy() {
|
||||
destroyed = true;
|
||||
for (const orbit of orbits) orbit.line.destroy();
|
||||
orbits.clear();
|
||||
for (const entry of banks.values()) entry.bank.destroy();
|
||||
banks.clear();
|
||||
dirty.clear();
|
||||
points.clear();
|
||||
tracked.clear();
|
||||
layerView.destroy();
|
||||
},
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,101 @@
|
||||
import test from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import * as geo from '../../../geo/index.js';
|
||||
import { createFakeEngine } from '../../../globe/testing/fakeEngine.js';
|
||||
import { WHITE, nearFarScale } from '../../shared/color.js';
|
||||
import { createSatellitesNavaraRenderer } from './navara.js';
|
||||
|
||||
const position = geo.cartesian3.fromDegrees(0, 0, 420000);
|
||||
const spec = (id) => ({
|
||||
id,
|
||||
position,
|
||||
color: WHITE,
|
||||
pixelSize: 12,
|
||||
outlineColor: WHITE.withAlpha(0.3),
|
||||
outlineWidth: 1,
|
||||
scaleByDistance: nearFarScale(1e6, 1.5, 2e7, 0.6),
|
||||
});
|
||||
|
||||
test('satellite banks retain styles, survive growth and update the real store', async () => {
|
||||
const engine = createFakeEngine();
|
||||
const renderer = createSatellitesNavaraRenderer(engine);
|
||||
const points = renderer.createPoints();
|
||||
const all = Array.from({ length: 1500 }, (_, i) => points.add(spec(i)));
|
||||
await Promise.resolve();
|
||||
const [listed] = engine.movers.list();
|
||||
const set = engine.fake.moverSet(listed.id);
|
||||
assert.equal(engine.movers.list().length, 1);
|
||||
assert.equal(set.store.count, 1500);
|
||||
assert.equal(set.store.pickIds[699], 699);
|
||||
assert.deepEqual(set.options.point.outlineColor, [1, 1, 1, 0.3]);
|
||||
const before = set.commits;
|
||||
const remove = renderer.onFrame(() => {
|
||||
all[0].position = { x: 1, y: 2, z: 3 };
|
||||
all[0].show = false;
|
||||
});
|
||||
engine.fake.frame();
|
||||
remove();
|
||||
assert.equal(engine.fake.moverSet(listed.id).commits, before + 1);
|
||||
assert.deepEqual([...set.store.positions.slice(0, 3)], [1, 2, 3]);
|
||||
assert.equal(set.store.shows[0], 0);
|
||||
all[1].pixelSize = 14;
|
||||
await Promise.resolve();
|
||||
assert.equal(set.store.count, 1499);
|
||||
assert.equal(engine.movers.list().length, 2);
|
||||
points.removeAll();
|
||||
await Promise.resolve();
|
||||
assert.ok(engine.movers.list().every((s) => s.count === 0));
|
||||
renderer.destroy();
|
||||
assert.equal(engine.movers.list().length, 0);
|
||||
engine.destroy();
|
||||
});
|
||||
|
||||
test('tracked glyph uses the follow sample and stays visible independently of fleet', async () => {
|
||||
const engine = createFakeEngine();
|
||||
const renderer = createSatellitesNavaraRenderer(engine);
|
||||
const points = renderer.createPoints();
|
||||
points.add(spec(25544));
|
||||
let sample = position;
|
||||
const entity = renderer.createTracked({
|
||||
id: 25544,
|
||||
position: () => sample,
|
||||
viewFrom: { x: -450000, y: -450000, z: 350000 },
|
||||
});
|
||||
entity.gevTrackedId = '25544';
|
||||
renderer.follow.start(entity);
|
||||
points.show = false;
|
||||
const remove = renderer.onFrame(() => {});
|
||||
sample = { x: position.x + 7600, y: 100, z: 0 };
|
||||
engine.fake.frame();
|
||||
remove();
|
||||
assert.deepEqual({ ...renderer.trackedPosition(entity) }, sample);
|
||||
assert.equal(renderer.follow.current(), entity);
|
||||
const sets = engine.movers.list().map((s) => engine.fake.moverSet(s.id));
|
||||
assert.equal(sets.find((s) => s.options.order === 100).store.shows[0], 1);
|
||||
assert.equal(sets.find((s) => s.options.order === 0).store.count, 0);
|
||||
renderer.removeTracked(entity);
|
||||
assert.equal(renderer.follow.current(), null);
|
||||
renderer.destroy();
|
||||
engine.destroy();
|
||||
});
|
||||
|
||||
test('orbit starts at identity, rotates without rebuilding and releases lines', () => {
|
||||
const engine = createFakeEngine();
|
||||
const renderer = createSatellitesNavaraRenderer(engine);
|
||||
const orbit = renderer.createOrbit({
|
||||
positions: [position, { x: 0, y: 6778137, z: 0 }],
|
||||
width: 2.5,
|
||||
color: WHITE,
|
||||
});
|
||||
assert.deepEqual(orbit.modelMatrix, geo.matrix4.IDENTITY);
|
||||
const before = engine.lines.list()[0];
|
||||
orbit.modelMatrix[12] = 123;
|
||||
renderer.commitOrbit(orbit);
|
||||
assert.equal(engine.lines.list()[0].id, before.id);
|
||||
orbit.show = false;
|
||||
assert.equal(engine.lines.list()[0].shown, false);
|
||||
renderer.removeOrbit(orbit);
|
||||
assert.equal(engine.lines.list().length, 0);
|
||||
renderer.destroy();
|
||||
engine.destroy();
|
||||
});
|
||||
@@ -59,6 +59,7 @@ export function createRendering({
|
||||
|
||||
layerState._orbitPaths.set(noradId, {
|
||||
primitive,
|
||||
basePositions,
|
||||
// Same Date object as computeOrbitPath's internal fixedGmst → identical
|
||||
// GMST value (gstime is pure), so delta starts at exactly 0 and the
|
||||
// initial identity modelMatrix is correct until the first ring tick.
|
||||
|
||||
@@ -449,6 +449,7 @@ export function createTracking({
|
||||
);
|
||||
|
||||
layerState._trackedEntity = getRenderer().createTracked({
|
||||
id: noradId,
|
||||
position,
|
||||
viewFrom,
|
||||
});
|
||||
|
||||
Reference in new issue
Block a user