@cesium/engine 11.0.0 → 12.0.0

package/Source/DataSources/PointVisualizer.js

@@ -56,7 +56,7 @@ function PointVisualizer(entityCluster, entityCollection) {
 
   entityCollection.collectionChanged.addEventListener(
     PointVisualizer.prototype._onCollectionChanged,
-    this
+    this,
   );
 
   this._cluster = entityCluster;
@@ -90,7 +90,7 @@ PointVisualizer.prototype.update = function (time) {
     const heightReference = Property.getValueOrDefault(
       pointGraphics._heightReference,
       time,
-      HeightReference.NONE
+      HeightReference.NONE,
     );
     let show =
       entity.isShowing &&
@@ -101,7 +101,7 @@ PointVisualizer.prototype.update = function (time) {
       position = Property.getValueOrUndefined(
         entity._position,
         time,
-        positionScratch
+        positionScratch,
       );
       show = defined(position);
     }
@@ -155,49 +155,49 @@ PointVisualizer.prototype.update = function (time) {
       pointPrimitive.scaleByDistance = Property.getValueOrUndefined(
         pointGraphics._scaleByDistance,
         time,
-        scaleByDistanceScratch
+        scaleByDistanceScratch,
       );
       pointPrimitive.translucencyByDistance = Property.getValueOrUndefined(
         pointGraphics._translucencyByDistance,
         time,
-        translucencyByDistanceScratch
+        translucencyByDistanceScratch,
       );
       pointPrimitive.color = Property.getValueOrDefault(
         pointGraphics._color,
         time,
         defaultColor,
-        colorScratch
+        colorScratch,
       );
       pointPrimitive.outlineColor = Property.getValueOrDefault(
         pointGraphics._outlineColor,
         time,
         defaultOutlineColor,
-        outlineColorScratch
+        outlineColorScratch,
       );
       pointPrimitive.outlineWidth = Property.getValueOrDefault(
         pointGraphics._outlineWidth,
         time,
-        defaultOutlineWidth
+        defaultOutlineWidth,
       );
       pointPrimitive.pixelSize = Property.getValueOrDefault(
         pointGraphics._pixelSize,
         time,
-        defaultPixelSize
+        defaultPixelSize,
       );
       pointPrimitive.distanceDisplayCondition = Property.getValueOrUndefined(
         pointGraphics._distanceDisplayCondition,
         time,
-        distanceDisplayConditionScratch
+        distanceDisplayConditionScratch,
       );
       pointPrimitive.disableDepthTestDistance = Property.getValueOrDefault(
         pointGraphics._disableDepthTestDistance,
         time,
-        defaultDisableDepthTestDistance
+        defaultDisableDepthTestDistance,
       );
       pointPrimitive.splitDirection = Property.getValueOrDefault(
         pointGraphics._splitDirection,
         time,
-        defaultSplitDirection
+        defaultSplitDirection,
       );
     } else if (defined(billboard)) {
       billboard.show = true;
@@ -205,27 +205,27 @@ PointVisualizer.prototype.update = function (time) {
       billboard.scaleByDistance = Property.getValueOrUndefined(
         pointGraphics._scaleByDistance,
         time,
-        scaleByDistanceScratch
+        scaleByDistanceScratch,
       );
       billboard.translucencyByDistance = Property.getValueOrUndefined(
         pointGraphics._translucencyByDistance,
         time,
-        translucencyByDistanceScratch
+        translucencyByDistanceScratch,
       );
       billboard.distanceDisplayCondition = Property.getValueOrUndefined(
         pointGraphics._distanceDisplayCondition,
         time,
-        distanceDisplayConditionScratch
+        distanceDisplayConditionScratch,
       );
       billboard.disableDepthTestDistance = Property.getValueOrDefault(
         pointGraphics._disableDepthTestDistance,
         time,
-        defaultDisableDepthTestDistance
+        defaultDisableDepthTestDistance,
       );
       billboard.splitDirection = Property.getValueOrDefault(
         pointGraphics._splitDirection,
         time,
-        defaultSplitDirection
+        defaultSplitDirection,
       );
       billboard.heightReference = heightReference;
 
@@ -233,20 +233,20 @@ PointVisualizer.prototype.update = function (time) {
         pointGraphics._color,
         time,
         defaultColor,
-        colorScratch
+        colorScratch,
       );
       const newOutlineColor = Property.getValueOrDefault(
         pointGraphics._outlineColor,
         time,
         defaultOutlineColor,
-        outlineColorScratch
+        outlineColorScratch,
       );
       const newOutlineWidth = Math.round(
         Property.getValueOrDefault(
           pointGraphics._outlineWidth,
           time,
-          defaultOutlineWidth
-        )
+          defaultOutlineWidth,
+        ),
       );
       let newPixelSize = Math.max(
         1,
@@ -254,9 +254,9 @@ PointVisualizer.prototype.update = function (time) {
           Property.getValueOrDefault(
             pointGraphics._pixelSize,
             time,
-            defaultPixelSize
-          )
-        )
+            defaultPixelSize,
+          ),
+        ),
       );
 
       if (newOutlineWidth > 0) {
@@ -300,8 +300,8 @@ PointVisualizer.prototype.update = function (time) {
             cssColor,
             cssOutlineColor,
             newOutlineWidth,
-            newPixelSize
-          )
+            newPixelSize,
+          ),
         );
       }
 
