bruce-cesium 5.7.9 → 5.8.1

package/dist/lib/rendering/visual-register-culler.js

@@ -0,0 +1,676 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VisualRegisterCuller = void 0;
+const bruce_models_1 = require("bruce-models");
+const Cesium = require("cesium");
+const entity_utils_1 = require("../utils/entity-utils");
+const view_utils_1 = require("../utils/view-utils");
+const DEBUG_MODE = false;
+const MODEL_MIN_RADIUS = 10;
+const POINT_MIN_RADIUS = 15;
+// If a shape has more than this amount of points, we'll avoid checking it because it will take too long.
+// We will put responsibility on the bookmark creator to view shapes they can see.
+const DO_NOT_CULL_AT_LEN_POINTS = 5000;
+// Returns terrain height at a given position.
+// This will cache the results based on the terrain provider and position.
+const _terrainCache = new bruce_models_1.LRUCache(1000);
+// Positions within this tolerance from each-other will be re-used.
+const TERRAIN_HEIGHT_TOLERANCE = 400;
+// Tolerance to use when number of entities is lower than x in the scene.
+const TERRAIN_HEIGHT_TOLERANCE_LOW_COUNT = 30;
+const TERRAIN_HEIGHT_TOLERANCE_LOW_ENTITY_THRESHOLD = 100;
+/**
+ * Returns the terrain height for a given position.
+ * This will not sample most-detailed and instead the current state of the terrain.
+ * TODO: If something is VERY far from the camera, we should just return 0.
+ * @param viewer
+ * @param pos3d
+ * @returns
+ */
+const getTerrainOffset = (viewer, pos3d) => {
+    var _a;
+    if (!viewer.terrainProvider || viewer.terrainProvider["ready"] == false) {
+        return null;
+    }
+    const terrain = (_a = view_utils_1.ViewUtils.GatherTerrainTile({
+        viewer
+    })) === null || _a === void 0 ? void 0 : _a.terrain;
+    if (!terrain || terrain.tilesetId == bruce_models_1.ProjectViewTile.EDefaultTerrain.FlatTerrain) {
+        return 0;
+    }
+    const terrainId = terrain.tilesetId;
+    // Check for existing values within TOLERANCE distance.
+    const keys = Array.from(_terrainCache.Entries());
+    const tolerance = viewer.entities.values.length > TERRAIN_HEIGHT_TOLERANCE_LOW_ENTITY_THRESHOLD ? TERRAIN_HEIGHT_TOLERANCE : TERRAIN_HEIGHT_TOLERANCE_LOW_COUNT;
+    for (let i = 0; i < keys.length; i++) {
+        const [key, offset] = keys[i];
+        const [terrainId2, x, y, z] = key.split("_");
+        if (terrainId2 != terrainId) {
+            continue;
+        }
+        const pos3d2 = new Cesium.Cartesian3(parseFloat(x), parseFloat(y), parseFloat(z));
+        const distance = Cesium.Cartesian3.distance(pos3d, pos3d2);
+        if (distance < tolerance) {
+            return offset;
+        }
+    }
+    const key = terrainId + "_" + pos3d.x + "_" + pos3d.y + "_" + pos3d.z;
+    let offset = _terrainCache.Get(key);
+    if (offset == null) {
+        const carto = Cesium.Cartographic.fromCartesian(pos3d);
+        let height = 0;
+        try {
+            height = viewer.scene.globe.getHeight(carto);
+        }
+        catch (e) {
+            if (DEBUG_MODE) {
+                console.warn("Failed to get terrain height.", e);
+            }
+            // Likely out of rendered area.
+            // This means it's not our problem since the user isn't looking there :)
+        }
+        offset = height;
+        _terrainCache.Set(key, offset);
+    }
+    return offset;
+};
+/**
+ * Converts given pos3d into a an absolute position.
+ * This means either setting it to terrain height or adding the height offset.
+ * @param viewer
+ * @param heightRef
+ * @param pos3d
+ * @returns
+ */
+const adjustPos3d = (viewer, heightRef, pos3d) => {
+    if (heightRef == Cesium.HeightReference.NONE) {
+        return pos3d;
+    }
+    const offset = getTerrainOffset(viewer, pos3d);
+    if (!offset) {
+        return pos3d;
+    }
+    const carto = Cesium.Cartographic.fromCartesian(pos3d);
+    if (heightRef == Cesium.HeightReference.CLAMP_TO_GROUND) {
+        carto.height = offset;
+    }
+    else {
+        carto.height += offset;
+    }
+    const newPos3d = Cesium.Cartographic.toCartesian(carto);
+    if (!(newPos3d === null || newPos3d === void 0 ? void 0 : newPos3d.x)) {
+        return pos3d;
+    }
+    return newPos3d;
+};
+function isFlatTerrain(viewer) {
+    var _a, _b;
+    if (!viewer) {
+        return false;
+    }
+    return ((_b = (_a = view_utils_1.ViewUtils.GatherTerrainTile({
+        viewer
+    })) === null || _a === void 0 ? void 0 : _a.terrain) === null || _b === void 0 ? void 0 : _b.tilesetId) == bruce_models_1.ProjectViewTile.EDefaultTerrain.FlatTerrain;
+}
+function getValue(viewer, obj) {
+    if (obj === null || obj === void 0 ? void 0 : obj.getValue) {
+        let date = viewer.scene.lastRenderTime;
+        if (!date) {
+            date = viewer.clock.currentTime;
+        }
+        return obj.getValue(date);
+    }
+    return obj;
+}
+const boundingSphereCache = new bruce_models_1.LRUCache(100000);
+function getPositionsFromEntity(viewer, entity) {
+    let positions = [];
+    let heightRef;
+    if (entity.billboard) {
+        let pos3d = getValue(viewer, entity.position);
+        if (!(pos3d === null || pos3d === void 0 ? void 0 : pos3d.x)) {
+            return null;
+        }
+        heightRef = getValue(viewer, entity.billboard.heightReference);
+        positions.push(pos3d);
+    }
+    else if (entity.polyline) {
+        let posses = getValue(viewer, entity.polyline.positions);
+        if (!(posses === null || posses === void 0 ? void 0 : posses.length) || posses.length >= DO_NOT_CULL_AT_LEN_POINTS) {
+            return null;
+        }
+        // Get the first, last, and every forth point.
+        // This is to reduce the amount of points we need to check.
+        if (posses.length > 10) {
+            const first = posses[0];
+            const last = posses[posses.length - 1];
+            const everyForth = posses.filter((_, index) => index % 4 == 0);
+            posses = [first, last].concat(everyForth);
+        }
+        heightRef = getValue(viewer, entity.polyline.clampToGround) == false ? Cesium.HeightReference.NONE : Cesium.HeightReference.CLAMP_TO_GROUND;
+        for (let i = 0; i < posses.length; i++) {
+            positions.push(posses[i]);
+        }
+    }
+    else if (entity.polygon) {
+        const hierarchy = getValue(viewer, entity.polygon.hierarchy);
+        let posses = hierarchy.positions;
+        if (!(posses === null || posses === void 0 ? void 0 : posses.length) || posses.length >= DO_NOT_CULL_AT_LEN_POINTS) {
+            return null;
+        }
+        // Get the first, last, and every forth point.
+        // This is to reduce the amount of points we need to check.
+        if (posses.length > 10) {
+            const first = posses[0];
+            const last = posses[posses.length - 1];
+            const everyForth = posses.filter((_, index) => index % 4 == 0);
+            posses = [first, last].concat(everyForth);
+        }
+        heightRef = getValue(viewer, entity.polygon.heightReference);
+        for (let i = 0; i < posses.length; i++) {
+            positions.push(posses[i]);
+        }
+    }
+    else if (entity.corridor) {
+        let posses = getValue(viewer, entity.corridor.positions);
+        if (!(posses === null || posses === void 0 ? void 0 : posses.length) || posses.length >= DO_NOT_CULL_AT_LEN_POINTS) {
+            return null;
+        }
+        // Get the first, last, and every forth point.
+        // This is to reduce the amount of points we need to check.
+        if (posses.length > 10) {
+            const first = posses[0];
+            const last = posses[posses.length - 1];
+            const everyForth = posses.filter((_, index) => index % 4 == 0);
+            posses = [first, last].concat(everyForth);
+        }
+        heightRef = getValue(viewer, entity.corridor.heightReference);
+        for (let i = 0; i < posses.length; i++) {
+            positions.push(posses[i]);
+        }
+    }
+    else if (entity.ellipse) {
+        let pos3d = getValue(viewer, entity.position);
+        if (!(pos3d === null || pos3d === void 0 ? void 0 : pos3d.x)) {
+            return null;
+        }
+        heightRef = getValue(viewer, entity.ellipse.heightReference);
+        positions.push(pos3d);
+    }
+    else if (entity.model) {
+        let pos3d = getValue(viewer, entity.position);
+        if (!(pos3d === null || pos3d === void 0 ? void 0 : pos3d.x)) {
+            return null;
+        }
+        heightRef = getValue(viewer, entity.model.heightReference);
+        positions.push(pos3d);
+    }
+    else if (entity.point) {
+        let pos3d = getValue(viewer, entity.position);
+        if (!(pos3d === null || pos3d === void 0 ? void 0 : pos3d.x)) {
+            return null;
+        }
+        heightRef = getValue(viewer, entity.point.heightReference);
+        positions.push(pos3d);
+    }
+    if (!(positions === null || positions === void 0 ? void 0 : positions.length)) {
+        return;
+    }
+    // We need to zero the heights.
+    if (heightRef == Cesium.HeightReference.CLAMP_TO_GROUND && isFlatTerrain(viewer)) {
+        for (let i = 0; i < positions.length; i++) {
+            const pos = positions[i];
+            const carto = Cesium.Cartographic.fromCartesian(pos);
+            carto.height = 0;
+            positions[i] = Cesium.Cartographic.toCartesian(carto);
+        }
+    }
+    return {
+        positions: positions,
+        heightRef: heightRef
+    };
+}
+function computeBoundingSphereFromPositions(positions) {
+    return Cesium.BoundingSphere.fromPoints(positions);
+}
+function shouldCullEntity(viewer, cEntity) {
+    var _a, _b, _c, _d;
+    const camera = viewer.scene.camera;
+    let boundingSphere;
+    const terrainId = (_c = (_b = (_a = view_utils_1.ViewUtils.GatherTerrainTile({
+        viewer
+    })) === null || _a === void 0 ? void 0 : _a.terrain) === null || _b === void 0 ? void 0 : _b.tilesetId) !== null && _c !== void 0 ? _c : bruce_models_1.ProjectViewTile.EDefaultTerrain.FlatTerrain;
+    let cullSphere;
+    const cacheKey = terrainId + cEntity.id;
+    const cacheData = boundingSphereCache.Get(cacheKey);
+    if (cacheData) {
+        boundingSphere = cacheData;
+    }
+    else {
+        const positions = getPositionsFromEntity(viewer, cEntity);
+        if ((_d = positions === null || positions === void 0 ? void 0 : positions.positions) === null || _d === void 0 ? void 0 : _d.length) {
+            // Sphere calculated from entity positions.
+            // We will evaluate the visual now to see if the sphere should be counted, for example 3D models might not be loaded yet.
+            let sphere = computeBoundingSphereFromPositions(positions.positions);
+            // If a 3D model is not loaded, we'll avoid caching the sphere data.
+            let doNotCache = false;
+            if (cEntity.model) {
+                const model = cEntity.model;
+                if (model._radius && !isNaN(model._radius)) {
+                    sphere.radius = Math.max(model._radius, MODEL_MIN_RADIUS);
+                }
+                else {
+                    // Unknown size. Ignoring.
+                    sphere = null;
+                    doNotCache = !model._radiusLoaded;
+                }
+            }
+            // Check for radius and extrusion.
+            else if (cEntity.ellipse) {
+                let radius = getValue(viewer, cEntity.ellipse.semiMajorAxis);
+                const extrusion = getValue(viewer, cEntity.ellipse.extrudedHeight);
+                if (extrusion && !isNaN(extrusion)) {
+                    if (!radius) {
+                        radius = extrusion;
+                    }
+                    else if (extrusion > radius / 2) {
+                        radius = extrusion;
+                    }
+                }
+                if (radius && !isNaN(radius)) {
+                    sphere.radius = radius;
+                }
+            }
+            // Check for extrusion.
+            else if (cEntity.polygon) {
+                const extrusion = getValue(viewer, cEntity.polygon.extrudedHeight);
+                if (extrusion && !isNaN(extrusion)) {
+                    if (!sphere.radius) {
+                        sphere.radius = extrusion;
+                    }
+                    else if (extrusion > sphere.radius / 2) {
+                        sphere.radius = extrusion;
+                    }
+                }
+            }
+            else if (cEntity.point || cEntity.billboard) {
+                sphere.radius = Math.max(sphere.radius, POINT_MIN_RADIUS);
+            }
+            boundingSphere = {
+                heightRef: positions.heightRef,
+                sphere: sphere
+            };
+            if (!doNotCache) {
+                boundingSphereCache.Set(cacheKey, boundingSphere);
+            }
+        }
+        else {
+            boundingSphereCache.Set(cacheKey, -1);
+        }
+    }
+    if (!boundingSphere || boundingSphere == -1 || !boundingSphere.sphere) {
+        return false;
+    }
+    const adjustedSphere = boundingSphere.sphere.clone();
+    adjustedSphere.center = adjustPos3d(viewer, boundingSphere.heightRef, adjustedSphere.center);
+    const cullingVolume = camera.frustum.computeCullingVolume(camera.position, camera.direction, camera.up);
+    const visibility = cullingVolume.computeVisibility(adjustedSphere);
+    // Render sphere to visualize.
+    if (DEBUG_MODE) {
+        cullSphere = viewer.entities.getById(cEntity.id + "_cull");
+        if (!cullSphere) {
+            cullSphere = viewer.entities.add({
+                id: cEntity.id + "_cull",
+                position: boundingSphere.sphere.center,
+                ellipsoid: {
+                    radii: new Cesium.Cartesian3(boundingSphere.sphere.radius, boundingSphere.sphere.radius, boundingSphere.sphere.radius),
+                    material: Cesium.Color.RED.withAlpha(0.1),
+                    heightReference: Cesium.HeightReference.NONE
+                }
+            });
+        }
+        // Change colour based on visibility.
+        cullSphere.ellipsoid.material =
+            (visibility == Cesium.Intersect.INSIDE ||
+                visibility == Cesium.Intersect.INTERSECTING) ? Cesium.Color.GREEN.withAlpha(0.1) :
+                Cesium.Color.RED.withAlpha(0.1);
+        cullSphere.position = new Cesium.ConstantPositionProperty(adjustedSphere.center);
+        cullSphere.ellipsoid.radii = new Cesium.ConstantProperty(new Cesium.Cartesian3(adjustedSphere.radius, adjustedSphere.radius, adjustedSphere.radius));
+        viewer.scene.requestRender();
+    }
+    return visibility !== Cesium.Intersect.INSIDE && visibility !== Cesium.Intersect.INTERSECTING;
+}
+// Amount of entities to check per interval.
+const CHECK_BATCH = 500;
+let checkInterval = null;
+let checkWaiting = false;
+// We will store the last recheck data on the camera.
+// This will allow us to check if the camera has moved enough to warrant a recheck.
+const LAST_RECHECK_KEY = Symbol("LAST_RECHECK_KEY");
+// Attached to a cesium viewer to indicate a re-check should be done.
+// This is to override the cache that avoids re-checking when the camera hasn't moved.
+const SHOULD_RECHECK_KEY = Symbol("SHOULD_RECHECK_KEY");
+/**
+ * We will recheck if the camera has turned or moved enough.
+ * @param viewer
+ * @returns
+ */
+function shouldRecheck(viewer) {
+    var _a;
+    if (viewer[SHOULD_RECHECK_KEY]) {
+        viewer[SHOULD_RECHECK_KEY] = false;
+        return true;
+    }
+    const camera = viewer.scene.camera;
+    if (!((_a = camera === null || camera === void 0 ? void 0 : camera.position) === null || _a === void 0 ? void 0 : _a.x)) {
+        return false;
+    }
+    const lastRecheck = camera[LAST_RECHECK_KEY];
+    if (!lastRecheck) {
+        camera[LAST_RECHECK_KEY] = {
+            position: camera.position.clone(),
+            direction: camera.direction.clone(),
+            tilesLoading: viewer.scene.globe.tilesLoaded
+        };
+        return true;
+    }
+    const { position, direction } = lastRecheck;
+    const tilesLoadingDiff = lastRecheck.tilesLoading != viewer.scene.globe.tilesLoaded;
+    let recheck = tilesLoadingDiff;
+    if (!recheck) {
+        const posDiff = Cesium.Cartesian3.magnitude(Cesium.Cartesian3.subtract(position, camera.position, new Cesium.Cartesian3()));
+        const dirDiff = Cesium.Cartesian3.magnitude(Cesium.Cartesian3.subtract(direction, camera.direction, new Cesium.Cartesian3()));
+        recheck = posDiff > 100 || dirDiff > 0.01;
+    }
+    if (recheck) {
+        camera[LAST_RECHECK_KEY] = {
+            position: camera.position.clone(),
+            direction: camera.direction.clone(),
+            tilesLoading: viewer.scene.globe.tilesLoaded
+        };
+    }
+    return recheck;
+}
+/**
+ * Returns true if the given rego should be ignored from culling.
+ * @param rego
+ * @returns
+ */
+function isCullingIgnored(viewer, rego) {
+    if (
+    // No rego or visual.
+    // This is a safety check to avoid crashes.
+    !rego ||
+        !rego.visual ||
+        // We will only touch entities. Not tileset stuff.
+        !(rego.visual instanceof Cesium.Entity) ||
+        // We won't touch relationship lines because they dynamically change shape.
+        rego.relation != null ||
+        // Explicitly being either shown or hidden.
+        rego.overrideShow != null ||
+        // Part of an independent collection.
+        // Won't touch in case there is special logic.
+        rego.collection ||
+        // We won't cull historic records as they may be interpolating their locations.
+        Boolean(rego.outline && rego.outline.some(x => !!x.DateTime))) {
+        return true;
+    }
+    const visual = rego.visual;
+    // We will only cull clamped stuff since it seems that's where we get benefits from.
+    let heightRef;
+    if (visual.polygon) {
+        heightRef = getValue(viewer, visual.polygon.heightReference);
+    }
+    else if (visual.polyline) {
+        heightRef = getValue(viewer, visual.polyline.clampToGround) == false ? Cesium.HeightReference.NONE : Cesium.HeightReference.CLAMP_TO_GROUND;
+    }
+    else if (visual.corridor) {
+        heightRef = getValue(viewer, visual.corridor.heightReference);
+    }
+    else if (visual.ellipse) {
+        heightRef = getValue(viewer, visual.ellipse.heightReference);
+    }
+    else if (visual.model) {
+        heightRef = getValue(viewer, visual.model.heightReference);
+    }
+    else if (visual.point) {
+        heightRef = getValue(viewer, visual.point.heightReference);
+    }
+    else if (visual.billboard) {
+        heightRef = getValue(viewer, visual.billboard.heightReference);
+    }
+    return heightRef != Cesium.HeightReference.CLAMP_TO_GROUND;
+}
+/**
+ * Runs through all entities in the register and culls them if they are out of the viewport.
+ * This will work in batches.
+ * @param register
+ */
+function runCullChecker(register) {
+    if (checkInterval != null) {
+        checkWaiting = true;
+        return;
+    }
+    const viewer = register.Viewer;
+    const entityIds = register.GetEntityIds();
+    // We'll use the terrain cache per culler cycle.
+    _terrainCache.Clear();
+    checkInterval = setInterval(() => {
+        var _a;
+        if (viewer.isDestroyed() || !viewer.scene) {
+            clearInterval(checkInterval);
+            checkInterval = null;
+            return;
+        }
+        const toRemove = [];
+        const toAdd = [];
+        const isIsolatedAny = register.GetIsIsolatedAny();
+        const slice = entityIds.splice(0, CHECK_BATCH);
+        for (let i = 0; i < slice.length; i++) {
+            const entityId = slice[i];
+            const 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;
+            }
+            for (let j = 0; j < regos.length; j++) {
+                const rego = regos[j];
+                if (isCullingIgnored(viewer, rego)) {
+                    continue;
+                }
+                // We skip if it's hidden due to being under the highest priority.
+                else if (rego.priority < highestPriority) {
+                    continue;
+                }
+                const state = register.GetState({
+                    entityId: entityId,
+                    menuItemId: rego.menuItemId
+                });
+                const parts = entity_utils_1.EntityUtils.GatherEntity({
+                    entity: rego.visual
+                });
+                for (let i = 0; i < parts.length; i++) {
+                    const part = parts[i];
+                    if (!(part instanceof Cesium.Entity)) {
+                        continue;
+                    }
+                    const shouldCull = shouldCullEntity(viewer, part);
+                    if (shouldCull) {
+                        part[VisualRegisterCuller.VISUAL_CULL_KEY] = true;
+                        toRemove.push(part);
+                    }
+                    else {
+                        delete part[VisualRegisterCuller.VISUAL_CULL_KEY];
+                        if (rego.overrideShow != false &&
+                            !viewer.entities.contains(part) &&
+                            !state.hidden &&
+                            (!isIsolatedAny || state.isolated)) {
+                            toAdd.push(part);
+                        }
+                    }
+                }
+            }
+        }
+        if (toRemove.length > 0) {
+            removeEntities(viewer, toRemove);
+        }
+        if (toAdd.length > 0) {
+            addEntities(viewer, toAdd);
+        }
+        if (entityIds.length <= 0) {
+            clearInterval(checkInterval);
+            checkInterval = null;
+            if (checkWaiting) {
+                checkWaiting = false;
+                runCullChecker(register);
+            }
+        }
+    }, 200);
+}
+// The latest remove/add pending states of an Entity.
+const entityRemoveAddState = new Map();
+/**
+ * Removes Entities from the viewer.
+ * This performs the action next viewer update to avoid any internal Cesium issues that can cause crashes.
+ * @param viewer
+ * @param entities
+ */
+function removeEntities(viewer, entities) {
+    for (let i = 0; i < entities.length; i++) {
+        const entity = entities[i];
+        entityRemoveAddState.set(entity.id, false);
+    }
+    const removal = viewer.scene.postRender.addEventListener(() => {
+        removal();
+        for (let i = 0; i < entities.length; i++) {
+            const entity = entities[i];
+            if (entityRemoveAddState.get(entity.id) != false) {
+                continue;
+            }
+            entityRemoveAddState.delete(entity.id);
+            viewer.entities.remove(entity);
+        }
+    });
+}
+/**
+ * Adds Entities to the viewer.
+ * @param viewer
+ * @param entities
+ */
+function addEntities(viewer, entities) {
+    for (let i = 0; i < entities.length; i++) {
+        const entity = entities[i];
+        entityRemoveAddState.set(entity.id, true);
+    }
+    const removal = viewer.scene.postRender.addEventListener(() => {
+        removal();
+        for (let i = 0; i < entities.length; i++) {
+            const entity = entities[i];
+            if (entityRemoveAddState.get(entity.id) != true) {
+                continue;
+            }
+            entityRemoveAddState.delete(entity.id);
+            viewer.entities.add(entity);
+        }
+    });
+}
+var VisualRegisterCuller;
+(function (VisualRegisterCuller) {
+    VisualRegisterCuller.VISUAL_CULL_KEY = Symbol("VISUAL_CULL_KEY");
+    /**
+     * Will monitor the visuals within a visual register and cull ones that are out of the viewport.
+     * @param params
+     * @returns a dispose function.
+     */
+    function Monitor(params) {
+        var _a;
+        const { register } = params;
+        if (!((_a = register === null || register === void 0 ? void 0 : register.Viewer) === null || _a === void 0 ? void 0 : _a.scene) || register.Viewer.isDestroyed()) {
+            console.warn("Cannot monitor a visual register that is not attached to a viewer.");
+            return () => { };
+        }
+        let lastCullCheck = null;
+        let checkQueue = new bruce_models_1.DelayQueue(() => {
+            if (register.Viewer == null || register.Viewer.isDestroyed() || !shouldRecheck(register.Viewer)) {
+                return;
+            }
+            runCullChecker(register);
+            lastCullCheck = new Date();
+        }, 1000);
+        let moveStartRemoval = register.Viewer.camera.moveStart.addEventListener(() => {
+            var _a;
+            (_a = checkQueue.Call) === null || _a === void 0 ? void 0 : _a.call(checkQueue);
+        });
+        let moveEndRemoval = register.Viewer.camera.moveEnd.addEventListener(() => {
+            var _a;
+            (_a = checkQueue.Call) === null || _a === void 0 ? void 0 : _a.call(checkQueue);
+        });
+        const RENDER_SECS_PASSED = 5;
+        let updateRemoval = register.Viewer.scene.postUpdate.addEventListener(() => {
+            var _a;
+            const now = new Date();
+            if (lastCullCheck == null || (now.getTime() - lastCullCheck.getTime()) > RENDER_SECS_PASSED * 1000) {
+                (_a = checkQueue.Call) === null || _a === void 0 ? void 0 : _a.call(checkQueue);
+            }
+        });
+        let terrChangeTimeout = null;
+        let terrChangeRemoval = register.Viewer.scene.terrainProviderChanged.addEventListener(() => {
+            clearTimeout(terrChangeTimeout);
+            terrChangeTimeout = setTimeout(() => {
+                var _a;
+                MarkShouldRecheck(register.Viewer);
+                (_a = checkQueue.Call) === null || _a === void 0 ? void 0 : _a.call(checkQueue);
+            }, 2500);
+        });
+        checkQueue.Call();
+        return (params) => {
+            const { uncull } = params || {};
+            moveStartRemoval === null || moveStartRemoval === void 0 ? void 0 : moveStartRemoval();
+            moveStartRemoval = null;
+            moveEndRemoval === null || moveEndRemoval === void 0 ? void 0 : moveEndRemoval();
+            moveEndRemoval = null;
+            updateRemoval === null || updateRemoval === void 0 ? void 0 : updateRemoval();
+            updateRemoval = null;
+            terrChangeRemoval === null || terrChangeRemoval === void 0 ? void 0 : terrChangeRemoval();
+            terrChangeRemoval = null;
+            clearTimeout(terrChangeTimeout);
+            terrChangeTimeout = null;
+            checkInterval === null || checkInterval === void 0 ? void 0 : checkInterval();
+            checkInterval = null;
+            checkWaiting = false;
+            checkQueue === null || checkQueue === void 0 ? void 0 : checkQueue.Dispose();
+            checkQueue = null;
+            if (uncull != false) {
+                // TODO. Unused for now.
+            }
+        };
+    }
+    VisualRegisterCuller.Monitor = Monitor;
+    function IsCulled(viewer, rego, visual) {
+        if (isCullingIgnored(viewer, rego)) {
+            return false;
+        }
+        if (!visual) {
+            return false;
+        }
+        if (visual instanceof Cesium.Entity) {
+            let status = visual[VisualRegisterCuller.VISUAL_CULL_KEY];
+            if (status == null) {
+                status = visual[VisualRegisterCuller.VISUAL_CULL_KEY] = shouldCullEntity(viewer, visual);
+            }
+            return status;
+        }
+        return false;
+    }
+    VisualRegisterCuller.IsCulled = IsCulled;
+    function MarkShouldRecheck(viewer) {
+        viewer[SHOULD_RECHECK_KEY] = true;
+    }
+    VisualRegisterCuller.MarkShouldRecheck = MarkShouldRecheck;
+})(VisualRegisterCuller = exports.VisualRegisterCuller || (exports.VisualRegisterCuller = {}));
+//# sourceMappingURL=visual-register-culler.js.map