bruce-cesium 7.3.2 → 7.3.4

package/dist/lib/bruce-cesium.js

@@ -83,7 +83,7 @@ __exportStar(require("./widgets/widget-info-view"), exports);
 __exportStar(require("./widgets/widget-left-panel"), exports);
 __exportStar(require("./widgets/widget-nav-compass"), exports);
 __exportStar(require("./widgets/widget-view-bar"), exports);
-exports.VERSION = "7.3.2";
+exports.VERSION = "7.3.4";
 /**
  * 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.

package/dist/lib/internal/code-logic-exceptions.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodeLogicExceptions = void 0;
+/**
+ * Places where the code is deliberately wrong for one customer and right for everyone else.
+ * This allows making fixes while leaving specific customers with unchanged experiences until they are migrated properly.
+ */
+var CodeLogicExceptions;
+(function (CodeLogicExceptions) {
+    // FNV-1a, run twice from different offsets and joined, so the result is 64 bits rather than 32.
+    const FNV_PRIME = 0x01000193;
+    const FNV_OFFSETS = [0x811c9dc5, 0x7fffffff];
+    function fnv1a(value, offset) {
+        let hash = offset;
+        for (let i = 0; i < value.length; i++) {
+            hash ^= value.charCodeAt(i);
+            // Multiply in 32-bit space without losing the high bits to float precision.
+            hash = Math.imul(hash, FNV_PRIME) >>> 0;
+        }
+        return hash >>> 0;
+    }
+    /**
+     * Returns the stored form of an account ID, or null when there is no usable account.
+     *
+     * Null rather than a hash of the empty string, so that everything without an account does not end
+     * up matching everything else without one.
+     * @param accountId
+     */
+    function HashAccountId(accountId) {
+        const normalized = (accountId || "").trim().toLowerCase();
+        if (!normalized) {
+            return null;
+        }
+        return (FNV_OFFSETS
+            .map(offset => fnv1a(normalized, offset).toString(16).padStart(8, "0"))
+            .join(""));
+    }
+    CodeLogicExceptions.HashAccountId = HashAccountId;
+    /**
+     * Returns whether an exception applies to the account currently being rendered for.
+     * Anything unknown is not an exception, so the ordinary path is what runs.
+     * @param exception
+     * @param accountId
+     */
+    function AppliesTo(exception, accountId) {
+        var _a;
+        const hash = HashAccountId(accountId);
+        if (!hash || !((_a = exception === null || exception === void 0 ? void 0 : exception.accounts) === null || _a === void 0 ? void 0 : _a.length)) {
+            return false;
+        }
+        return exception.accounts.indexOf(hash) !== -1;
+    }
+    CodeLogicExceptions.AppliesTo = AppliesTo;
+    /**
+     * A historic Assembly's root heading is turned through half a circle before it is written into the tileset's UCS.
+     */
+    CodeLogicExceptions.ASSEMBLY_HISTORIC_HEADING_FLIP = {
+        id: "assembly-historic-heading-flip",
+        what: "Adds 180 degrees to the root Entity's interpolated heading before the CAD tileset's UCS transform is written, in TilesetCadRenderManager's historic movement path.",
+        why: ("The assembly faced backwards along its own track for this customer's demo and nobody "
+            + "established whether the fault was in the recorded heading, the source model's axis "
+            + "convention, or our own transform. The correction was applied to everyone, which means "
+            + "any other account recording a correct heading has been rendered backwards ever since."),
+        raisedOn: "2026-08-31",
+        removeWhen: ("Someone loads this customer's assembly with the flip removed and confirms which "
+            + "of the three is actually wrong. If it is the source model, the fix belongs in the "
+            + "model or its import, not here."),
+        accounts: ["1185ae5ab0fb0794"]
+    };
+    /**
+     * Every exception, so this list is the one place to look.
+     */
+    CodeLogicExceptions.ALL = [
+        CodeLogicExceptions.ASSEMBLY_HISTORIC_HEADING_FLIP
+    ];
+})(CodeLogicExceptions = exports.CodeLogicExceptions || (exports.CodeLogicExceptions = {}));
+//# sourceMappingURL=code-logic-exceptions.js.map

