bruce-cesium 0.5.3 → 0.5.4

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, TilesetExtMapTiles, ProgramKey, Camera, MathUtils } from 'bruce-models';
-import { Cartesian2, Cartographic, Math as Math$1, Cartesian3, Color, HeightReference, Entity, HorizontalOrigin, VerticalOrigin, ClassificationType, ArcType, PolygonHierarchy, ShadowMode, PolylineGraphics, HeadingPitchRoll, Transforms, ColorBlendMode, Primitive, Cesium3DTileFeature, HeadingPitchRange, OrthographicFrustum, Matrix4, Cesium3DTileset, createWorldTerrain, EllipsoidTerrainProvider, CesiumTerrainProvider, BingMapsImageryProvider, BingMapsStyle, MapboxImageryProvider, MapboxStyleImageryProvider, ArcGisMapServerImageryProvider, OpenStreetMapImageryProvider, GridImageryProvider, GeographicTilingScheme, ImageryLayer, UrlTemplateImageryProvider, TileMapServiceImageryProvider, IonImageryProvider, EllipsoidGeodesic, createOsmBuildings, Cesium3DTileStyle, Rectangle } from 'cesium';
+import { Cartesian2, Cartographic, Math as Math$1, Color, HeightReference, Cartesian3, Entity, HorizontalOrigin, VerticalOrigin, ClassificationType, ArcType, PolygonHierarchy, ShadowMode, PolylineGraphics, HeadingPitchRoll, Transforms, ColorBlendMode, Primitive, Cesium3DTileFeature, HeadingPitchRange, OrthographicFrustum, createWorldTerrain, EllipsoidTerrainProvider, CesiumTerrainProvider, BingMapsImageryProvider, BingMapsStyle, MapboxImageryProvider, MapboxStyleImageryProvider, ArcGisMapServerImageryProvider, OpenStreetMapImageryProvider, GridImageryProvider, GeographicTilingScheme, ImageryLayer, UrlTemplateImageryProvider, TileMapServiceImageryProvider, IonImageryProvider, Matrix4, Cesium3DTileset, EllipsoidGeodesic, ColorMaterialProperty, Rectangle, Matrix3, EasingFunction, GeometryInstance, JulianDate, createOsmBuildings, Cesium3DTileStyle } from 'cesium';
 
 var TIME_LAG = 300;
 var POSITION_CHECK_TIMER = 950;
@@ -435,6 +435,65 @@ function traverseEntity(cEntity, arr) {
     }
     arr.push(cEntity);
 }
