bruce-cesium 0.0.1

package/dist/bruce-cesium.umd.js

@@ -0,0 +1,2766 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('bruce-models'), require('cesium')) :
+    typeof define === 'function' && define.amd ? define(['exports', 'bruce-models', 'cesium'], factory) :
+    (factory((global.bruceCesium = {}),global.bruceModels,global.Cesium));
+}(this, (function (exports,bruceModels,Cesium) { 'use strict';
+
+    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 Cesium.Cartesian2(x, y);
+            try {
+                var intersection = getAdjustedGroundIntersectionOfCameraRay(viewer, winPos);
+                if (intersection) {
+                    var point = Cesium.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 bruceModels.BruceEvent();
+            }
+            return this.updatedEvent;
+        };
+        CesiumViewMonitor.prototype.GetBounds = function () {
+            return this.bounds;
+        };
+        CesiumViewMonitor.prototype.GetTarget = function () {
+            return this.target;
+        };
+        CesiumViewMonitor.prototype.DoUpdate = function () {
+            this.tryEmitUpdate();
+        };
+        CesiumViewMonitor.prototype.Dispose = function () {
+            if (this.disposed) {
+                return;
+            }
+            this.disposed = true;
+            clearInterval(this.checkInterval);
+        };
+        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 = Cesium.Math.toDegrees(Math.max(viewRectRad.east, cameraPosition.longitude));
+                    viewRect.west = Cesium.Math.toDegrees(Math.min(viewRectRad.west, cameraPosition.longitude));
+                    viewRect.south = Cesium.Math.toDegrees(Math.min(viewRectRad.south, cameraPosition.latitude));
+                    viewRect.north = Cesium.Math.toDegrees(Math.max(viewRectRad.north, cameraPosition.latitude));
+                }
+                else {
+                    viewRect.east = cameraPosition.longitude;
+                    viewRect.west = cameraPosition.longitude;
+                    viewRect.south = cameraPosition.latitude;
+                    viewRect.north = cameraPosition.latitude;
+                }
+                center = {};
+                center.latitude = Cesium.Math.toDegrees(camera.positionCartographic.latitude);
+                center.longitude = Cesium.Math.toDegrees(camera.positionCartographic.longitude);
+            }
+            else {
+                // View area calculation.
+                var windowPosition = new Cesium.Cartesian2(this.viewer.container.clientWidth / 2, this.viewer.container.clientHeight / 2);
+                var intersection = getAdjustedGroundIntersectionOfCameraRay(this.viewer, windowPosition);
+                var point = null;
+                if (intersection) {
+                    point = Cesium.Cartographic.fromCartesian(intersection, this.viewer.scene.globe.ellipsoid);
+                }
+                if (point) {
+                    center = {};
+                    center.latitude = Cesium.Math.toDegrees(point.latitude);
+                    center.longitude = Cesium.Math.toDegrees(point.longitude);
+                    var viewRectRad = netScanViewForBoundaries(this.viewer);
+                    if (viewRectRad) {
+                        viewRect = {};
+                        viewRect.east = Cesium.Math.toDegrees(viewRectRad.east);
+                        viewRect.west = Cesium.Math.toDegrees(viewRectRad.west);
+                        viewRect.south = Cesium.Math.toDegrees(viewRectRad.south);
+                        viewRect.north = Cesium.Math.toDegrees(viewRectRad.north);
+                    }
+                }
+            }
+            // 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;
+    }());
+
+    (function (ViewerUtils) {
+        function InitViewer(container) {
+            if (container._cViewer) {
+                throw new Error("Container already has a viewer.");
+            }
+            var cViewer = new Cesium.Viewer(container, {
+                imageryProvider: new Cesium.ArcGisMapServerImageryProvider({
+                    url: "https://services.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer",
+                    enablePickFeatures: false
+                })
+            });
+            cViewer.cesiumWidget.screenSpaceEventHandler.removeInputAction(Cesium.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;
+    })(exports.ViewerUtils || (exports.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 = Cesium.Cartesian3.distance(positions[i], positions[i + 1]);
+                    if (length_1 + currentDistance >= distance) {
+                        var carto1 = Cesium.Cartographic.fromCartesian(positions[i]);
+                        var carto2 = Cesium.Cartographic.fromCartesian(positions[i + 1]);
+                        var geodesic = new Cesium.EllipsoidGeodesic(carto1, carto2, viewer.scene.globe.ellipsoid);
+                        var position = geodesic.interpolateUsingSurfaceDistance(distance - currentDistance);
+                        var height = (carto1.height + carto2.height) / 2;
+                        return Cesium.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 += Cesium.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 && bruceModels.Carto.ValidateCarto(entity.location)) {
+                var location_1 = entity.location;
+                return Cesium.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 = bruceModels.Geometry.ParsePoints(pointStr);
+                    var point = points.length > 0 ? points[0] : null;
+                    if (point && bruceModels.Carto.ValidateCarto(point)) {
+                        return Cesium.Cartesian3.fromDegrees(point.longitude, point.latitude, point.altitude);
+                    }
+                }
+                var lineStr = entity.geometry.LineString;
+                if (lineStr && typeof lineStr == "string") {
+                    var points = bruceModels.Geometry.ParsePoints(lineStr);
+                    if (points.length > 0) {
+                        var posses = points.map(function (x) { return Cesium.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 && bruceModels.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 == bruceModels.Geometry.EPolygonRingType.Boundaries; });
+                    if (boundary === null || boundary === void 0 ? void 0 : boundary.LinearRing) {
+                        var points = bruceModels.Geometry.ParsePoints(boundary.LinearRing);
+                        var point = bruceModels.Carto.GetCenter(points);
+                        if (point && bruceModels.Carto.ValidateCarto(point)) {
+                            return Cesium.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 && bruceModels.Carto.ValidateCarto(point)) {
+                    return Cesium.Cartesian3.fromDegrees(point.longitude, point.latitude, point.altitude);
+                }
+            }
+            return null;
+        }
+        EntityUtils.GetPos = GetPos;
+    })(EntityUtils || (EntityUtils = {}));
+
+    (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 = Cesium.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 = {}));
+    })(exports.RenderManager || (exports.RenderManager = {}));
+
+    function colorToCColor(color) {
+        return new Cesium.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 = +bruceModels.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 == Cesium.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: Cesium.HeightReference.RELATIVE_TO_GROUND,
+            posses: null
+        };
+        // Step 1. Try get using style.
+        var extrusion = getPolygonStyleExtrusion(pStyle, entity, tags, heightRef);
+        if (extrusion) {
+            if (heightRef == Cesium.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 Cesium.Cartographic.fromCartesian(x); });
+                points.forEach(function (point) {
+                    point.height = alt_1;
+                });
+                posses = points.map(function (x) { return Cesium.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 Cesium.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 = Cesium.HeightReference.NONE;
+            }
+        }
+        data.posses = posses;
+        return data;
+    }
+    function getHeightRef(style) {
+        var _a;
+        var heightRef = Cesium.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 = Cesium.HeightReference.NONE;
+        }
+        else if (altOptionId == 2) {
+            heightRef = Cesium.HeightReference.RELATIVE_TO_GROUND;
+        }
+        return heightRef;
+    }
+    function getZIndex(style, entity, tags) {
+        var zIndex = (style === null || style === void 0 ? void 0 : style.zIndex) ? +bruceModels.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*/, bruceModels.Style.Get(api, styleId)];
+                    case 1:
+                        style = _a.sent();
+                        _a.label = 2;
+                    case 2:
+                        if (!!style) return [3 /*break*/, 5];
+                        return [4 /*yield*/, bruceModels.EntityType.Get(api, entity.Bruce["EntityType.ID"])];
+                    case 3:
+                        type = _a.sent();
+                        if (!type["DisplaySetting.ID"]) return [3 /*break*/, 5];
+                        return [4 /*yield*/, bruceModels.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;
+    }
+    (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 = exports.RenderManager.Utils.DetermineZoomItem(params.viewer, entity, params.zoomControl);
+                                displayType = zoomItem === null || zoomItem === void 0 ? void 0 : zoomItem.DisplayType;
+                                if (!displayType) {
+                                    displayType = bruceModels.ZoomControl.EDisplayType.Hidden;
+                                }
+                                if (displayType != bruceModels.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 == bruceModels.ZoomControl.EDisplayType.Model3D) {
+                                            models.push(entity);
+                                        }
+                                        else if (displayType == bruceModels.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 ? bruceModels.Calculator.GetValue(style.color, entity, params.tags) : null;
+                var cColor = bColor ? colorToCColor(bColor) : Cesium.Color.RED;
+                var size = style.size ? bruceModels.Calculator.GetValue(style.size, entity, params.tags) : null;
+                if (size == null) {
+                    size = 30;
+                }
+                if (size <= 0) {
+                    return null;
+                }
+                var cEntity = new Cesium.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*/, bruceModels.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" ? bruceModels.Geometry.ParsePoints(line) : [];
+                if (!points || points.length < 2) {
+                    return null;
+                }
+                var isValid = true;
+                for (var i = 0; i < points.length; i++) {
+                    if (!bruceModels.Carto.ValidateCarto(points[i])) {
+                        isValid = false;
+                        break;
+                    }
+                }
+                if (!isValid) {
+                    return null;
+                }
+                var posses = points.map(function (x) { return Cesium.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 += Cesium.Cartesian3.distance(pos1, pos2);
+                        }
+                    }
+                    if (totalDistance < 0.001) {
+                        return null;
+                    }
+                }
+                var style = params.style;
+                var bColor = style.lineColor ? bruceModels.Calculator.GetValue(style.lineColor, entity, params.tags) : null;
+                var cColor = bColor ? colorToCColor(bColor) : Cesium.Color.RED;
+                var width = style.lineWidth ? bruceModels.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 Cesium.Entity({
+                    polyline: {
+                        positions: posses,
+                        material: cColor,
+                        width: width,
+                        classificationType: Cesium.ClassificationType.TERRAIN,
+                        arcType: Cesium.ArcType.GEODESIC,
+                        zIndex: getZIndex(style, entity, params.tags),
+                        clampToGround: heightRef == Cesium.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*/, bruceModels.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 = bruceModels.Calculator.GetValue(style.fillColor, entity, params.tags);
+                var cFillColor = bFillColor ? colorToCColor(bFillColor) : Cesium.Color.RED;
+                var bLineColor = bruceModels.Calculator.GetValue(style.lineColor, entity, params.tags);
+                var cLineColor = bLineColor ? colorToCColor(bLineColor) : Cesium.Color.RED;
+                var width = style.lineWidth ? bruceModels.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 == bruceModels.Geometry.EPolygonRingType.Boundaries; });
+                var points = bruceModels.Geometry.ParsePoints(outerRing === null || outerRing === void 0 ? void 0 : outerRing.LinearRing);
+                var posses = points.map(function (x) { return Cesium.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 == bruceModels.Geometry.EPolygonRingType.Hole; });
+                var holePosses = holeRings.map(function (x) {
+                    var points = bruceModels.Geometry.ParsePoints(x.LinearRing);
+                    return points.map(function (x) { return Cesium.Cartesian3.fromDegrees(x.longitude, x.latitude, x.altitude); });
+                });
+                var zIndex = getZIndex(style, entity, params.tags);
+                var cEntity = new Cesium.Entity({
+                    polygon: {
+                        hierarchy: new Cesium.PolygonHierarchy(posses, holePosses.map(function (x) { return new Cesium.PolygonHierarchy(x); })),
+                        material: cFillColor,
+                        extrudedHeight: extrusion.value,
+                        extrudedHeightReference: extrusion.exHeightRef,
+                        shadows: Cesium.ShadowMode.ENABLED,
+                        heightReference: heightRef,
+                        classificationType: Cesium.ClassificationType.BOTH,
+                        perPositionHeight: heightRef == Cesium.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 Cesium.Entity({
+                        polyline: new Cesium.PolylineGraphics({
+                            positions: posses_1,
+                            material: cLineColor,
+                            width: width,
+                            clampToGround: heightRef == Cesium.HeightReference.CLAMP_TO_GROUND,
+                            classificationType: Cesium.ClassificationType.TERRAIN,
+                            arcType: Cesium.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*/, bruceModels.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) ? +bruceModels.Calculator.GetValue(style === null || style === void 0 ? void 0 : style.scale, entity, params.tags) : null;
+                if (!styleScale) {
+                    styleScale = 1;
+                }
+                scale *= styleScale;
+                var hpr = new Cesium.HeadingPitchRoll(heading, pitch, roll);
+                var heightRef = getHeightRef(style);
+                var pos = EntityUtils.GetPos(params.viewer, entity);
+                if (heightRef == Cesium.HeightReference.CLAMP_TO_GROUND) {
+                    var carto = Cesium.Cartographic.fromCartesian(pos);
+                    pos = Cesium.Cartesian3.fromRadians(carto.longitude, carto.latitude, 0);
+                    heightRef = Cesium.HeightReference.RELATIVE_TO_GROUND;
+                }
+                var orientation = Cesium.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 = Cesium.ColorBlendMode.HIGHLIGHT;
+                    }
+                    if (blendMode == Cesium.ColorBlendMode.MIX) {
+                        blendAmount = style.fillColorBlendAmount;
+                        if (!blendAmount) {
+                            blendAmount = 0.5;
+                        }
+                    }
+                    var bColor = bruceModels.Calculator.GetValue(style.fillColor, entity, params.tags);
+                    if (bColor) {
+                        color = colorToCColor(bColor);
+                    }
+                }
+                var cEntity = new Cesium.Entity({
+                    model: {
+                        uri: params.lodUrl,
+                        heightReference: heightRef,
+                        scale: scale,
+                        shadows: Cesium.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*/, bruceModels.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 ? bruceModels.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*/, bruceModels.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*/, bruceModels.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: bruceModels.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 = {}));
+    })(exports.EntityRenderEngine || (exports.EntityRenderEngine = {}));
+
+    (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 bruceModels.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 bruceModels.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*/, bruceModels.Entity.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*/, exports.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;
+    })(exports.EntitiesRenderManager || (exports.EntitiesRenderManager = {}));
+
+    (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 bruceModels.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*/, exports.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;
+    })(exports.EntitiesLoadedRenderManager || (exports.EntitiesLoadedRenderManager = {}));
+
+    (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 bruceModels.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*/, bruceModels.Entity.GetListByIds(this.api, entityIds)];
+                            case 1:
+                                entities = _a.sent();
+                                return [4 /*yield*/, exports.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;
+    })(exports.EntitiesIdsRenderManager || (exports.EntitiesIdsRenderManager = {}));
+
+    (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 bruceModels.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*/, bruceModels.Entity.Get(this.api, id)];
+                            case 1:
+                                entity = _a.sent();
+                                return [4 /*yield*/, exports.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;
+    })(exports.EntityRenderManager || (exports.EntityRenderManager = {}));
+
+    function colorToCColor$1(color) {
+        return new Cesium.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 == bruceModels.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 = Cesium.Cartesian3.fromDegrees(point.longitude, point.latitude, point.altitude);
+                var hpr = Cesium.HeadingPitchRoll.fromDegrees(transform.heading, transform.pitch, transform.roll, new Cesium.HeadingPitchRoll());
+                root.transform = Cesium.Transforms.headingPitchRollToFixedFrame(pos, hpr);
+                var scale = +(transform === null || transform === void 0 ? void 0 : transform.scale);
+                if (!scale || scale <= 0) {
+                    scale = 0.000001;
+                }
+                var scaleMatrix = Cesium.Matrix4.fromScale(new Cesium.Cartesian3(scale, scale, scale), new Cesium.Matrix4());
+                root.transform = Cesium.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 == bruceModels.Tileset.EType.Cad) {
+                var cTileset_1 = new Cesium.Cesium3DTileset({
+                    url: bruceModels.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*/, bruceModels.Entity.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*/, bruceModels.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*/, bruceModels.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*/, bruceModels.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) ? bruceModels.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 Cesium.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 = {}));
+
+    (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*/, bruceModels.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 Cesium.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;
+    })(exports.TilesetCadRenderManager || (exports.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 : bruceModels.ObjectUtils.UId(),
+                                childIds: [],
+                                item: item,
+                                renderManager: null,
+                                type: item.Type
+                            };
+                            switch (item.Type) {
+                                case bruceModels.MenuItem.EType.Entities:
+                                    rItem.renderManager = new exports.EntitiesRenderManager.Manager(this.viewer, this.visualsRegister, api, item);
+                                    break;
+                                case bruceModels.MenuItem.EType.EntitiesLoaded:
+                                    rItem.renderManager = new exports.EntitiesLoadedRenderManager.Manager(this.viewer, this.visualsRegister, api, item);
+                                    break;
+                                case bruceModels.MenuItem.EType.EntitiesIds:
+                                    rItem.renderManager = new exports.EntitiesIdsRenderManager.Manager(this.viewer, this.visualsRegister, api, item);
+                                    break;
+                                case bruceModels.MenuItem.EType.Entity:
+                                    rItem.renderManager = new exports.EntityRenderManager.Manager(this.viewer, this.visualsRegister, api, item);
+                                case bruceModels.MenuItem.EType.CadTileset:
+                                    rItem.renderManager = new exports.TilesetCadRenderManager.Manager(this.viewer, this.visualsRegister, api, item);
+                                    break;
+                                case bruceModels.MenuItem.EType.Osm:
+                                    // TODO;
+                                    break;
+                                case bruceModels.MenuItem.EType.PointCloud:
+                                    // TODO;
+                                    break;
+                                case bruceModels.MenuItem.EType.EntityTileset:
+                                    // TODO;
+                                    break;
+                                case bruceModels.MenuItem.EType.Kml:
+                                    // TODO;
+                                    break;
+                                // Any "none" type can be ignored. These are just containers for other items.
+                                case bruceModels.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;
+    }());
+
+    (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: bruceModels.MenuItem.EType.EntitiesLoaded,
+                                id: bruceModels.ObjectUtils.UId(),
+                                Children: [],
+                                BruceEntity: {
+                                    EntityIds: entityIds
+                                },
+                                CameraZoomSettings: [
+                                    {
+                                        DisplayType: bruceModels.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: bruceModels.MenuItem.EType.None,
+                                id: bruceModels.ObjectUtils.UId(),
+                                Children: []
+                            };
+                            for (i = 0; i < typeIds.length; i++) {
+                                typeId = typeIds[i];
+                                menuItem = bruceModels.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: bruceModels.MenuItem.EType.None,
+                                id: bruceModels.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*/, bruceModels.Tileset.Get(api, tilesetId)];
+                        case 1:
+                            tileset = _a.sent();
+                            if (!(tileset.type == bruceModels.Tileset.EType.Cad)) return [3 /*break*/, 3];
+                            menuItem = {
+                                Caption: "Rendering Tileset",
+                                FlyTo: true,
+                                id: bruceModels.ObjectUtils.UId(),
+                                tileset: {
+                                    TilesetID: tilesetId
+                                },
+                                Type: bruceModels.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;
+    })(exports.RenderHelper || (exports.RenderHelper = {}));
+
+    function removeEntity(viewer, visuals) {
+        unmarkEntity(visuals);
+        for (var i = 0; i < visuals.length; i++) {
+            var visual = visuals[i];
+            if (visual instanceof Cesium.Entity) {
+                exports.EntityRenderEngine.Remove(viewer, visual);
+            }
+            else if (visual instanceof Cesium.Primitive) {
+                viewer.scene.primitives.remove(visual);
+            }
+            else if (visual instanceof Cesium.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 Cesium.Entity) {
+            updateCEntityShow(viewer, visual, show);
+        }
+        else if (visual instanceof Cesium.Primitive) {
+            visual.show = show;
+        }
+        else if (visual instanceof Cesium.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 Cesium.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 Cesium.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 = bruceModels.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 Cesium.Entity) {
+                    this.viewer.entities.remove(visual);
+                }
+                else if (visual instanceof Cesium.Primitive) {
+                    this.viewer.scene.primitives.remove(visual);
+                }
+                else if (visual instanceof Cesium.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 Cesium.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 Cesium.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;
+    }());
+
+    exports.CesiumViewMonitor = CesiumViewMonitor;
+    exports.MenuItemManager = MenuItemManager;
+    exports.VisualsRegister = VisualsRegister;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+})));
+//# sourceMappingURL=bruce-cesium.umd.js.map