bruce-cesium 5.4.6 → 5.4.7

package/dist/bruce-cesium.es5.js

@@ -1,6 +1,6 @@
 import { BruceEvent, Cartes, Entity as Entity$1, Carto, Geometry, MathUtils, LRUCache, Api, Calculator, ClientFile, EntityTag, EntityType, ObjectUtils, Style, ProjectViewTile, 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, ColorBlendMode, HeadingPitchRoll, Transforms, Model, HorizontalOrigin, VerticalOrigin, Primitive, Cesium3DTileFeature, SceneMode, GeoJsonDataSource, Cesium3DTileStyle, Cesium3DTileColorBlendMode, HeadingPitchRange, Ion, KmlDataSource, SceneTransforms, Cesium3DTileset, Matrix4, Matrix3, IonResource, EllipsoidTerrainProvider, CesiumInspector, OrthographicFrustum, defined, ClockRange, EasingFunction, NearFarScalar, EllipsoidGeodesic, sampleTerrainMostDetailed, PolygonPipeline, IonImageryProvider, createWorldImagery, createWorldImageryAsync, BingMapsImageryProvider, BingMapsStyle, MapboxImageryProvider, MapboxStyleImageryProvider, ArcGisMapServerImageryProvider, OpenStreetMapImageryProvider, UrlTemplateImageryProvider, GridImageryProvider, GeographicTilingScheme, ImageryLayer, TileMapServiceImageryProvider, CesiumTerrainProvider, BoundingSphere, GeometryInstance, ModelGraphics, PolygonGraphics, CorridorGraphics, PointGraphics, BillboardGraphics, EllipseGraphics, PolylineDashMaterialProperty, ScreenSpaceEventHandler, ScreenSpaceEventType, Quaternion, 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, PolygonHierarchy, PolylineGraphics, ColorMaterialProperty, HorizontalOrigin, VerticalOrigin, ColorBlendMode, HeadingPitchRoll, Transforms, Model, Primitive, Cesium3DTileFeature, SceneMode, GeoJsonDataSource, Cesium3DTileStyle, HeadingPitchRange, Ion, Cesium3DTileColorBlendMode, KmlDataSource, OrthographicFrustum, EasingFunction, NearFarScalar, SceneTransforms, Cesium3DTileset, Matrix4, Matrix3, IonResource, EllipsoidTerrainProvider, CesiumInspector, defined, ClockRange, EllipsoidGeodesic, sampleTerrainMostDetailed, PolygonPipeline, ModelGraphics, PolygonGraphics, CorridorGraphics, PointGraphics, BillboardGraphics, EllipseGraphics, PolylineDashMaterialProperty, IonImageryProvider, createWorldImagery, createWorldImageryAsync, BingMapsImageryProvider, BingMapsStyle, MapboxImageryProvider, MapboxStyleImageryProvider, ArcGisMapServerImageryProvider, OpenStreetMapImageryProvider, UrlTemplateImageryProvider, GridImageryProvider, GeographicTilingScheme, ImageryLayer, TileMapServiceImageryProvider, CesiumTerrainProvider, BoundingSphere, GeometryInstance, Quaternion, ScreenSpaceEventHandler, ScreenSpaceEventType, CzmlDataSource, Intersect, Fullscreen } from 'cesium';
 
 const TIME_LAG = 300;
 const POSITION_CHECK_TIMER = 950;
@@ -1152,10 +1152,15 @@ var CesiumAnimatedProperty;
             this.lastCalcSeriesTime = null;
             this.lastCalcOrient = null;
             this.lastCalcOrientTime = null;
+            // Indicates that the first time we get a GetValue position, we need to animate into it.
+            this.animateFromPos3d = null;
+            this.animateFromPos3dTimeStart = null;
             this.viewer = params.viewer;
             this.positions = params.posses;
             this.pitch = params.pitch;
             this.roll = params.roll;