package/dist/lib/internal/code-logic-exceptions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"code-logic-exceptions.js","sourceRoot":"","sources":["../../../src/internal/code-logic-exceptions.ts"],"names":[],"mappings":";;;AAAA;;;GAGG;AACH,IAAiB,mBAAmB,CA0FnC;AA1FD,WAAiB,mBAAmB;IAgBhC,gGAAgG;IAChG,MAAM,SAAS,GAAG,UAAU,CAAC;IAC7B,MAAM,WAAW,GAAG,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC;IAE7C,SAAS,KAAK,CAAC,KAAa,EAAE,MAAc;QACxC,IAAI,IAAI,GAAG,MAAM,CAAC;QAClB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YACnC,IAAI,IAAI,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;YAC5B,4EAA4E;YAC5E,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,SAAS,CAAC,KAAK,CAAC,CAAC;SAC3C;QACD,OAAO,IAAI,KAAK,CAAC,CAAC;IACtB,CAAC;IAED;;;;;;OAMG;IACH,SAAgB,aAAa,CAAC,SAAiB;QAC3C,MAAM,UAAU,GAAG,CAAC,SAAS,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;QAC1D,IAAI,CAAC,UAAU,EAAE;YACb,OAAO,IAAI,CAAC;SACf;QACD,OAAO,CACH,WAAW;aACN,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,KAAK,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;aACtE,IAAI,CAAC,EAAE,CAAC,CAChB,CAAC;IACN,CAAC;IAVe,iCAAa,gBAU5B,CAAA;IAED;;;;;OAKG;IACH,SAAgB,SAAS,CAAC,SAAqB,EAAE,SAAiB;;QAC9D,MAAM,IAAI,GAAG,aAAa,CAAC,SAAS,CAAC,CAAC;QACtC,IAAI,CAAC,IAAI,IAAI,CAAC,CAAA,MAAA,SAAS,aAAT,SAAS,uBAAT,SAAS,CAAE,QAAQ,0CAAE,MAAM,CAAA,EAAE;YACvC,OAAO,KAAK,CAAC;SAChB;QACD,OAAO,SAAS,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;IACnD,CAAC;IANe,6BAAS,YAMxB,CAAA;IAED;;OAEG;IACU,kDAA8B,GAAe;QACtD,EAAE,EAAE,gCAAgC;QACpC,IAAI,EAAE,oKAAoK;QAC1K,GAAG,EAAE,CACD,uFAAuF;cACrF,qFAAqF;cACrF,wFAAwF;cACxF,uFAAuF,CAC5F;QACD,QAAQ,EAAE,YAAY;QACtB,UAAU,EAAE,CACR,kFAAkF;cAChF,oFAAoF;cACpF,gCAAgC,CACrC;QACD,QAAQ,EAAE,CAAC,kBAAkB,CAAC;KACjC,CAAC;IAEF;;OAEG;IACU,uBAAG,GAAiB;QAC7B,oBAAA,8BAA8B;KACjC,CAAC;AACN,CAAC,EA1FgB,mBAAmB,GAAnB,2BAAmB,KAAnB,2BAAmB,QA0FnC"}

package/dist/lib/rendering/cesium-animated-property.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CesiumAnimatedProperty = void 0;
-const bruce_models_1 = require("bruce-models");
 const Cesium = require("cesium");
+const drawing_utils_1 = require("../utils/drawing-utils");
 const entity_utils_1 = require("../utils/entity-utils");
+const view_utils_1 = require("../utils/view-utils");
 function getColor(viewer, obj) {
     let value = null;
     if (obj === null || obj === void 0 ? void 0 : obj.getValue) {
@@ -368,6 +369,89 @@ var CesiumAnimatedProperty;
         }
     }
     CesiumAnimatedProperty.AnimateHeading = AnimateHeading;
