bruce-cesium 6.4.0 → 6.4.2

package/dist/bruce-cesium.es5.js

@@ -1,6 +1,6 @@
-import { Cartes, Entity as Entity$1, Calculator, EntityRelationType, EntityType, Style, ENVIRONMENT, ProjectViewTile, DelayQueue, LRUCache, BruceEvent, ObjectUtils, Geometry, EntityHistoricData, EntityLod, ZoomControl, EntityTag, Tileset, Api, EntityCoords, DataLab, EntitySource, ClientFile, MenuItem, EntityRelation, ProgramKey, Bounds, Carto, ProjectView, ProjectViewBookmark, Camera, ProjectViewLegacyTile, AbstractApi, EntityAttachment, EntityAttachmentType, EntityAttribute, MathUtils, Session } from 'bruce-models';
+import { Cartes, Entity as Entity$1, Calculator, EntityRelationType, EntityType, Style, ENVIRONMENT, ProjectViewTile, DelayQueue, LRUCache, BruceEvent, ObjectUtils, Geometry, EntityHistoricData, EntityLod, ZoomControl, EntityTag, Tileset, Api, EntityCoords, DataLab, EntitySource, ClientFile, MenuItem, EntityRelation, ProgramKey, Bounds, Carto, ProjectView, ProjectViewBookmark, ProjectViewLegacyTile, Camera, AbstractApi, EntityAttachment, EntityAttachmentType, EntityAttribute, MathUtils, Session } from 'bruce-models';
 import * as Cesium from 'cesium';
