bruce-cesium 2.9.7 → 2.9.9

package/dist/bruce-cesium.umd.js

@@ -75,191 +75,194 @@
     function arePosEqual(a, b) {
         return a.latitude == b.latitude && a.longitude == b.longitude;
     }
-    /**
-     * Monitors and emits events when the Cesium view changes.
-     */
-    var CesiumViewMonitor = /** @class */ (function () {
-        function CesiumViewMonitor(viewer) {
-            var _this = this;
-            this.target = null;
-            this.bounds = null;
-            this.disposed = false;
-            this.updatedEvent = null;
-            this.entity = null;
-            this.viewer = viewer;
-            this.tryEmitUpdate();
-            this.checkInterval = setInterval(function () {
-                _this.updateQueue();
-            }, POSITION_CHECK_TIMER);
-        }
-        Object.defineProperty(CesiumViewMonitor.prototype, "Disposed", {
-            get: function () {
-                return this.disposed;
-            },
-            enumerable: false,
-            configurable: true
-        });
-        CesiumViewMonitor.prototype.createEntity = function () {
-            var _this = this;
-            if (this.entity) {
-                return;
+    (function (CesiumViewMonitor) {
+        /**
+         * Monitors and emits events when the Cesium view changes.
+         */
+        var Monitor = /** @class */ (function () {
+            function Monitor(viewer) {
+                var _this = this;
+                this.target = null;
+                this.bounds = null;
+                this.disposed = false;
+                this.updatedEvent = null;
+                this.entity = null;
+                this.viewer = viewer;
+                this.tryEmitUpdate();
+                this.checkInterval = setInterval(function () {
+                    _this.updateQueue();
+                }, POSITION_CHECK_TIMER);
             }
-            this.entity = this.viewer.entities.add({
-                position: new Cesium.CallbackProperty(function () {
-                    return _this.target ? Cesium.Cartesian3.fromDegrees(_this.target.longitude, _this.target.latitude) : null;
-                }, false),
-                point: {
-                    pixelSize: 8,
-                    color: Cesium.Color.ORANGE
+            Object.defineProperty(Monitor.prototype, "Disposed", {
+                get: function () {
+                    return this.disposed;
                 },
-                rectangle: {
-                    coordinates: new Cesium.CallbackProperty(function () {
-                        return _this.bounds ? Cesium.Rectangle.fromDegrees(_this.bounds.west, _this.bounds.south, _this.bounds.east, _this.bounds.north) : null;
-                    }, false),
-                    material: Cesium.Color.fromCssColorString('#ff0000').withAlpha(0.4),
-                    zIndex: 1
-                }
+                enumerable: false,
+                configurable: true
             });
-        };
-        CesiumViewMonitor.prototype.destroyEntity = function () {
-            if (this.entity && this.viewer.entities.contains(this.entity)) {
-                this.viewer.entities.remove(this.entity);
-            }
-            this.entity = null;
-        };
-        CesiumViewMonitor.prototype.Updated = function () {
-            if (!this.updatedEvent) {
-                this.updatedEvent = new bruceModels.BruceEvent();
-            }
-            return this.updatedEvent;
-        };
-        CesiumViewMonitor.prototype.GetBounds = function () {
-            return this.bounds;
-        };
-        CesiumViewMonitor.prototype.GetTarget = function () {
-            return this.target;
-        };
-        CesiumViewMonitor.prototype.DoUpdate = function () {
-            this.tryEmitUpdate();
-        };
-        CesiumViewMonitor.prototype.Dispose = function () {
-            if (this.disposed) {
-                return;
-            }
-            this.disposed = true;
-            clearInterval(this.checkInterval);
-            this.destroyEntity();
-        };
-        CesiumViewMonitor.prototype.tryDoUpdate = function () {
-            var _a;
-            if (!this.viewer || this.viewer.isDestroyed()) {
-                this.Dispose();
-                return ESearchStatus.LocationMissing;
-            }
-            var viewRect = null;
-            var center = null;
-            var camera = this.viewer.camera;
-            var terrainHeight = this.viewer.scene.globe.getHeight(camera.positionCartographic);
-            var cameraPosition = this.viewer.camera.positionCartographic;
-            // We are almost at the ground, screw horizon, just load around.
-            if (terrainHeight && ((cameraPosition.height - terrainHeight) < DEFAULT_GROUNDED_HEIGHT)) {
-                // View area calculation.
-                viewRect = {};
-                var viewRectRad = netScanViewForBoundaries(this.viewer);
-                if (viewRectRad &&
-                    viewRectRad.east &&
-                    viewRectRad.west &&
-                    viewRectRad.north &&
-                    viewRectRad.south) {
-                    viewRect.east = Cesium.Math.toDegrees(Math.max(viewRectRad.east, cameraPosition.longitude));
-                    viewRect.west = Cesium.Math.toDegrees(Math.min(viewRectRad.west, cameraPosition.longitude));
-                    viewRect.south = Cesium.Math.toDegrees(Math.min(viewRectRad.south, cameraPosition.latitude));
-                    viewRect.north = Cesium.Math.toDegrees(Math.max(viewRectRad.north, cameraPosition.latitude));
+            Monitor.prototype.createEntity = function () {
+                var _this = this;
+                if (this.entity) {
+                    return;
                 }
-                else {
-                    viewRect.east = cameraPosition.longitude;
-                    viewRect.west = cameraPosition.longitude;
-                    viewRect.south = cameraPosition.latitude;
-                    viewRect.north = cameraPosition.latitude;
+                this.entity = this.viewer.entities.add({
+                    position: new Cesium.CallbackProperty(function () {
+                        return _this.target ? Cesium.Cartesian3.fromDegrees(_this.target.longitude, _this.target.latitude) : null;
+                    }, false),
+                    point: {
+                        pixelSize: 8,
+                        color: Cesium.Color.ORANGE
+                    },
+                    rectangle: {
+                        coordinates: new Cesium.CallbackProperty(function () {
+                            return _this.bounds ? Cesium.Rectangle.fromDegrees(_this.bounds.west, _this.bounds.south, _this.bounds.east, _this.bounds.north) : null;
+                        }, false),
+                        material: Cesium.Color.fromCssColorString('#ff0000').withAlpha(0.4),
+                        zIndex: 1
+                    }
+                });
+            };
+            Monitor.prototype.destroyEntity = function () {
+                if (this.entity && this.viewer.entities.contains(this.entity)) {
+                    this.viewer.entities.remove(this.entity);
                 }
-                center = {};
-                center.latitude = Cesium.Math.toDegrees(camera.positionCartographic.latitude);
-                center.longitude = Cesium.Math.toDegrees(camera.positionCartographic.longitude);
-            }
-            else {
-                // View area calculation.
-                var windowPosition = new Cesium.Cartesian2(this.viewer.container.clientWidth / 2, this.viewer.container.clientHeight / 2);
-                var intersection = getAdjustedGroundIntersectionOfCameraRay(this.viewer, windowPosition);
-                var point = null;
-                if (intersection) {
-                    point = Cesium.Cartographic.fromCartesian(intersection, this.viewer.scene.globe.ellipsoid);
+                this.entity = null;
+            };
+            Monitor.prototype.Updated = function () {
+                if (!this.updatedEvent) {
+                    this.updatedEvent = new bruceModels.BruceEvent();
                 }
-                if (point) {
-                    center = {};
-                    center.latitude = Cesium.Math.toDegrees(point.latitude);
-                    center.longitude = Cesium.Math.toDegrees(point.longitude);
+                return this.updatedEvent;
+            };
+            Monitor.prototype.GetBounds = function () {
+                return this.bounds;
+            };
+            Monitor.prototype.GetTarget = function () {
+                return this.target;
+            };
+            Monitor.prototype.DoUpdate = function () {
+                this.tryEmitUpdate();
+            };
+            Monitor.prototype.Dispose = function () {
+                if (this.disposed) {
+                    return;
+                }
+                this.disposed = true;
+                clearInterval(this.checkInterval);
+                this.destroyEntity();
+            };
+            Monitor.prototype.tryDoUpdate = function () {
+                var _a;
+                if (!this.viewer || this.viewer.isDestroyed()) {
+                    this.Dispose();
+                    return ESearchStatus.LocationMissing;
+                }
+                var viewRect = null;
+                var center = null;
+                var camera = this.viewer.camera;
+                var terrainHeight = this.viewer.scene.globe.getHeight(camera.positionCartographic);
+                var cameraPosition = this.viewer.camera.positionCartographic;
+                // We are almost at the ground, screw horizon, just load around.
+                if (terrainHeight && ((cameraPosition.height - terrainHeight) < DEFAULT_GROUNDED_HEIGHT)) {
+                    // View area calculation.
+                    viewRect = {};
                     var viewRectRad = netScanViewForBoundaries(this.viewer);
-                    if (viewRectRad) {
-                        viewRect = {};
-                        viewRect.east = Cesium.Math.toDegrees(viewRectRad.east);
-                        viewRect.west = Cesium.Math.toDegrees(viewRectRad.west);
-                        viewRect.south = Cesium.Math.toDegrees(viewRectRad.south);
-                        viewRect.north = Cesium.Math.toDegrees(viewRectRad.north);
+                    if (viewRectRad &&
+                        viewRectRad.east &&
+                        viewRectRad.west &&
+                        viewRectRad.north &&
+                        viewRectRad.south) {
+                        viewRect.east = Cesium.Math.toDegrees(Math.max(viewRectRad.east, cameraPosition.longitude));
+                        viewRect.west = Cesium.Math.toDegrees(Math.min(viewRectRad.west, cameraPosition.longitude));
+                        viewRect.south = Cesium.Math.toDegrees(Math.min(viewRectRad.south, cameraPosition.latitude));
+                        viewRect.north = Cesium.Math.toDegrees(Math.max(viewRectRad.north, cameraPosition.latitude));
+                    }
+                    else {
+                        viewRect.east = cameraPosition.longitude;
+                        viewRect.west = cameraPosition.longitude;
+                        viewRect.south = cameraPosition.latitude;
+                        viewRect.north = cameraPosition.latitude;
                     }
+                    center = {};
+                    center.latitude = Cesium.Math.toDegrees(camera.positionCartographic.latitude);
+                    center.longitude = Cesium.Math.toDegrees(camera.positionCartographic.longitude);
                 }
-            }
-            // Minimal field of view.
-            if (viewRect) {
-                var centerLong = (viewRect.east + viewRect.west) / 2;
-                var centerLat = (viewRect.north + viewRect.south) / 2;
-                viewRect.east = Math.max(viewRect.east, centerLong + (MINIMUM_VIEW_AREA_SIZE_DEGREES / 2));
-                viewRect.west = Math.min(viewRect.west, centerLong - (MINIMUM_VIEW_AREA_SIZE_DEGREES / 2));
-                viewRect.south = Math.min(viewRect.south, centerLat - (MINIMUM_VIEW_AREA_SIZE_DEGREES / 2));
-                viewRect.north = Math.max(viewRect.north, centerLat + (MINIMUM_VIEW_AREA_SIZE_DEGREES / 2));
-                viewRect.alt = (_a = this.viewer.scene.camera.positionCartographic) === null || _a === void 0 ? void 0 : _a.height;
-            }
-            if (center && viewRect) {
-                if ((!this.target || (this.target && !arePosEqual(this.target, center))) ||
-                    (!this.bounds || (this.bounds && !areBoundsEqual(this.bounds, viewRect)))) {
-                    this.target = center;
-                    this.bounds = viewRect;
-                    return ESearchStatus.LocationChanged;
+                else {
+                    // View area calculation.
+                    var windowPosition = new Cesium.Cartesian2(this.viewer.container.clientWidth / 2, this.viewer.container.clientHeight / 2);
+                    var intersection = getAdjustedGroundIntersectionOfCameraRay(this.viewer, windowPosition);
+                    var point = null;
+                    if (intersection) {
+                        point = Cesium.Cartographic.fromCartesian(intersection, this.viewer.scene.globe.ellipsoid);
+                    }
+                    if (point) {
+                        center = {};
+                        center.latitude = Cesium.Math.toDegrees(point.latitude);
+                        center.longitude = Cesium.Math.toDegrees(point.longitude);
+                        var viewRectRad = netScanViewForBoundaries(this.viewer);
+                        if (viewRectRad) {
+                            viewRect = {};
+                            viewRect.east = Cesium.Math.toDegrees(viewRectRad.east);
+                            viewRect.west = Cesium.Math.toDegrees(viewRectRad.west);
+                            viewRect.south = Cesium.Math.toDegrees(viewRectRad.south);
+                            viewRect.north = Cesium.Math.toDegrees(viewRectRad.north);
+                        }
+                    }
                 }
-                return ESearchStatus.LocationFound;
-            }
-            return ESearchStatus.LocationMissing;
-        };
-        CesiumViewMonitor.prototype.tryEmitUpdate = function () {
-            var _a;
-            var searchResult = this.tryDoUpdate();
-            if (searchResult == ESearchStatus.LocationChanged) {
-                var interest = {
-                    bounds: this.bounds,
-                    target: this.target
-                };
-                //this.createEntity();
-                (_a = this.updatedEvent) === null || _a === void 0 ? void 0 : _a.Trigger(interest);
-            }
-            else if (searchResult == ESearchStatus.LocationMissing) {
-                this.updateQueue();
-            }
-        };
-        CesiumViewMonitor.prototype.queuePosition = function (lag) {
-            var _this = this;
-            if (this.pendingTimeout) {
-                clearTimeout(this.pendingTimeout);
-            }
-            this.pendingTimeout = setTimeout(function () {
-                if (!_this.disposed) {
-                    _this.tryEmitUpdate();
+                // Minimal field of view.
+                if (viewRect) {
+                    var centerLong = (viewRect.east + viewRect.west) / 2;
+                    var centerLat = (viewRect.north + viewRect.south) / 2;
+                    viewRect.east = Math.max(viewRect.east, centerLong + (MINIMUM_VIEW_AREA_SIZE_DEGREES / 2));
+                    viewRect.west = Math.min(viewRect.west, centerLong - (MINIMUM_VIEW_AREA_SIZE_DEGREES / 2));
+                    viewRect.south = Math.min(viewRect.south, centerLat - (MINIMUM_VIEW_AREA_SIZE_DEGREES / 2));
+                    viewRect.north = Math.max(viewRect.north, centerLat + (MINIMUM_VIEW_AREA_SIZE_DEGREES / 2));
+                    viewRect.alt = (_a = this.viewer.scene.camera.positionCartographic) === null || _a === void 0 ? void 0 : _a.height;
+                }
+                if (center && viewRect) {
+                    if ((!this.target || (this.target && !arePosEqual(this.target, center))) ||
+                        (!this.bounds || (this.bounds && !areBoundsEqual(this.bounds, viewRect)))) {
+                        this.target = center;
+                        this.bounds = viewRect;
+                        return ESearchStatus.LocationChanged;
+                    }
+                    return ESearchStatus.LocationFound;
                 }
-            }, lag);
-        };
-        CesiumViewMonitor.prototype.updateQueue = function () {
-            this.queuePosition(TIME_LAG);
-        };
-        return CesiumViewMonitor;
-    }());
+                return ESearchStatus.LocationMissing;
+            };
+            Monitor.prototype.tryEmitUpdate = function () {
+                var _a;
+                var searchResult = this.tryDoUpdate();
+                if (searchResult == ESearchStatus.LocationChanged) {
+                    var interest = {
+                        bounds: this.bounds,
+                        target: this.target
+                    };
+                    //this.createEntity();
+                    (_a = this.updatedEvent) === null || _a === void 0 ? void 0 : _a.Trigger(interest);
+                }
+                else if (searchResult == ESearchStatus.LocationMissing) {
+                    this.updateQueue();
+                }
+            };
+            Monitor.prototype.queuePosition = function (lag) {
+                var _this = this;
+                if (this.pendingTimeout) {
+                    clearTimeout(this.pendingTimeout);
+                }
+                this.pendingTimeout = setTimeout(function () {
+                    if (!_this.disposed) {
+                        _this.tryEmitUpdate();
+                    }
+                }, lag);
+            };
+            Monitor.prototype.updateQueue = function () {
+                this.queuePosition(TIME_LAG);
+            };
+            return Monitor;
+        }());
+        CesiumViewMonitor.Monitor = Monitor;
+    })(exports.CesiumViewMonitor || (exports.CesiumViewMonitor = {}));
 
     /*! *****************************************************************************
     Copyright (c) Microsoft Corporation. All rights reserved.
@@ -5044,7 +5047,7 @@
             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 = 100;
+            var numberOfSubdivisions = 5;
             var positions = [];
             for (var i = 0; i < numberOfSubdivisions; i++) {
                 var theta = i * (2 * Math.PI / numberOfSubdivisions);
@@ -5089,7 +5092,7 @@
             if (positions) {
                 boundingSphere = computeBoundingSphereFromPositions(positions);
                 if (cEntity.model) {
-                    // Expand the bounding sphere for models due to our tolerance
+                    // 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;
@@ -5102,17 +5105,24 @@
         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 LAST_RECHECK_KEY = Symbol("LAST_RECHECK_KEY");
     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] = {
@@ -5121,7 +5131,7 @@
             };
             return true;
         }
-        var _a = lastRecheck, position = _a.position, direction = _a.direction;
+        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;
@@ -5222,7 +5232,7 @@
                 (_a = checkQueue.Call) === null || _a === void 0 ? void 0 : _a.call(checkQueue);
             });
             var RENDER_SECS_PASSED = 5;
-            var updateRemoval = register.Viewer.scene.postRender.addEventListener(function () {
+            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) {
@@ -7558,6 +7568,94 @@
         EntitiesRenderManager.Manager = Manager;
     })(exports.EntitiesRenderManager || (exports.EntitiesRenderManager = {}));
 
+    var MAX_AREA_IN_DEGREES = 90;
+    var GETTER_DELAY = 50;
+    /**
+     * This is a batched "arbitrary data" getter.
+     * You feed it an array of data, then it will emit that data in batches when the view changes.
+     */
+    var BatchedDataGetter;
+    (function (BatchedDataGetter) {
+        var Getter = /** @class */ (function () {
+            function Getter(data, viewPort, batchSize) {
+                this.viewPortRemoval = null;
+                this.viewRect = null;
+                this.viewCenter = null;
+                this.onUpdate = null;
+                this.data = data;
+                this.viewPort = viewPort;
+                this.batchSize = batchSize;
+            }
+            Object.defineProperty(Getter.prototype, "OnUpdate", {
+                get: function () {
+                    if (!this.onUpdate) {
+                        this.onUpdate = new bruceModels.BruceEvent();
+                    }
+                    return this.onUpdate;
+                },
+                enumerable: false,
+                configurable: true
+            });
+            Getter.prototype.Start = function () {
+                var _this = this;
+                this.viewPortRemoval = this.viewPort.Updated().Subscribe(function () {
+                    _this.updateViewport();
+                });
+                this.updateViewport();
+            };
+            Getter.prototype.Dispose = function () {
+                var _a;
+                (_a = this.viewPortRemoval) === null || _a === void 0 ? void 0 : _a.call(this);
+            };
+            Getter.prototype.updateViewport = function () {
+                this.updateBounds();
+                this.startGetterLoop();
+            };
+            Getter.prototype.updateBounds = function () {
+                var viewRect = this.viewPort.GetBounds();
+                var poi = this.viewPort.GetTarget();
+                if (viewRect && poi) {
+                    if (Math.abs(viewRect.west - viewRect.east) > MAX_AREA_IN_DEGREES) {
+                        return;
+                    }
+                    if (Math.abs(viewRect.south - viewRect.north) > MAX_AREA_IN_DEGREES) {
+                        return;
+                    }
+                    this.viewRect = viewRect;
+                    this.viewCenter = poi;
+                }
+            };
+            Getter.prototype.startGetterLoop = function () {
+                var _this = this;
+                clearInterval(this.getterInterval);
+                if (!this.viewRect || !this.viewCenter) {
+                    return;
+                }
+                var index = 0;
+                var onTick = function () {
+                    _this.processBatch(_this.data.slice(index, index + _this.batchSize));
+                    index += _this.batchSize;
+                    return index >= _this.data.length;
+                };
+                if (!onTick()) {
+                    this.getterInterval = setInterval(function () {
+                        if (onTick()) {
+                            clearInterval(_this.getterInterval);
+                        }
+                    }, GETTER_DELAY);
+                }
+            };
+            Getter.prototype.processBatch = function (batch) {
+                var _a;
+                if (batch.length > 0) {
+                    (_a = this.onUpdate) === null || _a === void 0 ? void 0 : _a.Trigger(batch);
+                }
+            };
+            return Getter;
+        }());
+        BatchedDataGetter.Getter = Getter;
+    })(BatchedDataGetter || (BatchedDataGetter = {}));
+
     var BATCH_SIZE$1 = 500;
     var CHECK_BATCH_SIZE$1 = 250;
     (function (EntitiesLoadedRenderManager) {
@@ -7681,7 +7779,7 @@
                 var _this = this;
                 var _a;
                 (_a = this.getterSub) === null || _a === void 0 ? void 0 : _a.call(this);
-                this.getter = new bruceModels.BatchedDataGetter.Getter(this.item.BruceEntity.Entities, this.monitor, BATCH_SIZE$1);
+                this.getter = new BatchedDataGetter.Getter(this.item.BruceEntity.Entities, this.monitor, BATCH_SIZE$1);
                 this.getterSub = this.getter.OnUpdate.Subscribe(function (entities) {
                     var _a;
                     for (var _i = 0, entities_1 = entities; _i < entities_1.length; _i++) {
@@ -7945,7 +8043,7 @@
                         }
                     ];
                 }
-                this.getter = new bruceModels.BatchedDataGetter.Getter(this.item.BruceEntity.EntityIds, this.monitor, BATCH_SIZE$2);
+                this.getter = new BatchedDataGetter.Getter(this.item.BruceEntity.EntityIds, this.monitor, BATCH_SIZE$2);
                 this.getterSub = this.getter.OnUpdate.Subscribe(function (ids) {
                     _this.onGetterUpdate(ids);
                 });
@@ -8165,7 +8263,7 @@
                         }
                     ];
                 }
-                this.getter = new bruceModels.BatchedDataGetter.Getter([this.item.BruceEntity.EntityId], this.monitor, 1);
+                this.getter = new BatchedDataGetter.Getter([this.item.BruceEntity.EntityId], this.monitor, 1);
                 this.getterSub = this.getter.OnUpdate.Subscribe(function (ids) {
                     _this.onGetterUpdate(ids[0]);
                 });
@@ -9569,6 +9667,521 @@
         TilesetCadRenderManager.Manager = Manager;
     })(exports.TilesetCadRenderManager || (exports.TilesetCadRenderManager = {}));
 
+    /**
+     * This is a helper for making entity requests based on a grid area.
+     * It will return grid cells based on given view-area then will remember when stuff-
+     * was fully-fetched for those cells to avoid making duplicate requests.
+     */
+    var EntityGlobe;
+    (function (EntityGlobe) {
+        var Cell = /** @class */ (function () {
+            function Cell() {
+                this.Fetched = false;
+                this.IsFetched = null;
+                this.FetchPageIndex = 0;
+                this.Boundaries = null;
+                this.Fetching = false;
+            }
+            Cell.prototype.GetBounds = function () {
+                // Entity data works in -180 to 180 range.
+                function prepareRangeForBounds(range) {
+                    if (range > 180) {
+                        return range - 360;
+                    }
+                    return range;
+                }
+                // Add minor decimal as API crashes when giving it whole numbers.
+                var maxLon = prepareRangeForBounds(this.Boundaries.maxLongitude) + 0.00001;
+                var minLon = prepareRangeForBounds(this.Boundaries.minLongitude) - 0.00001;
+                var maxLat = prepareRangeForBounds(this.Boundaries.maxLatitude) + 0.00001;
+                var minLat = prepareRangeForBounds(this.Boundaries.minLatitude) - 0.00001;
+                return {
+                    east: maxLon,
+                    north: maxLat,
+                    south: minLat,
+                    west: minLon
+                };
+            };
+            return Cell;
+        }());
+        EntityGlobe.Cell = Cell;
+        var Grid = /** @class */ (function () {
+            function Grid() {
+                this.cells = {};
+            }
+            Grid.prototype.GetCellsForView = function (cameraPos, viewRect) {
+                var cells = [];
+                var minLat = viewRect.south;
+                var minLon = viewRect.west;
+                var maxLat = viewRect.north;
+                var maxLon = viewRect.east;
+                var MAX_CELLS = 150;
+                var cellDegreeSize = getCellSizeFromHeight(viewRect.alt);
+                var curMinLon = floorValueToCellSize(cellDegreeSize, minLon);
+                var curMinLat = floorValueToCellSize(cellDegreeSize, minLat);
+                // For larger views we add additional padding because our view-area culling is too strong.
+                if (cellDegreeSize >= 2) {
+                    curMinLon -= cellDegreeSize;
+                    curMinLat -= cellDegreeSize;
+                }
+                var centerX = cameraPos === null || cameraPos === void 0 ? void 0 : cameraPos.longitude;
+                var centerY = cameraPos === null || cameraPos === void 0 ? void 0 : cameraPos.latitude;
+                if (isNaN(centerX) || isNaN(centerY)) {
+                    centerX = (minLon + maxLon) / 2;
+                    centerY = (minLat + maxLat) / 2;
+                }
+                var width = Math.ceil((maxLon - curMinLon) / cellDegreeSize);
+                var height = Math.ceil((maxLat - curMinLat) / cellDegreeSize);
+                // For larger views we add additional padding because our view-area culling is too strong.
+                if (cellDegreeSize >= 2) {
+                    width += 1;
+                    height += 1;
+                }
+                var cellDistances = [];
+                for (var x = 0; x < width; x++) {
+                    for (var y = 0; y < height; y++) {
+                        var lon = x * cellDegreeSize + curMinLon;
+                        var lat = y * cellDegreeSize + curMinLat;
+                        var cellCenterX = lon + cellDegreeSize / 2;
+                        var cellCenterY = lat + cellDegreeSize / 2;
+                        var dist = Math.sqrt(Math.pow(cellCenterX - centerX, 2) + Math.pow(cellCenterY - centerY, 2));
+                        cellDistances.push({ x: x, y: y, dist: dist });
+                    }
+                }
+                cellDistances.sort(function (a, b) { return a.dist - b.dist; });
+                for (var _i = 0, cellDistances_1 = cellDistances; _i < cellDistances_1.length; _i++) {
+                    var _a = cellDistances_1[_i], x = _a.x, y = _a.y;
+                    var lon = x * cellDegreeSize + curMinLon;
+                    var lat = y * cellDegreeSize + curMinLat;
+                    var _b = getOrCreateCell(this.cells, cellDegreeSize, lon, lon + cellDegreeSize, lat, lat + cellDegreeSize), cell = _b[1];
+                    cells.push(cell);
+                    if (cells.length >= MAX_CELLS) {
+                        break;
+                    }
+                }
+                return cells;
+            };
+            return Grid;
+        }());
+        EntityGlobe.Grid = Grid;
+    })(EntityGlobe || (EntityGlobe = {}));
+    function floorValueToCellSize(size, value) {
+        return Math.floor(value / size) * size;
+    }
+    function getCellSizeFromHeight(height) {
+        if (height < 1000) {
+            return 0.01;
+        }
+        if (height < 5000) {
+            return 0.025;
+        }
+        else if (height < 10000) {
+            return 0.05;
+        }
+        else if (height < 30000) {
+            return 0.1;
+        }
+        else if (height < 70000) {
+            return 0.2;
+        }
+        else if (height < 100000) {
+            return 0.3;
+        }
+        else if (height < 150000) {
+            return 0.4;
+        }
+        else if (height < 200000) {
+            return 0.5;
+        }
+        else if (height < 300000) {
+            return 0.6;
+        }
+        else if (height < 500000) {
+            return 1;
+        }
+        else if (height < 1000000) {
+            return 1.3;
+        }
+        else if (height < 1200000) {
+            return 1.8;
+        }
+        return 4;
+    }
+    function isCellFetched(cell) {
+        if (cell.Fetched) {
+            return true;
+        }
+        return false;
+    }
+    function getOrCreateCell(cells, cellSize, lon, maxLon, lat, maxLat) {
+        var id = cellSize + "_" + lon + "_" + maxLon + "_" + lat + "_" + maxLat;
+        var cell = cells[id];
+        if (!cell) {
+            cell = cells[id] = new EntityGlobe.Cell();
+            cell.Boundaries = {
+                minLatitude: lat,
+                maxLatitude: maxLat,
+                minLongitude: lon,
+                maxLongitude: maxLon
+            };
+            cell.IsFetched = function () { return isCellFetched(cell); };
+        }
+        return [id, cell];
+    }
+
+    var MAX_AREA_IN_DEGREES$1 = 90;
+    var MAX_RETRY_ATTEMPTS = 1;
+    var RETRY_DELAY_INCREMENT = 500;
+    var REQUEST_PAGE_DELAY = 50;
+    var regMenuItemGetter = /** @class */ (function () {
+        function regMenuItemGetter(tagIds, minHeight, maxHeight) {
+            this.TagIds = tagIds;
+            this.MinHeight = minHeight;
+            this.MaxHeight = maxHeight;
+        }
+        return regMenuItemGetter;
+    }());
+    function delay(milliseconds) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, new Promise(function (res) {
+                        setTimeout(function () {
+                            res();
+                        }, milliseconds);
+                    })];
+            });
+        });
+    }
+    /**
+     * This is a batched entity getter.
+     * It will scan for entity records in a view-area and emit them in batches.
+     * It will restart scanning if the camera moves.
+     */
+    var EntityFilterGetter;
+    (function (EntityFilterGetter) {
+        var EStatus;
+        (function (EStatus) {
+            EStatus["Scanning"] = "SCANNING";
+            EStatus["Loading"] = "LOADING";
+        })(EStatus = EntityFilterGetter.EStatus || (EntityFilterGetter.EStatus = {}));
+        var Getter = /** @class */ (function () {
+            function Getter(api, viewPort, typeId, batchSize, attrFilter, viaCdn) {
+                this.onUpdate = null;
+                this.LastStateUpdates = {};
+                this.onStateUpdate = null;
+                this.onScanUpdate = null;
+                this.viewPortChangeRemoval = null;
+                this.cells = null;
+                this.registeredItems = {};
+                this.getterLoopId = 0;
+                this.tagIds = null;
+                this.minHeight = 0;
+                this.maxHeight = 100000;
+                this.viewRect = null;
+                this.viewCenter = null;
+                this.api = api;
+                this.typeId = typeId;
+                this.viaCdn = Boolean(viaCdn);
+                this.batchSize = isNaN(batchSize) ? 300 : batchSize;
+                this.viewPort = viewPort;
+                this.attrFilter = attrFilter;
+                this.updateBounds();
+            }
+            Object.defineProperty(Getter.prototype, "OnUpdate", {
+                get: function () {
+                    if (!this.onUpdate) {
+                        this.onUpdate = new bruceModels.BruceEvent();
+                    }
+                    return this.onUpdate;
+                },
+                enumerable: false,
+                configurable: true
+            });
+            Object.defineProperty(Getter.prototype, "OnStateUpdate", {
+                get: function () {
+                    if (!this.onStateUpdate) {
+                        this.onStateUpdate = new bruceModels.BruceEvent();
+                    }
+                    return this.onStateUpdate;
+                },
+                enumerable: false,
+                configurable: true
+            });
+            Object.defineProperty(Getter.prototype, "OnScanUpdate", {
+                get: function () {
+                    if (!this.onScanUpdate) {
+                        this.onScanUpdate = new bruceModels.BruceEvent();
+                    }
+                    return this.onScanUpdate;
+                },
+                enumerable: false,
+                configurable: true
+            });
+            /**
+             * Returns id that represents the combined menu item parameters.
+             * If integrity changes while a request is running, the request will not emit a response.
+             * @returns
+             */
+            Getter.prototype.getIntegrityId = function () {
+                return this.tagIds == null ? "" : this.tagIds.join();
+            };
+            Getter.prototype.viewAreaSub = function () {
+                var _this = this;
+                this.viewAreaDispose();
+                this.viewPortChangeRemoval = this.viewPort.Updated().Subscribe(function () {
+                    _this.updateBounds();
+                    _this.startGetterLoop();
+                });
+            };
+            Getter.prototype.viewAreaDispose = function () {
+                var _a;
+                (_a = this.viewPortChangeRemoval) === null || _a === void 0 ? void 0 : _a.call(this);
+            };
+            Getter.prototype.GetMenuItems = function () {
+                return Object.keys(this.registeredItems);
+            };
+            Getter.prototype.IncludeMenuItem = function (menuItemId, layerIds, minHeight, maxHeight) {
+                this.registeredItems[menuItemId] = new regMenuItemGetter(layerIds, minHeight, maxHeight);
+                this.updateState();
+            };
+            Getter.prototype.ExcludeMenuItem = function (menuItemId) {
+                this.registeredItems[menuItemId] = null;
+                delete this.registeredItems[menuItemId];
+                this.updateState();
+            };
+            Getter.prototype.updateBounds = function () {
+                var viewRect = this.viewPort.GetBounds();
+                var poi = this.viewPort.GetTarget();
+                if (viewRect && poi) {
+                    if (Math.abs(viewRect.west - viewRect.east) > MAX_AREA_IN_DEGREES$1) {
+                        return;
+                    }
+                    if (Math.abs(viewRect.south - viewRect.north) > MAX_AREA_IN_DEGREES$1) {
+                        return;
+                    }
+                    this.viewRect = viewRect;
+                    this.viewCenter = poi;
+                }
+            };
+            Getter.prototype.updateState = function () {
+                var tagIds = [];
+                var menuItemIds = this.GetMenuItems();
+                var minHeight = null;
+                var maxHeight = null;
+                for (var i = 0; i < menuItemIds.length; i++) {
+                    var menuItem = this.registeredItems[menuItemIds[i]];
+                    if (menuItem) {
+                        if (maxHeight == null || maxHeight < menuItem.MaxHeight) {
+                            maxHeight = menuItem.MaxHeight;
+                        }
+                        if (minHeight == null || minHeight > menuItem.MinHeight) {
+                            minHeight = menuItem.MinHeight;
+                        }
+                        var itemLayerIds = menuItem.TagIds;
+                        if (itemLayerIds) {
+                            for (var j = 0; j < itemLayerIds.length; j++) {
+                                var itemLayerId = itemLayerIds[j];
+                                if (!tagIds.includes(itemLayerId)) {
+                                    tagIds.push(itemLayerId);
+                                }
+                            }
+                        }
+                    }
+                }
+                if (menuItemIds.length > 0) {
+                    // Reset cells so none are marked as fetched.
+                    this.cells = new EntityGlobe.Grid();
+                    this.tagIds = tagIds;
+                    this.minHeight = minHeight;
+                    this.maxHeight = maxHeight;
+                    this.updateBounds();
+                    this.startGetterLoop();
+                    this.viewAreaSub();
+                }
+                else {
+                    this.getterLoopId += 1;
+                    this.viewAreaDispose();
+                }
+            };
+            Getter.prototype.postStatus = function (status) {
+                var _a;
+                this.LastStateUpdates[status.msg] = status;
+                (_a = this.onStateUpdate) === null || _a === void 0 ? void 0 : _a.Trigger(status);
+            };
+            Getter.prototype.startGetterLoop = function () {
+                var _this = this;
+                // Increase id so that existing loops stop.
+                this.getterLoopId += 1;
+                var loopId = this.getterLoopId;
+                var loopIntegrity = this.getIntegrityId();
+                new Promise(function () { return __awaiter(_this, void 0, void 0, function () {
+                    var MIN_HEIGHT, MAX_HEIGHT, PAGE_SIZE, retryAttempts, retryDelay, prevFirstId, prevLastId, prevTicks, alt, cells, curCellIndex, postedScanning, postedLoading, total, curCell, entities, integrity, first, last, e_1;
+                    var _a, _b, _c, _d, _e, _f, _g, _h;
+                    return __generator(this, function (_j) {
+                        switch (_j.label) {
+                            case 0: 
+                            // Minor delay to stop 50 menu items enabling doing their first request all together.
+                            // This gives it time to recognize only 1 request is needed.
+                            // Would be better to not use this delay but we're on a clock.
+                            return [4 /*yield*/, delay(100)];
+                            case 1:
+                                // Minor delay to stop 50 menu items enabling doing their first request all together.
+                                // This gives it time to recognize only 1 request is needed.
+                                // Would be better to not use this delay but we're on a clock.
+                                _j.sent();
+                                MIN_HEIGHT = this.minHeight;
+                                MAX_HEIGHT = this.maxHeight;
+                                PAGE_SIZE = this.batchSize;
+                                retryAttempts = MAX_RETRY_ATTEMPTS;
+                                retryDelay = 0;
+                                prevFirstId = "";
+                                prevLastId = "";
+                                prevTicks = 0;
+                                _j.label = 2;
+                            case 2:
+                                if (!((!this.viewCenter || !this.viewRect) && this.getterLoopId == loopId)) return [3 /*break*/, 4];
+                                return [4 /*yield*/, delay(RETRY_DELAY_INCREMENT)];
+                            case 3:
+                                _j.sent();
+                                return [3 /*break*/, 2];
+                            case 4:
+                                if (this.getterLoopId != loopId) {
+                                    return [2 /*return*/];
+                                }
+                                alt = this.viewRect.alt;
+                                if (alt > MAX_HEIGHT || (alt < MIN_HEIGHT && MIN_HEIGHT > 0)) {
+                                    return [2 /*return*/];
+                                }
+                                cells = this.cells.GetCellsForView(this.viewCenter, this.viewRect);
+                                (_a = this.onScanUpdate) === null || _a === void 0 ? void 0 : _a.Trigger(cells);
+                                curCellIndex = cells.length > 0 ? 0 : null;
+                                postedScanning = false;
+                                postedLoading = false;
+                                total = 0;
+                                _j.label = 5;
+                            case 5:
+                                if (!(retryAttempts > 0 && curCellIndex != null)) return [3 /*break*/, 13];
+                                if (!(retryDelay > 0)) return [3 /*break*/, 7];
+                                return [4 /*yield*/, delay(retryDelay)];
+                            case 6:
+                                _j.sent();
+                                _j.label = 7;
+                            case 7:
+                                if (this.getterLoopId != loopId) {
+                                    return [3 /*break*/, 13];
+                                }
+                                if (!postedScanning) {
+                                    this.postStatus({ msg: EStatus.Scanning, revoking: false });
+                                    postedScanning = true;
+                                }
+                                curCell = cells[curCellIndex];
+                                if (curCell.IsFetched()) {
+                                    curCell.Fetching = false;
+                                    curCellIndex += 1;
+                                    if (cells[curCellIndex]) {
+                                        cells[curCellIndex].Fetching = true;
+                                    }
+                                    else {
+                                        curCellIndex = null;
+                                    }
+                                    (_b = this.onScanUpdate) === null || _b === void 0 ? void 0 : _b.Trigger(cells);
+                                    return [3 /*break*/, 5];
+                                }
+                                _j.label = 8;
+                            case 8:
+                                _j.trys.push([8, 10, , 11]);
+                                return [4 /*yield*/, bruceModels.Entity.GetList({
+                                        api: this.api,
+                                        filter: {
+                                            pageSize: PAGE_SIZE,
+                                            pageIndex: curCell.FetchPageIndex,
+                                            entityTypeId: this.typeId,
+                                            layerIds: this.tagIds,
+                                            // Any tag specified will be allowed.
+                                            layerIdsOperator: "in",
+                                            bounds: curCell.GetBounds(),
+                                            sortOrder: bruceModels.Api.ESortOrder.Asc,
+                                            entityTypeConditions: this.attrFilter
+                                        },
+                                        viaCdn: this.viaCdn,
+                                        req: {
+                                            noCache: true
+                                        }
+                                    })];
+                            case 9:
+                                entities = (_j.sent()).entities;
+                                integrity = this.getIntegrityId();
+                                if (loopIntegrity == integrity && entities) {
+                                    (_c = this.onUpdate) === null || _c === void 0 ? void 0 : _c.Trigger(entities);
+                                }
+                                if (this.getterLoopId != loopId) {
+                                    return [3 /*break*/, 13];
+                                }
+                                if (entities.length) {
+                                    total += entities.length;
+                                }
+                                if (!postedLoading) {
+                                    this.postStatus({ msg: EStatus.Loading, revoking: false });
+                                    postedLoading = true;
+                                }
+                                // Only mark as fetched when ALL pages are done.
+                                // Known issue where external sources may return less than page size.
+                                // Right now we're making it as fetched as we're siding with the majority use-case.
+                                if (entities.length <= 0 || entities.length < PAGE_SIZE) {
+                                    curCell.Fetched = true;
+                                    curCell.Fetching = false;
+                                    (_d = this.onScanUpdate) === null || _d === void 0 ? void 0 : _d.Trigger(cells);
+                                    return [3 /*break*/, 5];
+                                }
+                                // Checking to make sure it's not just the same batch over and over again.
+                                if (entities.length > 0) {
+                                    first = (_f = (_e = entities[0]) === null || _e === void 0 ? void 0 : _e.Bruce) === null || _f === void 0 ? void 0 : _f.ID;
+                                    last = (_h = (_g = entities[entities.length - 1]) === null || _g === void 0 ? void 0 : _g.Bruce) === null || _h === void 0 ? void 0 : _h.ID;
+                                    if (prevFirstId == first && prevLastId == last) {
+                                        prevTicks += 1;
+                                        if (prevTicks > 3) {
+                                            return [3 /*break*/, 13];
+                                        }
+                                    }
+                                    else {
+                                        prevFirstId = first;
+                                        prevLastId = last;
+                                        prevTicks = 0;
+                                    }
+                                }
+                                curCell.FetchPageIndex++;
+                                // Request passed so let's assume it was server hiccup and refresh counts.
+                                retryAttempts = MAX_RETRY_ATTEMPTS;
+                                retryDelay = 0;
+                                return [3 /*break*/, 11];
+                            case 10:
+                                e_1 = _j.sent();
+                                console.error(e_1);
+                                // Request failed so let's add a delay and try again soon.
+                                retryDelay += RETRY_DELAY_INCREMENT;
+                                retryAttempts -= 1;
+                                return [3 /*break*/, 11];
+                            case 11: return [4 /*yield*/, delay(REQUEST_PAGE_DELAY)];
+                            case 12:
+                                _j.sent();
+                                return [3 /*break*/, 5];
+                            case 13:
+                                if (postedLoading) {
+                                    this.postStatus({ msg: EStatus.Loading, revoking: true });
+                                }
+                                if (postedScanning) {
+                                    this.postStatus({ msg: EStatus.Scanning, revoking: true });
+                                }
+                                return [2 /*return*/];
+                        }
+                    });
+                }); });
+            };
+            return Getter;
+        }());
+        EntityFilterGetter.Getter = Getter;
+    })(EntityFilterGetter || (EntityFilterGetter = {}));
+
     function createFilterGetterCacheKey(params) {
         var cacheKey = "";
         cacheKey += params.api.GetBaseUrl();
@@ -9590,7 +10203,7 @@
                 var cacheKey = createFilterGetterCacheKey(params);
                 var getter = this.data[cacheKey];
                 if (!getter) {
-                    getter = new bruceModels.EntityFilterGetter.Getter(params.api, params.monitor, params.typeId, params.batchSize, params.attrFilter, params.cdn);
+                    getter = new EntityFilterGetter.Getter(params.api, params.monitor, params.typeId, params.batchSize, params.attrFilter, params.cdn);
                     this.data[cacheKey] = getter;
                     if (params.viewer && params.debugShowBounds) {
                         // Cell id -> entity.
@@ -11671,7 +12284,7 @@
                 }
                 this.visualsRegister = visualsRegister;
                 this.sharedGetters = new exports.SharedGetters.Cache();
-                this.sharedMonitor = new CesiumViewMonitor(this.viewer);
+                this.sharedMonitor = new exports.CesiumViewMonitor.Monitor(this.viewer);
             }
             Object.defineProperty(Manager.prototype, "Getters", {
                 get: function () {
@@ -17503,10 +18116,9 @@
         ViewerUtils.CreateWidgets = CreateWidgets;
     })(exports.ViewerUtils || (exports.ViewerUtils = {}));
 
-    var VERSION$1 = "2.9.7";
+    var VERSION$1 = "2.9.9";
 
     exports.VERSION = VERSION$1;
-    exports.CesiumViewMonitor = CesiumViewMonitor;
     exports.CesiumParabola = CesiumParabola;
     exports.CESIUM_INSPECTOR_KEY = CESIUM_INSPECTOR_KEY;
     exports.Draw3dPolygon = Draw3dPolygon;