bruce-cesium 3.4.8 → 3.4.9

package/dist/bruce-cesium.es5.js

@@ -1,6 +1,6 @@
-import { Cartes, Carto, Entity as Entity$1, Geometry, Tileset, MathUtils, LRUCache, ProjectViewTile, DelayQueue, ZoomControl, Style, EntityTag, Calculator, EntityLod, EntityType, ClientFile, ObjectUtils, Bounds, Api, EntityRelationType, ENVIRONMENT, BruceEvent, EntityCoords, EntitySource, MenuItem, EntityRelation, ProgramKey, AbstractApi, ProjectViewBookmark, EntityAttachment, EntityAttachmentType, EntityAttribute, ProjectView, ProjectViewLegacyTile, Camera } from 'bruce-models';
+import { BruceEvent, Cartes, Carto, Entity as Entity$1, Geometry, Tileset, MathUtils, LRUCache, ProjectViewTile, DelayQueue, ZoomControl, Style, EntityTag, Calculator, EntityLod, EntityType, ClientFile, ObjectUtils, Bounds, Api, EntityRelationType, ENVIRONMENT, EntityCoords, EntitySource, MenuItem, EntityRelation, ProgramKey, AbstractApi, ProjectViewBookmark, EntityAttachment, EntityAttachmentType, EntityAttribute, ProjectView, ProjectViewLegacyTile, Camera } from 'bruce-models';
 import * as Cesium from 'cesium';