-import { Cartographic, Entity, DistanceDisplayCondition, ColorMaterialProperty, Color, ConstantProperty, CallbackProperty, Primitive, Cesium3DTileFeature, Math as Math$1, Cartesian3, JulianDate, Quaternion, Transforms, HeadingPitchRoll, Matrix4, HeightReference, ColorBlendMode, ShadowMode, ClassificationType, Model, PolygonHierarchy, ConstantPositionProperty, PolylineGraphics, ArcType, CornerType, HorizontalOrigin, VerticalOrigin, Cartesian2, SceneTransforms, NearFarScalar, Matrix3, Rectangle, KmlDataSource, GeoJsonDataSource, SceneMode, Cesium3DTileStyle, HeadingPitchRange, Ion, Cesium3DTileColorBlendMode, Cesium3DTileset, IonResource, OrthographicFrustum, EasingFunction, EllipsoidTerrainProvider, IonImageryProvider, createWorldImagery, createWorldImageryAsync, BingMapsImageryProvider, BingMapsStyle, MapboxImageryProvider, MapboxStyleImageryProvider, ArcGisMapServerImageryProvider, OpenStreetMapImageryProvider, UrlTemplateImageryProvider, GridImageryProvider, GeographicTilingScheme, ImageryLayer, TileMapServiceImageryProvider, CesiumTerrainProvider, ModelGraphics, PolygonGraphics, CorridorGraphics, PointGraphics, BillboardGraphics, EllipseGraphics, PolylineDashMaterialProperty, EllipsoidGeodesic, sampleTerrainMostDetailed, defined, PolygonPipeline, CesiumInspector, ClockRange, BoundingSphere, GeometryInstance, ScreenSpaceEventHandler, ScreenSpaceEventType, Intersect, CzmlDataSource, Fullscreen } from 'cesium';
+import { Cartographic, ColorMaterialProperty, Entity, Color, ConstantProperty, CallbackProperty, Primitive, Cesium3DTileFeature, DistanceDisplayCondition, HeightReference, ColorBlendMode, HeadingPitchRoll, Math as Math$1, Transforms, ShadowMode, Cartesian3, ClassificationType, Model, PolygonHierarchy, ConstantPositionProperty, PolylineGraphics, ArcType, CornerType, HorizontalOrigin, VerticalOrigin, JulianDate, Quaternion, Matrix4, Cartesian2, SceneTransforms, NearFarScalar, Matrix3, Rectangle, KmlDataSource, GeoJsonDataSource, SceneMode, Cesium3DTileStyle, HeadingPitchRange, Ion, Cesium3DTileColorBlendMode, EllipsoidTerrainProvider, IonImageryProvider, createWorldImagery, createWorldImageryAsync, BingMapsImageryProvider, BingMapsStyle, MapboxImageryProvider, MapboxStyleImageryProvider, ArcGisMapServerImageryProvider, OpenStreetMapImageryProvider, UrlTemplateImageryProvider, GridImageryProvider, GeographicTilingScheme, ImageryLayer, TileMapServiceImageryProvider, CesiumTerrainProvider, IonResource, OrthographicFrustum, EasingFunction, Cesium3DTileset, ModelGraphics, PolygonGraphics, CorridorGraphics, PointGraphics, BillboardGraphics, EllipseGraphics, PolylineDashMaterialProperty, EllipsoidGeodesic, sampleTerrainMostDetailed, defined, PolygonPipeline, BoundingSphere, GeometryInstance, CesiumInspector, ClockRange, ScreenSpaceEventHandler, ScreenSpaceEventType, Intersect, CzmlDataSource, Fullscreen } from 'cesium';
 
 /**
  * Ensures a number is returned from a given value.
@@ -757,6 +757,7 @@ var CesiumAnimatedProperty;
      */
     class AnimatePositionSeries {
         constructor(params) {
+            this.useRealTime = false;
             this.currentPos = null;
             this.currentVelocity = new Cartesian3(0, 0, 0);
             this.smoothingFactor = 0.5;
@@ -771,13 +772,45 @@ var CesiumAnimatedProperty;
             this.lastCalcSeriesTime = null;
             this.lastCalcOrient = null;
             this.lastCalcOrientTime = null;
+            // Real-time animation fields (used when useRealTime is true).
+            this.realTimeAnimStartPos = null;
+            this.realTimeAnimStartTime = null;
+            this.realTimeAnimTarget = null;
             this.viewer = params.viewer;
             this.positions = params.posses || [];
             this.pitch = params.pitch || 0;
             this.roll = params.roll || 0;
+            this.useRealTime = Boolean(params.useRealTime);
             this.processHeadings();
             this.sortPositions();
         }
+        /**
+         * Returns the appropriate time in milliseconds for animation calculations.
+         * When useRealTime is true, returns wall-clock time (Date.now()).
+         * Otherwise returns the Cesium viewer time.
+         */
+        getTimeMs() {
+            if (this.useRealTime) {
+                return Date.now();
+            }
+            let viewerTime = this.viewer.scene.lastRenderTime;
+            if (!viewerTime) {
+                viewerTime = this.viewer.clock.currentTime;
+            }
+            return JulianDate.toDate(viewerTime).getTime();
+        }
+        SetUseRealTime(value) {
+            const changed = this.useRealTime !== value;
+            this.useRealTime = value;
+            if (changed) {
+                // Reset real-time animation state so the next updateRealTimePosition
+                // starts fresh from the current position.
+                this.realTimeAnimStartPos = null;
+                this.realTimeAnimStartTime = null;
+                this.realTimeAnimTarget = null;
+                this.invalidateCache();
+            }
+        }
         AddPosition(pos) {
             if (!pos || !pos.pos3d || !pos.dateTime) {
                 console.warn("Invalid position provided to AnimatePositionSeries.");
@@ -973,11 +1006,7 @@ var CesiumAnimatedProperty;
             };
         }
         GetValue() {
-            let viewerTime = this.viewer.scene.lastRenderTime;
-            if (!viewerTime) {
-                viewerTime = this.viewer.clock.currentTime;
-            }
-            const viewerTimeMs = JulianDate.toDate(viewerTime).getTime();
+            const viewerTimeMs = this.getTimeMs();
             const currentRealTimeMs = Date.now();
             const expected = this.calculateExpectedPosition(viewerTimeMs);
             if (!expected.position) {
@@ -994,6 +1023,10 @@ var CesiumAnimatedProperty;
                 this.lastUpdateTime = currentRealTimeMs;
                 return this.currentPos;
             }
+            // For real-time mode, use a fixed-duration eased lerp instead of velocity-based smoothing.
+            if (this.useRealTime) {
+                return this.updateRealTimePosition(expected.position, currentRealTimeMs);
+            }
             const deltaTime = this.lastUpdateTime ? (currentRealTimeMs - this.lastUpdateTime) / 1000.0 : 0.016;
             this.lastUpdateTime = currentRealTimeMs;
             const clampedDeltaTime = Math.min(deltaTime, 0.1);
@@ -1018,6 +1051,37 @@ var CesiumAnimatedProperty;
             this.currentPos = Cartesian3.add(this.currentPos, velocityDelta, new Cartesian3());
             return this.currentPos;
         }
+        /**
+         * Fixed-duration eased position animation for real-time (plugin-style) updates.
+         * Instead of velocity-based smoothing, lerps from the current position to the target
+         * over a fixed duration with ease-in-out.
+         */
+        updateRealTimePosition(targetPos, currentTimeMs) {
+            const duration = AnimatePositionSeries.REAL_TIME_ANIM_DURATION_MS;
+            // Detect target change. Start a new animation segment.
+            if (!this.realTimeAnimTarget || !Cartesian3.equals(this.realTimeAnimTarget, targetPos)) {
+                this.realTimeAnimStartPos = this.currentPos.clone();
+                this.realTimeAnimStartTime = currentTimeMs;
+                this.realTimeAnimTarget = targetPos.clone();
+            }
+            const elapsed = currentTimeMs - this.realTimeAnimStartTime;
+            if (elapsed >= duration) {
+                this.currentPos = this.realTimeAnimTarget.clone();
+                this.currentVelocity = new Cartesian3(0, 0, 0);
+                this.lastUpdateTime = currentTimeMs;
+                return this.currentPos;
+            }
+            const t = this.easeInOutQuad(elapsed / duration);
+            const newPos = Cartesian3.lerp(this.realTimeAnimStartPos, this.realTimeAnimTarget, t, new Cartesian3());
+            // Compute velocity from frame delta so GetOrient() can derive heading from movement.
+            const deltaTime = this.lastUpdateTime ? (currentTimeMs - this.lastUpdateTime) / 1000.0 : 0.016;
+            this.lastUpdateTime = currentTimeMs;
+            if (deltaTime > 0.001) {
+                this.currentVelocity = Cartesian3.divideByScalar(Cartesian3.subtract(newPos, this.currentPos, new Cartesian3()), deltaTime, new Cartesian3());
+            }
+            this.currentPos = newPos;
+            return this.currentPos;
+        }
         GetSeries() {
             let doUpdate = this.lastCalcSeriesTime == null;
             if (!doUpdate && this.lastCalcSeriesTime && (new Date().getTime() - this.lastCalcSeriesTime) > 1000 / 30) {
@@ -1027,13 +1091,10 @@ var CesiumAnimatedProperty;
                 return this.lastCalcSeriesPos3d;
             }
             this.GetValue();
-            let now = this.viewer.scene.lastRenderTime;
-            if (!now) {
-                now = this.viewer.clock.currentTime;
-            }
-            const nowDate = JulianDate.toDate(now);
+            const nowTimeMs = this.getTimeMs();
+            const nowDate = new Date(nowTimeMs);
             if (!this.positions || this.positions.length < 2) {
-                this.lastCalcSeriesTime = nowDate.getTime();
+                this.lastCalcSeriesTime = nowTimeMs;
                 this.lastCalcSeriesPos3d = [];
                 return [];
             }
@@ -1054,7 +1115,7 @@ var CesiumAnimatedProperty;
                     newPosses.push(pos.pos3d);
                 }
             }
