@cesium/engine 11.0.0 → 12.0.0

package/Source/Core/CorridorGeometryLibrary.js

@@ -37,11 +37,11 @@ function computeRoundCorner(
   startPoint,
   endPoint,
   cornerType,
-  leftIsOutside
+  leftIsOutside,
 ) {
   const angle = Cartesian3.angleBetween(
     Cartesian3.subtract(startPoint, cornerPoint, scratch1),
-    Cartesian3.subtract(endPoint, cornerPoint, scratch2)
+    Cartesian3.subtract(endPoint, cornerPoint, scratch2),
   );
   const granularity =
     cornerType === CornerType.BEVELED
@@ -61,14 +61,14 @@ function computeRoundCorner(
       Quaternion.fromAxisAngle(
         Cartesian3.negate(cornerPoint, scratch1),
         angle / granularity,
-        quaterion
+        quaterion,
       ),
-      rotMatrix
+      rotMatrix,
     );
   } else {
     m = Matrix3.fromQuaternion(
       Quaternion.fromAxisAngle(cornerPoint, angle / granularity, quaterion),
-      rotMatrix
+      rotMatrix,
     );
   }
 
@@ -93,7 +93,7 @@ function addEndCaps(calculatedPositions) {
   startPoint = Cartesian3.fromArray(
     calculatedPositions[1],
     leftEdge.length - 3,
-    startPoint
+    startPoint,
   );
   endPoint = Cartesian3.fromArray(calculatedPositions[0], 0, endPoint);
   cornerPoint = Cartesian3.midpoint(startPoint, endPoint, cornerPoint);
@@ -102,7 +102,7 @@ function addEndCaps(calculatedPositions) {
     startPoint,
     endPoint,
     CornerType.ROUNDED,
-    false
+    false,
   );
 
   const length = calculatedPositions.length - 1;
@@ -111,7 +111,7 @@ function addEndCaps(calculatedPositions) {
   startPoint = Cartesian3.fromArray(
     rightEdge,
     rightEdge.length - 3,
-    startPoint
+    startPoint,
   );
   endPoint = Cartesian3.fromArray(leftEdge, 0, endPoint);
   cornerPoint = Cartesian3.midpoint(startPoint, endPoint, cornerPoint);
@@ -120,7 +120,7 @@ function addEndCaps(calculatedPositions) {
     startPoint,
     endPoint,
     CornerType.ROUNDED,
-    false
+    false,
   );
 
   return [firstEndCap, lastEndCap];
@@ -130,7 +130,7 @@ function computeMiteredCorner(
   position,
   leftCornerDirection,
   lastPoint,
-  leftIsOutside
+  leftIsOutside,
 ) {
   let cornerPoint = scratch1;
   if (leftIsOutside) {
@@ -138,7 +138,7 @@ function computeMiteredCorner(
   } else {
     leftCornerDirection = Cartesian3.negate(
       leftCornerDirection,
-      leftCornerDirection
+      leftCornerDirection,
     );
     cornerPoint = Cartesian3.add(position, leftCornerDirection, cornerPoint);
   }
@@ -184,7 +184,7 @@ CorridorGeometryLibrary.addAttribute = function (
   attribute,
   value,
   front,
-  back
+  back,
 ) {
   const x = value.x;
   const y = value.y;
@@ -232,7 +232,7 @@ CorridorGeometryLibrary.computePositions = function (params) {
 
   forward = Cartesian3.normalize(
     Cartesian3.subtract(nextPosition, position, forward),
-    forward
+    forward,
   );
   normal = ellipsoid.geodeticSurfaceNormal(position, normal);
   left = Cartesian3.normalize(Cartesian3.cross(normal, forward, left), left);
@@ -254,17 +254,13 @@ CorridorGeometryLibrary.computePositions = function (params) {
     nextPosition = positions[i + 1];
     forward = Cartesian3.normalize(
       Cartesian3.subtract(nextPosition, position, forward),
-      forward
-    );
-    cornerDirection = Cartesian3.normalize(
-      Cartesian3.add(forward, backward, cornerDirection),
-      cornerDirection
+      forward,
     );
 
     const forwardProjection = Cartesian3.multiplyByScalar(
       normal,
       Cartesian3.dot(forward, normal),
-      scratchForwardProjection
+      scratchForwardProjection,
     );
     Cartesian3.subtract(forward, forwardProjection, forwardProjection);
     Cartesian3.normalize(forwardProjection, forwardProjection);
@@ -272,7 +268,7 @@ CorridorGeometryLibrary.computePositions = function (params) {
     const backwardProjection = Cartesian3.multiplyByScalar(
       normal,
       Cartesian3.dot(backward, normal),
-      scratchBackwardProjection
+      scratchBackwardProjection,
     );
     Cartesian3.subtract(backward, backwardProjection, backwardProjection);
     Cartesian3.normalize(backwardProjection, backwardProjection);
@@ -280,19 +276,23 @@ CorridorGeometryLibrary.computePositions = function (params) {
     const doCorner = !CesiumMath.equalsEpsilon(
       Math.abs(Cartesian3.dot(forwardProjection, backwardProjection)),
       1.0,
-      CesiumMath.EPSILON7
+      CesiumMath.EPSILON7,
     );
 
     if (doCorner) {
+      cornerDirection = Cartesian3.normalize(
+        Cartesian3.add(forward, backward, cornerDirection),
+        cornerDirection,
+      );
       cornerDirection = Cartesian3.cross(
         cornerDirection,
         normal,
-        cornerDirection
+        cornerDirection,
       );
       cornerDirection = Cartesian3.cross(
         normal,
         cornerDirection,
-        cornerDirection
+        cornerDirection,
       );
       cornerDirection = Cartesian3.normalize(cornerDirection, cornerDirection);
       const scalar =
@@ -300,31 +300,31 @@ CorridorGeometryLibrary.computePositions = function (params) {
         Math.max(
           0.25,
           Cartesian3.magnitude(
-            Cartesian3.cross(cornerDirection, backward, scratch1)
-          )
+            Cartesian3.cross(cornerDirection, backward, scratch1),
+          ),
         );
       const leftIsOutside = PolylineVolumeGeometryLibrary.angleIsGreaterThanPi(
         forward,
         backward,
         position,
-        ellipsoid
+        ellipsoid,
       );
       cornerDirection = Cartesian3.multiplyByScalar(
         cornerDirection,
         scalar,
-        cornerDirection
+        cornerDirection,
       );
       if (leftIsOutside) {
         rightPos = Cartesian3.add(position, cornerDirection, rightPos);
         center = Cartesian3.add(
           rightPos,
           Cartesian3.multiplyByScalar(left, width, center),
-          center
+          center,
         );
         leftPos = Cartesian3.add(
           rightPos,
           Cartesian3.multiplyByScalar(left, width * 2, leftPos),
-          leftPos
+          leftPos,
         );
         scaleArray2[0] = Cartesian3.clone(previousPos, scaleArray2[0]);
         scaleArray2[1] = Cartesian3.clone(center, scaleArray2[1]);
@@ -337,7 +337,7 @@ CorridorGeometryLibrary.computePositions = function (params) {
           subdividedPositions,
           left,
           width,
-          calculatedPositions
+          calculatedPositions,
         );
         if (saveAttributes) {
           calculatedLefts.push(left.x, left.y, left.z);
@@ -346,17 +346,17 @@ CorridorGeometryLibrary.computePositions = function (params) {
         startPoint = Cartesian3.clone(leftPos, startPoint);
         left = Cartesian3.normalize(
           Cartesian3.cross(normal, forward, left),
-          left
+          left,
         );
         leftPos = Cartesian3.add(
           rightPos,
           Cartesian3.multiplyByScalar(left, width * 2, leftPos),
-          leftPos
+          leftPos,
         );
         previousPos = Cartesian3.add(
           rightPos,
           Cartesian3.multiplyByScalar(left, width, previousPos),
-          previousPos
+          previousPos,
         );
         if (
           cornerType === CornerType.ROUNDED ||
@@ -368,7 +368,7 @@ CorridorGeometryLibrary.computePositions = function (params) {
               startPoint,
               leftPos,
               cornerType,
-              leftIsOutside
+              leftIsOutside,
             ),
           });
         } else {
@@ -377,7 +377,7 @@ CorridorGeometryLibrary.computePositions = function (params) {
               position,
               Cartesian3.negate(cornerDirection, cornerDirection),
               leftPos,
-              leftIsOutside
+              leftIsOutside,
             ),
           });
         }
@@ -387,17 +387,17 @@ CorridorGeometryLibrary.computePositions = function (params) {
           leftPos,
           Cartesian3.negate(
             Cartesian3.multiplyByScalar(left, width, center),
-            center
+            center,
           ),
-          center
+          center,
         );
         rightPos = Cartesian3.add(
           leftPos,
           Cartesian3.negate(
             Cartesian3.multiplyByScalar(left, width * 2, rightPos),
-            rightPos
+            rightPos,
           ),
-          rightPos
+          rightPos,
         );
         scaleArray2[0] = Cartesian3.clone(previousPos, scaleArray2[0]);
         scaleArray2[1] = Cartesian3.clone(center, scaleArray2[1]);
@@ -410,7 +410,7 @@ CorridorGeometryLibrary.computePositions = function (params) {
           subdividedPositions,
           left,
           width,
-          calculatedPositions
+          calculatedPositions,
         );
         if (saveAttributes) {
           calculatedLefts.push(left.x, left.y, left.z);
@@ -419,23 +419,23 @@ CorridorGeometryLibrary.computePositions = function (params) {
         startPoint = Cartesian3.clone(rightPos, startPoint);
         left = Cartesian3.normalize(
           Cartesian3.cross(normal, forward, left),
-          left
+          left,
         );
         rightPos = Cartesian3.add(
           leftPos,
           Cartesian3.negate(
             Cartesian3.multiplyByScalar(left, width * 2, rightPos),
-            rightPos
+            rightPos,
           ),
-          rightPos
+          rightPos,
         );
         previousPos = Cartesian3.add(
           leftPos,
           Cartesian3.negate(
             Cartesian3.multiplyByScalar(left, width, previousPos),
-            previousPos
+            previousPos,
           ),
-          previousPos
+          previousPos,
         );
         if (
           cornerType === CornerType.ROUNDED ||
@@ -447,7 +447,7 @@ CorridorGeometryLibrary.computePositions = function (params) {
               startPoint,
               rightPos,
               cornerType,
-              leftIsOutside
+              leftIsOutside,
             ),
           });
         } else {
@@ -456,7 +456,7 @@ CorridorGeometryLibrary.computePositions = function (params) {
               position,
               cornerDirection,
               rightPos,
-              leftIsOutside
+              leftIsOutside,
             ),
           });
         }
@@ -478,7 +478,7 @@ CorridorGeometryLibrary.computePositions = function (params) {
     subdividedPositions,
     left,
     width,
-    calculatedPositions
+    calculatedPositions,
   );
   if (saveAttributes) {
     calculatedLefts.push(left.x, left.y, left.z);

package/Source/Core/CorridorOutlineGeometry.js

@@ -94,19 +94,19 @@ function combine(computedPositions, cornerType) {
       leftPos = Cartesian3.fromArray(
         firstEndPositions,
         (halfLength - 1 - i) * 3,
-        leftPos
+        leftPos,
       );
       rightPos = Cartesian3.fromArray(
         firstEndPositions,
         (halfLength + i) * 3,
-        rightPos
+        rightPos,
       );
       CorridorGeometryLibrary.addAttribute(finalPositions, rightPos, front);
       CorridorGeometryLibrary.addAttribute(
         finalPositions,
         leftPos,
         undefined,
-        back
+        back,
       );
 
       LL = front / 3;
@@ -164,7 +164,7 @@ function combine(computedPositions, cornerType) {
           finalPositions,
           outsidePoint,
           undefined,
-          back
+          back,
         );
         back -= 3;
       }
@@ -184,7 +184,7 @@ function combine(computedPositions, cornerType) {
         CorridorGeometryLibrary.addAttribute(
           finalPositions,
           outsidePoint,
-          front
+          front,
         );
         front += 3;
       }
@@ -230,14 +230,14 @@ function combine(computedPositions, cornerType) {
       leftPos = Cartesian3.fromArray(
         lastEndPositions,
         (endPositionLength - i - 1) * 3,
-        leftPos
+        leftPos,
       );
       rightPos = Cartesian3.fromArray(lastEndPositions, i * 3, rightPos);
       CorridorGeometryLibrary.addAttribute(
         finalPositions,
         leftPos,
         undefined,
-        back
+        back,
       );
       CorridorGeometryLibrary.addAttribute(finalPositions, rightPos, front);
 
@@ -292,12 +292,12 @@ function computePositionsExtruded(params) {
   positions = PolygonPipeline.scaleToGeodeticHeight(
     positions,
     height,
-    ellipsoid
+    ellipsoid,
   );
   extrudedPositions = PolygonPipeline.scaleToGeodeticHeight(
     extrudedPositions,
     extrudedHeight,
-    ellipsoid
+    ellipsoid,
   );
   newPositions.set(positions);
   newPositions.set(extrudedPositions, length);
@@ -325,7 +325,7 @@ function computePositionsExtruded(params) {
   const iLength = indices.length;
   const newIndices = IndexDatatype.createTypedArray(
     newPositions.length / 3,
-    (iLength + wallIndices.length) * 2
+    (iLength + wallIndices.length) * 2,
   );
   newIndices.set(indices);
   let index = iLength;
@@ -390,7 +390,7 @@ function CorridorOutlineGeometry(options) {
 
   this._positions = positions;
   this._ellipsoid = Ellipsoid.clone(
-    defaultValue(options.ellipsoid, Ellipsoid.default)
+    defaultValue(options.ellipsoid, Ellipsoid.default),
   );
   this._width = width;
   this._height = Math.max(height, extrudedHeight);
@@ -398,7 +398,7 @@ function CorridorOutlineGeometry(options) {
   this._cornerType = defaultValue(options.cornerType, CornerType.ROUNDED);
   this._granularity = defaultValue(
     options.granularity,
-    CesiumMath.RADIANS_PER_DEGREE
+    CesiumMath.RADIANS_PER_DEGREE,
   );
   this._offsetAttribute = options.offsetAttribute;
   this._workerName = "createCorridorOutlineGeometry";
@@ -532,7 +532,7 @@ CorridorOutlineGeometry.createGeometry = function (corridorOutlineGeometry) {
   positions = scaleToSurface(positions, ellipsoid);
   const cleanPositions = arrayRemoveDuplicates(
     positions,
-    Cartesian3.equalsEpsilon
+    Cartesian3.equalsEpsilon,
   );
 
   if (cleanPositions.length < 2 || width <= 0) {
@@ -545,7 +545,7 @@ CorridorOutlineGeometry.createGeometry = function (corridorOutlineGeometry) {
     height,
     extrudedHeight,
     0,
-    CesiumMath.EPSILON2
+    CesiumMath.EPSILON2,
   );
 
   const params = {
@@ -568,7 +568,7 @@ CorridorOutlineGeometry.createGeometry = function (corridorOutlineGeometry) {
     attr.attributes.position.values = PolygonPipeline.scaleToGeodeticHeight(
       attr.attributes.position.values,
       height,
-      ellipsoid
+      ellipsoid,
     );
 
     if (defined(corridorOutlineGeometry._offsetAttribute)) {
@@ -590,7 +590,7 @@ CorridorOutlineGeometry.createGeometry = function (corridorOutlineGeometry) {
   const boundingSphere = BoundingSphere.fromVertices(
     attributes.position.values,
     undefined,
-    3
+    3,
   );
 
   return new Geometry({

package/Source/Core/CullingVolume.js

@@ -91,7 +91,7 @@ CullingVolume.fromBoundingSphere = function (boundingSphere, result) {
     plane1.z = -faceNormal.z;
     plane1.w = -Cartesian3.dot(
       Cartesian3.negate(faceNormal, scratchPlaneNormal),
-      scratchPlaneCenter
+      scratchPlaneCenter,
     );
 
     planeIndex += 2;
@@ -117,7 +117,7 @@ CullingVolume.prototype.computeVisibility = function (boundingVolume) {
   let intersecting = false;
   for (let k = 0, len = planes.length; k < len; ++k) {
     const result = boundingVolume.intersectPlane(
-      Plane.fromCartesian4(planes[k], scratchPlane)
+      Plane.fromCartesian4(planes[k], scratchPlane),
     );
     if (result === Intersect.OUTSIDE) {
       return Intersect.OUTSIDE;
@@ -143,7 +143,7 @@ CullingVolume.prototype.computeVisibility = function (boundingVolume) {
  */
 CullingVolume.prototype.computeVisibilityWithPlaneMask = function (
   boundingVolume,
-  parentPlaneMask
+  parentPlaneMask,
 ) {
   //>>includeStart('debug', pragmas.debug);
   if (!defined(boundingVolume)) {
@@ -176,7 +176,7 @@ CullingVolume.prototype.computeVisibilityWithPlaneMask = function (
     }
 
     const result = boundingVolume.intersectPlane(
-      Plane.fromCartesian4(planes[k], scratchPlane)
+      Plane.fromCartesian4(planes[k], scratchPlane),
     );
     if (result === Intersect.OUTSIDE) {
       return CullingVolume.MASK_OUTSIDE;

package/Source/Core/CustomHeightmapTerrainProvider.js

@@ -75,11 +75,12 @@ function CustomHeightmapTerrainProvider(options) {
   this._height = options.height;
   const maxTileDimensions = Math.max(this._width, this._height);
 
-  this._levelZeroMaximumGeometricError = TerrainProvider.getEstimatedLevelZeroGeometricErrorForAHeightmap(
-    this._tilingScheme.ellipsoid,
-    maxTileDimensions,
-    this._tilingScheme.getNumberOfXTilesAtLevel(0)
-  );
+  this._levelZeroMaximumGeometricError =
+    TerrainProvider.getEstimatedLevelZeroGeometricErrorForAHeightmap(
+      this._tilingScheme.ellipsoid,
+      maxTileDimensions,
+      this._tilingScheme.getNumberOfXTilesAtLevel(0),
+    );
 
   this._errorEvent = new Event();
 
@@ -216,7 +217,7 @@ CustomHeightmapTerrainProvider.prototype.requestTileGeometry = function (
   x,
   y,
   level,
-  request
+  request,
 ) {
   const promise = this._callback(x, y, level);
   if (!defined(promise)) {
@@ -247,11 +248,10 @@ CustomHeightmapTerrainProvider.prototype.requestTileGeometry = function (
  * @param {number} level The tile level for which to get the maximum geometric error.
  * @returns {number} The maximum geometric error.
  */
-CustomHeightmapTerrainProvider.prototype.getLevelMaximumGeometricError = function (
-  level
-) {
-  return this._levelZeroMaximumGeometricError / (1 << level);
-};
+CustomHeightmapTerrainProvider.prototype.getLevelMaximumGeometricError =
+  function (level) {
+    return this._levelZeroMaximumGeometricError / (1 << level);
+  };
 
 /**
  * Determines whether data for a tile is available to be loaded.
@@ -264,7 +264,7 @@ CustomHeightmapTerrainProvider.prototype.getLevelMaximumGeometricError = functio
 CustomHeightmapTerrainProvider.prototype.getTileDataAvailable = function (
   x,
   y,
-  level
+  level,
 ) {
   return undefined;
 };
@@ -280,7 +280,7 @@ CustomHeightmapTerrainProvider.prototype.getTileDataAvailable = function (
 CustomHeightmapTerrainProvider.prototype.loadTileDataAvailability = function (
   x,
   y,
-  level
+  level,
 ) {
   return undefined;
 };

package/Source/Core/CylinderGeometry.js

@@ -68,7 +68,7 @@ function CylinderGeometry(options) {
   }
   if (slices < 3) {
     throw new DeveloperError(
-      "options.slices must be greater than or equal to 3."
+      "options.slices must be greater than or equal to 3.",
     );
   }
   if (
@@ -76,7 +76,7 @@ function CylinderGeometry(options) {
     options.offsetAttribute === GeometryOffsetAttribute.TOP
   ) {
     throw new DeveloperError(
-      "GeometryOffsetAttribute.TOP is not a supported options.offsetAttribute for this geometry."
+      "GeometryOffsetAttribute.TOP is not a supported options.offsetAttribute for this geometry.",
     );
   }
   //>>includeEnd('debug');
@@ -159,7 +159,7 @@ CylinderGeometry.unpack = function (array, startingIndex, result) {
   const vertexFormat = VertexFormat.unpack(
     array,
     startingIndex,
-    scratchVertexFormat
+    scratchVertexFormat,
   );
   startingIndex += VertexFormat.packedLength;
 
@@ -221,7 +221,7 @@ CylinderGeometry.createGeometry = function (cylinderGeometry) {
     topRadius,
     bottomRadius,
     slices,
-    true
+    true,
   );
 
   const st = vertexFormat.st ? new Float32Array(numVertices * 2) : undefined;
@@ -264,7 +264,7 @@ CylinderGeometry.createGeometry = function (cylinderGeometry) {
         if (computeTangent) {
           tangent = Cartesian3.normalize(
             Cartesian3.cross(Cartesian3.UNIT_Z, normal, tangent),
-            tangent
+            tangent,
           );
         }
 
@@ -289,7 +289,7 @@ CylinderGeometry.createGeometry = function (cylinderGeometry) {
         if (vertexFormat.bitangent) {
           bitangent = Cartesian3.normalize(
             Cartesian3.cross(normal, tangent, bitangent),
-            bitangent
+            bitangent,
           );
           bitangents[bitangentIndex++] = bitangent.x;
           bitangents[bitangentIndex++] = bitangent.y;
@@ -429,7 +429,7 @@ CylinderGeometry.createGeometry = function (cylinderGeometry) {
 
   const boundingSphere = new BoundingSphere(
     Cartesian3.ZERO,
-    Cartesian2.magnitude(radiusScratch)
+    Cartesian2.magnitude(radiusScratch),
   );
 
   if (defined(cylinderGeometry._offsetAttribute)) {
@@ -471,7 +471,7 @@ CylinderGeometry.getUnitCylinder = function () {
         bottomRadius: 1.0,
         length: 1.0,
         vertexFormat: VertexFormat.POSITION_ONLY,
-      })
+      }),
     );
   }
   return unitCylinderGeometry;

package/Source/Core/CylinderGeometryLibrary.js

@@ -13,7 +13,7 @@ CylinderGeometryLibrary.computePositions = function (
   topRadius,
   bottomRadius,
   slices,
-  fill
+  fill,
 ) {
   const topZ = length * 0.5;
   const bottomZ = -topZ;

package/Source/Core/CylinderOutlineGeometry.js

@@ -55,7 +55,7 @@ function CylinderOutlineGeometry(options) {
   const slices = defaultValue(options.slices, 128);
   const numberOfVerticalLines = Math.max(
     defaultValue(options.numberOfVerticalLines, 16),
-    0
+    0,
   );
 
   //>>includeStart('debug', pragmas.debug);
@@ -68,7 +68,7 @@ function CylinderOutlineGeometry(options) {
     options.offsetAttribute === GeometryOffsetAttribute.TOP
   ) {
     throw new DeveloperError(
-      "GeometryOffsetAttribute.TOP is not a supported options.offsetAttribute for this geometry."
+      "GeometryOffsetAttribute.TOP is not a supported options.offsetAttribute for this geometry.",
     );
   }
   //>>includeEnd('debug');
@@ -197,7 +197,7 @@ CylinderOutlineGeometry.createGeometry = function (cylinderGeometry) {
     topRadius,
     bottomRadius,
     slices,
-    false
+    false,
   );
   let numIndices = slices * 2;
   let numSide;
@@ -241,7 +241,7 @@ CylinderOutlineGeometry.createGeometry = function (cylinderGeometry) {
 
   const boundingSphere = new BoundingSphere(
     Cartesian3.ZERO,
-    Cartesian2.magnitude(radiusScratch)
+    Cartesian2.magnitude(radiusScratch),
   );
 
   if (defined(cylinderGeometry._offsetAttribute)) {

package/Source/Core/DeveloperError.js

@@ -69,7 +69,7 @@ DeveloperError.prototype.toString = function () {
  */
 DeveloperError.throwInstantiationError = function () {
   throw new DeveloperError(
-    "This function defines an interface and should not be called directly."
+    "This function defines an interface and should not be called directly.",
   );
 };
 export default DeveloperError;