bruce-cesium 0.0.1

package/dist/bruce-cesium.es5.js

@@ -0,0 +1,2766 @@
+import { BruceEvent, Cartes, Carto, Geometry, ZoomControl, Style, EntityTag, Calculator, EntityLod, EntityType, ClientFile, DelayQueue, Entity as Entity$1, EntityFilterGetter, BatchedDataGetter, Tileset, MenuItem, ObjectUtils } from 'bruce-models';
+import { Cartesian2, Cartographic, Math as Math$1, Color, HeightReference, Cartesian3, Entity, ClassificationType, ArcType, PolygonHierarchy, ShadowMode, PolylineGraphics, HeadingPitchRoll, Transforms, ColorBlendMode, Primitive, Cesium3DTileFeature, Viewer, ArcGisMapServerImageryProvider, ScreenSpaceEventType, HeadingPitchRange, Matrix4, Cesium3DTileset, EllipsoidGeodesic } from 'cesium';
+
+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 = {}));
+function netScanViewForBoundaries(viewer) {
+    var maxLong = -2 * Math.PI;
+    var minLong = 2 * Math.PI;
+    var maxLat = -2 * Math.PI;
+    var minLat = 2 * Math.PI;
+    var found = 0;
+    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);
+                maxLong = Math.max(maxLong, point.longitude);
+                maxLat = Math.max(maxLat, point.latitude);
+                minLong = Math.min(minLong, point.longitude);
+                minLat = Math.min(minLat, point.latitude);
+                found++;
+            }
+        }
+        catch (_a) {
+        }
+    };
+    // 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 (found > 0) {
+        var viewRect = {
+            east: maxLong,
+            west: minLong,
+            north: maxLat,
+            south: minLat
+        };
+        return viewRect;
+    }
+    return null;
+}
+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;
+}
+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 = /** @class */ (function () {
+    function CesiumViewMonitor(viewer) {
+        var _this = this;
+        this.target = null;
+        this.bounds = null;
+        this.disposed = false;
+        this.updatedEvent = null;
+        this.viewer = viewer;
+        this.checkInterval = setInterval(function () {
+            _this.updateQueue();
+        }, POSITION_CHECK_TIMER);
+    }
+    Object.defineProperty(CesiumViewMonitor.prototype, "Disposed", {
+        get: function () {
+            return this.disposed;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    CesiumViewMonitor.prototype.Updated = function () {
+        if (!this.updatedEvent) {
+            this.updatedEvent = new BruceEvent();
+        }
+        return this.updatedEvent;
+    };
+    CesiumViewMonitor.prototype.GetBounds = function () {
+        return this.bounds;
+    };
+    CesiumViewMonitor.prototype.GetTarget = function () {
+        return this.target;
+    };
+    CesiumViewMonitor.prototype.DoUpdate = function () {
+        this.tryEmitUpdate();
+    };
+    CesiumViewMonitor.prototype.Dispose = function () {
+        if (this.disposed) {
+            return;
+        }
+        this.disposed = true;
+        clearInterval(this.checkInterval);
+    };
+    CesiumViewMonitor.prototype.tryDoUpdate = function () {
+        var viewRect = null;
+        var center = null;
+        var camera = this.viewer.camera;
+        var terrainHeight = this.viewer.scene.globe.getHeight(camera.positionCartographic);
+        var cameraPosition = this.viewer.camera.positionCartographic;
+        // We are almost at the ground, screw horizon, just load around.
+        if (terrainHeight && ((cameraPosition.height - terrainHeight) < DEFAULT_GROUNDED_HEIGHT)) {
+            // View area calculation.
+            viewRect = {};
+            var viewRectRad = netScanViewForBoundaries(this.viewer);
+            if (viewRectRad &&
+                viewRectRad.east &&
+                viewRectRad.west &&
+                viewRectRad.north &&
+                viewRectRad.south) {
+                viewRect.east = 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 {
+            // View area calculation.
+            var windowPosition = new Cartesian2(this.viewer.container.clientWidth / 2, this.viewer.container.clientHeight / 2);
+            var intersection = getAdjustedGroundIntersectionOfCameraRay(this.viewer, windowPosition);
+            var 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);
+                var viewRectRad = netScanViewForBoundaries(this.viewer);
+                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) {
+            var centerLong = (viewRect.east + viewRect.west) / 2;
+            var centerLat = (viewRect.north + viewRect.south) / 2;
+            viewRect.east = Math.max(viewRect.east, centerLong + (MINIMUM_VIEW_AREA_SIZE_DEGREES / 2));
+            viewRect.west = Math.min(viewRect.west, centerLong - (MINIMUM_VIEW_AREA_SIZE_DEGREES / 2));
+            viewRect.south = Math.min(viewRect.south, centerLat - (MINIMUM_VIEW_AREA_SIZE_DEGREES / 2));
+            viewRect.north = Math.max(viewRect.north, centerLat + (MINIMUM_VIEW_AREA_SIZE_DEGREES / 2));
+        }
+        if (center && viewRect) {
+            if ((!this.target || (this.target && !arePosEqual(this.target, center))) ||
+                (!this.bounds || (this.bounds && !areBoundsEqual(this.bounds, viewRect)))) {
+                this.target = center;
+                this.bounds = viewRect;
+                return ESearchStatus.LocationChanged;
+            }
+            return ESearchStatus.LocationFound;
+        }
+        return ESearchStatus.LocationMissing;
+    };
+    CesiumViewMonitor.prototype.tryEmitUpdate = function () {
+        var _a;
+        var searchResult = this.tryDoUpdate();
+        if (searchResult == ESearchStatus.LocationChanged) {
+            var interest = {
+                bounds: this.bounds,
+                target: this.target
+            };
+            (_a = this.updatedEvent) === null || _a === void 0 ? void 0 : _a.Trigger(interest);
+        }
+        else if (searchResult == ESearchStatus.LocationMissing) {
+            this.updateQueue();
+        }
+    };
+    CesiumViewMonitor.prototype.queuePosition = function (lag) {
+        var _this = this;
+        if (this.pendingTimeout) {
+            clearTimeout(this.pendingTimeout);
+        }
+        this.pendingTimeout = setTimeout(function () {
+            if (!_this.disposed) {
+                _this.tryEmitUpdate();
+            }
+        }, lag);
+    };
+    CesiumViewMonitor.prototype.updateQueue = function () {
+        this.queuePosition(TIME_LAG);
+    };
+    return CesiumViewMonitor;
+}());
+
+var ViewerUtils;
+(function (ViewerUtils) {
+    function InitViewer(container) {
+        if (container._cViewer) {
+            throw new Error("Container already has a viewer.");
+        }
+        var cViewer = new Viewer(container, {
+            imageryProvider: new ArcGisMapServerImageryProvider({
+                url: "https://services.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer",
+                enablePickFeatures: false
+            })
+        });
+        cViewer.cesiumWidget.screenSpaceEventHandler.removeInputAction(ScreenSpaceEventType.LEFT_DOUBLE_CLICK);
+        cViewer.camera.percentageChanged = 0.05;
+        ViewerUtils.DestroyWidget(cViewer.timeline);
+        ViewerUtils.DestroyWidget(cViewer.vrButton);
+        ViewerUtils.DestroyWidget(cViewer.sceneModePicker);
+        ViewerUtils.DestroyWidget(cViewer.homeButton);
+        ViewerUtils.DestroyWidget(cViewer.fullscreenButton);
+        ViewerUtils.DestroyWidget(cViewer.baseLayerPicker);
+        ViewerUtils.StyleContainer(cViewer);
+        container._cViewer = cViewer;
+        return cViewer;
+    }
+    ViewerUtils.InitViewer = InitViewer;
+    function GetViewerFromContainer(container) {
+        return container._cViewer;
+    }
+    ViewerUtils.GetViewerFromContainer = GetViewerFromContainer;
+    function DestroyWidget(widget) {
+        if (widget && !widget.isDestroyed()) {
+            widget.destroy();
+        }
+    }
+    ViewerUtils.DestroyWidget = DestroyWidget;
+    function StyleContainer(viewer) {
+        var _a;
+        var container = viewer.container;
+        var genContainer = (_a = container.getElementsByClassName("cesium-viewer")) === null || _a === void 0 ? void 0 : _a[0];
+        if (genContainer) {
+            var children = genContainer.children;
+            for (var i = 0; i < children.length; i++) {
+                var child = children[i];
+                if (!child.classList.contains("cesium-viewer-cesiumWidgetContainer")) {
+                    child.style.display = "none";
+                }
+            }
+        }
+        var canvas = viewer.canvas;
+        canvas.style.width = "100%";
+        canvas.style.height = "100%";
+        var widget = canvas.parentElement;
+        widget.style.width = "100%";
+        widget.style.height = "100%";
+        widget.style.touchAction = "none";
+        var widgetContainer = widget.parentElement;
+        widgetContainer.style.width = "100%";
+        widgetContainer.style.height = "100%";
+        var viewerContainer = widgetContainer.parentElement;
+        viewerContainer.style.fontFamily = "sans-serif";
+        viewerContainer.style.fontSize = "16px";
+        viewerContainer.style.overflow = "hidden";
+        viewerContainer.style.display = "block";
+        viewerContainer.style.position = "relative";
+        viewerContainer.style.top = "0";
+        viewerContainer.style.left = "0";
+        viewerContainer.style.width = "100%";
+        viewerContainer.style.height = "100%";
+    }
+    ViewerUtils.StyleContainer = StyleContainer;
+})(ViewerUtils || (ViewerUtils = {}));
+
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License. You may obtain a copy of the
+License at http://www.apache.org/licenses/LICENSE-2.0
+
+THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+MERCHANTABLITY OR NON-INFRINGEMENT.
+
+See the Apache Version 2.0 License for specific language governing permissions
+and limitations under the License.
+***************************************************************************** */
+
+var __assign = function() {
+    __assign = Object.assign || function __assign(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+function __generator(thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+}
+
+var DrawingUtils;
+(function (DrawingUtils) {
+    function PointAcrossPolyline(viewer, positions, distance) {
+        if (positions.length > 1) {
+            var currentDistance = 0;
+            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);
+                    var position = geodesic.interpolateUsingSurfaceDistance(distance - currentDistance);
+                    var height = (carto1.height + carto2.height) / 2;
+                    return Cartesian3.fromRadians(position.longitude, position.latitude, height);
+                }
+                else {
+                    currentDistance += length_1;
+                }
+            }
+        }
+        else if (positions.length > 0) {
+            return positions[0];
+        }
+        else {
+            return null;
+        }
+        return positions[positions.length - 1];
+    }
+    DrawingUtils.PointAcrossPolyline = PointAcrossPolyline;
+})(DrawingUtils || (DrawingUtils = {}));
+
+var MeasureUtils;
+(function (MeasureUtils) {
+    function MeasurePolyline(posses) {
+        if (posses.length < 2) {
+            return 0;
+        }
+        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;
+            }
+        }
+        return totalLength;
+    }
+    MeasureUtils.MeasurePolyline = MeasurePolyline;
+})(MeasureUtils || (MeasureUtils = {}));
+
+var EntityUtils;
+(function (EntityUtils) {
+    function GetPos(viewer, entity) {
+        if (entity.location && Carto.ValidateCarto(entity.location)) {
+            var location_1 = entity.location;
+            return Cartesian3.fromDegrees(location_1.longitude, location_1.latitude, location_1.altitude);
+        }
+        if (entity.geometry && typeof entity.geometry == "object") {
+            var pointStr = entity.geometry.Point;
+            if (pointStr && typeof pointStr == "string") {
+                var points = Geometry.ParsePoints(pointStr);
+                var point = points.length > 0 ? points[0] : null;
+                if (point && Carto.ValidateCarto(point)) {
+                    return Cartesian3.fromDegrees(point.longitude, point.latitude, point.altitude);
+                }
+            }
+            var lineStr = entity.geometry.LineString;
+            if (lineStr && typeof lineStr == "string") {
+                var points = Geometry.ParsePoints(lineStr);
+                if (points.length > 0) {
+                    var posses = points.map(function (x) { return Cartesian3.fromDegrees(x.longitude, x.latitude, x.altitude); });
+                    var length_1 = MeasureUtils.MeasurePolyline(posses);
+                    if (length_1 > 0) {
+                        var point = DrawingUtils.PointAcrossPolyline(viewer, posses, length_1 / 2);
+                        if (point && Cartes.ValidateCartes3(point)) {
+                            return point;
+                        }
+                    }
+                    else {
+                        return posses[0];
+                    }
+                }
+            }
+            var pRings = entity.geometry.Polygon;
+            if (pRings && typeof pRings == "object") {
+                var boundary = pRings.find(function (x) { return x.Facing == Geometry.EPolygonRingType.Boundaries; });
+                if (boundary === null || boundary === void 0 ? void 0 : boundary.LinearRing) {
+                    var points = Geometry.ParsePoints(boundary.LinearRing);
+                    var point = Carto.GetCenter(points);
+                    if (point && Carto.ValidateCarto(point)) {
+                        return Cartesian3.fromDegrees(point.longitude, point.latitude, point.altitude);
+                    }
+                }
+            }
+        }
+        if (entity.boundaries) {
+            var point = {
+                latitude: (entity.boundaries.minLatitude + entity.boundaries.maxLatitude) / 2,
+                longitude: (entity.boundaries.minLongitude + entity.boundaries.maxLongitude) / 2,
+                altitude: 0
+            };
+            if (point && Carto.ValidateCarto(point)) {
+                return Cartesian3.fromDegrees(point.longitude, point.latitude, point.altitude);
+            }
+        }
+        return null;
+    }
+    EntityUtils.GetPos = GetPos;
+})(EntityUtils || (EntityUtils = {}));
+
+var RenderManager;
+(function (RenderManager) {
+    var Utils;
+    (function (Utils) {
+        function DetermineZoomItem(viewer, entity, zoomControl) {
+            var pos = EntityUtils.GetPos(viewer, entity);
+            if (!pos) {
+                return null;
+            }
+            var cameraPos = viewer.camera.position;
+            var distance = Cartesian3.distance(pos, cameraPos);
+            return GetZoomControlFromDistance(zoomControl, distance);
+        }
+        Utils.DetermineZoomItem = DetermineZoomItem;
+        function GetZoomControlFromDistance(zoomControl, distance) {
+            for (var i = 0; i < zoomControl.length; i++) {
+                var zoomItem = zoomControl[i];
+                if ((distance >= zoomItem.MinZoom) && (distance <= zoomItem.MaxZoom)) {
+                    return zoomItem;
+                }
+            }
+            return null;
+        }
+        Utils.GetZoomControlFromDistance = GetZoomControlFromDistance;
+    })(Utils = RenderManager.Utils || (RenderManager.Utils = {}));
+})(RenderManager || (RenderManager = {}));
+
+function colorToCColor(color) {
+    return new Color(color.red ? color.red / 255 : 0, color.green ? color.green / 255 : 0, color.blue ? color.blue / 255 : 0, color.alpha);
+}
+function getPolygonStyleExtrusion(pStyle, entity, tags, heightRef) {
+    var _a;
+    var attrPath = pStyle.extrusionPath;
+    if (!pStyle.useExtrusion || !attrPath) {
+        return null;
+    }
+    try {
+        var extrusion = +Calculator.GetValue(attrPath, entity, tags);
+        if (!extrusion && extrusion != 0) {
+            return null;
+        }
+        /*
+            Cesium extrudes in strange way.
+            If you want something that is 50 meters above sea, and 5 meters tall,
+            You need to extrude by 55 meters, if you extrude by 5 it will extrude from sea and look flat.
+        */
+        var height = (_a = entity.location) === null || _a === void 0 ? void 0 : _a.altitude;
+        return heightRef == HeightReference.RELATIVE_TO_GROUND ? extrusion + height : extrusion;
+    }
+    catch (e) {
+        console.error(e);
+    }
+    return 0;
+}
+function getPolygonExtrusion(entity, tags, ring, posses, heightRef, pStyle) {
+    var _a;
+    var data = {
+        value: undefined,
+        exHeightRef: HeightReference.RELATIVE_TO_GROUND,
+        posses: null
+    };
+    // Step 1. Try get using style.
+    var extrusion = getPolygonStyleExtrusion(pStyle, entity, tags, heightRef);
+    if (extrusion) {
+        if (heightRef == HeightReference.NONE) {
+            // Let's normalize all point heights to be the same (at entity altitude).
+            // This let's us have a consistent extrusion height, and be adjustable easier by user.
+            var alt_1 = (_a = entity === null || entity === void 0 ? void 0 : entity.location) === null || _a === void 0 ? void 0 : _a.altitude;
+            if (!alt_1) {
+                alt_1 = 0;
+            }
+            var points = posses.map(function (x) { return Cartographic.fromCartesian(x); });
+            points.forEach(function (point) {
+                point.height = alt_1;
+            });
+            posses = points.map(function (x) { return Cartesian3.fromRadians(x.longitude, x.latitude, x.height); });
+        }
+    }
+    // Step 2. Try get using geometry data.
+    else {
+        data.exHeightRef = undefined;
+        if (ring.Height && ring.Height > 0) {
+            var points = posses.map(function (x) { return Cartographic.fromCartesian(x); });
+            if (points.length <= 0) {
+                data.value = ring.Height;
+            }
+            else {
+                var highest = null;
+                for (var i = 0; i < points.length; i++) {
+                    var pointHeight = points[i].height;
+                    if (pointHeight > highest || highest === null) {
+                        highest = pointHeight;
+                    }
+                }
+                highest = (highest === null ? 0 : highest) + ring.Height;
+                data.value = highest;
+            }
+            data.exHeightRef = HeightReference.NONE;
+        }
+    }
+    data.posses = posses;
+    return data;
+}
+function getHeightRef(style) {
+    var _a;
+    var heightRef = HeightReference.CLAMP_TO_GROUND;
+    var altOptionId = (_a = style === null || style === void 0 ? void 0 : style.altitudeOption) === null || _a === void 0 ? void 0 : _a.id;
+    if (altOptionId == 1) {
+        heightRef = HeightReference.NONE;
+    }
+    else if (altOptionId == 2) {
+        heightRef = HeightReference.RELATIVE_TO_GROUND;
+    }
+    return heightRef;
+}
+function getZIndex(style, entity, tags) {
+    var zIndex = (style === null || style === void 0 ? void 0 : style.zIndex) ? +Calculator.GetValue(style === null || style === void 0 ? void 0 : style.zIndex, entity, tags) : 0;
+    if (zIndex == null) {
+        zIndex = 0;
+    }
+    return zIndex;
+}
+function getStyle(api, entity, styleId) {
+    return __awaiter(this, void 0, void 0, function () {
+        var style, type;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    style = null;
+                    if (!styleId) return [3 /*break*/, 2];
+                    return [4 /*yield*/, Style.Get(api, styleId)];
+                case 1:
+                    style = _a.sent();
+                    _a.label = 2;
+                case 2:
+                    if (!!style) return [3 /*break*/, 5];
+                    return [4 /*yield*/, EntityType.Get(api, entity.Bruce["EntityType.ID"])];
+                case 3:
+                    type = _a.sent();
+                    if (!type["DisplaySetting.ID"]) return [3 /*break*/, 5];
+                    return [4 /*yield*/, Style.Get(api, type["DisplaySetting.ID"])];
+                case 4:
+                    style = _a.sent();
+                    _a.label = 5;
+                case 5: return [2 /*return*/, style];
+            }
+        });
+    });
+}
+function getExistingCEntity(entityId, menuItemId, item, visualRegister) {
+    var visuals = visualRegister.GetVisuals(entityId, menuItemId);
+    return visuals.length > 0 ? visuals[0] : null;
+}
+function getRenderGroupId(zoomItem) {
+    if (!zoomItem) {
+        return null;
+    }
+    return zoomItem.MinZoom + "-" + zoomItem.MaxZoom;
+}
+var EntityRenderEngine;
+(function (EntityRenderEngine) {
+    function Render(params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var groupRenderParams, cEntities, models, polygons, polylines, points, i, entity, id, zoomItem, displayType, newRenderId, existing, oldRenderId, mParams, mEntities, i, entity, id, cEntity, pParams, pEntities, i, entity, cEntity, pParams, pEntities, i, entity, cEntity, pParams, pEntities, i, entity, cEntity;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        groupRenderParams = {
+                            api: params.api,
+                            viewer: params.viewer,
+                            entities: [],
+                            zoomItems: {},
+                            menuItemId: params.menuItemId,
+                            visualRegister: params.visualRegister
+                        };
+                        cEntities = {};
+                        models = [];
+                        polygons = [];
+                        polylines = [];
+                        points = [];
+                        // Initial sorting.
+                        for (i = 0; i < params.entities.length; i++) {
+                            entity = params.entities[i];
+                            id = entity.Bruce.ID;
+                            zoomItem = RenderManager.Utils.DetermineZoomItem(params.viewer, entity, params.zoomControl);
+                            displayType = zoomItem === null || zoomItem === void 0 ? void 0 : zoomItem.DisplayType;
+                            if (!displayType) {
+                                displayType = ZoomControl.EDisplayType.Hidden;
+                            }
+                            if (displayType != ZoomControl.EDisplayType.Hidden) {
+                                newRenderId = getRenderGroupId(zoomItem);
+                                existing = getExistingCEntity(id, params.menuItemId, zoomItem, params.visualRegister);
+                                oldRenderId = existing === null || existing === void 0 ? void 0 : existing._renderGroup;
+                                if (newRenderId == oldRenderId) {
+                                    cEntities[id] = existing;
+                                }
+                                else {
+                                    if (displayType == ZoomControl.EDisplayType.Model3D) {
+                                        models.push(entity);
+                                    }
+                                    else if (displayType == ZoomControl.EDisplayType.Geometry) {
+                                        polygons.push(entity);
+                                    }
+                                    else {
+                                        points.push(entity);
+                                    }
+                                    groupRenderParams.zoomItems[id] = zoomItem;
+                                }
+                            }
+                        }
+                        if (!(models.length > 0)) return [3 /*break*/, 2];
+                        mParams = __assign(__assign({}, groupRenderParams), { entities: models });
+                        return [4 /*yield*/, Model3d.RenderGroup(mParams)];
+                    case 1:
+                        mEntities = _a.sent();
+                        for (i = 0; i < mParams.entities.length; i++) {
+                            entity = mParams.entities[i];
+                            id = entity.Bruce.ID;
+                            cEntity = mEntities[id];
+                            if (cEntity) {
+                                cEntities[id] = cEntity;
+                            }
+                            else {
+                                polygons.push(entity);
+                            }
+                        }
+                        _a.label = 2;
+                    case 2:
+                        if (!(polygons.length > 0)) return [3 /*break*/, 4];
+                        pParams = __assign(__assign({}, groupRenderParams), { entities: models });
+                        return [4 /*yield*/, Polygon.RenderGroup(pParams)];
+                    case 3:
+                        pEntities = _a.sent();
+                        for (i = 0; i < pParams.entities.length; i++) {
+                            entity = pParams.entities[i];
+                            cEntity = pEntities[entity.Bruce.ID];
+                            if (cEntity) {
+                                cEntities[entity.Bruce.ID] = cEntity;
+                            }
+                            else {
+                                polylines.push(entity);
+                            }
+                        }
+                        _a.label = 4;
+                    case 4:
+                        if (!(polylines.length > 0)) return [3 /*break*/, 6];
+                        pParams = __assign(__assign({}, groupRenderParams), { entities: models });
+                        return [4 /*yield*/, Polyline.RenderGroup(pParams)];
+                    case 5:
+                        pEntities = _a.sent();
+                        for (i = 0; i < pParams.entities.length; i++) {
+                            entity = pParams.entities[i];
+                            cEntity = pEntities[entity.Bruce.ID];
+                            if (cEntity) {
+                                cEntities[entity.Bruce.ID] = cEntity;
+                            }
+                            else {
+                                points.push(entity);
+                            }
+                        }
+                        _a.label = 6;
+                    case 6:
+                        if (!(points.length > 0)) return [3 /*break*/, 8];
+                        pParams = __assign(__assign({}, groupRenderParams), { entities: models });
+                        return [4 /*yield*/, Point.RenderGroup(pParams)];
+                    case 7:
+                        pEntities = _a.sent();
+                        for (i = 0; i < pParams.entities.length; i++) {
+                            entity = pParams.entities[i];
+                            cEntity = pEntities[entity.Bruce.ID];
+                            if (cEntity) {
+                                cEntities[entity.Bruce.ID] = cEntity;
+                            }
+                        }
+                        _a.label = 8;
+                    case 8: return [2 /*return*/, cEntities];
+                }
+            });
+        });
+    }
+    EntityRenderEngine.Render = Render;
+    function Remove(viewer, entity) {
+        if (entity._parentEntity) {
+            Remove(viewer, entity._parentEntity);
+        }
+        if (entity._siblingGraphics) {
+            for (var i = 0; i < entity._siblingGraphics.length; i++) {
+                var sibling = entity._siblingGraphics[i];
+                Remove(viewer, sibling);
+            }
+        }
+        if (viewer.entities.contains(entity)) {
+            viewer.entities.remove(entity);
+        }
+    }
+    EntityRenderEngine.Remove = Remove;
+    var Point;
+    (function (Point) {
+        function Render(params) {
+            var entity = params.entity;
+            var style = params.style;
+            var bColor = style.color ? Calculator.GetValue(style.color, entity, params.tags) : null;
+            var cColor = bColor ? colorToCColor(bColor) : Color.RED;
+            var size = style.size ? Calculator.GetValue(style.size, entity, params.tags) : null;
+            if (size == null) {
+                size = 30;
+            }
+            if (size <= 0) {
+                return null;
+            }
+            var cEntity = new Entity({
+                point: {
+                    pixelSize: size,
+                    color: cColor,
+                    heightReference: getHeightRef(style)
+                },
+                position: EntityUtils.GetPos(params.viewer, entity),
+                show: false
+            });
+            params.viewer.entities.add(cEntity);
+            return cEntity;
+        }
+        Point.Render = Render;
+        function RenderGroup(params) {
+            var _a, _b;
+            return __awaiter(this, void 0, void 0, function () {
+                var cEntities, i, entity, zoomItem, style, tagIds, tags, pStyle, cEntity;
+                return __generator(this, function (_c) {
+                    switch (_c.label) {
+                        case 0:
+                            cEntities = {};
+                            i = 0;
+                            _c.label = 1;
+                        case 1:
+                            if (!(i < params.entities.length)) return [3 /*break*/, 6];
+                            entity = params.entities[i];
+                            zoomItem = params.zoomItems[entity.Bruce.ID];
+                            return [4 /*yield*/, getStyle(params.api, entity, zoomItem.StyleID)];
+                        case 2:
+                            style = _c.sent();
+                            tagIds = entity.Bruce["Layer.ID"];
+                            tags = [];
+                            if (!(tagIds && tagIds.length > 0)) return [3 /*break*/, 4];
+                            return [4 /*yield*/, EntityTag.GetListByIds(params.api, tagIds)];
+                        case 3:
+                            tags = _c.sent();
+                            _c.label = 4;
+                        case 4:
+                            pStyle = (_b = (_a = style === null || style === void 0 ? void 0 : style.Settings) === null || _a === void 0 ? void 0 : _a.pointStyle) !== null && _b !== void 0 ? _b : {};
+                            cEntity = Render({
+                                entity: entity,
+                                style: pStyle,
+                                tags: tags,
+                                viewer: params.viewer
+                            });
+                            cEntity._renderGroup = getRenderGroupId(zoomItem);
+                            cEntities[entity.Bruce.ID] = cEntity;
+                            _c.label = 5;
+                        case 5:
+                            i++;
+                            return [3 /*break*/, 1];
+                        case 6: return [2 /*return*/, cEntities];
+                    }
+                });
+            });
+        }
+        Point.RenderGroup = RenderGroup;
+    })(Point = EntityRenderEngine.Point || (EntityRenderEngine.Point = {}));
+    var Polyline;
+    (function (Polyline) {
+        function Render(params) {
+            var _a;
+            var entity = params.entity;
+            var line = (_a = entity.geometry) === null || _a === void 0 ? void 0 : _a.LineString;
+            var points = line && typeof line == "string" ? Geometry.ParsePoints(line) : [];
+            if (!points || points.length < 2) {
+                return null;
+            }
+            var isValid = true;
+            for (var i = 0; i < points.length; i++) {
+                if (!Carto.ValidateCarto(points[i])) {
+                    isValid = false;
+                    break;
+                }
+            }
+            if (!isValid) {
+                return null;
+            }
+            var posses = points.map(function (x) { return Cartesian3.fromDegrees(x.longitude, x.latitude, x.altitude); });
+            // Making sure no 0 length lines coming through.
+            // Ideally we would measure the full line but I fear that's too expensive.
+            if (posses.length == 2 || posses.length == 3) {
+                var totalDistance = 0;
+                for (var i = 0; i < posses.length; i++) {
+                    var pos1 = posses[i];
+                    var pos2 = posses[i + 1];
+                    if (pos1 && pos2) {
+                        totalDistance += Cartesian3.distance(pos1, pos2);
+                    }
+                }
+                if (totalDistance < 0.001) {
+                    return null;
+                }
+            }
+            var style = params.style;
+            var bColor = style.lineColor ? Calculator.GetValue(style.lineColor, entity, params.tags) : null;
+            var cColor = bColor ? colorToCColor(bColor) : Color.RED;
+            var width = style.lineWidth ? Calculator.GetValue(style.lineWidth, entity, params.tags) : null;
+            if (width == null) {
+                width = 4;
+            }
+            if (width <= 0) {
+                return null;
+            }
+            var heightRef = getHeightRef(style);
+            var cEntity = new Entity({
+                polyline: {
+                    positions: posses,
+                    material: cColor,
+                    width: width,
+                    classificationType: ClassificationType.TERRAIN,
+                    arcType: ArcType.GEODESIC,
+                    zIndex: getZIndex(style, entity, params.tags),
+                    clampToGround: heightRef == HeightReference.CLAMP_TO_GROUND
+                },
+                position: EntityUtils.GetPos(params.viewer, entity),
+                show: false
+            });
+            params.viewer.entities.add(cEntity);
+            return cEntity;
+        }
+        Polyline.Render = Render;
+        function RenderGroup(params) {
+            var _a, _b;
+            return __awaiter(this, void 0, void 0, function () {
+                var cEntities, i, entity, zoomItem, style, tagIds, tags, lStyle, cEntity;
+                return __generator(this, function (_c) {
+                    switch (_c.label) {
+                        case 0:
+                            cEntities = {};
+                            i = 0;
+                            _c.label = 1;
+                        case 1:
+                            if (!(i < params.entities.length)) return [3 /*break*/, 6];
+                            entity = params.entities[i];
+                            zoomItem = params.zoomItems[entity.Bruce.ID];
+                            return [4 /*yield*/, getStyle(params.api, entity, zoomItem.StyleID)];
+                        case 2:
+                            style = _c.sent();
+                            tagIds = entity.Bruce["Layer.ID"];
+                            tags = [];
+                            if (!(tagIds && tagIds.length > 0)) return [3 /*break*/, 4];
+                            return [4 /*yield*/, EntityTag.GetListByIds(params.api, tagIds)];
+                        case 3:
+                            tags = _c.sent();
+                            _c.label = 4;
+                        case 4:
+                            lStyle = (_b = (_a = style === null || style === void 0 ? void 0 : style.Settings) === null || _a === void 0 ? void 0 : _a.polylineStyle) !== null && _b !== void 0 ? _b : {};
+                            cEntity = Render({
+                                entity: entity,
+                                style: lStyle,
+                                tags: tags,
+                                viewer: params.viewer
+                            });
+                            if (cEntity) {
+                                cEntity._renderGroup = getRenderGroupId(zoomItem);
+                                cEntities[entity.Bruce.ID] = cEntity;
+                            }
+                            _c.label = 5;
+                        case 5:
+                            i++;
+                            return [3 /*break*/, 1];
+                        case 6: return [2 /*return*/, cEntities];
+                    }
+                });
+            });
+        }
+        Polyline.RenderGroup = RenderGroup;
+    })(Polyline = EntityRenderEngine.Polyline || (EntityRenderEngine.Polyline = {}));
+    var Polygon;
+    (function (Polygon) {
+        function Render(params) {
+            var _a;
+            var entity = params.entity;
+            var pRings = (_a = entity.geometry) === null || _a === void 0 ? void 0 : _a.Polygon;
+            if (pRings == null || pRings.length <= 0) {
+                return null;
+            }
+            var style = params.style;
+            var bFillColor = Calculator.GetValue(style.fillColor, entity, params.tags);
+            var cFillColor = bFillColor ? colorToCColor(bFillColor) : Color.RED;
+            var bLineColor = Calculator.GetValue(style.lineColor, entity, params.tags);
+            var cLineColor = bLineColor ? colorToCColor(bLineColor) : Color.RED;
+            var width = style.lineWidth ? Calculator.GetValue(style.lineWidth, entity, params.tags) : null;
+            if (width == null) {
+                width = 4;
+            }
+            if (width <= 0) {
+                return null;
+            }
+            var heightRef = getHeightRef(style);
+            var outerRing = pRings.find(function (x) { return x.Facing == Geometry.EPolygonRingType.Boundaries; });
+            var points = Geometry.ParsePoints(outerRing === null || outerRing === void 0 ? void 0 : outerRing.LinearRing);
+            var posses = points.map(function (x) { return Cartesian3.fromDegrees(x.longitude, x.latitude, x.altitude); });
+            var extrusion = getPolygonExtrusion(entity, params.tags, outerRing, posses, heightRef, style);
+            posses = extrusion.posses;
+            var holeRings = pRings.filter(function (x) { return x.Facing == Geometry.EPolygonRingType.Hole; });
+            var holePosses = holeRings.map(function (x) {
+                var points = Geometry.ParsePoints(x.LinearRing);
+                return points.map(function (x) { return Cartesian3.fromDegrees(x.longitude, x.latitude, x.altitude); });
+            });
+            var zIndex = getZIndex(style, entity, params.tags);
+            var cEntity = new Entity({
+                polygon: {
+                    hierarchy: new PolygonHierarchy(posses, holePosses.map(function (x) { return new PolygonHierarchy(x); })),
+                    material: cFillColor,
+                    extrudedHeight: extrusion.value,
+                    extrudedHeightReference: extrusion.exHeightRef,
+                    shadows: ShadowMode.ENABLED,
+                    heightReference: heightRef,
+                    classificationType: ClassificationType.BOTH,
+                    perPositionHeight: heightRef == HeightReference.CLAMP_TO_GROUND ? false : true,
+                    zIndex: zIndex
+                },
+                position: EntityUtils.GetPos(params.viewer, entity),
+                show: false
+            });
+            cEntity._siblingGraphics = [];
+            for (var i = 0; i < holePosses.length; i++) {
+                var posses_1 = holePosses[i];
+                var cEntityHole = new Entity({
+                    polyline: new PolylineGraphics({
+                        positions: posses_1,
+                        material: cLineColor,
+                        width: width,
+                        clampToGround: heightRef == HeightReference.CLAMP_TO_GROUND,
+                        classificationType: ClassificationType.TERRAIN,
+                        arcType: ArcType.GEODESIC,
+                        zIndex: zIndex
+                    }),
+                    show: false
+                });
+                cEntity._siblingGraphics.push(cEntityHole);
+                cEntityHole._parentEntity = cEntity;
+                params.viewer.entities.add(cEntityHole);
+            }
+            params.viewer.entities.add(cEntity);
+            return cEntity;
+        }
+        Polygon.Render = Render;
+        function RenderGroup(params) {
+            var _a, _b;
+            return __awaiter(this, void 0, void 0, function () {
+                var cEntities, i, entity, zoomItem, style, tagIds, tags, pStyle, cEntity;
+                return __generator(this, function (_c) {
+                    switch (_c.label) {
+                        case 0:
+                            cEntities = {};
+                            i = 0;
+                            _c.label = 1;
+                        case 1:
+                            if (!(i < params.entities.length)) return [3 /*break*/, 6];
+                            entity = params.entities[i];
+                            zoomItem = params.zoomItems[entity.Bruce.ID];
+                            return [4 /*yield*/, getStyle(params.api, entity, zoomItem.StyleID)];
+                        case 2:
+                            style = _c.sent();
+                            tagIds = entity.Bruce["Layer.ID"];
+                            tags = [];
+                            if (!(tagIds && tagIds.length > 0)) return [3 /*break*/, 4];
+                            return [4 /*yield*/, EntityTag.GetListByIds(params.api, tagIds)];
+                        case 3:
+                            tags = _c.sent();
+                            _c.label = 4;
+                        case 4:
+                            pStyle = (_b = (_a = style === null || style === void 0 ? void 0 : style.Settings) === null || _a === void 0 ? void 0 : _a.polygonStyle) !== null && _b !== void 0 ? _b : {};
+                            cEntity = Render({
+                                entity: entity,
+                                style: pStyle,
+                                tags: tags,
+                                viewer: params.viewer
+                            });
+                            if (cEntity) {
+                                cEntity._renderGroup = getRenderGroupId(zoomItem);
+                                cEntities[entity.Bruce.ID] = cEntity;
+                            }
+                            _c.label = 5;
+                        case 5:
+                            i++;
+                            return [3 /*break*/, 1];
+                        case 6: return [2 /*return*/, cEntities];
+                    }
+                });
+            });
+        }
+        Polygon.RenderGroup = RenderGroup;
+    })(Polygon = EntityRenderEngine.Polygon || (EntityRenderEngine.Polygon = {}));
+    var Model3d;
+    (function (Model3d) {
+        function Render(params) {
+            var entity = params.entity;
+            var transform = entity === null || entity === void 0 ? void 0 : entity.transform;
+            var heading = transform ? +transform.heading : 0;
+            heading = (heading + 90) % 360;
+            var pitch = transform ? +transform.pitch : 0;
+            var roll = transform ? +transform.roll : 0;
+            var scale = transform ? +transform.scale : 1;
+            if (scale <= 0) {
+                scale = 1;
+            }
+            var style = params.style;
+            var styleScale = (style === null || style === void 0 ? void 0 : style.scale) ? +Calculator.GetValue(style === null || style === void 0 ? void 0 : style.scale, entity, params.tags) : null;
+            if (!styleScale) {
+                styleScale = 1;
+            }
+            scale *= styleScale;
+            var hpr = new HeadingPitchRoll(heading, pitch, roll);
+            var heightRef = getHeightRef(style);
+            var pos = EntityUtils.GetPos(params.viewer, entity);
+            if (heightRef == HeightReference.CLAMP_TO_GROUND) {
+                var carto = Cartographic.fromCartesian(pos);
+                pos = Cartesian3.fromRadians(carto.longitude, carto.latitude, 0);
+                heightRef = HeightReference.RELATIVE_TO_GROUND;
+            }
+            var orientation = Transforms.headingPitchRollQuaternion(pos, hpr);
+            var blendMode = null;
+            var blendAmount = null;
+            var color = null;
+            if (style === null || style === void 0 ? void 0 : style.customize) {
+                blendMode = style.fillColorBlendMode;
+                if (!blendMode) {
+                    blendMode = ColorBlendMode.HIGHLIGHT;
+                }
+                if (blendMode == ColorBlendMode.MIX) {
+                    blendAmount = style.fillColorBlendAmount;
+                    if (!blendAmount) {
+                        blendAmount = 0.5;
+                    }
+                }
+                var bColor = Calculator.GetValue(style.fillColor, entity, params.tags);
+                if (bColor) {
+                    color = colorToCColor(bColor);
+                }
+            }
+            var cEntity = new Entity({
+                model: {
+                    uri: params.lodUrl,
+                    heightReference: heightRef,
+                    scale: scale,
+                    shadows: ShadowMode.ENABLED,
+                    colorBlendAmount: blendAmount,
+                    colorBlendMode: blendMode,
+                    color: color
+                },
+                orientation: orientation,
+                position: pos,
+                show: false
+            });
+            params.viewer.entities.add(cEntity);
+            return cEntity;
+        }
+        Model3d.Render = Render;
+        function RenderGroup(params) {
+            var _a, _b, _c, _d;
+            return __awaiter(this, void 0, void 0, function () {
+                var cEntities, reqBody, i, entity, zoomItem, style, tagIds, tags, mStyle, group, level, catId, lodData, _loop_1, i;
+                return __generator(this, function (_e) {
+                    switch (_e.label) {
+                        case 0:
+                            cEntities = {};
+                            reqBody = {
+                                "strict": false,
+                                "externalSources": false,
+                                "Items": []
+                            };
+                            i = 0;
+                            _e.label = 1;
+                        case 1:
+                            if (!(i < params.entities.length)) return [3 /*break*/, 6];
+                            entity = params.entities[i];
+                            zoomItem = params.zoomItems[entity.Bruce.ID];
+                            return [4 /*yield*/, getStyle(params.api, entity, zoomItem.StyleID)];
+                        case 2:
+                            style = _e.sent();
+                            tagIds = entity.Bruce["Layer.ID"];
+                            tags = [];
+                            if (!(tagIds && tagIds.length > 0)) return [3 /*break*/, 4];
+                            return [4 /*yield*/, EntityTag.GetListByIds(params.api, tagIds)];
+                        case 3:
+                            tags = _e.sent();
+                            _e.label = 4;
+                        case 4:
+                            mStyle = (_b = (_a = style === null || style === void 0 ? void 0 : style.Settings) === null || _a === void 0 ? void 0 : _a.polygonStyle) !== null && _b !== void 0 ? _b : {};
+                            group = mStyle.lodGroup ? Calculator.GetValue(mStyle.lodGroup, entity, tags) : null;
+                            if (!group) {
+                                group = "DEFAULT";
+                            }
+                            level = +zoomItem.LODLevel;
+                            if (!level) {
+                                level = 0;
+                            }
+                            catId = zoomItem.LODCategoryID;
+                            if (!catId) {
+                                catId = "glb";
+                            }
+                            reqBody.Items.push({
+                                "entityId": entity.Bruce.ID,
+                                "categoryId": catId,
+                                "group": group,
+                                "level": level
+                            });
+                            _e.label = 5;
+                        case 5:
+                            i++;
+                            return [3 /*break*/, 1];
+                        case 6: return [4 /*yield*/, EntityLod.GetLods(params.api, reqBody)];
+                        case 7:
+                            lodData = _e.sent();
+                            _loop_1 = function (i) {
+                                var entity, zoomItem, style, tagIds, tags, lod, mStyle, cEntity;
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0:
+                                            entity = params.entities[i];
+                                            zoomItem = params.zoomItems[entity.Bruce.ID];
+                                            return [4 /*yield*/, getStyle(params.api, entity, zoomItem.StyleID)];
+                                        case 1:
+                                            style = _a.sent();
+                                            tagIds = entity.Bruce["Layer.ID"];
+                                            tags = [];
+                                            if (!(tagIds && tagIds.length > 0)) return [3 /*break*/, 3];
+                                            return [4 /*yield*/, EntityTag.GetListByIds(params.api, tagIds)];
+                                        case 2:
+                                            tags = _a.sent();
+                                            _a.label = 3;
+                                        case 3:
+                                            lod = lodData.find(function (x) { return x.entityId == entity.Bruce.ID; });
+                                            if (!(lod === null || lod === void 0 ? void 0 : lod.clientFileId)) {
+                                                return [2 /*return*/, "continue"];
+                                            }
+                                            mStyle = (_d = (_c = style === null || style === void 0 ? void 0 : style.Settings) === null || _c === void 0 ? void 0 : _c.polygonStyle) !== null && _d !== void 0 ? _d : {};
+                                            cEntity = Render({
+                                                entity: entity,
+                                                style: mStyle,
+                                                tags: tags,
+                                                viewer: params.viewer,
+                                                lodUrl: ClientFile.GetUrl(params.api, lod.clientFileId)
+                                            });
+                                            if (cEntity) {
+                                                cEntity._renderGroup = getRenderGroupId(zoomItem);
+                                                cEntities[entity.Bruce.ID] = cEntity;
+                                            }
+                                            return [2 /*return*/];
+                                    }
+                                });
+                            };
+                            i = 0;
+                            _e.label = 8;
+                        case 8:
+                            if (!(i < params.entities.length)) return [3 /*break*/, 11];
+                            return [5 /*yield**/, _loop_1(i)];
+                        case 9:
+                            _e.sent();
+                            _e.label = 10;
+                        case 10:
+                            i++;
+                            return [3 /*break*/, 8];
+                        case 11: return [2 /*return*/, cEntities];
+                    }
+                });
+            });
+        }
+        Model3d.RenderGroup = RenderGroup;
+    })(Model3d = EntityRenderEngine.Model3d || (EntityRenderEngine.Model3d = {}));
+})(EntityRenderEngine || (EntityRenderEngine = {}));
+
+var EntitiesRenderManager;
+(function (EntitiesRenderManager) {
+    var Manager = /** @class */ (function () {
+        function Manager(viewer, visualsManager, api, item) {
+            this.getter = null;
+            this.getterSub = null;
+            this.disposed = false;
+            this.renderedEntities = {};
+            this.entityCheckQueue = null;
+            this.entityCheckRemoval = null;
+            this.isRunningCheck = false;
+            this.viewMonitorRemoval = null;
+            this.viewer = viewer;
+            this.api = api;
+            this.item = item;
+            this.visualsManager = visualsManager;
+        }
+        Object.defineProperty(Manager.prototype, "Disposed", {
+            get: function () {
+                return this.disposed;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Manager.prototype.Init = function () {
+            return __awaiter(this, void 0, void 0, function () {
+                var _this = this;
+                return __generator(this, function (_a) {
+                    if (this.disposed) {
+                        throw (new Error("This item is disposed."));
+                    }
+                    this.getter = new EntityFilterGetter.Getter(this.api, new CesiumViewMonitor(this.viewer), this.item.BruceEntity["EntityType.ID"], 500, {});
+                    this.getter.IncludeMenuItem(this.item.id, [], 0, 100000);
+                    this.getterSub = this.getter.OnUpdate.Subscribe(function (entities) {
+                        _this.onGetterUpdate(entities);
+                    });
+                    this.viewMonitorRemoval = new CesiumViewMonitor(this.viewer).Updated().Subscribe(function () {
+                        _this.entityCheckQueue.Call();
+                    });
+                    this.entityCheckQueue = new DelayQueue(function () {
+                        _this.doEntityCheck();
+                    }, 3000);
+                    return [2 /*return*/];
+                });
+            });
+        };
+        Manager.prototype.Dispose = function () {
+            var _a, _b, _c;
+            if (this.disposed) {
+                return;
+            }
+            (_a = this.getterSub) === null || _a === void 0 ? void 0 : _a.call(this);
+            this.getterSub = null;
+            this.disposed = true;
+            this.visualsManager.RemoveByMenuItemId(this.item.id);
+            (_b = this.entityCheckRemoval) === null || _b === void 0 ? void 0 : _b.call(this);
+            (_c = this.viewMonitorRemoval) === null || _c === void 0 ? void 0 : _c.call(this);
+        };
+        Manager.prototype.doEntityCheck = function () {
+            return __awaiter(this, void 0, void 0, function () {
+                var ids_1, CHECK_BATCH_SIZE_1, checkBatch, e_1;
+                var _this = this;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            if (this.isRunningCheck) {
+                                this.entityCheckQueue.Call();
+                                return [2 /*return*/];
+                            }
+                            this.isRunningCheck = true;
+                            _a.label = 1;
+                        case 1:
+                            _a.trys.push([1, 5, , 6]);
+                            ids_1 = Object.keys(this.renderedEntities);
+                            if (this.disposed) {
+                                return [2 /*return*/];
+                            }
+                            if (!(ids_1.length > 0)) return [3 /*break*/, 4];
+                            CHECK_BATCH_SIZE_1 = 150;
+                            checkBatch = function () { return __awaiter(_this, void 0, void 0, function () {
+                                var entityIds, entities;
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0:
+                                            entityIds = ids_1.splice(0, CHECK_BATCH_SIZE_1);
+                                            return [4 /*yield*/, Entity$1.GetListByIds(this.api, entityIds)];
+                                        case 1:
+                                            entities = _a.sent();
+                                            if (this.disposed) {
+                                                return [2 /*return*/];
+                                            }
+                                            this.distributeGenerateBatches(entities);
+                                            return [2 /*return*/];
+                                    }
+                                });
+                            }); };
+                            _a.label = 2;
+                        case 2:
+                            if (!(ids_1.length > 0)) return [3 /*break*/, 4];
+                            return [4 /*yield*/, checkBatch()];
+                        case 3:
+                            _a.sent();
+                            return [3 /*break*/, 2];
+                        case 4: return [3 /*break*/, 6];
+                        case 5:
+                            e_1 = _a.sent();
+                            console.error(e_1);
+                            return [3 /*break*/, 6];
+                        case 6:
+                            this.isRunningCheck = false;
+                            return [2 /*return*/];
+                    }
+                });
+            });
+        };
+        Manager.prototype.distributeGenerateBatches = function (entities) {
+            var BATCH_SIZE = 50;
+            while (entities.length > 0) {
+                var batch = entities.splice(0, BATCH_SIZE);
+                this.onGetterUpdate(batch);
+            }
+        };
+        Manager.prototype.onGetterUpdate = function (entities) {
+            return __awaiter(this, void 0, void 0, function () {
+                var cEntities, i, id, cEntity, visuals;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            if (this.disposed) {
+                                return [2 /*return*/];
+                            }
+                            return [4 /*yield*/, EntityRenderEngine.Render({
+                                    viewer: this.viewer,
+                                    api: this.api,
+                                    entities: entities,
+                                    menuItemId: this.item.id,
+                                    visualRegister: this.visualsManager,
+                                    zoomControl: this.item.CameraZoomSettings
+                                })];
+                        case 1:
+                            cEntities = _a.sent();
+                            for (i = 0; i < entities.length; i++) {
+                                id = entities[i].Bruce.ID;
+                                cEntity = cEntities[id];
+                                this.renderedEntities[id] = !!cEntity;
+                                if (cEntity) {
+                                    visuals = this.visualsManager.GetVisuals(id, this.item.id);
+                                    if (visuals.length != 1 || (visuals.length > 0 && visuals[0] != cEntity)) {
+                                        this.visualsManager.Add({
+                                            entityId: id,
+                                            menuItemId: this.item.id,
+                                            visuals: [cEntity],
+                                            priority: 0
+                                        });
+                                    }
+                                }
+                                else {
+                                    this.visualsManager.Remove(id, this.item.id);
+                                }
+                            }
+                            return [2 /*return*/];
+                    }
+                });
+            });
+        };
+        return Manager;
+    }());
+    EntitiesRenderManager.Manager = Manager;
+})(EntitiesRenderManager || (EntitiesRenderManager = {}));
+
+var EntitiesLoadedRenderManager;
+(function (EntitiesLoadedRenderManager) {
+    var Manager = /** @class */ (function () {
+        function Manager(viewer, visualsManager, api, item) {
+            this.getter = null;
+            this.getterSub = null;
+            this.disposed = false;
+            this.renderedEntities = {};
+            this.viewer = viewer;
+            this.api = api;
+            this.item = item;
+            this.visualsManager = visualsManager;
+        }
+        Object.defineProperty(Manager.prototype, "Disposed", {
+            get: function () {
+                return this.disposed;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Manager.prototype.Init = function () {
+            return __awaiter(this, void 0, void 0, function () {
+                var _this = this;
+                return __generator(this, function (_a) {
+                    if (this.disposed) {
+                        throw (new Error("This item is disposed."));
+                    }
+                    this.getter = new BatchedDataGetter.Getter(this.item.BruceEntity.Entities, new CesiumViewMonitor(this.viewer), 500);
+                    this.getterSub = this.getter.OnUpdate.Subscribe(function (entities) {
+                        _this.onGetterUpdate(entities);
+                    });
+                    return [2 /*return*/];
+                });
+            });
+        };
+        Manager.prototype.Dispose = function () {
+            var _a;
+            if (this.disposed) {
+                return;
+            }
+            (_a = this.getterSub) === null || _a === void 0 ? void 0 : _a.call(this);
+            this.getterSub = null;
+            this.disposed = true;
+            this.visualsManager.RemoveByMenuItemId(this.item.id);
+        };
+        Manager.prototype.onGetterUpdate = function (entities) {
+            return __awaiter(this, void 0, void 0, function () {
+                var cEntities, i, id, cEntity, visuals;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            if (this.disposed) {
+                                return [2 /*return*/];
+                            }
+                            return [4 /*yield*/, EntityRenderEngine.Render({
+                                    viewer: this.viewer,
+                                    api: this.api,
+                                    entities: entities,
+                                    menuItemId: this.item.id,
+                                    visualRegister: this.visualsManager,
+                                    zoomControl: this.item.CameraZoomSettings
+                                })];
+                        case 1:
+                            cEntities = _a.sent();
+                            for (i = 0; i < entities.length; i++) {
+                                id = entities[i].Bruce.ID;
+                                cEntity = cEntities[id];
+                                this.renderedEntities[id] = !!cEntity;
+                                if (cEntity) {
+                                    visuals = this.visualsManager.GetVisuals(id, this.item.id);
+                                    if (visuals.length != 1 || (visuals.length > 0 && visuals[0] != cEntity)) {
+                                        this.visualsManager.Add({
+                                            entityId: id,
+                                            menuItemId: this.item.id,
+                                            visuals: [cEntity],
+                                            priority: 0
+                                        });
+                                    }
+                                }
+                                else {
+                                    this.visualsManager.Remove(id, this.item.id);
+                                }
+                            }
+                            return [2 /*return*/];
+                    }
+                });
+            });
+        };
+        return Manager;
+    }());
+    EntitiesLoadedRenderManager.Manager = Manager;
+})(EntitiesLoadedRenderManager || (EntitiesLoadedRenderManager = {}));
+
+var EntitiesIdsRenderManager;
+(function (EntitiesIdsRenderManager) {
+    var Manager = /** @class */ (function () {
+        function Manager(viewer, visualsManager, api, item) {
+            this.getter = null;
+            this.getterSub = null;
+            this.disposed = false;
+            this.renderedEntities = {};
+            this.viewer = viewer;
+            this.api = api;
+            this.item = item;
+            this.visualsManager = visualsManager;
+        }
+        Object.defineProperty(Manager.prototype, "Disposed", {
+            get: function () {
+                return this.disposed;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Manager.prototype.Init = function () {
+            return __awaiter(this, void 0, void 0, function () {
+                var _this = this;
+                return __generator(this, function (_a) {
+                    if (this.disposed) {
+                        throw (new Error("This item is disposed."));
+                    }
+                    this.getter = new BatchedDataGetter.Getter(this.item.BruceEntity.EntityIds, new CesiumViewMonitor(this.viewer), 500);
+                    this.getterSub = this.getter.OnUpdate.Subscribe(function (ids) {
+                        _this.onGetterUpdate(ids);
+                    });
+                    return [2 /*return*/];
+                });
+            });
+        };
+        Manager.prototype.Dispose = function () {
+            var _a;
+            if (this.disposed) {
+                return;
+            }
+            (_a = this.getterSub) === null || _a === void 0 ? void 0 : _a.call(this);
+            this.getterSub = null;
+            this.disposed = true;
+            this.visualsManager.RemoveByMenuItemId(this.item.id);
+        };
+        Manager.prototype.onGetterUpdate = function (entityIds) {
+            return __awaiter(this, void 0, void 0, function () {
+                var entities, cEntities, i, id, cEntity, visuals;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            if (this.disposed) {
+                                return [2 /*return*/];
+                            }
+                            return [4 /*yield*/, Entity$1.GetListByIds(this.api, entityIds)];
+                        case 1:
+                            entities = _a.sent();
+                            return [4 /*yield*/, EntityRenderEngine.Render({
+                                    viewer: this.viewer,
+                                    api: this.api,
+                                    entities: entities,
+                                    menuItemId: this.item.id,
+                                    visualRegister: this.visualsManager,
+                                    zoomControl: this.item.CameraZoomSettings
+                                })];
+                        case 2:
+                            cEntities = _a.sent();
+                            for (i = 0; i < entities.length; i++) {
+                                id = entities[i].Bruce.ID;
+                                cEntity = cEntities[id];
+                                this.renderedEntities[id] = !!cEntity;
+                                if (cEntity) {
+                                    visuals = this.visualsManager.GetVisuals(id, this.item.id);
+                                    if (visuals.length != 1 || (visuals.length > 0 && visuals[0] != cEntity)) {
+                                        this.visualsManager.Add({
+                                            entityId: id,
+                                            menuItemId: this.item.id,
+                                            visuals: [cEntity],
+                                            priority: 0
+                                        });
+                                    }
+                                }
+                                else {
+                                    this.visualsManager.Remove(id, this.item.id);
+                                }
+                            }
+                            return [2 /*return*/];
+                    }
+                });
+            });
+        };
+        return Manager;
+    }());
+    EntitiesIdsRenderManager.Manager = Manager;
+})(EntitiesIdsRenderManager || (EntitiesIdsRenderManager = {}));
+
+var EntityRenderManager;
+(function (EntityRenderManager) {
+    var Manager = /** @class */ (function () {
+        function Manager(viewer, visualsManager, api, item) {
+            this.getter = null;
+            this.getterSub = null;
+            this.disposed = false;
+            this.viewer = viewer;
+            this.api = api;
+            this.item = item;
+            this.visualsManager = visualsManager;
+        }
+        Object.defineProperty(Manager.prototype, "Disposed", {
+            get: function () {
+                return this.disposed;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Manager.prototype.Init = function () {
+            return __awaiter(this, void 0, void 0, function () {
+                var _this = this;
+                return __generator(this, function (_a) {
+                    if (this.disposed) {
+                        throw (new Error("This item is disposed."));
+                    }
+                    this.getter = new BatchedDataGetter.Getter([this.item.BruceEntity.EntityId], new CesiumViewMonitor(this.viewer), 1);
+                    this.getterSub = this.getter.OnUpdate.Subscribe(function (ids) {
+                        _this.onGetterUpdate(ids[0]);
+                    });
+                    return [2 /*return*/];
+                });
+            });
+        };
+        Manager.prototype.Dispose = function () {
+            var _a;
+            if (this.disposed) {
+                return;
+            }
+            this.disposed = true;
+            (_a = this.getterSub) === null || _a === void 0 ? void 0 : _a.call(this);
+            this.getterSub = null;
+            this.visualsManager.RemoveByMenuItemId(this.item.id);
+        };
+        Manager.prototype.onGetterUpdate = function (id) {
+            return __awaiter(this, void 0, void 0, function () {
+                var entity, cEntities, cEntity, visuals;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            if (this.disposed) {
+                                return [2 /*return*/];
+                            }
+                            return [4 /*yield*/, Entity$1.Get(this.api, id)];
+                        case 1:
+                            entity = _a.sent();
+                            return [4 /*yield*/, EntityRenderEngine.Render({
+                                    viewer: this.viewer,
+                                    api: this.api,
+                                    entities: [entity],
+                                    menuItemId: this.item.id,
+                                    visualRegister: this.visualsManager,
+                                    zoomControl: this.item.CameraZoomSettings
+                                })];
+                        case 2:
+                            cEntities = _a.sent();
+                            cEntity = cEntities[id];
+                            if (cEntity) {
+                                visuals = this.visualsManager.GetVisuals(id, this.item.id);
+                                if (visuals.length != 1 || (visuals.length > 0 && visuals[0] != cEntity)) {
+                                    this.visualsManager.Add({
+                                        entityId: entity.Bruce.ID,
+                                        menuItemId: this.item.id,
+                                        visuals: [cEntity],
+                                        priority: 0
+                                    });
+                                }
+                            }
+                            else {
+                                this.visualsManager.Remove(id, this.item.id);
+                            }
+                            return [2 /*return*/];
+                    }
+                });
+            });
+        };
+        return Manager;
+    }());
+    EntityRenderManager.Manager = Manager;
+})(EntityRenderManager || (EntityRenderManager = {}));
+
+function colorToCColor$1(color) {
+    return new Color(color.red ? color.red / 255 : 0, color.green ? color.green / 255 : 0, color.blue ? color.blue / 255 : 0, color.alpha);
+}
+var TilesetRenderEngine;
+(function (TilesetRenderEngine) {
+    function ApplySettings(cTileset, tileset) {
+        if (tileset.type == Tileset.EType.Cad) {
+            var settings = tileset.settings;
+            var root = cTileset.root;
+            var transform = settings.transform;
+            if (!transform) {
+                transform = {
+                    heading: 0,
+                    pitch: 0,
+                    roll: 0,
+                    scale: 1
+                };
+            }
+            var point = settings.location;
+            var pos = Cartesian3.fromDegrees(point.longitude, point.latitude, point.altitude);
+            var hpr = HeadingPitchRoll.fromDegrees(transform.heading, transform.pitch, transform.roll, new HeadingPitchRoll());
+            root.transform = Transforms.headingPitchRollToFixedFrame(pos, hpr);
+            var scale = +(transform === null || transform === void 0 ? void 0 : transform.scale);
+            if (!scale || scale <= 0) {
+                scale = 0.000001;
+            }
+            var scaleMatrix = Matrix4.fromScale(new Cartesian3(scale, scale, scale), new Matrix4());
+            root.transform = Matrix4.multiply(root.transform, scaleMatrix, root.transform);
+            // Force matrix to update
+            root.updateTransform();
+            var maxScreenSpaceError = settings.maximumScreenSpaceError;
+            if (maxScreenSpaceError || maxScreenSpaceError == 0) {
+                cTileset.maximumScreenSpaceError = maxScreenSpaceError;
+            }
+        }
+        else {
+            throw ("Not implemented.");
+        }
+    }
+    TilesetRenderEngine.ApplySettings = ApplySettings;
+    function Render(params) {
+        if (params.tileset.type == Tileset.EType.Cad) {
+            var cTileset_1 = new Cesium3DTileset({
+                url: Tileset.GetPublicFileUrl(params.api, params.tileset.id, "tileset.json") + "?generation=" + params.tileset.generateVersion
+            });
+            params.viewer.scene.primitives.add(cTileset_1);
+            cTileset_1.readyPromise.then(function () {
+                ApplySettings(cTileset_1, params.tileset);
+            });
+            return cTileset_1;
+        }
+        else {
+            throw ("Not implemented.");
+        }
+    }
+    TilesetRenderEngine.Render = Render;
+    var CadStyler = /** @class */ (function () {
+        function CadStyler(api, cTileset, fallbackStyleId, styleMapping) {
+            this.disposed = false;
+            this.loadedEntities = {};
+            this.styleMappingLoaded = false;
+            this.styleMappingsLoaded = {};
+            this.fallbackStyle = null;
+            this.runningQueues = 0;
+            this.recordLoadQueue = [];
+            this.recordCheckQueue = [];
+            this.api = api;
+            this.cTileset = cTileset;
+            this.fallbackStyleId = fallbackStyleId;
+            this.styleMapping = styleMapping;
+            this.loadStyles();
+        }
+        Object.defineProperty(CadStyler.prototype, "Disposed", {
+            get: function () {
+                return this.disposed;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        CadStyler.prototype.QueueEntities = function (entities) {
+            for (var i = 0; i < entities.length; i++) {
+                var entity = entities[i];
+                this.queueTilesetFeatureStyle(entity);
+            }
+            if (this.recordLoadQueue.length > 0) {
+                this.processQueue();
+            }
+        };
+        CadStyler.prototype.processQueue = function () {
+            return __awaiter(this, void 0, void 0, function () {
+                var MAX_BATCHES, BATCH_DELAY, batch, rerun, entityIds, entities, _loop_1, this_1, i;
+                var _this = this;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            MAX_BATCHES = 2;
+                            BATCH_DELAY = 200;
+                            if (this.runningQueues >= MAX_BATCHES) {
+                                return [2 /*return*/];
+                            }
+                            else if (this.disposed) {
+                                return [2 /*return*/];
+                            }
+                            this.runningQueues += 1;
+                            batch = [];
+                            rerun = false;
+                            _a.label = 1;
+                        case 1:
+                            _a.trys.push([1, , 4, 5]);
+                            batch = this.getEntitiesForQueue();
+                            entityIds = batch.map(function (x) { return x.entityId; });
+                            if (!(entityIds.length > 0)) return [3 /*break*/, 3];
+                            return [4 /*yield*/, Entity$1.GetListByIds(this.api, entityIds)];
+                        case 2:
+                            entities = _a.sent();
+                            _loop_1 = function (i) {
+                                var record = entities[i];
+                                var feature = batch.find(function (x) { var _a; return (x === null || x === void 0 ? void 0 : x.entityId) == ((_a = record === null || record === void 0 ? void 0 : record.Bruce) === null || _a === void 0 ? void 0 : _a.ID); });
+                                if (feature) {
+                                    this_1.styleTilesetFeatureFullData(feature, record);
+                                }
+                            };
+                            this_1 = this;
+                            for (i = 0; i < entities.length; i++) {
+                                _loop_1(i);
+                            }
+                            rerun = batch.length > 0;
+                            _a.label = 3;
+                        case 3: return [3 /*break*/, 5];
+                        case 4:
+                            setTimeout(function () {
+                                _this.runningQueues -= 1;
+                                if (rerun) {
+                                    _this.processQueue();
+                                }
+                            }, BATCH_DELAY);
+                            return [7 /*endfinally*/];
+                        case 5: return [2 /*return*/];
+                    }
+                });
+            });
+        };
+        CadStyler.prototype.getEntitiesForQueue = function () {
+            var BATCH_SIZE = 30;
+            var batchHashes = this.recordLoadQueue.splice(0, BATCH_SIZE);
+            var entities = [];
+            for (var i = 0; i < batchHashes.length; i++) {
+                var id = batchHashes[i];
+                var entity = this.loadedEntities[id];
+                if (entity) {
+                    entities.push(entity);
+                }
+            }
+            return entities;
+        };
+        CadStyler.prototype.Dispose = function () {
+            if (this.disposed) {
+                return;
+            }
+            this.disposed = true;
+            clearInterval(this.queueLoadInterval);
+            clearInterval(this.queueCheckInterval);
+        };
+        CadStyler.prototype.loadStyles = function () {
+            var _a, _b;
+            return __awaiter(this, void 0, void 0, function () {
+                var fallbackStyleId, data, e_1, styleMapping, modelTree, entityTypeIds, _loop_2, i, i, styleMap, styleId, entityType, e_2, data, e_3;
+                return __generator(this, function (_c) {
+                    switch (_c.label) {
+                        case 0:
+                            fallbackStyleId = this.fallbackStyleId;
+                            if (!(fallbackStyleId && fallbackStyleId > 0)) return [3 /*break*/, 4];
+                            _c.label = 1;
+                        case 1:
+                            _c.trys.push([1, 3, , 4]);
+                            return [4 /*yield*/, Style.Get(this.api, fallbackStyleId)];
+                        case 2:
+                            data = _c.sent();
+                            this.fallbackStyle = data;
+                            return [3 /*break*/, 4];
+                        case 3:
+                            e_1 = _c.sent();
+                            console.error(e_1);
+                            return [3 /*break*/, 4];
+                        case 4:
+                            styleMapping = this.styleMapping;
+                            if (!styleMapping) {
+                                styleMapping = [];
+                            }
+                            this.styleMapping = styleMapping;
+                            // It is default style.
+                            // We have to get all possible entity type ids and append them to mapping.
+                            if (!fallbackStyleId) {
+                                try {
+                                    modelTree = (_b = (_a = this.cTileset) === null || _a === void 0 ? void 0 : _a.extensions) === null || _b === void 0 ? void 0 : _b.modelTree;
+                                    if (modelTree) {
+                                        entityTypeIds = this.getEntityTypeIdsFromModelTree(modelTree);
+                                        _loop_2 = function (i) {
+                                            var entityTypeId = entityTypeIds[i];
+                                            if (styleMapping.findIndex(function (x) { return x.EntityTypeID == entityTypeId; }) <= -1) {
+                                                styleMapping.push({
+                                                    EntityTypeID: entityTypeId,
+                                                    StyleID: null,
+                                                    style: null
+                                                });
+                                            }
+                                        };
+                                        for (i = 0; i < entityTypeIds.length; i++) {
+                                            _loop_2(i);
+                                        }
+                                    }
+                                }
+                                catch (e) {
+                                    console.log(e);
+                                }
+                            }
+                            i = 0;
+                            _c.label = 5;
+                        case 5:
+                            if (!(i < styleMapping.length)) return [3 /*break*/, 15];
+                            if (this.disposed) {
+                                return [3 /*break*/, 15];
+                            }
+                            styleMap = styleMapping[i];
+                            if (!!styleMap.style) return [3 /*break*/, 13];
+                            styleId = styleMap.StyleID;
+                            if (!!styleId) return [3 /*break*/, 9];
+                            _c.label = 6;
+                        case 6:
+                            _c.trys.push([6, 8, , 9]);
+                            return [4 /*yield*/, EntityType.Get(this.api, styleMap.EntityTypeID)];
+                        case 7:
+                            entityType = _c.sent();
+                            styleId = entityType === null || entityType === void 0 ? void 0 : entityType["DisplaySetting.ID"];
+                            return [3 /*break*/, 9];
+                        case 8:
+                            e_2 = _c.sent();
+                            console.error(e_2);
+                            return [3 /*break*/, 9];
+                        case 9:
+                            if (!styleId) return [3 /*break*/, 13];
+                            _c.label = 10;
+                        case 10:
+                            _c.trys.push([10, 12, , 13]);
+                            return [4 /*yield*/, Style.Get(this.api, styleId)];
+                        case 11:
+                            data = _c.sent();
+                            if (data) {
+                                styleMap.style = data;
+                                styleMap.StyleID = styleId;
+                            }
+                            return [3 /*break*/, 13];
+                        case 12:
+                            e_3 = _c.sent();
+                            console.error(e_3);
+                            return [3 /*break*/, 13];
+                        case 13:
+                            if (styleMap.EntityTypeID && styleMap.style) {
+                                this.styleMappingsLoaded[styleMap.EntityTypeID] = true;
+                                this.processTilesetFeatureCheckQueue();
+                                this.processQueue();
+                            }
+                            _c.label = 14;
+                        case 14:
+                            i++;
+                            return [3 /*break*/, 5];
+                        case 15:
+                            this.styleMappingLoaded = true;
+                            if (!!this.disposed) return [3 /*break*/, 17];
+                            return [4 /*yield*/, this.processTilesetFeatureCheckQueue()];
+                        case 16:
+                            _c.sent();
+                            this.processQueue();
+                            _c.label = 17;
+                        case 17: return [2 /*return*/];
+                    }
+                });
+            });
+        };
+        CadStyler.prototype.getEntityTypeIdsFromModelTree = function (modelTree) {
+            var entityTypeIds = [];
+            this.digEntityTypeIdsFromModelTreeBranch(modelTree, entityTypeIds);
+            return entityTypeIds;
+        };
+        CadStyler.prototype.digEntityTypeIdsFromModelTreeBranch = function (branch, arr) {
+            if (branch) {
+                // Does not yet include this entity type id.
+                if (branch.typeId && !arr.includes(branch.typeId)) {
+                    arr.push(branch.typeId);
+                }
+                if (branch.children) {
+                    for (var i = 0; i < branch.children.length; i++) {
+                        var child = branch.children[i];
+                        this.digEntityTypeIdsFromModelTreeBranch(child, arr);
+                    }
+                }
+            }
+        };
+        CadStyler.prototype.processTilesetFeatureCheckQueue = function () {
+            return __awaiter(this, void 0, void 0, function () {
+                var BATCH_CHECK_SIZE;
+                var _this = this;
+                return __generator(this, function (_a) {
+                    BATCH_CHECK_SIZE = 1000;
+                    return [2 /*return*/, new Promise(function (res) {
+                            clearInterval(_this.queueCheckInterval);
+                            _this.queueCheckInterval = setInterval(function () {
+                                if (_this.disposed) {
+                                    clearInterval(_this.queueCheckInterval);
+                                    res();
+                                    return;
+                                }
+                                // Construct batch for loaded styles.
+                                var batch = [];
+                                if (_this.styleMappingLoaded) {
+                                    batch = _this.recordCheckQueue.splice(0, BATCH_CHECK_SIZE);
+                                }
+                                else {
+                                    for (var i = 0; i < _this.recordCheckQueue.length; i++) {
+                                        var hash = _this.recordCheckQueue[i];
+                                        var entity = _this.loadedEntities[hash];
+                                        if (entity) {
+                                            var entityTypeId = entity.entityTypeId;
+                                            if (entityTypeId) {
+                                                if (_this.styleMappingsLoaded[entityTypeId] == true) {
+                                                    batch.push(hash);
+                                                }
+                                            }
+                                        }
+                                        if (batch.length >= BATCH_CHECK_SIZE) {
+                                            break;
+                                        }
+                                    }
+                                    var _loop_3 = function (i) {
+                                        var hash = batch[i];
+                                        var index = _this.recordCheckQueue.findIndex(function (x) { return x == hash; });
+                                        if (index > -1) {
+                                            _this.recordCheckQueue.splice(index, 1);
+                                        }
+                                    };
+                                    for (var i = 0; i < batch.length; i++) {
+                                        _loop_3(i);
+                                    }
+                                }
+                                if (batch.length) {
+                                    for (var i = 0; i < batch.length; i++) {
+                                        var item = batch[i];
+                                        var entity = _this.loadedEntities[item];
+                                        if (entity) {
+                                            _this.queueTilesetFeatureStyle(entity);
+                                        }
+                                    }
+                                }
+                                else {
+                                    clearInterval(_this.queueCheckInterval);
+                                    res();
+                                }
+                            }, 50);
+                        })];
+                });
+            });
+        };
+        CadStyler.prototype.queueTilesetFeatureStyle = function (entity) {
+            if (this.styleMappingLoaded || this.styleMappingsLoaded[entity.entityTypeId] == true) {
+                var needsData = this.getTilesetFeatureNeedsFullData(entity.entityId, entity.entityTypeId);
+                if (needsData) {
+                    if (this.recordLoadQueue.findIndex(function (x) { return x == entity.entityId; })) {
+                        this.recordLoadQueue.push(entity.entityId);
+                    }
+                }
+                else {
+                    this.styleTilesetFeature(entity);
+                }
+            }
+            else {
+                this.recordCheckQueue.push(entity.entityId);
+            }
+        };
+        CadStyler.prototype.styleTilesetFeature = function (entity) {
+            this.styleTilesetFeatureFullData(entity, null);
+        };
+        CadStyler.prototype.styleTilesetFeatureFullData = function (entity, data) {
+            var _a;
+            var style = this.getTilesetFeatureStyle(entity.entityId, entity.entityTypeId);
+            if (!style) {
+                return;
+            }
+            var bColor = (((_a = style.modelStyle) === null || _a === void 0 ? void 0 : _a.fillColor) ? Calculator.GetValue(style.modelStyle.fillColor, data, []) : null);
+            if (bColor != null) {
+                var cColor = colorToCColor$1(bColor);
+                var visual = entity.visuals.length > 0 ? entity.visuals[0] : null;
+                if (visual && visual instanceof Cesium3DTileFeature) {
+                    visual.color = cColor;
+                }
+            }
+        };
+        CadStyler.prototype.getTilesetFeatureStyle = function (entityId, entityTypeId) {
+            var _a, _b, _c;
+            // Locate what style is applicable to the feature.
+            var style = null;
+            if (entityTypeId) {
+                style = (_a = this.styleMapping.find(function (x) { return x.EntityTypeID == entityTypeId; })) === null || _a === void 0 ? void 0 : _a.style;
+            }
+            if (!style) {
+                style = this.fallbackStyle;
+            }
+            if (!style) {
+                return null;
+            }
+            if (!((_c = (_b = style.Settings) === null || _b === void 0 ? void 0 : _b.modelStyle) === null || _c === void 0 ? void 0 : _c.customize)) {
+                return null;
+            }
+            return style.Settings;
+        };
+        CadStyler.prototype.getTilesetFeatureNeedsFullData = function (entityId, entityTypeId) {
+            var _a;
+            var style = this.getTilesetFeatureStyle(entityId, entityTypeId);
+            if (!style) {
+                return false;
+            }
+            var fill = (_a = style === null || style === void 0 ? void 0 : style.modelStyle) === null || _a === void 0 ? void 0 : _a.fillColor;
+            if (!fill || fill.length <= 0) {
+                return false;
+            }
+            return fill[0].type != 0;
+        };
+        return CadStyler;
+    }());
+    TilesetRenderEngine.CadStyler = CadStyler;
+})(TilesetRenderEngine || (TilesetRenderEngine = {}));
+
+var TilesetCadRenderManager;
+(function (TilesetCadRenderManager) {
+    var Manager = /** @class */ (function () {
+        function Manager(viewer, visualsManager, api, item) {
+            this.disposed = false;
+            this.cTileset = null;
+            this.styler = null;
+            this.viewer = viewer;
+            this.api = api;
+            this.item = item;
+            this.visualsManager = visualsManager;
+        }
+        Object.defineProperty(Manager.prototype, "Disposed", {
+            get: function () {
+                return this.disposed;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Manager.prototype.Init = function () {
+            var _a;
+            return __awaiter(this, void 0, void 0, function () {
+                var tilesetId, tileset, cTileset;
+                var _this = this;
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0:
+                            tilesetId = (_a = this.item.tileset) === null || _a === void 0 ? void 0 : _a.TilesetID;
+                            if (!tilesetId) {
+                                return [2 /*return*/];
+                            }
+                            return [4 /*yield*/, Tileset.Get(this.api, tilesetId)];
+                        case 1:
+                            tileset = _b.sent();
+                            if (!tileset) {
+                                return [2 /*return*/];
+                            }
+                            cTileset = this.cTileset = TilesetRenderEngine.Render({
+                                api: this.api,
+                                tileset: tileset,
+                                viewer: this.viewer
+                            });
+                            cTileset.readyPromise.then(function () {
+                                _this.onCTilesetLoad();
+                            });
+                            cTileset.tileLoad.addEventListener(function (tile) {
+                                _this.mapCTile(tile);
+                            });
+                            this.styler = new TilesetRenderEngine.CadStyler(this.api, this.cTileset, this.item.styleId, this.item.StyleMapping);
+                            return [2 /*return*/];
+                    }
+                });
+            });
+        };
+        Manager.prototype.onCTilesetLoad = function () {
+            if (this.disposed) {
+                return;
+            }
+            if (this.item.FlyTo) {
+                this.viewer.zoomTo(this.cTileset, new HeadingPitchRange(0.0, -0.5, this.cTileset.boundingSphere.radius / 4.0));
+            }
+        };
+        Manager.prototype.mapCTile = function (tile) {
+            var content = tile.content;
+            for (var i = 0; i < content.featuresLength; i++) {
+                var feature = content.getFeature(i);
+                var rego = this.mapTilesetFeature(feature);
+                if (rego === null || rego === void 0 ? void 0 : rego.entityId) {
+                    this.styler.QueueEntities([rego]);
+                }
+            }
+        };
+        Manager.prototype.mapTilesetFeature = function (feature) {
+            var _a, _b, _c;
+            var version = (_c = (_b = (_a = feature === null || feature === void 0 ? void 0 : feature.tileset) === null || _a === void 0 ? void 0 : _a.extensions) === null || _b === void 0 ? void 0 : _b.modelTree) === null || _c === void 0 ? void 0 : _c.version;
+            if (!version) {
+                version = 1;
+            }
+            var rego = {
+                entityId: null,
+                entityTypeId: null,
+                menuItemId: this.item.id,
+                priority: 0,
+                visuals: [feature]
+            };
+            if (version == 1) {
+                var pathStr = feature.getProperty("BrucePath");
+                if (pathStr != undefined) {
+                    var path = pathStr.split("|");
+                    var entityTypeId = this.getEntityTypeByPath(path);
+                    rego.entityTypeId = entityTypeId;
+                    rego.entityId = path[path.length - 1];
+                }
+            }
+            else if (version == 2) {
+                var geomId = +feature.getProperty("GeomId");
+                if (geomId != null && (!!geomId || geomId == 0)) {
+                    var meta = this.getMetaByGeomId(geomId, feature.tileset);
+                    if (meta) {
+                        rego.entityId = meta.id;
+                        rego.entityTypeId = meta.typeId;
+                    }
+                }
+            }
+            else {
+                console.log("Unhandled tileset tree version = " + version);
+            }
+            if (rego === null || rego === void 0 ? void 0 : rego.entityId) {
+                this.visualsManager.Add(rego);
+                return rego;
+            }
+            return null;
+        };
+        Manager.prototype.getMetaByGeomId = function (geomId, tileset) {
+            var _a;
+            var modelTree = (_a = tileset === null || tileset === void 0 ? void 0 : tileset.extensions) === null || _a === void 0 ? void 0 : _a.modelTree;
+            return this.digMetaByGeomId(geomId, modelTree, []);
+        };
+        Manager.prototype.digMetaByGeomId = function (geomId, branch, path) {
+            path = [].concat(path);
+            path.push(branch.id);
+            if (branch.geomId == geomId) {
+                return { id: path[path.length - 1], typeId: branch.typeId };
+            }
+            else if (branch.children) {
+                for (var i = 0; i < branch.children.length; i++) {
+                    var meta = this.digMetaByGeomId(geomId, branch.children[i], path);
+                    if (meta) {
+                        return meta;
+                    }
+                }
+            }
+            return null;
+        };
+        Manager.prototype.getEntityTypeByPath = function (path) {
+            var _a, _b;
+            var modelTree = (_b = (_a = this.cTileset) === null || _a === void 0 ? void 0 : _a.extensions) === null || _b === void 0 ? void 0 : _b.modelTree;
+            if (modelTree) {
+                var data = this.digModelTreeByPath(modelTree, path);
+                if (data) {
+                    return data.typeId;
+                }
+            }
+            return null;
+        };
+        Manager.prototype.digModelTreeByPath = function (branch, path) {
+            // Dereference.
+            path = JSON.parse(JSON.stringify(path));
+            if (path.length <= 0) {
+                return null;
+            }
+            var pathTop = path.splice(0, 1)[0];
+            if (pathTop != branch.id) {
+                return null;
+            }
+            else if (path.length == 0 && pathTop == branch.id) {
+                return branch;
+            }
+            else if (branch.children) {
+                for (var i = 0; i < branch.children.length; i++) {
+                    var foundPath = this.digModelTreeByPath(branch.children[i], path);
+                    if (foundPath) {
+                        return foundPath;
+                    }
+                }
+            }
+            return null;
+        };
+        Manager.prototype.Dispose = function () {
+            if (this.disposed) {
+                return;
+            }
+            this.disposed = true;
+            if (this.cTileset) {
+                this.cTileset.show = false;
+            }
+            this.styler.Dispose();
+            this.visualsManager.RemoveByMenuItemId(this.item.id);
+        };
+        return Manager;
+    }());
+    TilesetCadRenderManager.Manager = Manager;
+})(TilesetCadRenderManager || (TilesetCadRenderManager = {}));
+
+var MenuItemManager = /** @class */ (function () {
+    function MenuItemManager(viewer, visualsRegister) {
+        this.items = [];
+        this.viewer = viewer;
+        this.visualsRegister = visualsRegister;
+    }
+    MenuItemManager.prototype.RenderItem = function (api, item) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var rItem, i, childId;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        rItem = {
+                            id: (_a = item.id) !== null && _a !== void 0 ? _a : ObjectUtils.UId(),
+                            childIds: [],
+                            item: item,
+                            renderManager: null,
+                            type: item.Type
+                        };
+                        switch (item.Type) {
+                            case MenuItem.EType.Entities:
+                                rItem.renderManager = new EntitiesRenderManager.Manager(this.viewer, this.visualsRegister, api, item);
+                                break;
+                            case MenuItem.EType.EntitiesLoaded:
+                                rItem.renderManager = new EntitiesLoadedRenderManager.Manager(this.viewer, this.visualsRegister, api, item);
+                                break;
+                            case MenuItem.EType.EntitiesIds:
+                                rItem.renderManager = new EntitiesIdsRenderManager.Manager(this.viewer, this.visualsRegister, api, item);
+                                break;
+                            case MenuItem.EType.Entity:
+                                rItem.renderManager = new EntityRenderManager.Manager(this.viewer, this.visualsRegister, api, item);
+                            case MenuItem.EType.CadTileset:
+                                rItem.renderManager = new TilesetCadRenderManager.Manager(this.viewer, this.visualsRegister, api, item);
+                                break;
+                            case MenuItem.EType.Osm:
+                                // TODO;
+                                break;
+                            case MenuItem.EType.PointCloud:
+                                // TODO;
+                                break;
+                            case MenuItem.EType.EntityTileset:
+                                // TODO;
+                                break;
+                            case MenuItem.EType.Kml:
+                                // TODO;
+                                break;
+                            // Any "none" type can be ignored. These are just containers for other items.
+                            case MenuItem.EType.None:
+                            case "":
+                            case null:
+                                break;
+                            default:
+                                throw ("Menu item type is not implemented.");
+                        }
+                        if (!rItem.renderManager) return [3 /*break*/, 2];
+                        return [4 /*yield*/, rItem.renderManager.Init()];
+                    case 1:
+                        _b.sent();
+                        _b.label = 2;
+                    case 2:
+                        this.items.push(rItem);
+                        if (!item.Children) return [3 /*break*/, 6];
+                        i = 0;
+                        _b.label = 3;
+                    case 3:
+                        if (!(i < item.Children.length)) return [3 /*break*/, 6];
+                        return [4 /*yield*/, this.RenderItem(api, item.Children[i])];
+                    case 4:
+                        childId = _b.sent();
+                        rItem.childIds.push(childId);
+                        _b.label = 5;
+                    case 5:
+                        i++;
+                        return [3 /*break*/, 3];
+                    case 6: return [2 /*return*/, rItem.id];
+                }
+            });
+        });
+    };
+    MenuItemManager.prototype.RemoveItemById = function (id) {
+        return __awaiter(this, void 0, void 0, function () {
+            var item, _loop_1, this_1, i;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        item = this.items.find(function (x) { return x.id === id; });
+                        if (!item) return [3 /*break*/, 5];
+                        _loop_1 = function (i) {
+                            var child;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        child = this_1.items.find(function (x) { return x.id === item.childIds[i]; });
+                                        if (!child) return [3 /*break*/, 2];
+                                        return [4 /*yield*/, this_1.RemoveItemById(child.id)];
+                                    case 1:
+                                        _a.sent();
+                                        _a.label = 2;
+                                    case 2: return [2 /*return*/];
+                                }
+                            });
+                        };
+                        this_1 = this;
+                        i = 0;
+                        _a.label = 1;
+                    case 1:
+                        if (!(i < item.childIds.length)) return [3 /*break*/, 4];
+                        return [5 /*yield**/, _loop_1(i)];
+                    case 2:
+                        _a.sent();
+                        _a.label = 3;
+                    case 3:
+                        i++;
+                        return [3 /*break*/, 1];
+                    case 4:
+                        try {
+                            item.renderManager.Dispose();
+                        }
+                        catch (e) {
+                            console.error(e);
+                        }
+                        this.items = this.items.filter(function (x) { return x.id !== id; });
+                        _a.label = 5;
+                    case 5: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return MenuItemManager;
+}());
+
+var RenderHelper;
+(function (RenderHelper) {
+    function RenderEntities(manager, api, entityIds) {
+        return __awaiter(this, void 0, void 0, function () {
+            var item;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        item = {
+                            Caption: "Rendering Loaded Entities",
+                            Type: MenuItem.EType.EntitiesLoaded,
+                            id: ObjectUtils.UId(),
+                            Children: [],
+                            BruceEntity: {
+                                EntityIds: entityIds
+                            },
+                            CameraZoomSettings: [
+                                {
+                                    DisplayType: ZoomControl.EDisplayType.Model3D,
+                                    LODCategoryID: "glb",
+                                    LODLevel: 0,
+                                    MaxZoom: 100000,
+                                    MinZoom: 0,
+                                    StyleID: 0 // 0 = Attempt to get entity type's default.
+                                }
+                            ]
+                        };
+                        return [4 /*yield*/, manager.RenderItem(api, item)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    }
+    RenderHelper.RenderEntities = RenderEntities;
+    function RenderEntityTypes(manager, api, typeIds) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var groupItem, i, typeId, menuItem;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        groupItem = {
+                            Caption: "Rendering Entity Types",
+                            Type: MenuItem.EType.None,
+                            id: ObjectUtils.UId(),
+                            Children: []
+                        };
+                        for (i = 0; i < typeIds.length; i++) {
+                            typeId = typeIds[i];
+                            menuItem = MenuItem.CreateFromTypeId(typeId, 0);
+                            (_a = groupItem.Children) === null || _a === void 0 ? void 0 : _a.push(menuItem);
+                        }
+                        return [4 /*yield*/, manager.RenderItem(api, groupItem)];
+                    case 1: return [2 /*return*/, _b.sent()];
+                }
+            });
+        });
+    }
+    RenderHelper.RenderEntityTypes = RenderEntityTypes;
+    function RenderEntityFilter(viewer, api, filter) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                throw (new Error("Not implemented."));
+            });
+        });
+    }
+    RenderHelper.RenderEntityFilter = RenderEntityFilter;
+    function RenderBookmark(viewer, api, viewId, bookmarkId) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                throw (new Error("Not implemented."));
+            });
+        });
+    }
+    RenderHelper.RenderBookmark = RenderBookmark;
+    function RenderMenuItems(manager, api, menuItems) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var groupItem, i, menuItem;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        groupItem = {
+                            Caption: "Rendering Menu Items",
+                            Type: MenuItem.EType.None,
+                            id: ObjectUtils.UId(),
+                            Children: []
+                        };
+                        for (i = 0; i < menuItems.length; i++) {
+                            menuItem = menuItems[i];
+                            (_a = groupItem.Children) === null || _a === void 0 ? void 0 : _a.push(menuItem);
+                        }
+                        return [4 /*yield*/, manager.RenderItem(api, groupItem)];
+                    case 1: return [2 /*return*/, _b.sent()];
+                }
+            });
+        });
+    }
+    RenderHelper.RenderMenuItems = RenderMenuItems;
+    function RenderTileset(manager, api, tilesetId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var tileset, menuItem;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, Tileset.Get(api, tilesetId)];
+                    case 1:
+                        tileset = _a.sent();
+                        if (!(tileset.type == Tileset.EType.Cad)) return [3 /*break*/, 3];
+                        menuItem = {
+                            Caption: "Rendering Tileset",
+                            FlyTo: true,
+                            id: ObjectUtils.UId(),
+                            tileset: {
+                                TilesetID: tilesetId
+                            },
+                            Type: MenuItem.EType.CadTileset,
+                            styleId: 0,
+                            Children: []
+                        };
+                        return [4 /*yield*/, manager.RenderItem(api, menuItem)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                    case 3: throw (new Error("Tileset type not supported."));
+                }
+            });
+        });
+    }
+    RenderHelper.RenderTileset = RenderTileset;
+})(RenderHelper || (RenderHelper = {}));
+
+function removeEntity(viewer, visuals) {
+    unmarkEntity(visuals);
+    for (var i = 0; i < visuals.length; i++) {
+        var visual = visuals[i];
+        if (visual instanceof Entity) {
+            EntityRenderEngine.Remove(viewer, visual);
+        }
+        else if (visual instanceof Primitive) {
+            viewer.scene.primitives.remove(visual);
+        }
+        else if (visual instanceof Cesium3DTileFeature) {
+            visual.show = false;
+        }
+    }
+}
+function updateCEntityShow(viewer, visual, show) {
+    if (visual._parentEntity) {
+        updateCEntityShow(viewer, visual._parentEntity, show);
+    }
+    if (visual._siblingGraphics) {
+        for (var i = 0; i < visual._siblingGraphics.length; i++) {
+            var sibling = visual._siblingGraphics[i];
+            updateCEntityShow(viewer, sibling, show);
+        }
+    }
+    visual.show = show;
+}
+function updateEntityShow(viewer, visual, show) {
+    if (visual instanceof Entity) {
+        updateCEntityShow(viewer, visual, show);
+    }
+    else if (visual instanceof Primitive) {
+        visual.show = show;
+    }
+    else if (visual instanceof Cesium3DTileFeature) {
+        visual.show = show;
+    }
+}
+function updateEntity(viewer, entityRegos) {
+    var highestPriority = null;
+    for (var i = 0; i < entityRegos.length; i++) {
+        var rego = entityRegos[i];
+        if (highestPriority === null || rego.priority > highestPriority.priority) {
+            highestPriority = rego;
+        }
+    }
+    for (var i = 0; i < entityRegos.length; i++) {
+        var rego = entityRegos[i];
+        for (var j = 0; j < rego.visuals.length; j++) {
+            var visual = rego.visuals[j];
+            updateEntityShow(viewer, visual, rego === highestPriority);
+        }
+    }
+}
+function markEntity(register, rego, visuals) {
+    for (var i = 0; i < visuals.length; i++) {
+        var visual = visuals[i];
+        var vis = visual;
+        vis._register = register;
+        vis._rego = rego;
+        if (visual instanceof Entity) {
+            var visEnt = visual;
+            if (visEnt._parentEntity) {
+                markEntity(register, rego, [visEnt._parentEntity]);
+            }
+            if (visEnt._siblingGraphics) {
+                markEntity(register, rego, visEnt._siblingGraphics);
+            }
+        }
+    }
+}
+function unmarkEntity(visuals) {
+    for (var i = 0; i < visuals.length; i++) {
+        var visual = visuals[i];
+        var vis = visual;
+        vis._register = null;
+        if (visual instanceof Entity) {
+            var visEnt = visual;
+            if (visEnt._parentEntity) {
+                unmarkEntity([visEnt._parentEntity]);
+            }
+            if (visEnt._siblingGraphics) {
+                unmarkEntity(visEnt._siblingGraphics);
+            }
+        }
+    }
+}
+var VisualsRegister = /** @class */ (function () {
+    function VisualsRegister(viewer) {
+        this.id = ObjectUtils.UId();
+        this.rego = {};
+        this.viewer = viewer;
+    }
+    Object.defineProperty(VisualsRegister.prototype, "Id", {
+        get: function () {
+            return this.id;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    VisualsRegister.prototype.Add = function (rego) {
+        var _a;
+        this.Remove(rego.entityId, rego.menuItemId, false);
+        var entityId = rego.entityId;
+        var entityRegos = (_a = this.rego[entityId]) !== null && _a !== void 0 ? _a : [];
+        entityRegos.push(rego);
+        this.rego[entityId] = entityRegos;
+        markEntity(this, rego, rego.visuals);
+        updateEntity(this.viewer, this.rego[entityId]);
+    };
+    VisualsRegister.prototype.GetVisuals = function (entityId, menuItemId) {
+        var _a;
+        var entityRegos = this.rego[entityId];
+        if (!entityRegos) {
+            return [];
+        }
+        var visuals = (_a = entityRegos.find(function (r) { return r.menuItemId === menuItemId; })) === null || _a === void 0 ? void 0 : _a.visuals;
+        return visuals !== null && visuals !== void 0 ? visuals : [];
+    };
+    VisualsRegister.prototype.RemoveByEntityId = function (id) {
+        var entityRegos = this.rego[id];
+        if (!entityRegos) {
+            return;
+        }
+        for (var i = 0; i < entityRegos.length; i++) {
+            var rego = entityRegos[i];
+            removeEntity(this.viewer, rego.visuals);
+        }
+        this.rego[id] = [];
+        delete this.rego[id];
+    };
+    VisualsRegister.prototype.RemoveByMenuItemId = function (id) {
+        for (var entityId in this.rego) {
+            var entityRegos = this.rego[entityId];
+            if (entityRegos) {
+                var rego = entityRegos.find(function (r) { return r.menuItemId === id; });
+                if (!rego) {
+                    continue;
+                }
+                removeEntity(this.viewer, rego.visuals);
+                var doesInclude = this.rego[entityId].find(function (r) { return r.menuItemId === id; });
+                if (doesInclude) {
+                    this.rego[entityId] = entityRegos.filter(function (r) { return r.menuItemId !== id; });
+                    updateEntity(this.viewer, this.rego[entityId]);
+                }
+            }
+        }
+    };
+    VisualsRegister.prototype.Remove = function (entityId, menuItemId, _doUpdate) {
+        if (_doUpdate === void 0) { _doUpdate = true; }
+        var entityRegos = this.rego[entityId];
+        if (!entityRegos) {
+            return;
+        }
+        var rego = entityRegos.find(function (r) { return r.menuItemId === menuItemId; });
+        if (!rego) {
+            return;
+        }
+        for (var i = 0; i < rego.visuals.length; i++) {
+            var visual = rego.visuals[i];
+            if (visual instanceof Entity) {
+                this.viewer.entities.remove(visual);
+            }
+            else if (visual instanceof Primitive) {
+                this.viewer.scene.primitives.remove(visual);
+            }
+            else if (visual instanceof Cesium3DTileFeature) {
+                visual.show = false;
+            }
+        }
+        this.rego[entityId] = entityRegos.filter(function (r) { return r.menuItemId !== menuItemId; });
+        if (_doUpdate) {
+            updateEntity(this.viewer, this.rego[entityId]);
+        }
+    };
+    VisualsRegister.prototype.GetFromCursor = function (cursor) {
+        var _a;
+        var found = [];
+        var picked = this.viewer.scene.drillPick(new Cartesian2(cursor.x, cursor.y), 5);
+        for (var i = 0; i < picked.length; i++) {
+            var object = picked[i];
+            var entity = (object && object.id && object.id instanceof Entity ? object.id : object);
+            var visual = entity;
+            if (((_a = visual === null || visual === void 0 ? void 0 : visual._register) === null || _a === void 0 ? void 0 : _a.Id) == this.id) {
+                found.push(visual._rego);
+            }
+        }
+        return found;
+    };
+    return VisualsRegister;
+}());
+
+export { CesiumViewMonitor, ViewerUtils, MenuItemManager, EntityRenderEngine, RenderHelper, VisualsRegister, RenderManager, EntitiesIdsRenderManager, EntitiesLoadedRenderManager, EntitiesRenderManager, EntityRenderManager, TilesetCadRenderManager };
+//# sourceMappingURL=bruce-cesium.es5.js.map