+    // How much watching the trail represents.
+    CesiumAnimatedProperty.TRAIL_REAL_SECONDS = 20;
+    // A paused clock has no rate, so the trail falls back to this rather than vanishing.
+    CesiumAnimatedProperty.TRAIL_MIN_MS = 30 * 1000;
+    // And a hard scrub cannot ask for the whole archive.
+    CesiumAnimatedProperty.TRAIL_MAX_MS = 60 * 60 * 1000;
+    // A dense archive would otherwise build a polyline with more vertices than the scene can afford.
+    CesiumAnimatedProperty.TRAIL_MAX_POINTS = 500;
+    // And a sparse one would leave almost nothing to see, since the span is measured in time and says
+    // nothing about how often the thing being watched reports.
+    CesiumAnimatedProperty.TRAIL_MIN_POINTS = 8;
+    /**
+     * Returns how much scene time a trail should cover, for a clock moving at this rate.
+     * @param ratePerSecondMs milliseconds of scene time per real second.
+     * @param realSeconds how much watching the trail should represent.
+     */
+    function TrailSpanFor(ratePerSecondMs, realSeconds = CesiumAnimatedProperty.TRAIL_REAL_SECONDS, minMs = CesiumAnimatedProperty.TRAIL_MIN_MS, maxMs = CesiumAnimatedProperty.TRAIL_MAX_MS) {
+        const rate = Math.abs(ratePerSecondMs || 0);
+        const span = rate * realSeconds;
+        if (!(span > minMs)) {
+            return minMs;
+        }
+        return Math.min(span, maxMs);
+    }
+    CesiumAnimatedProperty.TrailSpanFor = TrailSpanFor;
+    /**
+     * Returns the positions a movement trail should run through, for a playhead at this time.
+     * @param params
+     */
+    function TrailPositionsFrom(params) {
+        const { positions, nowTimeMs, currentPos } = params;
+        if (!positions || positions.length < 2) {
+            return [];
+        }
+        const span = TrailSpanFor(params.ratePerSecondMs);
+        const firstMs = positions[0].dateTime.getTime();
+        const lastMs = positions[positions.length - 1].dateTime.getTime();
+        // A playhead nowhere near the records has no trail. Drawing the nearest leg anyway leaves a
+        // stub floating in the scene at a time the thing was not there.
+        if (nowTimeMs < firstMs - span || nowTimeMs > lastMs + span) {
+            return [];
+        }
+        // A trail is where the thing has been, so nothing ahead of the playhead belongs in it.
+        const behind = [];
+        for (const pos of positions) {
+            if (pos.pos3d && pos.dateTime.getTime() <= nowTimeMs) {
+                behind.push(pos);
+            }
+        }
+        const fromMs = nowTimeMs - span;
+        let firstInSpan = behind.length;
+        while (firstInSpan > 0 && behind[firstInSpan - 1].dateTime.getTime() >= fromMs) {
+            firstInSpan--;
+        }
+        // Sparse records would otherwise leave the span holding one point, which is not a line.
+        const from = Math.max(0, Math.min(firstInSpan, behind.length - CesiumAnimatedProperty.TRAIL_MIN_POINTS));
+        let newPosses = behind.slice(from).map(pos => pos.pos3d);
+        // The trail has to meet the graphic it trails, which is between two records most of the time.
+        if (currentPos && (!newPosses.length
+            || !Cesium.Cartesian3.equals(newPosses[newPosses.length - 1], currentPos))) {
+            newPosses.push(currentPos);
+        }
+        return DecimateSeries(newPosses, CesiumAnimatedProperty.TRAIL_MAX_POINTS);
+    }
+    CesiumAnimatedProperty.TrailPositionsFrom = TrailPositionsFrom;
+    /**
+     * Thins a run of positions down to at most maxPoints, keeping the first and last.
+     * @param posses
+     * @param maxPoints
+     */
+    function DecimateSeries(posses, maxPoints = CesiumAnimatedProperty.TRAIL_MAX_POINTS) {
+        if (!posses || posses.length <= maxPoints || maxPoints < 2) {
+            return posses;
+        }
+        const stride = (posses.length - 1) / (maxPoints - 1);
+        const out = [];
+        for (let i = 0; i < maxPoints - 1; i++) {
+            out.push(posses[Math.round(i * stride)]);
+        }
+        out.push(posses[posses.length - 1]);
+        return out;
+    }
+    CesiumAnimatedProperty.DecimateSeries = DecimateSeries;
     /**
      * Animates a position from a set of provided positions in time.
      * This will return a position across the provided positions based on the current time.
@@ -418,6 +502,20 @@ var CesiumAnimatedProperty;
             }
             return Cesium.JulianDate.toDate(viewerTime).getTime();
         }
+        /*
+         * Returns how fast scene time is passing, in milliseconds per real second.
+         */
+        ratePerSecondMs() {
+            var _a, _b;
+            if (this.useRealTime) {
+                return 1000;
+            }
+            const multiplier = (_b = (_a = this.viewer) === null || _a === void 0 ? void 0 : _a.clock) === null || _b === void 0 ? void 0 : _b.multiplier;
+            if (multiplier == null || isNaN(multiplier)) {
+                return 1000;
+            }
+            return Math.abs(multiplier) * 1000;
+        }
         SetUseRealTime(value) {
             const changed = this.useRealTime !== value;
             this.useRealTime = value;
@@ -717,27 +815,37 @@ var CesiumAnimatedProperty;
                 this.lastCalcSeriesPos3d = [];
                 return [];
             }
