bruce-cesium 7.6.0 → 7.6.2

package/dist/lib/rendering/render-managers/other/assembly-render-manager.js

@@ -9,7 +9,7 @@ const js_utils_1 = require("../../../internal/js-utils");
 const entity_render_engine_1 = require("../../entity-render-engine");
 const cesium_animated_property_1 = require("../../cesium-animated-property");
 const historic_utils_1 = require("../common/historic-utils");
-const cesium_entity_styler_1 = require("../../../utils/cesium-entity-styler");
+const historic_trail_1 = require("../common/historic-trail");
 const cesium_utils_1 = require("../../../internal/cesium-utils");
 /**
  * Menu Item that will render an Assembly.
@@ -32,6 +32,55 @@ var AssemblyRenderManager;
         get ModelSpace() {
             return this.modelSpace;
         }
+        /**
+         * Every node of the Assembly read so far, so a caller can work out motion in the Assembly's own terms.
+         * @param timeMs the scene time for each node's current pose. Default: the clock's.
+         * @returns per node its pose within its parent from the API (local) and as drawn at the time (current).
+         */
+        GetNodes(timeMs) {
+            const at = timeMs !== null && timeMs !== void 0 ? timeMs : Cesium.JulianDate.toDate(this.viewer.clock.currentTime).getTime();
+            const rowsOf = (m) => m ? [0, 1, 2, 3].map(row => [0, 1, 2, 3].map(column => m[(column * 4) + row])) : null;
+            return Object.values(this.hierarchyNodeByEntityId || {}).map(node => {
+                var _a, _b, _c;
+                const entity = (_a = this.apiEntities.get(node.entityId)) !== null && _a !== void 0 ? _a : null;
+                const rows = (_b = entity === null || entity === void 0 ? void 0 : entity.Bruce) === null || _b === void 0 ? void 0 : _b.AssemblyPosition;
+                return {
+                    entityId: node.entityId,
+                    name: node.name,
+                    parentId: (_c = node.parentId) !== null && _c !== void 0 ? _c : null,
+                    local: Manager.MatrixFromRows(rows) ? rows : null,
+                    current: rowsOf(this.localAt(node.entityId, at)),
+                    entity
+                };
+            });
+        }
+        /**
+         * The root's world frame at a time, history and simulation included, eg. to follow or frame the Assembly.
+         * @param timeMs the scene time. Default: the clock's.
+         * @returns null until the root has been read.
+         */
+        GetRootFrame(timeMs) {
+            const root = this.rootAt(timeMs !== null && timeMs !== void 0 ? timeMs : Cesium.JulianDate.toDate(this.viewer.clock.currentTime).getTime());
+            return root ? Manager.rootFrame(root.pos3d, root.heading, root.pitch, root.roll) : null;
+        }
+        /**
+         * A part's world frame at a time as its records and its parents place it, size included.
+         * @param entityId the part.
+         * @param timeMs the scene time. Default: the clock's.
+         * @returns null until the root and the part have been read.
+         */
+        GetPartFrame(entityId, timeMs) {
+            const at = timeMs !== null && timeMs !== void 0 ? timeMs : Cesium.JulianDate.toDate(this.viewer.clock.currentTime).getTime();
+            const rootFrame = this.GetRootFrame(at);
+            const world = entityId === this.rootId ? Cesium.Matrix4.IDENTITY : this.composeWorld(entityId, at);
+            if (!rootFrame || !world) {
+                return null;
+            }
+            // Where the part is drawn, so its own ground offset is part of its frame.
+            const ground = this.groundOffsets.get(entityId);
+            const placed = ground ? Cesium.Matrix4.multiply(Cesium.Matrix4.fromTranslation(ground), world, new Cesium.Matrix4()) : world;
+            return Cesium.Matrix4.multiply(rootFrame, placed, new Cesium.Matrix4());
+        }
         constructor(params) {
             this.disposed = false;
             // Cache of the hierarchy so that our scene-tree can reference it.
@@ -41,19 +90,41 @@ var AssemblyRenderManager;
             this.hierarchyNodeByEntityId = null;
             this.modelSpace = false;
             this.rootId = null;
-            // Where the root sits now, and which way it faces.
-            // Every child is placed through this, so a root move is one value changing rather than a refetch of the whole Assembly.
+            // Where the root sits outside its history, and which way it faces in degrees. Children are placed through it.
             this.rootPos3d = null;
             this.rootHeading = 0;
-            // Entity ID -> what was drawn for it and where it sits relative to the root.
+            this.rootPitch = 0;
+            this.rootRoll = 0;
+            // The root's recorded positions and attitudes, oldest first, kept apart since a record may name only one.
+            this.rootSeries = [];
+            this.rootAttitude = [];
+            // Every placement worked out for the scene time last asked about, shared by all parts drawn at it.
+            this.pose = null;
+            // Entity ID -> what was drawn for it.
             this.children = new Map();
+            // Entity ID -> its live position within its parent, for every node fetched including undrawn groups.
+            this.localPositions = new Map();
+            // Entity ID -> how much higher the ground under it is than under the root, along the root's up.
+            this.groundOffsets = new Map();
+            // Entity ID -> its recorded poses within its parent, oldest first.
+            this.jointSeries = new Map();
+            // Drawn children that can move with the clock, so a tick places only these and not the whole Assembly.
+            this.animatedIds = new Set();
             // The trail through the root's own movement, which describes the whole Assembly.
-            this.trackEntity = null;
+            this.trail = null;
+            this.simulationRemoval = null;
+            this.FollowsSimulation = true;
+            // Entity ID -> the record the API gave, so a cleared simulation falls back to it without a refetch.
+            this.apiEntities = new Map();
+            // Re-reads history and re-applies it, eg. after simulated records change. Set while the clock is followed.
+            this.regather = null;
+            this.followingClock = false;
             // Callback to dispose the link between scene time and the root's historic position.
             this.viewerDateTimeChangeRemoval = null;
             this.historicGatherer = null;
             this.historicAnimation = null;
             const { viewer, register: visualsManager, getters, item } = params;
+            this.simulation = params.simulation;
             this.viewer = viewer;
             this.getters = getters;
             this.item = item;
@@ -77,10 +148,10 @@ var AssemblyRenderManager;
             return entity_render_engine_1.EntityRenderEngine.GetHeightRef((_b = (_a = item === null || item === void 0 ? void 0 : item.Style) === null || _a === void 0 ? void 0 : _a.Settings) === null || _b === void 0 ? void 0 : _b["modelStyle"]);
         }
         /*
-         * The root's frame: east-north-up at its position, turned by its heading.
+         * The root's frame: east-north-up at its position, turned by its heading, pitch and roll.
          */