+var ORG_OPACITY_KEY = "_org_opacity_";
+function getColor(viewer, material) {
+    var _a;
+    var color;
+    if (material instanceof Color) {
+        color = material;
+    }
+    else if ((_a = material) === null || _a === void 0 ? void 0 : _a.color) {
+        var anyCol = material.color;
+        color = anyCol.getValue ? anyCol.getValue(viewer.scene.lastRenderTime) : anyCol;
+    }
+    return color;
+}
+function applyOpacityToColor(viewer, opacity, material) {
+    var color = getColor(viewer, material);
+    if (color) {
+        color.alpha = opacity;
+    }
+    return color;
+}
+function applyOpacityToGraphic(viewer, entity, graphicKey, opacity) {
+    var color = applyOpacityToColor(viewer, opacity, entity[graphicKey].material);
+    if (color) {
+        entity[graphicKey].material = new ColorMaterialProperty(color);
+    }
+}
+function revertAppliedEntityOpacity(viewer, entity) {
+    function processKey(graphicKey) {
+        if (entity[graphicKey]) {
+            var orgOpacity = entity[graphicKey][ORG_OPACITY_KEY];
+            if (orgOpacity != null) {
+                applyOpacityToGraphic(viewer, entity, graphicKey, orgOpacity);
+                entity[graphicKey][ORG_OPACITY_KEY] = null;
+            }
+        }
+    }
+    processKey("polygon");
+    processKey("polyline");
+    processKey("point");
+    processKey("ellipse");
+    processKey("model");
+}
+function applyOpacityToEntity(viewer, opacity, entity) {
+    function processKey(graphicKey) {
+        var _a;
+        if (entity[graphicKey]) {
+            var orgOpacity = entity[graphicKey][ORG_OPACITY_KEY];
+            if (orgOpacity == null) {
+                entity[graphicKey][ORG_OPACITY_KEY] = (_a = getColor(viewer, entity[graphicKey].material)) === null || _a === void 0 ? void 0 : _a.alpha;
+            }
+            applyOpacityToGraphic(viewer, entity, graphicKey, opacity);
+        }
+    }
+    processKey("polygon");
+    processKey("polyline");
+    processKey("point");
+    processKey("ellipse");
+    processKey("model");
+}
 var EntityUtils;
 (function (EntityUtils) {
     /**
@@ -517,6 +576,115 @@ var EntityUtils;
         return [entity];
     }
     EntityUtils.GatherEntity = GatherEntity;
+    /**
+     * Looks at given entities with least amount of movement.
+     * @param viewer
+     * @param entities
+     */
+    function LookAtEntities(viewer, entities) {
+        var _a = [Rectangle, Cartographic, Cartesian3, Matrix3, Matrix4, EasingFunction], C3 = _a[2], M4 = _a[4];
+        var cutoffDistance = 2000;
+        var hoverHeight = 2000;
+        var duration = 0.5;
+        var centers = function (p) {
+            var PM = p.modelMatrix;
+            var instances = (function (i) { return (i instanceof GeometryInstance ? [i] : i); })(p.geometryInstances);
+            return instances.map(function (g) {
+                var _M = M4.multiply(PM, g.modelMatrix, new M4);
+                var G = g.geometry;
+                var _p = G.attributes.position;
+                var b = G.boundingSphere;
+                return [b.center, b.radius];
+            });
+        };
+        var currentTime = JulianDate.now();
+        var target = entities.flatMap(function (e) {
+            var _a;
+            if (e instanceof Cartesian3) {
+                return [[e, 0]];
+            }
+            if (e instanceof Entity) {
+                return [[(_a = e.position) === null || _a === void 0 ? void 0 : _a.getValue(currentTime), 0]];
+            }
+            if (e instanceof Primitive) {
+                return centers(e);
+            }
+            if (e instanceof Cesium3DTileFeature) {
+                var s = e.tileset.boundingSphere;
+                return [[s.center, s.radius]];
+            }
+        });
+        var bounds = function (list) {
+            var min = list[0][0];
+            var max = min;
+            for (var _i = 0, list_1 = list; _i < list_1.length; _i++) {
+                var _a = list_1[_i], p_1 = _a[0], r = _a[1];
+                var pMin = C3.subtract(p_1, new C3(r), new C3);
+                var pMax = C3.add(p_1, new C3(r), new C3);
+                min = C3.minimumByComponent(pMin, min, new C3);
+                max = C3.maximumByComponent(pMax, max, new C3);
+            }
+            var c = C3.multiplyByScalar(C3.add(max, min, new C3), 0.5, new C3);
+            return c;
+        };
+        var center = bounds(target);
+        var orient = function (p) {
+            var d = C3.subtract(center, p, new C3);
+            var dir = C3.normalize(d, new C3);
+            var up = viewer.scene.globe.ellipsoid.geodeticSurfaceNormal(center);
+            return [p, dir, up];
+        };
+        var shorten = function (v, l) {
+            var c = l / C3.magnitude(v);
+            return C3.multiplyByScalar(v, c, new C3);
+        };
+        var camera = viewer.camera;
+        var _b = orient(camera.position), p = _b[0], direction = _b[1], up = _b[2];
+        var orientation = { direction: direction, up: up };
+        camera.flyTo({
+            destination: p,
+            orientation: orientation,
+            duration: duration,
+            complete: function () {
+                if (C3.distance(p, center) > cutoffDistance) {
+                    var d = C3.subtract(p, center, new C3);
+                    d = shorten(d, cutoffDistance);
+                    var h = C3.multiplyByScalar(C3.normalize(up, new C3), hoverHeight, new C3);
+                    d = C3.add(d, h, new C3);
+                    d = shorten(d, cutoffDistance);
+                    d = C3.add(d, center, new C3);
+                    var _a = orient(d), direction_1 = _a[1], u = _a[2];
+                    camera.flyTo({
+                        destination: d,
+                        orientation: { direction: direction_1, up: u }
+                    });
+                }
+            }
+        });
+    }
+    EntityUtils.LookAtEntities = LookAtEntities;
+    /**
+     * Sets opacity of given entity.
+     * Opacity will be multiplied by original opacity.
+     * Setting opacity puts original opacity into a temporary storage which can be reverted into.
+     * @param viewer
+     * @param entity
+     * @param opacity
+     */
+    function SetOpacity(viewer, entity, opacity) {
+        applyOpacityToEntity(viewer, opacity, entity);
+    }
+    EntityUtils.SetOpacity = SetOpacity;
+    /**
+     * Reverts opacity of given entity to original opacity.
+     * If opacity was not updated using "SetOpacity" then nothing will happen.
+     * @param viewer
+     * @param entity
+     */
+    function RevertOpacity(viewer, entity) {
+        revertAppliedEntityOpacity(viewer, entity);
+    }
+    EntityUtils.RevertOpacity = RevertOpacity;
 })(EntityUtils || (EntityUtils = {}));
 
 var RenderManager;