bruce-cesium 5.9.5 → 5.9.7

package/dist/bruce-cesium.es5.js

@@ -1,6 +1,6 @@
-import { BruceEvent, Cartes, Entity as Entity$1, ProjectViewTile, Carto, Geometry, MathUtils, LRUCache, Api, Calculator, ClientFile, EntityTag, EntityType, ObjectUtils, Style, DelayQueue, EntityLod, Bounds, ZoomControl, EntityRelationType, ENVIRONMENT, EntityHistoricData, Tileset, EntityCoords, DataLab, EntitySource, MenuItem, EntityRelation, ProgramKey, ProjectView, ProjectViewBookmark, ProjectViewLegacyTile, Camera, EntityAttachment, EntityAttachmentType, EntityAttribute, Session, AbstractApi } from 'bruce-models';
+import { BruceEvent, Cartes, Entity as Entity$1, ProjectViewTile, Carto, Geometry, MathUtils, LRUCache, Api, Calculator, ClientFile, EntityTag, EntityType, ObjectUtils, Style, DelayQueue, EntityLod, Bounds, ZoomControl, EntityRelationType, ENVIRONMENT, EntityHistoricData, Tileset, EntityCoords, DataLab, EntitySource, MenuItem, EntityRelation, ProgramKey, ProjectView, ProjectViewBookmark, Camera, ProjectViewLegacyTile, EntityAttachment, EntityAttachmentType, EntityAttribute, AbstractApi, Session } from 'bruce-models';
 import * as Cesium from 'cesium';
-import { Cartographic, Cartesian2, Math as Math$1, Cartesian3, CallbackProperty, Color, HeightReference, Rectangle, JulianDate, Entity, DistanceDisplayCondition, ClassificationType, ArcType, CornerType, ShadowMode, ConstantProperty, ConstantPositionProperty, PolygonHierarchy, PolylineGraphics, ColorMaterialProperty, HorizontalOrigin, VerticalOrigin, ColorBlendMode, HeadingPitchRoll, Transforms, Model, SceneMode, Primitive, Cesium3DTileFeature, GeoJsonDataSource, Cesium3DTileStyle, HeadingPitchRange, Cesium3DTileColorBlendMode, Ion, KmlDataSource, SceneTransforms, Quaternion, Matrix3, Matrix4, Cesium3DTileset, IonResource, EllipsoidTerrainProvider, CesiumInspector, OrthographicFrustum, defined, ClockRange, PolygonPipeline, EllipsoidGeodesic, sampleTerrainMostDetailed, IonImageryProvider, createWorldImagery, createWorldImageryAsync, BingMapsImageryProvider, BingMapsStyle, MapboxImageryProvider, MapboxStyleImageryProvider, ArcGisMapServerImageryProvider, OpenStreetMapImageryProvider, UrlTemplateImageryProvider, GridImageryProvider, GeographicTilingScheme, ImageryLayer, TileMapServiceImageryProvider, CesiumTerrainProvider, EasingFunction, NearFarScalar, ModelGraphics, PolygonGraphics, CorridorGraphics, PointGraphics, BillboardGraphics, EllipseGraphics, PolylineDashMaterialProperty, ScreenSpaceEventHandler, ScreenSpaceEventType, BoundingSphere, GeometryInstance, CzmlDataSource, Intersect, Fullscreen } from 'cesium';
+import { Cartographic, Cartesian2, Math as Math$1, Cartesian3, CallbackProperty, Color, HeightReference, Rectangle, JulianDate, Entity, DistanceDisplayCondition, ClassificationType, ArcType, CornerType, ShadowMode, ConstantProperty, ConstantPositionProperty, HorizontalOrigin, VerticalOrigin, ColorBlendMode, HeadingPitchRoll, Transforms, Model, PolygonHierarchy, PolylineGraphics, ColorMaterialProperty, Primitive, Cesium3DTileFeature, SceneMode, GeoJsonDataSource, Cesium3DTileStyle, HeadingPitchRange, Cesium3DTileColorBlendMode, Ion, KmlDataSource, Quaternion, Matrix3, Matrix4, OrthographicFrustum, EasingFunction, NearFarScalar, SceneTransforms, Cesium3DTileset, IonResource, EllipsoidTerrainProvider, CesiumInspector, defined, ClockRange, EllipsoidGeodesic, sampleTerrainMostDetailed, PolygonPipeline, IonImageryProvider, createWorldImagery, createWorldImageryAsync, BingMapsImageryProvider, BingMapsStyle, MapboxImageryProvider, MapboxStyleImageryProvider, ArcGisMapServerImageryProvider, OpenStreetMapImageryProvider, UrlTemplateImageryProvider, GridImageryProvider, GeographicTilingScheme, ImageryLayer, TileMapServiceImageryProvider, CesiumTerrainProvider, ModelGraphics, PolygonGraphics, CorridorGraphics, PointGraphics, BillboardGraphics, EllipseGraphics, PolylineDashMaterialProperty, ScreenSpaceEventHandler, ScreenSpaceEventType, BoundingSphere, GeometryInstance, CzmlDataSource, Intersect, Fullscreen } from 'cesium';
 
 const TIME_LAG = 300;
 const POSITION_CHECK_TIMER = 950;
