@cesium/engine 11.0.0 → 12.0.0

package/Source/DataSources/PolylineGeometryUpdater.js

@@ -40,7 +40,7 @@ const defaultMaterial = new ColorMaterialProperty(Color.WHITE);
 const defaultShow = new ConstantProperty(true);
 const defaultShadows = new ConstantProperty(ShadowMode.DISABLED);
 const defaultDistanceDisplayCondition = new ConstantProperty(
-  new DistanceDisplayCondition()
+  new DistanceDisplayCondition(),
 );
 const defaultClassificationType = new ConstantProperty(ClassificationType.BOTH);
 
@@ -82,7 +82,7 @@ function PolylineGeometryUpdater(entity, scene) {
   this._scene = scene;
   this._entitySubscription = entity.definitionChanged.addEventListener(
     PolylineGeometryUpdater.prototype._onEntityPropertyChanged,
-    this
+    this,
   );
   this._fillEnabled = false;
   this._dynamic = false;
@@ -366,7 +366,7 @@ PolylineGeometryUpdater.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');
@@ -374,14 +374,14 @@ PolylineGeometryUpdater.prototype.createFillGeometryInstance = function (time) {
   const entity = this._entity;
   const isAvailable = entity.isAvailable(time);
   const show = new ShowGeometryInstanceAttribute(
-    isAvailable && entity.isShowing && this._showProperty.getValue(time)
-  );
-  const distanceDisplayCondition = this._distanceDisplayConditionProperty.getValue(
-    time
-  );
-  const distanceDisplayConditionAttribute = DistanceDisplayConditionGeometryInstanceAttribute.fromDistanceDisplayCondition(
-    distanceDisplayCondition
+    isAvailable && entity.isShowing && this._showProperty.getValue(time),
   );
+  const distanceDisplayCondition =
+    this._distanceDisplayConditionProperty.getValue(time);
+  const distanceDisplayConditionAttribute =
+    DistanceDisplayConditionGeometryInstanceAttribute.fromDistanceDisplayCondition(
+      distanceDisplayCondition,
+    );
 
   const attributes = {
     show: show,
@@ -420,15 +420,14 @@ PolylineGeometryUpdater.prototype.createFillGeometryInstance = function (time) {
     ) {
       currentColor = this._depthFailMaterialProperty.color.getValue(
         time,
-        scratchColor
+        scratchColor,
       );
     }
     if (!defined(currentColor)) {
       currentColor = Color.WHITE;
     }
-    attributes.depthFailColor = ColorGeometryInstanceAttribute.fromColor(
-      currentColor
-    );
+    attributes.depthFailColor =
+      ColorGeometryInstanceAttribute.fromColor(currentColor);
   }
 
   return new GeometryInstance({
@@ -447,11 +446,11 @@ PolylineGeometryUpdater.prototype.createFillGeometryInstance = function (time) {
  * @exception {DeveloperError} This instance does not represent an outlined geometry.
  */
 PolylineGeometryUpdater.prototype.createOutlineGeometryInstance = function (
-  time
+  time,
 ) {
   //>>includeStart('debug', pragmas.debug);
   throw new DeveloperError(
-    "This instance does not represent an outlined geometry."
+    "This instance does not represent an outlined geometry.",
   );
   //>>includeEnd('debug');
 };
@@ -479,7 +478,7 @@ PolylineGeometryUpdater.prototype._onEntityPropertyChanged = function (
   entity,
   propertyName,
   newValue,
-  oldValue
+  oldValue,
 ) {
   if (!(propertyName === "availability" || propertyName === "polyline")) {
     return;
@@ -520,11 +519,11 @@ PolylineGeometryUpdater.prototype._onEntityPropertyChanged = function (
   this._shadowsProperty = defaultValue(polyline.shadows, defaultShadows);
   this._distanceDisplayConditionProperty = defaultValue(
     polyline.distanceDisplayCondition,
-    defaultDistanceDisplayCondition
+    defaultDistanceDisplayCondition,
   );
   this._classificationTypeProperty = defaultValue(
     polyline.classificationType,
-    defaultClassificationType
+    defaultClassificationType,
   );
   this._fillEnabled = true;
   this._zIndex = defaultValue(zIndex, defaultZIndex);
@@ -550,7 +549,7 @@ PolylineGeometryUpdater.prototype._onEntityPropertyChanged = function (
     const geometryOptions = this._geometryOptions;
     const positions = positionsProperty.getValue(
       Iso8601.MINIMUM_VALUE,
-      geometryOptions.positions
+      geometryOptions.positions,
     );
 
     //Because of the way we currently handle reference properties,
@@ -598,7 +597,7 @@ PolylineGeometryUpdater.prototype._onEntityPropertyChanged = function (
 
     if (!this._clampToGround && defined(zIndex)) {
       oneTimeWarning(
-        "Entity polylines must have clampToGround: true when using zIndex.  zIndex will be ignored."
+        "Entity polylines must have clampToGround: true when using zIndex.  zIndex will be ignored.",
       );
     }
 
@@ -619,7 +618,7 @@ PolylineGeometryUpdater.prototype._onEntityPropertyChanged = function (
  */
 PolylineGeometryUpdater.prototype.createDynamicUpdater = function (
   primitives,
-  groundPrimitives
+  groundPrimitives,
 ) {
   //>>includeStart('debug', pragmas.debug);
   Check.defined("primitives", primitives);
@@ -627,7 +626,7 @@ PolylineGeometryUpdater.prototype.createDynamicUpdater = function (
 
   if (!this._dynamic) {
     throw new DeveloperError(
-      "This instance does not represent dynamic geometry."
+      "This instance does not represent dynamic geometry.",
     );
   }
   //>>includeEnd('debug');
@@ -687,31 +686,28 @@ DynamicGeometryUpdater.prototype.update = function (time) {
   let positions = Property.getValueOrUndefined(
     positionsProperty,
     time,
-    this._positions
+    this._positions,
   );
 
   // Synchronize with geometryUpdater for GroundPolylinePrimitive
   geometryUpdater._clampToGround = Property.getValueOrDefault(
     polyline._clampToGround,
     time,
-    false
+    false,
   );
   geometryUpdater._groundGeometryOptions.positions = positions;
   geometryUpdater._groundGeometryOptions.width = Property.getValueOrDefault(
     polyline._width,
     time,
-    1
+    1,
   );
   geometryUpdater._groundGeometryOptions.arcType = Property.getValueOrDefault(
     polyline._arcType,
     time,
-    ArcType.GEODESIC
-  );
-  geometryUpdater._groundGeometryOptions.granularity = Property.getValueOrDefault(
-    polyline._granularity,
-    time,
-    9999
+    ArcType.GEODESIC,
   );
+  geometryUpdater._groundGeometryOptions.granularity =
+    Property.getValueOrDefault(polyline._granularity, time, 9999);
 
   const groundPrimitives = this._groundPrimitives;
 
@@ -741,7 +737,7 @@ DynamicGeometryUpdater.prototype.update = function (time) {
       const material = MaterialProperty.getValue(
         time,
         fillMaterialProperty,
-        this._material
+        this._material,
       );
       appearance = new PolylineMaterialAppearance({
         material: material,
@@ -754,12 +750,11 @@ DynamicGeometryUpdater.prototype.update = function (time) {
       new GroundPolylinePrimitive({
         geometryInstances: geometryUpdater.createFillGeometryInstance(time),
         appearance: appearance,
-        classificationType: geometryUpdater.classificationTypeProperty.getValue(
-          time
-        ),
+        classificationType:
+          geometryUpdater.classificationTypeProperty.getValue(time),
         asynchronous: false,
       }),
-      Property.getValueOrUndefined(geometryUpdater.zIndex, time)
+      Property.getValueOrUndefined(geometryUpdater.zIndex, time),
     );
 
     // Hide the polyline in the collection, if any
@@ -795,19 +790,19 @@ DynamicGeometryUpdater.prototype.update = function (time) {
     generateCartesianArcOptions.positions = positions;
     generateCartesianArcOptions.granularity = Property.getValueOrUndefined(
       polyline._granularity,
-      time
+      time,
     );
     generateCartesianArcOptions.height = PolylinePipeline.extractHeights(
       positions,
-      ellipsoid
+      ellipsoid,
     );
     if (arcType === ArcType.GEODESIC) {
       positions = PolylinePipeline.generateCartesianArc(
-        generateCartesianArcOptions
+        generateCartesianArcOptions,
       );
     } else {
       positions = PolylinePipeline.generateCartesianRhumbArc(
-        generateCartesianArcOptions
+        generateCartesianArcOptions,
       );
     }
   }
@@ -817,13 +812,13 @@ DynamicGeometryUpdater.prototype.update = function (time) {
   line.material = MaterialProperty.getValue(
     time,
     geometryUpdater.fillMaterialProperty,
-    line.material
+    line.material,
   );
   line.width = Property.getValueOrDefault(polyline._width, time, 1);
   line.distanceDisplayCondition = Property.getValueOrUndefined(
     polyline._distanceDisplayCondition,
     time,
-    line.distanceDisplayCondition
+    line.distanceDisplayCondition,
   );
 };
 
@@ -846,7 +841,7 @@ DynamicGeometryUpdater.prototype.getBoundingSphere = function (result) {
       groundPolylinePrimitive.ready
     ) {
       const attributes = groundPolylinePrimitive.getGeometryInstanceAttributes(
-        this._geometryUpdater._entity
+        this._geometryUpdater._entity,
       );
       if (defined(attributes) && defined(attributes.boundingSphere)) {
         BoundingSphere.clone(attributes.boundingSphere, result);

package/Source/DataSources/PolylineGlowMaterialProperty.js

@@ -116,19 +116,19 @@ PolylineGlowMaterialProperty.prototype.getValue = function (time, result) {
     this._color,
     time,
     defaultColor,
-    result.color
+    result.color,
   );
   result.glowPower = Property.getValueOrDefault(
     this._glowPower,
     time,
     defaultGlowPower,
-    result.glowPower
+    result.glowPower,
   );
   result.taperPower = Property.getValueOrDefault(
     this._taperPower,
     time,
     defaultTaperPower,
-    result.taperPower
+    result.taperPower,
   );
   return result;
 };

package/Source/DataSources/PolylineGraphics.js

@@ -165,7 +165,7 @@ Object.defineProperties(PolylineGraphics.prototype, {
    * @type {Property|undefined}
    */
   distanceDisplayCondition: createPropertyDescriptor(
-    "distanceDisplayCondition"
+    "distanceDisplayCondition",
   ),
 
   /**
@@ -230,18 +230,18 @@ PolylineGraphics.prototype.merge = function (source) {
   this.material = defaultValue(this.material, source.material);
   this.depthFailMaterial = defaultValue(
     this.depthFailMaterial,
-    source.depthFailMaterial
+    source.depthFailMaterial,
   );
   this.arcType = defaultValue(this.arcType, source.arcType);
   this.clampToGround = defaultValue(this.clampToGround, source.clampToGround);
   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);
 };

package/Source/DataSources/PolylineOutlineMaterialProperty.js

@@ -123,18 +123,18 @@ PolylineOutlineMaterialProperty.prototype.getValue = function (time, result) {
     this._color,
     time,
     defaultColor,
-    result.color
+    result.color,
   );
   result.outlineColor = Property.getValueOrClonedDefault(
     this._outlineColor,
     time,
     defaultOutlineColor,
-    result.outlineColor
+    result.outlineColor,
   );
   result.outlineWidth = Property.getValueOrDefault(
     this._outlineWidth,
     time,
-    defaultOutlineWidth
+    defaultOutlineWidth,
   );
   return result;
 };

package/Source/DataSources/PolylineVisualizer.js

@@ -35,9 +35,8 @@ function insertUpdaterIntoBatch(that, time, updater) {
 
   if (updater.clampToGround && updater.fillEnabled) {
     // Also checks for support
-    const classificationType = updater.classificationTypeProperty.getValue(
-      time
-    );
+    const classificationType =
+      updater.classificationTypeProperty.getValue(time);
     that._groundBatches[classificationType].add(time, updater);
     return;
   }
@@ -83,7 +82,7 @@ function PolylineVisualizer(
   scene,
   entityCollection,
   primitives,
-  groundPrimitives
+  groundPrimitives,
 ) {
   //>>includeStart('debug', pragmas.debug);
   Check.defined("scene", scene);
@@ -111,14 +110,14 @@ function PolylineVisualizer(
       PolylineColorAppearance,
       undefined,
       false,
-      i
+      i,
     ); // no depth fail appearance
     this._materialBatches[i] = new StaticGeometryPerMaterialBatch(
       primitives,
       PolylineMaterialAppearance,
       undefined,
       false,
-      i
+      i,
     );
 
     this._colorBatches[i + numberOfShadowModes] = new StaticGeometryColorBatch(
@@ -126,36 +125,33 @@ function PolylineVisualizer(
       PolylineColorAppearance,
       PolylineColorAppearance,
       false,
-      i
+      i,
     ); //depth fail appearance variations
-    this._materialBatches[
-      i + numberOfShadowModes
-    ] = new StaticGeometryPerMaterialBatch(
-      primitives,
-      PolylineMaterialAppearance,
-      PolylineColorAppearance,
-      false,
-      i
-    );
+    this._materialBatches[i + numberOfShadowModes] =
+      new StaticGeometryPerMaterialBatch(
+        primitives,
+        PolylineMaterialAppearance,
+        PolylineColorAppearance,
+        false,
+        i,
+      );
 
-    this._colorBatches[
-      i + numberOfShadowModes * 2
-    ] = new StaticGeometryColorBatch(
-      primitives,
-      PolylineColorAppearance,
-      PolylineMaterialAppearance,
-      false,
-      i
-    );
-    this._materialBatches[
-      i + numberOfShadowModes * 2
-    ] = new StaticGeometryPerMaterialBatch(
-      primitives,
-      PolylineMaterialAppearance,
-      PolylineMaterialAppearance,
-      false,
-      i
-    );
+    this._colorBatches[i + numberOfShadowModes * 2] =
+      new StaticGeometryColorBatch(
+        primitives,
+        PolylineColorAppearance,
+        PolylineMaterialAppearance,
+        false,
+        i,
+      );
+    this._materialBatches[i + numberOfShadowModes * 2] =
+      new StaticGeometryPerMaterialBatch(
+        primitives,
+        PolylineMaterialAppearance,
+        PolylineMaterialAppearance,
+        false,
+        i,
+      );
   }
 
   this._dynamicBatch = new DynamicGeometryBatch(primitives, groundPrimitives);
@@ -167,14 +163,14 @@ function PolylineVisualizer(
   for (i = 0; i < numberOfClassificationTypes; ++i) {
     this._groundBatches[i] = new StaticGroundPolylinePerMaterialBatch(
       groundPrimitives,
-      i
+      i,
     );
   }
 
   this._batches = this._colorBatches.concat(
     this._materialBatches,
     this._dynamicBatch,
-    this._groundBatches
+    this._groundBatches,
   );
 
   this._subscriptions = new AssociativeArray();
@@ -183,12 +179,12 @@ function PolylineVisualizer(
   this._entityCollection = entityCollection;
   entityCollection.collectionChanged.addEventListener(
     PolylineVisualizer.prototype._onCollectionChanged,
-    this
+    this,
   );
   this._onCollectionChanged(
     entityCollection,
     entityCollection.values,
-    emptyArray
+    emptyArray,
   );
 }
 
@@ -257,8 +253,8 @@ PolylineVisualizer.prototype.update = function (time) {
       id,
       updater.geometryChanged.addEventListener(
         PolylineVisualizer._onGeometryChanged,
-        this
-      )
+        this,
+      ),
     );
   }
 
@@ -311,7 +307,7 @@ PolylineVisualizer.prototype.getBoundingSphere = function (entity, result) {
     } else if (state === BoundingSphereState.DONE) {
       boundingSpheres[count] = BoundingSphere.clone(
         tmp,
-        boundingSpheres[count]
+        boundingSpheres[count],
       );
       count++;
     }
@@ -341,7 +337,7 @@ PolylineVisualizer.prototype.isDestroyed = function () {
 PolylineVisualizer.prototype.destroy = function () {
   this._entityCollection.collectionChanged.removeEventListener(
     PolylineVisualizer.prototype._onCollectionChanged,
-    this
+    this,
   );
   this._addedObjects.removeAll();
   this._removedObjects.removeAll();
@@ -383,7 +379,7 @@ PolylineVisualizer._onGeometryChanged = function (updater) {
 PolylineVisualizer.prototype._onCollectionChanged = function (
   entityCollection,
   added,
-  removed
+  removed,
 ) {
   const addedObjects = this._addedObjects;
   const removedObjects = this._removedObjects;