@@ -345,7 +345,7 @@ PointVisualizer.prototype.getBoundingSphere = function (entity, result) {
   if (defined(item.pointPrimitive)) {
     result.center = Cartesian3.clone(
       item.pointPrimitive.position,
-      result.center
+      result.center,
     );
   } else {
     const billboard = item.billboard;
@@ -374,7 +374,7 @@ PointVisualizer.prototype.isDestroyed = function () {
 PointVisualizer.prototype.destroy = function () {
   this._entityCollection.collectionChanged.removeEventListener(
     PointVisualizer.prototype._onCollectionChanged,
-    this
+    this,
   );
   const entities = this._entityCollection.values;
   for (let i = 0; i < entities.length; i++) {
@@ -387,7 +387,7 @@ PointVisualizer.prototype._onCollectionChanged = function (
   entityCollection,
   added,
   removed,
-  changed
+  changed,
 ) {
   let i;
   let entity;

package/Source/DataSources/PolygonGeometryUpdater.js

@@ -79,7 +79,7 @@ function PolygonGeometryUpdater(entity, scene) {
 
 if (defined(Object.create)) {
   PolygonGeometryUpdater.prototype = Object.create(
-    GroundGeometryUpdater.prototype
+    GroundGeometryUpdater.prototype,
   );
   PolygonGeometryUpdater.prototype.constructor = PolygonGeometryUpdater;
 }
@@ -98,7 +98,7 @@ PolygonGeometryUpdater.prototype.createFillGeometryInstance = function (time) {
 
   if (!this._fillEnabled) {
     throw new DeveloperError(
-      "This instance does not represent a filled geometry."
+      "This instance does not represent a filled geometry.",
     );
   }
   //>>includeEnd('debug');
@@ -112,11 +112,12 @@ PolygonGeometryUpdater.prototype.createFillGeometryInstance = function (time) {
       isAvailable &&
         entity.isShowing &&
         this._showProperty.getValue(time) &&
-        this._fillProperty.getValue(time)
-    ),
-    distanceDisplayCondition: DistanceDisplayConditionGeometryInstanceAttribute.fromDistanceDisplayCondition(
-      this._distanceDisplayConditionProperty.getValue(time)
+        this._fillProperty.getValue(time),
     ),
+    distanceDisplayCondition:
+      DistanceDisplayConditionGeometryInstanceAttribute.fromDistanceDisplayCondition(
+        this._distanceDisplayConditionProperty.getValue(time),
+      ),
     offset: undefined,
     color: undefined,
   };
@@ -140,8 +141,8 @@ PolygonGeometryUpdater.prototype.createFillGeometryInstance = function (time) {
         this._terrainOffsetProperty,
         time,
         defaultOffset,
-        offsetScratch
-      )
+        offsetScratch,
+      ),
     );
   }
 
@@ -168,14 +169,14 @@ PolygonGeometryUpdater.prototype.createFillGeometryInstance = function (time) {
  * @exception {DeveloperError} This instance does not represent an outlined geometry.
  */
 PolygonGeometryUpdater.prototype.createOutlineGeometryInstance = function (
-  time
+  time,
 ) {
   //>>includeStart('debug', pragmas.debug);
   Check.defined("time", time);
 
   if (!this._outlineEnabled) {
     throw new DeveloperError(
-      "This instance does not represent an outlined geometry."
+      "This instance does not represent an outlined geometry.",
     );
   }
   //>>includeEnd('debug');
@@ -187,23 +188,23 @@ PolygonGeometryUpdater.prototype.createOutlineGeometryInstance = function (
     this._outlineColorProperty,
     time,
     Color.BLACK,
-    scratchColor
-  );
-  const distanceDisplayCondition = this._distanceDisplayConditionProperty.getValue(
-    time
+    scratchColor,
   );
+  const distanceDisplayCondition =
+    this._distanceDisplayConditionProperty.getValue(time);
 
   const attributes = {
     show: new ShowGeometryInstanceAttribute(
       isAvailable &&
         entity.isShowing &&
         this._showProperty.getValue(time) &&
-        this._showOutlineProperty.getValue(time)
+        this._showOutlineProperty.getValue(time),
     ),
     color: ColorGeometryInstanceAttribute.fromColor(outlineColor),
-    distanceDisplayCondition: DistanceDisplayConditionGeometryInstanceAttribute.fromDistanceDisplayCondition(
-      distanceDisplayCondition
-    ),
+    distanceDisplayCondition:
+      DistanceDisplayConditionGeometryInstanceAttribute.fromDistanceDisplayCondition(
+        distanceDisplayCondition,
+      ),
     offset: undefined,
   };
 
@@ -213,8 +214,8 @@ PolygonGeometryUpdater.prototype.createOutlineGeometryInstance = function (
         this._terrainOffsetProperty,
         time,
         defaultOffset,
-        offsetScratch
-      )
+        offsetScratch,
+      ),
     );
   }
 
@@ -234,7 +235,7 @@ PolygonGeometryUpdater.prototype.createOutlineGeometryInstance = function (
 PolygonGeometryUpdater.prototype._computeCenter = function (time, result) {
   const hierarchy = Property.getValueOrUndefined(
     this._entity.polygon.hierarchy,
-    time
+    time,
   );
   if (!defined(hierarchy)) {
     return;
@@ -248,7 +249,7 @@ PolygonGeometryUpdater.prototype._computeCenter = function (time, result) {
   const tangentPlane = EllipsoidTangentPlane.fromPoints(positions, ellipsoid);
   const positions2D = tangentPlane.projectPointsOntoPlane(
     positions,
-    scratch2DPositions
+    scratch2DPositions,
   );
 
   const length = positions2D.length;
@@ -283,7 +284,7 @@ PolygonGeometryUpdater.prototype._isOnTerrain = function (entity, polygon) {
   const onTerrain = GroundGeometryUpdater.prototype._isOnTerrain.call(
     this,
     entity,
-    polygon
+    polygon,
   );
   const perPositionHeightProperty = polygon.perPositionHeight;
   const perPositionHeightEnabled =
@@ -316,7 +317,7 @@ PolygonGeometryUpdater.prototype._isDynamic = function (entity, polygon) {
 
 PolygonGeometryUpdater.prototype._setStaticOptions = function (
   entity,
-  polygon
+  polygon,
 ) {
   const isColorMaterial =
     this._materialProperty instanceof ColorMaterialProperty;
@@ -329,31 +330,31 @@ PolygonGeometryUpdater.prototype._setStaticOptions = function (
   const hierarchyValue = polygon.hierarchy.getValue(Iso8601.MINIMUM_VALUE);
   let heightValue = Property.getValueOrUndefined(
     polygon.height,
-    Iso8601.MINIMUM_VALUE
+    Iso8601.MINIMUM_VALUE,
   );
   const heightReferenceValue = Property.getValueOrDefault(
     polygon.heightReference,
     Iso8601.MINIMUM_VALUE,
-    HeightReference.NONE
+    HeightReference.NONE,
   );
   let extrudedHeightValue = Property.getValueOrUndefined(
     polygon.extrudedHeight,
-    Iso8601.MINIMUM_VALUE
+    Iso8601.MINIMUM_VALUE,
   );
   const extrudedHeightReferenceValue = Property.getValueOrDefault(
     polygon.extrudedHeightReference,
     Iso8601.MINIMUM_VALUE,
-    HeightReference.NONE
+    HeightReference.NONE,
   );
   const perPositionHeightValue = Property.getValueOrDefault(
     polygon.perPositionHeight,
     Iso8601.MINIMUM_VALUE,
-    false
+    false,
   );
 
   heightValue = GroundGeometryUpdater.getGeometryHeight(
     heightValue,
-    heightReferenceValue
+    heightReferenceValue,
   );
 
   let offsetAttribute;
@@ -377,56 +378,57 @@ PolygonGeometryUpdater.prototype._setStaticOptions = function (
       heightValue,
       heightReferenceValue,
       extrudedHeightValue,
-      extrudedHeightReferenceValue
+      extrudedHeightReferenceValue,
     );
   }
 
   options.polygonHierarchy = hierarchyValue;
   options.granularity = Property.getValueOrUndefined(
     polygon.granularity,
-    Iso8601.MINIMUM_VALUE
+    Iso8601.MINIMUM_VALUE,
   );
   options.stRotation = Property.getValueOrUndefined(
     polygon.stRotation,
-    Iso8601.MINIMUM_VALUE
+    Iso8601.MINIMUM_VALUE,
   );
   options.perPositionHeight = perPositionHeightValue;
   options.closeTop = Property.getValueOrDefault(
     polygon.closeTop,
     Iso8601.MINIMUM_VALUE,
-    true
+    true,
   );
   options.closeBottom = Property.getValueOrDefault(
     polygon.closeBottom,
     Iso8601.MINIMUM_VALUE,
-    true
+    true,
   );
   options.offsetAttribute = offsetAttribute;
   options.height = heightValue;
   options.arcType = Property.getValueOrDefault(
     polygon.arcType,
     Iso8601.MINIMUM_VALUE,
-    ArcType.GEODESIC
+    ArcType.GEODESIC,
   );
   options.textureCoordinates = Property.getValueOrUndefined(
     polygon.textureCoordinates,
-    Iso8601.MINIMUM_VALUE
+    Iso8601.MINIMUM_VALUE,
   );
 
   extrudedHeightValue = GroundGeometryUpdater.getGeometryExtrudedHeight(
     extrudedHeightValue,
-    extrudedHeightReferenceValue
+    extrudedHeightReferenceValue,
   );
   if (extrudedHeightValue === GroundGeometryUpdater.CLAMP_TO_GROUND) {
     const rectangle = PolygonGeometry.computeRectangleFromPositions(
       options.polygonHierarchy.positions,
       options.ellipsoid,
       options.arcType,
-      scratchRectangle
+      scratchRectangle,
     );
-    extrudedHeightValue = ApproximateTerrainHeights.getMinimumMaximumHeights(
-      rectangle
-    ).minimumTerrainHeight;
+    extrudedHeightValue =
+      ApproximateTerrainHeights.getMinimumMaximumHeights(
+        rectangle,
+      ).minimumTerrainHeight;
   }
 
   options.extrudedHeight = extrudedHeightValue;
@@ -451,27 +453,28 @@ PolygonGeometryUpdater.DynamicGeometryUpdater = DyanmicPolygonGeometryUpdater;
 function DyanmicPolygonGeometryUpdater(
   geometryUpdater,
   primitives,
-  groundPrimitives
+  groundPrimitives,
 ) {
   DynamicGeometryUpdater.call(
     this,
     geometryUpdater,
     primitives,
-    groundPrimitives
+    groundPrimitives,
   );
 }
 
 if (defined(Object.create)) {
   DyanmicPolygonGeometryUpdater.prototype = Object.create(
-    DynamicGeometryUpdater.prototype
+    DynamicGeometryUpdater.prototype,
   );
-  DyanmicPolygonGeometryUpdater.prototype.constructor = DyanmicPolygonGeometryUpdater;
+  DyanmicPolygonGeometryUpdater.prototype.constructor =
+    DyanmicPolygonGeometryUpdater;
 }
 
 DyanmicPolygonGeometryUpdater.prototype._isHidden = function (
   entity,
   polygon,
-  time
+  time,
 ) {
   return (
     !defined(this._options.polygonHierarchy) ||
@@ -482,38 +485,38 @@ DyanmicPolygonGeometryUpdater.prototype._isHidden = function (
 DyanmicPolygonGeometryUpdater.prototype._setOptions = function (
   entity,
   polygon,
-  time
+  time,
 ) {
   const options = this._options;
 
   options.polygonHierarchy = Property.getValueOrUndefined(
     polygon.hierarchy,
-    time
+    time,
   );
 
   let heightValue = Property.getValueOrUndefined(polygon.height, time);
   const heightReferenceValue = Property.getValueOrDefault(
     polygon.heightReference,
     time,
-    HeightReference.NONE
+    HeightReference.NONE,
   );
   const extrudedHeightReferenceValue = Property.getValueOrDefault(
     polygon.extrudedHeightReference,
     time,
-    HeightReference.NONE
+    HeightReference.NONE,
   );
   let extrudedHeightValue = Property.getValueOrUndefined(
     polygon.extrudedHeight,
-    time
+    time,
   );
   const perPositionHeightValue = Property.getValueOrUndefined(
     polygon.perPositionHeight,
-    time
+    time,
   );
 
   heightValue = GroundGeometryUpdater.getGeometryHeight(
     heightValue,
-    extrudedHeightReferenceValue
+    extrudedHeightReferenceValue,
   );
 
   let offsetAttribute;
@@ -538,7 +541,7 @@ DyanmicPolygonGeometryUpdater.prototype._setOptions = function (
       heightValue,
       heightReferenceValue,
       extrudedHeightValue,
-      extrudedHeightReferenceValue
+      extrudedHeightReferenceValue,
     );
   }
 
@@ -546,40 +549,41 @@ DyanmicPolygonGeometryUpdater.prototype._setOptions = function (
   options.stRotation = Property.getValueOrUndefined(polygon.stRotation, time);
   options.textureCoordinates = Property.getValueOrUndefined(
     polygon.textureCoordinates,
-    time
+    time,
   );
   options.perPositionHeight = Property.getValueOrUndefined(
     polygon.perPositionHeight,
-    time
+    time,
   );
   options.closeTop = Property.getValueOrDefault(polygon.closeTop, time, true);
   options.closeBottom = Property.getValueOrDefault(
     polygon.closeBottom,
     time,
-    true
+    true,
   );
   options.offsetAttribute = offsetAttribute;
   options.height = heightValue;
   options.arcType = Property.getValueOrDefault(
     polygon.arcType,
     time,
-    ArcType.GEODESIC
+    ArcType.GEODESIC,
   );
 
   extrudedHeightValue = GroundGeometryUpdater.getGeometryExtrudedHeight(
     extrudedHeightValue,
-    extrudedHeightReferenceValue
+    extrudedHeightReferenceValue,
   );
   if (extrudedHeightValue === GroundGeometryUpdater.CLAMP_TO_GROUND) {
     const rectangle = PolygonGeometry.computeRectangleFromPositions(
       options.polygonHierarchy.positions,
       options.ellipsoid,
       options.arcType,
-      scratchRectangle
+      scratchRectangle,
     );
-    extrudedHeightValue = ApproximateTerrainHeights.getMinimumMaximumHeights(
-      rectangle
-    ).minimumTerrainHeight;
+    extrudedHeightValue =
+      ApproximateTerrainHeights.getMinimumMaximumHeights(
+        rectangle,
+      ).minimumTerrainHeight;
   }
 
   options.extrudedHeight = extrudedHeightValue;

package/Source/DataSources/PolygonGraphics.js

@@ -137,7 +137,7 @@ Object.defineProperties(PolygonGraphics.prototype, {
   hierarchy: createPropertyDescriptor(
     "hierarchy",
     undefined,
-    createPolygonHierarchyProperty
+    createPolygonHierarchyProperty,
   ),
 
   /**
@@ -278,7 +278,7 @@ Object.defineProperties(PolygonGraphics.prototype, {
    * @type {Property|undefined}
    */
   distanceDisplayCondition: createPropertyDescriptor(
-    "distanceDisplayCondition"
+    "distanceDisplayCondition",
   ),
 
   /**
@@ -358,15 +358,15 @@ PolygonGraphics.prototype.merge = function (source) {
   this.height = defaultValue(this.height, source.height);
   this.heightReference = defaultValue(
     this.heightReference,
-    source.heightReference
+    source.heightReference,
   );
   this.extrudedHeight = defaultValue(
     this.extrudedHeight,
-    source.extrudedHeight
+    source.extrudedHeight,
   );
   this.extrudedHeightReference = defaultValue(
     this.extrudedHeightReference,
-    source.extrudedHeightReference
+    source.extrudedHeightReference,
   );
   this.stRotation = defaultValue(this.stRotation, source.stRotation);
   this.granularity = defaultValue(this.granularity, source.granularity);
@@ -377,7 +377,7 @@ PolygonGraphics.prototype.merge = function (source) {
   this.outlineWidth = defaultValue(this.outlineWidth, source.outlineWidth);
   this.perPositionHeight = defaultValue(
     this.perPositionHeight,
-    source.perPositionHeight
+    source.perPositionHeight,
   );
   this.closeTop = defaultValue(this.closeTop, source.closeTop);
   this.closeBottom = defaultValue(this.closeBottom, source.closeBottom);
@@ -385,16 +385,16 @@ PolygonGraphics.prototype.merge = function (source) {
   this.shadows = defaultValue(this.shadows, source.shadows);
   this.distanceDisplayCondition = defaultValue(
     this.distanceDisplayCondition,
-    source.distanceDisplayCondition
+    source.distanceDisplayCondition,
   );
   this.classificationType = defaultValue(
     this.classificationType,
-    source.classificationType
+    source.classificationType,
   );
   this.zIndex = defaultValue(this.zIndex, source.zIndex);
   this.textureCoordinates = defaultValue(
     this.textureCoordinates,
-    source.textureCoordinates
+    source.textureCoordinates,
   );
 };
 export default PolygonGraphics;

package/Source/DataSources/PolylineArrowMaterialProperty.js

@@ -88,7 +88,7 @@ PolylineArrowMaterialProperty.prototype.getValue = function (time, result) {
     this._color,
     time,
     Color.WHITE,
-    result.color
+    result.color,
   );
   return result;
 };

package/Source/DataSources/PolylineDashMaterialProperty.js

@@ -131,25 +131,25 @@ PolylineDashMaterialProperty.prototype.getValue = function (time, result) {
     this._color,
     time,
     defaultColor,
-    result.color
+    result.color,
   );
   result.gapColor = Property.getValueOrClonedDefault(
     this._gapColor,
     time,
     defaultGapColor,
-    result.gapColor
+    result.gapColor,
   );
   result.dashLength = Property.getValueOrDefault(
     this._dashLength,
     time,
     defaultDashLength,
-    result.dashLength
+    result.dashLength,
   );
   result.dashPattern = Property.getValueOrDefault(
     this._dashPattern,
     time,
     defaultDashPattern,
-    result.dashPattern
+    result.dashPattern,
   );
   return result;
 };