-import { Cartographic, Cartesian2, Math as Math$1, Cartesian3, CallbackProperty, Color, HeightReference, Rectangle, JulianDate, Entity, Primitive, Cesium3DTileFeature, SceneMode, DistanceDisplayCondition, NearFarScalar, Model, HorizontalOrigin, VerticalOrigin, ClassificationType, ArcType, CornerType, ShadowMode, PolygonHierarchy, PolylineGraphics, HeadingPitchRoll, Transforms, ColorBlendMode, GeoJsonDataSource, ColorMaterialProperty, Cesium3DTileColorBlendMode, HeadingPitchRange, Ion, Cesium3DTileStyle, KmlDataSource, SceneTransforms, OrthographicFrustum, EasingFunction, Cesium3DTileset, Matrix4, Matrix3, IonResource, EllipsoidTerrainProvider, BingMapsImageryProvider, BingMapsStyle, MapboxImageryProvider, MapboxStyleImageryProvider, ArcGisMapServerImageryProvider, OpenStreetMapImageryProvider, GridImageryProvider, GeographicTilingScheme, ImageryLayer, UrlTemplateImageryProvider, TileMapServiceImageryProvider, IonImageryProvider, CesiumTerrainProvider, CesiumInspector, defined, EllipsoidGeodesic, sampleTerrainMostDetailed, PolygonPipeline, BoundingSphere, GeometryInstance, ScreenSpaceEventHandler, ScreenSpaceEventType, ModelGraphics, PolygonGraphics, CorridorGraphics, PointGraphics, BillboardGraphics, EllipseGraphics, Intersect } from 'cesium';
+import { Cartographic, Cartesian2, Math as Math$1, Cartesian3, CallbackProperty, Color, HeightReference, Rectangle, JulianDate, DistanceDisplayCondition, NearFarScalar, Model, Entity, HorizontalOrigin, VerticalOrigin, ClassificationType, ArcType, CornerType, ShadowMode, PolygonHierarchy, PolylineGraphics, HeadingPitchRoll, Transforms, ColorBlendMode, Primitive, Cesium3DTileFeature, SceneMode, GeoJsonDataSource, ColorMaterialProperty, Cesium3DTileColorBlendMode, HeadingPitchRange, Ion, Cesium3DTileStyle, KmlDataSource, SceneTransforms, EllipsoidTerrainProvider, BingMapsImageryProvider, BingMapsStyle, MapboxImageryProvider, MapboxStyleImageryProvider, ArcGisMapServerImageryProvider, OpenStreetMapImageryProvider, GridImageryProvider, GeographicTilingScheme, ImageryLayer, UrlTemplateImageryProvider, TileMapServiceImageryProvider, IonImageryProvider, CesiumTerrainProvider, OrthographicFrustum, EasingFunction, Cesium3DTileset, Matrix4, Matrix3, IonResource, CesiumInspector, defined, PolygonPipeline, ScreenSpaceEventHandler, ScreenSpaceEventType, BoundingSphere, GeometryInstance, EllipsoidGeodesic, sampleTerrainMostDetailed, Intersect, ModelGraphics, PolygonGraphics, CorridorGraphics, PointGraphics, BillboardGraphics, EllipseGraphics } from 'cesium';
 
 /*! *****************************************************************************
 Copyright (c) Microsoft Corporation. All rights reserved.
@@ -79,460 +79,876 @@ function __generator(thisArg, body) {
     }
 }
 
+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;
-}
-
-var MeasureUtils;
-(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 += 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 Cartesian2(x, y);
+        try {
+            var intersection = getAdjustedGroundIntersectionOfCameraRay(viewer, winPos);
+            if (intersection) {
+                var point = 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 (!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(Math$1.toRadians(center.longitude), Math$1.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(Math$1.toRadians(p1.longitude), Math$1.toRadians(p1.latitude));
         }
-        var area = 0;
-        var indices = 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 = Cartesian3.subtract(vector2, vector1, new Cartesian3());
-            var vectorD = Cartesian3.subtract(vector3, vector1, new Cartesian3());
-            var areaVector = Cartesian3.cross(vectorC, vectorD, new Cartesian3());
-            area += Cartesian3.magnitude(areaVector) / 2.0;
+        if (p2 === null || p2 === void 0 ? void 0 : p2.latitude) {
+            updateMinMax(Math$1.toRadians(p2.longitude), Math$1.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;
-})(MeasureUtils || (MeasureUtils = {}));
-
-var C3 = [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 = Math$1.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 θ = Math$1.toRadians(heading);
+    var φ1 = Math$1.toRadians(point.latitude);
+    var λ1 = Math$1.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: Math$1.toDegrees(φ2),
+        longitude: Math$1.toDegrees(λ2)
+    };
 }
-var DrawingUtils;
-(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 = 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 = Cartesian3.distance(positions[i], positions[i + 1]);
-                if (length_1 + currentDistance >= distance) {
-                    var carto1 = Cartographic.fromCartesian(positions[i]);
-                    var carto2 = Cartographic.fromCartesian(positions[i + 1]);
-                    var geodesic = new 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: 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 EllipsoidTerrainProvider) {
-                            return [2 /*return*/, {
-                                    height: 0
-                                }];
-                        }
-                        return [4 /*yield*/, sampleTerrainMostDetailed(viewer.scene.terrainProvider, [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 = Cartographic.fromCartesian(pos3d);
+    var newCarto = _offsetPoint({
+        altitude: carto.height,
+        latitude: Math$1.toDegrees(carto.latitude),
+        longitude: Math$1.toDegrees(carto.longitude)
+    }, distance, heading);
+    return 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 = Cartes.ValidateCartes3(pos3d) ? Cartographic.fromCartesian(pos3d) : null;
-        if (!(carto === null || carto === void 0 ? void 0 : carto.latitude)) {
-            return pos3d;
-        }
-        if (heightRef == null) {
-            heightRef = HeightReference.CLAMP_TO_GROUND;
-        }
-        if (desiredHeightRef == null) {
-            desiredHeightRef = HeightReference.CLAMP_TO_GROUND;
-        }
-        if (heightRef == desiredHeightRef) {
-            return pos3d;
-        }
-        if (heightRef == HeightReference.NONE) {
-            // Turn absolute into clamped.
-            if (desiredHeightRef == HeightReference.CLAMP_TO_GROUND) {
-                return Cartesian3.fromRadians(carto.longitude, carto.latitude, 0);
-            }
-            // Turn absolute into relative (remove terrain height).
-            else if (desiredHeightRef == HeightReference.RELATIVE_TO_GROUND) {
-                var terrainHeight = EnsureNumber(viewer.scene.globe.getHeight(carto), 0);
-                return Cartesian3.fromRadians(carto.longitude, carto.latitude, carto.height - terrainHeight);
-            }
-        }
-        else if (heightRef == HeightReference.CLAMP_TO_GROUND) {
-            var terrainHeight = EnsureNumber(viewer.scene.globe.getHeight(carto), 0);
-            return Cartesian3.fromRadians(carto.longitude, carto.latitude, terrainHeight);
-        }
-        else if (heightRef == HeightReference.RELATIVE_TO_GROUND) {
-            // Turn relative into absolute (add terrain height).
-            if (desiredHeightRef == HeightReference.NONE) {
-                var terrainHeight = EnsureNumber(viewer.scene.globe.getHeight(carto), 0);
-                return Cartesian3.fromRadians(carto.longitude, carto.latitude, carto.height + terrainHeight);
-            }
-            // Turn relative into clamped.
-            else if (desiredHeightRef == HeightReference.CLAMP_TO_GROUND) {
-                return 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, Math$1.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;
+}
+var CesiumViewMonitor;
+(function (CesiumViewMonitor$$1) {
     /**
-     * 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 = Cartesian2.distanceSquared(cursor, cachedPick.cursor) < 9; // 3 pixels
-                var directionDot = Cartesian3.dot(camera.directionWC, cachedCameraState.direction);
-                var directionLengths = Cartesian3.magnitude(camera.directionWC) * 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 > Math$1.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 CallbackProperty(function () {
+                    return _this.target ? Cartesian3.fromDegrees(_this.target.longitude, _this.target.latitude) : null;
+                }, false),
+                point: {
+                    pixelSize: 8,
+                    color: Color.ORANGE,
+                    heightReference: HeightReference.NONE
+                },
+                rectangle: {
+                    coordinates: new CallbackProperty(function () {
+                        return _this.bounds ? Rectangle.fromDegrees(_this.bounds.west, _this.bounds.south, _this.bounds.east, _this.bounds.north) : null;
+                    }, false),
+                    material: Color.fromCssColorString('#ff0000').withAlpha(0.4),
+                    zIndex: 1,
+                    heightReference: 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 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 (defined(pos3d)) {
-                    var carto = Cartographic.fromCartesian(pos3d);
-                    if (!defined(carto) || carto.height < 0) {
-                        pos3d = null;
-                    }
-                }
-                if (!defined(pos3d)) {
-                    pos3d = null;
-                    var ray = scene.camera.getPickRay(cursor);
-                    if (scene.pickPositionSupported) {
-                        var pickedObject = scene.pick(cursor, 1, 1);
-                        if (defined(pickedObject) &&
-                            (pickedObject instanceof Cesium3DTileFeature ||
-                                pickedObject.primitive instanceof Cesium3DTileset ||
-                                pickedObject.primitive instanceof 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*/, 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 = Math$1.toDegrees(Math.max(viewRectRad.east, cameraPosition.longitude));
+                                    viewRect.west = Math$1.toDegrees(Math.min(viewRectRad.west, cameraPosition.longitude));
+                                    viewRect.south = Math$1.toDegrees(Math.min(viewRectRad.south, cameraPosition.latitude));
+                                    viewRect.north = Math$1.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 = Math$1.toDegrees(camera.positionCartographic.latitude);
+                                center.longitude = Math$1.toDegrees(camera.positionCartographic.longitude);
+                            }
+                            else {
+                                windowPosition = new Cartesian2(this.viewer.container.clientWidth / 2, this.viewer.container.clientHeight / 2);
+                                intersection = getGroundCenterOfCameraRay(this.viewer, windowPosition);
+                                point = null;
+                                if (intersection) {
+                                    point = Cartographic.fromCartesian(intersection, this.viewer.scene.globe.ellipsoid);
+                                }
+                                if (point) {
+                                    center = {};
+                                    center.latitude = Math$1.toDegrees(point.latitude);
+                                    center.longitude = Math$1.toDegrees(point.longitude);
+                                    viewRectRad = netScanViewForBoundaries(this.viewer, center);
+                                    if (viewRectRad) {
+                                        viewRect = {};
+                                        viewRect.east = Math$1.toDegrees(viewRectRad.east);
+                                        viewRect.west = Math$1.toDegrees(viewRectRad.west);
+                                        viewRect.south = Math$1.toDegrees(viewRectRad.south);
+                                        viewRect.north = Math$1.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 && !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$$1.Monitor = Monitor;
+})(CesiumViewMonitor || (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;
+}
+
+var MeasureUtils;
+(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 += 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 (!Cartes.IsRing3Closed(posses)) {
+            posses.push(posses[0].clone());
+        }
+        if (posses.length < 3) {
+            return {
+                area: 0,
+                perimeter: 0
+            };
+        }
+        var area = 0;
+        var indices = 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 = Cartesian3.subtract(vector2, vector1, new Cartesian3());
+            var vectorD = Cartesian3.subtract(vector3, vector1, new Cartesian3());
+            var areaVector = Cartesian3.cross(vectorC, vectorD, new Cartesian3());
+            area += Cartesian3.magnitude(areaVector) / 2.0;
+        }
+        var perimeter = MeasurePolyline({
+            posses: posses
+        }).totalLength;
+        return {
+            area: area,
+            perimeter: perimeter
+        };
+    }
+    MeasureUtils.MeasurePolygon = MeasurePolygon;
+})(MeasureUtils || (MeasureUtils = {}));
+
+var C3 = [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 = Math$1.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;
+}
+var DrawingUtils;
+(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 = 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 = Cartesian3.distance(positions[i], positions[i + 1]);
+                if (length_1 + currentDistance >= distance) {
+                    var carto1 = Cartographic.fromCartesian(positions[i]);
+                    var carto2 = Cartographic.fromCartesian(positions[i + 1]);
+                    var geodesic = new 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: 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 = Cartographic.fromCartesian(pos3d);
-                        terrainCarto = carto.clone();
-                        terrainCarto.height = 0;
-                        if (!(viewer.scene.terrainProvider instanceof EllipsoidTerrainProvider)) return [3 /*break*/, 1];
-                        carto.height = Math.max(carto.height, minimumHeight);
-                        return [3 /*break*/, 3];
-                    case 1: return [4 /*yield*/, sampleTerrainMostDetailed(viewer.scene.terrainProvider, [terrainCarto])];
+                        if (viewer.scene.terrainProvider instanceof EllipsoidTerrainProvider) {
+                            return [2 /*return*/, {
+                                    height: 0
+                                }];
+                        }
+                        return [4 /*yield*/, sampleTerrainMostDetailed(viewer.scene.terrainProvider, [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*/, 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;
-})(DrawingUtils || (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 Entity) {
-        return true;
-    }
-    else if (visual instanceof Primitive) {
-        return true;
-    }
-    else if (visual instanceof 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 = Cartes.ValidateCartes3(pos3d) ? 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 = HeightReference.CLAMP_TO_GROUND;
         }
-        return true;
+        if (desiredHeightRef == null) {
+            desiredHeightRef = HeightReference.CLAMP_TO_GROUND;
+        }
+        if (heightRef == desiredHeightRef) {
+            return pos3d;
+        }
+        if (heightRef == HeightReference.NONE) {
+            // Turn absolute into clamped.
+            if (desiredHeightRef == HeightReference.CLAMP_TO_GROUND) {
+                return Cartesian3.fromRadians(carto.longitude, carto.latitude, 0);
+            }
+            // Turn absolute into relative (remove terrain height).
+            else if (desiredHeightRef == HeightReference.RELATIVE_TO_GROUND) {
+                var terrainHeight = EnsureNumber(viewer.scene.globe.getHeight(carto), 0);
+                return Cartesian3.fromRadians(carto.longitude, carto.latitude, carto.height - terrainHeight);
+            }
+        }
+        else if (heightRef == HeightReference.CLAMP_TO_GROUND) {
+            var terrainHeight = EnsureNumber(viewer.scene.globe.getHeight(carto), 0);
+            return Cartesian3.fromRadians(carto.longitude, carto.latitude, terrainHeight);
+        }
+        else if (heightRef == HeightReference.RELATIVE_TO_GROUND) {
+            // Turn relative into absolute (add terrain height).
+            if (desiredHeightRef == HeightReference.NONE) {
+                var terrainHeight = EnsureNumber(viewer.scene.globe.getHeight(carto), 0);
+                return Cartesian3.fromRadians(carto.longitude, carto.latitude, carto.height + terrainHeight);
+            }
+            // Turn relative into clamped.
+            else if (desiredHeightRef == HeightReference.CLAMP_TO_GROUND) {
+                return Cartesian3.fromRadians(carto.longitude, carto.latitude, 0);
+            }
+        }
+        return pos3d;
     }
-    return false;
-}
-var _selectColor = Color.fromAlpha(Color.YELLOW, 0.5);
-var _highlightColor = 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 Color.WHITE;
+    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 = Cartesian2.distanceSquared(cursor, cachedPick.cursor) < 9; // 3 pixels
+                var directionDot = Cartesian3.dot(camera.directionWC, cachedCameraState.direction);
+                var directionLengths = Cartesian3.magnitude(camera.directionWC) * 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 > Math$1.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 (defined(pos3d)) {
+                    var carto = Cartographic.fromCartesian(pos3d);
+                    if (!defined(carto) || carto.height < 0) {
+                        pos3d = null;
+                    }
+                }
+                if (!defined(pos3d)) {
+                    pos3d = null;
+                    var ray = scene.camera.getPickRay(cursor);
+                    if (scene.pickPositionSupported) {
+                        var pickedObject = scene.pick(cursor, 1, 1);
+                        if (defined(pickedObject) &&
+                            (pickedObject instanceof Cesium3DTileFeature ||
+                                pickedObject.primitive instanceof Cesium3DTileset ||
+                                pickedObject.primitive instanceof Model)) {
+                            pos3d = scene.pickPosition(cursor);
+                        }
+                    }
+                    if (!pickOnly && !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 = Cartographic.fromCartesian(pos3d);
+                        terrainCarto = carto.clone();
+                        terrainCarto.height = 0;
+                        if (!(viewer.scene.terrainProvider instanceof EllipsoidTerrainProvider)) return [3 /*break*/, 1];
+                        carto.height = Math.max(carto.height, minimumHeight);
+                        return [3 /*break*/, 3];
+                    case 1: return [4 /*yield*/, 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*/, Cartesian3.fromRadians(carto.longitude, carto.latitude, carto.height)];
+                }
+            });
+        });
+    }
+    DrawingUtils.RaisePos3d = RaisePos3d;
+})(DrawingUtils || (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 Entity) {
+        return true;
+    }
+    else if (visual instanceof Primitive) {
+        return true;
+    }
+    else if (visual instanceof 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 = Color.fromAlpha(Color.YELLOW, 0.5);
+var _highlightColor = 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 Color.WHITE;
     }
     if (prop.getValue) {
         prop = prop.getValue(viewer.scene.lastRenderTime);
@@ -6540,7 +6956,6 @@ function updateEntity(viewer, entityId, register) {
         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({
@@ -13434,7 +13849,7 @@ var DataSourceStaticKmlManager;
             configurable: true
         });
         Manager.prototype.Init = function () {
-            var _a;
+            var _this = this;
             var files = this.item.KML;
             if (!files) {
                 return;
@@ -13442,31 +13857,47 @@ var DataSourceStaticKmlManager;
             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 = ClientFile.GetUrl({
-                        api: api,
-                        fileId: fileId,
-                        viaCdn: true
-                    });
-                }
-                else if (externalURL) {
-                    fileUrl = externalURL;
-                }
-                var source = new 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 = ClientFile.GetUrl({
+                                        api: api,
+                                        fileId: fileId,
+                                        viaCdn: true
+                                    });
+                                }
+                                else if (externalURL) {
+                                    fileUrl = externalURL;
+                                }
+                                source = new 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;
@@ -20976,633 +21407,217 @@ function renderNavigator(iteration, params, bookmark, view, getters) {
                             for (i = 0; i < imagery.length; i++) {
                                 layer = imagery[i];
                                 if (layer.tilesetId == ProjectViewTile.EDefaultImagery.BingMapsAerial) {
-                                    layer.tilesetId = ProjectViewTile.EDefaultImagery.MapboxSatellite;
-                                    console.warn("Cesium Ion token not set, using mapbox satellite instead of bing maps aerial.");
-                                }
-                                else if (layer.tilesetId == ProjectViewTile.EDefaultImagery.BingMapsAerialWithLabels) {
-                                    layer.tilesetId = ProjectViewTile.EDefaultImagery.MapboxSatellite;
-                                    console.warn("Cesium Ion token not set, using mapbox satellite instead of bing maps aerial with labels.");
-                                }
-                                else if (layer.tilesetId == ProjectViewTile.EDefaultImagery.BingMapsRoads) {
-                                    layer.tilesetId = 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.
-                    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) != 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) != 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*/, 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: 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: 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*/];
-            }
-        });
-    });
-}
-var ViewRenderEngine;
-(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 = 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 = 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*/, 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*/, 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;
-})(ViewRenderEngine || (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 Cartesian2(x, y);
-        try {
-            var intersection = getAdjustedGroundIntersectionOfCameraRay(viewer, winPos);
-            if (intersection) {
-                var point = 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(Math$1.toRadians(center.longitude), Math$1.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(Math$1.toRadians(p1.longitude), Math$1.toRadians(p1.latitude));
-        }
-        if (p2 === null || p2 === void 0 ? void 0 : p2.latitude) {
-            updateMinMax(Math$1.toRadians(p2.longitude), Math$1.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 θ = Math$1.toRadians(heading);
-    var φ1 = Math$1.toRadians(point.latitude);
-    var λ1 = Math$1.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: Math$1.toDegrees(φ2),
-        longitude: Math$1.toDegrees(λ2)
-    };
-}
-/**
- * @param pos3d
- * @param distance in meters
- * @param heading in degrees
- * @returns
- */
-function _offsetPos3d(pos3d, distance, heading) {
-    var carto = Cartographic.fromCartesian(pos3d);
-    var newCarto = _offsetPoint({
-        altitude: carto.height,
-        latitude: Math$1.toDegrees(carto.latitude),
-        longitude: Math$1.toDegrees(carto.longitude)
-    }, distance, heading);
-    return 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, Math$1.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;
-}
-var CesiumViewMonitor;
-(function (CesiumViewMonitor$$1) {
-    /**
-     * 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 CallbackProperty(function () {
-                    return _this.target ? Cartesian3.fromDegrees(_this.target.longitude, _this.target.latitude) : null;
-                }, false),
-                point: {
-                    pixelSize: 8,
-                    color: Color.ORANGE,
-                    heightReference: HeightReference.NONE
-                },
-                rectangle: {
-                    coordinates: new CallbackProperty(function () {
-                        return _this.bounds ? Rectangle.fromDegrees(_this.bounds.west, _this.bounds.south, _this.bounds.east, _this.bounds.north) : null;
-                    }, false),
-                    material: Color.fromCssColorString('#ff0000').withAlpha(0.4),
-                    zIndex: 1,
-                    heightReference: 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 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*/, 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 = Math$1.toDegrees(Math.max(viewRectRad.east, cameraPosition.longitude));
-                                    viewRect.west = Math$1.toDegrees(Math.min(viewRectRad.west, cameraPosition.longitude));
-                                    viewRect.south = Math$1.toDegrees(Math.min(viewRectRad.south, cameraPosition.latitude));
-                                    viewRect.north = Math$1.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 = Math$1.toDegrees(camera.positionCartographic.latitude);
-                                center.longitude = Math$1.toDegrees(camera.positionCartographic.longitude);
-                            }
-                            else {
-                                windowPosition = new Cartesian2(this.viewer.container.clientWidth / 2, this.viewer.container.clientHeight / 2);
-                                intersection = getGroundCenterOfCameraRay(this.viewer, windowPosition);
-                                point = null;
-                                if (intersection) {
-                                    point = Cartographic.fromCartesian(intersection, this.viewer.scene.globe.ellipsoid);
-                                }
-                                if (point) {
-                                    center = {};
-                                    center.latitude = Math$1.toDegrees(point.latitude);
-                                    center.longitude = Math$1.toDegrees(point.longitude);
-                                    viewRectRad = netScanViewForBoundaries(this.viewer, center);
-                                    if (viewRectRad) {
-                                        viewRect = {};
-                                        viewRect.east = Math$1.toDegrees(viewRectRad.east);
-                                        viewRect.west = Math$1.toDegrees(viewRectRad.west);
-                                        viewRect.south = Math$1.toDegrees(viewRectRad.south);
-                                        viewRect.north = Math$1.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];
+                                    layer.tilesetId = ProjectViewTile.EDefaultImagery.MapboxSatellite;
+                                    console.warn("Cesium Ion token not set, using mapbox satellite instead of bing maps aerial.");
+                                }
+                                else if (layer.tilesetId == ProjectViewTile.EDefaultImagery.BingMapsAerialWithLabels) {
+                                    layer.tilesetId = ProjectViewTile.EDefaultImagery.MapboxSatellite;
+                                    console.warn("Cesium Ion token not set, using mapbox satellite instead of bing maps aerial with labels.");
+                                }
+                                else if (layer.tilesetId == ProjectViewTile.EDefaultImagery.BingMapsRoads) {
+                                    layer.tilesetId = 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.
+                    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) != 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) != 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*/, 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: 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: 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();
+        });
+    });
+}
+var ViewRenderEngine;
+(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 = 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 = 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*/, 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*/, 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$$1.Monitor = Monitor;
-})(CesiumViewMonitor || (CesiumViewMonitor = {}));
+            });
+        });
+    }
+    ViewRenderEngine.Render = Render;
+})(ViewRenderEngine || (ViewRenderEngine = {}));
 
