bruce-cesium 1.0.3 → 1.0.5

package/dist/bruce-cesium.es5.js

@@ -1,5 +1,5 @@
-import { BruceEvent, Cartes, Carto, Geometry, ZoomControl, Style, EntityTag, Calculator, EntityLod, EntityType, ClientFile, DelayQueue, Entity as Entity$1, BatchedDataGetter, ObjectUtils, Tileset, EntityCoords, EntityFilterGetter, EntitySource, MenuItem, ProjectView, ProjectViewBookmark, ProjectViewTile, ProjectViewLegacyTile, ProgramKey, Camera } from 'bruce-models';
-import { Cartesian2, Cartographic, Math as Math$1, Entity, Primitive, Cesium3DTileFeature, Color, Cartesian3, HeightReference, HorizontalOrigin, VerticalOrigin, ClassificationType, ArcType, PolygonHierarchy, ShadowMode, PolylineGraphics, HeadingPitchRoll, Transforms, ColorBlendMode, Cesium3DTileColorBlendMode, HeadingPitchRange, OrthographicFrustum, JulianDate, createWorldTerrain, EllipsoidTerrainProvider, CesiumTerrainProvider, BingMapsImageryProvider, BingMapsStyle, MapboxImageryProvider, MapboxStyleImageryProvider, ArcGisMapServerImageryProvider, OpenStreetMapImageryProvider, GridImageryProvider, GeographicTilingScheme, ImageryLayer, UrlTemplateImageryProvider, TileMapServiceImageryProvider, IonImageryProvider, PolygonPipeline, Matrix4, Cesium3DTileStyle, Cesium3DTileset, IonResource, ColorMaterialProperty, Rectangle, Matrix3, EasingFunction, GeometryInstance, EllipsoidGeodesic, createOsmBuildings, KmlDataSource } from 'cesium';
+import { BruceEvent, Cartes, Carto, Geometry, ZoomControl, Style, EntityTag, Calculator, EntityLod, EntityType, ClientFile, DelayQueue, Entity as Entity$1, BatchedDataGetter, EntityRelationType, ObjectUtils, Tileset, EntityCoords, EntityFilterGetter, EntitySource, EntityRelation, MenuItem, ProjectView, ProjectViewBookmark, ProjectViewTile, ProjectViewLegacyTile, ProgramKey, Camera } from 'bruce-models';
+import { Cartesian2, Cartographic, Math as Math$1, Color, HeightReference, Cartesian3, Entity, HorizontalOrigin, VerticalOrigin, ClassificationType, ArcType, PolygonHierarchy, ShadowMode, PolylineGraphics, HeadingPitchRoll, Transforms, ColorBlendMode, Primitive, Cesium3DTileFeature, Cesium3DTileColorBlendMode, HeadingPitchRange, OrthographicFrustum, JulianDate, createWorldTerrain, EllipsoidTerrainProvider, CesiumTerrainProvider, BingMapsImageryProvider, BingMapsStyle, MapboxImageryProvider, MapboxStyleImageryProvider, ArcGisMapServerImageryProvider, OpenStreetMapImageryProvider, GridImageryProvider, GeographicTilingScheme, ImageryLayer, UrlTemplateImageryProvider, TileMapServiceImageryProvider, IonImageryProvider, Matrix4, Cesium3DTileStyle, Cesium3DTileset, IonResource, PolygonPipeline, EllipsoidGeodesic, sampleTerrainMostDetailed, ColorMaterialProperty, Rectangle, Matrix3, EasingFunction, GeometryInstance, CallbackProperty, createOsmBuildings, KmlDataSource } from 'cesium';
 
 var TIME_LAG = 300;
 var POSITION_CHECK_TIMER = 950;
@@ -401,6 +401,54 @@ var DrawingUtils;
         };
     }
     DrawingUtils.PointAcrossPolyline = PointAcrossPolyline;
