bruce-cesium 2.9.5 → 2.9.7

package/dist/bruce-cesium.es5.js

@@ -1,6 +1,6 @@
-import { BruceEvent, Cartes, Carto, Entity as Entity$1, Geometry, Tileset, MathUtils, LRUCache, ZoomControl, Style, EntityTag, Calculator, EntityLod, EntityType, ClientFile, ObjectUtils, Bounds, EntityRelationType, DelayQueue, BatchedDataGetter, EntityCoords, EntityFilterGetter, EntitySource, MenuItem, EntityRelation, ENVIRONMENT, ProjectView, ProjectViewBookmark, ProjectViewTile, ProjectViewLegacyTile, ProgramKey, Camera, AbstractApi, EntityAttachment, EntityAttachmentType, EntityAttribute } from 'bruce-models';
+import { BruceEvent, Cartes, ProjectViewTile, Carto, Entity as Entity$1, Geometry, Tileset, MathUtils, LRUCache, ZoomControl, Style, EntityTag, Calculator, EntityLod, EntityType, ClientFile, ObjectUtils, Bounds, EntityRelationType, DelayQueue, BatchedDataGetter, EntityCoords, EntityFilterGetter, EntitySource, MenuItem, EntityRelation, ENVIRONMENT, ProjectView, ProjectViewBookmark, ProjectViewLegacyTile, ProgramKey, Camera, AbstractApi, EntityAttachment, EntityAttachmentType, EntityAttribute } from 'bruce-models';
 import * as Cesium from 'cesium';
-import { Cartographic, Cartesian2, CallbackProperty, Cartesian3, Color, Rectangle, Math as Math$1, JulianDate, Entity, Primitive, Cesium3DTileFeature, SceneMode, HeightReference, DistanceDisplayCondition, NearFarScalar, HorizontalOrigin, VerticalOrigin, ClassificationType, ArcType, CornerType, ShadowMode, PolygonHierarchy, PolylineGraphics, HeadingPitchRoll, Transforms, ColorBlendMode, Cesium3DTileColorBlendMode, HeadingPitchRange, Cesium3DTileStyle, KmlDataSource, createOsmBuildings, createWorldTerrain, EllipsoidTerrainProvider, CesiumTerrainProvider, BingMapsImageryProvider, BingMapsStyle, MapboxImageryProvider, MapboxStyleImageryProvider, ArcGisMapServerImageryProvider, OpenStreetMapImageryProvider, GridImageryProvider, GeographicTilingScheme, ImageryLayer, UrlTemplateImageryProvider, TileMapServiceImageryProvider, IonImageryProvider, SceneTransforms, CesiumInspector, OrthographicFrustum, defined, Cesium3DTileset, Matrix4, Matrix3, IonResource, Ion, EllipsoidGeodesic, sampleTerrainMostDetailed, Model, EasingFunction, PolygonPipeline, ColorMaterialProperty, GeometryInstance, ScreenSpaceEventHandler, ScreenSpaceEventType, BoundingSphere } from 'cesium';
+import { Cartographic, Cartesian2, CallbackProperty, Cartesian3, Color, Rectangle, Math as Math$1, JulianDate, HeightReference, DistanceDisplayCondition, NearFarScalar, Entity, HorizontalOrigin, VerticalOrigin, ClassificationType, ArcType, CornerType, ShadowMode, PolygonHierarchy, PolylineGraphics, HeadingPitchRoll, Transforms, ColorBlendMode, Primitive, Cesium3DTileFeature, Cesium3DTileColorBlendMode, HeadingPitchRange, createOsmBuildings, Cesium3DTileStyle, SceneMode, KmlDataSource, SceneTransforms, EllipsoidTerrainProvider, CesiumInspector, OrthographicFrustum, defined, EasingFunction, createWorldTerrain, CesiumTerrainProvider, BingMapsImageryProvider, BingMapsStyle, MapboxImageryProvider, MapboxStyleImageryProvider, ArcGisMapServerImageryProvider, OpenStreetMapImageryProvider, GridImageryProvider, GeographicTilingScheme, ImageryLayer, UrlTemplateImageryProvider, TileMapServiceImageryProvider, IonImageryProvider, EllipsoidGeodesic, sampleTerrainMostDetailed, Cesium3DTileset, Model, PolygonPipeline, Matrix4, Matrix3, IonResource, Ion, ScreenSpaceEventHandler, ScreenSpaceEventType, ColorMaterialProperty, GeometryInstance, BoundingSphere, Intersect } from 'cesium';
 
 var TIME_LAG = 300;
 var POSITION_CHECK_TIMER = 950;
@@ -727,6 +727,213 @@ var DrawingUtils;
     DrawingUtils.RaisePos3d = RaisePos3d;
 })(DrawingUtils || (DrawingUtils = {}));
 
