bruce-cesium 2.9.6 → 2.9.8

package/dist/bruce-cesium.umd.js

@@ -5008,6 +5008,267 @@
         EntityLabel.GetLabel = GetLabel;
     })(exports.EntityLabel || (exports.EntityLabel = {}));
 
+    // Area in m^2 for 3D model visibility check.
+    var MODEL_SIZE_TOLERANCE = 1000;
+    function getValue$2(viewer, obj) {
+        if (obj === null || obj === void 0 ? void 0 : obj.getValue) {
+            return obj.getValue(viewer.scene.lastRenderTime);
+        }
+        return obj;
+    }
+    var boundingSphereCache = {};
+    function getPositionsFromEntity(viewer, entity) {
+        if (entity.billboard) {
+            var pos3d = getValue$2(viewer, entity.position);
+            if (!(pos3d === null || pos3d === void 0 ? void 0 : pos3d.x)) {
+                return null;
+            }
+            return [pos3d];
+        }
+        else if (entity.polyline) {
+            return getValue$2(viewer, entity.polyline.positions);
+        }
+        else if (entity.polygon) {
+            var hierarchy = getValue$2(viewer, entity.polygon.hierarchy);
+            return hierarchy.positions;
+        }
+        else if (entity.corridor) {
+            return getValue$2(viewer, entity.corridor.positions);
+        }
+        else if (entity.ellipse) {
+            var position = getValue$2(viewer, entity.position);
+            if (!(position === null || position === void 0 ? void 0 : position.x)) {
+                return null;
+            }
+            var semiMajorAxis = getValue$2(viewer, entity.ellipse.semiMajorAxis);
+            var semiMinorAxis = getValue$2(viewer, entity.ellipse.semiMinorAxis);
+            var rotation = getValue$2(viewer, entity.ellipse.rotation);
+            // More subdivisions means a more accurate ellipse but worse performance.
+            var numberOfSubdivisions = 5;
+            var positions = [];
+            for (var i = 0; i < numberOfSubdivisions; i++) {
+                var theta = i * (2 * Math.PI / numberOfSubdivisions);
+                var x = semiMajorAxis * Math.cos(theta);
+                var y = semiMinorAxis * Math.sin(theta);
+                // Apply rotation.
+                var rotatedX = x * Math.cos(rotation) - y * Math.sin(rotation);
+                var rotatedY = x * Math.sin(rotation) + y * Math.cos(rotation);
+                // Translate by the ellipse's position.
+                var point = new Cesium.Cartesian3(position.x + rotatedX, position.y + rotatedY, position.z);
+                positions.push(point);
+            }
+            return positions;
+        }
+        else if (entity.model) {
+            var pos3d = getValue$2(viewer, entity.position);
+            if (!(pos3d === null || pos3d === void 0 ? void 0 : pos3d.x)) {
+                return null;
+            }
+            return [pos3d];
+        }
+        else if (entity.point) {
+            var pos3d = getValue$2(viewer, entity.position);
+            if (!(pos3d === null || pos3d === void 0 ? void 0 : pos3d.x)) {
+                return null;
+            }
+            return [pos3d];
+        }
+        return null;
+    }
+    function computeBoundingSphereFromPositions(positions) {
+        return Cesium.BoundingSphere.fromPoints(positions);
+    }
+    function shouldCullEntity(viewer, cEntity) {
+        var camera = viewer.scene.camera;
+        var boundingSphere;
+        if (boundingSphereCache[cEntity.id]) {
+            boundingSphere = boundingSphereCache[cEntity.id];
+        }
+        else {
+            var positions = getPositionsFromEntity(viewer, cEntity);
+            if (positions) {
+                boundingSphere = computeBoundingSphereFromPositions(positions);
+                if (cEntity.model) {
+                    // We don't know how large models are so we'll just add a tolerance.
+                    boundingSphere.radius += Math.sqrt(MODEL_SIZE_TOLERANCE);
+                }
+                boundingSphereCache[cEntity.id] = boundingSphere;
+            }
+        }
+        if (!boundingSphere) {
+            return false;
+        }
+        var cullingVolume = camera.frustum.computeCullingVolume(camera.position, camera.direction, camera.up);
+        var visibility = cullingVolume.computeVisibility(boundingSphere);
+        return visibility !== Cesium.Intersect.INSIDE && visibility !== Cesium.Intersect.INTERSECTING;
+    }
+    // Amount of entities to check per interval.
+    var CHECK_BATCH = 500;
+    var checkInterval = null;
+    var 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.
+    var LAST_RECHECK_KEY = Symbol("LAST_RECHECK_KEY");
+    /**
+     * We will recheck if the camera has turned or moved enough.
+     * @param viewer
+     * @returns
+     */
+    function shouldRecheck(viewer) {
+        var _a;
+        var 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;
+        }
+        var lastRecheck = camera[LAST_RECHECK_KEY];
+        if (!lastRecheck) {
+            camera[LAST_RECHECK_KEY] = {
+                position: camera.position.clone(),
+                direction: camera.direction.clone(),
+            };
+            return true;
+        }
+        var _b = lastRecheck, position = _b.position, direction = _b.direction;
+        var posDiff = Cesium.Cartesian3.magnitude(Cesium.Cartesian3.subtract(position, camera.position, new Cesium.Cartesian3()));
+        var dirDiff = Cesium.Cartesian3.magnitude(Cesium.Cartesian3.subtract(direction, camera.direction, new Cesium.Cartesian3()));
+        var recheck = posDiff > 100 || dirDiff > 0.01;
+        if (recheck) {
+            camera[LAST_RECHECK_KEY] = {
+                position: camera.position.clone(),
+                direction: camera.direction.clone(),
+            };
+        }
+        return recheck;
+    }
+    /**
+     * 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;
+        }
+        var viewer = register.Viewer;
+        var entityIds = register.GetEntityIds();
+        checkInterval = setInterval(function () {
+            if (viewer.isDestroyed() || !viewer.scene) {
+                clearInterval(checkInterval);
+                checkInterval = null;
+                return;
+            }
+            var slice = entityIds.splice(0, CHECK_BATCH);
+            for (var i = 0; i < slice.length; i++) {
+                var entityId = slice[i];
+                var rego = register.GetRego({
+                    entityId: entityId
+                });
+                if (!rego || !rego.visual || !(rego.visual instanceof Cesium.Entity)) {
+                    continue;
+                }
+                var parts = exports.EntityUtils.GatherEntity({
+                    entity: rego.visual
+                });
+                for (var i_1 = 0; i_1 < parts.length; i_1++) {
+                    var part = parts[i_1];
+                    var shouldCull = shouldCullEntity(viewer, part);
+                    if (shouldCull) {
+                        part[VisualRegisterCuller.VISUAL_CULL_KEY] = true;
+                        if (viewer.entities.contains(part)) {
+                            viewer.entities.remove(part);
+                        }
+                    }
+                    else {
+                        delete part[VisualRegisterCuller.VISUAL_CULL_KEY];
+                        if (!rego.suppressShow && rego.best && !viewer.entities.contains(part)) {
+                            viewer.entities.add(part);
+                        }
+                    }
+                }
+            }
+            if (entityIds.length <= 0) {
+                clearInterval(checkInterval);
+                checkInterval = null;
+                if (checkWaiting) {
+                    checkWaiting = false;
+                    runCullChecker(register);
+                }
+            }
+        }, 200);
+    }
+    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;
+            var register = params.register;
+            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 function () { };
+            }
+            var lastCullCheck = null;
+            var checkQueue = new bruceModels.DelayQueue(function () {
+                if (register.Viewer == null || register.Viewer.isDestroyed() || !shouldRecheck(register.Viewer)) {
+                    return;
+                }
+                runCullChecker(register);
+                lastCullCheck = new Date();
+            }, 1000);
+            var moveStartRemoval = register.Viewer.camera.moveStart.addEventListener(function () {
+                var _a;
+                (_a = checkQueue.Call) === null || _a === void 0 ? void 0 : _a.call(checkQueue);
+            });
+            var moveEndRemoval = register.Viewer.camera.moveEnd.addEventListener(function () {
+                var _a;
+                (_a = checkQueue.Call) === null || _a === void 0 ? void 0 : _a.call(checkQueue);
+            });
+            var RENDER_SECS_PASSED = 5;
+            var updateRemoval = register.Viewer.scene.postUpdate.addEventListener(function () {
+                var _a;
+                var 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);
+                }
+            });
+            checkQueue.Call();
+            return function (params) {
+                var uncull = (params || {}).uncull;
+                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;
+                checkInterval === null || checkInterval === void 0 ? void 0 : checkInterval();
+                checkInterval = null;
+                checkWaiting = false;
+                checkQueue === null || checkQueue === void 0 ? void 0 : checkQueue.Dispose();
+                checkQueue = null;
+            };
+        }
+        VisualRegisterCuller.Monitor = Monitor;
+        function IsCulled(viewer, visual) {
+            if (!visual) {
+                return false;
+            }
+            if (visual instanceof Cesium.Entity) {
+                var status_1 = visual[VisualRegisterCuller.VISUAL_CULL_KEY];
+                if (status_1 == null) {
+                    status_1 = visual[VisualRegisterCuller.VISUAL_CULL_KEY] = shouldCullEntity(viewer, visual);
+                }
+                return status_1;
+            }
+            return false;
+        }
+        VisualRegisterCuller.IsCulled = IsCulled;
+    })(VisualRegisterCuller || (VisualRegisterCuller = {}));
+
     /**
      * Returns if a given visual is alive and in the scene.
      * @param viewer
@@ -5062,6 +5323,13 @@
         }
     }
     function updateCEntityShow(viewer, visual, show, ignoreParent) {
+        if (show) {
+            // Culling is controlled by "visual-register-culler.ts".
+            // When an object is unculled then the 'updateEntityShow' function is re-called to reveal it and related objects.
+            // A sub-object can be culled while the siblings are not.
+            var isCulled = show ? VisualRegisterCuller.IsCulled(viewer, visual) : true;
+            show = !isCulled;
+        }
         if (visual._parentEntity && !ignoreParent) {
             updateCEntityShow(viewer, visual._parentEntity, show, false);
         }
@@ -5343,6 +5611,9 @@
                 this.labelledEntityIds = [];
                 this.viewer = params.viewer;
                 this.apiGetters = params.apiGetters;
+                this.cameraCullerDispose = VisualRegisterCuller.Monitor({
+                    register: this
+                });
             }
             Object.defineProperty(Register.prototype, "Id", {
                 get: function () {
@@ -5375,6 +5646,13 @@
                 enumerable: false,
                 configurable: true
             });
+            Register.prototype.Dispose = function () {
+                var _a;
+                (_a = this.cameraCullerDispose) === null || _a === void 0 ? void 0 : _a.call(this, {
+                    uncull: false
+                });
+                this.cameraCullerDispose = null;
+            };
             Register.prototype.ForceUpdate = function (params) {
                 var entityIds = params.entityIds;
                 for (var i = 0; i < entityIds.length; i++) {
@@ -11440,6 +11718,27 @@
                 enumerable: false,
                 configurable: true
             });
+            /**
+             * Disposes the menu item manager.
+             * This will dispose all render managers and unregister all menu items.
+             */
+            Manager.prototype.Dispose = function (params) {
+                var _a;
+                var disposeRegister = (params !== null && params !== void 0 ? params : {}).disposeRegister;
+                for (var i = 0; i < this.items.length; i++) {
+                    var item = this.items[i];
+                    try {
+                        (_a = item.renderManager) === null || _a === void 0 ? void 0 : _a.Dispose();
+                    }
+                    catch (e) {
+                        console.error(e);
+                    }
+                }
+                this.items = [];
+                if (this.visualsRegister && disposeRegister != false) {
+                    this.visualsRegister.Dispose();
+                }
+            };
             /**
              * Renders a given menu item and all its children.
              * Will return the enabled item id.
@@ -17211,7 +17510,7 @@
         ViewerUtils.CreateWidgets = CreateWidgets;
     })(exports.ViewerUtils || (exports.ViewerUtils = {}));
 
-    var VERSION$1 = "2.9.6";
+    var VERSION$1 = "2.9.8";
 
     exports.VERSION = VERSION$1;
     exports.CesiumViewMonitor = CesiumViewMonitor;