+    /**
+     * Returns terrain height from current viewer's provider.
+     * On error or flat terrain, it will return 0.
+     * If an error occurred it will be attached to the result.
+     * @param pos3d
+     * @param viewer
+     * @returns
+     */
+    function GetTerrainHeight(params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var pos3d, viewer, sample, height, e_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        pos3d = params.pos3d, viewer = params.viewer;
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        if (viewer.scene.terrainProvider instanceof EllipsoidTerrainProvider) {
+                            return [2 /*return*/, {
+                                    height: 0
+                                }];
+                        }
+                        return [4 /*yield*/, sampleTerrainMostDetailed(viewer.scene.terrainProvider, [Cartographic.fromCartesian(pos3d)])];
+                    case 2:
+                        sample = _a.sent();
+                        height = (sample === null || sample === void 0 ? void 0 : sample.length) ? sample[0].height : null;
+                        if (isNaN(height)) {
+                            return [2 /*return*/, {
+                                    height: 0,
+                                    error: "NaN"
+                                }];
+                        }
+                        return [2 /*return*/, {
+                                height: height
+                            }];
+                    case 3:
+                        e_1 = _a.sent();
+                        return [2 /*return*/, {
+                                height: 0,
+                                error: e_1
+                            }];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    }
+    DrawingUtils.GetTerrainHeight = GetTerrainHeight;
 })(DrawingUtils || (DrawingUtils = {}));
 
 var MeasureUtils;
@@ -613,13 +661,27 @@ var EntityUtils;
     /**
      * Returns an entity's position.
      * This will attempt to calculate it from multiple sources of data.
-     * @param viewer
-     * @param entity
+     * @param params
      * @returns
      */
     function GetPos(params) {
-        var viewer = params.viewer, entity = params.entity;
-        function evaluate() {
+        var viewer = params.viewer, entity = params.entity, visualRegister = params.visualRegister;
+        function evaluateRendered() {
+            var rego = visualRegister ? visualRegister.GetRego({
+                entityId: entity.Bruce.ID,
+            }) : null;
+            if ((rego === null || rego === void 0 ? void 0 : rego.visual) instanceof Entity) {
+                var visual = rego.visual;
+                if (visual.position) {
+                    if (visual.position.getValue) {
+                        return visual.position.getValue(viewer.scene.lastRenderTime);
+                    }
+                    return visual.position;
+                }
+            }
+            return null;
+        }
+        function evaluateRecord() {
             if (entity.location && Carto.ValidateCarto(entity.location)) {
                 var location_1 = entity.location;
                 return Cartesian3.fromDegrees(EnsureNumber(location_1.longitude), EnsureNumber(location_1.latitude), EnsureNumber(location_1.altitude));
@@ -679,7 +741,11 @@ var EntityUtils;
                 }
             }
         }
-        var pos3d = evaluate();
+        var pos3d = evaluateRendered();
+        if (Cartes.ValidateCartes3(pos3d)) {
+            return pos3d;
+        }
+        pos3d = evaluateRecord();
         return Cartes.ValidateCartes3(pos3d) ? pos3d : null;
     }
     EntityUtils.GetPos = GetPos;
@@ -2203,6 +2269,446 @@ var EntitiesLoadedRenderManager;
     EntitiesLoadedRenderManager.Manager = Manager;
 })(EntitiesLoadedRenderManager || (EntitiesLoadedRenderManager = {}));
 