-            this.lastCalcSeriesTime = nowDate.getTime();
+            this.lastCalcSeriesTime = nowTimeMs;
             this.lastCalcSeriesPos3d = newPosses;
             return newPosses;
         }
@@ -1087,11 +1148,7 @@ var CesiumAnimatedProperty;
                     this.lastCalcOrientTime = Date.now();
                     return this.lastCalcOrient;
                 }
-                let now = this.viewer.scene.lastRenderTime;
-                if (!now) {
-                    now = this.viewer.clock.currentTime;
-                }
-                const nowTime = JulianDate.toDate(now).getTime();
+                const nowTime = this.getTimeMs();
                 const lastIndex = this.lastDesiredPosIndex;
                 const nextIndex = this.lastDesiredNextIndex;
                 if (lastIndex < 0 || nextIndex < 0 ||
@@ -1227,6 +1284,7 @@ var CesiumAnimatedProperty;
             return this.positions.length;
         }
     }
+    AnimatePositionSeries.REAL_TIME_ANIM_DURATION_MS = 500;
     CesiumAnimatedProperty.AnimatePositionSeries = AnimatePositionSeries;
     function GetSeriesPossesForHistoricEntity(viewer, dataHeightRef, heightRef, historic) {
         if (!historic || !historic.length) {
@@ -31268,7 +31326,10 @@ var EntityRenderEngineModel3d;
             }
         };
         let cEntity = params.rendered;