-            const totalDuration = this.positions[this.positions.length - 1].dateTime.getTime() - this.positions[0].dateTime.getTime();
-            const visibilityPercentage = 0.05;
-            const visibilityDuration = totalDuration * visibilityPercentage;
-            const newPosses = [];
-            for (let i = 0; i < this.positions.length; i++) {
-                const pos = this.positions[i];
-                if (!pos.pos3d) {
-                    continue;
-                }
-                let add = nowDate >= new Date(pos.dateTime.getTime() - visibilityDuration / 2) && nowDate <= new Date(pos.dateTime.getTime() + visibilityDuration / 2);
-                if (!add && this.lastDesiredPosIndex > -1 && this.lastDesiredNextIndex > -1) {
-                    add = i >= this.lastDesiredPosIndex && i <= this.lastDesiredNextIndex;
-                }
-                if (add) {
-                    newPosses.push(pos.pos3d);
-                }
-            }
+            const newPosses = TrailPositionsFrom({
+                positions: this.positions,
+                nowTimeMs: nowTimeMs,
+                ratePerSecondMs: this.ratePerSecondMs(),
+                currentPos: this.currentPos
+            });
             this.lastCalcSeriesTime = nowTimeMs;
             this.lastCalcSeriesPos3d = newPosses;
             return newPosses;
         }