-var VERSION$1 = "3.4.8";
+var VERSION = "3.4.9";
 
-export { VERSION$1 as VERSION, CesiumViewMonitor, ViewerUtils, MenuItemManager, EntityRenderEngine, MenuItemCreator, VisualsRegister, RenderManager, EntitiesIdsRenderManager, EntitiesLoadedRenderManager, EntitiesRenderManager, EntityRenderManager, TilesetCadRenderManager, TilesetArbRenderManager, TilesetEntitiesRenderManager, TilesetOsmRenderManager, TilesetPointcloudRenderManager, TilesetGooglePhotosRenderManager, DataSourceStaticKmlManager, RelationsRenderManager, SharedGetters, CesiumParabola, EntityLabel, ViewRenderEngine, TileRenderEngine, TilesetRenderEngine, CESIUM_INSPECTOR_KEY, ViewUtils, DrawingUtils, MeasureUtils, EntityUtils, Draw3dPolygon, Draw3dPolyline };
+export { VERSION, CesiumViewMonitor, ViewerUtils, MenuItemManager, EntityRenderEngine, MenuItemCreator, VisualsRegister, RenderManager, EntitiesIdsRenderManager, EntitiesLoadedRenderManager, EntitiesRenderManager, EntityRenderManager, TilesetCadRenderManager, TilesetArbRenderManager, TilesetEntitiesRenderManager, TilesetOsmRenderManager, TilesetPointcloudRenderManager, TilesetGooglePhotosRenderManager, DataSourceStaticKmlManager, RelationsRenderManager, SharedGetters, CesiumParabola, EntityLabel, ViewRenderEngine, TileRenderEngine, TilesetRenderEngine, CESIUM_INSPECTOR_KEY, ViewUtils, DrawingUtils, MeasureUtils, EntityUtils, Draw3dPolygon, Draw3dPolyline };
 //# sourceMappingURL=bruce-cesium.es5.js.map