-        let prevPos3d = cEntity ? GetCValue(params.viewer, cEntity.position) : null;
+        // Use the stored position from the previous render rather than evaluating the position callback.
+        // The callback may reference the entity object which can be mutated in-place (e.g., by plugins)
+        // before Render is called, which would make prevPos3d == pos3d and skip animation.
+        let prevPos3d = (cEntity === null || cEntity === void 0 ? void 0 : cEntity.model) ? cEntity.model._lastPos3d : null;
         if (!cEntity || !cEntity.model) {
             updateShouldShowTrack();
             if (!color) {
@@ -31358,23 +31419,46 @@ 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 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;
+            let 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 isHistoric = Boolean(dateTimeStr);
+            let dateTime = dateTimeStr ? new Date(dateTimeStr) : null;
+            // Initial animation check to see if we're continuing an animation.
+            // This requires historic data, otherwise we continue on and later animate a before vs after movement based on the rendered data.
             if (cEntity.position && cEntity.position["CesiumAnimatedProperty.AnimatePositionSeries"]) {
                 animatePosition = cEntity.position["CesiumAnimatedProperty.AnimatePositionSeries"];
                 const animateSeries = animatePosition;
                 const series = CesiumAnimatedProperty.GetSeriesPossesForHistoricEntity(params.viewer, heightRef, heightRef, params.entityHistoric);
+                // Ensure the time mode matches the current data situation.
+                // Historic/timestamped data should use viewer time; plugin-style direct updates should use real time.
+                const shouldUseRealTime = !dateTime && !series.length;
+                animateSeries.SetUseRealTime(shouldUseRealTime);
                 if (series.length) {
                     animateSeries.SupplementSeries(series);
                 }
                 if (dateTime) {
                     animateSeries.UpdatePositionForDateTime(pos3d, dateTime, !EnsureNumber(transform === null || transform === void 0 ? void 0 : transform.heading) ? null : heading);
                 }
-                // We don't have a date-stamped incoming position.
-                if (!dateTime && !series.length) {
-                    animatePosition = null;
+                // We don't have a date-stamped incoming position (e.g., plugin-style direct updates).
+                // Add the new position to the existing series so the fixed-duration animation can handle it.
+                if (shouldUseRealTime) {
+                    const posChanged = !prevPos3d || !Cartesian3.equals(prevPos3d, pos3d);
+                    if (posChanged && pos3d) {
+                        animateSeries.AddPosition({
+                            pos3d: pos3d,
+                            dateTime: new Date(),
+                            heading: !EnsureNumber(transform === null || transform === void 0 ? void 0 : transform.heading) ? null : heading
+                        });
+                    }
                 }
             }
+            // Now that main animation check is passed we'll ensure a date does exist so any further usage knows when 'now' is.
+            if (!dateTimeStr) {
+                dateTimeStr = entity.Bruce.Updated || entity.Bruce.Created;
+            }
+            dateTime = dateTimeStr ? new Date(dateTimeStr) : null;
+            if (!dateTime) {
+                dateTime = new Date();
+            }
             if (!animatePosition) {
                 // 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);
@@ -31392,25 +31476,31 @@ var EntityRenderEngineModel3d;
                     const posChanged = !prevPos3d || !Cartesian3.equals(prevPos3d, pos3d);
                     if (posChanged) {
                         let posses = [];
-                        const isLive = ViewUtils.GetTimeDetails({ viewer: params.viewer }).isLive;
+                        // On true to allow for animation through direct plugin changes.
+                        // Will see if there are side-effects and make it more elaborate if needed.
+                        const isLive = true || ViewUtils.GetTimeDetails({ viewer: params.viewer }).isLive;
+                        // Just using real time for animation to avoid it teleporting on first movement.
+                        // If the prior update was too long ago our velocity estimate will make it teleport.
+                        const animStartTime = new Date();
                         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),
+                                dateTime: animStartTime,
                                 heading: !EnsureNumber(transform === null || transform === void 0 ? void 0 : transform.heading) ? null : heading
                             });
                         }
                         posses.push({
                             pos3d: pos3d,
-                            dateTime: dateTime,
+                            // Target time is in the future so the series interpolates forward.
+                            dateTime: new Date(animStartTime.getTime() + 1000),
                             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
+                            roll: roll,
+                            useRealTime: true
                         });
                         cEntity.position = new CallbackProperty(() => animatePosition.GetValue(), false);
                         cEntity.position["CesiumAnimatedProperty.AnimatePositionSeries"] = animatePosition;
@@ -31418,7 +31508,14 @@ var EntityRenderEngineModel3d;
                 }
             }
             // If we're animating position then we can animate orientation too based on the interpolated position.