-        static rootFrame(rootPos3d, headingDegrees) {
-            const hpr = new Cesium.HeadingPitchRoll(Cesium.Math.toRadians(headingDegrees || 0), 0, 0);
+        static rootFrame(rootPos3d, headingDegrees, pitchDegrees = 0, rollDegrees = 0) {
+            const hpr = new Cesium.HeadingPitchRoll(Cesium.Math.toRadians(headingDegrees || 0), Cesium.Math.toRadians(pitchDegrees || 0), Cesium.Math.toRadians(rollDegrees || 0));
             return Cesium.Transforms.headingPitchRollToFixedFrame(rootPos3d, hpr);
         }
         /**
@@ -103,28 +174,553 @@ var AssemblyRenderManager;
             return Cesium.Matrix4.multiplyByPoint(Manager.rootFrame(rootPos3d, headingDegrees), offset, new Cesium.Cartesian3());
         }
         /**
-         * Moves the whole Assembly to a new root position, without refetching any of its children.
+         * Moves where the root sits outside its history, without refetching children; recorded poses still win.
          * @param params
          */
         ApplyRootPosition(params) {
-            var _a, _b;
+            var _a, _b, _c, _d, _e, _f;
             if (this.disposed || !(params === null || params === void 0 ? void 0 : params.pos3d)) {
                 return;
             }
             this.rootPos3d = params.pos3d;
             this.rootHeading = (_b = (_a = params.heading) !== null && _a !== void 0 ? _a : this.rootHeading) !== null && _b !== void 0 ? _b : 0;
+            this.rootPitch = (_d = (_c = params.pitch) !== null && _c !== void 0 ? _c : this.rootPitch) !== null && _d !== void 0 ? _d : 0;
+            this.rootRoll = (_f = (_e = params.roll) !== null && _e !== void 0 ? _e : this.rootRoll) !== null && _f !== void 0 ? _f : 0;
+            this.repose(true);
+        }
+        /*
+         * Drops every placement worked out so far, after the root or a joint's records change.
+         * @param everyChild re-place the parts that cannot move as well, because where they rest has changed.
+         */
+        repose(everyChild = false) {
+            this.pose = null;
             for (const child of this.children.values()) {
-                const pos3d = Manager.ChildPositionFrom(this.rootPos3d, this.rootHeading, child.offset);
-                if (!pos3d) {
+                if (everyChild || Boolean(child.moving) != this.canMove(child.entityId)) {
+                    this.bindPlacement(child);
+                }
+            }
+            this.viewer.scene.requestRender();
+        }
+        /*
+         * Takes a node's pose outside its history from its record, and for the root where it stands and faces.
+         */
+        absorbNode(entity) {
+            var _a, _b, _c, _d, _e;
+            const id = (_a = entity === null || entity === void 0 ? void 0 : entity.Bruce) === null || _a === void 0 ? void 0 : _a.ID;
+            const local = Manager.MatrixFromRows((_b = entity === null || entity === void 0 ? void 0 : entity.Bruce) === null || _b === void 0 ? void 0 : _b.AssemblyPosition);
+            if (local) {
+                this.localPositions.set(id, local);
+            }
+            // Anchored on the root, which is usually never drawn; everything under it is placed from the hierarchy.
+            if (id === this.rootId || (!this.rootId && !this.rootPos3d)) {
+                const rootPos3d = entity_utils_1.EntityUtils.GetPos({
+                    viewer: this.viewer,
+                    entity,
+                    recordHeightRef: Manager.GetRecordHeightRef(this.item),
+                    returnHeightRef: Cesium.HeightReference.NONE,
+                    allowRendered: false
+                });
+                if (rootPos3d) {
+                    this.rootPos3d = rootPos3d;
+                    this.rootHeading = (0, js_utils_1.EnsureNumber)((_c = entity.Bruce.Transform) === null || _c === void 0 ? void 0 : _c.heading, 0);
+                    this.rootPitch = (0, js_utils_1.EnsureNumber)((_d = entity.Bruce.Transform) === null || _d === void 0 ? void 0 : _d.pitch, 0);
+                    this.rootRoll = (0, js_utils_1.EnsureNumber)((_e = entity.Bruce.Transform) === null || _e === void 0 ? void 0 : _e.roll, 0);
+                }
+            }
+        }
+        /*
+         * A node's record with its simulation laid over it, keeping what a stand-in leaves out, eg. its model.
+         */
+        withSimulation(entity) {
+            var _a;
+            const id = (_a = entity === null || entity === void 0 ? void 0 : entity.Bruce) === null || _a === void 0 ? void 0 : _a.ID;
+            if (!this.simulation || !id) {
+                return entity;
+            }
+            const standIn = this.simulation.GetEntity(id);
+            if (!standIn) {
+                return this.simulation.Overlay(entity);
+            }
+            return { ...entity, ...standIn, Bruce: { ...entity.Bruce, ...standIn.Bruce } };
+        }
+        /*
+         * Brings the Assembly in line with a change to what is simulated.
+         */
+        onSimulationChanged(change) {
+            var _a;
+            if (this.disposed || !this.hierarchyNodeByEntityId) {
+                return;
+            }
+            const ids = change.entityIds.filter(id => this.hierarchyNodeByEntityId[id]);
+            if (!ids.length) {
+                return;
+            }
+            if (change.entities) {
+                for (const id of ids) {
+                    const api = this.apiEntities.get(id);
+                    if (!api) {
+                        // Not loaded yet, and it will be drawn from its simulation when it is.
+                        continue;
+                    }
+                    const entity = this.withSimulation(api);
+                    // A cleared blob leaves the node's own matrix where the API has none, so it is reset.
+                    if (!((_a = entity.Bruce) === null || _a === void 0 ? void 0 : _a.AssemblyPosition)) {
+                        this.localPositions.delete(id);
+                    }
+                    this.absorbNode(entity);
+                    const child = this.children.get(id);
+                    if (child) {
+                        child.entity = entity;
+                    }
+                }
+                this.repose(true);
+            }
+            if (change.records) {
+                if (this.regather) {
+                    this.regather(true);
+                }
+                else {
+                    this.viewerDateTimeSub();
+                }
+            }
+        }
+        /*
+         * Nodes of this Assembly with simulated history.
+         */
+        simulatedNodeIds() {
+            if (!this.simulation || !this.hierarchyNodeByEntityId) {
+                return [];
+            }
+            return this.simulation.GetRecordEntityIds().filter(id => this.hierarchyNodeByEntityId[id]);
+        }
+        /*
+         * Whether a node can move with time: the root has history, or it or an ancestor does.
+         */
+        canMove(entityId) {
+            return this.rootSeries.length > 0 || this.rootAttitude.length > 0 || this.animatedIds.has(entityId);
+        }
+        /*
+         * Gives a child its position and orientation, as functions of scene time only when it can move.
+         */
+        bindPlacement(child) {
+            const id = child.entityId;
+            const moving = this.canMove(id);
+            if (moving) {
+                if (!child.moving) {
+                    child.cEntity.position = new Cesium.CallbackProperty((time, result) => { var _a; return Manager.cloneOrUndefined((_a = this.placementAt(id, time)) === null || _a === void 0 ? void 0 : _a.pos3d, result); }, false);
+                    child.cEntity.orientation = new Cesium.CallbackProperty((time, result) => {
+                        var _a;
+                        const orient = (_a = this.placementAt(id, time)) === null || _a === void 0 ? void 0 : _a.orient;
+                        return orient ? Cesium.Quaternion.clone(orient, result) : undefined;
+                    }, false);
+                    child.cEntity.model.scale = new Cesium.CallbackProperty((time) => { var _a, _b; return (_b = (_a = this.placementAt(id, time)) === null || _a === void 0 ? void 0 : _a.scale) !== null && _b !== void 0 ? _b : 1; }, false);
+                }
+            }
+            else {
+                const placed = this.placementAt(id, this.viewer.clock.currentTime);
+                if (placed) {
+                    child.cEntity.position = new Cesium.ConstantPositionProperty(placed.pos3d);
+                    if (placed.orient) {
+                        child.cEntity.orientation = new Cesium.ConstantProperty(placed.orient);
+                    }
+                    child.cEntity.model.scale = new Cesium.ConstantProperty(placed.scale);
+                }
+            }
+            if (Boolean(child.moving) != moving) {
+                child.moving = moving;
+                this.visualsManager.SetMoving({ moving, entityIds: [id], menuItemId: this.item.id });
+            }
+        }
+        /*
+         * The one scale a model takes from its part's composed matrix, the largest when they are uneven.
+         */
+        static uniformScale(world) {
+            return Cesium.Cartesian3.maximumComponent(Cesium.Matrix4.getScale(world, new Cesium.Cartesian3()));
+        }
+        static cloneOrUndefined(pos3d, result) {
+            return pos3d ? Cesium.Cartesian3.clone(pos3d, result) : undefined;
+        }
+        /*
+         * Where a node draws at a scene time, from one composition shared by every part asked about at that time.
+         */
+        placementAt(entityId, time) {
+            if (this.disposed || !time) {
+                return null;
+            }
+            const timeMs = Cesium.JulianDate.toDate(time).getTime();
+            if (!this.pose || this.pose.timeMs !== timeMs) {
+                const root = this.rootAt(timeMs);
+                this.pose = {
+                    timeMs,
+                    rootFrame: root ? Manager.rootFrame(root.pos3d, root.heading, root.pitch, root.roll) : null,
+                    worlds: new Map(),
+                    placements: new Map()
+                };
+            }
+            const pose = this.pose;
+            if (!pose.rootFrame) {
+                return null;
+            }
+            let placed = pose.placements.get(entityId);
+            if (!placed) {
+                const world = this.composeWorld(entityId, timeMs, pose.worlds);
+                const offset = world
+                    ? Cesium.Matrix4.getTranslation(world, new Cesium.Cartesian3())
+                    : new Cesium.Cartesian3(0, 0, 0);
+                const ground = this.groundOffsets.get(entityId);
+                if (ground) {
+                    Cesium.Cartesian3.add(offset, ground, offset);
+                }
+                placed = {
+                    pos3d: Cesium.Matrix4.multiplyByPoint(pose.rootFrame, offset, new Cesium.Cartesian3()),
+                    // Without a matrix, eg. the root itself, there is no orientation of its own to apply.
+                    orient: world ? entity_utils_1.EntityUtils.GetAssemblyOrientationInFrame(pose.rootFrame, world) : null,
+                    scale: world ? Manager.uniformScale(world) : 1
+                };
+                pose.placements.set(entityId, placed);
+            }
+            return placed;
+        }
+        /*
+         * The root's pose at a time, position and attitude each following their own records as a joint's do.
+         */
+        rootAt(timeMs) {
+            const pos3d = this.rootPositionAt(timeMs);
+            if (!pos3d) {
+                return null;
+            }
+            const live = { heading: this.rootHeading, pitch: this.rootPitch, roll: this.rootRoll };
+            const series = this.rootAttitude;
+            if (!series.length || timeMs < series[0].timeMs) {
+                return { pos3d, ...live };
+            }
+            let i = 0;
+            while (i < series.length - 1 && series[i + 1].timeMs <= timeMs) {
+                i++;
+            }
+            const a = series[i];
+            const b = series[i + 1];
+            const t = b ? (timeMs - a.timeMs) / (b.timeMs - a.timeMs) : 0;
+            const turn = (from, to, fallback) => {
+                var _a, _b, _c;
+                const x = (_a = from !== null && from !== void 0 ? from : fallback) !== null && _a !== void 0 ? _a : 0;
+                const y = (_c = (_b = (b ? to : from)) !== null && _b !== void 0 ? _b : fallback) !== null && _c !== void 0 ? _c : 0;
+                // The short way round, so 350 to 10 degrees turns through north rather than all the way back.
+                return x + (Cesium.Math.negativePiToPi(Cesium.Math.toRadians(y - x)) * 180 / Math.PI) * t;
+            };
+            return {
+                pos3d,
+                heading: turn(a.heading, b === null || b === void 0 ? void 0 : b.heading, live.heading),
+                pitch: turn(a.pitch, b === null || b === void 0 ? void 0 : b.pitch, live.pitch),
+                roll: turn(a.roll, b === null || b === void 0 ? void 0 : b.roll, live.roll)
+            };
+        }
+        /*
+         * Where the root is at a time, from its recorded positions.
+         */
+        rootPositionAt(timeMs) {
+            const series = this.rootSeries;
+            if (!series.length || timeMs < series[0].timeMs) {
+                return this.rootPos3d;
+            }
+            let i = 0;
+            while (i < series.length - 1 && series[i + 1].timeMs <= timeMs) {
+                i++;
+            }
+            const a = series[i];
+            const b = series[i + 1];
+            if (!b) {
+                return a.pos3d;
+            }
+            const t = (timeMs - a.timeMs) / (b.timeMs - a.timeMs);
+            // A straight line between orbit samples cuts up to a kilometre inside the path, so it is lifted back out.
+            const chord = Cesium.Cartesian3.lerp(a.pos3d, b.pos3d, t, new Cesium.Cartesian3());
+            const carto = Cesium.Cartographic.fromCartesian(chord);
+            return carto
+                ? Cesium.Cartesian3.fromRadians(carto.longitude, carto.latitude, Cesium.Math.lerp(a.height, b.height, t))
+                : chord;
+        }
+        /*
+         * Takes the root's records into its series.
+         * @param replace the records are everything held for the root, so the series becomes exactly them.
+         * @returns whether the series changed.
+         */
+        absorbRootRecords(posses, replace) {
+            if (!(posses === null || posses === void 0 ? void 0 : posses.length) && !(replace && this.rootSeries.length)) {
+                return false;
+            }
+            const byTime = new Map(replace ? [] : this.rootSeries.map(k => [k.timeMs, k]));
+            for (const pos of posses) {
+                const carto = Cesium.Cartographic.fromCartesian(pos.pos3d);
+                if (!carto) {
                     continue;
                 }
-                child.cEntity.position = new Cesium.ConstantPositionProperty(pos3d);
-                const orient = entity_utils_1.EntityUtils.GetAssemblyOrientation(child.entity, pos3d);
-                if (orient) {
-                    child.cEntity.orientation = new Cesium.ConstantProperty(orient);
+                byTime.set(pos.dateTime.getTime(), {
+                    timeMs: pos.dateTime.getTime(),
+                    pos3d: pos.pos3d,
+                    height: carto.height
+                });
+            }
+            const series = Array.from(byTime.values()).sort((x, y) => x.timeMs - y.timeMs);
+            const changed = (series.length !== this.rootSeries.length ||
+                series.some((k, i) => !Cesium.Cartesian3.equals(k.pos3d, this.rootSeries[i].pos3d)));
+            this.rootSeries = series;
+            return changed;
+        }
+        /*
+         * Takes the angles the root's records name into its attitude series, apart from where it is.
+         * @param replace the records are everything held for the root, as for absorbRootRecords.
+         * @returns whether the series changed.
+         */
+        absorbRootAttitude(records, replace) {
+            const angle = (transform, key) => {
+                var _a;
+                const value = (_a = transform === null || transform === void 0 ? void 0 : transform[key]) !== null && _a !== void 0 ? _a : transform === null || transform === void 0 ? void 0 : transform[key[0].toUpperCase() + key.slice(1)];
+                return value == null || isNaN(+value) ? null : +value;
+            };
+            const byTime = new Map(replace ? [] : this.rootAttitude.map(k => [k.timeMs, k]));
+            for (const record of records || []) {
+                const timeMs = (record === null || record === void 0 ? void 0 : record.dateTime) ? new Date(record.dateTime).getTime() : NaN;
+                const key = {
+                    timeMs,
+                    heading: angle(record === null || record === void 0 ? void 0 : record.transform, "heading"),
+                    pitch: angle(record === null || record === void 0 ? void 0 : record.transform, "pitch"),
+                    roll: angle(record === null || record === void 0 ? void 0 : record.transform, "roll")
+                };
+                if (isNaN(timeMs) || (key.heading == null && key.pitch == null && key.roll == null)) {
+                    continue;
                 }
+                byTime.set(timeMs, key);
             }
-            this.viewer.scene.requestRender();
+            const series = Array.from(byTime.values()).sort((x, y) => x.timeMs - y.timeMs);
+            const held = this.rootAttitude;
+            const differs = (k, i) => (k.timeMs !== held[i].timeMs ||
+                k.heading !== held[i].heading ||
+                k.pitch !== held[i].pitch ||
+                k.roll !== held[i].roll);
+            const changed = series.length !== held.length || series.some(differs);
+            this.rootAttitude = series;
+            return changed;
+        }
+        /*
+         * A node's matrix in the root's frame at a time, from each ancestor's pose within its parent.
+         */
+        composeWorld(entityId, timeMs, memo, localOf = (id) => this.localAt(id, timeMs)) {
+            var _a, _b, _c, _d;
+            if (memo === null || memo === void 0 ? void 0 : memo.has(entityId)) {
+                return memo.get(entityId);
+            }
+            let world = null;
+            const local = localOf(entityId);
+            if (local) {
+                const parentId = (_b = (_a = this.hierarchyNodeByEntityId) === null || _a === void 0 ? void 0 : _a[entityId]) === null || _b === void 0 ? void 0 : _b.parentId;
+                const parent = parentId ? this.composeWorld(parentId, timeMs, memo, localOf) : null;
+                world = parent ? Cesium.Matrix4.multiply(parent, local, new Cesium.Matrix4()) : Cesium.Matrix4.clone(local);
+            }
+            else if (entityId !== this.rootId) {
+                // A node whose own position was not fetched falls back to the API's composed matrix.
+                const child = this.children.get(entityId);
+                world = Manager.MatrixFromRows((_d = (_c = child === null || child === void 0 ? void 0 : child.entity) === null || _c === void 0 ? void 0 : _c.Bruce) === null || _d === void 0 ? void 0 : _d.AssemblyWorldPosition);
+            }
+            memo === null || memo === void 0 ? void 0 : memo.set(entityId, world);
+            return world;
+        }
+        /*
+         * Under a clamped or relative style, lifts a part by how much higher its ground is than the root's.
+         */
+        measureGroundOffset(entity) {
+            var _a;
+            const entityId = (_a = entity === null || entity === void 0 ? void 0 : entity.Bruce) === null || _a === void 0 ? void 0 : _a.ID;
+            this.groundOffsets.delete(entityId);
+            const root = this.apiEntities.get(this.rootId);
+            if (!entityId ||
+                entityId === this.rootId ||
+                !root ||
+                !this.rootPos3d ||
+                Manager.GetRecordHeightRef(this.item) === Cesium.HeightReference.NONE) {
+                return;
+            }
+            const rootFrame = Manager.rootFrame(this.rootPos3d, this.rootHeading, this.rootPitch, this.rootRoll);
+            const toRoot = Cesium.Matrix4.inverse(rootFrame, new Cesium.Matrix4());
+            const groundUp = (record) => {
+                const pos3d = entity_utils_1.EntityUtils.GetPos({
+                    viewer: this.viewer,
+                    entity: record,
+                    recordHeightRef: Cesium.HeightReference.CLAMP_TO_GROUND,
+                    returnHeightRef: Cesium.HeightReference.NONE,
+                    allowRendered: false
+                });
+                return pos3d ? Cesium.Matrix4.multiplyByPoint(toRoot, pos3d, new Cesium.Cartesian3()).z : null;
+            };
+            const part = groundUp(entity);
+            const under = groundUp(root);
+            if (part == null || under == null || Math.abs(part - under) < 1e-6) {
+                return;
+            }
+            this.groundOffsets.set(entityId, new Cesium.Cartesian3(0, 0, part - under));
+        }
+        /*
+         * The rigid Earth-fixed motion from where a part's record places it to where it is drawn at a time.
+         */
+        motionAt(entityId, time) {
+            if (this.disposed || !time || !this.rootPos3d) {
+                return null;
+            }
+            const timeMs = Cesium.JulianDate.toDate(time).getTime();
+            const root = this.rootAt(timeMs);
+            const drawn = this.composeWorld(entityId, timeMs, new Map());
+            const stored = this.composeWorld(entityId, timeMs, new Map(), (id) => {
+                var _a, _b, _c, _d;
+                return ((_d = (_c = Manager.MatrixFromRows((_b = (_a = this.apiEntities.get(id)) === null || _a === void 0 ? void 0 : _a.Bruce) === null || _b === void 0 ? void 0 : _b.AssemblyPosition)) !== null && _c !== void 0 ? _c : this.localPositions.get(id)) !== null && _d !== void 0 ? _d : null);
+            });
+            if (!root || !drawn || !stored) {
+                return null;
+            }
+            const drawnFixed = Cesium.Matrix4.multiply(Manager.rootFrame(root.pos3d, root.heading, root.pitch, root.roll), drawn, new Cesium.Matrix4());
+            const storedFixed = Cesium.Matrix4.multiply(Manager.rootFrame(this.rootPos3d, this.rootHeading, this.rootPitch, this.rootRoll), stored, new Cesium.Matrix4());
+            return Cesium.Matrix4.multiply(drawnFixed, Cesium.Matrix4.inverse(storedFixed, new Cesium.Matrix4()), new Cesium.Matrix4());
+        }
+        /*
+         * A node's pose within its parent at a time, interpolated between the records either side.
+         */
+        localAt(entityId, timeMs) {
+            var _a;
+            // The live pose stands before the first record and the last record holds after it, as in an API read.
+            const live = (_a = this.localPositions.get(entityId)) !== null && _a !== void 0 ? _a : null;
+            const series = this.jointSeries.get(entityId);
+            if (!(series === null || series === void 0 ? void 0 : series.length) || timeMs == null || timeMs < series[0].timeMs) {
+                return live;
+            }
+            let i = 0;
+            while (i < series.length - 1 && series[i + 1].timeMs <= timeMs) {
+                i++;
+            }
+            const a = series[i];
+            const b = series[i + 1];
+            if (!b) {
+                return Cesium.Matrix4.fromTranslationQuaternionRotationScale(a.translation, a.rotation, a.scale);
+            }
+            const t = (timeMs - a.timeMs) / (b.timeMs - a.timeMs);
+            return Cesium.Matrix4.fromTranslationQuaternionRotationScale(Cesium.Cartesian3.lerp(a.translation, b.translation, t, new Cesium.Cartesian3()), Cesium.Quaternion.slerp(a.rotation, b.rotation, t, new Cesium.Quaternion()), Cesium.Cartesian3.lerp(a.scale, b.scale, t, new Cesium.Cartesian3()));
+        }
+        /*
+         * Rebuilds each node's keyframes from the historic records held so far.
+         * @returns whether any node has keyframes.
+         */
+        absorbJointRecords(recordsByIds) {
+            var _a;
+            // Everything held is given, so a node with nothing left, eg. its simulated records cleared, stops moving.
+            for (const entityId of Array.from(this.jointSeries.keys())) {
+                if (!((_a = recordsByIds === null || recordsByIds === void 0 ? void 0 : recordsByIds[entityId]) === null || _a === void 0 ? void 0 : _a.length)) {
+                    this.jointSeries.delete(entityId);
+                }
+            }
+            for (const entityId of Object.keys(recordsByIds || {})) {
+                const keyframes = [];
+                for (const record of recordsByIds[entityId] || []) {
+                    const matrix = Manager.MatrixFromRows(record.assemblyPosition);
+                    const timeMs = new Date(record.dateTime).getTime();
+                    if (!matrix || isNaN(timeMs)) {
+                        continue;
+                    }
+                    const scale = Cesium.Matrix4.getScale(matrix, new Cesium.Cartesian3());
+                    const rotation = Cesium.Matrix4.getRotation(matrix, new Cesium.Matrix3());
+                    keyframes.push({
+                        timeMs,
+                        translation: Cesium.Matrix4.getTranslation(matrix, new Cesium.Cartesian3()),
+                        rotation: Cesium.Quaternion.fromRotationMatrix(rotation),
+                        scale
+                    });
+                }
+                if (keyframes.length) {
+                    keyframes.sort((x, y) => x.timeMs - y.timeMs);
+                    this.jointSeries.set(entityId, keyframes);
+                }
+            }
+            this.refreshAnimated();
+            return this.jointSeries.size > 0;
+        }
+        /*
+         * Rebuilds which drawn children can move with the clock, by walking each one up to the root.
+         */
+        refreshAnimated() {
+            this.animatedIds.clear();
+            if (!this.jointSeries.size) {
+                return;
+            }
+            for (const entityId of this.children.keys()) {
+                if (this.hasAnimatedAncestry(entityId)) {
+                    this.animatedIds.add(entityId);
+                }
+            }
+        }
+        /*
+         * Whether a node or anything above it has keyframes, so the clock can move it.
+         */
+        hasAnimatedAncestry(entityId) {
+            var _a, _b;
+            let at = entityId;
+            while (at && this.jointSeries.size) {
+                if (this.jointSeries.has(at)) {
+                    return true;
+                }
+                at = (_b = (_a = this.hierarchyNodeByEntityId) === null || _a === void 0 ? void 0 : _a[at]) === null || _b === void 0 ? void 0 : _b.parentId;
+            }
+            return false;
+        }
+        /*
+         * Which nodes to ask history for.
+         */
+        async historicEntityIds(api) {
+            var _a, _b;
+            // Through the Assembly when there is one, so the hierarchy follows the relation type on its record.
+            const assemblyId = this.item["Assembly.ID"];
+            const root = assemblyId ? { key: "root", AssemblyID: assemblyId } : { key: "root", RootID: this.rootId };
+            const historic = {
+                key: "historic",
+                Historic: { HistoricKey: ((_a = this.item.BruceEntity) === null || _a === void 0 ? void 0 : _a.historicAttrKey) || undefined }
+            };
+            const query = {
+                [bruce_models_1.DataLab.EReqKey.Primary]: { Items: [root, historic], Select: { Type: bruce_models_1.DataLab.ESelectType.Id } }
+            };
+            const load = 1000;
+            try {
+                const ids = [];
+                for (let skip = 0;; skip += load) {
+                    const { items } = await bruce_models_1.DataLab.Run({ api, query, skip, load });
+                    ids.push(...(items !== null && items !== void 0 ? items : []));
+                    if (!items || items.length < load) {
+                        return ids;
+                    }
+                }
+            }
+            catch (e) {
+                // An API without the historic criterion gets asked about every node, as before it existed.
+                console.warn("AssemblyRenderManager.historicEntityIds()", e);
+            }
+            return Object.keys((_b = this.hierarchyNodeByEntityId) !== null && _b !== void 0 ? _b : { [this.rootId]: null });
+        }
+        /**
+         * Builds a matrix from the row-major rows that Bruce/AssemblyPosition and AssemblyWorldPosition use.
+         * @param rows
+         */
+        static MatrixFromRows(rows) {
+            if (!Array.isArray(rows) || rows.length !== 4 || rows.some(r => !Array.isArray(r) || r.length !== 4)) {
+                return null;
+            }
+            return new Cesium.Matrix4(+rows[0][0], +rows[0][1], +rows[0][2], +rows[0][3], +rows[1][0], +rows[1][1], +rows[1][2], +rows[1][3], +rows[2][0], +rows[2][1], +rows[2][2], +rows[2][3], +rows[3][0], +rows[3][1], +rows[3][2], +rows[3][3]);
+        }
+        /**
+         * The inverse of MatrixFromRows.
+         * @param matrix
+         */
+        static RowsFromMatrix(matrix) {
+            const rows = [];
+            for (let r = 0; r < 4; r++) {
+                const row = Cesium.Matrix4.getRow(matrix, r, new Cesium.Cartesian4());
+                rows.push([row.x, row.y, row.z, row.w]);
+            }
+            return rows;
         }
         Init() {
             this.renderPriority = this.item.renderPriority;
@@ -132,6 +728,7 @@ var AssemblyRenderManager;
                 this.renderPriority = 1;
             }
             (async () => {
+                var _a, _b;
                 if (this.disposed) {
                     return;
                 }
@@ -147,6 +744,8 @@ var AssemblyRenderManager;
                         this.hierarchyUpdate.Trigger(hierarchy);
                         // Build hierarchy node cache for quick lookups
                         this.buildHierarchyNodes(hierarchy);
+                        // A set for membership, since searching the list took minutes at 200k nodes.
+                        const seenIds = new Set();
                         const traverseHierarchy = (node, leavesOnly) => {
                             var _a;
                             if (node.Children) {
@@ -155,7 +754,8 @@ var AssemblyRenderManager;
                                 }
                             }
                             const addNode = !leavesOnly || !((_a = node.Children) === null || _a === void 0 ? void 0 : _a.length);
-                            if (addNode && node.ID && !flatEntityIds.includes(node.ID)) {
+                            if (addNode && node.ID && !seenIds.has(node.ID)) {
+                                seenIds.add(node.ID);
                                 flatEntityIds.push(node.ID);
                             }
                         };
@@ -174,17 +774,17 @@ var AssemblyRenderManager;
                         }
                     }
                     this.rootId = rootId;
+                    this.simulationRemoval = (_b = (_a = this.simulation) === null || _a === void 0 ? void 0 : _a.OnChanged.Subscribe((change) => this.onSimulationChanged(change))) !== null && _b !== void 0 ? _b : null;
                     if (this.disposed) {
                         return;
                     }
                     else if (flatEntityIds.length === 0) {
                         return;
                     }
+                    // Followed while the parts load: in a large Assembly loading takes far longer than anyone waits.
+                    const following = this.viewerDateTimeSub();
                     await this.processEntityIds(flatEntityIds);
-                    if (this.disposed) {
-                        return;
-                    }
-                    this.viewerDateTimeSub();
+                    await following;
                 }
                 catch (e) {
                     console.error("AssemblyRenderManager.Manager.Init()", e);
@@ -216,7 +816,7 @@ var AssemblyRenderManager;
                 if (!batch.length) {
                     continue;
                 }
-                const { entities: fetched } = await bruce_models_1.Entity.GetListByIds({
+                const { entities: apiEntities } = await bruce_models_1.Entity.GetListByIds({
                     entityIds: batch,
                     api: this.getters.GetBruceApi(),
                     expandLODs: true,
@@ -228,6 +828,16 @@ var AssemblyRenderManager;
                 if (this.disposed) {
                     return;
                 }
+                const fetched = apiEntities.map((entity) => {
+                    var _a;
+                    this.apiEntities.set((_a = entity.Bruce) === null || _a === void 0 ? void 0 : _a.ID, entity);
+                    return this.withSimulation(entity);
+                });
+                for (const entity of fetched) {
+                    this.absorbNode(entity);
+                }
+                // Placements already worked out did not know about this batch's positions.
+                this.pose = null;
                 for (const entity of fetched) {
                     // Filter for valid LODs then take the highest quality one (lowest level).
                     let lods = entity.Bruce.LOD || [];
@@ -250,57 +860,46 @@ var AssemblyRenderManager;
                         // Won't bother with vector data for this experiment.
                         continue;
                     }
-                    const recordHeightRef = Manager.GetRecordHeightRef(this.item);
-                    const recordPos3d = entity_utils_1.EntityUtils.GetPos({
-                        viewer: this.viewer,
-                        entity,
-                        recordHeightRef: recordHeightRef,
-                        returnHeightRef: Cesium.HeightReference.NONE,
-                        allowRendered: false
-                    });
-                    if (!recordPos3d) {
-                        continue;
-                    }
                     const entityId = entity.Bruce.ID;
-                    if (entityId === this.rootId || !this.rootPos3d) {
-                        // Nothing has a frame to be relative to until the root has one.
-                        this.rootPos3d = recordPos3d;
-                        this.rootHeading = (0, js_utils_1.EnsureNumber)((_a = entity.Bruce.Transform) === null || _a === void 0 ? void 0 : _a.heading, 0);
+                    this.measureGroundOffset(entity);
+                    // A placement cached before the offset was known would leave the part off its ground.
+                    (_a = this.pose) === null || _a === void 0 ? void 0 : _a.placements.delete(entityId);
+                    if (!this.canMove(entityId) && !this.placementAt(entityId, this.viewer.clock.currentTime)) {
+                        continue;
                     }
-                    // Held as an offset in the root's frame, so a root move places it again without
-                    // anything being fetched. Where the root already moved, that is where it goes.
-                    const offset = Manager.ChildOffsetIn(this.rootPos3d, this.rootHeading, recordPos3d);
-                    const pos3d = Manager.ChildPositionFrom(this.rootPos3d, this.rootHeading, offset);
-                    // Optional: a child with no world matrix is still worth drawing, it just has no
-                    // orientation of its own to apply.
-                    const orient = entity_utils_1.EntityUtils.GetAssemblyOrientation(entity, pos3d);
                     const cEntity = this.viewer.entities.add({
                         model: {
                             uri: lod["ClientFile"].URL,
                             ...view_utils_1.ViewUtils.DefaultLightingProps(),
                             heightReference: Cesium.HeightReference.NONE
-                        },
-                        position: pos3d,
-                        orientation: orient ? new Cesium.ConstantProperty(orient) : undefined
+                        }
                     });
                     const prior = this.children.get(entityId);
                     if (prior && prior.cEntity !== cEntity) {
                         (0, cesium_utils_1.RemoveCEntityFromScene)(this.viewer, prior.cEntity);
                     }
-                    this.children.set(entityId, {
+                    const child = {
                         entityId: entityId,
                         entity: entity,
-                        cEntity: cEntity,
-                        offset: offset
-                    });
+                        cEntity: cEntity
+                    };
+                    this.children.set(entityId, child);
+                    // Joins the animated set by its own ancestry, so a late part never re-walks the rest.
+                    if (this.hasAnimatedAncestry(entityId)) {
+                        this.animatedIds.add(entityId);
+                    }
                     const geometryRadius = bruce_models_1.Entity.GetValue({
                         entity: entity,
                         path: ["Bruce", "GeometryRadius"]
                     });
                     cEntity.model["_radius"] = geometryRadius;
                     cEntity.model["_radiusLoaded"] = true;
+                    // Placed before it is registered, so the register never measures a visual with no position.
+                    this.bindPlacement(child);
                     this.visualsManager.AddRego({
                         rego: {
+                            moving: child.moving ? true : null,
+                            motion: (time) => this.motionAt(entity.Bruce.ID, time),
                             canEdit: true,
                             entityId: entity.Bruce.ID,
                             menuItemId: this.item.id,
@@ -320,47 +919,89 @@ var AssemblyRenderManager;
             }
         }
         /*
-         * Follows the scene clock and moves the whole Assembly along the root Entity's historic path.
-         * Only the root is fetched: everything under it is placed through ApplyRootPosition.
+         * Follows the scene clock, moving the Assembly along the root's history and each joint along its own.
          */
-        viewerDateTimeSub() {
-            if (!Manager.IsHistoric(this.item) || this.viewerDateTimeChangeRemoval || !this.rootId) {
+        async viewerDateTimeSub() {
+            var _a;
+            const historic = Manager.IsHistoric(this.item);
+            if (this.followingClock || !this.rootId || (!historic && !this.simulatedNodeIds().length)) {
                 return;
             }
+            this.followingClock = true;
             const api = this.getters.GetBruceApi();
-            const rootEntity = { Bruce: { ID: this.rootId } };
+            const historicIds = historic ? await this.historicEntityIds(api) : [];
+            if (this.disposed) {
+                return;
+            }
+            const attrKey = (_a = this.item.BruceEntity) === null || _a === void 0 ? void 0 : _a.historicAttrKey;
             const recordHeightRef = Manager.GetRecordHeightRef(this.item);
             const toPosses = (records) => {
                 return cesium_animated_property_1.CesiumAnimatedProperty.GetSeriesPossesForHistoricEntity(this.viewer, recordHeightRef, Cesium.HeightReference.NONE, records);
             };
-            this.historicGatherer = new historic_utils_1.HistoricGatherer({
-                viewer: this.viewer,
-                getApi: () => api,
-                getAttrKey: () => { var _a; return (_a = this.item.BruceEntity) === null || _a === void 0 ? void 0 : _a.historicAttrKey; },
-                // For clock desync between whatever wrote the record and this client.
-                paddingMs: 15000,
-                onRecords: (recordsByIds) => {
-                    const records = recordsByIds[this.rootId];
-                    if ((records === null || records === void 0 ? void 0 : records.length) && this.historicAnimation) {
-                        this.historicAnimation.SupplementSeries(toPosses(records));
+            if (historicIds.length) {
+                this.historicGatherer = new historic_utils_1.HistoricGatherer({
+                    viewer: this.viewer,
+                    getApi: () => api,
+                    getAttrKey: () => attrKey,
+                    // For clock desync between whatever wrote the record and this client.
+                    paddingMs: 15000,
+                    simulation: this.simulation,
+                    onRecords: (recordsByIds) => {
+                        var _a;
+                        const records = recordsByIds[this.rootId];
+                        if (records === null || records === void 0 ? void 0 : records.length) {
+                            const posses = toPosses(records);
+                            (_a = this.historicAnimation) === null || _a === void 0 ? void 0 : _a.SupplementSeries(posses);
+                            const moved = this.absorbRootRecords(posses, false);
+                            if (this.absorbRootAttitude(records, false) || moved) {
+                                this.repose();
+                            }
+                        }
+                        // Joint records go in together once the gather lands, so parents never draw apart from children.
                     }
-                }
-            });
+                });
+            }
+            // The nodes with history: what the API has records for, and whatever has been simulated since.
+            const nodes = () => Array.from(new Set([...historicIds, ...this.simulatedNodeIds()]));
             let gathering = false;
-            const gather = async () => {
+            // Set when what is held changed without a fetch, eg. a simulated record arriving.
+            let stale = true;
+            const gather = async (force) => {
+                var _a, _b;
+                stale = stale || Boolean(force);
                 if (this.disposed || gathering) {
                     return;
                 }
                 gathering = true;
                 try {
-                    const { recordsByIds } = await this.historicGatherer.Gather([rootEntity]);
+                    const ids = nodes();
+                    let fetched = false;
+                    let recordsByIds;
+                    if (this.historicGatherer) {
+                        ({ fetched, recordsByIds } = await this.historicGatherer.Gather(ids.map(id => ({ Bruce: { ID: id } }))));
+                    }
+                    else {
+                        recordsByIds = (_b = (_a = this.simulation) === null || _a === void 0 ? void 0 : _a.MergeRecords({}, attrKey, ids)) !== null && _b !== void 0 ? _b : {};
+                    }
                     if (this.disposed) {
                         return;
                     }
+                    // A gather served from what is held changes nothing and runs every tick, so it stops here.
+                    if (!fetched && !stale && this.jointSeries.size) {
+                        return;
+                    }
+                    stale = false;
+                    let changed = this.absorbJointRecords(recordsByIds);
                     const posses = toPosses(recordsByIds[this.rootId] || []);
+                    changed = this.absorbRootRecords(posses, true) || changed;
+                    changed = this.absorbRootAttitude(recordsByIds[this.rootId] || [], true) || changed;
+                    if (changed) {
+                        this.repose();
+                    }
                     if (!posses.length) {
                         return;
                     }
+                    // Held for the trail alone; where the root is drawn comes from rootAt(), never from its smoothing.
                     if (!this.historicAnimation) {
                         this.historicAnimation = new cesium_animated_property_1.CesiumAnimatedProperty.AnimatePositionSeries({
                             posses: posses,
@@ -374,15 +1015,21 @@ var AssemblyRenderManager;
                 }
                 catch (e) {
                     console.error("AssemblyRenderManager.viewerDateTimeSub()", e);
+                    // A gather that throws would throw again straight away, so the retry waits for the next tick.
+                    stale = false;
                 }
                 finally {
                     gathering = false;
+                    // A change that landed mid-gather is not left for a tick that may never come on a paused clock.
+                    if (stale && !this.disposed) {
+                        gather();
+                    }
                 }
             };
+            this.regather = gather;
             gather();
             let lastTime = null;
             const tickRemoval = this.viewer.clock.onTick.addEventListener(() => {
-                var _a;
                 if (this.disposed) {
                     return;
                 }
@@ -392,15 +1039,9 @@ var AssemblyRenderManager;
                 }
                 lastTime = now;
                 gather();
-                if (!this.historicAnimation) {
-                    return;
-                }
-                const pos3d = this.historicAnimation.GetValue();
-                if (pos3d) {
-                    this.ApplyRootPosition({
-                        pos3d: pos3d,
-                        heading: (_a = this.historicAnimation.GetHeadingDegrees()) !== null && _a !== void 0 ? _a : this.rootHeading
-                    });
+                // Moving parts read the clock themselves when drawn, so the scene only needs a new frame.
+                if (this.rootSeries.length || this.rootAttitude.length || this.animatedIds.size) {
+                    this.viewer.scene.requestRender();
                 }
             });
             this.viewerDateTimeChangeRemoval = () => {
@@ -409,6 +1050,10 @@ var AssemblyRenderManager;
                 (_a = this.historicGatherer) === null || _a === void 0 ? void 0 : _a.Dispose();
                 this.historicGatherer = null;
                 this.historicAnimation = null;
+                this.regather = null;
+                this.rootSeries = [];
+                this.rootAttitude = [];
+                this.pose = null;
             };
         }
         /*
@@ -416,7 +1061,7 @@ var AssemblyRenderManager;
          */
         applyRootTrack() {
             var _a;
-            if (!this.item.historicDrawTrack || !this.historicAnimation || this.trackEntity) {
+            if (!this.item.historicDrawTrack || !this.historicAnimation || this.trail) {
                 return;
             }
             const trackStyle = entity_render_engine_1.EntityRenderEngine.GetTrackStyle({
@@ -426,41 +1071,35 @@ var AssemblyRenderManager;
             if (!trackStyle) {
                 return;
             }
-            this.trackEntity = this.viewer.entities.add({
-                id: bruce_models_1.ObjectUtils.UId(15),
-                polyline: {
-                    positions: new Cesium.CallbackProperty(() => { var _a, _b; return (_b = (_a = this.historicAnimation) === null || _a === void 0 ? void 0 : _a.GetSeries()) !== null && _b !== void 0 ? _b : []; }, false),
-                    width: trackStyle.width,
-                    material: trackStyle.color,
-                    clampToGround: entity_render_engine_1.EntityRenderEngine.GetHeightRefPolyline(Manager.GetRecordHeightRef(this.item))
-                        == Cesium.HeightReference.CLAMP_TO_GROUND,
-                    zIndex: 0,
-                    classificationType: Cesium.ClassificationType.BOTH
-                }
-            });
-            this.trackEntity._noEdit = true;
-            this.trackEntity._noSelect = true;
-            cesium_entity_styler_1.CesiumEntityStyler.SetDefaultColor({
-                color: trackStyle.color,
-                entity: this.trackEntity,
+            this.trail = new historic_trail_1.HistoricTrail.Trail({
                 viewer: this.viewer,
-                override: true,
-                requestRender: false
+                color: trackStyle.color,
+                width: trackStyle.width,
+                clampToGround: entity_render_engine_1.EntityRenderEngine.GetHeightRefPolyline(Manager.GetRecordHeightRef(this.item))
+                    == Cesium.HeightReference.CLAMP_TO_GROUND,
+                getSeries: () => { var _a, _b; return (_b = (_a = this.historicAnimation) === null || _a === void 0 ? void 0 : _a.GetSeries()) !== null && _b !== void 0 ? _b : []; },
+                trailSeconds: historic_trail_1.HistoricTrail.GetTrailSeconds(this.item),
+                // Where the root is drawn, so the trail ends on the model; nothing before the first record held.
+                positionAt: (timeMs) => (this.rootSeries.length && timeMs >= this.rootSeries[0].timeMs ? this.rootPositionAt(timeMs) : null)
             });
         }
         Dispose() {
-            var _a;
+            var _a, _b, _c;
             if (this.disposed) {
                 return;
             }
             this.disposed = true;
             (_a = this.viewerDateTimeChangeRemoval) === null || _a === void 0 ? void 0 : _a.call(this);
             this.viewerDateTimeChangeRemoval = null;
-            if (this.trackEntity) {
-                (0, cesium_utils_1.RemoveCEntityFromScene)(this.viewer, this.trackEntity);
-                this.trackEntity = null;
-            }
+            (_b = this.simulationRemoval) === null || _b === void 0 ? void 0 : _b.call(this);
+            this.simulationRemoval = null;
+            this.apiEntities.clear();
+            (_c = this.trail) === null || _c === void 0 ? void 0 : _c.Dispose();
+            this.trail = null;
             this.children.clear();
+            this.localPositions.clear();
+            this.jointSeries.clear();
+            this.animatedIds.clear();
             this.visualsManager.RemoveRegos({
                 menuItemId: this.item.id
             });