+        /**
+         * Returns the heading carried by the last record at or before the playhead, in degrees, or
+         * null when no record in range names one.
+         */
+        GetHeadingDegrees() {
+            var _a;
+            if (!((_a = this.positions) === null || _a === void 0 ? void 0 : _a.length)) {
+                return null;
+            }
+            const nowTimeMs = this.getTimeMs();
+            let heading = null;
+            for (const pos of this.positions) {
+                if (pos.dateTime.getTime() > nowTimeMs) {
+                    break;
+                }
+                if (pos.heading != null) {
+                    heading = pos.heading;
+                }
+            }
+            return heading;
+        }
         GetOrient() {
             let doUpdate = this.lastCalcOrientTime == null;
             if (!doUpdate && this.lastCalcOrientTime && (new Date().getTime() - this.lastCalcOrientTime) > 1000 / 30) {
@@ -857,16 +965,16 @@ var CesiumAnimatedProperty;
                 const existingIndex = dateTimeIndexes.get(pos.dateTime.getTime());
                 if (existingIndex >= 0) {
                     this.positions[existingIndex] = pos;
+                    continue;
                 }
-                else {
-                    const newPoint = {
-                        pos: pos.pos3d.clone(),
-                        time: pos.dateTime.getTime(),
-                        realTime: Date.now()
-                    };
-                    this.positionHistory.push(newPoint);
-                    dateTimeIndexes.set(pos.dateTime.getTime(), this.positions.length);
-                }
+                // A record at a time not seen before belongs in the series being animated along.
+                dateTimeIndexes.set(pos.dateTime.getTime(), this.positions.length);
+                this.positions.push(pos);
+                this.positionHistory.push({
+                    pos: pos.pos3d.clone(),
+                    time: pos.dateTime.getTime(),
+                    realTime: Date.now()
+                });
             }
             if (this.positionHistory.length > this.maxHistorySize) {
                 this.positionHistory = this.positionHistory.slice(-this.maxHistorySize);
@@ -905,7 +1013,44 @@ var CesiumAnimatedProperty;
     }
     AnimatePositionSeries.REAL_TIME_ANIM_DURATION_MS = 500;
     CesiumAnimatedProperty.AnimatePositionSeries = AnimatePositionSeries;
+    /*
+     * Reads one transform component, tolerating either spelling, and keeping "not recorded" distinct from a recorded zero.
+     * TODO: see when we actually have varied spelling, might be a result of misusing historic data.
+     */
+    function pick(transform, lower, upper) {
+        var _a;
+        const value = (_a = transform === null || transform === void 0 ? void 0 : transform[lower]) !== null && _a !== void 0 ? _a : transform === null || transform === void 0 ? void 0 : transform[upper];
+        return value == null || isNaN(+value) ? null : +value;
+    }
+    /**
+     * Returns a position at the height its graphic is actually drawn at.
+     * Respecting the height ref means it is pointing the right way when we orient based on movement.
+     * @param viewer
+     * @param pos3d
+     * @param heightRef
+     */
+    function GetDrawnHeightPos3d(viewer, pos3d, heightRef) {
+        if (heightRef != Cesium.HeightReference.CLAMP_TO_GROUND || !pos3d) {
+            return pos3d;
+        }
+        const offset = drawing_utils_1.DrawingUtils.GetTerrainOffset({
+            viewer: viewer,
+            pos3d: pos3d,
+            terrainId: view_utils_1.ViewUtils.GetTerrainCacheId(viewer)
+        });
+        if (isNaN(offset)) {
+            return null;
+        }
+        const carto = Cesium.Cartographic.fromCartesian(pos3d);
+        if (!carto) {
+            return pos3d;
+        }
+        carto.height = offset;
+        return Cesium.Cartographic.toCartesian(carto);
+    }
+    CesiumAnimatedProperty.GetDrawnHeightPos3d = GetDrawnHeightPos3d;
     function GetSeriesPossesForHistoricEntity(viewer, dataHeightRef, heightRef, historic) {
+        var _a;
         if (!historic || !historic.length) {
             return [];
         }
@@ -925,7 +1070,7 @@ var CesiumAnimatedProperty;
             if (!dateTime || !dateTime.getTime()) {
                 continue;
             }
-            const pos3d = entity_utils_1.EntityUtils.GetPos({
+            let pos3d = entity_utils_1.EntityUtils.GetPos({
                 entity: data,
                 viewer: viewer,
                 recordHeightRef: dataHeightRef,
@@ -935,13 +1080,18 @@ var CesiumAnimatedProperty;
             if (!pos3d || isNaN(pos3d.x) || isNaN(pos3d.y) || isNaN(pos3d.z)) {
                 continue;
             }
+            pos3d = GetDrawnHeightPos3d(viewer, pos3d, heightRef);
+            if (!pos3d) {
+                // Ground not resolved yet. A later pass re-reads the records and will place it.
+                continue;
+            }
+            const transform = (_a = data.Bruce) === null || _a === void 0 ? void 0 : _a.Transform;
             series.push({
                 dateTime,
                 pos3d: pos3d,
-                heading: bruce_models_1.Entity.GetValue({
-                    entity: data,
-                    path: ["Bruce", "Transform", "Heading"]
-                })
+                heading: pick(transform, "heading", "Heading"),
+                pitch: pick(transform, "pitch", "Pitch"),
+                roll: pick(transform, "roll", "Roll")
             });
         }
         return series;
@@ -949,6 +1099,7 @@ var CesiumAnimatedProperty;
     CesiumAnimatedProperty.GetSeriesPossesForHistoricEntity = GetSeriesPossesForHistoricEntity;
     class AnimateTPositionSeries {
         constructor(params) {
+            this.lastCalcAttitude = null;
             // Cache for calculated values.
             this.lastCalcTime = null;
             this.lastCalcPos3d = null;
@@ -1017,6 +1168,21 @@ var CesiumAnimatedProperty;
                 maxDate: this.maxDate
             };
         }
+        /**
+         * Returns the positions a movement trail through this series should run through.
+         * The same window an Entity's own trail uses, so a root trail matches one drawn per Entity.
+         */
+        GetSeries() {
+            var _a, _b;
+            const viewerTime = this.viewer.scene.lastRenderTime || this.viewer.clock.currentTime;
+            const multiplier = (_b = (_a = this.viewer) === null || _a === void 0 ? void 0 : _a.clock) === null || _b === void 0 ? void 0 : _b.multiplier;
+            return TrailPositionsFrom({
+                positions: this.positions,
+                nowTimeMs: Cesium.JulianDate.toDate(viewerTime).getTime(),
+                ratePerSecondMs: multiplier == null || isNaN(multiplier) ? 1000 : Math.abs(multiplier) * 1000,
+                currentPos: this.lastCalcPos3d
+            });
+        }
         /**
          * Trigger the onRangeChange callback to request more data.
          */
@@ -1037,6 +1203,14 @@ var CesiumAnimatedProperty;
                 }
             }
         }
+        /*
+         * Returns the attitude of the record at an index, or nothing recorded when it names none.
+         */
+        attitudeAt(index) {
+            var _a, _b, _c;
+            const pos = index >= 0 ? (_a = this.positions) === null || _a === void 0 ? void 0 : _a[index] : null;
+            return { pitch: (_b = pos === null || pos === void 0 ? void 0 : pos.pitch) !== null && _b !== void 0 ? _b : null, roll: (_c = pos === null || pos === void 0 ? void 0 : pos.roll) !== null && _c !== void 0 ? _c : null };
+        }
         update() {
             if (!this.positions || this.positions.length === 0) {
                 return;
@@ -1051,7 +1225,8 @@ var CesiumAnimatedProperty;
             // Initialize if this is the first update.
             if (!this.lastCalcPos3d) {
                 this.lastCalcPos3d = targetPosition.pos3d;
-                this.onUpdate(targetPosition.pos3d, this.lastCalcHeading);
+                this.lastCalcAttitude = this.attitudeAt(targetPosition.indexLast);
+                this.onUpdate(targetPosition.pos3d, this.lastCalcHeading, this.lastCalcAttitude);
                 return;
             }
             // Check if target has changed.
@@ -1113,7 +1288,8 @@ var CesiumAnimatedProperty;
                 }
             }
             // Provide the calculated values to the caller.
-            this.onUpdate(pos3d, this.lastCalcHeading);
+            this.lastCalcAttitude = this.attitudeAt(targetPosition.indexLast);
+            this.onUpdate(pos3d, this.lastCalcHeading, this.lastCalcAttitude);
         }
         interpolatePos3dOverTime(startTimeMs, currentTimeMs) {
             const lastPos = this.lastCalcPos3d;