+var CESIUM_INSPECTOR_KEY = "_nextspace_inspector";
+var ViewUtils;
+(function (ViewUtils) {
+    function GatherLegacyMapTiles(params) {
+        var viewer = params.viewer;
+        var collection = viewer.imageryLayers;
+        var tiles = [];
+        for (var i = 0; i < collection.length; i++) {
+            var layer = collection.get(i);
+            if (layer._bName) {
+                tiles.push({
+                    alpha: layer.alpha,
+                    brightness: layer.brightness,
+                    contrast: layer.contrast,
+                    hue: layer.hue,
+                    saturation: layer.saturation,
+                    gamma: layer.gamma,
+                    title: layer._bName,
+                });
+            }
+        }
+        return {
+            imagery: tiles.reverse()
+        };
+    }
+    ViewUtils.GatherLegacyMapTiles = GatherLegacyMapTiles;
+    function GatherLegacyTerrainTile(params) {
+        var viewer = params.viewer;
+        var enabled = viewer.terrainProvider;
+        if (enabled === null || enabled === void 0 ? void 0 : enabled._bName) {
+            return {
+                terrain: enabled._bName
+            };
+        }
+        return {
+            terrain: "flatterrain"
+        };
+    }
+    ViewUtils.GatherLegacyTerrainTile = GatherLegacyTerrainTile;
+    function GatherMapTiles(params) {
+        var viewer = params.viewer;
+        var imagery = viewer.imageryLayers;
+        var tiles = [];
+        var _loop_1 = function (i) {
+            var provider = imagery.get(i);
+            if (provider._bMeta) {
+                var idCombo_1 = provider._bMeta.accountId + provider._bMeta.tilesetId;
+                if (!tiles.find(function (x) { return x.accountId + x.tilesetId === idCombo_1; })) {
+                    tiles.push({
+                        accountId: provider._bMeta.accountId,
+                        tilesetId: provider._bMeta.tilesetId,
+                        alpha: provider.alpha,
+                        brightness: provider.brightness,
+                        contrast: provider.contrast,
+                        hue: provider.hue,
+                        saturation: provider.saturation,
+                        gamma: provider.gamma
+                    });
+                }
+            }
+        };
+        for (var i = 0; i < imagery.length; i++) {
+            _loop_1(i);
+        }
+        return {
+            imagery: tiles
+        };
+    }
+    ViewUtils.GatherMapTiles = GatherMapTiles;
+    function GatherTerrainTile(params) {
+        var viewer = params.viewer;
+        var provider = viewer.terrainProvider;
+        if (provider._bMeta) {
+            return {
+                terrain: {
+                    accountId: provider._bMeta.accountId,
+                    tilesetId: provider._bMeta.tilesetId,
+                }
+            };
+        }
+        else if (provider instanceof EllipsoidTerrainProvider) {
+            return {
+                terrain: {
+                    tilesetId: ProjectViewTile.EDefaultTerrain.FlatTerrain,
+                    accountId: null
+                }
+            };
+        }
+        return null;
+    }
+    ViewUtils.GatherTerrainTile = GatherTerrainTile;
+    function SetTerrainWireframeStatus(params) {
+        if (!params.viewer[CESIUM_INSPECTOR_KEY]) {
+            var InspectorClass = CesiumInspector;
+            if (InspectorClass) {
+                var inspector = new InspectorClass(document.createElement("div"), params.viewer.scene);
+                inspector.container.style.display = "none";
+                params.viewer[CESIUM_INSPECTOR_KEY] = inspector;
+                params.viewer.scene.requestRender();
+            }
+        }
+        if (params.viewer[CESIUM_INSPECTOR_KEY]) {
+            params.viewer[CESIUM_INSPECTOR_KEY].viewModel.wireframe = params.status;
+        }
+    }
+    ViewUtils.SetTerrainWireframeStatus = SetTerrainWireframeStatus;
+    function GetTerrainWireframeStatus(params) {
+        var _a, _b;
+        if (!params.viewer[CESIUM_INSPECTOR_KEY]) {
+            return false;
+        }
+        return (_b = (_a = params.viewer[CESIUM_INSPECTOR_KEY]) === null || _a === void 0 ? void 0 : _a.viewModel) === null || _b === void 0 ? void 0 : _b.wireframe;
+    }
+    ViewUtils.GetTerrainWireframeStatus = GetTerrainWireframeStatus;
+    /**
+     * Changes between perspective and orthographic view.
+     * When Cesium stops being bad at picking positions in 2d mode we'll use the flat earth mode instead.
+     * @param params
+     */
+    function Set2dStatus(params) {
+        var viewer = params.viewer, is2d = params.status, moveCamera = params.moveCamera;
+        var curLens2d = viewer.camera.frustum instanceof OrthographicFrustum;
+        if (curLens2d && !is2d) {
+            viewer.camera.switchToPerspectiveFrustum();
+            viewer.scene.screenSpaceCameraController.enableTilt = true;
+            viewer.scene.requestRender();
+        }
+        else if (!curLens2d && is2d) {
+            viewer.camera.switchToOrthographicFrustum();
+            viewer.scene.screenSpaceCameraController.enableTilt = false;
+            if (moveCamera != false) {
+                try {
+                    // Face camera downwards to make it look 2d.
+                    // We want to try make it look at the center-point of the current view.
+                    // If center cannot be calculated then we'll simply raise the camera and face it downwards.
+                    var scene = viewer.scene;
+                    var windowPosition = new Cartesian2(scene.canvas.clientWidth / 2, scene.canvas.clientHeight / 2);
+                    var ray = viewer.camera.getPickRay(windowPosition);
+                    var intersection = scene.globe.pick(ray, scene);
+                    var center = void 0;
+                    if (defined(intersection)) {
+                        center = Cartographic.fromCartesian(intersection);
+                    }
+                    // Use current camera position if we can't calculate the center.
+                    else {
+                        center = Cartographic.fromCartesian(viewer.camera.position);
+                        center.height = 0;
+                    }
+                    center.height = viewer.camera.positionCartographic.height + 100;
+                    viewer.camera.setView({
+                        destination: Cartographic.toCartesian(center),
+                        orientation: {
+                            heading: 0.0,
+                            pitch: Math$1.toRadians(-90.0),
+                            roll: 0.0
+                        }
+                    });
+                }
+                catch (e) {
+                    console.error(e);
+                }
+            }
+            viewer.scene.requestRender();
+        }
+    }
+    ViewUtils.Set2dStatus = Set2dStatus;
+    function Get2dStatus(params) {
+        var viewer = params.viewer;
+        return viewer.camera.frustum instanceof OrthographicFrustum;
+    }
+    ViewUtils.Get2dStatus = Get2dStatus;
+    function SetLockedCameraStatus(params) {
+        var viewer = params.viewer, status = params.status;
+        var scene = viewer === null || viewer === void 0 ? void 0 : viewer.scene;
+        if (!scene) {
+            return;
+        }
+        if (status) {
+            scene.screenSpaceCameraController.enableInputs = false;
+            scene.screenSpaceCameraController.enableTranslate = false;
+            scene.screenSpaceCameraController.enableZoom = false;
+            scene.screenSpaceCameraController.enableRotate = false;
+            scene.screenSpaceCameraController.enableTilt = false;
+        }
+        else {
+            scene.screenSpaceCameraController.enableInputs = true;
+            scene.screenSpaceCameraController.enableTranslate = true;
+            scene.screenSpaceCameraController.enableZoom = true;
+            scene.screenSpaceCameraController.enableRotate = true;
+            if (!ViewUtils.Get2dStatus({ viewer: viewer })) {
+                scene.screenSpaceCameraController.enableTilt = true;
+            }
+        }
+        viewer.scene.requestRender();
+    }
+    ViewUtils.SetLockedCameraStatus = SetLockedCameraStatus;
+    function GetLockedCameraStatus(params) {
+        var _a;
+        var scene = (_a = params.viewer) === null || _a === void 0 ? void 0 : _a.scene;
+        if (!scene) {
+            return false;
+        }
+        return !scene.screenSpaceCameraController.enableTranslate;
+    }
+    ViewUtils.GetLockedCameraStatus = GetLockedCameraStatus;
+})(ViewUtils || (ViewUtils = {}));
+
 /**
  * Returns if a given visual is alive and in the scene.
  * @param viewer
@@ -891,10 +1098,522 @@ function GetValue(viewer, obj) {
 }
 var EntityUtils;
 (function (EntityUtils) {
+    /**
+     * Returns the location for given entity or entities.
+     * If available it will also compute a rectangle.
+     * It is recommended to fly-to a rectangle if available as it will ensure the full geometry is in view.
+     * @param params
+     */
+    function GetLocation(params) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var api, viewer, samples, visualRegister, minimumAlt, paddingAlt, MAX_DISTANCE_BETWEEN_SAMPLES, MAX_TERRAIN_SAMPLES, terrainSamples, MAX_API_CALLS, apiCalls, MAX_VALID_SAMPLES, validSamples, MIN_RECT_DIAGONAL_LENGTH, data, processPosHeight, ensureHeightRefs, getEntityPositions, allPosses, i, sample, samplePosses, valid, j, samplePos, k, allPos, distance, rect, factor, marginX, marginY, diagonalLen, terrData, posCarto, height, MIN_POSSES_LEN;
+            var _this = this;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        api = params.api, viewer = params.viewer, samples = params.samples, visualRegister = params.visualRegister, minimumAlt = params.minimumAlt, paddingAlt = params.paddingAlt;
+                        if (!paddingAlt) {
+                            paddingAlt = 0;
+                        }
+                        MAX_DISTANCE_BETWEEN_SAMPLES = 5000;
+                        MAX_TERRAIN_SAMPLES = 25;
+                        terrainSamples = 0;
+                        MAX_API_CALLS = 10;
+                        apiCalls = 0;
+                        MAX_VALID_SAMPLES = 20;
+                        validSamples = 0;
+                        MIN_RECT_DIAGONAL_LENGTH = isNaN(minimumAlt) || minimumAlt == null ? 0 : minimumAlt * 10;
+                        if (MIN_RECT_DIAGONAL_LENGTH < 1500) {
+                            MIN_RECT_DIAGONAL_LENGTH = 1500;
+                        }
+                        data = {
+                            pos3d: null,
+                            rectangle: null
+                        };
+                        processPosHeight = function (pos3d, heightRef) { return __awaiter(_this, void 0, void 0, function () {
+                            var carto, baseHeight, terrData, height, carto;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        if (!(!isNaN(minimumAlt) && minimumAlt != null)) return [3 /*break*/, 5];
+                                        carto = Cartographic.fromCartesian(pos3d);
+                                        if (!(carto === null || carto === void 0 ? void 0 : carto.latitude)) return [3 /*break*/, 4];
+                                        baseHeight = 0;
+                                        if (!(heightRef == null || heightRef == HeightReference.RELATIVE_TO_GROUND || heightRef == HeightReference.NONE)) return [3 /*break*/, 3];
+                                        if (!(terrainSamples > MAX_TERRAIN_SAMPLES)) return [3 /*break*/, 1];
+                                        baseHeight = viewer.scene.globe.getHeight(carto);
+                                        return [3 /*break*/, 3];
+                                    case 1: return [4 /*yield*/, DrawingUtils.GetTerrainHeight({
+                                            pos3d: pos3d,
+                                            viewer: viewer
+                                        })];
+                                    case 2:
+                                        terrData = _a.sent();
+                                        baseHeight = terrData === null || terrData === void 0 ? void 0 : terrData.height;
+                                        terrainSamples += 1;
+                                        _a.label = 3;
+                                    case 3:
+                                        if (baseHeight != undefined && !isNaN(baseHeight)) {
+                                            height = baseHeight + minimumAlt;
+                                            if (height > carto.height) {
+                                                carto.height = height;
+                                            }
+                                            return [2 /*return*/, Cartesian3.fromRadians(carto.longitude, carto.latitude, carto.height + paddingAlt)];
+                                        }
+                                        _a.label = 4;
+                                    case 4: return [3 /*break*/, 6];
+                                    case 5:
+                                        if (paddingAlt) {
+                                            carto = Cartographic.fromCartesian(pos3d);
+                                            if (carto === null || carto === void 0 ? void 0 : carto.latitude) {
+                                                return [2 /*return*/, Cartesian3.fromRadians(carto.longitude, carto.latitude, carto.height + paddingAlt)];
+                                            }
+                                        }
+                                        _a.label = 6;
+                                    case 6: return [2 /*return*/, pos3d];
+                                }
+                            });
+                        }); };
+                        ensureHeightRefs = function (posses, sample) { return __awaiter(_this, void 0, void 0, function () {
+                            var heightRef, returnHeightRef, i, _a, _b;
+                            return __generator(this, function (_c) {
+                                switch (_c.label) {
+                                    case 0:
+                                        if (!(posses === null || posses === void 0 ? void 0 : posses.length)) return [3 /*break*/, 4];
+                                        heightRef = sample.heightRef;
+                                        returnHeightRef = sample.returnHeightRef;
+                                        i = 0;
+                                        _c.label = 1;
+                                    case 1:
+                                        if (!(i < posses.length)) return [3 /*break*/, 4];
+                                        if (heightRef != null && returnHeightRef != null && heightRef != returnHeightRef) {
+                                            posses[i] = DrawingUtils.EnsurePosHeight({
+                                                desiredHeightRef: returnHeightRef,
+                                                heightRef: heightRef,
+                                                pos3d: posses[i],
+                                                viewer: viewer
+                                            });
+                                        }
+                                        _a = posses;
+                                        _b = i;
+                                        return [4 /*yield*/, processPosHeight(posses[i], returnHeightRef)];
+                                    case 2:
+                                        _a[_b] = _c.sent();
+                                        _c.label = 3;
+                                    case 3:
+                                        i++;
+                                        return [3 /*break*/, 1];
+                                    case 4: return [2 /*return*/];
+                                }
+                            });
+                        }); };
+                        getEntityPositions = function (sample) { return __awaiter(_this, void 0, void 0, function () {
+                            var entityId, entity, tileset, tilesetId, lat, lon, e_1, e_2, evaluateRendered, evaluateRecord, renderedPosses, recordPosses, tSettings, pos3d, alt, alt, heading, pitch, roll, matrix4, offset, m1, hpr, transform, transformedOffset;
+                            var _this = this;
+                            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+                            return __generator(this, function (_o) {
+                                switch (_o.label) {
+                                    case 0:
+                                        entityId = sample.entityId, entity = sample.entity, tileset = sample.tileset, tilesetId = sample.tilesetId;
+                                        if (!!entity) return [3 /*break*/, 9];
+                                        lat = 0;
+                                        lon = 0;
+                                        if (!(apiCalls < MAX_API_CALLS)) return [3 /*break*/, 9];
+                                        // Counting this whole area as a single call because it has a single purpose.
+                                        apiCalls += 1;
+                                        _o.label = 1;
+                                    case 1:
+                                        _o.trys.push([1, 3, , 4]);
+                                        return [4 /*yield*/, Entity$1.Get({
+                                                api: api,
+                                                entityId: entityId,
+                                                expandLocation: false
+                                            })];
+                                    case 2:
+                                        entity = (_o.sent()).entity;
+                                        lat = +((_a = entity === null || entity === void 0 ? void 0 : entity.location) === null || _a === void 0 ? void 0 : _a.latitude);
+                                        lon = +((_b = entity === null || entity === void 0 ? void 0 : entity.location) === null || _b === void 0 ? void 0 : _b.longitude);
+                                        return [3 /*break*/, 4];
+                                    case 3:
+                                        e_1 = _o.sent();
+                                        console.error(e_1);
+                                        return [3 /*break*/, 4];
+                                    case 4:
+                                        if (!(entity && (isNaN(lat) || isNaN(lon) || (lat == 0 && lon == 0)))) return [3 /*break*/, 9];
+                                        _o.label = 5;
+                                    case 5:
+                                        _o.trys.push([5, 7, , 9]);
+                                        return [4 /*yield*/, Entity$1.Get({
+                                                api: api,
+                                                entityId: entityId,
+                                                expandLocation: true
+                                            })];
+                                    case 6:
+                                        entity = (_o.sent()).entity;
+                                        return [3 /*break*/, 9];
+                                    case 7:
+                                        e_2 = _o.sent();
+                                        console.warn(e_2);
+                                        return [4 /*yield*/, Entity$1.Get({
+                                                api: api,
+                                                entityId: entityId,
+                                                expandLocation: false
+                                            })];
+                                    case 8:
+                                        entity = (_o.sent()).entity;
+                                        return [3 /*break*/, 9];
+                                    case 9:
+                                        if (!entity) {
+                                            return [2 /*return*/, []];
+                                        }
+                                        if (!tilesetId) {
+                                            tilesetId = ((_c = entity.tilesetID) === null || _c === void 0 ? void 0 : _c.length) ? entity.tilesetID[0] : tilesetId;
+                                        }
+                                        evaluateRendered = function () { return __awaiter(_this, void 0, void 0, function () {
+                                            var rego, posses, visual, visualHeightRef, hierarchy, hPosses, hPossesSample, step, i, pPosses, pPossesSample, step, i, pPosses, pPossesSample, step, i, pos3d_1;
+                                            return __generator(this, function (_a) {
+                                                switch (_a.label) {
+                                                    case 0:
+                                                        rego = visualRegister ? visualRegister.GetRego({
+                                                            entityId: entity.Bruce.ID,
+                                                        }) : null;
+                                                        posses = [];
+                                                        if (!((rego === null || rego === void 0 ? void 0 : rego.visual) instanceof Entity)) return [3 /*break*/, 14];
+                                                        visual = rego.visual;
+                                                        visualHeightRef = HeightReference.RELATIVE_TO_GROUND;
+                                                        if (!visual.model) return [3 /*break*/, 1];
+                                                        visualHeightRef = GetValue(viewer, visual.model.heightReference);
+                                                        return [3 /*break*/, 12];
+                                                    case 1:
+                                                        if (!visual.polygon) return [3 /*break*/, 4];
+                                                        visualHeightRef = GetValue(viewer, visual.polygon.heightReference);
+                                                        hierarchy = GetValue(viewer, visual.polygon.hierarchy);
+                                                        if (!(hierarchy === null || hierarchy === void 0 ? void 0 : hierarchy.positions)) return [3 /*break*/, 3];
+                                                        hPosses = hierarchy.positions.map(function (x) { return x.clone ? x.clone() : x; });
+                                                        hPossesSample = [];
+                                                        step = Math.floor(hPosses.length / 5);
+                                                        for (i = 0; i < hPosses.length; i += step) {
+                                                            hPossesSample.push(hPosses[i]);
+                                                        }
+                                                        return [4 /*yield*/, ensureHeightRefs(hPossesSample, __assign(__assign({}, sample), { heightRef: visualHeightRef }))];
+                                                    case 2:
+                                                        _a.sent();
+                                                        posses = posses.concat(hPossesSample);
+                                                        _a.label = 3;
+                                                    case 3: return [3 /*break*/, 12];
+                                                    case 4:
+                                                        if (!visual.polyline) return [3 /*break*/, 7];
+                                                        visualHeightRef = GetValue(viewer, visual.polyline.clampToGround) ?
+                                                            HeightReference.CLAMP_TO_GROUND : HeightReference.NONE;
+                                                        pPosses = GetValue(viewer, visual.polyline.positions);
+                                                        if (!(pPosses === null || pPosses === void 0 ? void 0 : pPosses.length)) return [3 /*break*/, 6];
+                                                        // Grab 5 positions from the polyline at varied indexes.
+                                                        pPosses = pPosses.map(function (x) { return x.clone ? x.clone() : x; });
+                                                        pPossesSample = [];
+                                                        step = Math.floor(pPosses.length / 5);
+                                                        for (i = 0; i < pPosses.length; i += step) {
+                                                            pPossesSample.push(pPosses[i]);
+                                                        }
+                                                        return [4 /*yield*/, ensureHeightRefs(pPossesSample, __assign(__assign({}, sample), { heightRef: visualHeightRef }))];
+                                                    case 5:
+                                                        _a.sent();
+                                                        posses = posses.concat(pPossesSample);
+                                                        _a.label = 6;
+                                                    case 6: return [3 /*break*/, 12];
+                                                    case 7:
+                                                        if (!visual.billboard) return [3 /*break*/, 8];
+                                                        visualHeightRef = GetValue(viewer, visual.billboard.heightReference);
+                                                        return [3 /*break*/, 12];
+                                                    case 8:
+                                                        if (!visual.corridor) return [3 /*break*/, 11];
+                                                        visualHeightRef = GetValue(viewer, visual.corridor.heightReference);
+                                                        pPosses = GetValue(viewer, visual.corridor.positions);
+                                                        if (!(pPosses === null || pPosses === void 0 ? void 0 : pPosses.length)) return [3 /*break*/, 10];
+                                                        // Grab 5 positions from the corridor at varied indexes.
+                                                        pPosses = pPosses.map(function (x) { return x.clone ? x.clone() : x; });
+                                                        pPossesSample = [];
+                                                        step = Math.floor(pPosses.length / 5);
+                                                        for (i = 0; i < pPosses.length; i += step) {
+                                                            pPossesSample.push(pPosses[i]);
+                                                        }
+                                                        return [4 /*yield*/, ensureHeightRefs(pPossesSample, __assign(__assign({}, sample), { heightRef: visualHeightRef }))];
+                                                    case 9:
+                                                        _a.sent();
+                                                        posses = posses.concat(pPossesSample);
+                                                        _a.label = 10;
+                                                    case 10: return [3 /*break*/, 12];
+                                                    case 11:
+                                                        if (visual.ellipse) {
+                                                            visualHeightRef = GetValue(viewer, visual.ellipse.heightReference);
+                                                        }
+                                                        else if (visual.point) {
+                                                            visualHeightRef = GetValue(viewer, visual.point.heightReference);
+                                                        }
+                                                        _a.label = 12;
+                                                    case 12:
+                                                        pos3d_1 = GetValue(viewer, visual.position);
+                                                        if (!(pos3d_1 === null || pos3d_1 === void 0 ? void 0 : pos3d_1.x)) return [3 /*break*/, 14];
+                                                        pos3d_1 = DrawingUtils.EnsurePosHeight({
+                                                            desiredHeightRef: sample.returnHeightRef,
+                                                            heightRef: visualHeightRef,
+                                                            pos3d: pos3d_1,
+                                                            viewer: viewer
+                                                        });
+                                                        return [4 /*yield*/, processPosHeight(pos3d_1, sample.returnHeightRef)];
+                                                    case 13:
+                                                        pos3d_1 = _a.sent();
+                                                        posses.push(pos3d_1);
+                                                        _a.label = 14;
+                                                    case 14: return [2 /*return*/, posses];
+                                                }
+                                            });
+                                        }); };
+                                        evaluateRecord = function () { return __awaiter(_this, void 0, void 0, function () {
+                                            var posses, location_1, latitude, longitude, pos3d_2, pointStr, points, point, pos3d_3, lineStr, points, pPosses, pRings, boundary, points, pPosses, point, bPosses;
+                                            return __generator(this, function (_a) {
+                                                switch (_a.label) {
+                                                    case 0:
+                                                        posses = [];
+                                                        if (entity.location && Carto.ValidateCarto(entity.location)) {
+                                                            location_1 = entity.location;
+                                                            latitude = EnsureNumber(location_1.latitude);
+                                                            longitude = EnsureNumber(location_1.longitude);
+                                                            // Disallowing exact 0.
+                                                            if (latitude || longitude) {
+                                                                pos3d_2 = Cartesian3.fromDegrees(longitude, latitude, EnsureNumber(location_1.altitude));
+                                                                posses.push(pos3d_2);
+                                                            }
+                                                        }
+                                                        if (!(entity.geometry && typeof entity.geometry == "object")) return [3 /*break*/, 4];
+                                                        pointStr = entity.geometry.Point;
+                                                        if (pointStr && typeof pointStr == "string") {
+                                                            points = Geometry.ParsePoints(pointStr);
+                                                            point = points.length > 0 ? points[0] : null;
+                                                            if (point && Carto.ValidateCarto(point)) {
+                                                                pos3d_3 = Cartesian3.fromDegrees(EnsureNumber(point.longitude), EnsureNumber(point.latitude), EnsureNumber(point.altitude));
+                                                                posses.push(pos3d_3);
+                                                            }
+                                                        }
+                                                        lineStr = entity.geometry.LineString;
+                                                        if (!(lineStr && typeof lineStr == "string")) return [3 /*break*/, 2];
+                                                        points = Geometry.ParsePoints(lineStr);
+                                                        if (!(points.length > 0)) return [3 /*break*/, 2];
+                                                        pPosses = points.map(function (x) { return Cartesian3.fromDegrees(EnsureNumber(x.longitude), EnsureNumber(x.latitude), EnsureNumber(x.altitude)); });
+                                                        return [4 /*yield*/, ensureHeightRefs(pPosses, sample)];
+                                                    case 1:
+                                                        _a.sent();
+                                                        posses = posses.concat(pPosses);
+                                                        _a.label = 2;
+                                                    case 2:
+                                                        pRings = entity.geometry.Polygon;
+                                                        if (!(pRings && typeof pRings == "object")) return [3 /*break*/, 4];
+                                                        boundary = pRings.find(function (x) { return x.Facing == Geometry.EPolygonRingType.Boundaries; });
+                                                        if (!(boundary === null || boundary === void 0 ? void 0 : boundary.LinearRing)) return [3 /*break*/, 4];
+                                                        points = Geometry.ParsePoints(boundary.LinearRing);
+                                                        pPosses = points.map(function (x) { return Cartesian3.fromDegrees(EnsureNumber(x.longitude), EnsureNumber(x.latitude), EnsureNumber(x.altitude)); });
+                                                        return [4 /*yield*/, ensureHeightRefs(pPosses, sample)];
+                                                    case 3:
+                                                        _a.sent();
+                                                        posses = posses.concat(pPosses);
+                                                        _a.label = 4;
+                                                    case 4:
+                                                        if (!entity.boundaries) return [3 /*break*/, 6];
+                                                        point = {
+                                                            latitude: (EnsureNumber(entity.boundaries.minLatitude) + EnsureNumber(entity.boundaries.maxLatitude)) / 2,
+                                                            longitude: (EnsureNumber(entity.boundaries.minLongitude) + EnsureNumber(entity.boundaries.maxLongitude)) / 2,
+                                                            altitude: 0
+                                                        };
+                                                        if (!(point.latitude || point.longitude)) return [3 /*break*/, 6];
+                                                        bPosses = [
+                                                            Cartesian3.fromDegrees(EnsureNumber(entity.boundaries.minLongitude), EnsureNumber(entity.boundaries.minLatitude), EnsureNumber(entity.boundaries.minAltitude)),
+                                                            Cartesian3.fromDegrees(EnsureNumber(entity.boundaries.maxLongitude), EnsureNumber(entity.boundaries.maxLatitude), EnsureNumber(entity.boundaries.maxAltitude))
+                                                        ];
+                                                        return [4 /*yield*/, ensureHeightRefs(bPosses, sample)];
+                                                    case 5:
+                                                        _a.sent();
+                                                        posses = posses.concat(bPosses);
+                                                        _a.label = 6;
+                                                    case 6: return [2 /*return*/, posses];
+                                                }
+                                            });
+                                        }); };
+                                        return [4 /*yield*/, evaluateRendered()];
+                                    case 10:
+                                        renderedPosses = _o.sent();
+                                        if (renderedPosses === null || renderedPosses === void 0 ? void 0 : renderedPosses.length) {
+                                            return [2 /*return*/, renderedPosses];
+                                        }
+                                        return [4 /*yield*/, evaluateRecord()];
+                                    case 11:
+                                        recordPosses = _o.sent();
+                                        if (recordPosses === null || recordPosses === void 0 ? void 0 : recordPosses.length) {
+                                            return [2 /*return*/, recordPosses];
+                                        }
+                                        if (!!tileset) return [3 /*break*/, 13];
+                                        if (!(tilesetId && apiCalls < MAX_API_CALLS)) return [3 /*break*/, 13];
+                                        apiCalls += 1;
+                                        return [4 /*yield*/, Tileset.Get({
+                                                api: api,
+                                                tilesetId: tilesetId
+                                            })];
+                                    case 12:
+                                        tileset = (_o.sent()).tileset;
+                                        _o.label = 13;
+                                    case 13:
+                                        tSettings = tileset === null || tileset === void 0 ? void 0 : tileset.settings;
+                                        pos3d = null;
+                                        if (!(((_d = entity.location) === null || _d === void 0 ? void 0 : _d.longitude) || ((_e = tSettings === null || tSettings === void 0 ? void 0 : tSettings.location) === null || _e === void 0 ? void 0 : _e.longitude))) return [3 /*break*/, 15];
+                                        if ((_f = entity === null || entity === void 0 ? void 0 : entity.location) === null || _f === void 0 ? void 0 : _f.longitude) {
+                                            alt = +entity.location.altitude;
+                                            if (isNaN(alt)) {
+                                                alt = 0;
+                                            }
+                                            pos3d = Cartesian3.fromDegrees(+entity.location.longitude, +entity.location.latitude, alt);
+                                        }
+                                        else {
+                                            alt = +tSettings.location.altitude;
+                                            if (isNaN(alt)) {
+                                                alt = 0;
+                                            }
+                                            pos3d = Cartesian3.fromDegrees(+tSettings.location.longitude, +tSettings.location.latitude, alt);
+                                        }
+                                        if (!(entity === null || entity === void 0 ? void 0 : entity.worldPosition)) return [3 /*break*/, 15];
+                                        heading = 0;
+                                        pitch = 0;
+                                        roll = 0;
+                                        if ((_g = entity === null || entity === void 0 ? void 0 : entity.transform) === null || _g === void 0 ? void 0 : _g.heading) {
+                                            heading = entity.transform.heading;
+                                        }
+                                        else if ((_h = tSettings === null || tSettings === void 0 ? void 0 : tSettings.transform) === null || _h === void 0 ? void 0 : _h.heading) {
+                                            heading = tSettings.transform.heading;
+                                        }
+                                        if ((_j = entity === null || entity === void 0 ? void 0 : entity.transform) === null || _j === void 0 ? void 0 : _j.pitch) {
+                                            pitch = entity.transform.pitch;
+                                        }
+                                        else if ((_k = tSettings === null || tSettings === void 0 ? void 0 : tSettings.transform) === null || _k === void 0 ? void 0 : _k.pitch) {
+                                            pitch = tSettings.transform.pitch;
+                                        }
+                                        if ((_l = entity === null || entity === void 0 ? void 0 : entity.transform) === null || _l === void 0 ? void 0 : _l.roll) {
+                                            roll = entity.transform.roll;
+                                        }
+                                        else if ((_m = tSettings === null || tSettings === void 0 ? void 0 : tSettings.transform) === null || _m === void 0 ? void 0 : _m.roll) {
+                                            roll = tSettings.transform.roll;
+                                        }
+                                        heading = +heading;
+                                        if (isNaN(heading)) {
+                                            heading = 0;
+                                        }
+                                        pitch = +pitch;
+                                        if (isNaN(pitch)) {
+                                            pitch = 0;
+                                        }
+                                        roll = +roll;
+                                        if (isNaN(roll)) {
+                                            roll = 0;
+                                        }
+                                        matrix4 = entity.worldPosition;
+                                        offset = new Cartesian3(+matrix4[0][3], +matrix4[1][3], +matrix4[2][3]);
+                                        if (entity.worldPivot) //the position from worldMatrix + center of geometry offset
+                                         {
+                                            offset = new Cartesian3(entity.worldPivot[0], entity.worldPivot[1], entity.worldPivot[2]);
+                                        }
+                                        m1 = Transforms.eastNorthUpToFixedFrame(pos3d);
+                                        hpr = HeadingPitchRoll.fromDegrees(heading, pitch, roll, new HeadingPitchRoll());
+                                        transform = Matrix3.fromHeadingPitchRoll(hpr);
+                                        transformedOffset = Matrix3.multiplyByVector(transform, offset, new Cartesian3());
+                                        pos3d = Matrix4.multiplyByPoint(m1, transformedOffset, new Cartesian3());
+                                        if (!(pos3d === null || pos3d === void 0 ? void 0 : pos3d.x)) return [3 /*break*/, 15];
+                                        return [4 /*yield*/, processPosHeight(pos3d, HeightReference.NONE)];
+                                    case 14:
+                                        pos3d = _o.sent();
+                                        _o.label = 15;
+                                    case 15:
+                                        if (pos3d) {
+                                            return [2 /*return*/, [pos3d]];
+                                        }
+                                        return [2 /*return*/, []];
+                                }
+                            });
+                        }); };
+                        allPosses = [];
+                        i = 0;
+                        _b.label = 1;
+                    case 1:
+                        if (!(i < samples.length)) return [3 /*break*/, 4];
+                        sample = samples[i];
+                        return [4 /*yield*/, getEntityPositions(sample)];
+                    case 2:
+                        samplePosses = _b.sent();
+                        if (samplePosses === null || samplePosses === void 0 ? void 0 : samplePosses.length) {
+                            valid = !(allPosses === null || allPosses === void 0 ? void 0 : allPosses.length);
+                            if (!valid) {
+                                for (j = 0; j < samplePosses.length; j++) {
+                                    samplePos = samplePosses[j];
+                                    for (k = 0; k < allPosses.length; k++) {
+                                        allPos = allPosses[k];
+                                        distance = Cartesian3.distance(samplePos, allPos);
+                                        if (distance < MAX_DISTANCE_BETWEEN_SAMPLES) {
+                                            valid = true;
+                                            break;
+                                        }
+                                    }
+                                    if (valid) {
+                                        break;
+                                    }
+                                }
+                            }
+                            if (valid) {
+                                allPosses = allPosses.concat(samplePosses);
+                                validSamples += 1;
+                                if (validSamples >= MAX_VALID_SAMPLES) {
+                                    return [3 /*break*/, 4];
+                                }
+                            }
+                        }
+                        _b.label = 3;
+                    case 3:
+                        i++;
+                        return [3 /*break*/, 1];
+                    case 4:
+                        if (allPosses.length > 1) {
+                            rect = allPosses.length == 1 ? null : Rectangle.fromCartesianArray(allPosses);
+                            factor = 0.1;
+                            marginX = rect.width * factor / 2;
+                            marginY = rect.height * factor / 2;
+                            rect.east += marginX;
+                            rect.west -= marginX;
+                            rect.north += marginY;
+                            rect.south -= marginY;
+                            diagonalLen = Cartesian3.distance(Cartesian3.fromRadians(rect.west, rect.north), Cartesian3.fromRadians(rect.east, rect.south));
+                            terrData = ViewUtils.GatherTerrainTile({
+                                viewer: viewer
+                            });
+                            if (((_a = terrData === null || terrData === void 0 ? void 0 : terrData.terrain) === null || _a === void 0 ? void 0 : _a.tilesetId) == ProjectViewTile.EDefaultTerrain.FlatTerrain) {
+                                MIN_RECT_DIAGONAL_LENGTH = 0;
+                            }
+                            posCarto = Cartographic.fromCartesian(allPosses[0]);
+                            height = posCarto.height + (diagonalLen * 1.5);
+                            data.pos3d = Cartesian3.fromRadians(posCarto.longitude, posCarto.latitude, height);
+                            MIN_POSSES_LEN = 10;
+                            if (diagonalLen >= MIN_RECT_DIAGONAL_LENGTH && allPosses.length >= MIN_POSSES_LEN) {
+                                data.rectangle = rect;
+                            }
+                        }
+                        else if (allPosses.length == 1) {
+                            data.pos3d = allPosses[0];
+                        }
+                        return [2 /*return*/, data];
+                }
+            });
+        });
+    }
+    EntityUtils.GetLocation = GetLocation;
     /**
      * Returns an entity's position.
      * This will attempt to calculate it from multiple sources of data.
      * @param params
+     * @deprecated use GetLocation instead.
      * @returns
      */
     function GetPos(params) {
@@ -906,9 +1625,9 @@ var EntityUtils;
             if ((rego === null || rego === void 0 ? void 0 : rego.visual) instanceof Entity) {
                 var visual = rego.visual;
                 if (visual.position) {
-                    var pos3d_1 = GetValue(viewer, visual.position);
+                    var pos3d_4 = GetValue(viewer, visual.position);
                     // Fix height reference.
-                    if (pos3d_1 === null || pos3d_1 === void 0 ? void 0 : pos3d_1.x) {
+                    if (pos3d_4 === null || pos3d_4 === void 0 ? void 0 : pos3d_4.x) {
                         var visualHeightRef = HeightReference.RELATIVE_TO_GROUND;
                         if (visual.model) {
                             visualHeightRef = GetValue(viewer, visual.model.heightReference);
@@ -935,7 +1654,7 @@ var EntityUtils;
                         return DrawingUtils.EnsurePosHeight({
                             desiredHeightRef: params.returnHeightRef,
                             heightRef: visualHeightRef,
-                            pos3d: pos3d_1,
+                            pos3d: pos3d_4,
                             viewer: viewer
                         });
                     }
@@ -945,12 +1664,12 @@ var EntityUtils;
         }
         function evaluateRecord() {
             if (entity.location && Carto.ValidateCarto(entity.location)) {
-                var location_1 = entity.location;
-                var latitude = EnsureNumber(location_1.latitude);
-                var longitude = EnsureNumber(location_1.longitude);
+                var location_2 = entity.location;
+                var latitude = EnsureNumber(location_2.latitude);
+                var longitude = EnsureNumber(location_2.longitude);
                 // Disallowing exact 0.
                 if (latitude || longitude) {
-                    return Cartesian3.fromDegrees(longitude, latitude, EnsureNumber(location_1.altitude));
+                    return Cartesian3.fromDegrees(longitude, latitude, EnsureNumber(location_2.altitude));
                 }
             }
             if (entity.geometry && typeof entity.geometry == "object") {
@@ -1028,12 +1747,13 @@ var EntityUtils;
      * Returns the position of the entity.
      * This is an async variant that checks for related tilesets.
      * @param params
+     * @deprecated use GetLocation instead.
      * @returns
      */
     function GetPosAsync(params) {
         var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
         return __awaiter(this, void 0, void 0, function () {
-            var viewer, entityId, entity, tileset, tilesetId, visualRegister, returnHeightRef, recordHeightRef, api, lat, lon, e_1, e_2, pos3d, tSettings, alt, alt, heading, pitch, roll, matrix4, offset, m1, hpr, transform, transformedOffset;
+            var viewer, entityId, entity, tileset, tilesetId, visualRegister, returnHeightRef, recordHeightRef, api, lat, lon, e_3, e_4, pos3d, tSettings, alt, alt, heading, pitch, roll, matrix4, offset, m1, hpr, transform, transformedOffset;
             return __generator(this, function (_o) {
                 switch (_o.label) {
                     case 0:
@@ -1055,8 +1775,8 @@ var EntityUtils;
                         lon = +((_b = entity === null || entity === void 0 ? void 0 : entity.location) === null || _b === void 0 ? void 0 : _b.longitude);
                         return [3 /*break*/, 4];
                     case 3:
-                        e_1 = _o.sent();
-                        console.error(e_1);
+                        e_3 = _o.sent();
+                        console.error(e_3);
                         return [3 /*break*/, 4];
                     case 4:
                         if (!(entity && (isNaN(lat) || isNaN(lon) || (lat == 0 && lon == 0)))) return [3 /*break*/, 9];
@@ -1072,8 +1792,8 @@ var EntityUtils;
                         entity = (_o.sent()).entity;
                         return [3 /*break*/, 9];
                     case 7:
-                        e_2 = _o.sent();
-                        console.warn(e_2);
+                        e_4 = _o.sent();
+                        console.warn(e_4);
                         return [4 /*yield*/, Entity$1.Get({
                                 api: api,
                                 entityId: entityId,
@@ -1205,90 +1925,107 @@ var EntityUtils;
      * @param entities
      */
     function LookAtEntities(params) {
-        var viewer = params.viewer, entities = params.entities;
-        // Removing cesium tileset features for now as it's not accurate.
-        entities = [].concat(entities).filter(function (x) { return !(x instanceof Cesium3DTileFeature); });
-        if (!entities.length) {
-            return;
-        }
-        var _a = [Rectangle, Cartographic, Cartesian3, Matrix3, Matrix4, EasingFunction], C3 = _a[2], M4 = _a[4];
-        var cutoffDistance = 2000;
-        var hoverHeight = 2000;
-        var duration = 0.5;
-        var centers = function (p) {
-            var PM = p.modelMatrix;
-            var instances = (function (i) { return (i instanceof GeometryInstance ? [i] : i); })(p.geometryInstances);
-            return instances.map(function (g) {
-                var _M = M4.multiply(PM, g.modelMatrix, new M4);
-                var G = g.geometry;
-                var _p = G.attributes.position;
-                var b = G.boundingSphere;
-                return [b.center, b.radius];
-            });
-        };
-        var currentTime = JulianDate.now();
-        var target = entities.flatMap(function (e) {
-            var _a;
-            if (e instanceof Cartesian3) {
-                return [[e, 0]];
-            }
-            if (e instanceof Entity) {
-                return [[(_a = e.position) === null || _a === void 0 ? void 0 : _a.getValue(currentTime), 0]];
-            }
-            if (e instanceof Primitive) {
-                return centers(e);
-            }
-            if (e instanceof Cesium3DTileFeature) {
-                var s = e.tileset.boundingSphere;
-                return [[s.center, s.radius]];
-            }
-        });
-        var bounds = function (list) {
-            var min = list[0][0];
-            var max = min;
-            for (var _i = 0, list_1 = list; _i < list_1.length; _i++) {
-                var _a = list_1[_i], p_1 = _a[0], r = _a[1];
-                var pMin = C3.subtract(p_1, new C3(r), new C3);
-                var pMax = C3.add(p_1, new C3(r), new C3);
-                min = C3.minimumByComponent(pMin, min, new C3);
-                max = C3.maximumByComponent(pMax, max, new C3);
-            }
-            var c = C3.multiplyByScalar(C3.add(max, min, new C3), 0.5, new C3);
-            return c;
-        };
-        var center = bounds(target);
-        var orient = function (p) {
-            var d = C3.subtract(center, p, new C3);
-            var dir = C3.normalize(d, new C3);
-            var up = viewer.scene.globe.ellipsoid.geodeticSurfaceNormal(center);
-            return [p, dir, up];
-        };
-        var shorten = function (v, l) {
-            var c = l / C3.magnitude(v);
-            return C3.multiplyByScalar(v, c, new C3);
-        };
-        var camera = viewer.camera;
-        var _b = orient(camera.position), p = _b[0], direction = _b[1], up = _b[2];
-        var orientation = { direction: direction, up: up };
-        camera.flyTo({
-            destination: p,
-            orientation: orientation,
-            duration: duration,
-            complete: function () {
-                if (C3.distance(p, center) > cutoffDistance) {
-                    var d = C3.subtract(p, center, new C3);
-                    d = shorten(d, cutoffDistance);
-                    var h = C3.multiplyByScalar(C3.normalize(up, new C3), hoverHeight, new C3);
-                    d = C3.add(d, h, new C3);
-                    d = shorten(d, cutoffDistance);
-                    d = C3.add(d, center, new C3);
-                    var _a = orient(d), direction_1 = _a[1], u = _a[2];
-                    camera.flyTo({
-                        destination: d,
-                        orientation: { direction: direction_1, up: u }
-                    });
+        return __awaiter(this, void 0, void 0, function () {
+            var viewer, entities, _a, R, CT, C3, M3, M4, E, duration, centers, currentTime, target, bounds, center, orient, camera, _b, p, direction, up, orientation, terrData, MIN_HEIGHT, carto;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        viewer = params.viewer, entities = params.entities;
+                        // Removing cesium tileset features for now as it's not accurate.
+                        entities = [].concat(entities).filter(function (x) { return !(x instanceof Cesium3DTileFeature); });
+                        if (!entities.length) {
+                            return [2 /*return*/];
+                        }
+                        _a = [Rectangle, Cartographic, Cartesian3, Matrix3, Matrix4, EasingFunction], R = _a[0], CT = _a[1], C3 = _a[2], M3 = _a[3], M4 = _a[4], E = _a[5];
+                        duration = 0.5;
+                        centers = function (p) {
+                            var PM = p.modelMatrix;
+                            var instances = (function (i) { return (i instanceof GeometryInstance ? [i] : i); })(p.geometryInstances);
+                            return instances.map(function (g) {
+                                var _M = M4.multiply(PM, g.modelMatrix, new M4);
+                                var G = g.geometry;
+                                var _p = G.attributes.position;
+                                var b = G.boundingSphere;
+                                return [b.center, b.radius];
+                            });
+                        };
+                        currentTime = JulianDate.now();
+                        target = entities.flatMap(function (e) {
+                            var _a;
+                            if (e instanceof Cartesian3) {
+                                return [[e, 0]];
+                            }
+                            if (e instanceof Entity) {
+                                return [[(_a = e.position) === null || _a === void 0 ? void 0 : _a.getValue(currentTime), 0]];
+                            }
+                            if (e instanceof Primitive) {
+                                return centers(e);
+                            }
+                            if (e instanceof Cesium3DTileFeature) {
+                                var s = e.tileset.boundingSphere;
+                                return [[s.center, s.radius]];
+                            }
+                        });
+                        bounds = function (list) {
+                            var min = list[0][0];
+                            var max = min;
+                            for (var _i = 0, list_1 = list; _i < list_1.length; _i++) {
+                                var _a = list_1[_i], p_1 = _a[0], r = _a[1];
+                                var pMin = C3.subtract(p_1, new C3(r), new C3);
+                                var pMax = C3.add(p_1, new C3(r), new C3);
+                                min = C3.minimumByComponent(pMin, min, new C3);
+                                max = C3.maximumByComponent(pMax, max, new C3);
+                            }
+                            var c = C3.multiplyByScalar(C3.add(max, min, new C3), 0.5, new C3);
+                            return c;
+                        };
+                        center = bounds(target);
+                        orient = function (p) {
+                            var d = C3.subtract(center, p, new C3);
+                            var dir = C3.normalize(d, new C3);
+                            var up = viewer.scene.globe.ellipsoid.geodeticSurfaceNormal(center);
+                            return [p, dir, up];
+                        };
+                        camera = viewer.camera;
+                        _b = orient(camera.position), p = _b[0], direction = _b[1], up = _b[2];
+                        orientation = { direction: direction, up: up };
+                        if (!(p === null || p === void 0 ? void 0 : p.x)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, DrawingUtils.GetTerrainHeight({
+                                pos3d: p,
+                                viewer: viewer
+                            })];
+                    case 1:
+                        terrData = _c.sent();
+                        MIN_HEIGHT = terrData.height + 300;
+                        carto = Cartographic.fromCartesian(p);
+                        if (carto.height < MIN_HEIGHT) {
+                            carto.height = MIN_HEIGHT;
+                            p = Cartesian3.fromRadians(carto.longitude, carto.latitude, carto.height);
+                        }
+                        camera.flyTo({
+                            destination: p,
+                            orientation: orientation,
+                            duration: duration,
+                            complete: function () {
+                                // if (C3.distance(p, center) > cutoffDistance) {
+                                //     let d = C3.subtract(p, center, new C3);
+                                //     d = shorten(d, cutoffDistance);
+                                //     const h = C3.multiplyByScalar(C3.normalize(up, new C3), hoverHeight, new C3);
+                                //     d = C3.add(d, h, new C3);
+                                //     d = shorten(d, cutoffDistance);
+                                //     d = C3.add(d, center, new C3);
+                                //     const [ _p, direction, u ] = orient(d);
+                                //     camera.flyTo({
+                                //         destination: d,
+                                //         orientation: { direction, up: u }
+                                //     });
+                                // }
+                            }
+                        });
+                        _c.label = 2;
+                    case 2: return [2 /*return*/];
                 }
-            }
+            });
         });
     }
     EntityUtils.LookAtEntities = LookAtEntities;
@@ -4260,24 +4997,278 @@ var EntityLabel;
             }
             return;
         }
-        (_c = (_b = rego[EntityLabel.ATTACH_KEY]).Dispose) === null || _c === void 0 ? void 0 : _c.call(_b);
-        rego[EntityLabel.ATTACH_KEY] = null;
-    }
-    EntityLabel.Detatch = Detatch;
+        (_c = (_b = rego[EntityLabel.ATTACH_KEY]).Dispose) === null || _c === void 0 ? void 0 : _c.call(_b);
+        rego[EntityLabel.ATTACH_KEY] = null;
+    }
+    EntityLabel.Detatch = Detatch;
+    /**
+     * Returns label instance from given rego if one exists.
+     * @param params
+     * @returns
+     */
+    function GetLabel(params) {
+        var rego = params.rego;
+        if (!rego) {
+            return null;
+        }
+        return rego[EntityLabel.ATTACH_KEY];
+    }
+    EntityLabel.GetLabel = GetLabel;
+})(EntityLabel || (EntityLabel = {}));
+
+// Area in m^2 for 3D model visibility check.
+var MODEL_SIZE_TOLERANCE = 1000;
+function getValue$2(viewer, obj) {
+    if (obj === null || obj === void 0 ? void 0 : obj.getValue) {
+        return obj.getValue(viewer.scene.lastRenderTime);
+    }
+    return obj;
+}
+var boundingSphereCache = {};
+function getPositionsFromEntity(viewer, entity) {
+    if (entity.billboard) {
+        var pos3d = getValue$2(viewer, entity.position);
+        if (!(pos3d === null || pos3d === void 0 ? void 0 : pos3d.x)) {
+            return null;
+        }
+        return [pos3d];
+    }
+    else if (entity.polyline) {
+        return getValue$2(viewer, entity.polyline.positions);
+    }
+    else if (entity.polygon) {
+        var hierarchy = getValue$2(viewer, entity.polygon.hierarchy);
+        return hierarchy.positions;
+    }
+    else if (entity.corridor) {
+        return getValue$2(viewer, entity.corridor.positions);
+    }
+    else if (entity.ellipse) {
+        var position = getValue$2(viewer, entity.position);
+        if (!(position === null || position === void 0 ? void 0 : position.x)) {
+            return null;
+        }
+        var semiMajorAxis = getValue$2(viewer, entity.ellipse.semiMajorAxis);
+        var semiMinorAxis = getValue$2(viewer, entity.ellipse.semiMinorAxis);
+        var rotation = getValue$2(viewer, entity.ellipse.rotation);
+        // More subdivisions means a more accurate ellipse but worse performance.
+        var numberOfSubdivisions = 100;
+        var positions = [];
+        for (var i = 0; i < numberOfSubdivisions; i++) {
+            var theta = i * (2 * Math.PI / numberOfSubdivisions);
+            var x = semiMajorAxis * Math.cos(theta);
+            var y = semiMinorAxis * Math.sin(theta);
+            // Apply rotation.
+            var rotatedX = x * Math.cos(rotation) - y * Math.sin(rotation);
+            var rotatedY = x * Math.sin(rotation) + y * Math.cos(rotation);
+            // Translate by the ellipse's position.
+            var point = new Cartesian3(position.x + rotatedX, position.y + rotatedY, position.z);
+            positions.push(point);
+        }
+        return positions;
+    }
+    else if (entity.model) {
+        var pos3d = getValue$2(viewer, entity.position);
+        if (!(pos3d === null || pos3d === void 0 ? void 0 : pos3d.x)) {
+            return null;
+        }
+        return [pos3d];
+    }
+    else if (entity.point) {
+        var pos3d = getValue$2(viewer, entity.position);
+        if (!(pos3d === null || pos3d === void 0 ? void 0 : pos3d.x)) {
+            return null;
+        }
+        return [pos3d];
+    }
+    return null;
+}
+function computeBoundingSphereFromPositions(positions) {
+    return BoundingSphere.fromPoints(positions);
+}
+function shouldCullEntity(viewer, cEntity) {
+    var camera = viewer.scene.camera;
+    var boundingSphere;
+    if (boundingSphereCache[cEntity.id]) {
+        boundingSphere = boundingSphereCache[cEntity.id];
+    }
+    else {
+        var positions = getPositionsFromEntity(viewer, cEntity);
+        if (positions) {
+            boundingSphere = computeBoundingSphereFromPositions(positions);
+            if (cEntity.model) {
+                // Expand the bounding sphere for models due to our tolerance
+                boundingSphere.radius += Math.sqrt(MODEL_SIZE_TOLERANCE);
+            }
+            boundingSphereCache[cEntity.id] = boundingSphere;
+        }
+    }
+    if (!boundingSphere) {
+        return false;
+    }
+    var cullingVolume = camera.frustum.computeCullingVolume(camera.position, camera.direction, camera.up);
+    var visibility = cullingVolume.computeVisibility(boundingSphere);
+    return visibility !== Intersect.INSIDE && visibility !== Intersect.INTERSECTING;
+}
+var CHECK_BATCH = 500;
+var LAST_RECHECK_KEY = Symbol("LAST_RECHECK_KEY");
+var checkInterval = null;
+var checkWaiting = false;
+/**
+ * We will recheck if the camera has turned or moved enough.
+ * @param viewer
+ * @returns
+ */
+function shouldRecheck(viewer) {
+    var camera = viewer.scene.camera;
+    var lastRecheck = camera[LAST_RECHECK_KEY];
+    if (!lastRecheck) {
+        camera[LAST_RECHECK_KEY] = {
+            position: camera.position.clone(),
+            direction: camera.direction.clone(),
+        };
+        return true;
+    }
+    var _a = lastRecheck, position = _a.position, direction = _a.direction;
+    var posDiff = Cartesian3.magnitude(Cartesian3.subtract(position, camera.position, new Cartesian3()));
+    var dirDiff = Cartesian3.magnitude(Cartesian3.subtract(direction, camera.direction, new Cartesian3()));
+    var recheck = posDiff > 100 || dirDiff > 0.01;
+    if (recheck) {
+        camera[LAST_RECHECK_KEY] = {
+            position: camera.position.clone(),
+            direction: camera.direction.clone(),
+        };
+    }
+    return recheck;
+}
+/**
+ * Runs through all entities in the register and culls them if they are out of the viewport.
+ * This will work in batches.
+ * @param register
+ */
+function runCullChecker(register) {
+    if (checkInterval != null) {
+        checkWaiting = true;
+        return;
+    }
+    var viewer = register.Viewer;
+    var entityIds = register.GetEntityIds();
+    checkInterval = setInterval(function () {
+        if (viewer.isDestroyed() || !viewer.scene) {
+            clearInterval(checkInterval);
+            checkInterval = null;
+            return;
+        }
+        var slice = entityIds.splice(0, CHECK_BATCH);
+        for (var i = 0; i < slice.length; i++) {
+            var entityId = slice[i];
+            var rego = register.GetRego({
+                entityId: entityId
+            });
+            if (!rego || !rego.visual || !(rego.visual instanceof Entity)) {
+                continue;
+            }
+            var parts = EntityUtils.GatherEntity({
+                entity: rego.visual
+            });
+            for (var i_1 = 0; i_1 < parts.length; i_1++) {
+                var part = parts[i_1];
+                var shouldCull = shouldCullEntity(viewer, part);
+                if (shouldCull) {
+                    part[VisualRegisterCuller.VISUAL_CULL_KEY] = true;
+                    if (viewer.entities.contains(part)) {
+                        viewer.entities.remove(part);
+                    }
+                }
+                else {
+                    delete part[VisualRegisterCuller.VISUAL_CULL_KEY];
+                    if (!rego.suppressShow && rego.best && !viewer.entities.contains(part)) {
+                        viewer.entities.add(part);
+                    }
+                }
+            }
+        }
+        if (entityIds.length <= 0) {
+            clearInterval(checkInterval);
+            checkInterval = null;
+            if (checkWaiting) {
+                checkWaiting = false;
+                runCullChecker(register);
+            }
+        }
+    }, 200);
+}
+var VisualRegisterCuller;
+(function (VisualRegisterCuller) {
+    VisualRegisterCuller.VISUAL_CULL_KEY = Symbol("VISUAL_CULL_KEY");
     /**
-     * Returns label instance from given rego if one exists.
+     * Will monitor the visuals within a visual register and cull ones that are out of the viewport.
      * @param params
-     * @returns
+     * @returns a dispose function.
      */
-    function GetLabel(params) {
-        var rego = params.rego;
-        if (!rego) {
-            return null;
+    function Monitor(params) {
+        var _a;
+        var register = params.register;
+        if (!((_a = register === null || register === void 0 ? void 0 : register.Viewer) === null || _a === void 0 ? void 0 : _a.scene) || register.Viewer.isDestroyed()) {
+            console.warn("Cannot monitor a visual register that is not attached to a viewer.");
+            return function () { };
+        }
+        var lastCullCheck = null;
+        var checkQueue = new DelayQueue(function () {
+            if (register.Viewer == null || register.Viewer.isDestroyed() || !shouldRecheck(register.Viewer)) {
+                return;
+            }
+            runCullChecker(register);
+            lastCullCheck = new Date();
+        }, 1000);
+        var moveStartRemoval = register.Viewer.camera.moveStart.addEventListener(function () {
+            var _a;
+            (_a = checkQueue.Call) === null || _a === void 0 ? void 0 : _a.call(checkQueue);
+        });
+        var moveEndRemoval = register.Viewer.camera.moveEnd.addEventListener(function () {
+            var _a;
+            (_a = checkQueue.Call) === null || _a === void 0 ? void 0 : _a.call(checkQueue);
+        });
+        var RENDER_SECS_PASSED = 5;
+        var updateRemoval = register.Viewer.scene.postRender.addEventListener(function () {
+            var _a;
+            var now = new Date();
+            if (lastCullCheck == null || (now.getTime() - lastCullCheck.getTime()) > RENDER_SECS_PASSED * 1000) {
+                (_a = checkQueue.Call) === null || _a === void 0 ? void 0 : _a.call(checkQueue);
+            }
+        });
+        checkQueue.Call();
+        return function (params) {
+            var uncull = (params || {}).uncull;
+            moveStartRemoval === null || moveStartRemoval === void 0 ? void 0 : moveStartRemoval();
+            moveStartRemoval = null;
+            moveEndRemoval === null || moveEndRemoval === void 0 ? void 0 : moveEndRemoval();
+            moveEndRemoval = null;
+            updateRemoval === null || updateRemoval === void 0 ? void 0 : updateRemoval();
+            updateRemoval = null;
+            checkInterval === null || checkInterval === void 0 ? void 0 : checkInterval();
+            checkInterval = null;
+            checkWaiting = false;
+            checkQueue === null || checkQueue === void 0 ? void 0 : checkQueue.Dispose();
+            checkQueue = null;
+        };
+    }
+    VisualRegisterCuller.Monitor = Monitor;
+    function IsCulled(viewer, visual) {
+        if (!visual) {
+            return false;
         }
-        return rego[EntityLabel.ATTACH_KEY];
+        if (visual instanceof Entity) {
+            var status_1 = visual[VisualRegisterCuller.VISUAL_CULL_KEY];
+            if (status_1 == null) {
+                status_1 = visual[VisualRegisterCuller.VISUAL_CULL_KEY] = shouldCullEntity(viewer, visual);
+            }
+            return status_1;
+        }
+        return false;
     }
-    EntityLabel.GetLabel = GetLabel;
-})(EntityLabel || (EntityLabel = {}));
+    VisualRegisterCuller.IsCulled = IsCulled;
+})(VisualRegisterCuller || (VisualRegisterCuller = {}));
 
 /**
  * Returns if a given visual is alive and in the scene.
@@ -4333,6 +5324,13 @@ function removeEntity(viewer, visual) {
     }
 }
 function updateCEntityShow(viewer, visual, show, ignoreParent) {
+    if (show) {
+        // Culling is controlled by "visual-register-culler.ts".
+        // When an object is unculled then the 'updateEntityShow' function is re-called to reveal it and related objects.
+        // A sub-object can be culled while the siblings are not.
+        var isCulled = show ? VisualRegisterCuller.IsCulled(viewer, visual) : true;
+        show = !isCulled;
+    }
     if (visual._parentEntity && !ignoreParent) {
         updateCEntityShow(viewer, visual._parentEntity, show, false);
     }
@@ -4619,6 +5617,9 @@ var VisualsRegister;
             this.labelledEntityIds = [];
             this.viewer = params.viewer;
             this.apiGetters = params.apiGetters;
+            this.cameraCullerDispose = VisualRegisterCuller.Monitor({
+                register: this
+            });
         }
         Object.defineProperty(Register.prototype, "Id", {
             get: function () {
@@ -4651,6 +5652,13 @@ var VisualsRegister;
             enumerable: false,
             configurable: true
         });
+        Register.prototype.Dispose = function () {
+            var _a;
+            (_a = this.cameraCullerDispose) === null || _a === void 0 ? void 0 : _a.call(this, {
+                uncull: false
+            });
+            this.cameraCullerDispose = null;
+        };
         Register.prototype.ForceUpdate = function (params) {
             var entityIds = params.entityIds;
             for (var i = 0; i < entityIds.length; i++) {
@@ -10754,6 +11762,27 @@ var MenuItemManager;
             enumerable: false,
             configurable: true
         });
+        /**
+         * Disposes the menu item manager.
+         * This will dispose all render managers and unregister all menu items.
+         */
+        Manager.prototype.Dispose = function (params) {
+            var _a;
+            var disposeRegister = (params !== null && params !== void 0 ? params : {}).disposeRegister;
+            for (var i = 0; i < this.items.length; i++) {
+                var item = this.items[i];
+                try {
+                    (_a = item.renderManager) === null || _a === void 0 ? void 0 : _a.Dispose();
+                }
+                catch (e) {
+                    console.error(e);
+                }
+            }
+            this.items = [];
+            if (this.visualsRegister && disposeRegister != false) {
+                this.visualsRegister.Dispose();
+            }
+        };
         /**
          * Renders a given menu item and all its children.
          * Will return the enabled item id.
@@ -12779,213 +13808,6 @@ var TileRenderEngine;
     })(Terrain = TileRenderEngine.Terrain || (TileRenderEngine.Terrain = {}));
 })(TileRenderEngine || (TileRenderEngine = {}));
 
-var CESIUM_INSPECTOR_KEY = "_nextspace_inspector";
-var ViewUtils;
-(function (ViewUtils) {
-    function GatherLegacyMapTiles(params) {
-        var viewer = params.viewer;
-        var collection = viewer.imageryLayers;
-        var tiles = [];
-        for (var i = 0; i < collection.length; i++) {
-            var layer = collection.get(i);
-            if (layer._bName) {
-                tiles.push({
-                    alpha: layer.alpha,
-                    brightness: layer.brightness,
-                    contrast: layer.contrast,
-                    hue: layer.hue,
-                    saturation: layer.saturation,
-                    gamma: layer.gamma,
-                    title: layer._bName,
-                });
-            }
-        }
-        return {
-            imagery: tiles.reverse()
-        };
-    }
-    ViewUtils.GatherLegacyMapTiles = GatherLegacyMapTiles;
-    function GatherLegacyTerrainTile(params) {
-        var viewer = params.viewer;
-        var enabled = viewer.terrainProvider;
-        if (enabled === null || enabled === void 0 ? void 0 : enabled._bName) {
-            return {
-                terrain: enabled._bName
-            };
-        }
-        return {
-            terrain: "flatterrain"
-        };
-    }
-    ViewUtils.GatherLegacyTerrainTile = GatherLegacyTerrainTile;
-    function GatherMapTiles(params) {
-        var viewer = params.viewer;
-        var imagery = viewer.imageryLayers;
-        var tiles = [];
-        var _loop_1 = function (i) {
-            var provider = imagery.get(i);
-            if (provider._bMeta) {
-                var idCombo_1 = provider._bMeta.accountId + provider._bMeta.tilesetId;
-                if (!tiles.find(function (x) { return x.accountId + x.tilesetId === idCombo_1; })) {
-                    tiles.push({
-                        accountId: provider._bMeta.accountId,
-                        tilesetId: provider._bMeta.tilesetId,
-                        alpha: provider.alpha,
-                        brightness: provider.brightness,
-                        contrast: provider.contrast,
-                        hue: provider.hue,
-                        saturation: provider.saturation,
-                        gamma: provider.gamma
-                    });
-                }
-            }
-        };
-        for (var i = 0; i < imagery.length; i++) {
-            _loop_1(i);
-        }
-        return {
-            imagery: tiles
-        };
-    }
-    ViewUtils.GatherMapTiles = GatherMapTiles;
-    function GatherTerrainTile(params) {
-        var viewer = params.viewer;
-        var provider = viewer.terrainProvider;
-        if (provider._bMeta) {
-            return {
-                terrain: {
-                    accountId: provider._bMeta.accountId,
-                    tilesetId: provider._bMeta.tilesetId,
-                }
-            };
-        }
-        else if (provider instanceof EllipsoidTerrainProvider) {
-            return {
-                terrain: {
-                    tilesetId: ProjectViewTile.EDefaultTerrain.FlatTerrain,
-                    accountId: null
-                }
-            };
-        }
-        return null;
-    }
-    ViewUtils.GatherTerrainTile = GatherTerrainTile;
-    function SetTerrainWireframeStatus(params) {
-        if (!params.viewer[CESIUM_INSPECTOR_KEY]) {
-            var InspectorClass = CesiumInspector;
-            if (InspectorClass) {
-                var inspector = new InspectorClass(document.createElement("div"), params.viewer.scene);
-                inspector.container.style.display = "none";
-                params.viewer[CESIUM_INSPECTOR_KEY] = inspector;
-                params.viewer.scene.requestRender();
-            }
-        }
-        if (params.viewer[CESIUM_INSPECTOR_KEY]) {
-            params.viewer[CESIUM_INSPECTOR_KEY].viewModel.wireframe = params.status;
-        }
-    }
-    ViewUtils.SetTerrainWireframeStatus = SetTerrainWireframeStatus;
-    function GetTerrainWireframeStatus(params) {
-        var _a, _b;
-        if (!params.viewer[CESIUM_INSPECTOR_KEY]) {
-            return false;
-        }
-        return (_b = (_a = params.viewer[CESIUM_INSPECTOR_KEY]) === null || _a === void 0 ? void 0 : _a.viewModel) === null || _b === void 0 ? void 0 : _b.wireframe;
-    }
-    ViewUtils.GetTerrainWireframeStatus = GetTerrainWireframeStatus;
-    /**
-     * Changes between perspective and orthographic view.
-     * When Cesium stops being bad at picking positions in 2d mode we'll use the flat earth mode instead.
-     * @param params
-     */
-    function Set2dStatus(params) {
-        var viewer = params.viewer, is2d = params.status, moveCamera = params.moveCamera;
-        var curLens2d = viewer.camera.frustum instanceof OrthographicFrustum;
-        if (curLens2d && !is2d) {
-            viewer.camera.switchToPerspectiveFrustum();
-            viewer.scene.screenSpaceCameraController.enableTilt = true;
-            viewer.scene.requestRender();
-        }
-        else if (!curLens2d && is2d) {
-            viewer.camera.switchToOrthographicFrustum();
-            viewer.scene.screenSpaceCameraController.enableTilt = false;
-            if (moveCamera != false) {
-                try {
-                    // Face camera downwards to make it look 2d.
-                    // We want to try make it look at the center-point of the current view.
-                    // If center cannot be calculated then we'll simply raise the camera and face it downwards.
-                    var scene = viewer.scene;
-                    var windowPosition = new Cartesian2(scene.canvas.clientWidth / 2, scene.canvas.clientHeight / 2);
-                    var ray = viewer.camera.getPickRay(windowPosition);
-                    var intersection = scene.globe.pick(ray, scene);
-                    var center = void 0;
-                    if (defined(intersection)) {
-                        center = Cartographic.fromCartesian(intersection);
-                    }
-                    // Use current camera position if we can't calculate the center.
-                    else {
-                        center = Cartographic.fromCartesian(viewer.camera.position);
-                        center.height = 0;
-                    }
-                    center.height = viewer.camera.positionCartographic.height + 100;
-                    viewer.camera.setView({
-                        destination: Cartographic.toCartesian(center),
-                        orientation: {
-                            heading: 0.0,
-                            pitch: Math$1.toRadians(-90.0),
-                            roll: 0.0
-                        }
-                    });
-                }
-                catch (e) {
-                    console.error(e);
-                }
-            }
-            viewer.scene.requestRender();
-        }
-    }
-    ViewUtils.Set2dStatus = Set2dStatus;
-    function Get2dStatus(params) {
-        var viewer = params.viewer;
-        return viewer.camera.frustum instanceof OrthographicFrustum;
-    }
-    ViewUtils.Get2dStatus = Get2dStatus;
-    function SetLockedCameraStatus(params) {
-        var viewer = params.viewer, status = params.status;
-        var scene = viewer === null || viewer === void 0 ? void 0 : viewer.scene;
-        if (!scene) {
-            return;
-        }
-        if (status) {
-            scene.screenSpaceCameraController.enableInputs = false;
-            scene.screenSpaceCameraController.enableTranslate = false;
-            scene.screenSpaceCameraController.enableZoom = false;
-            scene.screenSpaceCameraController.enableRotate = false;
-            scene.screenSpaceCameraController.enableTilt = false;
-        }
-        else {
-            scene.screenSpaceCameraController.enableInputs = true;
-            scene.screenSpaceCameraController.enableTranslate = true;
-            scene.screenSpaceCameraController.enableZoom = true;
-            scene.screenSpaceCameraController.enableRotate = true;
-            if (!ViewUtils.Get2dStatus({ viewer: viewer })) {
-                scene.screenSpaceCameraController.enableTilt = true;
-            }
-        }
-        viewer.scene.requestRender();
-    }
-    ViewUtils.SetLockedCameraStatus = SetLockedCameraStatus;
-    function GetLockedCameraStatus(params) {
-        var _a;
-        var scene = (_a = params.viewer) === null || _a === void 0 ? void 0 : _a.scene;
-        if (!scene) {
-            return false;
-        }
-        return !scene.screenSpaceCameraController.enableTranslate;
-    }
-    ViewUtils.GetLockedCameraStatus = GetLockedCameraStatus;
-})(ViewUtils || (ViewUtils = {}));
-
 var VIEWER_BOOKMARKS_WIDGET_KEY = "_viewerBookmarksWidget";
 var WidgetBookmarks = /** @class */ (function (_super) {
     __extends(WidgetBookmarks, _super);
@@ -16739,7 +17561,7 @@ var ViewerUtils;
     ViewerUtils.CreateWidgets = CreateWidgets;
 })(ViewerUtils || (ViewerUtils = {}));
 
-var VERSION$1 = "2.9.5";
+var VERSION$1 = "2.9.7";
 
 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 };
 //# sourceMappingURL=bruce-cesium.es5.js.map