+            this.animateFromPos3d = params.animateFromPos3d;
+            this.animateFromPos3dTimeStart = Date.now();
             this.processHeadings();
             // Order positions by date.
             this.positions.sort((a, b) => {
@@ -1189,19 +1194,28 @@ var CesiumAnimatedProperty;
             if (!now) {
                 now = this.viewer.clock.currentTime;
             }
-            const nowTime = JulianDate.toDate(now);
-            if (this.lastCalcTime == nowTime.getTime()) {
+            const nowTimeMs = JulianDate.toDate(now).getTime();
+            // Skip calculation if time hasn't changed.
+            if (this.lastCalcTime === nowTimeMs) {
+                if (this.animateFromPos3d) {
+                    // We emit an interpolated position if we're animating from the start position.
+                    const interpolatedPos = this.interpolateToStartPos3d(this.animateFromPos3dTimeStart, Date.now());
+                    if (Cartesian3.equals(interpolatedPos, this.animateFromPos3d)) {
+                        this.animateFromPos3d = null;
+                    }
+                    return interpolatedPos;
+                }
                 return this.lastCalcPos3d;
             }
             const calculate = () => {
                 // See if we're before the first position.
-                if (nowTime.getTime() <= this.positions[0].dateTime.getTime()) {
+                if (nowTimeMs <= this.positions[0].dateTime.getTime()) {
                     this.lastCalcPosIndexLast = 0;
                     this.lastCalcPosIndexNext = 0;
                     return this.positions[0].pos3d;
                 }
                 // See if we're after the last position.
-                if (nowTime.getTime() >= this.positions[this.positions.length - 1].dateTime.getTime()) {
+                if (nowTimeMs >= this.positions[this.positions.length - 1].dateTime.getTime()) {
                     this.lastCalcPosIndexLast = this.positions.length - 1;
                     this.lastCalcPosIndexNext = this.positions.length - 1;
                     return this.positions[this.positions.length - 1].pos3d;
@@ -1210,7 +1224,7 @@ var CesiumAnimatedProperty;
                 let lastIndex = 0;
                 for (let i = 1; i < this.positions.length; i++) {
                     let pos = this.positions[i];
-                    if (nowTime.getTime() >= pos.dateTime.getTime()) {
+                    if (nowTimeMs >= pos.dateTime.getTime()) {
                         lastIndex = i;
                     }
                     else {
@@ -1226,12 +1240,43 @@ var CesiumAnimatedProperty;
                     return last.pos3d;
                 }
                 this.lastCalcPosIndexNext = lastIndex + 1;
-                let progress = (nowTime.getTime() - last.dateTime.getTime()) / (next.dateTime.getTime() - last.dateTime.getTime());
+                let progress = (nowTimeMs - last.dateTime.getTime()) / (next.dateTime.getTime() - last.dateTime.getTime());
                 return Cartesian3.lerp(last.pos3d, next.pos3d, progress, new Cartesian3());
             };
-            this.lastCalcTime = nowTime.getTime();
+            this.lastCalcTime = nowTimeMs;
             this.lastCalcPos3d = calculate();
-            return this.lastCalcPos3d;
+            let pos3d = this.lastCalcPos3d;
+            // We emit an interpolated position if we're animating from the start position.
+            if (this.animateFromPos3d && Cartes.ValidateCartes3(this.lastCalcPos3d)) {
+                if (Cartesian3.equals(this.animateFromPos3d, this.lastCalcPos3d)) {
+                    this.animateFromPos3d = null;
+                }
+                else if (this.animateFromPos3d) {
+                    pos3d = this.interpolateToStartPos3d(this.animateFromPos3dTimeStart, Date.now());
+                    if (Cartesian3.equals(pos3d, this.animateFromPos3d)) {
+                        this.animateFromPos3d = null;
+                    }
+                }
+            }
+            return pos3d;
+        }
+        /**
+         * Interpolates between the start position and the last calculated position.
+         * This lets us animate in the series positions.
+         * @param nowMs
+         */
+        interpolateToStartPos3d(startMs, nowMs) {
+            const startPos = this.animateFromPos3d;
+            const targetPos = this.lastCalcPos3d;
+            if (!startPos || !targetPos) {
+                return startPos ? startPos : targetPos;
+            }
+            const duration = nowMs - startMs;
+            let progress = duration / 300; // 300ms duration.
+            if (progress > 1) {
+                progress = 1;
+            }
+            return Cartesian3.lerp(startPos, targetPos, progress, new Cartesian3());
         }
         /**
          * Returns a series of positions to use for rendering the path.
@@ -1414,6 +1459,9 @@ var CesiumAnimatedProperty;
             // Cache for calculated values.
             this.lastCalcTime = null;
             this.lastCalcPos3d = null;
+            this.lastCalcPosApplyOverTime = false;
+            this.lastCalcPos3dApplyOverTimeTarget = null;
+            this.lastCalcPos3dApplyOverTimeTimeStart = null;
             this.lastCalcHeading = null;
             this.removal = null;
             // Track the timeline range for which we have data.
@@ -1511,17 +1559,75 @@ var CesiumAnimatedProperty;
             const nowTimeMs = nowTime.getTime();
             // Skip calculation if time hasn't changed.
             if (this.lastCalcTime === nowTimeMs) {
+                // If we're currently mid-animation, we need to update the position over time.
+                if (this.lastCalcPosApplyOverTime) {
+                    const interpolatedPos = this.interpolatePos3dOverTime(this.lastCalcPos3dApplyOverTimeTimeStart, Date.now());
+                    if (Cartesian3.equals(interpolatedPos, this.lastCalcPos3dApplyOverTimeTarget)) {
+                        this.lastCalcPosApplyOverTime = false;
+                        this.lastCalcPos3d = interpolatedPos;
+                    }
+                    this.onUpdate(interpolatedPos, this.lastCalcHeading);
+                }
                 return;
             }
             // Calculate position.
             const position = this.calculatePosition(nowTimeMs);
+            // Calculate what position to emit.
+            let pos3d = null;
             // Update cache values.
             this.lastCalcTime = nowTimeMs;
-            this.lastCalcPos3d = position.pos3d;
+            if (position.applyOverTime && Cartes.ValidateCartes3(this.lastCalcPos3d)) {
+                if (Cartesian3.equals(this.lastCalcPos3d, position.pos3d)) {
+                    pos3d = position.pos3d;
+                    this.lastCalcPosApplyOverTime = false;
+                }
+                else if (Cartesian3.equals(this.lastCalcPos3dApplyOverTimeTarget, position.pos3d)) {
+                    pos3d = this.interpolatePos3dOverTime(this.lastCalcPos3dApplyOverTimeTimeStart, Date.now());
+                    if (Cartesian3.equals(pos3d, this.lastCalcPos3dApplyOverTimeTarget)) {
+                        this.lastCalcPos3d = pos3d;
+                        this.lastCalcPosApplyOverTime = false;
+                    }
+                }
+                else {
+                    if (!this.lastCalcPosApplyOverTime) {
+                        this.lastCalcPos3dApplyOverTimeTimeStart = Date.now();
+                    }
+                    this.lastCalcPosApplyOverTime = true;
+                    this.lastCalcPos3dApplyOverTimeTarget = position.pos3d;
+                    pos3d = this.interpolatePos3dOverTime(this.lastCalcPos3dApplyOverTimeTimeStart, Date.now());
+                }
+            }
+            else {
+                this.lastCalcPos3d = position.pos3d;
+                pos3d = position.pos3d;
+            }
             // Calculate heading.
-            this.lastCalcHeading = this.calculateHeading(nowTimeMs, position.indexLast, position.indexNext);
+            const posses = this.positions;
+            const lastPos = posses[position.indexLast];
+            const nextPos = posses[position.indexNext];
+            if (lastPos && nextPos) {
+                this.lastCalcHeading = this.calculateHeading(nowTimeMs, lastPos, nextPos);
+            }
             // Provide the calculated values to the caller.
-            this.onUpdate(this.lastCalcPos3d, this.lastCalcHeading);
+            this.onUpdate(pos3d, this.lastCalcHeading);
+        }
+        /**
+         * Interpolates the position over time between the last and target positions.
+         * This is used when we reach a boundary position so to smoothly animate to it, we move from the current position to it.
+         * @param nowMs
+         */
+        interpolatePos3dOverTime(prevMs, nowMs) {
+            const lastPos = this.lastCalcPos3d;
+            const targetPos = this.lastCalcPos3dApplyOverTimeTarget;
+            if (!lastPos || !targetPos) {
+                return lastPos ? lastPos : targetPos;
+            }
+            const duration = nowMs - prevMs;
+            let progress = duration / 300; // 300ms duration.
+            if (progress > 1) {
+                progress = 1;
+            }
+            return Cartesian3.lerp(lastPos, targetPos, progress, new Cartesian3());
         }
         /**
          * Pre-process headings in the series.
@@ -1553,7 +1659,8 @@ var CesiumAnimatedProperty;
                 return {
                     pos3d: new Cartesian3(),
                     indexLast: -1,
-                    indexNext: -1
+                    indexNext: -1,
+                    applyOverTime: false
                 };
             }
             // See if we're before the first position.
@@ -1561,7 +1668,8 @@ var CesiumAnimatedProperty;
                 return {
                     pos3d: posses[0].pos3d,
                     indexLast: 0,
-                    indexNext: 0
+                    indexNext: 0,
+                    applyOverTime: true
                 };
             }
             // See if we're after the last position.
@@ -1570,7 +1678,8 @@ var CesiumAnimatedProperty;
                 return {
                     pos3d: posses[lastIndex].pos3d,
                     indexLast: lastIndex,
-                    indexNext: lastIndex
+                    indexNext: lastIndex,
+                    applyOverTime: true
                 };
             }
             // Binary search to find the closest position.
@@ -1596,7 +1705,8 @@ var CesiumAnimatedProperty;
                 return {
                     pos3d: last.pos3d,
                     indexLast: lastIndex,
-                    indexNext: lastIndex
+                    indexNext: lastIndex,
+                    applyOverTime: true
                 };
             }
             // Interpolate between the two closest positions.
@@ -1607,25 +1717,18 @@ var CesiumAnimatedProperty;
             return {
                 pos3d: interpolatedPos,
                 indexLast: lastIndex,
-                indexNext: nextIndex
+                indexNext: nextIndex,
+                applyOverTime: false
             };
         }
         /**
          * Calculate the heading at the given time.
          */
-        calculateHeading(currentTimeMs, lastIndex, nextIndex) {
-            const posses = this.positions;
-            // Ensure valid indices.
-            if (lastIndex < 0 || nextIndex < 0 ||
-                lastIndex >= posses.length || nextIndex >= posses.length) {
-                return null;
-            }
-            const lastPos = posses[lastIndex];
-            const nextPos = posses[nextIndex];
+        calculateHeading(currentTimeMs, lastPos, nextPos) {
             // If the heading is present and not null, interpolate or use it directly.
             if (lastPos.heading !== null && nextPos.heading !== null) {
                 // If they're the same position or same time, just return the heading.
-                if (lastIndex === nextIndex ||
+                if (lastPos === nextPos ||
                     lastPos.dateTime.getTime() === nextPos.dateTime.getTime()) {
                     return lastPos.heading;
                 }
@@ -1645,16 +1748,16 @@ var CesiumAnimatedProperty;
             }
             // If no valid heading is available, calculate based on movement direction.
             else {
-                const previousPos = lastPos.pos3d;
-                const currentPos = nextPos.pos3d;
-                if (!previousPos || isNaN(previousPos.x) ||
-                    !currentPos || isNaN(currentPos.x)) {
+                const prevPos3d = lastPos.pos3d;
+                const nextPos3d = nextPos.pos3d;
+                if (!prevPos3d || isNaN(prevPos3d.x) ||
+                    !nextPos3d || isNaN(nextPos3d.x)) {
                     return null;
                 }
                 // Flatten to avoid orientation changes due to height differences.
-                const adjustedPointPrev = Cartographic.fromCartesian(previousPos);
+                const adjustedPointPrev = Cartographic.fromCartesian(prevPos3d);
                 const adjustedPos3dPrev = Cartesian3.fromRadians(adjustedPointPrev.longitude, adjustedPointPrev.latitude, 0);
-                const adjustedPointNext = Cartographic.fromCartesian(currentPos);
+                const adjustedPointNext = Cartographic.fromCartesian(nextPos3d);
                 const adjustedPos3dNext = Cartesian3.fromRadians(adjustedPointNext.longitude, adjustedPointNext.latitude, 0);
                 // Check if the positions are too close.
                 if (Cartesian3.distance(adjustedPos3dPrev, adjustedPos3dNext) < 0.05) {
@@ -1665,14 +1768,24 @@ var CesiumAnimatedProperty;
                 if (direction.x === 0 && direction.y === 0 && direction.z === 0) {
                     return null;
                 }
-                // Calculate heading from the direction vector.
+                // Normalize the direction vector.
                 Cartesian3.normalize(direction, direction);
-                // Convert the direction to a heading angle.
-                const east = Cartesian3.UNIT_X;
-                const north = Cartesian3.UNIT_Y;
-                const heading = Math.atan2(Cartesian3.dot(direction, east), Cartesian3.dot(direction, north));
-                // Convert to degrees.
-                return (Math$1.toDegrees(heading) + 360) % 360;
+                // Calculate heading in the ENU (East-North-Up).
+                // First, get the local ENU frame at the midpoint.
+                const midPoint = Cartesian3.midpoint(adjustedPos3dPrev, adjustedPos3dNext, new Cartesian3());
+                // Convert direction from ECEF to ENU.
+                // We need to create a transform from ECEF to ENU at our position.
+                const transform = Transforms.eastNorthUpToFixedFrame(midPoint);
+                const inverseTransform = Matrix4.inverseTransformation(transform, new Matrix4());
+                // Transform our direction vector to local ENU.
+                const localDirection = Matrix4.multiplyByPointAsVector(inverseTransform, direction, new Cartesian3());
+                Cartesian3.normalize(localDirection, localDirection);
+                // Now calculate the heading in the ENU frame (clockwise from north).
+                // atan2(east, north) gives us the angle in the east-north plane measured clockwise from north.
+                const heading = Math.atan2(localDirection.x, localDirection.y);
+                // Convert to degrees and ensure it's in the range [0, 360].
+                const headingDegrees = (Math$1.toDegrees(heading) + 360) % 360;
+                return headingDegrees;
             }
         }
     }
@@ -4554,12 +4667,14 @@ var EntityRenderEnginePoint;
                         // Unset width/height.
                         cEntity.billboard.width = undefined;
                         cEntity.billboard.height = undefined;
+                        const prevPos3d = GetCValue(params.viewer, cEntity.position);
                         // If we have a series of time-based positions then we'll animate as time changes.
                         const series = CesiumAnimatedProperty.GetSeriesPossesForHistoricEntity(params.viewer, heightRef, heightRef, params.entityHistoric);
                         if (series.length > 1) {
                             animatePosition = new CesiumAnimatedProperty.AnimatePositionSeries({
                                 posses: series,
-                                viewer: params.viewer
+                                viewer: params.viewer,
+                                animateFromPos3d: prevPos3d
                             });
                             cEntity.position = new CallbackProperty(() => animatePosition.GetValue(), false);
                         }
@@ -4571,7 +4686,6 @@ var EntityRenderEnginePoint;
                                 returnHeightRef: heightRef,
                                 allowRendered: false
                             });
-                            const prevPos3d = GetCValue(params.viewer, cEntity.position);
                             if (!prevPos3d || !Cartesian3.equals(prevPos3d, pos3d)) {
                                 animatePosition = new CesiumAnimatedProperty.AnimatePosition({
                                     durationMs: 200,
@@ -4877,12 +4991,14 @@ var EntityRenderEnginePoint;
                 cEntity.billboard.heightReference = new ConstantProperty(heightRef);
                 cEntity.billboard.distanceDisplayCondition = new ConstantProperty(EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance));
                 cEntity.billboard.disableDepthTestDistance = new ConstantProperty(disableDepthTest ? Number.POSITIVE_INFINITY : undefined);
+                const prevPos3d = GetCValue(params.viewer, cEntity.position);
                 // If we have a series of time-based positions then we'll animate as time changes.
                 const series = CesiumAnimatedProperty.GetSeriesPossesForHistoricEntity(params.viewer, heightRef, heightRef, params.entityHistoric);
                 if (series.length > 1) {
                     animatePosition = new CesiumAnimatedProperty.AnimatePositionSeries({
                         posses: series,
-                        viewer: params.viewer
+                        viewer: params.viewer,
+                        animateFromPos3d: prevPos3d
                     });
                     cEntity.position = new CallbackProperty(() => animatePosition.GetValue(), false);
                 }
@@ -4894,7 +5010,6 @@ var EntityRenderEnginePoint;
                         returnHeightRef: heightRef,
                         allowRendered: false
                     });
-                    const prevPos3d = GetCValue(params.viewer, cEntity.position);
                     if (!prevPos3d || !Cartesian3.equals(prevPos3d, pos3d)) {
                         animatePosition = new CesiumAnimatedProperty.AnimatePosition({
                             durationMs: 200,
@@ -6474,6 +6589,7 @@ 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);
             // If we have a series of time-based positions then we'll animate as time changes.
             const series = CesiumAnimatedProperty.GetSeriesPossesForHistoricEntity(params.viewer, heightRef, heightRef, params.entityHistoric);
             if (series.length > 1) {
@@ -6481,12 +6597,12 @@ var EntityRenderEngineModel3d;
                     posses: series,
                     viewer: params.viewer,
                     pitch: pitch,
-                    roll: roll
+                    roll: roll,
+                    animateFromPos3d: prevPos3d
                 });
                 cEntity.position = new CallbackProperty(() => animatePosition.GetValue(), false);
             }
             else {
-                const prevPos3d = GetCValue(params.viewer, cEntity.position);
                 const posChanged = !prevPos3d || !Cartesian3.equals(prevPos3d, pos3d);
                 if (posChanged) {
                     animatePosition = new CesiumAnimatedProperty.AnimatePosition({
@@ -14395,36 +14511,54 @@ var EntitiesIdsRenderManager;
          * @param entities
          */
         async getHistoricInfo(entities) {
-            const startTmp = JulianDate.toDate(this.viewer.clock.startTime);
-            const stopTmp = JulianDate.toDate(this.viewer.clock.stopTime);
+            // Time padding in milliseconds (15 seconds).
+            // Helps account for desync between client and server.
+            const TIME_PADDING_MS = 15000;
+            const minDateTimeStr = this.viewer.clock.startTime.toString();
+            const maxDateTimeStr = this.viewer.clock.stopTime.toString();
+            const minDateTime = new Date(minDateTimeStr).getTime();
+            const maxDateTime = new Date(maxDateTimeStr).getTime();
             let rangesToRequest = [{
-                    start: startTmp.toISOString(),
-                    stop: stopTmp.toISOString()
+                    start: minDateTime,
+                    stop: maxDateTime
                 }];
             // If we already have cached data, determine what ranges we're missing.
-            if (this.lastHistoricMin && this.lastHistoricMax && Object.keys(this.entitiesHistoric).length >= entities.length) {
-                const cachedStart = new Date(this.lastHistoricMin).getTime();
-                const cachedStop = new Date(this.lastHistoricMax).getTime();
-                const newStart = startTmp.getTime();
-                const newStop = stopTmp.getTime();
+            if (Object.keys(this.entitiesHistoric).length >= entities.length) {
+                let foundMinDateTime = null;
+                let foundMaxDateTime = null;
+                // Find the min/max based on cached data.
+                // Since we set the values sorted, we only have to check the first and last records for each entity.
+                for (const entityId of Object.keys(this.entitiesHistoric)) {
+                    const records = this.entitiesHistoric[entityId] || [];
+                    if (records.length) {
+                        const dateTime = new Date(records[0].dateTime).getTime();
+                        if (foundMinDateTime == null || dateTime < foundMinDateTime) {
+                            foundMinDateTime = dateTime;
+                        }
+                        const dateTime2 = new Date(records[records.length - 1].dateTime).getTime();
+                        if (foundMaxDateTime == null || dateTime2 > foundMaxDateTime) {
+                            foundMaxDateTime = dateTime2;
+                        }
+                    }
+                }
                 // Complete overlap - we already have all the data.
-                if (newStart >= cachedStart && newStop <= cachedStop) {
+                if (foundMinDateTime != null && foundMaxDateTime != null && foundMinDateTime <= minDateTime && foundMaxDateTime >= maxDateTime) {
                     return [false, this.entitiesHistoric];
                 }
                 // Calculate missing ranges.
                 rangesToRequest = [];
                 // Check if we need data before our cached range.
-                if (newStart < cachedStart) {
+                if (foundMinDateTime != null && foundMinDateTime > minDateTime) {
                     rangesToRequest.push({
-                        start: startTmp.toISOString(),
-                        stop: new Date(cachedStart).toISOString()
+                        start: minDateTime,
+                        stop: new Date(foundMinDateTime).getTime()
                     });
                 }
                 // Check if we need data after our cached range.
-                if (newStop > cachedStop) {
+                if (foundMaxDateTime != null && foundMaxDateTime < maxDateTime) {
                     rangesToRequest.push({
-                        start: new Date(cachedStop).toISOString(),
-                        stop: stopTmp.toISOString()
+                        start: new Date(foundMaxDateTime).getTime(),
+                        stop: maxDateTime
                     });
                 }
             }
@@ -14435,17 +14569,12 @@ var EntitiesIdsRenderManager;
                 if (this.disposed) {
                     break;
                 }
-                // Add padding to ensure we get all data.
-                const start = new Date(range.start);
-                const stop = new Date(range.stop);
-                start.setSeconds(start.getSeconds() - 1);
-                stop.setSeconds(stop.getSeconds() + 1);
-                const paddedStartStr = start.toISOString();
-                const paddedStopStr = stop.toISOString();
+                const start = new Date(range.start - TIME_PADDING_MS);
+                const stop = new Date(range.stop + TIME_PADDING_MS);
                 const historicData = await EntityHistoricData.GetList({
                     attrKey: this.item.BruceEntity.historicAttrKey,
-                    dateTimeFrom: paddedStartStr,
-                    dateTimeTo: paddedStopStr,
+                    dateTimeFrom: start.toISOString(),
+                    dateTimeTo: stop.toISOString(),
                     entityIds: entityIds,
                     api: this.apiGetter.getApi()
                 });
@@ -14479,9 +14608,6 @@ var EntitiesIdsRenderManager;
                 }
             }
             if (!this.disposed) {
-                // Update our cache boundaries.
-                this.lastHistoricMin = startTmp.toISOString();
-                this.lastHistoricMax = stopTmp.toISOString();
                 this.entitiesHistoric = combined;
             }
             return [rangesToRequest.length > 0, combined];
@@ -17615,6 +17741,9 @@ var TilesetCadRenderManager;
             const api = this.getters.GetBruceApi({
                 accountId: accountId
             });
+            // Time padding in milliseconds (15 seconds).
+            // Helps account for desync between client and server.
+            const TIME_PADDING_MS = 15000;
             // 'start-stop' time string that maps to a pending request.
             // Helps us avoid repeated requests that are the same.
             const pendingRequests = new Map();
@@ -17658,29 +17787,32 @@ var TilesetCadRenderManager;
              * @returns
              */
             const checkTimelineRange = async () => {
-                const minDateTime = this.viewer.clock.startTime.toString();
-                const maxDateTime = this.viewer.clock.stopTime.toString();
+                // Current timeline range.
+                const minDateTime = new Date(this.viewer.clock.startTime.toString()).getTime();
+                const maxDateTime = new Date(this.viewer.clock.stopTime.toString()).getTime();
+                // What we have loaded.
+                const range = this.historicAnimation.getDateRange();
+                const foundMinDateTime = (range === null || range === void 0 ? void 0 : range.minDate) ? range.minDate.getTime() : null;
+                const foundMaxDateTime = (range === null || range === void 0 ? void 0 : range.maxDate) ? range.maxDate.getTime() : null;
                 // See if the current range is within the range we already have.
                 if (this.historicPosses.length > 0 &&
-                    this.historicPossesMinDateTime &&
-                    this.historicPossesMaxDateTime &&
-                    minDateTime >= this.historicPossesMinDateTime &&
-                    maxDateTime <= this.historicPossesMaxDateTime) {
+                    foundMinDateTime &&
+                    foundMaxDateTime &&
+                    minDateTime >= foundMinDateTime &&
+                    maxDateTime <= foundMaxDateTime) {
                     return;
                 }
                 // See if the requested range is before or after the range we have.
-                const fetchBefore = !this.historicPossesMinDateTime || minDateTime < this.historicPossesMinDateTime;
-                const fetchAfter = !this.historicPossesMaxDateTime || maxDateTime > this.historicPossesMaxDateTime;
+                const fetchBefore = !foundMinDateTime || minDateTime < foundMinDateTime;
+                const fetchAfter = !foundMaxDateTime || maxDateTime > foundMaxDateTime;
                 if (!fetchBefore && !fetchAfter) {
                     // Already have the data we need.
                     return;
                 }
                 // No known range so we need to fetch the whole thing.
-                if (!this.historicPossesMinDateTime || !this.historicPossesMaxDateTime) {
-                    const startTmp = JulianDate.toDate(this.viewer.clock.startTime);
-                    const stopTmp = JulianDate.toDate(this.viewer.clock.stopTime);
-                    const startStr = new Date(startTmp.getTime() - 1000).toISOString();
-                    const stopStr = new Date(stopTmp.getTime() + 1000).toISOString();
+                if (!foundMinDateTime || !foundMaxDateTime) {
+                    const startStr = new Date(minDateTime - TIME_PADDING_MS).toISOString();
+                    const stopStr = new Date(maxDateTime + TIME_PADDING_MS).toISOString();
                     const newPositions = await getPossesForRange(startStr, stopStr);
                     if (this.disposed) {
                         return;
@@ -17688,22 +17820,17 @@ var TilesetCadRenderManager;
                     if (this.historicAnimation && this.historicAnimation.addPositions) {
                         this.historicAnimation.addPositions(newPositions);
                     }
-                    this.historicPossesMinDateTime = minDateTime;
-                    this.historicPossesMaxDateTime = maxDateTime;
                 }
                 else {
                     // The data we want is before the range we've currently loaded.
                     if (fetchBefore) {
                         // Calculate the missing difference and request it.
-                        const startTmp = JulianDate.toDate(this.viewer.clock.startTime);
-                        const stopTmp = new Date(this.historicPossesMinDateTime);
-                        const startStr = new Date(startTmp.getTime() - 1000).toISOString();
-                        const stopStr = stopTmp.toISOString();
-                        getPossesForRange(startStr, stopStr).then(newPositions => {
+                        const startStr = new Date(minDateTime - TIME_PADDING_MS).toISOString();
+                        const stopStr = new Date(foundMinDateTime + TIME_PADDING_MS).toISOString();
+                        getPossesForRange(startStr, stopStr).then((newPositions) => {
                             if (this.disposed) {
                                 return;
                             }
-                            this.historicPossesMinDateTime = minDateTime;
                             if (this.historicAnimation && this.historicAnimation.addPositions) {
                                 this.historicAnimation.addPositions(newPositions);
                             }
@@ -17712,15 +17839,12 @@ var TilesetCadRenderManager;
                     // The data we want is after the range we've currently loaded.
                     if (fetchAfter) {
                         // Calculate the missing difference and request it.
-                        const startTmp = new Date(this.historicPossesMaxDateTime);
-                        const stopTmp = JulianDate.toDate(this.viewer.clock.stopTime);
-                        const startStr = startTmp.toISOString();
-                        const stopStr = new Date(stopTmp.getTime() + 1000).toISOString();
-                        getPossesForRange(startStr, stopStr).then(newPositions => {
+                        const startStr = new Date(foundMaxDateTime - TIME_PADDING_MS).toISOString();
+                        const stopStr = new Date(maxDateTime + TIME_PADDING_MS).toISOString();
+                        getPossesForRange(startStr, stopStr).then((newPositions) => {
                             if (this.disposed) {
                                 return;
                             }
-                            this.historicPossesMaxDateTime = maxDateTime;
                             if (this.historicAnimation && this.historicAnimation.addPositions) {
                                 this.historicAnimation.addPositions(newPositions);
                             }
@@ -17734,8 +17858,6 @@ var TilesetCadRenderManager;
              * @returns
              */
             const getInitialPosses = async () => {
-                const minDateTime = this.viewer.clock.startTime.toString();
-                const maxDateTime = this.viewer.clock.stopTime.toString();
                 this.historicPossesLoadingProm = new Promise(async (res) => {
                     try {
                         if (this.disposed) {
@@ -17752,8 +17874,6 @@ var TilesetCadRenderManager;
                             return;
                         }
                         this.historicPosses = positions;
-                        this.historicPossesMinDateTime = minDateTime;
-                        this.historicPossesMaxDateTime = maxDateTime;
                         res(positions);
                     }
                     catch (e) {
@@ -17779,6 +17899,13 @@ var TilesetCadRenderManager;
                         if (this.disposed) {
                             return;
                         }
+                        // Reverse heading .
+                        // Not sure if calc or model is the issue.
+                        // This is all for a single demo until we figure out how we configure assemblies for this anyways.
+                        heading = heading + 180;
+                        if (heading > 360) {
+                            heading = heading - 360;
+                        }
                         // Jank code that hacks the position to be different.
                         // This can mess up our panels so we'll need to disable editing until a better system is in place.
                         const location = Cartographic.fromCartesian(pos3d);
@@ -30631,7 +30758,7 @@ class WidgetViewBar extends Widget.AWidget {
     }
 }
 
-const VERSION = "5.4.6";
+const VERSION = "5.4.7";
 
 export { VERSION, CesiumViewMonitor, ViewerUtils, ViewerEventTracker, MenuItemManager, isHistoricMetadataChanged, EntityRenderEngine, EntityRenderEnginePoint, EntityRenderEnginePolyline, EntityRenderEnginePolygon, EntityRenderEngineModel3d, MenuItemCreator, VisualsRegister, RenderManager, EntitiesIdsRenderManager, DataLabRenderManager, EntitiesLoadedRenderManager, EntitiesRenderManager, EntityRenderManager, TilesetCadRenderManager, TilesetArbRenderManager, TilesetEntitiesRenderManager, TilesetOsmRenderManager, TilesetPointcloudRenderManager, TilesetGooglePhotosRenderManager, DataSourceStaticKmlManager, GoogleSearchRenderManager, RelationsRenderManager, SharedGetters, CesiumParabola, EntityLabel, ViewRenderEngine, TileRenderEngine, TilesetRenderEngine, CESIUM_INSPECTOR_KEY, CESIUM_TIMELINE_KEY, CESIUM_TIMELINE_LIVE_KEY, CESIUM_TIMELINE_LIVE_PADDING_FORWARD_KEY, CESIUM_TIMELINE_LIVE_PADDING_BACKWARD_KEY, CESIUM_TIMELINE_INTERVAL_KEY, 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