@@ -1144,48 +1144,70 @@ var CesiumAnimatedProperty;
      */
     class AnimatePositionSeries {
         constructor(params) {
-            // Current position state.
-            this.lastCalcPos3d = null;
-            this.lastCalcPosIndexLast = -1;
-            this.lastCalcPosIndexNext = -1;
-            // Series data for rendering path.
+            // Animation state.
+            this.currentAnimatedPos = null;
+            this.actualTargetPos = null;
+            this.animationStartPos = null;
+            this.animationStartTime = null;
+            this.animationDuration = 350;
+            // Cached data for performance.
+            this.lastDesiredPosIndex = -1;
+            this.lastDesiredNextIndex = -1;
+            // Series data for rendering path
             this.lastCalcSeriesPos3d = [];
             this.lastCalcSeriesTime = null;
-            // Orientation.
+            // Orientation cache.
             this.lastCalcOrient = null;
             this.lastCalcOrientTime = null;
-            // Starting animation state.
-            this.animateFromPos3d = null;
-            this.animateFromPos3dTimeStart = null;
-            this.animationDuration = 200; // milliseconds
             this.viewer = params.viewer;
             this.positions = params.posses || [];
             this.pitch = params.pitch || 0;
             this.roll = params.roll || 0;
-            // Animation from a starting position.
+            this.processHeadings();
+            this.sortPositions();
+            // Initialize animation from starting position if provided.
             if (params.animateFromPos3d) {
-                this.animateFromPos3d = params.animateFromPos3d;
+                this.animationStartPos = params.animateFromPos3d;
                 const currentTime = Date.now();
                 const providedTime = params.animateFromPos3dTimeStart || 0;
-                // Check if the provided timestamp is stale (animation would have already completed)
-                // If so, use current time to restart the animation.
+                // Check if the provided timestamp is stale.
                 if (!providedTime || (currentTime - providedTime) >= this.animationDuration) {
-                    this.animateFromPos3dTimeStart = currentTime;
+                    this.animationStartTime = currentTime;
                 }
                 else {
-                    this.animateFromPos3dTimeStart = providedTime;
+                    this.animationStartTime = providedTime;
                 }
             }
+        }
+        AddPosition(pos) {
+            if (!pos || !pos.pos3d || !pos.dateTime) {
+                console.warn("Invalid position provided to AnimatePositionSeries.");
+                return;
+            }
+            this.positions.push(pos);
             this.processHeadings();
-            // Order positions by date.
+            this.sortPositions();
+            this.invalidateCache();
+        }
+        UpdatePitchRoll(pitch, roll) {
+            this.pitch = pitch;
+            this.roll = roll;
+            this.invalidateCache();
+        }
+        GetAnimateFromDateTime() {
+            return this.animationStartTime;
+        }
+        GetPositions() {
+            return this.positions;
+        }
+        sortPositions() {
             if (this.positions.length > 0) {
-                this.positions.sort((a, b) => {
-                    return a.dateTime.getTime() - b.dateTime.getTime();
-                });
+                this.positions.sort((a, b) => a.dateTime.getTime() - b.dateTime.getTime());
             }
         }
-        GetAnimateFromDateTime() {
-            return this.animateFromPos3dTimeStart;
+        invalidateCache() {
+            this.lastCalcSeriesTime = null;
+            this.lastCalcOrientTime = null;
         }
         /**
          * Pre-process headings in the series.
@@ -1209,130 +1231,178 @@ var CesiumAnimatedProperty;
                 }
             }
         }
-        GetPositions() {
-            return this.positions;
-        }
         easeInOutQuad(t) {
             return t < 0.5 ? 2 * t * t : 1 - Math.pow(-2 * t + 2, 2) / 2;
         }
         /**
-         * Interpolates between the starting position and target position.
+         * Calculate the desired position based on current time without any animation smoothing.
          */
-        interpolateToTargetPosition(startPos, targetPos, startTimeMs, currentTimeMs) {
-            if (!startPos || !targetPos) {
-                return startPos || targetPos || new Cartesian3();
+        calculateDesiredPosition(timeMs) {
+            // No positions available.
+            if (!this.positions || this.positions.length === 0) {
+                return { position: null, lastIndex: -1, nextIndex: -1 };
             }
-            const elapsedTime = currentTimeMs - startTimeMs;
-            let progress = Math.min(elapsedTime / this.animationDuration, 1.0);
-            // Apply easing for more natural motion.
-            progress = this.easeInOutQuad(progress);
-            try {
-                return Cartesian3.lerp(startPos, targetPos, progress, new Cartesian3());
+            // Only one position..
+            if (this.positions.length === 1) {
+                return {
+                    position: this.positions[0].pos3d || null,
+                    lastIndex: 0,
+                    nextIndex: 0
+                };
             }
-            catch (e) {
-                console.error("Error in position interpolation: ", e);
-                return targetPos;
+            // Before first position - use first two positions for orientation.
+            if (timeMs <= this.positions[0].dateTime.getTime()) {
+                return {
+                    position: this.positions[0].pos3d || null,
+                    lastIndex: 0,
+                    nextIndex: Math.min(1, this.positions.length - 1)
+                };
             }
+            // After last position - use last two positions for orientation.
+            const lastIdx = this.positions.length - 1;
+            if (timeMs >= this.positions[lastIdx].dateTime.getTime()) {
+                return {
+                    position: this.positions[lastIdx].pos3d || null,
+                    lastIndex: Math.max(0, lastIdx - 1),
+                    nextIndex: lastIdx
+                };
+            }
+            // Find positions to interpolate between.
+            for (let i = 0; i < this.positions.length - 1; i++) {
+                const current = this.positions[i];
+                const next = this.positions[i + 1];
+                if (timeMs >= current.dateTime.getTime() && timeMs < next.dateTime.getTime()) {
+                    // Exact match on current position - still use current and next for orientation.
+                    if (timeMs === current.dateTime.getTime()) {
+                        return {
+                            position: current.pos3d || null,
+                            lastIndex: i,
+                            nextIndex: i + 1
+                        };
+                    }
+                    // Interpolate between current and next.
+                    if (!current.pos3d || !next.pos3d) {
+                        return {
+                            position: current.pos3d || next.pos3d || null,
+                            lastIndex: i,
+                            nextIndex: i + 1
+                        };
+                    }
+                    try {
+                        const progress = (timeMs - current.dateTime.getTime()) / (next.dateTime.getTime() - current.dateTime.getTime());
+                        const interpolatedPos = Cartesian3.lerp(current.pos3d, next.pos3d, progress, new Cartesian3());
+                        return {
+                            position: interpolatedPos,
+                            lastIndex: i,
+                            nextIndex: i + 1
+                        };
+                    }
+                    catch (e) {
+                        console.error("Error in position interpolation: ", e);
+                        return {
+                            position: current.pos3d,
+                            lastIndex: i,
+                            nextIndex: i + 1
+                        };
+                    }
+                }
+            }
+            // Fallback to last position with previous position for orientation.
+            return {
+                position: this.positions[lastIdx].pos3d || null,
+                lastIndex: Math.max(0, lastIdx - 1),
+                nextIndex: lastIdx
+            };
         }
         /**
-         * Main method to get the current position based on time
+         * Main method to get the current position based on time.
          */
         GetValue() {
-            let now = this.viewer.scene.lastRenderTime;
-            if (!now) {
-                now = this.viewer.clock.currentTime;
+            let viewerTime = this.viewer.scene.lastRenderTime;
+            if (!viewerTime) {
+                viewerTime = this.viewer.clock.currentTime;
             }
-            const nowTimeMs = JulianDate.toDate(now).getTime();
+            const viewerTimeMs = JulianDate.toDate(viewerTime).getTime();
             const currentRealTimeMs = Date.now();
-            // Calculate the ideal position based on time.
-            const idealPosition = this.calculateIdealPosition(nowTimeMs);
-            // First run initialization.
-            if (!this.lastCalcPos3d) {
-                this.lastCalcPos3d = idealPosition;
-                // If we have a starting position, animate from it.
-                if (this.animateFromPos3d) {
-                    return this.interpolateToTargetPosition(this.animateFromPos3d, idealPosition, this.animateFromPos3dTimeStart, currentRealTimeMs);
-                }
-                return idealPosition;
-            }
-            // If we're animating from a start position.
-            if (this.animateFromPos3d) {
-                const elapsedTime = currentRealTimeMs - this.animateFromPos3dTimeStart;
-                // If animation is complete, just return ideal position and clear animation state.
-                if (elapsedTime >= this.animationDuration) {
-                    this.animateFromPos3d = null;
-                    this.lastCalcPos3d = idealPosition;
-                    return idealPosition;
-                }
-                // Otherwise continue interpolation.
-                const interpolatedPos = this.interpolateToTargetPosition(this.animateFromPos3d, idealPosition, this.animateFromPos3dTimeStart, currentRealTimeMs);
-                this.lastCalcPos3d = interpolatedPos;
-                return interpolatedPos;
-            }
-            // If we're not animating, directly use the ideal position.
-            // This ensures we're exactly where we should be based on time.
-            this.lastCalcPos3d = idealPosition;
-            return idealPosition;
-        }
-        /**
-         * Calculate the ideal position based on current time without any smoothing.
-         */
-        calculateIdealPosition(timeMs) {
-            if (!this.positions || this.positions.length === 0) {
+            // Calculate the desired position based on time.
+            const desired = this.calculateDesiredPosition(viewerTimeMs);
+            if (!desired.position) {
+                this.currentAnimatedPos = null;
+                this.actualTargetPos = null;
                 return new Cartesian3();
             }
-            // Before first position.
-            if (timeMs <= this.positions[0].dateTime.getTime()) {
-                this.lastCalcPosIndexLast = 0;
-                this.lastCalcPosIndexNext = 0;
-                return this.positions[0].pos3d || new Cartesian3();
-            }
-            // After last position.
-            if (timeMs >= this.positions[this.positions.length - 1].dateTime.getTime()) {
-                const lastIndex = this.positions.length - 1;
-                this.lastCalcPosIndexLast = lastIndex;
-                this.lastCalcPosIndexNext = lastIndex;
-                return this.positions[lastIndex].pos3d || new Cartesian3();
-            }
-            // Find the position before and after the current time.
-            let lastIndex = 0;
-            for (let i = 0; i < this.positions.length - 1; i++) {
-                if (timeMs >= this.positions[i].dateTime.getTime() &&
-                    timeMs < this.positions[i + 1].dateTime.getTime()) {
-                    lastIndex = i;
-                    break;
-                }
-            }
-            const last = this.positions[lastIndex];
-            this.lastCalcPosIndexLast = lastIndex;
-            // If we're exactly at this position's time.
-            if (timeMs === last.dateTime.getTime()) {
-                this.lastCalcPosIndexNext = lastIndex;
-                return last.pos3d || new Cartesian3();
+            this.lastDesiredPosIndex = desired.lastIndex;
+            this.lastDesiredNextIndex = desired.nextIndex;
+            // Determine the desired position without interpolation.
+            let discreteTarget;
+            if (desired.lastIndex === desired.nextIndex) {
+                discreteTarget = this.positions[desired.lastIndex].pos3d;
             }
-            // Interpolate between surrounding positions.
-            const next = this.positions[lastIndex + 1];
-            if (!next) {
-                this.lastCalcPosIndexNext = lastIndex;
-                return last.pos3d || new Cartesian3();
-            }
-            this.lastCalcPosIndexNext = lastIndex + 1;
-            try {
-                // Ensure both position vectors are valid.
-                if (!last.pos3d || !next.pos3d) {
-                    return last.pos3d || next.pos3d || new Cartesian3();
+            // Use the next position as the target.
+            else {
+                discreteTarget = this.positions[desired.nextIndex].pos3d;
+            }
+            // Check if we have a new actual target
+            const actualTargetChanged = !this.actualTargetPos || !Cartesian3.equals(this.actualTargetPos, discreteTarget);
+            // First time or no previous position - start here.
+            if (!this.currentAnimatedPos) {
+                if (this.animationStartPos) {
+                    this.actualTargetPos = discreteTarget;
+                    const progress = this.getAnimationProgress(currentRealTimeMs, this.animationStartTime);
+                    // Animation from start position complete.
+                    if (progress >= 1.0) {
+                        this.currentAnimatedPos = desired.position;
+                        this.animationStartPos = null;
+                        this.animationStartTime = null;
+                        return desired.position;
+                    }
+                    // Still animating from initial position.
+                    else {
+                        const easedProgress = this.easeInOutQuad(progress);
+                        this.currentAnimatedPos = Cartesian3.lerp(this.animationStartPos, desired.position, easedProgress, new Cartesian3());
+                        return this.currentAnimatedPos;
+                    }
+                }
+                // No initial animation needed.
+                else {
+                    this.currentAnimatedPos = desired.position;
+                    this.actualTargetPos = discreteTarget;
+                    return desired.position;
+                }
+            }
+            // Target changed.
+            if (actualTargetChanged) {
+                this.animationStartPos = this.currentAnimatedPos;
+                this.animationStartTime = currentRealTimeMs;
+                this.actualTargetPos = discreteTarget;
+            }
+            // Continue or start animation to target if we have an active animation.
+            if (this.animationStartPos && this.animationStartTime) {
+                const progress = this.getAnimationProgress(currentRealTimeMs, this.animationStartTime);
+                // Animation complete.
+                if (progress >= 1.0) {
+                    this.currentAnimatedPos = desired.position;
+                    this.animationStartPos = null;
+                    this.animationStartTime = null;
+                    return desired.position;
+                }
+                // Continue animation to interpolated position.
+                else {
+                    const easedProgress = this.easeInOutQuad(progress);
+                    this.currentAnimatedPos = Cartesian3.lerp(this.animationStartPos, desired.position, easedProgress, new Cartesian3());
+                    return this.currentAnimatedPos;
                 }
-                const progress = (timeMs - last.dateTime.getTime()) /
-                    (next.dateTime.getTime() - last.dateTime.getTime());
-                return Cartesian3.lerp(last.pos3d, next.pos3d, progress, new Cartesian3());
-            }
-            catch (e) {
-                console.error("Error in ideal position calculation: ", e);
-                return last.pos3d || new Cartesian3();
             }
+            // No active animation - follow interpolated path directly.
+            this.currentAnimatedPos = desired.position;
+            return desired.position;
+        }
+        getAnimationProgress(currentTime, startTime) {
+            const elapsed = currentTime - startTime;
+            return Math.min(elapsed / this.animationDuration, 1.0);
         }
         /**
-         * Returns a series of positions to use for rendering the path..
+         * Returns a series of positions to use for rendering the path.
          */
         GetSeries() {
             // Update at 30 fps.
@@ -1356,8 +1426,7 @@ var CesiumAnimatedProperty;
                 this.lastCalcSeriesPos3d = [];
                 return [];
             }
-            const totalDuration = this.positions[this.positions.length - 1].dateTime.getTime() -
-                this.positions[0].dateTime.getTime();
+            const totalDuration = this.positions[this.positions.length - 1].dateTime.getTime() - this.positions[0].dateTime.getTime();
             // Percentage of the polyline to be visible before and after each point.
             const visibilityPercentage = 0.05; // 5%
             const visibilityDuration = totalDuration * visibilityPercentage;
@@ -1365,13 +1434,14 @@ var CesiumAnimatedProperty;
             const newPosses = [];
             for (let i = 0; i < this.positions.length; i++) {
                 const pos = this.positions[i];
-                if (!pos.pos3d)
+                if (!pos.pos3d) {
                     continue;
+                }
                 let add = nowDate >= new Date(pos.dateTime.getTime() - visibilityDuration / 2) &&
                     nowDate <= new Date(pos.dateTime.getTime() + visibilityDuration / 2);
                 // Also include the segment we're currently traversing.
-                if (!add && this.lastCalcPosIndexLast > -1 && this.lastCalcPosIndexNext > -1) {
-                    add = i >= this.lastCalcPosIndexLast && i <= this.lastCalcPosIndexNext;
+                if (!add && this.lastDesiredPosIndex > -1 && this.lastDesiredNextIndex > -1) {
+                    add = i >= this.lastDesiredPosIndex && i <= this.lastDesiredNextIndex;
                 }
                 if (add) {
                     newPosses.push(pos.pos3d);
@@ -1409,10 +1479,10 @@ var CesiumAnimatedProperty;
             }
             const nowTime = JulianDate.toDate(now).getTime();
             try {
-                // Get last and next position indices.
-                const lastIndex = this.lastCalcPosIndexLast;
-                const nextIndex = this.lastCalcPosIndexNext;
-                // Validate indices.
+                // Get current position indices.
+                const lastIndex = this.lastDesiredPosIndex;
+                const nextIndex = this.lastDesiredNextIndex;
+                // Invalid indices.
                 if (lastIndex < 0 || nextIndex < 0 ||
                     lastIndex >= this.positions.length || nextIndex >= this.positions.length) {
                     return this.lastCalcOrient || defaultQuaternion;
@@ -1422,6 +1492,17 @@ var CesiumAnimatedProperty;
                 if (!lastPos || !nextPos) {
                     return this.lastCalcOrient || defaultQuaternion;
                 }
+                // Single position case - use its heading if available.
+                if (lastIndex === nextIndex) {
+                    if (lastPos.heading !== null) {
+                        this.lastCalcOrient = Transforms.headingPitchRollQuaternion(currentPosition, new HeadingPitchRoll(Math$1.toRadians(lastPos.heading), Math$1.toRadians(this.pitch), Math$1.toRadians(this.roll)));
+                        this.lastCalcOrientTime = Date.now();
+                        return this.lastCalcOrient;
+                    }
+                    // No heading data and single position, return previous or default.
+                    return this.lastCalcOrient || defaultQuaternion;
+                }
+                // Two different positions - we can calculate orientation.
                 // Use explicit heading values if available.
                 if (lastPos.heading !== null && nextPos.heading !== null) {
                     // Calculate interpolated heading.
@@ -1435,8 +1516,7 @@ var CesiumAnimatedProperty;
                     }
                     // Calculate interpolation factor.
                     let factor = 0;
-                    if (lastIndex !== nextIndex &&
-                        lastPos.dateTime.getTime() !== nextPos.dateTime.getTime()) {
+                    if (lastPos.dateTime.getTime() !== nextPos.dateTime.getTime()) {
                         factor = (nowTime - lastPos.dateTime.getTime()) /
                             (nextPos.dateTime.getTime() - lastPos.dateTime.getTime());
                         factor = Math.max(0, Math.min(1, factor));
@@ -1449,7 +1529,7 @@ var CesiumAnimatedProperty;
                     // Create quaternion from heading, pitch, roll.
                     this.lastCalcOrient = Transforms.headingPitchRollQuaternion(currentPosition, new HeadingPitchRoll(Math$1.toRadians(interpolatedHeading), Math$1.toRadians(this.pitch), Math$1.toRadians(this.roll)));
                 }
-                // Calculate heading from position changes if not available.
+                // Calculate heading from position changes if heading data not available.
                 else {
                     if (!lastPos.pos3d || !nextPos.pos3d) {
                         return this.lastCalcOrient || defaultQuaternion;
@@ -6842,7 +6922,9 @@ function removeEntities(viewer, entities) {
                 continue;
             }
             entityRemoveAddState.delete(entity.id);
-            viewer.entities.remove(entity);
+            if (viewer.entities.contains(entity)) {
+                viewer.entities.remove(entity);
+            }
         }
     });
 }
@@ -6864,7 +6946,9 @@ function addEntities(viewer, entities) {
                 continue;
             }
             entityRemoveAddState.delete(entity.id);
-            viewer.entities.add(entity);
+            if (!viewer.entities.contains(entity)) {
+                viewer.entities.add(entity);
+            }
         }
     });
 }
@@ -6971,7 +7055,7 @@ var EntityRenderEngineModel3d;
      * @returns
      */
     function Render(params) {
-        var _a, _b;
+        var _a, _b, _c, _d;
         const entity = params.entity;
         if (!params.entityHistoric) {
             params.entityHistoric = [];
@@ -7073,6 +7157,7 @@ var EntityRenderEngineModel3d;
             }
         };
         let cEntity = params.rendered;
+        let prevPos3d = cEntity ? GetCValue(params.viewer, cEntity.position) : null;
         if (!cEntity || !cEntity.model) {
             updateShouldShowTrack();
             if (!color) {
@@ -7162,12 +7247,11 @@ var EntityRenderEngineModel3d;
             cEntity.model.colorBlendAmount = new ConstantProperty(blendAmount);
             cEntity.model.colorBlendMode = new ConstantProperty(blendMode);
             cEntity.model.distanceDisplayCondition = new ConstantProperty(EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance));
-            const prevPos3d = GetCValue(params.viewer, cEntity.position);
             let prevStartTime = null;
             if (cEntity.position && cEntity.position["CesiumAnimatedProperty.AnimatePositionSeries"]) {
                 prevStartTime = cEntity.position["CesiumAnimatedProperty.AnimatePositionSeries"].GetAnimateFromDateTime();
             }
-            // If we have a series of time-based positions then we'll animate as time changes.
+            // If we've loaded a set of series positions then we'll animate through them.
             const series = CesiumAnimatedProperty.GetSeriesPossesForHistoricEntity(params.viewer, heightRef, heightRef, params.entityHistoric);
             if (series.length > 1) {
                 animatePosition = new CesiumAnimatedProperty.AnimatePositionSeries({
@@ -7182,17 +7266,50 @@ var EntityRenderEngineModel3d;
                 cEntity.position["CesiumAnimatedProperty.AnimatePositionSeries"] = animatePosition;
             }
             else {
+                const dateTimeStr = (_b = (_a = entity.Bruce.Outline) === null || _a === void 0 ? void 0 : _a.find(x => !!x.DateTime)) === null || _b === void 0 ? void 0 : _b.DateTime;
+                const dateTime = dateTimeStr ? new Date(dateTimeStr) : null;
                 const posChanged = !prevPos3d || !Cartesian3.equals(prevPos3d, pos3d);
                 if (posChanged) {
-                    animatePosition = new CesiumAnimatedProperty.AnimatePosition({
-                        durationMs: 200,
-                        targetPos3d: pos3d,
-                        viewer: params.viewer,
-                        startPos3d: prevPos3d
-                    });
-                    cEntity.position = new CallbackProperty(() => animatePosition.GetValue(), false);
+                    if (cEntity.position["CesiumAnimatedProperty.AnimatePositionSeries"]) {
+                        const prevAnimatePosition = cEntity.position["CesiumAnimatedProperty.AnimatePositionSeries"];
+                        animatePosition = prevAnimatePosition;
+                        animatePosition.AddPosition({
+                            pos3d: pos3d,
+                            dateTime: dateTime,
+                            heading: !EnsureNumber(transform === null || transform === void 0 ? void 0 : transform.heading) ? null : heading
+                        });
+                        animatePosition.UpdatePitchRoll(pitch, roll);
+                    }
+                    else {
+                        let posses = [];
+                        const isLive = ViewUtils.GetTimeDetails({ viewer: params.viewer }).isLive;
+                        if (prevPos3d && isLive) {
+                            posses.push({
+                                pos3d: prevPos3d,
+                                // Guess so that we can determine a direction of movement right away :)
+                                dateTime: new Date(dateTime.getTime() - 1000),
+                                heading: !EnsureNumber(transform === null || transform === void 0 ? void 0 : transform.heading) ? null : heading
+                            });
+                        }
+                        posses.push({
+                            pos3d: pos3d,
+                            dateTime: dateTime,
+                            heading: !EnsureNumber(transform === null || transform === void 0 ? void 0 : transform.heading) ? null : heading
+                        });
+                        animatePosition = new CesiumAnimatedProperty.AnimatePositionSeries({
+                            posses: posses,
+                            viewer: params.viewer,
+                            pitch: pitch,
+                            roll: roll,
+                            animateFromPos3d: prevPos3d && !isLive ? prevPos3d : null,
+                            animateFromPos3dTimeStart: null
+                        });
+                        cEntity.position = new CallbackProperty(() => animatePosition.GetValue(), false);
+                        cEntity.position["CesiumAnimatedProperty.AnimatePositionSeries"] = animatePosition;
+                    }
                 }
             }
+            // If we're animating position then we can animate orientation too based on the interpolated position.
             if (animatePosition && animatePosition instanceof CesiumAnimatedProperty.AnimatePositionSeries && animatePosition.GetOrient) {
                 cEntity.orientation = new CallbackProperty(() => {
                     return animatePosition.GetOrient();
@@ -7200,15 +7317,16 @@ var EntityRenderEngineModel3d;
             }
             else {
                 const prevHeading = cEntity.model._heading;
+                // Not worth animating.
                 if (prevHeading == null || prevHeading == heading || isNaN(prevHeading)) {
                     const hpr = new HeadingPitchRoll(Math$1.toRadians(heading), Math$1.toRadians(pitch), Math$1.toRadians(roll));
                     const orient = Transforms.headingPitchRollQuaternion(pos3d, hpr);
                     cEntity.orientation = new CallbackProperty(() => orient, true);
                 }
-                // Animate orientation. We'll calculate the heading based on movement.
+                // Animate the change.
                 else {
                     const animateHeading = new CesiumAnimatedProperty.AnimateHeading({
-                        durationMs: 200,
+                        durationMs: 500,
                         targetHeading: heading,
                         viewer: params.viewer,
                         startHeading: prevHeading
@@ -7240,7 +7358,7 @@ var EntityRenderEngineModel3d;
             else {
                 cEntity.model.scale = new CallbackProperty(() => scale * styleScale, true);
             }
-            // We'll use "SetDefaultColor" to updating the internal reference and to allow for an animation.
+            // We'll use "SetDefaultColor" to update the internal reference and to allow for an animation.
             // cEntity.model.color = new Cesium.CallbackProperty(() => color, true);
             CesiumEntityStyler.SetDefaultColor({
                 color: color ? color : new Color(),
@@ -7337,7 +7455,7 @@ var EntityRenderEngineModel3d;
         // Generate a polyline 'track' for the historic data.
         // We do this for historic data that exists and is moving.
         if (shouldShowTrack && animatePosition && animatePosition instanceof CesiumAnimatedProperty.AnimatePositionSeries && animatePosition.GetSeries) {
-            const lStyle = (_b = (_a = params.fullStyle) === null || _a === void 0 ? void 0 : _a.polylineStyle) !== null && _b !== void 0 ? _b : {};
+            const lStyle = (_d = (_c = params.fullStyle) === null || _c === void 0 ? void 0 : _c.polylineStyle) !== null && _d !== void 0 ? _d : {};
             const bColor = lStyle.lineColor ? Calculator.GetColor(lStyle.lineColor, entity, params.tags) : null;
             const cColor = bColor ? ColorToCColor(bColor) : Color.fromCssColorString("rgba(255, 193, 7, 0.8)");
             let width = lStyle.lineWidth ? EnsureNumber(Calculator.GetNumber(lStyle.lineWidth, entity, params.tags)) : 2;
@@ -33131,7 +33249,7 @@ class WidgetViewBar extends Widget.AWidget {
     }
 }
 
-const VERSION = "5.9.5";
+const VERSION = "5.9.7";
 
 export { VERSION, CesiumViewMonitor, ViewerUtils, ViewerEventTracker, MenuItemManager, isOutlineChanged, EntityRenderEngine, EntityRenderEnginePoint, EntityRenderEnginePolyline, EntityRenderEnginePolygon, EntityRenderEngineModel3d, MenuItemCreator, VisualsRegister, RenderManager, EntitiesIdsRenderManager, DataLabRenderManager, EntitiesLoadedRenderManager, EntitiesRenderManager, EntityRenderManager, TilesetCadRenderManager, TilesetArbRenderManager, TilesetEntitiesRenderManager, TilesetOsmRenderManager, TilesetPointcloudRenderManager, TilesetGooglePhotosRenderManager, DataSourceStaticKmlManager, GoogleSearchRenderManager, AssemblyRenderManager, RelationsRenderManager, SharedGetters, CesiumParabola, EntityLabel, ViewRenderEngine, TileRenderEngine, TilesetRenderEngine, CESIUM_INSPECTOR_KEY, CESIUM_TIMELINE_KEY, CESIUM_TIMELINE_LIVE_KEY, CESIUM_TIMELINE_LIVE_PADDING_KEY, CESIUM_TIMELINE_INTERVAL_KEY, DEFAULT_LIVE_PADDING_SECONDS, ViewUtils, DrawingUtils, MeasureUtils, EntityUtils, CesiumEntityStyler, CesiumAnimatedProperty, CesiumAnimatedInOut, Draw3dPolygon, Draw3dPolyline, MeasureCreator, Walkthrough, Widget, VIEWER_BOOKMARKS_WIDGET_KEY, WidgetBookmarks, WidgetBranding, WidgetCursorBar, WidgetEmbeddedInfoView, WidgetInfoView, WidgetNavCompass$$1 as WidgetNavCompass, VIEWER_VIEW_BAR_WIDGET_KEY, WidgetViewBar, WidgetControlViewBar, WidgetControlViewBarSearch, VIEWER_LEFT_PANEL_WIDGET_KEY, VIEWER_LEFT_PANEL_CSS_VAR_LEFT, WidgetLeftPanel, WidgetLeftPanelTab, WidgetLeftPanelTabBookmarks };
 //# sourceMappingURL=bruce-cesium.es5.js.map