+/**
+ * Utility for rendering parabolas between two points on the map.
+ */
+var CesiumParabola = /** @class */ (function () {
+    function CesiumParabola(params) {
+        this.color = "white";
+        this.width = 2;
+        this.duration = 10;
+        this.heightDistanceRatio = 0.25;
+        this.viewer = params.viewer;
+        this.pos1 = params.pos1;
+        this.pos2 = params.pos2;
+        if (params.color) {
+            this.color = params.color;
+        }
+        if (!isNaN(params.width)) {
+            this.width = params.width;
+        }
+        if (!isNaN(params.duration)) {
+            this.duration = params.duration;
+        }
+        if (!isNaN(params.heightDistanceRatio)) {
+            this.heightDistanceRatio = params.heightDistanceRatio;
+        }
+    }
+    Object.defineProperty(CesiumParabola.prototype, "curPos1", {
+        get: function () {
+            return this.pos1 instanceof Function ? this.pos1() : this.pos1;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(CesiumParabola.prototype, "curPos2", {
+        get: function () {
+            return this.pos2 instanceof Function ? this.pos2() : this.pos2;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    CesiumParabola.prototype.Animate = function () {
+        var _this = this;
+        this.Dispose();
+        var p1 = this.curPos1;
+        var p2 = this.curPos2;
+        var retry = false;
+        if (!p1 || !p2 || !Cartes.ValidateCartes3(p1) || !Cartes.ValidateCartes3(p2)) {
+            retry = true;
+        }
+        var TOTAL_LENGTH = retry ? 0 : Cartesian3.distance(p1, p2);
+        if (TOTAL_LENGTH <= 0) {
+            retry = true;
+        }
+        if (retry) {
+            var retryTimeout_1 = setTimeout(function () {
+                _this.Animate();
+            }, 2000);
+            this.dispose = function () {
+                clearTimeout(retryTimeout_1);
+            };
+            return;
+        }
+        var TOTAL_POINTS = Math.max(50, Math.min(1000, TOTAL_LENGTH * 0.1));
+        var POINT_LENGTH = TOTAL_LENGTH / TOTAL_POINTS;
+        var RATE_PER_SECOND = 1000 / 40;
+        var SEC_DURATION = this.duration;
+        var HEIGHT_DISTANCE_RATIO = this.heightDistanceRatio;
+        var TICK_LENGTH_INC = SEC_DURATION == 0 ? TOTAL_LENGTH : TOTAL_POINTS / (RATE_PER_SECOND * SEC_DURATION);
+        var curPoints = [];
+        var curPoint = 0;
+        var parabola = new Entity({
+            polyline: {
+                positions: new CallbackProperty(function () {
+                    return curPoints;
+                }, false),
+                width: this.width,
+                material: Color.fromCssColorString(this.color)
+            }
+        });
+        this.viewer.entities.add(parabola);
+        var p1Entity = new Entity({
+            position: new CallbackProperty(function () {
+                return curPoints.length ? curPoints[0] : new Cartesian3();
+            }, false),
+            point: {
+                heightReference: HeightReference.NONE,
+                pixelSize: this.width * 1.3,
+                color: Color.fromCssColorString(this.color),
+                outlineColor: Color.WHITE,
+                outlineWidth: 2
+            }
+        });
+        var p2Entity = new Entity({
+            position: new CallbackProperty(function () {
+                return curPoints.length ? curPoints[curPoints.length - 1] : new Cartesian3();
+            }, false),
+            point: {
+                heightReference: HeightReference.NONE,
+                pixelSize: this.width * 1.3,
+                color: Color.fromCssColorString(this.color),
+                outlineColor: Color.WHITE,
+                outlineWidth: 2
+            }
+        });
+        this.viewer.entities.add(p1Entity);
+        this.viewer.entities.add(p2Entity);
+        p1Entity.parent = parabola;
+        p2Entity.parent = parabola;
+        var quadraticKey = null;
+        var quadratic = null;
+        var prepareQuadratic = function () {
+            var p1 = _this.curPos1;
+            var p2 = _this.curPos2;
+            if (!p1 || !p2 || !Cartes.ValidateCartes3(p1) || !Cartes.ValidateCartes3(p2)) {
+                return;
+            }
+            var height1 = Cartographic.fromCartesian(p1).height;
+            var height2 = Cartographic.fromCartesian(p2).height;
+            if (isNaN(height1) || isNaN(height2)) {
+                return;
+            }
+            var totalHeight = height2 + height1;
+            var curQuadraticKey = height1 + "-" + height2;
+            if (quadraticKey == curQuadraticKey) {
+                return;
+            }
+            var points2d = [
+                new Cartesian2(0, height1),
+                new Cartesian2(TOTAL_LENGTH, height2)
+            ];
+            var vertexHeight = 0;
+            // Flat line.
+            if (HEIGHT_DISTANCE_RATIO == 0) {
+                vertexHeight = totalHeight * 0.5;
+            }
+            else {
+                var largestHeight = Math.max(height1, height2);
+                vertexHeight = largestHeight + (TOTAL_LENGTH * HEIGHT_DISTANCE_RATIO);
+            }
+            points2d.push(new Cartesian2(TOTAL_LENGTH * 0.5, vertexHeight));
+            var calcQuadratic = function (points) {
+                // Swaps position of two rows in matrix.
+                function swapRows(matrix, rowAIndex, rowBIndex) {
+                    var rowAVal = matrix[rowAIndex];
+                    matrix[rowAIndex] = matrix[rowBIndex];
+                    matrix[rowBIndex] = rowAVal;
+                    return matrix;
+                }
+                // Zeros rowA at colIndex by subtracting a multiplied rowB from it.
+                function reduceMatrixRowByRow(matrix, zeroingIndex, parentIndex, colIndex) {
+                    var zeroRow = matrix[zeroingIndex];
+                    var parentRow = matrix[parentIndex];
+                    if (zeroRow[colIndex] == 0) {
+                        return matrix;
+                    }
+                    else if (parentRow[colIndex] == 0) {
+                        matrix = swapRows(matrix, parentIndex, zeroingIndex);
+                        return divideMatrixRow(matrix, parentIndex, colIndex);
+                    }
+                    // rowAIndex colIndex / rowBIndex colIndex = factor;
+                    var factor = zeroRow[colIndex] / parentRow[colIndex];
+                    for (var i = 0; i < zeroRow.length; i++) {
+                        if (i >= colIndex) {
+                            zeroRow[i] -= parentRow[i] * factor;
+                        }
+                    }
+                    return matrix;
+                }
+                // Makes a given row column equal 1 by diving while row by that column.
+                function divideMatrixRow(matrix, rowIndex, colIndex) {
+                    var row = matrix[rowIndex];
+                    var colValue = row[colIndex];
+                    for (var i = 0; i < row.length; i++) {
+                        if (i >= colIndex) {
+                            row[i] /= colValue;
+                        }
+                    }
+                    return matrix;
+                }
+                // Returns initial matrix for calculating a, b and c for quadratic formula from given points.
+                function matrixFromPoints(points) {
+                    var rows = [];
+                    var constructRow = function (point) {
+                        rows.push([
+                            -Math.pow(point.x, 2),
+                            point.x,
+                            1,
+                            point.y
+                        ]);
+                    };
+                    for (var i = 0; i < points.length; i++) {
+                        constructRow(points[i]);
+                    }
+                    return rows;
+                }
+                var initialMatrix = matrixFromPoints(points);
+                var step1Matrix = reduceMatrixRowByRow(initialMatrix, 1, 0, 0);
+                var step2Matrix = reduceMatrixRowByRow(step1Matrix, 2, 0, 0);
+                var step3Matrix = reduceMatrixRowByRow(step2Matrix, 2, 1, 1);
+                var step4Matrix = reduceMatrixRowByRow(step3Matrix, 0, 1, 1);
+                var step5Matrix = reduceMatrixRowByRow(step4Matrix, 0, 2, 2);
+                var step6Matrix = reduceMatrixRowByRow(step5Matrix, 1, 2, 2);
+                var a = step6Matrix[0][3];
+                var b = step6Matrix[1][3];
+                var c = step6Matrix[2][3];
+                return { a: a, b: b, c: c };
+            };
+            quadratic = calcQuadratic(points2d);
+        };
+        var getPosition = function (increment) {
+            if (!quadratic) {
+                return null;
+            }
+            var lengthAcross = POINT_LENGTH * increment;
+            if (lengthAcross > TOTAL_LENGTH) {
+                lengthAcross = TOTAL_LENGTH;
+            }
+            var getParabolaYFromX = function (x, quadLetters) {
+                var a = quadLetters.a;
+                var b = quadLetters.b;
+                var c = quadLetters.c;
+                return (-a * Math.pow(x, 2)) + (b * x) + c;
+            };
+            var pos3d = DrawingUtils.PointAcrossPolyline({
+                viewer: _this.viewer,
+                distance: lengthAcross,
+                posses: [p1, p2]
+            }).point;
+            var point = Cartographic.fromCartesian(pos3d);
+            var posHeight = getParabolaYFromX(lengthAcross, quadratic);
+            return Cartesian3.fromRadians(point.longitude, point.latitude, posHeight);
+        };
+        var updatePoints = function () {
+            var increment = Math.floor(curPoint);
+            var chips = curPoint - Math.floor(curPoint);
+            var posses = [];
+            posses.push(getPosition(0));
+            var addLast = increment >= TOTAL_POINTS;
+            var totalCycles = addLast ? increment + 1 : increment;
+            for (var i = 0; i < totalCycles; i++) {
+                posses.push(getPosition(i));
+            }
+            posses.push(getPosition(increment + chips));
+            if (posses.find(function (x) { return !x || !Cartes.ValidateCartes3(x); })) {
+                return;
+            }
+            curPoints = posses;
+        };
+        var doTick = function () {
+            if (curPoint >= TOTAL_POINTS) {
+                clearInterval(animateInterval);
+                return;
+            }
+            curPoint += TICK_LENGTH_INC;
+            prepareQuadratic();
+            updatePoints();
+        };
+        var animateInterval = setInterval(doTick, RATE_PER_SECOND);
+        this.dispose = function () {
+            clearInterval(animateInterval);
+            if (parabola && _this.viewer.entities.contains(parabola)) {
+                _this.viewer.entities.remove(parabola);
+            }
+            if (p1Entity && _this.viewer.entities.contains(p1Entity)) {
+                _this.viewer.entities.remove(p1Entity);
+            }
+            if (p2Entity && _this.viewer.entities.contains(p2Entity)) {
+                _this.viewer.entities.remove(p2Entity);
+            }
+        };
+        return {
+            parabola: parabola,
+            siblings: [
+                p1Entity,
+                p2Entity
+            ]
+        };
+    };
+    CesiumParabola.prototype.Dispose = function () {
+        var _a;
+        (_a = this.dispose) === null || _a === void 0 ? void 0 : _a.call(this);
+        this.dispose = null;
+    };
+    return CesiumParabola;
+}());
+
+function colorToCColor$1(color) {
+    return new Color(color.red ? color.red / 255 : 0, color.green ? color.green / 255 : 0, color.blue ? color.blue / 255 : 0, color.alpha);
+}
+var RelationRenderEngine;
+(function (RelationRenderEngine) {
+    function GetRenderGroupId(relation) {
+        return relation["Related.Entity.ID"] + "-" + relation["Principal.Entity.ID"] + "-" + relation["Relation.Type.ID"];
+    }
+    RelationRenderEngine.GetRenderGroupId = GetRenderGroupId;
+    function Render(params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var apiGetter, viewer, visualRegister, menuItemId, relations, api, rendered, i, relation, fromEntity, toEntity, dataEntity, _a, relationType, style, _b, cEntity;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        apiGetter = params.apiGetter, viewer = params.viewer, visualRegister = params.visualRegister, menuItemId = params.menuItemId, relations = params.relations;
+                        api = apiGetter.getApi(apiGetter.accountId);
+                        rendered = {};
+                        i = 0;
+                        _c.label = 1;
+                    case 1:
+                        if (!(i < relations.length)) return [3 /*break*/, 12];
+                        relation = relations[i];
+                        return [4 /*yield*/, Entity$1.Get({
+                                api: api,
+                                entityId: relation["Principal.Entity.ID"],
+                            })];
+                    case 2:
+                        fromEntity = (_c.sent()).entity;
+                        return [4 /*yield*/, Entity$1.Get({
+                                api: api,
+                                entityId: relation["Related.Entity.ID"],
+                            })];
+                    case 3:
+                        toEntity = (_c.sent()).entity;
+                        if (!relation["Data.Entity.ID"]) return [3 /*break*/, 5];
+                        return [4 /*yield*/, Entity$1.Get({
+                                api: api,
+                                entityId: relation["Data.Entity.ID"]
+                            })];
+                    case 4:
+                        _a = (_c.sent()).entity;
+                        return [3 /*break*/, 6];
+                    case 5:
+                        _a = null;
+                        _c.label = 6;
+                    case 6:
+                        dataEntity = _a;
+                        return [4 /*yield*/, EntityRelationType.Get({
+                                api: api,
+                                relationTypeId: relation["Relation.Type.ID"]
+                            })];
+                    case 7:
+                        relationType = (_c.sent()).relationType;
+                        if (!relationType.EntityDisplaySettingID) return [3 /*break*/, 9];
+                        return [4 /*yield*/, Style.Get({
+                                api: api,
+                                styleId: Number(relationType.EntityDisplaySettingID)
+                            })];
+                    case 8:
+                        _b = (_c.sent()).style;
+                        return [3 /*break*/, 10];
+                    case 9:
+                        _b = null;
+                        _c.label = 10;
+                    case 10:
+                        style = _b;
+                        cEntity = Parabola.Render({
+                            dataEntity: dataEntity,
+                            fromEntity: fromEntity,
+                            relation: relation,
+                            style: style,
+                            toEntity: toEntity,
+                            viewer: viewer,
+                            visualRegister: visualRegister
+                        });
+                        cEntity._renderGroup = GetRenderGroupId(relation);
+                        rendered[GetRenderGroupId(relation)] = cEntity;
+                        _c.label = 11;
+                    case 11:
+                        i++;
+                        return [3 /*break*/, 1];
+                    case 12: return [2 /*return*/, rendered];
+                }
+            });
+        });
+    }
+    RelationRenderEngine.Render = Render;
+    var Parabola;
+    (function (Parabola) {
+        function Render(params) {
+            var _a;
+            var style = (_a = params.style) === null || _a === void 0 ? void 0 : _a.Settings;
+            var entity = params.dataEntity;
+            var bColor = (style === null || style === void 0 ? void 0 : style.lineColor) ? Calculator.GetColor(style === null || style === void 0 ? void 0 : style.lineColor, entity, []) : null;
+            var cColor = bColor ? colorToCColor$1(bColor) : Color.WHITE;
+            var width = EnsureNumber((style === null || style === void 0 ? void 0 : style.lineWidth) ? Calculator.GetValue(style === null || style === void 0 ? void 0 : style.lineWidth, entity, []) : 4, 4);
+            if (width < 1) {
+                width = 1;
+            }
+            var duration = EnsureNumber((style === null || style === void 0 ? void 0 : style.duration) ? Calculator.GetValue(style === null || style === void 0 ? void 0 : style.duration, entity, []) : 2, 2);
+            var hDistanceRatio = EnsureNumber((style === null || style === void 0 ? void 0 : style.heightDistanceRatio) ? Calculator.GetValue(style === null || style === void 0 ? void 0 : style.heightDistanceRatio, entity, []) : 0.25, 0.25);
+            var fromPos = null;
+            var toPos = null;
+            var updatePosses = function () {
+                try {
+                    fromPos = EntityUtils.GetPos({
+                        entity: params.fromEntity,
+                        viewer: params.viewer,
+                        visualRegister: params.visualRegister
+                    });
+                    toPos = EntityUtils.GetPos({
+                        entity: params.toEntity,
+                        viewer: params.viewer,
+                        visualRegister: params.visualRegister
+                    });
+                }
+                catch (e) {
+                    console.error(e);
+                }
+            };
+            updatePosses();
+            var parabola = new CesiumParabola({
+                viewer: params.viewer,
+                pos1: function () { return fromPos; },
+                pos2: function () { return toPos; },
+                color: cColor.toString(),
+                width: width,
+                duration: duration,
+                heightDistanceRatio: hDistanceRatio
+            });
+            var cEntities = parabola.Animate();
+            var cEntity = cEntities.parabola;
+            cEntity._siblingGraphics = [];
+            for (var i = 0; i < cEntities.siblings.length; i++) {
+                var sibling = cEntities.siblings[i];
+                cEntity._siblingGraphics.push(sibling);
+            }
+            var updateInterval = setInterval(function () {
+                var _a;
+                if (!((_a = params.viewer) === null || _a === void 0 ? void 0 : _a.scene) ||
+                    params.viewer.isDestroyed() ||
+                    !params.viewer.entities.contains(cEntity)) {
+                    clearInterval(updateInterval);
+                    parabola.Dispose();
+                    return;
+                }
+                updatePosses();
+            }, 1000);
+            return cEntity;
+        }
+        Parabola.Render = Render;
+    })(Parabola = RelationRenderEngine.Parabola || (RelationRenderEngine.Parabola = {}));
+})(RelationRenderEngine || (RelationRenderEngine = {}));
+
 function removeEntity(viewer, visual) {
     unmarkEntity(visual);
     if (visual instanceof Entity) {
@@ -2708,8 +3214,8 @@ var VisualsRegister;
          * @returns
          */
         Register.prototype.RemoveRegos = function (params) {
-            var _a, _b;
-            var entityId = params.entityId, menuItemId = params.menuItemId, doUpdate = params.doUpdate;
+            var _a, _b, _c;
+            var entityId = params.entityId, menuItemId = params.menuItemId, doUpdate = params.doUpdate, relation = params.relation;
             if (doUpdate == null) {
                 doUpdate = true;
             }
@@ -2767,6 +3273,28 @@ var VisualsRegister;
                         return state_1.value;
                 }
             }
+            else if (relation) {
+                var relationKey_1 = RelationRenderEngine.GetRenderGroupId(relation);
+                for (var entityId_4 in this.rego) {
+                    var entityRegos = this.rego[entityId_4];
+                    if (entityRegos) {
+                        var rego = entityRegos.find(function (r) { return r.relation && RelationRenderEngine.GetRenderGroupId(r.relation) == relationKey_1; });
+                        if (!rego) {
+                            continue;
+                        }
+                        removeEntity(this.viewer, rego.visual);
+                        (_c = this.onUpdate) === null || _c === void 0 ? void 0 : _c.Trigger({
+                            type: EVisualUpdateType.Remove,
+                            entityId: rego.entityId,
+                            rego: rego
+                        });
+                        this.rego[entityId_4] = entityRegos.filter(function (r) { return r.menuItemId !== menuItemId; });
+                        if (doUpdate && menuItemId) {
+                            updateEntity(this.viewer, entityId_4, this);
+                        }
+                    }
+                }
+            }
         };
         /**
          * Returns an array of drilled visuals associated with this register.
@@ -3205,7 +3733,7 @@ var EntityRenderManager;
     EntityRenderManager.Manager = Manager;
 })(EntityRenderManager || (EntityRenderManager = {}));
 
-function colorToCColor$1(color) {
+function colorToCColor$2(color) {
     return new Color(color.red ? color.red / 255 : 0, color.green ? color.green / 255 : 0, color.blue ? color.blue / 255 : 0, color.alpha);
 }
 /**
@@ -3834,7 +4362,7 @@ var TilesetRenderEngine;
             }
             var bColor = ((_a = style.modelStyle) === null || _a === void 0 ? void 0 : _a.fillColor) ? Calculator.GetColor(style.modelStyle.fillColor, data, []) : null;
             if (bColor != null) {
-                var cColor = colorToCColor$1(bColor);
+                var cColor = colorToCColor$2(bColor);
                 var visual = entity.visual;
                 if (visual && visual instanceof Cesium3DTileFeature) {
                     visual.color = cColor;
@@ -5038,6 +5566,163 @@ var TilesetArbRenderManager;
     TilesetArbRenderManager.Manager = Manager;
 })(TilesetArbRenderManager || (TilesetArbRenderManager = {}));
 
+var RelationsRenderManager;
+(function (RelationsRenderManager) {
+    var Manager = /** @class */ (function () {
+        function Manager(params) {
+            this.disposed = false;
+            var apiGetter = params.apiGetter, item = params.item, register = params.register, viewer = params.viewer;
+            this.apiGetter = apiGetter;
+            this.item = item;
+            this.register = register;
+            this.viewer = viewer;
+        }
+        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 drawn, api, BATCH_SIZE, drawBatch, i, entityId, relations, _loop_1, this_1, j;
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0:
+                            drawn = [];
+                            api = this.apiGetter.getApi(this.apiGetter.accountId);
+                            BATCH_SIZE = 5;
+                            drawBatch = [];
+                            i = 0;
+                            _b.label = 1;
+                        case 1:
+                            if (!(i < this.item.BruceEntity.EntityIds.length)) return [3 /*break*/, 4];
+                            entityId = this.item.BruceEntity.EntityIds[i];
+                            return [4 /*yield*/, EntityRelation.GetList({
+                                    api: api,
+                                    entityId: entityId,
+                                    filter: {
+                                        oneWayOnly: false,
+                                        loadEntityData: false
+                                    }
+                                })];
+                        case 2:
+                            relations = (_b.sent()).relations;
+                            _loop_1 = function (j) {
+                                var relation = relations[j];
+                                if (((_a = this_1.item.relationTypeIds) === null || _a === void 0 ? void 0 : _a.length) && !this_1.item.relationTypeIds.includes(relation["Relation.Type.ID"])) {
+                                    return "continue";
+                                }
+                                var key = RelationRenderEngine.GetRenderGroupId(relation);
+                                if (!drawn.find(function (x) { return x == key; })) {
+                                    drawn.push(key);
+                                    drawBatch.push(relation);
+                                    if (drawBatch.length >= BATCH_SIZE) {
+                                        this_1.onGetterUpdate(drawBatch);
+                                        drawBatch = [];
+                                    }
+                                }
+                            };
+                            this_1 = this;
+                            for (j = 0; j < relations.length; j++) {
+                                _loop_1(j);
+                            }
+                            _b.label = 3;
+                        case 3:
+                            i++;
+                            return [3 /*break*/, 1];
+                        case 4:
+                            if (drawBatch === null || drawBatch === void 0 ? void 0 : drawBatch.length) {
+                                this.onGetterUpdate(drawBatch);
+                            }
+                            return [2 /*return*/];
+                    }
+                });
+            });
+        };
+        Manager.prototype.Dispose = function () {
+            if (this.disposed) {
+                return;
+            }
+            this.disposed = true;
+            this.register.RemoveRegos({
+                menuItemId: this.item.id
+            });
+        };
+        Manager.prototype.ReRender = function (entityIds) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    return [2 /*return*/];
+                });
+            });
+        };
+        Manager.prototype.onGetterUpdate = function (relations) {
+            var _a, _b;
+            return __awaiter(this, void 0, void 0, function () {
+                var cEntities, i, relation, key, cEntity, visual, e_1;
+                return __generator(this, function (_c) {
+                    switch (_c.label) {
+                        case 0:
+                            _c.trys.push([0, 2, , 3]);
+                            if (this.disposed || this.viewer.isDestroyed()) {
+                                return [2 /*return*/];
+                            }
+                            return [4 /*yield*/, RelationRenderEngine.Render({
+                                    apiGetter: this.apiGetter,
+                                    menuItemId: this.item.id,
+                                    relations: relations,
+                                    viewer: this.viewer,
+                                    visualRegister: this.register
+                                })];
+                        case 1:
+                            cEntities = _c.sent();
+                            for (i = 0; i < relations.length; i++) {
+                                relation = relations[i];
+                                key = RelationRenderEngine.GetRenderGroupId(relation);
+                                cEntity = cEntities[key];
+                                if (cEntity) {
+                                    visual = (_a = this.register.GetRego({
+                                        entityId: key,
+                                        menuItemId: this.item.id
+                                    })) === null || _a === void 0 ? void 0 : _a.visual;
+                                    if (!visual || visual != cEntity) {
+                                        this.register.AddRego({
+                                            rego: {
+                                                entityId: (_b = relation["Data.Entity.ID"]) !== null && _b !== void 0 ? _b : ObjectUtils.UId(),
+                                                menuItemId: this.item.id,
+                                                relation: relation,
+                                                visual: cEntity,
+                                                priority: 0,
+                                                accountId: this.apiGetter.accountId
+                                            }
+                                        });
+                                    }
+                                }
+                                else {
+                                    this.register.RemoveRegos({
+                                        entityId: relation["Data.Entity.ID"],
+                                        relation: relation,
+                                        menuItemId: this.item.id
+                                    });
+                                }
+                            }
+                            return [3 /*break*/, 3];
+                        case 2:
+                            e_1 = _c.sent();
+                            console.error(e_1);
+                            return [3 /*break*/, 3];
+                        case 3: return [2 /*return*/];
+                    }
+                });
+            });
+        };
+        return Manager;
+    }());
+    RelationsRenderManager.Manager = Manager;
+})(RelationsRenderManager || (RelationsRenderManager = {}));
+
 /**
  * Utility to keep track of enabled menu items within a Cesium viewer.
  */
