bruce-cesium 3.4.8 → 3.5.0

package/dist/bruce-cesium.umd.js

@@ -81,463 +81,878 @@
         }
     }
 
+    var TIME_LAG = 300;
+    var POSITION_CHECK_TIMER = 950;
+    var DEFAULT_GROUNDED_HEIGHT = 300;
+    var MINIMUM_VIEW_AREA_SIZE_DEGREES = 0.01;
+    var NET_STEP_PERCENT = 5;
+    var BORDER_STEPS = 3;
+    var ESearchStatus;
+    (function (ESearchStatus) {
+        ESearchStatus[ESearchStatus["LocationFound"] = 1] = "LocationFound";
+        ESearchStatus[ESearchStatus["LocationChanged"] = 2] = "LocationChanged";
+        ESearchStatus[ESearchStatus["LocationMissing"] = 3] = "LocationMissing";
+    })(ESearchStatus || (ESearchStatus = {}));
     /**
-     * Ensures a number is returned from a given value.
-     * If given value cannot be parsed it will return defaultNum.
-     * @param value
-     * @param defaultNum default is 0.
+     * @param viewer
+     * @param center the previously calculated center of the view area. This is in degrees.
      * @returns
      */
-    function EnsureNumber(value, defaultNum) {
-        if (!defaultNum) {
-            defaultNum = 0;
-        }
-        value = Number(value);
-        if (isNaN(value)) {
-            return defaultNum;
-        }
-        return value;
-    }
-
-    (function (MeasureUtils) {
-        /**
-         * Returns the total distance in meters between an array of points.
-         * This distance is NOT following the terrain.
-         * @param posses
-         * @returns
-         */
-        function MeasurePolyline(params) {
-            var posses = params.posses;
-            if (posses.length < 2) {
-                return {
-                    totalLength: 0
-                };
+    function netScanViewForBoundaries(viewer, center) {
+        var maxLong = -2 * Math.PI;
+        var minLong = 2 * Math.PI;
+        var maxLat = -2 * Math.PI;
+        var minLat = 2 * Math.PI;
+        var found = 0;
+        var updateMinMax = function (lon, lat) {
+            // Check to see if given lon/lat (in radians) are within valid range.
+            if (lon < -Math.PI || lon > Math.PI || lat < -Math.PI / 2 || lat > Math.PI / 2) {
+                return;
             }
-            var totalLength = 0;
-            var pos1 = null;
-            var pos2 = null;
-            for (var i = 0; i < posses.length; i++) {
-                if (pos1 == null) {
-                    pos1 = posses[i];
-                }
-                else if (pos2 == null) {
-                    pos2 = posses[i];
-                    totalLength += Cesium.Cartesian3.distance(pos1, pos2);
-                    pos1 = pos2;
-                    pos2 = null;
+            maxLong = Math.max(maxLong, lon);
+            maxLat = Math.max(maxLat, lat);
+            minLong = Math.min(minLong, lon);
+            minLat = Math.min(minLat, lat);
+        };
+        var updateMinMaxForPoint = function (stepX, stepY) {
+            var x = Math.round(0 + (viewer.container.clientWidth / 100) * (stepX * NET_STEP_PERCENT));
+            var y = Math.round(0 + (viewer.container.clientHeight / 100) * (stepY * NET_STEP_PERCENT));
+            var winPos = new Cesium.Cartesian2(x, y);
+            try {
+                var intersection = getAdjustedGroundIntersectionOfCameraRay(viewer, winPos);
+                if (intersection) {
+                    var point = Cesium.Cartographic.fromCartesian(intersection, viewer.scene.globe.ellipsoid);
+                    updateMinMax(point.longitude, point.latitude);
+                    found++;
                 }
             }
-            return {
-                totalLength: totalLength
-            };
-        }
-        MeasureUtils.MeasurePolyline = MeasurePolyline;
-        function MeasurePolygon(params) {
-            var posses = params.posses;
-            posses = [].concat(posses);
-            if (!bruceModels.Cartes.IsRing3Closed(posses)) {
-                posses.push(posses[0].clone());
+            catch (e) {
+                console.error(e);
             }
-            if (posses.length < 3) {
-                return {
-                    area: 0,
-                    perimeter: 0
-                };
+        };
+        // Outer circle.
+        updateMinMaxForPoint(BORDER_STEPS, BORDER_STEPS);
+        updateMinMaxForPoint((100 / NET_STEP_PERCENT) - BORDER_STEPS, BORDER_STEPS);
+        updateMinMaxForPoint(BORDER_STEPS, (100 / NET_STEP_PERCENT) - BORDER_STEPS);
+        updateMinMaxForPoint((100 / NET_STEP_PERCENT) - BORDER_STEPS, (100 / NET_STEP_PERCENT) - BORDER_STEPS);
+        // Inner circle.
+        updateMinMaxForPoint(BORDER_STEPS * 2, BORDER_STEPS * 2);
+        updateMinMaxForPoint((100 / NET_STEP_PERCENT) - BORDER_STEPS * 2, BORDER_STEPS * 2);
+        updateMinMaxForPoint(BORDER_STEPS * 2, (100 / NET_STEP_PERCENT) - BORDER_STEPS * 2);
+        updateMinMaxForPoint((100 / NET_STEP_PERCENT) - BORDER_STEPS * 2, (100 / NET_STEP_PERCENT) - BORDER_STEPS * 2);
+        // If we failed to find intersections and a center-point was provided, then we can use that to make some guesses.
+        // This happens if terrain is hidden, and there's nothing to intersect with.
+        if (center && found <= 0) {
+            updateMinMax(Cesium.Math.toRadians(center.longitude), Cesium.Math.toRadians(center.latitude));
+            found += 1;
+            // We'll use the camera height as an indicator on size of the rect.
+            var size = viewer.camera.positionCartographic.height;
+            var pitch = viewer.camera.pitch;
+            var distance = size / Math.tan(pitch);
+            var p1 = _offsetPoint({
+                altitude: center.altitude,
+                latitude: center.latitude,
+                longitude: center.longitude
+            }, distance, 45);
+            var p2 = _offsetPoint({
+                altitude: center.altitude,
+                latitude: center.latitude,
+                longitude: center.longitude
+            }, -distance, 45);
+            if (p1 === null || p1 === void 0 ? void 0 : p1.latitude) {
+                updateMinMax(Cesium.Math.toRadians(p1.longitude), Cesium.Math.toRadians(p1.latitude));
             }
-            var area = 0;
-            var indices = Cesium.PolygonPipeline.triangulate(posses, []);
-            for (var i = 0; i < indices.length; i += 3) {
-                var vector1 = posses[indices[i]];
-                var vector2 = posses[indices[i + 1]];
-                var vector3 = posses[indices[i + 2]];
-                var vectorC = Cesium.Cartesian3.subtract(vector2, vector1, new Cesium.Cartesian3());
-                var vectorD = Cesium.Cartesian3.subtract(vector3, vector1, new Cesium.Cartesian3());
-                var areaVector = Cesium.Cartesian3.cross(vectorC, vectorD, new Cesium.Cartesian3());
-                area += Cesium.Cartesian3.magnitude(areaVector) / 2.0;
+            if (p2 === null || p2 === void 0 ? void 0 : p2.latitude) {
+                updateMinMax(Cesium.Math.toRadians(p2.longitude), Cesium.Math.toRadians(p2.latitude));
             }
-            var perimeter = MeasurePolyline({
-                posses: posses
-            }).totalLength;
-            return {
-                area: area,
-                perimeter: perimeter
+        }
+        if (found > 0) {
+            var viewRect = {
+                east: maxLong,
+                west: minLong,
+                north: maxLat,
+                south: minLat
             };
+            return viewRect;
         }
-        MeasureUtils.MeasurePolygon = MeasurePolygon;
-    })(exports.MeasureUtils || (exports.MeasureUtils = {}));
-
-    var C3 = [Cesium.Cartesian3][0];
-    function getT(t, alpha, p0, p1) {
-        var d = C3.subtract(p1, p0, new C3);
-        var a = C3.dot(d, d);
-        var b = Math.pow(a, alpha * 0.5);
-        return b + t;
+        return null;
     }
-    function catmullRom(p0, p1, p2, p3, t) {
-        var t0 = 0;
-        var t1 = getT(t0, 0.5, p0, p1);
-        var t2 = getT(t1, 0.5, p1, p2);
-        var t3 = getT(t2, 0.5, p2, p3);
-        t = Cesium.Math.lerp(t1, t2, t);
-        var _a = [function (l, r) { return C3.add(l, r, new C3); }, function (l, r) { return C3.multiplyByScalar(l, r, new C3); }], add = _a[0], mul = _a[1];
-        var A1 = add(mul(p0, (t1 - t) / (t1 - t0)), mul(p1, (t - t0) / (t1 - t0)));
-        var A2 = add(mul(p1, (t2 - t) / (t2 - t1)), mul(p2, (t - t1) / (t2 - t1)));
-        var A3 = add(mul(p2, (t3 - t) / (t3 - t2)), mul(p3, (t - t2) / (t3 - t2)));
-        var B1 = add(mul(A1, (t2 - t) / (t2 - t0)), mul(A2, (t - t0) / (t2 - t0)));
-        var B2 = add(mul(A2, (t3 - t) / (t3 - t1)), mul(A3, (t - t1) / (t3 - t1)));
-        var C = add(mul(B1, (t2 - t) / (t2 - t1)), mul(B2, (t - t1) / (t2 - t1)));
-        return C;
+    /**
+     * Moves a given point by a given distance towards a heading.
+     * @param point in degrees.
+     * @param distance in meters.
+     * @param heading in degrees.
+     * @returns
+     */
+    function _offsetPoint(point, distance, heading) {
+        // Radius of earth.
+        var radius = 6371e3;
+        var δ = distance / radius;
+        var θ = Cesium.Math.toRadians(heading);
+        var φ1 = Cesium.Math.toRadians(point.latitude);
+        var λ1 = Cesium.Math.toRadians(point.longitude);
+        var sinφ2 = Math.sin(φ1) * Math.cos(δ) + Math.cos(φ1) * Math.sin(δ) * Math.cos(θ);
+        var φ2 = Math.asin(sinφ2);
+        var y = Math.sin(θ) * Math.sin(δ) * Math.cos(φ1);
+        var x = Math.cos(δ) - Math.sin(φ1) * sinφ2;
+        var λ2 = λ1 + Math.atan2(y, x);
+        return {
+            altitude: point.altitude,
+            latitude: Cesium.Math.toDegrees(φ2),
+            longitude: Cesium.Math.toDegrees(λ2)
+        };
     }
-    (function (DrawingUtils) {
-        /**
-         * Returns the point across a polyline at a given distance.
-         * If the distance exceeds the length of the line, the point will be placed at the end of the line.
-         * @param viewer
-         * @param positions
-         * @param distance
-         * @returns
-         */
-        function PointAcrossPolyline(params) {
-            var viewer = params.viewer, positions = params.posses, distance = params.distance;
-            if (distance <= 0 && positions.length > 0) {
-                return {
-                    point: positions[0]
-                };
-            }
-            else if (positions.length > 1) {
-                var currentDistance = 0;
-                var totalLength = exports.MeasureUtils.MeasurePolyline({
-                    posses: positions,
-                }).totalLength;
-                if (distance > totalLength) {
-                    return {
-                        point: positions[positions.length - 1]
-                    };
-                }
-                for (var i = 0; i < positions.length - 1; i++) {
-                    var length_1 = Cesium.Cartesian3.distance(positions[i], positions[i + 1]);
-                    if (length_1 + currentDistance >= distance) {
-                        var carto1 = Cesium.Cartographic.fromCartesian(positions[i]);
-                        var carto2 = Cesium.Cartographic.fromCartesian(positions[i + 1]);
-                        var geodesic = new Cesium.EllipsoidGeodesic(carto1, carto2, viewer.scene.globe.ellipsoid);
-                        //const position = geodesic.interpolateUsingSurfaceDistance(distance - currentDistance);
-                        var position = geodesic.interpolateUsingFraction((distance - currentDistance) / length_1);
-                        var height = (carto1.height + carto2.height) / 2;
-                        return {
-                            point: Cesium.Cartesian3.fromRadians(position.longitude, position.latitude, height)
-                        };
-                    }
-                    else {
-                        currentDistance += length_1;
-                    }
-                }
-            }
-            return {
-                point: positions.length ? positions[positions.length - 1] : null
-            };
-        }
-        DrawingUtils.PointAcrossPolyline = PointAcrossPolyline;
-        /**
-         * Returns terrain height from current viewer's provider.
-         * On error or flat terrain, it will return 0.
-         * If an error occurred it will be attached to the result.
-         * @param pos3d
-         * @param viewer
-         * @returns
-         */
-        function GetTerrainHeight(params) {
-            return __awaiter(this, void 0, void 0, function () {
-                var pos3d, viewer, sample, height, e_1;
-                return __generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0:
-                            pos3d = params.pos3d, viewer = params.viewer;
-                            _a.label = 1;
-                        case 1:
-                            _a.trys.push([1, 3, , 4]);
-                            // If the terrain provider is not ready let's not ping it.
-                            if (!viewer.terrainProvider || viewer.terrainProvider["ready"] == false) {
-                                return [2 /*return*/, {
-                                        height: 0,
-                                        error: "Terrain provider not ready."
-                                    }];
-                            }
-                            if (viewer.scene.terrainProvider instanceof Cesium.EllipsoidTerrainProvider) {
-                                return [2 /*return*/, {
-                                        height: 0
-                                    }];
-                            }
-                            return [4 /*yield*/, Cesium.sampleTerrainMostDetailed(viewer.scene.terrainProvider, [Cesium.Cartographic.fromCartesian(pos3d)])];
-                        case 2:
-                            sample = _a.sent();
-                            height = (sample === null || sample === void 0 ? void 0 : sample.length) ? sample[0].height : null;
-                            if (isNaN(height)) {
-                                return [2 /*return*/, {
-                                        height: 0,
-                                        error: "NaN"
-                                    }];
-                            }
-                            return [2 /*return*/, {
-                                    height: height
-                                }];
-                        case 3:
-                            e_1 = _a.sent();
-                            return [2 /*return*/, {
-                                    height: 0,
-                                    error: e_1
-                                }];
-                        case 4: return [2 /*return*/];
-                    }
-                });
-            });
+    /**
+     * @param pos3d
+     * @param distance in meters
+     * @param heading in degrees
+     * @returns
+     */
+    function _offsetPos3d(pos3d, distance, heading) {
+        var carto = Cesium.Cartographic.fromCartesian(pos3d);
+        var newCarto = _offsetPoint({
+            altitude: carto.height,
+            latitude: Cesium.Math.toDegrees(carto.latitude),
+            longitude: Cesium.Math.toDegrees(carto.longitude)
+        }, distance, heading);
+        return Cesium.Cartesian3.fromDegrees(newCarto.longitude, newCarto.latitude, newCarto.altitude);
+    }
+    /**
+     * Returns the intersection of the camera ray with the ground.
+     * @param viewer
+     * @param screenPos
+     * @returns
+     */
+    function getAdjustedGroundIntersectionOfCameraRay(viewer, screenPos) {
+        var ray = viewer.camera.getPickRay(screenPos);
+        var intersection = ray ? viewer.scene.globe.pick(ray, viewer.scene) : null;
+        if (intersection) {
+            return intersection;
         }
-        DrawingUtils.GetTerrainHeight = GetTerrainHeight;
-        function EnsurePosHeight(params) {
-            var pos3d = params.pos3d, viewer = params.viewer, desiredHeightRef = params.desiredHeightRef, heightRef = params.heightRef;
-            var carto = bruceModels.Cartes.ValidateCartes3(pos3d) ? Cesium.Cartographic.fromCartesian(pos3d) : null;
-            if (!(carto === null || carto === void 0 ? void 0 : carto.latitude)) {
-                return pos3d;
-            }
-            if (heightRef == null) {
-                heightRef = Cesium.HeightReference.CLAMP_TO_GROUND;
-            }
-            if (desiredHeightRef == null) {
-                desiredHeightRef = Cesium.HeightReference.CLAMP_TO_GROUND;
-            }
-            if (heightRef == desiredHeightRef) {
-                return pos3d;
-            }
-            if (heightRef == Cesium.HeightReference.NONE) {
-                // Turn absolute into clamped.
-                if (desiredHeightRef == Cesium.HeightReference.CLAMP_TO_GROUND) {
-                    return Cesium.Cartesian3.fromRadians(carto.longitude, carto.latitude, 0);
-                }
-                // Turn absolute into relative (remove terrain height).
-                else if (desiredHeightRef == Cesium.HeightReference.RELATIVE_TO_GROUND) {
-                    var terrainHeight = EnsureNumber(viewer.scene.globe.getHeight(carto), 0);
-                    return Cesium.Cartesian3.fromRadians(carto.longitude, carto.latitude, carto.height - terrainHeight);
-                }
-            }
-            else if (heightRef == Cesium.HeightReference.CLAMP_TO_GROUND) {
-                var terrainHeight = EnsureNumber(viewer.scene.globe.getHeight(carto), 0);
-                return Cesium.Cartesian3.fromRadians(carto.longitude, carto.latitude, terrainHeight);
-            }
-            else if (heightRef == Cesium.HeightReference.RELATIVE_TO_GROUND) {
-                // Turn relative into absolute (add terrain height).
-                if (desiredHeightRef == Cesium.HeightReference.NONE) {
-                    var terrainHeight = EnsureNumber(viewer.scene.globe.getHeight(carto), 0);
-                    return Cesium.Cartesian3.fromRadians(carto.longitude, carto.latitude, carto.height + terrainHeight);
-                }
-                // Turn relative into clamped.
-                else if (desiredHeightRef == Cesium.HeightReference.CLAMP_TO_GROUND) {
-                    return Cesium.Cartesian3.fromRadians(carto.longitude, carto.latitude, 0);
-                }
-            }
-            return pos3d;
+        return null;
+    }
+    /**
+     * Returns the intersection of the camera ray with the ground.
+     * If no intersection is found, then a "guess" is made based on the camera angle and height.
+     * The guess is made at the center of the view! It ignores the screenPos.
+     * @param viewer
+     * @param screenPos
+     * @returns
+     */
+    function getGroundCenterOfCameraRay(viewer, screenPos) {
+        var _a, _b;
+        var ray = viewer.camera.getPickRay(screenPos);
+        var intersection = ray ? viewer.scene.globe.pick(ray, viewer.scene) : null;
+        if (intersection) {
+            return intersection;
         }
-        DrawingUtils.EnsurePosHeight = EnsurePosHeight;
+        // The fallback will be to "guess" where the intersection might be.
+        // This happens if terrain is hidden, and there's nothing to intersect with.
+        // We will use the camera angle + camera height.
+        // Eg: if camera is looking straight down and is 100 meters above the ground, then the intersection will be 100 meters below the camera.
+        var cameraHeight = viewer.camera.positionCartographic.height;
+        if (!isNaN(cameraHeight) && cameraHeight != null && ((_b = (_a = viewer.camera) === null || _a === void 0 ? void 0 : _a.position) === null || _b === void 0 ? void 0 : _b.clone)) {
+            var cameraPos3d = viewer.camera.position.clone();
+            var pitch = viewer.camera.pitch;
+            var distance = cameraHeight / Math.tan(pitch);
+            return _offsetPos3d(cameraPos3d, -distance, Cesium.Math.toDegrees(viewer.camera.heading));
+        }
+        return null;
+    }
+    function areBoundsEqual(a, b) {
+        return a.north == b.north && a.south == b.south && a.east == b.east && a.west == b.west;
+    }
+    function arePosEqual(a, b) {
+        return a.latitude == b.latitude && a.longitude == b.longitude;
+    }
+    (function (CesiumViewMonitor) {
         /**
-         * Returns an accurate 3d position from a given screen position.
-         * @param viewer
-         * @param cursor
-         * @returns
+         * Monitors and emits events when the Cesium view changes.
          */
-        DrawingUtils.GetAccuratePosition = (function () {
-            var cachedPick = null;
-            var cacheTimestamp = null;
-            var cachedCameraState = null;
-            return function (viewer, cursor, pickOnly) {
-                if (pickOnly === void 0) { pickOnly = false; }
-                var scene = viewer.scene;
-                var camera = scene.camera;
-                // Check if we can use cached position.
-                if (cachedPick && cacheTimestamp) {
-                    var timeElapsed = Date.now() - cacheTimestamp;
-                    var isWithinCacheDuration = timeElapsed < 3000; // 3 seconds
-                    var isNearPreviousPick = Cesium.Cartesian2.distanceSquared(cursor, cachedPick.cursor) < 9; // 3 pixels
-                    var directionDot = Cesium.Cartesian3.dot(camera.directionWC, cachedCameraState.direction);
-                    var directionLengths = Cesium.Cartesian3.magnitude(camera.directionWC) * Cesium.Cartesian3.magnitude(cachedCameraState.direction);
-                    var angle = Math.acos(directionDot / directionLengths);
-                    var hasCameraMoved = Math.abs(camera.positionWC.x - cachedCameraState.position.x) > 2 || // 2 meters
-                        Math.abs(camera.positionWC.y - cachedCameraState.position.y) > 2 ||
-                        angle > Cesium.Math.toRadians(5); // 5 degrees
-                    if (isWithinCacheDuration && isNearPreviousPick && !hasCameraMoved) {
-                        return cachedPick.position;
+        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.updating = false;
+                this.viewer = viewer;
+                this.tryEmitUpdate();
+                this.checkInterval = setInterval(function () {
+                    _this.updateQueue();
+                }, POSITION_CHECK_TIMER);
+            }
+            Object.defineProperty(Monitor.prototype, "Disposed", {
+                get: function () {
+                    return this.disposed;
+                },
+                enumerable: false,
+                configurable: true
+            });
+            Monitor.prototype.createEntity = function () {
+                var _this = this;
+                if (this.entity) {
+                    return;
+                }
+                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,
+                        heightReference: Cesium.HeightReference.NONE
+                    },
+                    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,
+                        heightReference: Cesium.HeightReference.NONE
                     }
+                });
+            };
+            Monitor.prototype.destroyEntity = function () {
+                if (this.entity && this.viewer.entities.contains(this.entity)) {
+                    this.viewer.entities.remove(this.entity);
                 }
-                // Actual picking logic
-                // https://community.cesium.com/t/scene-pick-returning-point-inside-the-globe/18940/9
-                var pos3d = null;
-                // Means we can accurately pick right now.
-                if (!pickOnly && scene.globe.depthTestAgainstTerrain) {
-                    pos3d = scene.pickPosition(cursor);
+                this.entity = null;
+            };
+            Monitor.prototype.Updated = function () {
+                if (!this.updatedEvent) {
+                    this.updatedEvent = new bruceModels.BruceEvent();
                 }
-                // Means we cannot guarantee an accurate pick.
-                // We want to prioritize pick-position when we can, so we'll try use it and if the result is sus then we'll use some fallbacks.
-                else {
-                    if (!pickOnly) {
-                        pos3d = scene.pickPosition(cursor);
-                    }
-                    if (Cesium.defined(pos3d)) {
-                        var carto = Cesium.Cartographic.fromCartesian(pos3d);
-                        if (!Cesium.defined(carto) || carto.height < 0) {
-                            pos3d = null;
-                        }
-                    }
-                    if (!Cesium.defined(pos3d)) {
-                        pos3d = null;
-                        var ray = scene.camera.getPickRay(cursor);
-                        if (scene.pickPositionSupported) {
-                            var pickedObject = scene.pick(cursor, 1, 1);
-                            if (Cesium.defined(pickedObject) &&
-                                (pickedObject instanceof Cesium.Cesium3DTileFeature ||
-                                    pickedObject.primitive instanceof Cesium.Cesium3DTileset ||
-                                    pickedObject.primitive instanceof Cesium.Model)) {
-                                pos3d = scene.pickPosition(cursor);
-                            }
+                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;
+                return __awaiter(this, void 0, void 0, function () {
+                    var viewRect, center, camera, terrData, cameraPosition, terrHeight, viewRectRad, windowPosition, intersection, point, viewRectRad, centerLong, centerLat;
+                    return __generator(this, function (_b) {
+                        switch (_b.label) {
+                            case 0:
+                                if (!this.viewer || this.viewer.isDestroyed()) {
+                                    this.Dispose();
+                                    return [2 /*return*/, ESearchStatus.LocationMissing];
+                                }
+                                viewRect = null;
+                                center = null;
+                                camera = this.viewer.camera;
+                                return [4 /*yield*/, exports.DrawingUtils.GetTerrainHeight({
+                                        pos3d: camera.position,
+                                        viewer: this.viewer
+                                    })];
+                            case 1:
+                                terrData = _b.sent();
+                                cameraPosition = this.viewer.camera.positionCartographic;
+                                terrHeight = terrData.error ? cameraPosition.height + DEFAULT_GROUNDED_HEIGHT : terrData.height;
+                                // We are almost at the ground, screw horizon, just load around.
+                                if (terrHeight && ((cameraPosition.height - terrHeight) < DEFAULT_GROUNDED_HEIGHT)) {
+                                    // View area calculation.
+                                    viewRect = {};
+                                    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));
+                                    }
+                                    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);
+                                }
+                                else {
+                                    windowPosition = new Cesium.Cartesian2(this.viewer.container.clientWidth / 2, this.viewer.container.clientHeight / 2);
+                                    intersection = getGroundCenterOfCameraRay(this.viewer, windowPosition);
+                                    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);
+                                        viewRectRad = netScanViewForBoundaries(this.viewer, center);
+                                        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);
+                                        }
+                                    }
+                                }
+                                // Minimal field of view.
+                                if (viewRect) {
+                                    centerLong = (viewRect.east + viewRect.west) / 2;
+                                    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 [2 /*return*/, ESearchStatus.LocationChanged];
+                                    }
+                                    return [2 /*return*/, ESearchStatus.LocationFound];
+                                }
+                                return [2 /*return*/, ESearchStatus.LocationMissing];
                         }
-                        if (!pickOnly && !Cesium.defined(pos3d)) {
-                            pos3d = scene.globe.pick(ray, scene);
+                    });
+                });
+            };
+            Monitor.prototype.tryEmitUpdate = function () {
+                var _a;
+                return __awaiter(this, void 0, void 0, function () {
+                    var searchResult, interest, e_1;
+                    return __generator(this, function (_b) {
+                        switch (_b.label) {
+                            case 0:
+                                if (this.updating) {
+                                    return [2 /*return*/];
+                                }
+                                this.updating = true;
+                                _b.label = 1;
+                            case 1:
+                                _b.trys.push([1, 3, , 4]);
+                                return [4 /*yield*/, this.tryDoUpdate()];
+                            case 2:
+                                searchResult = _b.sent();
+                                if (searchResult == ESearchStatus.LocationChanged) {
+                                    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();
+                                }
+                                return [3 /*break*/, 4];
+                            case 3:
+                                e_1 = _b.sent();
+                                console.error(e_1);
+                                this.updateQueue();
+                                return [3 /*break*/, 4];
+                            case 4:
+                                this.updating = false;
+                                return [2 /*return*/];
                         }
-                    }
+                    });
+                });
+            };
+            Monitor.prototype.queuePosition = function (lag) {
+                var _this = this;
+                if (this.pendingTimeout) {
+                    clearTimeout(this.pendingTimeout);
                 }
-                // Update cache.
-                cachedPick = {
-                    position: pos3d,
-                    cursor: cursor.clone()
-                };
-                cacheTimestamp = Date.now();
-                cachedCameraState = {
-                    position: camera.positionWC.clone(),
-                    direction: camera.directionWC.clone()
-                };
-                return pos3d;
+                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 = {}));
+
+    /**
+     * Ensures a number is returned from a given value.
+     * If given value cannot be parsed it will return defaultNum.
+     * @param value
+     * @param defaultNum default is 0.
+     * @returns
+     */
+    function EnsureNumber(value, defaultNum) {
+        if (!defaultNum) {
+            defaultNum = 0;
+        }
+        value = Number(value);
+        if (isNaN(value)) {
+            return defaultNum;
+        }
+        return value;
+    }
+
+    (function (MeasureUtils) {
         /**
-         * Smooths a given set of points.
-         * @param points
-         * @param multiplier
-         * @param closed: true if this is a closed shape. Eg: polygon.
+         * Returns the total distance in meters between an array of points.
+         * This distance is NOT following the terrain.
+         * @param posses
          * @returns
          */
-        function SmoothPoints(points, multiplier, closed) {
-            if (points.length < 4 || multiplier < 2) {
-                return points;
-            }
-            if (!closed) {
-                points.unshift(C3.subtract(points[0], points[1], new C3));
-                points.push(C3.subtract(points[points.length - 1], points[points.length - 2], new C3));
-            }
-            else {
-                points.unshift(points[points.length - 1]);
-                points.unshift(points[points.length - 2]);
-                points.push(points[2]);
+        function MeasurePolyline(params) {
+            var posses = params.posses;
+            if (posses.length < 2) {
+                return {
+                    totalLength: 0
+                };
             }
-            var splinePoints = [];
-            var _loop_1 = function (i) {
-                var _a = [0, 1, 2, 3].map(function (n) { return points[i + n]; }), P0 = _a[0], P1 = _a[1], P2 = _a[2], P3 = _a[3];
-                for (var j = 0; j <= multiplier; j++) {
-                    splinePoints.push(catmullRom(P0, P1, P2, P3, j / multiplier));
+            var totalLength = 0;
+            var pos1 = null;
+            var pos2 = null;
+            for (var i = 0; i < posses.length; i++) {
+                if (pos1 == null) {
+                    pos1 = posses[i];
+                }
+                else if (pos2 == null) {
+                    pos2 = posses[i];
+                    totalLength += Cesium.Cartesian3.distance(pos1, pos2);
+                    pos1 = pos2;
+                    pos2 = null;
                 }
-            };
-            for (var i = 0; i < points.length - 3; i++) {
-                _loop_1(i);
             }
-            return splinePoints;
+            return {
+                totalLength: totalLength
+            };
         }
-        DrawingUtils.SmoothPoints = SmoothPoints;
+        MeasureUtils.MeasurePolyline = MeasurePolyline;
+        function MeasurePolygon(params) {
+            var posses = params.posses;
+            posses = [].concat(posses);
+            if (!bruceModels.Cartes.IsRing3Closed(posses)) {
+                posses.push(posses[0].clone());
+            }
+            if (posses.length < 3) {
+                return {
+                    area: 0,
+                    perimeter: 0
+                };
+            }
+            var area = 0;
+            var indices = Cesium.PolygonPipeline.triangulate(posses, []);
+            for (var i = 0; i < indices.length; i += 3) {
+                var vector1 = posses[indices[i]];
+                var vector2 = posses[indices[i + 1]];
+                var vector3 = posses[indices[i + 2]];
+                var vectorC = Cesium.Cartesian3.subtract(vector2, vector1, new Cesium.Cartesian3());
+                var vectorD = Cesium.Cartesian3.subtract(vector3, vector1, new Cesium.Cartesian3());
+                var areaVector = Cesium.Cartesian3.cross(vectorC, vectorD, new Cesium.Cartesian3());
+                area += Cesium.Cartesian3.magnitude(areaVector) / 2.0;
+            }
+            var perimeter = MeasurePolyline({
+                posses: posses
+            }).totalLength;
+            return {
+                area: area,
+                perimeter: perimeter
+            };
+        }
+        MeasureUtils.MeasurePolygon = MeasurePolygon;
+    })(exports.MeasureUtils || (exports.MeasureUtils = {}));
+
+    var C3 = [Cesium.Cartesian3][0];
+    function getT(t, alpha, p0, p1) {
+        var d = C3.subtract(p1, p0, new C3);
+        var a = C3.dot(d, d);
+        var b = Math.pow(a, alpha * 0.5);
+        return b + t;
+    }
+    function catmullRom(p0, p1, p2, p3, t) {
+        var t0 = 0;
+        var t1 = getT(t0, 0.5, p0, p1);
+        var t2 = getT(t1, 0.5, p1, p2);
+        var t3 = getT(t2, 0.5, p2, p3);
+        t = Cesium.Math.lerp(t1, t2, t);
+        var _a = [function (l, r) { return C3.add(l, r, new C3); }, function (l, r) { return C3.multiplyByScalar(l, r, new C3); }], add = _a[0], mul = _a[1];
+        var A1 = add(mul(p0, (t1 - t) / (t1 - t0)), mul(p1, (t - t0) / (t1 - t0)));
+        var A2 = add(mul(p1, (t2 - t) / (t2 - t1)), mul(p2, (t - t1) / (t2 - t1)));
+        var A3 = add(mul(p2, (t3 - t) / (t3 - t2)), mul(p3, (t - t2) / (t3 - t2)));
+        var B1 = add(mul(A1, (t2 - t) / (t2 - t0)), mul(A2, (t - t0) / (t2 - t0)));
+        var B2 = add(mul(A2, (t3 - t) / (t3 - t1)), mul(A3, (t - t1) / (t3 - t1)));
+        var C = add(mul(B1, (t2 - t) / (t2 - t1)), mul(B2, (t - t1) / (t2 - t1)));
+        return C;
+    }
+    (function (DrawingUtils) {
+        /**
+         * Returns the point across a polyline at a given distance.
+         * If the distance exceeds the length of the line, the point will be placed at the end of the line.
+         * @param viewer
+         * @param positions
+         * @param distance
+         * @returns
+         */
+        function PointAcrossPolyline(params) {
+            var viewer = params.viewer, positions = params.posses, distance = params.distance;
+            if (distance <= 0 && positions.length > 0) {
+                return {
+                    point: positions[0]
+                };
+            }
+            else if (positions.length > 1) {
+                var currentDistance = 0;
+                var totalLength = exports.MeasureUtils.MeasurePolyline({
+                    posses: positions,
+                }).totalLength;
+                if (distance > totalLength) {
+                    return {
+                        point: positions[positions.length - 1]
+                    };
+                }
+                for (var i = 0; i < positions.length - 1; i++) {
+                    var length_1 = Cesium.Cartesian3.distance(positions[i], positions[i + 1]);
+                    if (length_1 + currentDistance >= distance) {
+                        var carto1 = Cesium.Cartographic.fromCartesian(positions[i]);
+                        var carto2 = Cesium.Cartographic.fromCartesian(positions[i + 1]);
+                        var geodesic = new Cesium.EllipsoidGeodesic(carto1, carto2, viewer.scene.globe.ellipsoid);
+                        //const position = geodesic.interpolateUsingSurfaceDistance(distance - currentDistance);
+                        var position = geodesic.interpolateUsingFraction((distance - currentDistance) / length_1);
+                        var height = (carto1.height + carto2.height) / 2;
+                        return {
+                            point: Cesium.Cartesian3.fromRadians(position.longitude, position.latitude, height)
+                        };
+                    }
+                    else {
+                        currentDistance += length_1;
+                    }
+                }
+            }
+            return {
+                point: positions.length ? positions[positions.length - 1] : null
+            };
+        }
+        DrawingUtils.PointAcrossPolyline = PointAcrossPolyline;
         /**
+         * Returns terrain height from current viewer's provider.
+         * On error or flat terrain, it will return 0.
+         * If an error occurred it will be attached to the result.
          * @param pos3d
-         * @param minimumHeight height relative to ground
+         * @param viewer
+         * @returns
          */
-        function RaisePos3d(viewer, pos3d, minimumHeight) {
-            if (minimumHeight === void 0) { minimumHeight = 0; }
+        function GetTerrainHeight(params) {
             return __awaiter(this, void 0, void 0, function () {
-                var carto, terrainCarto, sample, terrainHeight;
+                var pos3d, viewer, sample, height, e_1;
                 return __generator(this, function (_a) {
                     switch (_a.label) {
                         case 0:
+                            pos3d = params.pos3d, viewer = params.viewer;
+                            _a.label = 1;
+                        case 1:
+                            _a.trys.push([1, 3, , 4]);
                             // If the terrain provider is not ready let's not ping it.
                             if (!viewer.terrainProvider || viewer.terrainProvider["ready"] == false) {
-                                return [2 /*return*/, pos3d];
+                                return [2 /*return*/, {
+                                        height: 0,
+                                        error: "Terrain provider not ready."
+                                    }];
                             }
-                            carto = Cesium.Cartographic.fromCartesian(pos3d);
-                            terrainCarto = carto.clone();
-                            terrainCarto.height = 0;
-                            if (!(viewer.scene.terrainProvider instanceof Cesium.EllipsoidTerrainProvider)) return [3 /*break*/, 1];
-                            carto.height = Math.max(carto.height, minimumHeight);
-                            return [3 /*break*/, 3];
-                        case 1: return [4 /*yield*/, Cesium.sampleTerrainMostDetailed(viewer.scene.terrainProvider, [terrainCarto])];
+                            if (viewer.scene.terrainProvider instanceof Cesium.EllipsoidTerrainProvider) {
+                                return [2 /*return*/, {
+                                        height: 0
+                                    }];
+                            }
+                            return [4 /*yield*/, Cesium.sampleTerrainMostDetailed(viewer.scene.terrainProvider, [Cesium.Cartographic.fromCartesian(pos3d)])];
                         case 2:
                             sample = _a.sent();
-                            terrainHeight = (sample === null || sample === void 0 ? void 0 : sample.length) ? sample[0].height : null;
-                            if (terrainHeight != null) {
-                                carto.height = Math.max(carto.height, terrainHeight + minimumHeight);
+                            height = (sample === null || sample === void 0 ? void 0 : sample.length) ? sample[0].height : null;
+                            if (isNaN(height)) {
+                                return [2 /*return*/, {
+                                        height: 0,
+                                        error: "NaN"
+                                    }];
                             }
-                            _a.label = 3;
-                        case 3: return [2 /*return*/, Cesium.Cartesian3.fromRadians(carto.longitude, carto.latitude, carto.height)];
+                            return [2 /*return*/, {
+                                    height: height
+                                }];
+                        case 3:
+                            e_1 = _a.sent();
+                            return [2 /*return*/, {
+                                    height: 0,
+                                    error: e_1
+                                }];
+                        case 4: return [2 /*return*/];
                     }
                 });
             });
         }
-        DrawingUtils.RaisePos3d = RaisePos3d;
-    })(exports.DrawingUtils || (exports.DrawingUtils = {}));
-
-    /**
-     * Returns if a given visual can be styled by this utility.
-     * @param viewer
-     * @param visual
-     * @returns
-     */
-    function isAlive(viewer, visual) {
-        if (!(viewer === null || viewer === void 0 ? void 0 : viewer.scene) || viewer.isDestroyed()) {
-            return false;
-        }
-        if (visual instanceof Cesium.Entity) {
-            return true;
-        }
-        else if (visual instanceof Cesium.Primitive) {
-            return true;
-        }
-        else if (visual instanceof Cesium.Cesium3DTileFeature) {
-            var cTileset = visual === null || visual === void 0 ? void 0 : visual.tileset;
-            if (!cTileset) {
-                return false;
+        DrawingUtils.GetTerrainHeight = GetTerrainHeight;
+        function EnsurePosHeight(params) {
+            var pos3d = params.pos3d, viewer = params.viewer, desiredHeightRef = params.desiredHeightRef, heightRef = params.heightRef;
+            var carto = bruceModels.Cartes.ValidateCartes3(pos3d) ? Cesium.Cartographic.fromCartesian(pos3d) : null;
+            if (!(carto === null || carto === void 0 ? void 0 : carto.latitude)) {
+                return pos3d;
             }
-            if (cTileset.isDestroyed() || !viewer.scene.primitives.contains(cTileset)) {
-                return false;
+            if (heightRef == null) {
+                heightRef = Cesium.HeightReference.CLAMP_TO_GROUND;
             }
-            return true;
-        }
-        return false;
-    }
-    var _selectColor = Cesium.Color.fromAlpha(Cesium.Color.YELLOW, 0.5);
-    var _highlightColor = Cesium.Color.fromCssColorString("#33b1ff").withAlpha(0.5);
-    var STORE_COLOR_PREFIX = "_storeColor_";
-    function getStoreKey(key) {
-        return STORE_COLOR_PREFIX + key;
-    }
-    var STORE_KEY_STATE_PREFIX = "_storeKeyState_";
-    function getStoreStateKey(key) {
-        return STORE_KEY_STATE_PREFIX + key;
-    }
-    var LAST_APPLIED_OPACITY_KEY = "_lastAppliedOpacityKey";
-    /**
-     * Returns a color property from a graphic.
-     * This will turn materials properties into colors before returning them.
-     * @param viewer
-     * @param prop
-     * @returns
-     */
-    function getCesiumColorValue(viewer, prop) {
-        if (!prop) {
-            return Cesium.Color.WHITE;
-        }
-        if (prop.getValue) {
-            prop = prop.getValue(viewer.scene.lastRenderTime);
+            if (desiredHeightRef == null) {
+                desiredHeightRef = Cesium.HeightReference.CLAMP_TO_GROUND;
+            }
+            if (heightRef == desiredHeightRef) {
+                return pos3d;
+            }
+            if (heightRef == Cesium.HeightReference.NONE) {
+                // Turn absolute into clamped.
+                if (desiredHeightRef == Cesium.HeightReference.CLAMP_TO_GROUND) {
+                    return Cesium.Cartesian3.fromRadians(carto.longitude, carto.latitude, 0);
+                }
+                // Turn absolute into relative (remove terrain height).
+                else if (desiredHeightRef == Cesium.HeightReference.RELATIVE_TO_GROUND) {
+                    var terrainHeight = EnsureNumber(viewer.scene.globe.getHeight(carto), 0);
+                    return Cesium.Cartesian3.fromRadians(carto.longitude, carto.latitude, carto.height - terrainHeight);
+                }
+            }
+            else if (heightRef == Cesium.HeightReference.CLAMP_TO_GROUND) {
+                var terrainHeight = EnsureNumber(viewer.scene.globe.getHeight(carto), 0);
+                return Cesium.Cartesian3.fromRadians(carto.longitude, carto.latitude, terrainHeight);
+            }
+            else if (heightRef == Cesium.HeightReference.RELATIVE_TO_GROUND) {
+                // Turn relative into absolute (add terrain height).
+                if (desiredHeightRef == Cesium.HeightReference.NONE) {
+                    var terrainHeight = EnsureNumber(viewer.scene.globe.getHeight(carto), 0);
+                    return Cesium.Cartesian3.fromRadians(carto.longitude, carto.latitude, carto.height + terrainHeight);
+                }
+                // Turn relative into clamped.
+                else if (desiredHeightRef == Cesium.HeightReference.CLAMP_TO_GROUND) {
+                    return Cesium.Cartesian3.fromRadians(carto.longitude, carto.latitude, 0);
+                }
+            }
+            return pos3d;
         }
-        if (prop instanceof Cesium.Color) {
+        DrawingUtils.EnsurePosHeight = EnsurePosHeight;
+        /**
+         * Returns an accurate 3d position from a given screen position.
+         * @param viewer
+         * @param cursor
+         * @returns
+         */
+        DrawingUtils.GetAccuratePosition = (function () {
+            var cachedPick = null;
+            var cacheTimestamp = null;
+            var cachedCameraState = null;
+            return function (viewer, cursor, pickOnly) {
+                if (pickOnly === void 0) { pickOnly = false; }
+                var scene = viewer.scene;
+                var camera = scene.camera;
+                // Check if we can use cached position.
+                if (cachedPick && cacheTimestamp) {
+                    var timeElapsed = Date.now() - cacheTimestamp;
+                    var isWithinCacheDuration = timeElapsed < 3000; // 3 seconds
+                    var isNearPreviousPick = Cesium.Cartesian2.distanceSquared(cursor, cachedPick.cursor) < 9; // 3 pixels
+                    var directionDot = Cesium.Cartesian3.dot(camera.directionWC, cachedCameraState.direction);
+                    var directionLengths = Cesium.Cartesian3.magnitude(camera.directionWC) * Cesium.Cartesian3.magnitude(cachedCameraState.direction);
+                    var angle = Math.acos(directionDot / directionLengths);
+                    var hasCameraMoved = Math.abs(camera.positionWC.x - cachedCameraState.position.x) > 2 || // 2 meters
+                        Math.abs(camera.positionWC.y - cachedCameraState.position.y) > 2 ||
+                        angle > Cesium.Math.toRadians(5); // 5 degrees
+                    if (isWithinCacheDuration && isNearPreviousPick && !hasCameraMoved) {
+                        return cachedPick.position;
+                    }
+                }
+                // Actual picking logic
+                // https://community.cesium.com/t/scene-pick-returning-point-inside-the-globe/18940/9
+                var pos3d = null;
+                // Means we can accurately pick right now.
+                if (!pickOnly && scene.globe.depthTestAgainstTerrain) {
+                    pos3d = scene.pickPosition(cursor);
+                }
+                // Means we cannot guarantee an accurate pick.
+                // We want to prioritize pick-position when we can, so we'll try use it and if the result is sus then we'll use some fallbacks.
+                else {
+                    if (!pickOnly) {
+                        pos3d = scene.pickPosition(cursor);
+                    }
+                    if (Cesium.defined(pos3d)) {
+                        var carto = Cesium.Cartographic.fromCartesian(pos3d);
+                        if (!Cesium.defined(carto) || carto.height < 0) {
+                            pos3d = null;
+                        }
+                    }
+                    if (!Cesium.defined(pos3d)) {
+                        pos3d = null;
+                        var ray = scene.camera.getPickRay(cursor);
+                        if (scene.pickPositionSupported) {
+                            var pickedObject = scene.pick(cursor, 1, 1);
+                            if (Cesium.defined(pickedObject) &&
+                                (pickedObject instanceof Cesium.Cesium3DTileFeature ||
+                                    pickedObject.primitive instanceof Cesium.Cesium3DTileset ||
+                                    pickedObject.primitive instanceof Cesium.Model)) {
+                                pos3d = scene.pickPosition(cursor);
+                            }
+                        }
+                        if (!pickOnly && !Cesium.defined(pos3d)) {
+                            pos3d = scene.globe.pick(ray, scene);
+                        }
+                    }
+                }
+                // Update cache.
+                cachedPick = {
+                    position: pos3d,
+                    cursor: cursor.clone()
+                };
+                cacheTimestamp = Date.now();
+                cachedCameraState = {
+                    position: camera.positionWC.clone(),
+                    direction: camera.directionWC.clone()
+                };
+                return pos3d;
+            };
+        })();
+        /**
+         * Smooths a given set of points.
+         * @param points
+         * @param multiplier
+         * @param closed: true if this is a closed shape. Eg: polygon.
+         * @returns
+         */
+        function SmoothPoints(points, multiplier, closed) {
+            if (points.length < 4 || multiplier < 2) {
+                return points;
+            }
+            if (!closed) {
+                points.unshift(C3.subtract(points[0], points[1], new C3));
+                points.push(C3.subtract(points[points.length - 1], points[points.length - 2], new C3));
+            }
+            else {
+                points.unshift(points[points.length - 1]);
+                points.unshift(points[points.length - 2]);
+                points.push(points[2]);
+            }
+            var splinePoints = [];
+            var _loop_1 = function (i) {
+                var _a = [0, 1, 2, 3].map(function (n) { return points[i + n]; }), P0 = _a[0], P1 = _a[1], P2 = _a[2], P3 = _a[3];
+                for (var j = 0; j <= multiplier; j++) {
+                    splinePoints.push(catmullRom(P0, P1, P2, P3, j / multiplier));
+                }
+            };
+            for (var i = 0; i < points.length - 3; i++) {
+                _loop_1(i);
+            }
+            return splinePoints;
+        }
+        DrawingUtils.SmoothPoints = SmoothPoints;
+        /**
+         * @param pos3d
+         * @param minimumHeight height relative to ground
+         */
+        function RaisePos3d(viewer, pos3d, minimumHeight) {
+            if (minimumHeight === void 0) { minimumHeight = 0; }
+            return __awaiter(this, void 0, void 0, function () {
+                var carto, terrainCarto, sample, terrainHeight;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            // If the terrain provider is not ready let's not ping it.
+                            if (!viewer.terrainProvider || viewer.terrainProvider["ready"] == false) {
+                                return [2 /*return*/, pos3d];
+                            }
+                            carto = Cesium.Cartographic.fromCartesian(pos3d);
+                            terrainCarto = carto.clone();
+                            terrainCarto.height = 0;
+                            if (!(viewer.scene.terrainProvider instanceof Cesium.EllipsoidTerrainProvider)) return [3 /*break*/, 1];
+                            carto.height = Math.max(carto.height, minimumHeight);
+                            return [3 /*break*/, 3];
+                        case 1: return [4 /*yield*/, Cesium.sampleTerrainMostDetailed(viewer.scene.terrainProvider, [terrainCarto])];
+                        case 2:
+                            sample = _a.sent();
+                            terrainHeight = (sample === null || sample === void 0 ? void 0 : sample.length) ? sample[0].height : null;
+                            if (terrainHeight != null) {
+                                carto.height = Math.max(carto.height, terrainHeight + minimumHeight);
+                            }
+                            _a.label = 3;
+                        case 3: return [2 /*return*/, Cesium.Cartesian3.fromRadians(carto.longitude, carto.latitude, carto.height)];
+                    }
+                });
+            });
+        }
+        DrawingUtils.RaisePos3d = RaisePos3d;
+    })(exports.DrawingUtils || (exports.DrawingUtils = {}));
+
+    /**
+     * Returns if a given visual can be styled by this utility.
+     * @param viewer
+     * @param visual
+     * @returns
+     */
+    function isAlive(viewer, visual) {
+        if (!(viewer === null || viewer === void 0 ? void 0 : viewer.scene) || viewer.isDestroyed()) {
+            return false;
+        }
+        if (visual instanceof Cesium.Entity) {
+            return true;
+        }
+        else if (visual instanceof Cesium.Primitive) {
+            return true;
+        }
+        else if (visual instanceof Cesium.Cesium3DTileFeature) {
+            var cTileset = visual === null || visual === void 0 ? void 0 : visual.tileset;
+            if (!cTileset) {
+                return false;
+            }
+            if (cTileset.isDestroyed() || !viewer.scene.primitives.contains(cTileset)) {
+                return false;
+            }
+            return true;
+        }
+        return false;
+    }
+    var _selectColor = Cesium.Color.fromAlpha(Cesium.Color.YELLOW, 0.5);
+    var _highlightColor = Cesium.Color.fromCssColorString("#33b1ff").withAlpha(0.5);
+    var STORE_COLOR_PREFIX = "_storeColor_";
+    function getStoreKey(key) {
+        return STORE_COLOR_PREFIX + key;
+    }
+    var STORE_KEY_STATE_PREFIX = "_storeKeyState_";
+    function getStoreStateKey(key) {
+        return STORE_KEY_STATE_PREFIX + key;
+    }
+    var LAST_APPLIED_OPACITY_KEY = "_lastAppliedOpacityKey";
+    /**
+     * Returns a color property from a graphic.
+     * This will turn materials properties into colors before returning them.
+     * @param viewer
+     * @param prop
+     * @returns
+     */
+    function getCesiumColorValue(viewer, prop) {
+        if (!prop) {
+            return Cesium.Color.WHITE;
+        }
+        if (prop.getValue) {
+            prop = prop.getValue(viewer.scene.lastRenderTime);
+        }
+        if (prop instanceof Cesium.Color) {
             return prop;
         }
         var tmp = prop === null || prop === void 0 ? void 0 : prop.color;
@@ -6532,7 +6947,6 @@
             if (visible == null) {
                 visible = getShowState(rego);
             }
-            console.log("entityId", rego.entityId, "visible", visible, "overrideShow", rego.overrideShow);
             updateEntityShow(viewer, rego, visible);
             if (rego.best) {
                 var isLabelled = register.GetIsLabelled({
@@ -12702,7 +13116,7 @@
                 var _this = this;
                 var _a, _b;
                 var menuItem = this.item;
-                this.sourceId = (_a = menuItem.BruceEntity) === null || _a === void 0 ? void 0 : _a.SourceId;
+                this.sourceId = EnsureNumber((_a = menuItem.BruceEntity) === null || _a === void 0 ? void 0 : _a.SourceId, 0);
                 this.entityTypeId = (_b = menuItem.BruceEntity) === null || _b === void 0 ? void 0 : _b["EntityType.ID"];
                 (function () { return __awaiter(_this, void 0, void 0, function () {
                     var validToken, CESIUM, cTileset;
@@ -12943,10 +13357,12 @@
                                         priority: 0,
                                         visual: feature,
                                         entityTypeId: this.entityTypeId,
-                                        sourceId: this.sourceId,
                                         sourceEntityId: osmId,
                                         accountId: this.getters.GetAccountId()
                                     };
+                                    if (this.sourceId) {
+                                        rego.sourceId = this.sourceId;
+                                    }
                                     this.visualsManager.AddRego({
                                         rego: rego,
                                         requestRender: false
@@ -13390,7 +13806,7 @@
                 configurable: true
             });
             Manager.prototype.Init = function () {
-                var _a;
+                var _this = this;
                 var files = this.item.KML;
                 if (!files) {
                     return;
@@ -13398,31 +13814,47 @@
                 if (!Array.isArray(files)) {
                     files = [files];
                 }
-                for (var i = 0; i < files.length; i++) {
-                    var file = files[i];
-                    var fileId = (_a = file === null || file === void 0 ? void 0 : file.ClientFile) === null || _a === void 0 ? void 0 : _a.ID;
-                    var externalURL = file === null || file === void 0 ? void 0 : file.fileUrl;
-                    if (!fileId && !externalURL) {
-                        continue;
-                    }
-                    var api = this.apiGetter.getApi();
-                    var fileUrl = void 0;
-                    if (fileId) {
-                        fileUrl = bruceModels.ClientFile.GetUrl({
-                            api: api,
-                            fileId: fileId,
-                            viaCdn: true
-                        });
-                    }
-                    else if (externalURL) {
-                        fileUrl = externalURL;
-                    }
-                    var source = new Cesium.KmlDataSource();
-                    source.load(fileUrl);
-                    this.viewer.dataSources.add(source);
-                    this.dataSources.push(source);
-                    this.viewer.scene.requestRender();
-                }
+                (function () { return __awaiter(_this, void 0, void 0, function () {
+                    var api, i, file, fileId, externalURL, fileUrl, source;
+                    var _a;
+                    return __generator(this, function (_b) {
+                        switch (_b.label) {
+                            case 0:
+                                api = this.apiGetter.getApi();
+                                return [4 /*yield*/, api.Loading];
+                            case 1:
+                                _b.sent();
+                                if (this.disposed) {
+                                    return [2 /*return*/];
+                                }
+                                for (i = 0; i < files.length; i++) {
+                                    file = files[i];
+                                    fileId = (_a = file === null || file === void 0 ? void 0 : file.ClientFile) === null || _a === void 0 ? void 0 : _a.ID;
+                                    externalURL = file === null || file === void 0 ? void 0 : file.fileUrl;
+                                    if (!fileId && !externalURL) {
+                                        continue;
+                                    }
+                                    fileUrl = void 0;
+                                    if (fileId) {
+                                        fileUrl = bruceModels.ClientFile.GetUrl({
+                                            api: api,
+                                            fileId: fileId,
+                                            viaCdn: true
+                                        });
+                                    }
+                                    else if (externalURL) {
+                                        fileUrl = externalURL;
+                                    }
+                                    source = new Cesium.KmlDataSource();
+                                    source.load(fileUrl);
+                                    this.viewer.dataSources.add(source);
+                                    this.dataSources.push(source);
+                                    this.viewer.scene.requestRender();
+                                }
+                                return [2 /*return*/];
+                        }
+                    });
+                }); })();
             };
             Manager.prototype.Dispose = function () {
                 var _a;
@@ -18319,7 +18751,7 @@
         }
         viewer[BACKGROUND_RENDERING_KEY] = true;
         var interval = setInterval(function () {
-            if (!(viewer === null || viewer === void 0 ? void 0 : viewer.scene) || viewer.isDestroyed()) {
+            if (!(viewer === null || viewer === void 0 ? void 0 : viewer.cesiumWidget) || !(viewer === null || viewer === void 0 ? void 0 : viewer.scene) || viewer.isDestroyed()) {
                 clearInterval(interval);
                 return;
             }
@@ -18346,12 +18778,17 @@
             var viewer = params.viewer, destroyWidgets = params.destroyWidgets, styleContainer = params.styleContainer, nextspaceWidgets = params.nextspaceWidgets;
             var data = { widgets: {} };
             if (destroyWidgets != false) {
-                ViewerUtils.DestroyWidget(viewer.timeline);
-                ViewerUtils.DestroyWidget(viewer.vrButton);
-                ViewerUtils.DestroyWidget(viewer.sceneModePicker);
-                ViewerUtils.DestroyWidget(viewer.homeButton);
-                ViewerUtils.DestroyWidget(viewer.fullscreenButton);
-                ViewerUtils.DestroyWidget(viewer.baseLayerPicker);
+                try {
+                    ViewerUtils.DestroyWidget(viewer.timeline);
+                    ViewerUtils.DestroyWidget(viewer.vrButton);
+                    ViewerUtils.DestroyWidget(viewer.sceneModePicker);
+                    ViewerUtils.DestroyWidget(viewer.homeButton);
+                    ViewerUtils.DestroyWidget(viewer.fullscreenButton);
+                    ViewerUtils.DestroyWidget(viewer.baseLayerPicker);
+                }
+                catch (e) {
+                    console.error(e);
+                }
             }
             if (styleContainer != false) {
                 ViewerUtils.StyleContainer({ viewer: viewer });
@@ -20918,634 +21355,219 @@
                                 imagery = JSON.parse(JSON.stringify(imagery));
                                 for (i = 0; i < imagery.length; i++) {
                                     layer = imagery[i];
-                                    if (layer.tilesetId == bruceModels.ProjectViewTile.EDefaultImagery.BingMapsAerial) {
-                                        layer.tilesetId = bruceModels.ProjectViewTile.EDefaultImagery.MapboxSatellite;
-                                        console.warn("Cesium Ion token not set, using mapbox satellite instead of bing maps aerial.");
-                                    }
-                                    else if (layer.tilesetId == bruceModels.ProjectViewTile.EDefaultImagery.BingMapsAerialWithLabels) {
-                                        layer.tilesetId = bruceModels.ProjectViewTile.EDefaultImagery.MapboxSatellite;
-                                        console.warn("Cesium Ion token not set, using mapbox satellite instead of bing maps aerial with labels.");
-                                    }
-                                    else if (layer.tilesetId == bruceModels.ProjectViewTile.EDefaultImagery.BingMapsRoads) {
-                                        layer.tilesetId = bruceModels.ProjectViewTile.EDefaultImagery.MapBoxStreets;
-                                        console.warn("Cesium Ion token not set, using mapbox streets instead of bing maps roads.");
-                                    }
-                                }
-                            }
-                        }
-                        // We don't wait for imageries to load, this does not affect rendering other things.
-                        exports.TileRenderEngine.Map.Navigator.Render({
-                            apiGetter: params.apiGetter,
-                            tiles: imagery,
-                            viewer: params.manager.Viewer,
-                        });
-                        legacyRelationIds = bSettings === null || bSettings === void 0 ? void 0 : bSettings.renderedEntityRelations;
-                        if (!legacyRelationIds) {
-                            legacyRelationIds = [];
-                        }
-                        relations = bSettings === null || bSettings === void 0 ? void 0 : bSettings.renderedRelations;
-                        if (!relations) {
-                            relations = [];
-                        }
-                        viewer.scene.requestRender();
-                        curEnabled = params.manager.GetEnabledItemIds();
-                        newItemIds = (_5 = bSettings === null || bSettings === void 0 ? void 0 : bSettings.menuItemIds) !== null && _5 !== void 0 ? _5 : [];
-                        for (_i = 0, curEnabled_1 = curEnabled; _i < curEnabled_1.length; _i++) {
-                            id = curEnabled_1[_i];
-                            shouldRemove = void 0;
-                            if (id == RELATION_MENU_ITEM_ID) {
-                                rendered = params.manager.GetEnabledItem(id);
-                                shouldRemove = false;
-                                if (!legacyRelationIds.length && !relations.length) {
-                                    shouldRemove = true;
-                                }
-                                // If we're about to render legacy relationships but a non-legacy item is currently enabled then we remove it.
-                                else if (legacyRelationIds.length && (rendered === null || rendered === void 0 ? void 0 : rendered.type) != bruceModels.MenuItem.EType.Relations) {
-                                    shouldRemove = true;
-                                }
-                                // If we're about to render non-legacy relationships but a legacy item is currently enabled then we remove it.
-                                else if (relations.length && (rendered === null || rendered === void 0 ? void 0 : rendered.type) != bruceModels.MenuItem.EType.Relationships) {
-                                    shouldRemove = true;
-                                }
-                            }
-                            else {
-                                shouldRemove = newItemIds.indexOf(id) === -1;
-                            }
-                            if (shouldRemove) {
-                                params.manager.RemoveItemById({
-                                    menuItemId: id
-                                });
-                            }
-                        }
-                        if (!bookmark) return [3 /*break*/, 15];
-                        return [4 /*yield*/, exports.MenuItemCreator.RenderBookmarkItems({
-                                getters: params.getters,
-                                manager: params.manager,
-                                view: view,
-                                bookmark: bookmark
-                            })];
-                    case 14:
-                        _8.sent();
-                        if (!assertIteration$1(params.viewer, iteration)) {
-                            return [2 /*return*/];
-                        }
-                        _8.label = 15;
-                    case 15:
-                        if (legacyRelationIds.length || relations.length) {
-                            if (relations.length) {
-                                menuItem = {
-                                    id: RELATION_MENU_ITEM_ID,
-                                    Caption: "Entity relations",
-                                    relations: relations,
-                                    Type: bruceModels.MenuItem.EType.Relationships
-                                };
-                                params.manager.RenderItem({
-                                    getters: params.getters,
-                                    item: menuItem
-                                });
-                            }
-                            else if (legacyRelationIds.length) {
-                                menuItem = {
-                                    id: RELATION_MENU_ITEM_ID,
-                                    Caption: "Entity relations",
-                                    BruceEntity: {
-                                        EntityIds: legacyRelationIds
-                                    },
-                                    Type: bruceModels.MenuItem.EType.Relations
-                                };
-                                params.manager.RenderItem({
-                                    getters: params.getters,
-                                    item: menuItem
-                                });
-                            }
-                            if (!assertIteration$1(params.viewer, iteration)) {
-                                return [2 /*return*/];
-                            }
-                        }
-                        gOcclusion = bSettings === null || bSettings === void 0 ? void 0 : bSettings.groundOcclusion;
-                        if (gOcclusion == null) {
-                            gOcclusion = (_6 = defaults === null || defaults === void 0 ? void 0 : defaults.settings) === null || _6 === void 0 ? void 0 : _6.groundOcclusion;
-                        }
-                        if (gOcclusion == null) {
-                            // TODO: Need global default.
-                            gOcclusion = true;
-                        }
-                        scene.globe.depthTestAgainstTerrain = Boolean(gOcclusion);
-                        return [2 /*return*/];
-                }
-            });
-        });
-    }
-    (function (ViewRenderEngine) {
-        function Render(params) {
-            var _a;
-            return __awaiter(this, void 0, void 0, function () {
-                var iteration, api, view, _b, bookmark, bookmarkId, _c, version, bWidget;
-                return __generator(this, function (_d) {
-                    switch (_d.label) {
-                        case 0:
-                            if (!params.manager && params.viewer) {
-                                params.manager = exports.ViewerUtils.GetManager({
-                                    viewer: params.viewer,
-                                    createIfMissing: true
-                                });
-                            }
-                            else if (!params.viewer && params.manager) {
-                                params.viewer = params.manager.Viewer;
-                            }
-                            iteration = newIteration$1(params.viewer);
-                            if (!params.getters) {
-                                params.getters = bruceModels.ENVIRONMENT.Api();
-                            }
-                            if (params.apiGetter && !params.getters) {
-                                console.warn("ViewRenderEngine.Render(): Please pass getters instead of apiGetter. This is now deprecated due to needing access to other kinds of apis.");
-                            }
-                            else if (!params.apiGetter) {
-                                params.apiGetter = params.getters.GetBruceGetter();
-                            }
-                            api = params.getters.GetBruceApi();
-                            if (!params.view) return [3 /*break*/, 1];
-                            _b = params.view;
-                            return [3 /*break*/, 3];
-                        case 1: return [4 /*yield*/, bruceModels.ProjectView.Get({
-                                api: api,
-                                viewId: params.viewId
-                            })];
-                        case 2:
-                            _b = (_d.sent()).view;
-                            _d.label = 3;
-                        case 3:
-                            view = _b;
-                            bookmark = params.bookmark;
-                            if (!!bookmark) return [3 /*break*/, 7];
-                            bookmarkId = params.bookmarkId;
-                            if (!bookmarkId) {
-                                bookmarkId = view.DefaultUISlideID;
-                            }
-                            if (!bookmarkId) return [3 /*break*/, 5];
-                            return [4 /*yield*/, bruceModels.ProjectViewBookmark.Get({
-                                    api: api,
-                                    viewId: params.viewId,
-                                    bookmarkId: bookmarkId
-                                })];
-                        case 4:
-                            _c = (_d.sent()).bookmark;
-                            return [3 /*break*/, 6];
-                        case 5:
-                            _c = null;
-                            _d.label = 6;
-                        case 6:
-                            bookmark = _c;
-                            _d.label = 7;
-                        case 7:
-                            if (!assertIteration$1(params.viewer, iteration)) {
-                                return [2 /*return*/];
-                            }
-                            version = view.DataVersion;
-                            if (!(version == 1)) return [3 /*break*/, 9];
-                            return [4 /*yield*/, renderLegacyNavigator(iteration, params, bookmark, view)];
-                        case 8:
-                            _d.sent();
-                            return [3 /*break*/, 11];
-                        case 9: return [4 /*yield*/, renderNavigator(iteration, params, bookmark, view, params.getters)];
-                        case 10:
-                            _d.sent();
-                            _d.label = 11;
-                        case 11:
-                            if (!assertIteration$1(params.viewer, iteration)) {
-                                return [2 /*return*/];
-                            }
-                            bWidget = (_a = params.viewer) === null || _a === void 0 ? void 0 : _a[VIEWER_BOOKMARKS_WIDGET_KEY];
-                            if (bWidget) {
-                                bWidget.ViewId = params.viewId ? params.viewId : view === null || view === void 0 ? void 0 : view.ID;
-                                bWidget.LastEnabledBookmarkId = params.bookmarkId ? params.bookmarkId : bookmark === null || bookmark === void 0 ? void 0 : bookmark.ID;
-                            }
-                            return [2 /*return*/];
-                    }
-                });
-            });
-        }
-        ViewRenderEngine.Render = Render;
-    })(exports.ViewRenderEngine || (exports.ViewRenderEngine = {}));
-
-    var TIME_LAG = 300;
-    var POSITION_CHECK_TIMER = 950;
-    var DEFAULT_GROUNDED_HEIGHT = 300;
-    var MINIMUM_VIEW_AREA_SIZE_DEGREES = 0.01;
-    var NET_STEP_PERCENT = 5;
-    var BORDER_STEPS = 3;
-    var ESearchStatus;
-    (function (ESearchStatus) {
-        ESearchStatus[ESearchStatus["LocationFound"] = 1] = "LocationFound";
-        ESearchStatus[ESearchStatus["LocationChanged"] = 2] = "LocationChanged";
-        ESearchStatus[ESearchStatus["LocationMissing"] = 3] = "LocationMissing";
-    })(ESearchStatus || (ESearchStatus = {}));
-    /**
-     * @param viewer
-     * @param center the previously calculated center of the view area. This is in degrees.
-     * @returns
-     */
-    function netScanViewForBoundaries(viewer, center) {
-        var maxLong = -2 * Math.PI;
-        var minLong = 2 * Math.PI;
-        var maxLat = -2 * Math.PI;
-        var minLat = 2 * Math.PI;
-        var found = 0;
-        var updateMinMax = function (lon, lat) {
-            // Check to see if given lon/lat (in radians) are within valid range.
-            if (lon < -Math.PI || lon > Math.PI || lat < -Math.PI / 2 || lat > Math.PI / 2) {
-                return;
-            }
-            maxLong = Math.max(maxLong, lon);
-            maxLat = Math.max(maxLat, lat);
-            minLong = Math.min(minLong, lon);
-            minLat = Math.min(minLat, lat);
-        };
-        var updateMinMaxForPoint = function (stepX, stepY) {
-            var x = Math.round(0 + (viewer.container.clientWidth / 100) * (stepX * NET_STEP_PERCENT));
-            var y = Math.round(0 + (viewer.container.clientHeight / 100) * (stepY * NET_STEP_PERCENT));
-            var winPos = new Cesium.Cartesian2(x, y);
-            try {
-                var intersection = getAdjustedGroundIntersectionOfCameraRay(viewer, winPos);
-                if (intersection) {
-                    var point = Cesium.Cartographic.fromCartesian(intersection, viewer.scene.globe.ellipsoid);
-                    updateMinMax(point.longitude, point.latitude);
-                    found++;
-                }
-            }
-            catch (e) {
-                console.error(e);
-            }
-        };
-        // Outer circle.
-        updateMinMaxForPoint(BORDER_STEPS, BORDER_STEPS);
-        updateMinMaxForPoint((100 / NET_STEP_PERCENT) - BORDER_STEPS, BORDER_STEPS);
-        updateMinMaxForPoint(BORDER_STEPS, (100 / NET_STEP_PERCENT) - BORDER_STEPS);
-        updateMinMaxForPoint((100 / NET_STEP_PERCENT) - BORDER_STEPS, (100 / NET_STEP_PERCENT) - BORDER_STEPS);
-        // Inner circle.
-        updateMinMaxForPoint(BORDER_STEPS * 2, BORDER_STEPS * 2);
-        updateMinMaxForPoint((100 / NET_STEP_PERCENT) - BORDER_STEPS * 2, BORDER_STEPS * 2);
-        updateMinMaxForPoint(BORDER_STEPS * 2, (100 / NET_STEP_PERCENT) - BORDER_STEPS * 2);
-        updateMinMaxForPoint((100 / NET_STEP_PERCENT) - BORDER_STEPS * 2, (100 / NET_STEP_PERCENT) - BORDER_STEPS * 2);
-        // If we failed to find intersections and a center-point was provided, then we can use that to make some guesses.
-        // This happens if terrain is hidden, and there's nothing to intersect with.
-        if (center && found <= 0) {
-            updateMinMax(Cesium.Math.toRadians(center.longitude), Cesium.Math.toRadians(center.latitude));
-            found += 1;
-            // We'll use the camera height as an indicator on size of the rect.
-            var size = viewer.camera.positionCartographic.height;
-            var pitch = viewer.camera.pitch;
-            var distance = size / Math.tan(pitch);
-            var p1 = _offsetPoint({
-                altitude: center.altitude,
-                latitude: center.latitude,
-                longitude: center.longitude
-            }, distance, 45);
-            var p2 = _offsetPoint({
-                altitude: center.altitude,
-                latitude: center.latitude,
-                longitude: center.longitude
-            }, -distance, 45);
-            if (p1 === null || p1 === void 0 ? void 0 : p1.latitude) {
-                updateMinMax(Cesium.Math.toRadians(p1.longitude), Cesium.Math.toRadians(p1.latitude));
-            }
-            if (p2 === null || p2 === void 0 ? void 0 : p2.latitude) {
-                updateMinMax(Cesium.Math.toRadians(p2.longitude), Cesium.Math.toRadians(p2.latitude));
-            }
-        }
-        if (found > 0) {
-            var viewRect = {
-                east: maxLong,
-                west: minLong,
-                north: maxLat,
-                south: minLat
-            };
-            return viewRect;
-        }
-        return null;
-    }
-    /**
-     * Moves a given point by a given distance towards a heading.
-     * @param point in degrees.
-     * @param distance in meters.
-     * @param heading in degrees.
-     * @returns
-     */
-    function _offsetPoint(point, distance, heading) {
-        // Radius of earth.
-        var radius = 6371e3;
-        var δ = distance / radius;
-        var θ = Cesium.Math.toRadians(heading);
-        var φ1 = Cesium.Math.toRadians(point.latitude);
-        var λ1 = Cesium.Math.toRadians(point.longitude);
-        var sinφ2 = Math.sin(φ1) * Math.cos(δ) + Math.cos(φ1) * Math.sin(δ) * Math.cos(θ);
-        var φ2 = Math.asin(sinφ2);
-        var y = Math.sin(θ) * Math.sin(δ) * Math.cos(φ1);
-        var x = Math.cos(δ) - Math.sin(φ1) * sinφ2;
-        var λ2 = λ1 + Math.atan2(y, x);
-        return {
-            altitude: point.altitude,
-            latitude: Cesium.Math.toDegrees(φ2),
-            longitude: Cesium.Math.toDegrees(λ2)
-        };
-    }
-    /**
-     * @param pos3d
-     * @param distance in meters
-     * @param heading in degrees
-     * @returns
-     */
-    function _offsetPos3d(pos3d, distance, heading) {
-        var carto = Cesium.Cartographic.fromCartesian(pos3d);
-        var newCarto = _offsetPoint({
-            altitude: carto.height,
-            latitude: Cesium.Math.toDegrees(carto.latitude),
-            longitude: Cesium.Math.toDegrees(carto.longitude)
-        }, distance, heading);
-        return Cesium.Cartesian3.fromDegrees(newCarto.longitude, newCarto.latitude, newCarto.altitude);
-    }
-    /**
-     * Returns the intersection of the camera ray with the ground.
-     * @param viewer
-     * @param screenPos
-     * @returns
-     */
-    function getAdjustedGroundIntersectionOfCameraRay(viewer, screenPos) {
-        var ray = viewer.camera.getPickRay(screenPos);
-        var intersection = ray ? viewer.scene.globe.pick(ray, viewer.scene) : null;
-        if (intersection) {
-            return intersection;
-        }
-        return null;
-    }
-    /**
-     * Returns the intersection of the camera ray with the ground.
-     * If no intersection is found, then a "guess" is made based on the camera angle and height.
-     * The guess is made at the center of the view! It ignores the screenPos.
-     * @param viewer
-     * @param screenPos
-     * @returns
-     */
-    function getGroundCenterOfCameraRay(viewer, screenPos) {
-        var _a, _b;
-        var ray = viewer.camera.getPickRay(screenPos);
-        var intersection = ray ? viewer.scene.globe.pick(ray, viewer.scene) : null;
-        if (intersection) {
-            return intersection;
-        }
-        // The fallback will be to "guess" where the intersection might be.
-        // This happens if terrain is hidden, and there's nothing to intersect with.
-        // We will use the camera angle + camera height.
-        // Eg: if camera is looking straight down and is 100 meters above the ground, then the intersection will be 100 meters below the camera.
-        var cameraHeight = viewer.camera.positionCartographic.height;
-        if (!isNaN(cameraHeight) && cameraHeight != null && ((_b = (_a = viewer.camera) === null || _a === void 0 ? void 0 : _a.position) === null || _b === void 0 ? void 0 : _b.clone)) {
-            var cameraPos3d = viewer.camera.position.clone();
-            var pitch = viewer.camera.pitch;
-            var distance = cameraHeight / Math.tan(pitch);
-            return _offsetPos3d(cameraPos3d, -distance, Cesium.Math.toDegrees(viewer.camera.heading));
-        }
-        return null;
-    }
-    function areBoundsEqual(a, b) {
-        return a.north == b.north && a.south == b.south && a.east == b.east && a.west == b.west;
-    }
-    function arePosEqual(a, b) {
-        return a.latitude == b.latitude && a.longitude == b.longitude;
-    }
-    (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.updating = false;
-                this.viewer = viewer;
-                this.tryEmitUpdate();
-                this.checkInterval = setInterval(function () {
-                    _this.updateQueue();
-                }, POSITION_CHECK_TIMER);
-            }
-            Object.defineProperty(Monitor.prototype, "Disposed", {
-                get: function () {
-                    return this.disposed;
-                },
-                enumerable: false,
-                configurable: true
-            });
-            Monitor.prototype.createEntity = function () {
-                var _this = this;
-                if (this.entity) {
-                    return;
-                }
-                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,
-                        heightReference: Cesium.HeightReference.NONE
-                    },
-                    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,
-                        heightReference: Cesium.HeightReference.NONE
-                    }
-                });
-            };
-            Monitor.prototype.destroyEntity = function () {
-                if (this.entity && this.viewer.entities.contains(this.entity)) {
-                    this.viewer.entities.remove(this.entity);
-                }
-                this.entity = null;
-            };
-            Monitor.prototype.Updated = function () {
-                if (!this.updatedEvent) {
-                    this.updatedEvent = new bruceModels.BruceEvent();
-                }
-                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;
-                return __awaiter(this, void 0, void 0, function () {
-                    var viewRect, center, camera, terrData, cameraPosition, terrHeight, viewRectRad, windowPosition, intersection, point, viewRectRad, centerLong, centerLat;
-                    return __generator(this, function (_b) {
-                        switch (_b.label) {
-                            case 0:
-                                if (!this.viewer || this.viewer.isDestroyed()) {
-                                    this.Dispose();
-                                    return [2 /*return*/, ESearchStatus.LocationMissing];
-                                }
-                                viewRect = null;
-                                center = null;
-                                camera = this.viewer.camera;
-                                return [4 /*yield*/, exports.DrawingUtils.GetTerrainHeight({
-                                        pos3d: camera.position,
-                                        viewer: this.viewer
-                                    })];
-                            case 1:
-                                terrData = _b.sent();
-                                cameraPosition = this.viewer.camera.positionCartographic;
-                                terrHeight = terrData.error ? cameraPosition.height + DEFAULT_GROUNDED_HEIGHT : terrData.height;
-                                // We are almost at the ground, screw horizon, just load around.
-                                if (terrHeight && ((cameraPosition.height - terrHeight) < DEFAULT_GROUNDED_HEIGHT)) {
-                                    // View area calculation.
-                                    viewRect = {};
-                                    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));
-                                    }
-                                    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);
-                                }
-                                else {
-                                    windowPosition = new Cesium.Cartesian2(this.viewer.container.clientWidth / 2, this.viewer.container.clientHeight / 2);
-                                    intersection = getGroundCenterOfCameraRay(this.viewer, windowPosition);
-                                    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);
-                                        viewRectRad = netScanViewForBoundaries(this.viewer, center);
-                                        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);
-                                        }
-                                    }
-                                }
-                                // Minimal field of view.
-                                if (viewRect) {
-                                    centerLong = (viewRect.east + viewRect.west) / 2;
-                                    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 [2 /*return*/, ESearchStatus.LocationChanged];
+                                    if (layer.tilesetId == bruceModels.ProjectViewTile.EDefaultImagery.BingMapsAerial) {
+                                        layer.tilesetId = bruceModels.ProjectViewTile.EDefaultImagery.MapboxSatellite;
+                                        console.warn("Cesium Ion token not set, using mapbox satellite instead of bing maps aerial.");
+                                    }
+                                    else if (layer.tilesetId == bruceModels.ProjectViewTile.EDefaultImagery.BingMapsAerialWithLabels) {
+                                        layer.tilesetId = bruceModels.ProjectViewTile.EDefaultImagery.MapboxSatellite;
+                                        console.warn("Cesium Ion token not set, using mapbox satellite instead of bing maps aerial with labels.");
+                                    }
+                                    else if (layer.tilesetId == bruceModels.ProjectViewTile.EDefaultImagery.BingMapsRoads) {
+                                        layer.tilesetId = bruceModels.ProjectViewTile.EDefaultImagery.MapBoxStreets;
+                                        console.warn("Cesium Ion token not set, using mapbox streets instead of bing maps roads.");
                                     }
-                                    return [2 /*return*/, ESearchStatus.LocationFound];
                                 }
-                                return [2 /*return*/, ESearchStatus.LocationMissing];
+                            }
                         }
-                    });
-                });
-            };
-            Monitor.prototype.tryEmitUpdate = function () {
-                var _a;
-                return __awaiter(this, void 0, void 0, function () {
-                    var searchResult, interest, e_1;
-                    return __generator(this, function (_b) {
-                        switch (_b.label) {
-                            case 0:
-                                if (this.updating) {
-                                    return [2 /*return*/];
+                        // We don't wait for imageries to load, this does not affect rendering other things.
+                        exports.TileRenderEngine.Map.Navigator.Render({
+                            apiGetter: params.apiGetter,
+                            tiles: imagery,
+                            viewer: params.manager.Viewer,
+                        });
+                        legacyRelationIds = bSettings === null || bSettings === void 0 ? void 0 : bSettings.renderedEntityRelations;
+                        if (!legacyRelationIds) {
+                            legacyRelationIds = [];
+                        }
+                        relations = bSettings === null || bSettings === void 0 ? void 0 : bSettings.renderedRelations;
+                        if (!relations) {
+                            relations = [];
+                        }
+                        viewer.scene.requestRender();
+                        curEnabled = params.manager.GetEnabledItemIds();
+                        newItemIds = (_5 = bSettings === null || bSettings === void 0 ? void 0 : bSettings.menuItemIds) !== null && _5 !== void 0 ? _5 : [];
+                        for (_i = 0, curEnabled_1 = curEnabled; _i < curEnabled_1.length; _i++) {
+                            id = curEnabled_1[_i];
+                            shouldRemove = void 0;
+                            if (id == RELATION_MENU_ITEM_ID) {
+                                rendered = params.manager.GetEnabledItem(id);
+                                shouldRemove = false;
+                                if (!legacyRelationIds.length && !relations.length) {
+                                    shouldRemove = true;
                                 }
-                                this.updating = true;
-                                _b.label = 1;
-                            case 1:
-                                _b.trys.push([1, 3, , 4]);
-                                return [4 /*yield*/, this.tryDoUpdate()];
-                            case 2:
-                                searchResult = _b.sent();
-                                if (searchResult == ESearchStatus.LocationChanged) {
-                                    interest = {
-                                        bounds: this.bounds,
-                                        target: this.target
-                                    };
-                                    // this.createEntity();
-                                    (_a = this.updatedEvent) === null || _a === void 0 ? void 0 : _a.Trigger(interest);
+                                // If we're about to render legacy relationships but a non-legacy item is currently enabled then we remove it.
+                                else if (legacyRelationIds.length && (rendered === null || rendered === void 0 ? void 0 : rendered.type) != bruceModels.MenuItem.EType.Relations) {
+                                    shouldRemove = true;
                                 }
-                                else if (searchResult == ESearchStatus.LocationMissing) {
-                                    this.updateQueue();
+                                // If we're about to render non-legacy relationships but a legacy item is currently enabled then we remove it.
+                                else if (relations.length && (rendered === null || rendered === void 0 ? void 0 : rendered.type) != bruceModels.MenuItem.EType.Relationships) {
+                                    shouldRemove = true;
                                 }
-                                return [3 /*break*/, 4];
-                            case 3:
-                                e_1 = _b.sent();
-                                console.error(e_1);
-                                this.updateQueue();
-                                return [3 /*break*/, 4];
-                            case 4:
-                                this.updating = false;
+                            }
+                            else {
+                                shouldRemove = newItemIds.indexOf(id) === -1;
+                            }
+                            if (shouldRemove) {
+                                params.manager.RemoveItemById({
+                                    menuItemId: id
+                                });
+                            }
+                        }
+                        if (!bookmark) return [3 /*break*/, 15];
+                        return [4 /*yield*/, exports.MenuItemCreator.RenderBookmarkItems({
+                                getters: params.getters,
+                                manager: params.manager,
+                                view: view,
+                                bookmark: bookmark
+                            })];
+                    case 14:
+                        _8.sent();
+                        if (!assertIteration$1(params.viewer, iteration)) {
+                            return [2 /*return*/];
+                        }
+                        _8.label = 15;
+                    case 15:
+                        if (legacyRelationIds.length || relations.length) {
+                            if (relations.length) {
+                                menuItem = {
+                                    id: RELATION_MENU_ITEM_ID,
+                                    Caption: "Entity relations",
+                                    relations: relations,
+                                    Type: bruceModels.MenuItem.EType.Relationships
+                                };
+                                params.manager.RenderItem({
+                                    getters: params.getters,
+                                    item: menuItem
+                                });
+                            }
+                            else if (legacyRelationIds.length) {
+                                menuItem = {
+                                    id: RELATION_MENU_ITEM_ID,
+                                    Caption: "Entity relations",
+                                    BruceEntity: {
+                                        EntityIds: legacyRelationIds
+                                    },
+                                    Type: bruceModels.MenuItem.EType.Relations
+                                };
+                                params.manager.RenderItem({
+                                    getters: params.getters,
+                                    item: menuItem
+                                });
+                            }
+                            if (!assertIteration$1(params.viewer, iteration)) {
                                 return [2 /*return*/];
+                            }
                         }
-                    });
-                });
-            };
-            Monitor.prototype.queuePosition = function (lag) {
-                var _this = this;
-                if (this.pendingTimeout) {
-                    clearTimeout(this.pendingTimeout);
+                        gOcclusion = bSettings === null || bSettings === void 0 ? void 0 : bSettings.groundOcclusion;
+                        if (gOcclusion == null) {
+                            gOcclusion = (_6 = defaults === null || defaults === void 0 ? void 0 : defaults.settings) === null || _6 === void 0 ? void 0 : _6.groundOcclusion;
+                        }
+                        if (gOcclusion == null) {
+                            // TODO: Need global default.
+                            gOcclusion = true;
+                        }
+                        scene.globe.depthTestAgainstTerrain = Boolean(gOcclusion);
+                        return [2 /*return*/];
                 }
-                this.pendingTimeout = setTimeout(function () {
-                    if (!_this.disposed) {
-                        _this.tryEmitUpdate();
+            });
+        });
+    }
+    (function (ViewRenderEngine) {
+        function Render(params) {
+            var _a;
+            return __awaiter(this, void 0, void 0, function () {
+                var iteration, api, view, _b, bookmark, bookmarkId, _c, version, bWidget;
+                return __generator(this, function (_d) {
+                    switch (_d.label) {
+                        case 0:
+                            if (!params.manager && params.viewer) {
+                                params.manager = exports.ViewerUtils.GetManager({
+                                    viewer: params.viewer,
+                                    createIfMissing: true
+                                });
+                            }
+                            else if (!params.viewer && params.manager) {
+                                params.viewer = params.manager.Viewer;
+                            }
+                            iteration = newIteration$1(params.viewer);
+                            if (!params.getters) {
+                                params.getters = bruceModels.ENVIRONMENT.Api();
+                            }
+                            if (params.apiGetter && !params.getters) {
+                                console.warn("ViewRenderEngine.Render(): Please pass getters instead of apiGetter. This is now deprecated due to needing access to other kinds of apis.");
+                            }
+                            else if (!params.apiGetter) {
+                                params.apiGetter = params.getters.GetBruceGetter();
+                            }
+                            api = params.getters.GetBruceApi();
+                            if (!params.view) return [3 /*break*/, 1];
+                            _b = params.view;
+                            return [3 /*break*/, 3];
+                        case 1: return [4 /*yield*/, bruceModels.ProjectView.Get({
+                                api: api,
+                                viewId: params.viewId
+                            })];
+                        case 2:
+                            _b = (_d.sent()).view;
+                            _d.label = 3;
+                        case 3:
+                            view = _b;
+                            bookmark = params.bookmark;
+                            if (!!bookmark) return [3 /*break*/, 7];
+                            bookmarkId = params.bookmarkId;
+                            if (!bookmarkId) {
+                                bookmarkId = view.DefaultUISlideID;
+                            }
+                            if (!bookmarkId) return [3 /*break*/, 5];
+                            return [4 /*yield*/, bruceModels.ProjectViewBookmark.Get({
+                                    api: api,
+                                    viewId: params.viewId,
+                                    bookmarkId: bookmarkId
+                                })];
+                        case 4:
+                            _c = (_d.sent()).bookmark;
+                            return [3 /*break*/, 6];
+                        case 5:
+                            _c = null;
+                            _d.label = 6;
+                        case 6:
+                            bookmark = _c;
+                            _d.label = 7;
+                        case 7:
+                            if (!assertIteration$1(params.viewer, iteration)) {
+                                return [2 /*return*/];
+                            }
+                            version = view.DataVersion;
+                            if (!(version == 1)) return [3 /*break*/, 9];
+                            return [4 /*yield*/, renderLegacyNavigator(iteration, params, bookmark, view)];
+                        case 8:
+                            _d.sent();
+                            return [3 /*break*/, 11];
+                        case 9: return [4 /*yield*/, renderNavigator(iteration, params, bookmark, view, params.getters)];
+                        case 10:
+                            _d.sent();
+                            _d.label = 11;
+                        case 11:
+                            if (!assertIteration$1(params.viewer, iteration)) {
+                                return [2 /*return*/];
+                            }
+                            bWidget = (_a = params.viewer) === null || _a === void 0 ? void 0 : _a[VIEWER_BOOKMARKS_WIDGET_KEY];
+                            if (bWidget) {
+                                bWidget.ViewId = params.viewId ? params.viewId : view === null || view === void 0 ? void 0 : view.ID;
+                                bWidget.LastEnabledBookmarkId = params.bookmarkId ? params.bookmarkId : bookmark === null || bookmark === void 0 ? void 0 : bookmark.ID;
+                            }
+                            return [2 /*return*/];
                     }
-                }, lag);
-            };
-            Monitor.prototype.updateQueue = function () {
-                this.queuePosition(TIME_LAG);
-            };
-            return Monitor;
-        }());
-        CesiumViewMonitor.Monitor = Monitor;
-    })(exports.CesiumViewMonitor || (exports.CesiumViewMonitor = {}));
+                });
+            });
+        }
+        ViewRenderEngine.Render = Render;
+    })(exports.ViewRenderEngine || (exports.ViewRenderEngine = {}));
 
-    var VERSION$1 = "3.4.8";
+    var VERSION = "3.5.0";
 
-    exports.VERSION = VERSION$1;
+    exports.VERSION = VERSION;
     exports.CesiumParabola = CesiumParabola;
     exports.CESIUM_INSPECTOR_KEY = CESIUM_INSPECTOR_KEY;
     exports.Draw3dPolygon = Draw3dPolygon;