bruce-cesium 5.7.9 → 5.8.1

package/dist/lib/rendering/visuals-register.js

@@ -0,0 +1,1741 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VisualsRegister = void 0;
+const bruce_models_1 = require("bruce-models");
+const Cesium = require("cesium");
+const js_utils_1 = require("../internal/js-utils");
+const entity_utils_1 = require("../utils/entity-utils");
+const relation_render_engine_1 = require("./relation-render-engine");
+const entity_label_1 = require("../rendering/render-managers/common/entity-label");
+const visual_register_culler_1 = require("./visual-register-culler");
+const cesium_entity_styler_1 = require("../utils/cesium-entity-styler");
+const cesium_animated_in_out_1 = require("./cesium-animated-in-out");
+/**
+ * Returns if a given visual is alive and in the scene.
+ * @param viewer
+ * @param visual
+ * @returns
+ */
+function isAlive(viewer, visual) {
+    if (!(viewer === null || viewer === void 0 ? void 0 : viewer.scene) || viewer.isDestroyed()) {
+        return false;
+    }
+    if (visual instanceof Cesium.Entity) {
+        return viewer.entities.contains(visual);
+    }
+    else if (visual instanceof Cesium.Primitive) {
+        return viewer.scene.primitives.contains(visual);
+    }
+    else if (visual instanceof Cesium.Cesium3DTileFeature) {
+        const cTileset = visual === null || visual === void 0 ? void 0 : visual.tileset;
+        if (!cTileset) {
+            return false;
+        }
+        if (cTileset.isDestroyed() || !viewer.scene.primitives.contains(cTileset)) {
+            return false;
+        }
+        return true;
+    }
+    return false;
+}
+function removeEntity(viewer, visual) {
+    unmarkEntity(visual, false);
+    cesium_animated_in_out_1.CesiumAnimatedInOut.AnimateOut({
+        entity: visual,
+        viewer
+    });
+}
+const MAX_SHOW_DEPTH = 10;
+function updateCEntityShow(viewer, visual, rego, show, ignoreParent, depth = 0) {
+    if (depth > MAX_SHOW_DEPTH) {
+        console.warn("updateCEntityShow(): Max show depth reached. EntityId = " + rego.entityId);
+        return;
+    }
+    // A sub-object can be culled while the siblings are not.
+    // We only cull things that give us some benefit. For example clamped to ground graphics are expensive to keep rendered.
+    show = show ? !visual_register_culler_1.VisualRegisterCuller.IsCulled(viewer, rego, visual) : false;
+    if (visual._parentEntity && !ignoreParent) {
+        updateCEntityShow(viewer, visual._parentEntity, rego, show, false, depth + 1);
+    }
+    if (visual._siblingGraphics) {
+        for (let i = 0; i < visual._siblingGraphics.length; i++) {
+            const sibling = visual._siblingGraphics[i];
+            updateCEntityShow(viewer, sibling, rego, show, true, depth + 1);
+        }
+    }
+    /**
+     * Do NOT use ".show" as it causes crashes in Cesium polylines that are clamped to ground.
+     * We could target them specifically here but we may be getting overall performance gain by just removing stuff from the scene.
+     */
+    if (rego.collection) {
+        if (!show && rego.collection.contains(visual)) {
+            rego.collection.remove(visual);
+        }
+        else if (show && !rego.collection.contains(visual)) {
+            rego.collection.add(visual);
+        }
+    }
+    else {
+        if (!show && viewer.entities.contains(visual)) {
+            viewer.entities.remove(visual);
+        }
+        else if (show && !viewer.entities.contains(visual)) {
+            viewer.entities.add(visual);
+        }
+    }
+}
+function updateEntityShow(viewer, rego, show) {
+    const visual = rego.visual;
+    if (visual instanceof Cesium.Entity) {
+        if (!(viewer === null || viewer === void 0 ? void 0 : viewer.scene) || viewer.isDestroyed()) {
+            return;
+        }
+        updateCEntityShow(viewer, rego.visual, rego, show, false, 0);
+        return;
+    }
+    if (!isAlive(viewer, visual)) {
+        return;
+    }
+    if (visual instanceof Cesium.Primitive) {
+        if (viewer.scene.primitives.contains(visual)) {
+            visual.show = show;
+        }
+    }
+    else if (visual instanceof Cesium.Cesium3DTileFeature) {
+        // No way to tell if changing show will crash it!
+        // ^ We need to improve removing visuals from the register when tiles unload to avoid this :)
+        try {
+            visual.show = show;
+        }
+        catch (e) {
+            console.error(e);
+        }
+        const ent = visual;
+        if (ent._siblingGraphics) {
+            for (let i = 0; i < ent._siblingGraphics.length; i++) {
+                try {
+                    const sibling = ent._siblingGraphics[i];
+                    sibling.show = show;
+                }
+                catch (e) {
+                    console.error(e);
+                }
+            }
+        }
+    }
+}
+function updateEntity(viewer, entityId, register, refresh, cache = {}) {
+    var _a;
+    // Unavailable for unoptimized single-Entity updates.
+    if (!cache) {
+        cache = {};
+    }
+    let regos = register.GetRegos({
+        entityId
+    });
+    regos.sort((a, b) => {
+        return b.priority - a.priority;
+    });
+    let highestPriority = (_a = regos[0]) === null || _a === void 0 ? void 0 : _a.priority;
+    if (!highestPriority) {
+        highestPriority = 0;
+    }
+    function getShowState(rego, state) {
+        if (state.hidden) {
+            return false;
+        }
+        else if (!state.isolated) {
+            if (cache.isIsolatedAny == null) {
+                cache.isIsolatedAny = register.GetIsIsolatedAny();
+            }
+            if (cache.isIsolatedAny) {
+                return false;
+            }
+        }
+        // We show all regos in the same highest priority level.
+        // So if a new visual is added that's higher priority, all lower ones get hidden.
+        // By default, everything has 0 priority unless explicitly set.
+        const priority = rego.priority ? rego.priority : 0;
+        return priority >= highestPriority;
+    }
+    for (let i = 0; i < regos.length; i++) {
+        const rego = regos[i];
+        const state = register.GetState({
+            entityId: entityId,
+            menuItemId: rego.menuItemId
+        });
+        let visible = rego.overrideShow;
+        if (visible == null || visible === undefined) {
+            visible = getShowState(rego, state);
+        }
+        updateEntityShow(viewer, rego, visible);
+        if (visible) {
+            if (refresh === true || (refresh !== false && (refresh === null || refresh === void 0 ? void 0 : refresh.highlighted))) {
+                if (state.highlighted) {
+                    cesium_entity_styler_1.CesiumEntityStyler.Highlight({
+                        entity: rego.visual,
+                        viewer,
+                        requestRender: false
+                    });
+                }
+                else {
+                    cesium_entity_styler_1.CesiumEntityStyler.Unhighlight({
+                        entity: rego.visual,
+                        viewer,
+                        requestRender: false
+                    });
+                }
+            }
+            if (refresh === true || (refresh !== false && (refresh === null || refresh === void 0 ? void 0 : refresh.selected))) {
+                if (state.selected) {
+                    cesium_entity_styler_1.CesiumEntityStyler.Select({
+                        entity: rego.visual,
+                        viewer,
+                        requestRender: false
+                    });
+                }
+                else {
+                    cesium_entity_styler_1.CesiumEntityStyler.Deselect({
+                        entity: rego.visual,
+                        viewer,
+                        requestRender: false
+                    });
+                }
+            }
+            if (refresh === true || (refresh !== false && (refresh === null || refresh === void 0 ? void 0 : refresh.opacity))) {
+                if (state.opacity != null && state.opacity != 1) {
+                    entity_utils_1.EntityUtils.SetOpacity({
+                        entity: rego.visual,
+                        opacity: state.opacity,
+                        viewer: viewer,
+                        requestRender: false
+                    });
+                }
+                else {
+                    entity_utils_1.EntityUtils.RevertOpacity({
+                        entity: rego.visual,
+                        viewer: viewer,
+                        requestRender: false
+                    });
+                }
+            }
+        }
+        if (state.labelled && visible) {
+            entity_label_1.EntityLabel.Attach({
+                rego,
+                viewer,
+                api: register.ApiGetters.GetBruceApi(),
+                visualRegister: register
+            });
+        }
+        else {
+            entity_label_1.EntityLabel.Detatch({
+                rego
+            });
+        }
+    }
+}
+function markEntity(register, rego, visual, ignoreParent) {
+    const vis = visual;
+    vis._register = register;
+    vis._rego = rego;
+    if (visual instanceof Cesium.Entity) {
+        const visEnt = visual;
+        if (visEnt._parentEntity && !ignoreParent) {
+            markEntity(register, rego, visEnt._parentEntity, false);
+        }
+        if (visEnt._siblingGraphics) {
+            for (let i = 0; i < visEnt._siblingGraphics.length; i++) {
+                markEntity(register, rego, visEnt._siblingGraphics[i], true);
+            }
+        }
+    }
+    else if (visual instanceof Cesium.Cesium3DTileFeature) {
+        const visEnt = visual;
+        if (visEnt._siblingGraphics) {
+            for (let i = 0; i < visEnt._siblingGraphics.length; i++) {
+                markEntity(register, rego, visEnt._siblingGraphics[i], true);
+            }
+        }
+    }
+}
+function unmarkEntity(visual, ignoreParent) {
+    const vis = visual;
+    vis._register = null;
+    if (visual instanceof Cesium.Entity) {
+        const visEnt = visual;
+        if (visEnt._parentEntity && !ignoreParent) {
+            unmarkEntity(visEnt._parentEntity, false);
+        }
+        if (visEnt._siblingGraphics) {
+            for (let i = 0; i < visEnt._siblingGraphics.length; i++) {
+                unmarkEntity(visEnt._siblingGraphics[i], true);
+            }
+        }
+    }
+    else if (visual instanceof Cesium.Cesium3DTileFeature) {
+        const visEnt = visual;
+        if (visEnt._siblingGraphics) {
+            for (let i = 0; i < visEnt._siblingGraphics.length; i++) {
+                unmarkEntity(visEnt._siblingGraphics[i], true);
+            }
+        }
+    }
+}
+const NO_MENU_ITEM_KEY = "";
+function getBlankState(entityId, menuItemId) {
+    const state = {
+        entityId: entityId
+    };
+    if (menuItemId) {
+        state.menuItemId = menuItemId;
+    }
+    return state;
+}
+function isBlankState(state) {
+    const idKeys = !state.menuItemId ? 1 : 2;
+    return Object.keys(state).length === idKeys;
+}
+/**
+ * Manages a registry of all Bruce visuals being rendered by menu items.
+ */
+var VisualsRegister;
+(function (VisualsRegister) {
+    let EVisualUpdateType;
+    (function (EVisualUpdateType) {
+        EVisualUpdateType["Add"] = "ADD";
+        EVisualUpdateType["Remove"] = "REMOVE";
+        EVisualUpdateType["Update"] = "UPDATE";
+        EVisualUpdateType["DeselectAll"] = "DESELECT_ALL";
+    })(EVisualUpdateType = VisualsRegister.EVisualUpdateType || (VisualsRegister.EVisualUpdateType = {}));
+    class Register {
+        get Id() {
+            return this.id;
+        }
+        get Disposed() {
+            return this.disposed;
+        }
+        get Viewer() {
+            return this.viewer;
+        }
+        get ApiGetters() {
+            return this.apiGetters;
+        }
+        get OnUpdate() {
+            if (!this.onUpdate) {
+                this.onUpdate = new bruce_models_1.BruceEvent();
+            }
+            return this.onUpdate;
+        }
+        constructor(params) {
+            this.id = bruce_models_1.ObjectUtils.UId();
+            this.disposed = false;
+            this.rego = {};
+            this.onUpdate = null;
+            // Entity ID -> Menu Item ID -> State.
+            // When no Menu Item ID is set, then the second key is a blank string.
+            // If an Entity ID state is set without a Menu Item ID, then it acts as a default for all Menu Items.
+            this.states = {};
+            // Queue of Entity updates to process in batches to avoid overloading the render loop.
+            this.updateQueue = [];
+            // Settings related to those Entities in the queue.
+            // This lets us modify the update without re-adding the item to the queue if it's already in it.
+            this.updateQueueSettings = {};
+            this.updateQueueInterval = null;
+            this.viewer = params.viewer;
+            this.apiGetters = params.apiGetters;
+            this.cameraCullerDispose = visual_register_culler_1.VisualRegisterCuller.Monitor({
+                register: this
+            });
+        }
+        queueUpdate(update) {
+            if (this.Disposed) {
+                return;
+            }
+            // Merge settings from existing queued item.
+            let settings = this.updateQueueSettings[update.entityId];
+            if (settings !== true) {
+                if (update.refresh === true) {
+                    settings = true;
+                }
+                else if (update.refresh === false) {
+                    if (!settings) {
+                        settings = false;
+                    }
+                }
+                else {
+                    if (!settings) {
+                        settings = {};
+                    }
+                    if (update.refresh.highlighted) {
+                        settings.highlighted = true;
+                    }
+                    if (update.refresh.selected) {
+                        settings.selected = true;
+                    }
+                    if (update.refresh.opacity) {
+                        settings.opacity = true;
+                    }
+                }
+            }
+            this.updateQueueSettings[update.entityId] = settings;
+            // Queue ID if it's not already in the queue.
+            if (!this.updateQueue.includes(update.entityId)) {
+                this.updateQueue.push(update.entityId);
+                this.pingUpdateQueue();
+            }
+        }
+        pingUpdateQueue() {
+            if (this.updateQueueInterval) {
+                return;
+            }
+            const BATCH_SIZE = 300;
+            if (this.updateQueue.length) {
+                this.updateQueueInterval = setInterval(() => {
+                    if (this.Disposed || (!this.viewer || !this.viewer.scene || this.viewer.isDestroyed())) {
+                        clearInterval(this.updateQueueInterval);
+                        this.updateQueueInterval = null;
+                        return;
+                    }
+                    const batch = this.updateQueue.splice(0, BATCH_SIZE);
+                    const cache = {};
+                    for (let i = 0; i < batch.length; i++) {
+                        const entityId = batch[i];
+                        // Check if still registered.
+                        if (!this.rego[entityId] || !this.rego[entityId].length) {
+                            continue;
+                        }
+                        updateEntity(this.viewer, entityId, this, this.updateQueueSettings[entityId] == null ? false : this.updateQueueSettings[entityId], cache);
+                        this.updateQueueSettings[entityId] = null;
+                        delete this.updateQueueSettings[entityId];
+                    }
+                    this.viewer.scene.requestRender();
+                    if (!this.updateQueue.length) {
+                        clearInterval(this.updateQueueInterval);
+                        this.updateQueueInterval = null;
+                    }
+                }, 10);
+            }
+        }
+        /**
+         * Returns the applied visual state for a given Entity ID.
+         * This is a combination of a Menu Item specific state and a general state.
+         * @param params
+         */
+        GetState(params) {
+            var _a, _b;
+            const { entityId, menuItemId } = params;
+            let eState = (_a = this.states[entityId]) === null || _a === void 0 ? void 0 : _a[NO_MENU_ITEM_KEY];
+            if (eState && isBlankState(eState)) {
+                eState = null;
+                delete this.states[entityId][NO_MENU_ITEM_KEY];
+            }
+            let mState;
+            if (menuItemId) {
+                mState = (_b = this.states[entityId]) === null || _b === void 0 ? void 0 : _b[menuItemId];
+                if (mState && isBlankState(mState)) {
+                    mState = null;
+                    delete this.states[entityId][menuItemId];
+                }
+            }
+            if (!mState && eState) {
+                return eState;
+            }
+            let state = getBlankState(entityId, menuItemId);
+            if (eState) {
+                state = Object.assign(state, eState);
+            }
+            if (mState) {
+                state = Object.assign(state, mState);
+            }
+            if (menuItemId) {
+                state.menuItemId = menuItemId;
+            }
+            state.entityId = entityId;
+            return state;
+        }
+        /**
+         * Sets the state for a given Entity.
+         * This can be used to perform multiple visual updates in one go.
+         * @param state
+         * @param update
+         */
+        SetState(state, update = true, source) {
+            if (!state || isBlankState(state)) {
+                return;
+            }
+            const refresh = {
+                highlighted: state.hasOwnProperty("highlighted"),
+                selected: state.hasOwnProperty("selected"),
+                opacity: state.hasOwnProperty("opacity")
+            };
+            const updateAll = state.hasOwnProperty("isolated");
+            let changed = this.setStateValues(state);
+            // Update the related Entity.
+            if (changed && update) {
+                if (updateAll) {
+                    this.updateAllEntities({
+                        refresh: refresh
+                    });
+                }
+                else {
+                    this.queueUpdate({
+                        entityId: state.entityId,
+                        refresh: refresh
+                    });
+                }
+                // Trigger update event.
+                if (this.onUpdate) {
+                    const update = {
+                        type: EVisualUpdateType.Update,
+                        entityId: state.entityId
+                    };
+                    if (state.hasOwnProperty("selected")) {
+                        update.selected = state.selected;
+                    }
+                    if (state.hasOwnProperty("opacity")) {
+                        update.opacity = state.opacity;
+                    }
+                    if (state.hasOwnProperty("isolated")) {
+                        update.isolated = state.isolated;
+                    }
+                    if (state.hasOwnProperty("hidden")) {
+                        update.hidden = state.hidden;
+                    }
+                    if (source) {
+                        update.source = source;
+                    }
+                    this.onUpdate.Trigger(update);
+                }
+            }
+            return changed;
+        }
+        SetStates(states, source) {
+            // Array of changed Entity IDs so we know what to refresh/notify at the end.
+            const entityIds = [];
+            // If we need to update all Entities.
+            // This is usually for isolation changes.
+            let updateAll = false;
+            // Map of individual Entity refresh settings.
+            let refresh = {};
+            // Settings to apply if a refresh-all is needed.
+            let refreshAccumulated = {};
+            // Indicator that at least one Entity state was updated.
+            let changed = false;
+            const updateRefreshMarkers = (state) => {
+                if (state.hasOwnProperty("isolated")) {
+                    updateAll = true;
+                }
+                let values = refresh[state.entityId];
+                if (!values) {
+                    values = refresh[state.entityId] = {};
+                }
+                if (state.hasOwnProperty("highlighted")) {
+                    values.highlighted = true;
+                    refreshAccumulated.highlighted = true;
+                }
+                if (state.hasOwnProperty("selected")) {
+                    values.selected = true;
+                    refreshAccumulated.selected = true;
+                }
+                if (state.hasOwnProperty("opacity")) {
+                    values.opacity = true;
+                    refreshAccumulated.opacity = true;
+                }
+            };
+            const doUpdate = (state) => {
+                const eChanged = this.SetState(state, false, source);
+                if (eChanged && !entityIds.includes(state.entityId)) {
+                    updateRefreshMarkers(state);
+                    entityIds.push(state.entityId);
+                    changed = true;
+                }
+            };
+            if (Array.isArray(states)) {
+                for (let i = 0; i < states.length; i++) {
+                    doUpdate(states[i]);
+                }
+            }
+            else {
+                Object.values(states).forEach(state => {
+                    doUpdate(state);
+                });
+            }
+            if (changed) {
+                if (updateAll) {
+                    this.updateAllEntities({
+                        refresh: refreshAccumulated
+                    });
+                }
+                else {
+                    for (let i = 0; i < entityIds.length; i++) {
+                        this.queueUpdate({
+                            entityId: entityIds[i],
+                            refresh: refresh[entityIds[i]]
+                        });
+                    }
+                }
+                // Trigger update event.
+                if (this.onUpdate) {
+                    const keys = Object.keys(states);
+                    for (let i = 0; i < keys.length; i++) {
+                        const key = keys[i];
+                        const state = states[key];
+                        if (entityIds.includes(state.entityId)) {
+                            const update = {
+                                type: EVisualUpdateType.Update,
+                                entityId: state.entityId
+                            };
+                            if (state.hasOwnProperty("selected")) {
+                                update.selected = state.selected;
+                            }
+                            if (state.hasOwnProperty("opacity")) {
+                                update.opacity = state.opacity;
+                            }
+                            if (state.hasOwnProperty("isolated")) {
+                                update.isolated = state.isolated;
+                            }
+                            if (state.hasOwnProperty("hidden")) {
+                                update.hidden = state.hidden;
+                            }
+                            if (source) {
+                                update.source = source;
+                            }
+                            this.onUpdate.Trigger(update);
+                        }
+                    }
+                }
+            }
+        }
+        /**
+         * Sets the provided settings for a given Entity's state.
+         * @param params
+         */
+        setStateValues(values) {
+            const { entityId, menuItemId } = values;
+            const keys = Object.keys(values).filter(k => k !== "entityId" && k !== "menuItemId");
+            if (!keys.length) {
+                return false;
+            }
+            let changed = false;
+            const eStates = this.states[entityId] || {};
+            this.states[entityId] = eStates;
+            const targetMenuItemId = menuItemId || NO_MENU_ITEM_KEY;
+            let state = eStates[targetMenuItemId] || getBlankState(entityId, menuItemId);
+            eStates[targetMenuItemId] = state;
+            // Update state and detect changes.
+            for (const key of keys) {
+                if (state[key] !== values[key]) {
+                    state[key] = values[key];
+                    changed = true;
+                }
+                if (state[key] == null) {
+                    delete state[key];
+                }
+            }
+            if (isBlankState(state)) {
+                delete eStates[targetMenuItemId];
+                if (Object.keys(eStates).length === 0) {
+                    delete this.states[entityId];
+                }
+            }
+            // If no menuItemId, strip matching keys from other menu item states.
+            if (!menuItemId) {
+                for (const key in eStates) {
+                    if (key !== NO_MENU_ITEM_KEY) {
+                        const otherState = eStates[key];
+                        for (const stateKey of keys) {
+                            if (otherState.hasOwnProperty(stateKey)) {
+                                changed = true;
+                                delete otherState[stateKey];
+                            }
+                        }
+                        if (isBlankState(otherState)) {
+                            delete eStates[key];
+                        }
+                    }
+                }
+                if (Object.keys(eStates).length === 0) {
+                    delete this.states[entityId];
+                }
+            }
+            return changed;
+        }
+        /**
+         * Returns all visual state settings.
+         * This is typically used for saving.
+         */
+        GetStates(params) {
+            const states = [];
+            // We flatten the dictionary into an array.
+            const keys = Object.keys(this.states);
+            for (let i = 0; i < keys.length; i++) {
+                const entityId = keys[i];
+                const eStates = this.states[entityId];
+                if (!eStates) {
+                    continue;
+                }
+                const mKeys = Object.keys(eStates);
+                for (let j = 0; j < mKeys.length; j++) {
+                    const menuItemId = mKeys[j];
+                    const state = eStates[menuItemId];
+                    if (!state) {
+                        continue;
+                    }
+                    states.push(state);
+                }
+            }
+            if (!(params === null || params === void 0 ? void 0 : params.optimized)) {
+                return states;
+            }
+            const newStates = [];
+            for (let i = 0; i < states.length; i++) {
+                let state = states[i];
+                // Dereference.
+                state = {
+                    ...state
+                };
+                if (state.opacity === 1) {
+                    delete state.opacity;
+                }
+                if (state.hidden === false) {
+                    delete state.hidden;
+                }
+                if (state.highlighted === false) {
+                    delete state.highlighted;
+                }
+                if (state.selected === false) {
+                    delete state.selected;
+                }
+                if (state.labelled === false) {
+                    delete state.labelled;
+                }
+                if (state.isolated === false) {
+                    delete state.isolated;
+                }
+                if (isBlankState(state)) {
+                    continue;
+                }
+                newStates.push(state);
+            }
+            return newStates;
+        }
+        /**
+         * Applies a set of new states to override the existing ones.
+         * This can be a costly operation as it will update all visuals.
+         * @param states
+         */
+        OverrideStates(states) {
+            // Clear current states.
+            this.ClearOpacity();
+            this.ClearLabelled();
+            this.ClearSelected();
+            this.ClearHighlighted();
+            this.ClearIsolated();
+            this.ClearHidden();
+            this.states = {};
+            let newStates = {};
+            for (let i = 0; i < states.length; i++) {
+                const state = states[i];
+                if (!state.menuItemId && state.hasOwnProperty("menuItemId")) {
+                    delete state.menuItemId;
+                }
+                if (!state.entityId) {
+                    continue;
+                }
+                if (isBlankState(state)) {
+                    continue;
+                }
+                if (!newStates[state.entityId]) {
+                    newStates[state.entityId] = {};
+                }
+                newStates[state.entityId][state.menuItemId ? state.menuItemId : NO_MENU_ITEM_KEY] = {
+                    ...state
+                };
+            }
+            this.states = newStates;
+            // Reflect the rest of the changes.
+            this.updateAllEntities();
+        }
+        /**
+         * Returns all states with the first detected Menu Item ID settings included.
+         * This is a utility function for returning settings for apps that don't support the newer state settings.
+         * @deprecated Use GetStates() or GetState().
+         * @returns
+         */
+        GetStatesLegacy() {
+            const states = {};
+            let entityIds = [];
+            let entityIdsMenuItem = {};
+            for (const entityId in this.states) {
+                const eStates = this.states[entityId];
+                if (!eStates) {
+                    continue;
+                }
+                if (!entityIds.includes(entityId)) {
+                    entityIds.push(entityId);
+                }
+                const mKeys = Object.keys(eStates);
+                for (let i = 0; i < mKeys.length; i++) {
+                    const menuItemId = mKeys[i];
+                    if (menuItemId) {
+                        entityIdsMenuItem[entityId] = menuItemId;
+                    }
+                }
+            }
+            for (let i = 0; i < entityIds.length; i++) {
+                const entityId = entityIds[i];
+                const state = this.GetState({
+                    entityId: entityId,
+                    // First known Menu Item.
+                    menuItemId: entityIdsMenuItem[entityId]
+                });
+                states[entityId] = state;
+            }
+            // Remove empty states.
+            const keys = Object.keys(states);
+            for (let i = 0; i < keys.length; i++) {
+                const key = keys[i];
+                const state = states[key];
+                const idKeys = !state.menuItemId ? 1 : 2;
+                if (Object.keys(state).length === idKeys) {
+                    delete states[key];
+                }
+            }
+            return states;
+        }
+        /**
+         * Utility to iterate over all states.
+         * @param callback
+         */
+        ForEachState(callback) {
+            // Flatten and iterate.
+            const keys = Object.keys(this.states);
+            for (let i = 0; i < keys.length; i++) {
+                const entityId = keys[i];
+                const eStates = this.states[entityId];
+                if (!eStates) {
+                    continue;
+                }
+                const mKeys = Object.keys(eStates);
+                for (let j = 0; j < mKeys.length; j++) {
+                    const menuItemId = mKeys[j];
+                    const state = eStates[menuItemId];
+                    if (!state) {
+                        continue;
+                    }
+                    callback(state);
+                }
+            }
+        }
+        RefreshMark(params) {
+            const { rego } = params;
+            markEntity(this, rego, rego.visual, false);
+        }
+        Dispose() {
+            var _a;
+            (_a = this.cameraCullerDispose) === null || _a === void 0 ? void 0 : _a.call(this, {
+                uncull: false
+            });
+            this.cameraCullerDispose = null;
+            clearInterval(this.updateQueueInterval);
+            this.updateQueueInterval = null;
+            this.disposed = true;
+        }
+        ForceUpdate(params) {
+            var _a;
+            let { entityIds, requestRender, refreshColors, source } = params;
+            for (let i = 0; i < entityIds.length; i++) {
+                const entityId = entityIds[i];
+                this.queueUpdate({
+                    entityId: entityId,
+                    refresh: true
+                });
+                const update = {
+                    type: EVisualUpdateType.Update,
+                    entityId
+                };
+                if (source) {
+                    update.source = source;
+                }
+                (_a = this.onUpdate) === null || _a === void 0 ? void 0 : _a.Trigger(update);
+            }
+        }
+        /**
+         * Marks given entityIds as either labelled or not labelled.
+         * When an entity is labelled a label will be drawn on the "best" visual for it.
+         * @param params
+         */
+        SetLabelled(params) {
+            const { labelled, entityIds, requestRender, menuItemId } = params;
+            const cache = {};
+            for (let i = 0; i < entityIds.length; i++) {
+                const id = entityIds[i];
+                const state = this.GetState({
+                    entityId: id,
+                    menuItemId
+                });
+                const doLabel = Boolean(state.labelled) != labelled;
+                this.setStateValues({
+                    entityId: id,
+                    menuItemId: menuItemId,
+                    // Null means it will be deleted from the object.
+                    labelled: labelled ? true : null
+                });
+                if (doLabel) {
+                    this.queueUpdate({
+                        entityId: id,
+                        refresh: false
+                    });
+                }
+            }
+        }
+        /**
+         * Returns if given entity id is labelled.
+         * @param params
+         */
+        GetIsLabelled(params) {
+            const { entityId: id, menuItemId } = params;
+            const state = this.GetState({
+                entityId: id,
+                menuItemId
+            });
+            return state.labelled === true;
+        }
+        /**
+         * Clears all labelled entities.
+         * @param params
+         */
+        ClearLabelled(params) {
+            const cache = {};
+            const toUpdateIds = [];
+            this.ForEachState((state) => {
+                if (state.labelled == null || state.labelled === undefined) {
+                    return;
+                }
+                delete state.labelled;
+                if (!toUpdateIds.includes(state.entityId)) {
+                    toUpdateIds.push(state.entityId);
+                }
+            });
+            for (let i = 0; i < toUpdateIds.length; i++) {
+                const id = toUpdateIds[i];
+                this.queueUpdate({
+                    entityId: id,
+                    refresh: false
+                });
+            }
+        }
+        /**
+         * Returns all labelled entity ids.
+         * @deprecated Use GetStates() or GetState().
+         */
+        GetLabelled() {
+            const labelledIds = [];
+            const states = this.GetStatesLegacy();
+            for (const entityId in states) {
+                if (states[entityId].labelled) {
+                    labelledIds.push(entityId);
+                }
+            }
+            return labelledIds;
+        }
+        /**
+         * Updates the selection color.
+         * This will not update the selection color for already selected entities.
+         * @param color
+         */
+        SetSelectionColor(color) {
+            if (color) {
+                cesium_entity_styler_1.CesiumEntityStyler.UpdateColorSetting("select", color);
+            }
+        }
+        /**
+         * Updates the highlight color.
+         * This will not update the highlight color for already highlighted entities.
+         * @param color
+         */
+        SetHighlightColor(color) {
+            if (color) {
+                cesium_entity_styler_1.CesiumEntityStyler.UpdateColorSetting("highlight", color);
+            }
+        }
+        SetSelected(params) {
+            var _a;
+            let { entityIds, selected, refreshIfSelected, requestRender, menuItemId, source } = params;
+            if (refreshIfSelected == null || refreshIfSelected === undefined) {
+                refreshIfSelected = true;
+            }
+            for (let i = 0; i < entityIds.length; i++) {
+                const id = entityIds[i];
+                const state = this.GetState({
+                    entityId: id,
+                    menuItemId
+                });
+                // Checking if we need to refresh the selection.
+                const doSelect = refreshIfSelected || (Boolean(state.selected) != selected);
+                this.setStateValues({
+                    entityId: id,
+                    menuItemId: menuItemId,
+                    // Null means it will be deleted from the object.
+                    selected: selected ? true : null
+                });
+                if (selected) {
+                    if (doSelect) {
+                        const regos = this.rego[id];
+                        if (regos) {
+                            for (let i = 0; i < regos.length; i++) {
+                                const rego = regos[i];
+                                if (menuItemId && rego.menuItemId !== menuItemId) {
+                                    continue;
+                                }
+                                cesium_entity_styler_1.CesiumEntityStyler.Select({
+                                    entity: rego.visual,
+                                    viewer: this.viewer,
+                                    requestRender: false
+                                });
+                            }
+                        }
+                    }
+                }
+                else {
+                    if (doSelect) {
+                        const regos = this.rego[id];
+                        if (regos) {
+                            for (let i = 0; i < regos.length; i++) {
+                                const rego = regos[i];
+                                if (menuItemId && rego.menuItemId !== menuItemId) {
+                                    continue;
+                                }
+                                cesium_entity_styler_1.CesiumEntityStyler.Deselect({
+                                    entity: rego.visual,
+                                    viewer: this.viewer,
+                                    requestRender: false
+                                });
+                            }
+                        }
+                    }
+                }
+                const update = {
+                    entityId: id,
+                    type: EVisualUpdateType.Update,
+                    selected: selected
+                };
+                if (source) {
+                    update.source = source;
+                }
+                (_a = this.onUpdate) === null || _a === void 0 ? void 0 : _a.Trigger(update);
+            }
+            if (requestRender != false) {
+                this.viewer.scene.requestRender();
+            }
+        }
+        GetIsSelected(params) {
+            const { entityId: id, menuItemId } = params;
+            const state = this.GetState({
+                entityId: id,
+                menuItemId
+            });
+            return state.selected === true;
+        }
+        ClearSelected(params) {
+            var _a;
+            const cleared = [];
+            this.ForEachState((state) => {
+                if (state.selected == null || state.selected === undefined) {
+                    return;
+                }
+                delete state.selected;
+                const regos = this.GetRegos({
+                    entityId: state.entityId,
+                    menuItemId: state.menuItemId
+                });
+                for (let i = 0; i < regos.length; i++) {
+                    const rego = regos[i];
+                    if ((rego === null || rego === void 0 ? void 0 : rego.visual) && !cleared.includes(rego)) {
+                        cesium_entity_styler_1.CesiumEntityStyler.Deselect({
+                            entity: rego.visual,
+                            viewer: this.viewer,
+                            requestRender: false
+                        });
+                        cleared.push(rego);
+                    }
+                }
+            });
+            const update = {
+                type: EVisualUpdateType.DeselectAll
+            };
+            if (params === null || params === void 0 ? void 0 : params.source) {
+                update.source = params.source;
+            }
+            (_a = this.onUpdate) === null || _a === void 0 ? void 0 : _a.Trigger(update);
+            if ((params === null || params === void 0 ? void 0 : params.requestRender) != false) {
+                this.viewer.scene.requestRender();
+            }
+        }
+        /**
+         * @deprecated Use GetStates() or GetState().
+         * @returns
+         */
+        GetSelected() {
+            const selectedIds = [];
+            const states = this.GetStatesLegacy();
+            for (const entityId in states) {
+                if (states[entityId].selected) {
+                    selectedIds.push(entityId);
+                }
+            }
+            return selectedIds;
+        }
+        SetHighlighted(params) {
+            let { entityIds, highlighted, refreshIfHighlighted, requestRender, menuItemId } = params;
+            if (refreshIfHighlighted || refreshIfHighlighted === undefined) {
+                refreshIfHighlighted = true;
+            }
+            for (let i = 0; i < entityIds.length; i++) {
+                const id = entityIds[i];
+                const state = this.GetState({
+                    entityId: id,
+                    menuItemId
+                });
+                // Checking if we need to refresh the highlight.
+                const doHighlight = refreshIfHighlighted || (Boolean(state.highlighted) != highlighted);
+                const changed = this.setStateValues({
+                    entityId: id,
+                    menuItemId: menuItemId,
+                    // Null means it will be deleted from the object.
+                    highlighted: highlighted ? true : null
+                });
+                if (highlighted) {
+                    if (doHighlight) {
+                        const regos = this.rego[id];
+                        if (regos) {
+                            for (let i = 0; i < regos.length; i++) {
+                                const rego = regos[i];
+                                if (menuItemId && rego.menuItemId !== menuItemId) {
+                                    continue;
+                                }
+                                cesium_entity_styler_1.CesiumEntityStyler.Highlight({
+                                    entity: rego.visual,
+                                    viewer: this.viewer,
+                                    requestRender: false
+                                });
+                            }
+                        }
+                    }
+                }
+                else {
+                    const regos = this.rego[id];
+                    if (regos) {
+                        for (let i = 0; i < regos.length; i++) {
+                            const rego = regos[i];
+                            if (menuItemId && rego.menuItemId !== menuItemId) {
+                                continue;
+                            }
+                            cesium_entity_styler_1.CesiumEntityStyler.Unhighlight({
+                                entity: rego.visual,
+                                viewer: this.viewer,
+                                requestRender: false
+                            });
+                        }
+                    }
+                }
+            }
+            if (requestRender != false) {
+                this.viewer.scene.requestRender();
+            }
+        }
+        GetIsHighlighted(params) {
+            const { entityId: id, menuItemId } = params;
+            const state = this.GetState({
+                entityId: id,
+                menuItemId
+            });
+            return state.highlighted === true;
+        }
+        ClearHighlighted(params) {
+            // Null all states.
+            let entityIds = [];
+            this.ForEachState((state) => {
+                if (state.highlighted) {
+                    delete state.highlighted;
+                    if (!entityIds.includes(state.entityId)) {
+                        entityIds.push(state.entityId);
+                    }
+                }
+            });
+            // Revert needed visual changes.
+            for (let i = 0; i < entityIds.length; i++) {
+                const id = entityIds[i];
+                const regos = this.rego[id];
+                if (regos) {
+                    for (let i = 0; i < regos.length; i++) {
+                        const rego = regos[i];
+                        cesium_entity_styler_1.CesiumEntityStyler.Unhighlight({
+                            entity: rego.visual,
+                            viewer: this.viewer,
+                            requestRender: false
+                        });
+                    }
+                }
+            }
+            if ((params === null || params === void 0 ? void 0 : params.requestRender) != false) {
+                this.viewer.scene.requestRender();
+            }
+        }
+        /**
+         * @deprecated Use GetStates() or GetState().
+         * @returns
+         */
+        GetHighlighted() {
+            const highlightedIds = [];
+            const states = this.GetStatesLegacy();
+            for (const entityId in states) {
+                if (states[entityId].highlighted) {
+                    highlightedIds.push(entityId);
+                }
+            }
+            return highlightedIds;
+        }
+        SetIsolated(params) {
+            var _a;
+            const { entityIds, isolated: isolate, requestRender, menuItemId, source } = params;
+            for (let i = 0; i < entityIds.length; i++) {
+                const entityId = entityIds[i];
+                this.setStateValues({
+                    entityId: entityId,
+                    menuItemId: menuItemId,
+                    // Null means it will be deleted from the object.
+                    isolated: isolate ? true : null
+                });
+                const update = {
+                    entityId: entityId,
+                    type: EVisualUpdateType.Update,
+                    isolated: isolate
+                };
+                if (source) {
+                    update.source = source;
+                }
+                (_a = this.onUpdate) === null || _a === void 0 ? void 0 : _a.Trigger(update);
+            }
+            this.updateAllEntities({
+                requestRender: false,
+                refresh: isolate
+            });
+            if (requestRender != false) {
+                this.viewer.scene.requestRender();
+            }
+        }
+        GetIsIsolated(params) {
+            const { entityId: id, menuItemId } = params;
+            const state = this.GetState({
+                entityId: id,
+                menuItemId: menuItemId
+            });
+            return state.isolated === true;
+        }
+        GetIsIsolatedAny() {
+            return Object.values(this.states).some(state => state && Object.values(state).some(item => item.isolated));
+        }
+        /**
+         * @deprecated Use GetStates() or GetState().
+         * @returns
+         */
+        GetIsolated() {
+            const isolatedIds = [];
+            const states = this.GetStatesLegacy();
+            for (const entityId in states) {
+                if (states[entityId].isolated) {
+                    isolatedIds.push(entityId);
+                }
+            }
+            return isolatedIds;
+        }
+        ClearIsolated(params) {
+            let changed = false;
+            this.ForEachState((state) => {
+                if (state.isolated) {
+                    changed = true;
+                }
+                delete state.isolated;
+            });
+            if (changed) {
+                this.updateAllEntities({
+                    requestRender: params === null || params === void 0 ? void 0 : params.requestRender,
+                    refresh: true
+                });
+            }
+        }
+        SetHidden(params) {
+            const { entityIds, hidden, requestRender, menuItemId, source } = params;
+            const stateChanges = [];
+            for (let i = 0; i < entityIds.length; i++) {
+                const entityId = entityIds[i];
+                const state = {
+                    entityId: entityId,
+                    hidden: hidden
+                };
+                if (menuItemId) {
+                    state.menuItemId = menuItemId;
+                }
+                stateChanges.push(state);
+            }
+            this.SetStates(stateChanges, source);
+        }
+        GetIsHidden(params) {
+            const { entityId: id, menuItemId } = params;
+            const state = this.GetState({
+                entityId: id,
+                menuItemId: menuItemId
+            });
+            return state.hidden === true;
+        }
+        /**
+         * @deprecated Use GetStates() or GetState().
+         * @returns
+         */
+        GetHidden() {
+            const hiddenIds = [];
+            const states = this.GetStatesLegacy();
+            for (const entityId in states) {
+                if (states[entityId].hidden) {
+                    hiddenIds.push(entityId);
+                }
+            }
+            return hiddenIds;
+        }
+        ClearHidden(params) {
+            var _a;
+            let changed = false;
+            this.ForEachState((state) => {
+                if (state.hidden) {
+                    changed = true;
+                }
+                delete state.hidden;
+            });
+            if (changed) {
+                this.updateAllEntities({
+                    requestRender: params === null || params === void 0 ? void 0 : params.requestRender,
+                    refresh: true
+                });
+            }
+            const update = {
+                type: EVisualUpdateType.Update,
+                hidden: false
+            };
+            if (params === null || params === void 0 ? void 0 : params.source) {
+                update.source = params.source;
+            }
+            (_a = this.onUpdate) === null || _a === void 0 ? void 0 : _a.Trigger(update);
+        }
+        AddRego(params) {
+            var _a, _b;
+            const { rego, requestRender, source } = params;
+            // ND-2078
+            // Tilesets will often add -> remove -> add because of how tiles load in and out of the scene.
+            // To avoid flickering, we'll just replace rather than remove -> add.
+            if (!rego.tilesetId && params.removePrior != false) {
+                this.RemoveRegos({
+                    entityId: rego.entityId,
+                    menuItemId: rego.menuItemId,
+                    doUpdate: false,
+                    requestRender: false
+                });
+            }
+            const entityId = rego.entityId;
+            // Add the new visual to the register.
+            const entityRegos = (_a = this.rego[entityId]) !== null && _a !== void 0 ? _a : [];
+            entityRegos.push(rego);
+            this.rego[entityId] = entityRegos;
+            // Mark the visual as part of this register so selection works.
+            markEntity(this, rego, rego.visual, false);
+            // Run any updates on the visual based on the calculated state.
+            // Eg: visibility, opacity, selection, etc.
+            this.queueUpdate({
+                entityId: entityId,
+                refresh: true
+            });
+            const update = {
+                rego: rego,
+                type: EVisualUpdateType.Add,
+                entityId: rego.entityId
+            };
+            if (source) {
+                update.source = source;
+            }
+            (_b = this.onUpdate) === null || _b === void 0 ? void 0 : _b.Trigger(update);
+            if (requestRender != false) {
+                this.viewer.scene.requestRender();
+            }
+        }
+        /**
+         * Locates a visual corresponding to a given entity id.
+         * If no menu item id is provided, then it will pick the "best" one.
+         * @param params
+         * @returns
+         */
+        GetRego(params) {
+            const { entityId, menuItemId, relation } = params;
+            if (relation) {
+                const relationKey = relation_render_engine_1.RelationRenderEngine.GetRenderGroupId(relation);
+                for (const entityId in this.rego) {
+                    const entityRegos = this.rego[entityId];
+                    if (entityRegos) {
+                        const rego = entityRegos.find(r => r.relation && relation_render_engine_1.RelationRenderEngine.GetRenderGroupId(r.relation) == relationKey);
+                        if (rego) {
+                            return rego;
+                        }
+                    }
+                }
+            }
+            else {
+                const entityRegos = this.rego[entityId];
+                if (!entityRegos) {
+                    return null;
+                }
+                if (menuItemId) {
+                    return entityRegos.find(r => r.menuItemId === menuItemId);
+                }
+                return entityRegos.sort((a, b) => {
+                    return b.priority - a.priority;
+                })[0];
+            }
+        }
+        /**
+         * Returns regos matching given criteria.
+         * Either entityId or menuItemId must be provided.
+         * @param params
+         * @returns
+         */
+        GetRegos(params) {
+            // TODO: refactor.
+            // Currently this was made by merging two functions.
+            const { entityId, menuItemId } = params;
+            if (entityId) {
+                const entityId = params.entityId;
+                const entityRegos = this.rego[entityId];
+                if (!entityRegos) {
+                    return [];
+                }
+                return menuItemId ? entityRegos.filter(x => x.menuItemId == menuItemId) : entityRegos;
+            }
+            else if (menuItemId) {
+                const menuItemId = params.menuItemId;
+                const visuals = [];
+                for (const entityId in this.rego) {
+                    const entityRegos = this.rego[entityId];
+                    if (entityRegos) {
+                        const rego = entityRegos.find(r => r.menuItemId === menuItemId);
+                        if (rego) {
+                            visuals.push(rego);
+                        }
+                    }
+                }
+                return visuals;
+            }
+        }
+        /**
+         * Removes regos matching given criteria.
+         * Either entityId or menuItemId must be provided.
+         * @param params
+         * @returns
+         */
+        RemoveRegos(params) {
+            var _a, _b, _c;
+            let { entityId, menuItemId, doUpdate, relation, retainTagIds, requestRender, doRemove, source } = params;
+            if (doUpdate == null || doUpdate === undefined) {
+                doUpdate = true;
+            }
+            if (retainTagIds == null || retainTagIds === undefined) {
+                retainTagIds = [];
+            }
+            // TODO: refactor.
+            // Currently this was made by merging two functions.
+            if (menuItemId && !entityId) {
+                for (const entityId in this.rego) {
+                    const entityRegos = this.rego[entityId];
+                    if (entityRegos) {
+                        const rego = entityRegos.find(r => r.menuItemId === menuItemId);
+                        if (!rego) {
+                            continue;
+                        }
+                        const regoTagIds = rego.tagIds ? rego.tagIds : [];
+                        const shouldRetain = regoTagIds.some(tagId => retainTagIds.includes(tagId));
+                        if (shouldRetain) {
+                            continue;
+                        }
+                        entity_label_1.EntityLabel.Detatch({
+                            rego
+                        });
+                        if (doRemove != false) {
+                            removeEntity(this.viewer, rego.visual);
+                        }
+                        rego.visual = null;
+                        const doesInclude = this.rego[entityId].find(r => r.menuItemId === menuItemId);
+                        if (doesInclude) {
+                            this.rego[entityId] = entityRegos.filter(r => r.menuItemId !== menuItemId);
+                        }
+                        const update = {
+                            type: EVisualUpdateType.Remove,
+                            entityId: rego.entityId,
+                            rego: rego
+                        };
+                        if (source) {
+                            update.source = source;
+                        }
+                        (_a = this.onUpdate) === null || _a === void 0 ? void 0 : _a.Trigger(update);
+                        if (doesInclude) {
+                            this.queueUpdate({
+                                entityId: entityId,
+                                refresh: false
+                            });
+                        }
+                    }
+                }
+            }
+            else if (entityId) {
+                const entityRegos = this.rego[entityId];
+                if (!entityRegos) {
+                    return;
+                }
+                const menuItems = menuItemId ? [menuItemId] : entityRegos.map(x => x.menuItemId);
+                for (let i = 0; i < menuItems.length; i++) {
+                    const menuItemId = menuItems[i];
+                    const rego = entityRegos.find(r => r.menuItemId === menuItemId);
+                    if (!rego) {
+                        return;
+                    }
+                    entity_label_1.EntityLabel.Detatch({
+                        rego
+                    });
+                    if (doRemove != false) {
+                        removeEntity(this.viewer, rego.visual);
+                    }
+                    rego.visual = null;
+                    const update = {
+                        type: EVisualUpdateType.Remove,
+                        entityId: rego.entityId,
+                        rego: rego
+                    };
+                    if (source) {
+                        update.source = source;
+                    }
+                    (_b = this.onUpdate) === null || _b === void 0 ? void 0 : _b.Trigger(update);
+                    this.rego[entityId] = entityRegos.filter(r => r.menuItemId !== menuItemId);
+                    if (doUpdate && menuItemId) {
+                        this.queueUpdate({
+                            entityId: entityId,
+                            refresh: false
+                        });
+                    }
+                }
+            }
+            else if (relation) {
+                const relationKey = relation_render_engine_1.RelationRenderEngine.GetRenderGroupId(relation);
+                for (const entityId in this.rego) {
+                    const entityRegos = this.rego[entityId];
+                    if (entityRegos) {
+                        const rego = entityRegos.find(r => r.relation && relation_render_engine_1.RelationRenderEngine.GetRenderGroupId(r.relation) == relationKey);
+                        if (!rego) {
+                            continue;
+                        }
+                        entity_label_1.EntityLabel.Detatch({
+                            rego
+                        });
+                        removeEntity(this.viewer, rego.visual);
+                        rego.visual = null;
+                        this.rego[entityId] = entityRegos.filter(r => r.menuItemId !== menuItemId);
+                        const update = {
+                            type: EVisualUpdateType.Remove,
+                            entityId: rego.entityId,
+                            rego: rego
+                        };
+                        if (source) {
+                            update.source = source;
+                        }
+                        (_c = this.onUpdate) === null || _c === void 0 ? void 0 : _c.Trigger(update);
+                        if (doUpdate && menuItemId) {
+                            this.queueUpdate({
+                                entityId: entityId,
+                                refresh: false
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        /**
+         * Returns an array of drilled visuals associated with this register.
+         * The top array item is the first found.
+         * @param params
+         * @returns
+         */
+        GetRegosFromCursor(params) {
+            var _a, _b;
+            const { cursor } = params;
+            const found = [];
+            const width = Math.ceil((0, js_utils_1.EnsureNumber)(params.width, 5));
+            const height = Math.ceil((0, js_utils_1.EnsureNumber)(params.height, 5));
+            const pickLimit = Math.ceil((0, js_utils_1.EnsureNumber)(params.pickLimit, 5));
+            const picked = this.viewer.scene.drillPick(new Cesium.Cartesian2(cursor.x, cursor.y), pickLimit, width, height);
+            for (let i = 0; i < picked.length; i++) {
+                const object = picked[i];
+                const entity = (object && object.id && object.id instanceof Cesium.Entity ? object.id : object);
+                const visual = entity;
+                if (((_a = visual === null || visual === void 0 ? void 0 : visual._register) === null || _a === void 0 ? void 0 : _a.Id) == this.id) {
+                    const foundEntityId = (_b = visual._rego) === null || _b === void 0 ? void 0 : _b.entityId;
+                    if (foundEntityId && found.findIndex(x => x.entityId == foundEntityId) <= -1) {
+                        found.push(visual._rego);
+                    }
+                }
+            }
+            return {
+                regos: found
+            };
+        }
+        /**
+         * Returns all registered entity ids.
+         */
+        GetEntityIds() {
+            const ids = [];
+            for (const entityId in this.rego) {
+                const regos = this.rego[entityId];
+                if (regos && regos.length) {
+                    ids.push(entityId);
+                }
+            }
+            return ids;
+        }
+        /**
+         * Marks regos corresponding to given entity ids as stale.
+         * This will cause them to be updated on the next update cycle.
+         * Optionally include menu item ids to restrict the filter.
+         * @param params
+         */
+        MarkStale(params) {
+            const { entityIds, menuItemIds } = params;
+            for (const entityId of entityIds) {
+                const regos = this.rego[entityId];
+                if (regos && regos.length) {
+                    for (const rego of regos) {
+                        if (!menuItemIds || menuItemIds.includes(rego.menuItemId)) {
+                            rego.stale = true;
+                        }
+                    }
+                }
+            }
+        }
+        updateAllEntities(params) {
+            for (const entityId in this.rego) {
+                const regos = this.rego[entityId];
+                if (regos && regos.length) {
+                    this.queueUpdate({
+                        entityId: entityId,
+                        refresh: (params === null || params === void 0 ? void 0 : params.refresh) == null ? true : params.refresh
+                    });
+                }
+            }
+        }
+        /**
+         * Sets opacity for given set of entities.
+         * 100% opacity is treated as "use original".
+         * @param params
+         */
+        SetOpacity(params) {
+            var _a;
+            let { opacity, entityIds, menuItemId, requestRender, source } = params;
+            for (const entityId of entityIds) {
+                this.setStateValues({
+                    entityId: entityId,
+                    menuItemId: menuItemId,
+                    opacity: opacity
+                });
+                const update = {
+                    type: EVisualUpdateType.Update,
+                    entityId: entityId,
+                    opacity: opacity
+                };
+                if (source) {
+                    update.source = source;
+                }
+                (_a = this.onUpdate) === null || _a === void 0 ? void 0 : _a.Trigger(update);
+                this.queueUpdate({
+                    entityId: entityId,
+                    refresh: {
+                        opacity: true
+                    }
+                });
+            }
+        }
+        /**
+         * Returns opacity for given entity/s.
+         * If multiple entities are supplied, then the average is returned.
+         * Unknown opacity is treated as 100% opacity.
+         * @param params
+         * @returns
+         */
+        GetOpacity(params) {
+            let { entityIds, entityId, menuItemId, menuItemIds } = params;
+            if (!entityIds) {
+                entityIds = entityId ? [entityId] : [];
+            }
+            if (!menuItemIds && menuItemId) {
+                menuItemIds = menuItemId;
+            }
+            let totalOpacity = null;
+            let totalTicks = 0;
+            for (const entityId of entityIds) {
+                const rego = this.GetRego({
+                    entityId: entityId,
+                    menuItemId: menuItemId
+                });
+                if (rego) {
+                    const state = this.GetState({
+                        entityId: entityId,
+                        menuItemId: rego.menuItemId
+                    });
+                    let opacity = state === null || state === void 0 ? void 0 : state.opacity;
+                    if (opacity != null) {
+                        totalOpacity += opacity;
+                        totalTicks += 1;
+                    }
+                }
+            }
+            return (totalOpacity && totalTicks) ? (totalOpacity / totalTicks) : totalOpacity != null && typeof totalOpacity == "number" ? totalOpacity : 1;
+        }
+        ClearOpacity(params) {
+            const clearedIds = [];
+            this.ForEachState((state) => {
+                if (!clearedIds.includes(state.entityId) && state.opacity != null) {
+                    this.queueUpdate({
+                        entityId: state.entityId,
+                        refresh: {
+                            opacity: true
+                        }
+                    });
+                    clearedIds.push(state.entityId);
+                }
+                delete state.opacity;
+            });
+        }
+        /**
+         * Returns a dictionary containing entityId -> opacity values.
+         * Opacity 1 = 100%.
+         * @returns
+         * @deprecated Use GetStates() or GetState().
+         */
+        GetOpacityMap() {
+            const map = {};
+            const states = this.GetStatesLegacy();
+            for (const entityId in states) {
+                const opacity = states[entityId].opacity;
+                if (opacity != null && opacity != 1) {
+                    map[entityId] = opacity;
+                }
+            }
+            return map;
+        }
+    }
+    VisualsRegister.Register = Register;
+})(VisualsRegister = exports.VisualsRegister || (exports.VisualsRegister = {}));
+//# sourceMappingURL=visuals-register.js.map