@@ -5195,6 +5880,14 @@ var MenuItemManager;
                                         register: this.visualsRegister
                                     });
                                     break;
+                                case MenuItem.EType.Relations:
+                                    rItem.renderManager = new RelationsRenderManager.Manager({
+                                        apiGetter: params.apiGetter,
+                                        item: params.item,
+                                        register: this.visualsRegister,
+                                        viewer: this.viewer
+                                    });
+                                    break;
                                 // Any "none" type can be ignored. These are just containers for other items.
                                 case MenuItem.EType.None:
                                     break;
@@ -7094,5 +7787,5 @@ var ViewUtils;
     ViewUtils.GatherTerrainTile = GatherTerrainTile;
 })(ViewUtils || (ViewUtils = {}));
 
-export { CesiumViewMonitor, ViewerUtils, MenuItemManager, EntityRenderEngine, MenuItemCreator, VisualsRegister, RenderManager, EntitiesIdsRenderManager, EntitiesLoadedRenderManager, EntitiesRenderManager, EntityRenderManager, TilesetCadRenderManager, ViewRenderEngine, TileRenderEngine, TilesetRenderEngine, SharedGetters, ViewUtils, DrawingUtils, MeasureUtils, EntityUtils };
+export { CesiumViewMonitor, ViewerUtils, MenuItemManager, EntityRenderEngine, MenuItemCreator, VisualsRegister, RenderManager, EntitiesIdsRenderManager, EntitiesLoadedRenderManager, EntitiesRenderManager, EntityRenderManager, TilesetCadRenderManager, ViewRenderEngine, TileRenderEngine, TilesetRenderEngine, SharedGetters, ViewUtils, DrawingUtils, MeasureUtils, EntityUtils, CesiumParabola };
 //# sourceMappingURL=bruce-cesium.es5.js.map