bruce-cesium 5.7.9 → 5.8.1

package/dist/lib/rendering/render-managers/tilesets/tileset-cad-render-manager.js

@@ -0,0 +1,861 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TilesetCadRenderManager = void 0;
+const bruce_models_1 = require("bruce-models");
+const Cesium = require("cesium");
+const tileset_render_engine_1 = require("../../tileset-render-engine");
+const js_utils_1 = require("../../../internal/js-utils");
+const shared_getters_1 = require("../../render-managers/common/shared-getters");
+const view_utils_1 = require("../../../utils/view-utils");
+const cesium_animated_property_1 = require("../../cesium-animated-property");
+const entity_utils_1 = require("../../../utils/entity-utils");
+function coordsFromHistoricEntity(entity) {
+    var _a;
+    if (!entity) {
+        return null;
+    }
+    const location = entity.Bruce.Location;
+    if (!location || !location.latitude || !location.longitude) {
+        return null;
+    }
+    const pos3d = Cesium.Cartesian3.fromDegrees(location.longitude, location.latitude, 0);
+    const heading = ((_a = entity.Bruce.Transform) === null || _a === void 0 ? void 0 : _a.heading) || 0;
+    return coordsFromHistoricPos3d(null, entity.Bruce.ID, pos3d, heading);
+}
+function coordsFromHistoricPos3d(cTileset, rootId, pos3d, heading) {
+    if (!pos3d) {
+        return null;
+    }
+    // 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 = Cesium.Cartographic.fromCartesian(pos3d);
+    const lat = Cesium.Math.toDegrees(location.latitude);
+    const lon = Cesium.Math.toDegrees(location.longitude);
+    const alt = location.height;
+    const prevCoords = cTileset === null || cTileset === void 0 ? void 0 : cTileset._bruceCoords;
+    const coords = {
+        "Entity.ID": null,
+        ...prevCoords,
+        transform: {
+            ...prevCoords === null || prevCoords === void 0 ? void 0 : prevCoords.transform,
+            heading: heading
+        },
+        ucs: {
+            name: null,
+            transform: null,
+            ...prevCoords === null || prevCoords === void 0 ? void 0 : prevCoords.ucs,
+            "Entity.ID": rootId,
+            location: {
+                altitude: alt,
+                latitude: lat,
+                longitude: lon
+            }
+        }
+    };
+    return coords;
+}
+/**
+ * Manager for rendering CAD tilesets.
+ * CAD tilesets are referred to as "MODEL" tilesets in some other areas of Bruce code.
+ */
+var TilesetCadRenderManager;
+(function (TilesetCadRenderManager) {
+    class Manager {
+        get Disposed() {
+            return this.disposed;
+        }
+        get ModelSpace() {
+            return this.modelSpace;
+        }
+        get Tileset() {
+            return this.cTileset;
+        }
+        get Styler() {
+            return this.styler;
+        }
+        constructor(params) {
+            this.disposed = false;
+            this.modelSpace = false;
+            this.cTileset = null;
+            this.styler = new tileset_render_engine_1.TilesetRenderEngine.Styler();
+            // Quick look-up of the model tree nodes by entity/geomId.
+            // Saves us from recursing the model tree for every feature.
+            this.treeNodeByGeomId = null;
+            this.treeNodeByEntityId = null;
+            // Cache of 'something isolated' that we detect and use to calculate a default show state.
+            // It's pretty expensive so we save it for a few seconds inbetween checks.
+            this.somethingIsolated = null;
+            this.somethingIsolatedDateTime = null;
+            // Entity ID -> rego.
+            // We retain this information as a quick look-up on what has been registered.
+            // This lets us properly assign siblings to the same rego when hierarchy items are marked as collapsed.
+            this.loadedCesiumEntities = {};
+            // Callback to dispose the link between scene time and the root's historic position.
+            this.viewerDateTimeChangeRemoval = null;
+            // Series of points to help interpolate movement when the timeline changes.
+            this.historicPossesInitialLoaded = false;
+            this.historicAnimation = null;
+            this.historicPossesLoadingProm = null;
+            const { viewer, register: visualsManager, getters, item, modelSpace } = params;
+            this.viewer = viewer;
+            this.getters = getters;
+            this.item = item;
+            this.visualsManager = visualsManager;
+            this.modelSpace = Boolean(modelSpace);
+        }
+        Init() {
+            var _a, _b;
+            const tilesetId = (_a = this.item.tileset) === null || _a === void 0 ? void 0 : _a.TilesetID;
+            if (!tilesetId) {
+                return;
+            }
+            let accountId = (_b = this.item.tileset) === null || _b === void 0 ? void 0 : _b.ClientAccountID;
+            if (!accountId) {
+                accountId = this.getters.GetAccountId();
+            }
+            this.renderPriority = this.item.renderPriority;
+            if (this.renderPriority == null) {
+                this.renderPriority = 0;
+            }
+            (async () => {
+                var _a;
+                const api = this.getters.GetBruceApi({
+                    accountId: accountId
+                });
+                let coords = null;
+                let tileset = null;
+                // Single shared getter to avoid multiple assemblies fighting to render.
+                // This lets one complete, then the next start.
+                await shared_getters_1.SharedGetters.Queue.Run("Rendering assembly.", async () => {
+                    var _a;
+                    if (this.disposed) {
+                        return;
+                    }
+                    if (tilesetId) {
+                        let canAccess = false;
+                        try {
+                            canAccess = await bruce_models_1.Tileset.Publish.IsAccessAllowed({
+                                sourceAccountId: accountId,
+                                tilesetId: tilesetId,
+                                forAccountId: this.getters.GetAccountId(),
+                                getters: this.getters
+                            });
+                            if (this.disposed) {
+                                return;
+                            }
+                        }
+                        catch (e) {
+                            console.error(e);
+                        }
+                        if (!canAccess) {
+                            console.warn(`Cannot access tileset: ${tilesetId}, from account: ${accountId}.`);
+                            return;
+                        }
+                    }
+                    else {
+                        console.warn("No tileset id found. Skipping access check.");
+                    }
+                    tileset = (await bruce_models_1.Tileset.Get({
+                        api,
+                        tilesetId
+                    })).tileset;
+                    if (!tileset || this.disposed) {
+                        return;
+                    }
+                    const settings = tileset.settings;
+                    const rootId = settings.rootEntityId;
+                    this.rootId = rootId;
+                    // If historic, we'll see if the root Entity has a historic position to use.
+                    if (((_a = this.item.BruceEntity) === null || _a === void 0 ? void 0 : _a.historic) && rootId) {
+                        try {
+                            const { entity: root } = await bruce_models_1.Entity.Get({
+                                entityId: rootId,
+                                historicPoint: this.viewer.clock.currentTime.toString(),
+                                api: api
+                            });
+                            coords = coordsFromHistoricEntity(root);
+                        }
+                        catch (e) {
+                            console.error(e);
+                        }
+                    }
+                    if (this.disposed) {
+                        return;
+                    }
+                    // Default process.
+                    if (!coords) {
+                        coords = (await bruce_models_1.EntityCoords.GetEntityCoords({
+                            api,
+                            rootEntityId: rootId
+                        })).coords;
+                    }
+                    if (this.disposed) {
+                        return;
+                    }
+                });
+                if (!tileset || this.disposed) {
+                    return;
+                }
+                // Get the model tree if it's in a separate file.
+                // There is a setting that is more explicit but it's lying on the file name so can't trust it yet.
+                if (((_a = tileset.settings) === null || _a === void 0 ? void 0 : _a["tilesetVersion"]) > 1) {
+                    try {
+                        const modelTreeUrl = bruce_models_1.Tileset.GetFileUrl({
+                            api: api,
+                            file: "model_tree.json",
+                            tilesetId: tileset.id,
+                            cacheToken: tileset.generateVersion,
+                            viaCdn: Boolean(this.item.cdnEnabled == null ? true : this.item.cdnEnabled)
+                        });
+                        this.modelTree = await api.get(modelTreeUrl);
+                    }
+                    catch (e) {
+                        console.error(e);
+                    }
+                }
+                if (this.disposed) {
+                    return;
+                }
+                // Render outside the shared process because we can't control file requests from Cesium.
+                const cTileset = this.cTileset = await tileset_render_engine_1.TilesetRenderEngine.Render({
+                    apiGetter: this.getters.GetBruceGetter(),
+                    tileset: tileset,
+                    viewer: this.viewer,
+                    coords: coords,
+                    accountId: accountId,
+                    viaCdn: Boolean(this.item.cdnEnabled == null ? true : this.item.cdnEnabled),
+                    noMemoryLimit: this.item["noMaximumMemory"],
+                    modelSpace: this.modelSpace
+                });
+                if (this.disposed) {
+                    this.doDispose();
+                    return;
+                }
+                this.viewer.scene.requestRender();
+                tileset_render_engine_1.TilesetRenderEngine.OnTilesetReady(this.cTileset).then(() => {
+                    var _a, _b, _c;
+                    try {
+                        if (this.disposed || cTileset.isDestroyed()) {
+                            return;
+                        }
+                        // We style Entities to be hidden by default so that we can selectively-
+                        // do a default later.
+                        // This stops them flickering in/out as Bookmark settings get applied.
+                        if (this.visualsManager.GetIsIsolatedAny()) {
+                            // This is causing a bug where tileset features never appear.
+                            // Need to investigate further, until then, we'll use the above check to avoid running it sometimes.
+                            this.cTileset.style = new Cesium.Cesium3DTileStyle({
+                                show: "false"
+                            });
+                        }
+                        this.onCTilesetLoad();
+                        this.styler.Init({
+                            viewer: this.viewer,
+                            // Default API instead of the account one.
+                            // Records are driven by the account loading it instead of the source account.
+                            api: this.getters.GetBruceApi(),
+                            cTileset: this.cTileset,
+                            fallbackStyleId: this.item.styleId,
+                            styleMapping: this.item.StyleMapping,
+                            expandSources: (_a = this.item.BruceEntity) === null || _a === void 0 ? void 0 : _a.ExpandSources,
+                            menuItemId: this.item.id,
+                            register: this.visualsManager,
+                            scenario: (_b = this.item.BruceEntity) === null || _b === void 0 ? void 0 : _b.Scenario,
+                            historic: (_c = this.item.BruceEntity) === null || _c === void 0 ? void 0 : _c.historic,
+                        });
+                        this.viewer.scene.requestRender();
+                        // Monitor scene time changes and update the root Entity.
+                        this.viewerDateTimeSub(tileset);
+                    }
+                    catch (e) {
+                        console.error(e);
+                    }
+                });
+                cTileset.tileLoad.addEventListener((tile) => {
+                    try {
+                        this.mapCTile(tile, true);
+                    }
+                    catch (e) {
+                        console.error(e);
+                    }
+                });
+                cTileset.tileUnload.addEventListener((tile) => {
+                    try {
+                        this.mapCTile(tile, false);
+                    }
+                    catch (e) {
+                        console.error(e);
+                    }
+                });
+            })();
+        }
+        onCTilesetLoad() {
+            if (this.item.StyleBlending) {
+                let blending = this.item.StyleBlending;
+                this.cTileset.colorBlendMode = (0, js_utils_1.EnsureNumber)(blending === null || blending === void 0 ? void 0 : blending.blendMode, Cesium.Cesium3DTileColorBlendMode.MIX);
+                this.cTileset.colorBlendAmount = (0, js_utils_1.EnsureNumber)(blending === null || blending === void 0 ? void 0 : blending.blendPercent, 0.9);
+            }
+            if (this.item.FlyTo) {
+                this.viewer.zoomTo(this.cTileset, new Cesium.HeadingPitchRange(0.0, -0.5, this.cTileset.boundingSphere.radius / 4.0));
+            }
+        }
+        /**
+         * @param tile
+         * @param load indicates if we are loading or unloading the tile.
+         * @returns
+         */
+        mapCTile(tile, load) {
+            const content = tile === null || tile === void 0 ? void 0 : tile.content;
+            if (!content) {
+                return;
+            }
+            const regosToQueue = new Map();
+            for (let i = 0; i < content.featuresLength; i++) {
+                const feature = content.getFeature(i);
+                let rego = this.mapTilesetFeature(feature, load);
+                if (!(rego === null || rego === void 0 ? void 0 : rego.entityId)) {
+                    // Override the default hide state set by the style.
+                    feature.show = true;
+                    continue;
+                }
+                regosToQueue.set(rego.entityId, rego);
+            }
+            if (this.styler && regosToQueue.size) {
+                this.styler.QueueEntities(Array.from(regosToQueue.values()));
+            }
+            this.viewer.scene.requestRender();
+        }
+        /**
+         * @param feature
+         * @param add indicates if we are adding or removing the feature.
+         * @returns
+         */
+        mapTilesetFeature(feature, add) {
+            var _a, _b, _c, _d, _e, _f;
+            const accountId = (_b = ((_a = this.item.tileset) === null || _a === void 0 ? void 0 : _a.ClientAccountID)) !== null && _b !== void 0 ? _b : this.getters.GetAccountId();
+            const canEdit = accountId === this.getters.GetAccountId() && !this.modelSpace && !((_c = this.item.BruceEntity) === null || _c === void 0 ? void 0 : _c.historic);
+            let rego = {
+                canEdit: canEdit,
+                entityId: null,
+                entityTypeId: null,
+                menuItemId: this.item.id,
+                menuItemType: this.item.Type,
+                priority: this.renderPriority,
+                visual: feature,
+                accountId: accountId,
+                tilesetId: (_d = this.item.tileset) === null || _d === void 0 ? void 0 : _d.TilesetID,
+                tilesetType: bruce_models_1.Tileset.EType.Cad,
+                rootId: this.rootId
+            };
+            const featureAny = feature;
+            const propertyNames = featureAny.getPropertyNames ? featureAny.getPropertyNames() : (_e = featureAny.getPropertyIds) === null || _e === void 0 ? void 0 : _e.call(featureAny);
+            if (!propertyNames) {
+                return null;
+            }
+            const setByGeomId = () => {
+                const geomIdProp = propertyNames.find(x => String(x).toLowerCase() == "geomid");
+                if (geomIdProp) {
+                    const geomId = +feature.getProperty(geomIdProp);
+                    if (geomId != null && (!!geomId || geomId == 0)) {
+                        const meta = this.getMetaByGeomId(geomId, feature.tileset);
+                        if (meta) {
+                            rego.entityId = meta.entityId;
+                            rego.entityTypeId = meta.typeId;
+                            rego.name = meta.name;
+                        }
+                    }
+                }
+            };
+            const setByEntityId = () => {
+                const bruceIdProp = propertyNames.find(x => (String(x).toLowerCase() == "bruceid"));
+                if (bruceIdProp) {
+                    rego.entityId = feature.getProperty(bruceIdProp);
+                }
+            };
+            const setByPath = () => {
+                const brucePathProp = propertyNames.find(x => String(x).toLowerCase() == "brucepath");
+                if (brucePathProp) {
+                    const pathStr = feature.getProperty(brucePathProp);
+                    if (pathStr) {
+                        let path = pathStr.split("|");
+                        let entityTypeId = this.getEntityTypeByPath(path);
+                        rego.entityTypeId = entityTypeId;
+                        rego.entityId = path[path.length - 1];
+                    }
+                }
+            };
+            setByGeomId();
+            if (!rego.entityId) {
+                setByEntityId();
+            }
+            if (!rego.entityId) {
+                setByPath();
+            }
+            if (!rego.entityId) {
+                return null;
+            }
+            // Optional menu item restriction.
+            // Allows only showing certain entities from a tileset.
+            const onlyIds = (_f = this.item.BruceEntity) === null || _f === void 0 ? void 0 : _f.EntityIds;
+            if ((onlyIds === null || onlyIds === void 0 ? void 0 : onlyIds.length) && !onlyIds.includes(rego.entityId)) {
+                if (this.item.BruceEntity.Ghosts) {
+                    feature.color = Cesium.Color.WHITE.clone().withAlpha(0.5);
+                }
+                else {
+                    feature.show = false;
+                }
+                return null;
+            }
+            if (add) {
+                // Get the initial hide/show state.
+                const state = this.visualsManager.GetState({
+                    entityId: rego.entityId,
+                    menuItemId: this.item.id,
+                });
+                if (this.somethingIsolated == null ||
+                    // 5s cache.
+                    (this.somethingIsolatedDateTime && this.somethingIsolatedDateTime.getTime() + 5000 < new Date().getTime())) {
+                    this.somethingIsolated = this.visualsManager.GetIsIsolatedAny();
+                    this.somethingIsolatedDateTime = new Date();
+                }
+                // Override the default hide state set by the style.
+                let hide = false;
+                if (state) {
+                    if (state.hidden) {
+                        hide = true;
+                    }
+                    else if (state.opacity === 0) {
+                        hide = true;
+                    }
+                    else if (!state.isolated && this.somethingIsolated) {
+                        hide = true;
+                    }
+                }
+                feature.show = !hide;
+                // Already exists, so we add this graphic as a sibling.
+                if (this.loadedCesiumEntities[rego.entityId]) {
+                    rego = this.loadedCesiumEntities[rego.entityId];
+                    if (!rego.visual) {
+                        // No parent graphic.
+                        rego.visual = feature;
+                    }
+                    else if (rego.visual == feature) {
+                        // Same graphic. Nothing to do.
+                    }
+                    else {
+                        const visual = rego.visual;
+                        // Sibling graphic.
+                        if (!visual._siblingGraphics) {
+                            visual._siblingGraphics = [];
+                        }
+                        if (visual._siblingGraphics.indexOf(feature) < 0) {
+                            visual._siblingGraphics.push(feature);
+                        }
+                    }
+                }
+                this.loadedCesiumEntities[rego.entityId] = rego;
+                this.visualsManager.AddRego({
+                    rego,
+                    requestRender: false
+                });
+                return rego;
+            }
+            else {
+                this.visualsManager.RemoveRegos({
+                    entityId: rego.entityId,
+                    requestRender: false,
+                    menuItemId: this.item.id,
+                    doRemove: false
+                });
+                // Might have to do something smarter since siblings could still be OK.
+                this.loadedCesiumEntities[rego.entityId] = null;
+                delete this.loadedCesiumEntities[rego.entityId];
+            }
+        }
+        getMetaByGeomId(geomId, tileset) {
+            var _a;
+            if (this.treeNodeByGeomId == null) {
+                let modelTree = (_a = tileset === null || tileset === void 0 ? void 0 : tileset.extensions) === null || _a === void 0 ? void 0 : _a.modelTree;
+                // Wasn't inside tileset.json and instead in a separate file.
+                if (!modelTree) {
+                    modelTree = this.modelTree;
+                }
+                if (!modelTree) {
+                    return null;
+                }
+                this.buildModelTreeNodes(modelTree);
+            }
+            return this.treeNodeByGeomId[geomId] || null;
+        }
+        /**
+         * Builds quick look-up of the model tree nodes by geomId.
+         * @param modelTree
+         */
+        buildModelTreeNodes(modelTree) {
+            this.treeNodeByGeomId = {};
+            this.treeNodeByEntityId = {};
+            const recurse = (node, firstFoundCollapsedBranch) => {
+                if (firstFoundCollapsedBranch) {
+                    this.treeNodeByGeomId[node.geomId] = firstFoundCollapsedBranch;
+                    this.treeNodeByEntityId[node.id] = firstFoundCollapsedBranch;
+                }
+                else {
+                    const cache = {
+                        entityId: node.id,
+                        typeId: node.typeId,
+                        name: node.name,
+                        geomId: node.geomId
+                    };
+                    this.treeNodeByGeomId[node.geomId] = cache;
+                    this.treeNodeByEntityId[node.id] = cache;
+                    if (!firstFoundCollapsedBranch && node.collapsed) {
+                        firstFoundCollapsedBranch = cache;
+                    }
+                }
+                if (node.children) {
+                    for (let i = 0; i < node.children.length; i++) {
+                        recurse(node.children[i], firstFoundCollapsedBranch);
+                    }
+                }
+            };
+            recurse(modelTree, null);
+        }
+        getEntityTypeByPath(path) {
+            var _a, _b;
+            const entityId = path[path.length - 1];
+            if (this.treeNodeByEntityId == null) {
+                let modelTree = (_b = (_a = this.cTileset) === null || _a === void 0 ? void 0 : _a.extensions) === null || _b === void 0 ? void 0 : _b.modelTree;
+                // Wasn't inside tileset.json and instead in a separate file.
+                if (!modelTree) {
+                    modelTree = this.modelTree;
+                }
+                if (!modelTree) {
+                    return null;
+                }
+                this.buildModelTreeNodes(modelTree);
+            }
+            const node = this.treeNodeByEntityId[entityId] || null;
+            return node ? node.typeId : null;
+        }
+        Dispose() {
+            if (this.disposed) {
+                return;
+            }
+            this.disposed = true;
+            this.doDispose();
+        }
+        doDispose() {
+            var _a, _b;
+            if (this.cTileset) {
+                const viewer = this.viewer;
+                if (!(viewer === null || viewer === void 0 ? void 0 : viewer.isDestroyed()) && this.viewer.scene.primitives.contains(this.cTileset)) {
+                    this.cTileset.show = false;
+                    this.viewer.scene.primitives.remove(this.cTileset);
+                    (_a = tileset_render_engine_1.TilesetRenderEngine.GetMemoryWatcher(viewer)) === null || _a === void 0 ? void 0 : _a.Unwatch(this.cTileset);
+                    this.viewer.scene.requestRender();
+                }
+                this.cTileset = null;
+            }
+            (_b = this.styler) === null || _b === void 0 ? void 0 : _b.Dispose();
+            this.visualsManager.RemoveRegos({
+                menuItemId: this.item.id,
+                doRemove: false
+            });
+            this.viewerDateTimeDispose();
+        }
+        async ReRender(params) {
+            let { entityIds, force, entities } = params;
+            if (entities && !entityIds) {
+                entityIds = entities.map(x => { var _a; return (_a = x.Bruce) === null || _a === void 0 ? void 0 : _a.ID; });
+            }
+            if (!this.styler) {
+                return;
+            }
+            let regos = this.visualsManager.GetRegos({
+                menuItemId: this.item.id
+            });
+            if (entityIds != null) {
+                regos = regos.filter(r => entityIds.indexOf(r.entityId) >= 0);
+            }
+            // Update the cache so we use that data instead of requesting the records.
+            this.styler.SetEntityCache(entityIds, entities);
+            this.styler.QueueEntities(regos, true);
+        }
+        /**
+         * Monitors the Cesium Viewer and updates the root Entity based on the scene time changing.
+         * If the root Entity is historic, this can allow for movement of the assembly as a whole.
+         * @param tileset
+         */
+        viewerDateTimeSub(tileset) {
+            var _a, _b;
+            if (!((_a = this.item.BruceEntity) === null || _a === void 0 ? void 0 : _a.historic) || this.viewerDateTimeChangeRemoval) {
+                return;
+            }
+            let accountId = (_b = this.item.tileset) === null || _b === void 0 ? void 0 : _b.ClientAccountID;
+            if (!accountId) {
+                accountId = this.getters.GetAccountId();
+            }
+            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();
+            /**
+             * Returns a list of historic positions for a given time range.
+             * @param startStr
+             * @param stopStr
+             * @returns
+             */
+            const getPossesForRange = async (startStr, stopStr) => {
+                const requestKey = `${startStr}-${stopStr}`;
+                if (pendingRequests.has(requestKey)) {
+                    return pendingRequests.get(requestKey);
+                }
+                const requestPromise = new Promise(async (res) => {
+                    try {
+                        const historicData = await bruce_models_1.EntityHistoricData.GetList({
+                            attrKey: null,
+                            dateTimeFrom: startStr,
+                            dateTimeTo: stopStr,
+                            entityIds: [this.rootId],
+                            api: api
+                        });
+                        const posses = cesium_animated_property_1.CesiumAnimatedProperty.GetSeriesPossesForHistoricEntity(this.viewer, Cesium.HeightReference.NONE, Cesium.HeightReference.CLAMP_TO_GROUND, historicData.recordsByIds[this.rootId]);
+                        res(posses);
+                    }
+                    catch (e) {
+                        console.error(e);
+                        res([]);
+                    }
+                    finally {
+                        pendingRequests.delete(requestKey);
+                    }
+                });
+                pendingRequests.set(requestKey, requestPromise);
+                return requestPromise;
+            };
+            /**
+             * Checks if the current timeline range is not fully loaded and requests the difference.
+             * This will call getPossesForRange() if it needs more data.
+             * @returns
+             */
+            const checkTimelineRange = async () => {
+                // 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.historicPossesInitialLoaded &&
+                    foundMinDateTime &&
+                    foundMaxDateTime &&
+                    minDateTime >= foundMinDateTime &&
+                    maxDateTime <= foundMaxDateTime) {
+                    return;
+                }
+                const tDetails = view_utils_1.ViewUtils.GetTimeDetails({
+                    viewer: this.viewer,
+                });
+                const isLive = tDetails.isLive;
+                // See if the requested range is before or after the range we have.
+                const fetchBefore = !foundMinDateTime || (!isLive && 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 (!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;
+                    }
+                    if (this.historicAnimation && this.historicAnimation.addPositions) {
+                        this.historicAnimation.addPositions(newPositions);
+                    }
+                }
+                else {
+                    // The data we want is before the range we've currently loaded.
+                    if (fetchBefore) {
+                        // Calculate the missing difference and request it.
+                        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;
+                            }
+                            if (this.historicAnimation && this.historicAnimation.addPositions) {
+                                this.historicAnimation.addPositions(newPositions);
+                            }
+                        });
+                    }
+                    // The data we want is after the range we've currently loaded.
+                    if (fetchAfter) {
+                        // Calculate the missing difference and request it.
+                        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;
+                            }
+                            if (this.historicAnimation && this.historicAnimation.addPositions) {
+                                this.historicAnimation.addPositions(newPositions);
+                            }
+                        });
+                    }
+                }
+            };
+            /**
+             * Requests the initial set of historic positions for the timeline range.
+             * This is called when the tileset is loaded and the timeline range is set.
+             * @returns
+             */
+            const getInitialPosses = async () => {
+                this.historicPossesLoadingProm = new Promise(async (res) => {
+                    try {
+                        if (this.disposed) {
+                            res(false);
+                            return;
+                        }
+                        const startTmp = Cesium.JulianDate.toDate(this.viewer.clock.startTime);
+                        const stopTmp = Cesium.JulianDate.toDate(this.viewer.clock.stopTime);
+                        const startStr = new Date(startTmp.getTime() - 1000).toISOString();
+                        const stopStr = new Date(stopTmp.getTime() + 1000).toISOString();
+                        const positions = await getPossesForRange(startStr, stopStr);
+                        if (this.disposed) {
+                            res(false);
+                            return;
+                        }
+                        // Also request the current position in case its not in the range.
+                        const { entity } = await bruce_models_1.Entity.Get({
+                            entityId: this.rootId,
+                            historicPoint: this.viewer.clock.currentTime.toString(),
+                            api: api
+                        });
+                        if (this.disposed || !entity) {
+                            res(false);
+                            return;
+                        }
+                        const historicDetails = entity.Bruce.Outline ? entity.Bruce.Outline.find(x => !!x.DateTime) : null;
+                        if (historicDetails) {
+                            const pos3d = entity_utils_1.EntityUtils.GetPos({
+                                entity: entity,
+                                viewer: this.viewer,
+                                recordHeightRef: Cesium.HeightReference.NONE,
+                                returnHeightRef: Cesium.HeightReference.CLAMP_TO_GROUND,
+                                allowRendered: false
+                            });
+                            if (pos3d && !isNaN(pos3d.x) && !isNaN(pos3d.y) && !isNaN(pos3d.z)) {
+                                positions.push({
+                                    dateTime: new Date(historicDetails.DateTime),
+                                    pos3d: pos3d,
+                                    heading: null
+                                });
+                            }
+                        }
+                        this.historicPossesInitialLoaded = true;
+                        res(positions);
+                    }
+                    catch (e) {
+                        console.error(e);
+                        res(false);
+                    }
+                });
+                return await this.historicPossesLoadingProm;
+            };
+            // Last known timeline range. Helps us detect changes.
+            let lastStartTime = this.viewer.clock.startTime.toString();
+            let lastStopTime = this.viewer.clock.stopTime.toString();
+            let clockTickRemoval;
+            getInitialPosses().then((posses) => {
+                if (this.disposed || posses === false) {
+                    return;
+                }
+                // Generate animation utility for the initial set of positions.
+                this.historicAnimation = new cesium_animated_property_1.CesiumAnimatedProperty.AnimateTPositionSeries({
+                    viewer: this.viewer,
+                    posses: posses,
+                    onUpdate: (pos3d, heading) => {
+                        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;
+                        }
+                        const coords = coordsFromHistoricPos3d(this.cTileset, this.rootId, pos3d, heading);
+                        this.applyCoords(tileset, coords);
+                    },
+                    onRangeChange: () => {
+                        checkTimelineRange();
+                    },
+                    onDone: () => {
+                        if (this.viewerDateTimeChangeRemoval) {
+                            this.viewerDateTimeChangeRemoval();
+                            this.viewerDateTimeChangeRemoval = null;
+                        }
+                    }
+                });
+                // When the clock changes we'll see if the range is different and queue a request for the difference.
+                clockTickRemoval = this.viewer.clock.onTick.addEventListener(() => {
+                    const startTime = this.viewer.clock.startTime.toString();
+                    const stopTime = this.viewer.clock.stopTime.toString();
+                    if (startTime !== lastStartTime || stopTime !== lastStopTime) {
+                        lastStartTime = startTime;
+                        lastStopTime = stopTime;
+                        this.historicAnimation.onRangeChange();
+                    }
+                });
+                this.viewerDateTimeChangeRemoval = () => {
+                    if (this.historicAnimation) {
+                        this.historicAnimation.stop();
+                        this.historicAnimation = null;
+                    }
+                    if (clockTickRemoval) {
+                        clockTickRemoval();
+                        clockTickRemoval = null;
+                    }
+                };
+            });
+        }
+        viewerDateTimeDispose() {
+            var _a;
+            (_a = this.viewerDateTimeChangeRemoval) === null || _a === void 0 ? void 0 : _a.call(this);
+            this.viewerDateTimeChangeRemoval = null;
+        }
+        /**
+         * Updates the Tileset with latest coordinates.
+         * This is used to refresh with new values, not to render the first time!
+         * @param tileset
+         * @param coords
+         */
+        applyCoords(tileset, coords) {
+            if (this.disposed || !this.cTileset || this.cTileset.isDestroyed()) {
+                return;
+            }
+            const settings = tileset.settings;
+            tileset_render_engine_1.TilesetRenderEngine.ApplyPosition({
+                cTileset: this.Tileset,
+                position: {
+                    ucs: coords === null || coords === void 0 ? void 0 : coords.ucs,
+                    location: (coords === null || coords === void 0 ? void 0 : coords.location) == null ? settings.location : coords.location,
+                    transform: (coords === null || coords === void 0 ? void 0 : coords.transform) == null ? settings.transform : coords.transform
+                }
+            });
+            this.viewer.scene.requestRender();
+        }
+    }
+    TilesetCadRenderManager.Manager = Manager;
+})(TilesetCadRenderManager = exports.TilesetCadRenderManager || (exports.TilesetCadRenderManager = {}));
+//# sourceMappingURL=tileset-cad-render-manager.js.map