-            if (dateTime && animatePosition && animatePosition instanceof CesiumAnimatedProperty.AnimatePositionSeries && animatePosition.GetOrient) {
+            // We avoid interpolating it when there is no historic data AND the created/updated dates have changed.
+            // This is to avoid interpolating towards a just-saved Entity after the user moves it.
+            const prevUpdatedTime = cEntity.model._lastUpdatedTime;
+            const curUpdatedTime = entity.Bruce.Updated || entity.Bruce.Created;
+            const updatedTimeChanged = prevUpdatedTime && curUpdatedTime && prevUpdatedTime !== curUpdatedTime;
+            const hasHistoricSeries = isHistoric || (params.entityHistoric && params.entityHistoric.length > 0);
+            const shouldInterpolateHeading = !updatedTimeChanged || hasHistoricSeries;
+            if (shouldInterpolateHeading && dateTime && animatePosition && animatePosition instanceof CesiumAnimatedProperty.AnimatePositionSeries && animatePosition.GetOrient) {
                 cEntity.orientation = new CallbackProperty(() => {
                     return animatePosition.GetOrient();
                 }, false);
@@ -31560,6 +31657,8 @@ var EntityRenderEngineModel3d;
             style: styleScale
         };
         model._heading = heading;
+        model._lastPos3d = pos3d;
+        model._lastUpdatedTime = entity.Bruce.Updated || entity.Bruce.Created;
         // 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) {
@@ -34716,7 +34815,7 @@ class WidgetViewBar extends Widget.AWidget {
     }
 }
 
-const VERSION = "6.4.0";
+const VERSION = "6.4.2";
 /**
  * Updates the environment instance used by bruce-cesium to one specified.
  * This can be used to ensure that the instance a parent is referencing is shared between bruce-cesium, bruce-models, and the parent app.