@cesium/engine 11.0.0 → 11.1.0

package/Source/Core/PolygonPipeline.js

@@ -31,7 +31,7 @@ PolygonPipeline.computeArea2D = function (positions) {
   Check.typeOf.number.greaterThanOrEquals(
     "positions.length",
     positions.length,
-    3
+    3,
   );
   //>>includeEnd('debug');
 
@@ -104,7 +104,7 @@ PolygonPipeline.computeSubdivision = function (
   positions,
   indices,
   texcoords,
-  granularity
+  granularity,
 ) {
   granularity = defaultValue(granularity, CesiumMath.RADIANS_PER_DEGREE);
 
@@ -159,17 +159,17 @@ PolygonPipeline.computeSubdivision = function (
     const v0 = Cartesian3.fromArray(
       subdividedPositions,
       i0 * 3,
-      subdivisionV0Scratch
+      subdivisionV0Scratch,
     );
     const v1 = Cartesian3.fromArray(
       subdividedPositions,
       i1 * 3,
-      subdivisionV1Scratch
+      subdivisionV1Scratch,
     );
     const v2 = Cartesian3.fromArray(
       subdividedPositions,
       i2 * 3,
-      subdivisionV2Scratch
+      subdivisionV2Scratch,
     );
 
     let t0, t1, t2;
@@ -177,44 +177,44 @@ PolygonPipeline.computeSubdivision = function (
       t0 = Cartesian2.fromArray(
         subdividedTexcoords,
         i0 * 2,
-        subdivisionT0Scratch
+        subdivisionT0Scratch,
       );
       t1 = Cartesian2.fromArray(
         subdividedTexcoords,
         i1 * 2,
-        subdivisionT1Scratch
+        subdivisionT1Scratch,
       );
       t2 = Cartesian2.fromArray(
         subdividedTexcoords,
         i2 * 2,
-        subdivisionT2Scratch
+        subdivisionT2Scratch,
       );
     }
 
     const s0 = Cartesian3.multiplyByScalar(
       Cartesian3.normalize(v0, subdivisionS0Scratch),
       radius,
-      subdivisionS0Scratch
+      subdivisionS0Scratch,
     );
     const s1 = Cartesian3.multiplyByScalar(
       Cartesian3.normalize(v1, subdivisionS1Scratch),
       radius,
-      subdivisionS1Scratch
+      subdivisionS1Scratch,
     );
     const s2 = Cartesian3.multiplyByScalar(
       Cartesian3.normalize(v2, subdivisionS2Scratch),
       radius,
-      subdivisionS2Scratch
+      subdivisionS2Scratch,
     );
 
     const g0 = Cartesian3.magnitudeSquared(
-      Cartesian3.subtract(s0, s1, subdivisionMidScratch)
+      Cartesian3.subtract(s0, s1, subdivisionMidScratch),
     );
     const g1 = Cartesian3.magnitudeSquared(
-      Cartesian3.subtract(s1, s2, subdivisionMidScratch)
+      Cartesian3.subtract(s1, s2, subdivisionMidScratch),
     );
     const g2 = Cartesian3.magnitudeSquared(
-      Cartesian3.subtract(s2, s0, subdivisionMidScratch)
+      Cartesian3.subtract(s2, s0, subdivisionMidScratch),
     );
 
     const max = Math.max(g0, g1, g2);
@@ -339,7 +339,7 @@ PolygonPipeline.computeRhumbLineSubdivision = function (
   positions,
   indices,
   texcoords,
-  granularity
+  granularity,
 ) {
   granularity = defaultValue(granularity, CesiumMath.RADIANS_PER_DEGREE);
 
@@ -397,17 +397,17 @@ PolygonPipeline.computeRhumbLineSubdivision = function (
     const v0 = Cartesian3.fromArray(
       subdividedPositions,
       i0 * 3,
-      subdivisionV0Scratch
+      subdivisionV0Scratch,
     );
     const v1 = Cartesian3.fromArray(
       subdividedPositions,
       i1 * 3,
-      subdivisionV1Scratch
+      subdivisionV1Scratch,
     );
     const v2 = Cartesian3.fromArray(
       subdividedPositions,
       i2 * 3,
-      subdivisionV2Scratch
+      subdivisionV2Scratch,
     );
 
     let t0, t1, t2;
@@ -415,17 +415,17 @@ PolygonPipeline.computeRhumbLineSubdivision = function (
       t0 = Cartesian2.fromArray(
         subdividedTexcoords,
         i0 * 2,
-        subdivisionT0Scratch
+        subdivisionT0Scratch,
       );
       t1 = Cartesian2.fromArray(
         subdividedTexcoords,
         i1 * 2,
-        subdivisionT1Scratch
+        subdivisionT1Scratch,
       );
       t2 = Cartesian2.fromArray(
         subdividedTexcoords,
         i2 * 2,
-        subdivisionT2Scratch
+        subdivisionT2Scratch,
       );
     }
 
@@ -456,7 +456,7 @@ PolygonPipeline.computeRhumbLineSubdivision = function (
         if (!defined(i)) {
           mid = rhumb0.interpolateUsingFraction(
             0.5,
-            subdivisionCartographicScratch
+            subdivisionCartographicScratch,
           );
           midHeight = (c0.height + c1.height) * 0.5;
           midCartesian3 = Cartesian3.fromRadians(
@@ -464,12 +464,12 @@ PolygonPipeline.computeRhumbLineSubdivision = function (
             mid.latitude,
             midHeight,
             ellipsoid,
-            subdivisionMidScratch
+            subdivisionMidScratch,
           );
           subdividedPositions.push(
             midCartesian3.x,
             midCartesian3.y,
-            midCartesian3.z
+            midCartesian3.z,
           );
           i = subdividedPositions.length / 3 - 1;
           edges[edge] = i;
@@ -490,7 +490,7 @@ PolygonPipeline.computeRhumbLineSubdivision = function (
         if (!defined(i)) {
           mid = rhumb1.interpolateUsingFraction(
             0.5,
-            subdivisionCartographicScratch
+            subdivisionCartographicScratch,
           );
           midHeight = (c1.height + c2.height) * 0.5;
           midCartesian3 = Cartesian3.fromRadians(
@@ -498,12 +498,12 @@ PolygonPipeline.computeRhumbLineSubdivision = function (
             mid.latitude,
             midHeight,
             ellipsoid,
-            subdivisionMidScratch
+            subdivisionMidScratch,
           );
           subdividedPositions.push(
             midCartesian3.x,
             midCartesian3.y,
-            midCartesian3.z
+            midCartesian3.z,
           );
           i = subdividedPositions.length / 3 - 1;
           edges[edge] = i;
@@ -524,7 +524,7 @@ PolygonPipeline.computeRhumbLineSubdivision = function (
         if (!defined(i)) {
           mid = rhumb2.interpolateUsingFraction(
             0.5,
-            subdivisionCartographicScratch
+            subdivisionCartographicScratch,
           );
           midHeight = (c2.height + c0.height) * 0.5;
           midCartesian3 = Cartesian3.fromRadians(
@@ -532,12 +532,12 @@ PolygonPipeline.computeRhumbLineSubdivision = function (
             mid.latitude,
             midHeight,
             ellipsoid,
-            subdivisionMidScratch
+            subdivisionMidScratch,
           );
           subdividedPositions.push(
             midCartesian3.x,
             midCartesian3.y,
-            midCartesian3.z
+            midCartesian3.z,
           );
           i = subdividedPositions.length / 3 - 1;
           edges[edge] = i;
@@ -595,7 +595,7 @@ PolygonPipeline.scaleToGeodeticHeight = function (
   positions,
   height,
   ellipsoid,
-  scaleToSurface
+  scaleToSurface,
 ) {
   ellipsoid = defaultValue(ellipsoid, Ellipsoid.default);
 

package/Source/Core/PolylineGeometry.js

@@ -52,7 +52,7 @@ function interpolateColors(p0, p1, color0, color1, numPoints) {
       r0 + i * redPerVertex,
       g0 + i * greenPerVertex,
       b0 + i * bluePerVertex,
-      a0 + i * alphaPerVertex
+      a0 + i * alphaPerVertex,
     );
   }
 
@@ -125,16 +125,16 @@ function PolylineGeometry(options) {
   this._width = width;
   this._colorsPerVertex = colorsPerVertex;
   this._vertexFormat = VertexFormat.clone(
-    defaultValue(options.vertexFormat, VertexFormat.DEFAULT)
+    defaultValue(options.vertexFormat, VertexFormat.DEFAULT),
   );
 
   this._arcType = defaultValue(options.arcType, ArcType.GEODESIC);
   this._granularity = defaultValue(
     options.granularity,
-    CesiumMath.RADIANS_PER_DEGREE
+    CesiumMath.RADIANS_PER_DEGREE,
   );
   this._ellipsoid = Ellipsoid.clone(
-    defaultValue(options.ellipsoid, Ellipsoid.default)
+    defaultValue(options.ellipsoid, Ellipsoid.default),
   );
   this._workerName = "createPolylineGeometry";
 
@@ -254,7 +254,7 @@ PolylineGeometry.unpack = function (array, startingIndex, result) {
   const vertexFormat = VertexFormat.unpack(
     array,
     startingIndex,
-    scratchVertexFormat
+    scratchVertexFormat,
   );
   startingIndex += VertexFormat.packedLength;
 
@@ -314,7 +314,7 @@ PolylineGeometry.createGeometry = function (polylineGeometry) {
     polylineGeometry._positions,
     Cartesian3.equalsEpsilon,
     false,
-    removedIndices
+    removedIndices,
   );
 
   if (defined(colors) && removedIndices.length > 0) {
@@ -352,7 +352,7 @@ PolylineGeometry.createGeometry = function (polylineGeometry) {
     if (arcType === ArcType.GEODESIC) {
       subdivisionSize = CesiumMath.chordLength(
         granularity,
-        ellipsoid.maximumRadius
+        ellipsoid.maximumRadius,
       );
       numberOfPointsFunction = PolylinePipeline.numberOfPoints;
     } else {
@@ -368,7 +368,7 @@ PolylineGeometry.createGeometry = function (polylineGeometry) {
         colorLength += numberOfPointsFunction(
           positions[i],
           positions[i + 1],
-          subdivisionSize
+          subdivisionSize,
         );
       }
 
@@ -388,7 +388,7 @@ PolylineGeometry.createGeometry = function (polylineGeometry) {
             p1,
             c0,
             c1,
-            numColors
+            numColors,
           );
           const interpolatedColorsLength = interpolatedColors.length;
           for (j = 0; j < interpolatedColorsLength; ++j) {
@@ -457,7 +457,7 @@ PolylineGeometry.createGeometry = function (polylineGeometry) {
       Cartesian3.subtract(
         positions[positionsLength - 1],
         positions[positionsLength - 2],
-        position
+        position,
       );
       Cartesian3.add(positions[positionsLength - 1], position, position);
     } else {

package/Source/Core/PolylinePipeline.js

@@ -28,7 +28,7 @@ PolylinePipeline.numberOfPointsRhumbLine = function (p0, p1, granularity) {
 
   return Math.max(
     1,
-    Math.ceil(Math.sqrt(radiansDistanceSquared / (granularity * granularity)))
+    Math.ceil(Math.sqrt(radiansDistanceSquared / (granularity * granularity))),
   );
 };
 
@@ -96,7 +96,7 @@ function generateCartesianArc(
   h0,
   h1,
   array,
-  offset
+  offset,
 ) {
   const first = ellipsoid.scaleToGeodeticSurface(p0, scaleFirst);
   const last = ellipsoid.scaleToGeodeticSurface(p1, scaleLast);
@@ -118,7 +118,7 @@ function generateCartesianArc(
   for (let i = 1; i < numPoints; i++) {
     const carto = ellipsoidGeodesic.interpolateUsingSurfaceDistance(
       i * surfaceDistanceBetweenPoints,
-      carto2
+      carto2,
     );
     carto.height = heights[i];
     cart = ellipsoid.cartographicToCartesian(carto, cartesian);
@@ -140,14 +140,14 @@ function generateCartesianRhumbArc(
   h0,
   h1,
   array,
-  offset
+  offset,
 ) {
   const start = ellipsoid.cartesianToCartographic(p0, carto1);
   const end = ellipsoid.cartesianToCartographic(p1, carto2);
   const numPoints = PolylinePipeline.numberOfPointsRhumbLine(
     start,
     end,
-    granularity
+    granularity,
   );
   start.height = 0.0;
   end.height = 0.0;
@@ -169,7 +169,7 @@ function generateCartesianRhumbArc(
   for (let i = 1; i < numPoints; i++) {
     const carto = ellipsoidRhumb.interpolateUsingSurfaceDistance(
       i * surfaceDistanceBetweenPoints,
-      carto2
+      carto2,
     );
     carto.height = heights[i];
     cart = ellipsoid.cartographicToCartesian(carto, cartesian);
@@ -211,39 +211,39 @@ PolylinePipeline.wrapLongitude = function (positions, modelMatrix) {
     modelMatrix = defaultValue(modelMatrix, Matrix4.IDENTITY);
     const inverseModelMatrix = Matrix4.inverseTransformation(
       modelMatrix,
-      wrapLongitudeInversMatrix
+      wrapLongitudeInversMatrix,
     );
 
     const origin = Matrix4.multiplyByPoint(
       inverseModelMatrix,
       Cartesian3.ZERO,
-      wrapLongitudeOrigin
+      wrapLongitudeOrigin,
     );
     const xzNormal = Cartesian3.normalize(
       Matrix4.multiplyByPointAsVector(
         inverseModelMatrix,
         Cartesian3.UNIT_Y,
-        wrapLongitudeXZNormal
+        wrapLongitudeXZNormal,
       ),
-      wrapLongitudeXZNormal
+      wrapLongitudeXZNormal,
     );
     const xzPlane = Plane.fromPointNormal(
       origin,
       xzNormal,
-      wrapLongitudeXZPlane
+      wrapLongitudeXZPlane,
     );
     const yzNormal = Cartesian3.normalize(
       Matrix4.multiplyByPointAsVector(
         inverseModelMatrix,
         Cartesian3.UNIT_X,
-        wrapLongitudeYZNormal
+        wrapLongitudeYZNormal,
       ),
-      wrapLongitudeYZNormal
+      wrapLongitudeYZNormal,
     );
     const yzPlane = Plane.fromPointNormal(
       origin,
       yzNormal,
-      wrapLongitudeYZPlane
+      wrapLongitudeYZPlane,
     );
 
     let count = 1;
@@ -264,27 +264,27 @@ PolylinePipeline.wrapLongitude = function (positions, modelMatrix) {
           prev,
           cur,
           xzPlane,
-          wrapLongitudeIntersection
+          wrapLongitudeIntersection,
         );
         if (defined(intersection)) {
           // move point on the xz-plane slightly away from the plane
           const offset = Cartesian3.multiplyByScalar(
             xzNormal,
             5.0e-9,
-            wrapLongitudeOffset
+            wrapLongitudeOffset,
           );
           if (Plane.getPointDistance(xzPlane, prev) < 0.0) {
             Cartesian3.negate(offset, offset);
           }
 
           cartesians.push(
-            Cartesian3.add(intersection, offset, new Cartesian3())
+            Cartesian3.add(intersection, offset, new Cartesian3()),
           );
           segments.push(count + 1);
 
           Cartesian3.negate(offset, offset);
           cartesians.push(
-            Cartesian3.add(intersection, offset, new Cartesian3())
+            Cartesian3.add(intersection, offset, new Cartesian3()),
           );
           count = 1;
         }
@@ -359,7 +359,7 @@ PolylinePipeline.generateArc = function (options) {
   if (!defined(minDistance)) {
     const granularity = defaultValue(
       options.granularity,
-      CesiumMath.RADIANS_PER_DEGREE
+      CesiumMath.RADIANS_PER_DEGREE,
     );
     minDistance = CesiumMath.chordLength(granularity, ellipsoid.maximumRadius);
   }
@@ -371,7 +371,7 @@ PolylinePipeline.generateArc = function (options) {
     numPoints += PolylinePipeline.numberOfPoints(
       positions[i],
       positions[i + 1],
-      minDistance
+      minDistance,
     );
   }
 
@@ -394,7 +394,7 @@ PolylinePipeline.generateArc = function (options) {
       h0,
       h1,
       newPositions,
-      offset
+      offset,
     );
   }
 
@@ -464,7 +464,7 @@ PolylinePipeline.generateRhumbArc = function (options) {
 
   const granularity = defaultValue(
     options.granularity,
-    CesiumMath.RADIANS_PER_DEGREE
+    CesiumMath.RADIANS_PER_DEGREE,
   );
 
   let numPoints = 0;
@@ -472,13 +472,13 @@ PolylinePipeline.generateRhumbArc = function (options) {
 
   let c0 = ellipsoid.cartesianToCartographic(
     positions[0],
-    scratchCartographic0
+    scratchCartographic0,
   );
   let c1;
   for (i = 0; i < length - 1; i++) {
     c1 = ellipsoid.cartesianToCartographic(
       positions[i + 1],
-      scratchCartographic1
+      scratchCartographic1,
     );
     numPoints += PolylinePipeline.numberOfPointsRhumbLine(c0, c1, granularity);
     c0 = Cartographic.clone(c1, scratchCartographic0);
@@ -503,7 +503,7 @@ PolylinePipeline.generateRhumbArc = function (options) {
       h0,
       h1,
       newPositions,
-      offset
+      offset,
     );
   }
 

package/Source/Core/PolylineVolumeGeometry.js

@@ -26,7 +26,7 @@ function computeAttributes(
   combinedPositions,
   shape,
   boundingRectangle,
-  vertexFormat
+  vertexFormat,
 ) {
   const attributes = new GeometryAttributes();
   if (vertexFormat.position) {
@@ -150,7 +150,7 @@ function computeAttributes(
     } catch (e) {
       oneTimeWarning(
         "polyline-volume-tangent-bitangent",
-        "Unable to compute tangents and bitangents for polyline volume geometry"
+        "Unable to compute tangents and bitangents for polyline volume geometry",
       );
       //TODO https://github.com/CesiumGS/cesium/issues/3609
     }
@@ -223,15 +223,15 @@ function PolylineVolumeGeometry(options) {
   this._positions = positions;
   this._shape = shape;
   this._ellipsoid = Ellipsoid.clone(
-    defaultValue(options.ellipsoid, Ellipsoid.default)
+    defaultValue(options.ellipsoid, Ellipsoid.default),
   );
   this._cornerType = defaultValue(options.cornerType, CornerType.ROUNDED);
   this._vertexFormat = VertexFormat.clone(
-    defaultValue(options.vertexFormat, VertexFormat.DEFAULT)
+    defaultValue(options.vertexFormat, VertexFormat.DEFAULT),
   );
   this._granularity = defaultValue(
     options.granularity,
-    CesiumMath.RADIANS_PER_DEGREE
+    CesiumMath.RADIANS_PER_DEGREE,
   );
   this._workerName = "createPolylineVolumeGeometry";
 
@@ -347,7 +347,7 @@ PolylineVolumeGeometry.unpack = function (array, startingIndex, result) {
   const vertexFormat = VertexFormat.unpack(
     array,
     startingIndex,
-    scratchVertexFormat
+    scratchVertexFormat,
   );
   startingIndex += VertexFormat.packedLength;
 
@@ -384,7 +384,7 @@ PolylineVolumeGeometry.createGeometry = function (polylineVolumeGeometry) {
   const positions = polylineVolumeGeometry._positions;
   const cleanPositions = arrayRemoveDuplicates(
     positions,
-    Cartesian3.equalsEpsilon
+    Cartesian3.equalsEpsilon,
   );
   let shape2D = polylineVolumeGeometry._shape;
   shape2D = PolylineVolumeGeometryLibrary.removeDuplicatesFromShape(shape2D);
@@ -405,13 +405,13 @@ PolylineVolumeGeometry.createGeometry = function (polylineVolumeGeometry) {
     shape2D,
     boundingRectangle,
     polylineVolumeGeometry,
-    true
+    true,
   );
   return computeAttributes(
     computedPositions,
     shape2D,
     boundingRectangle,
-    polylineVolumeGeometry._vertexFormat
+    polylineVolumeGeometry._vertexFormat,
   );
 };
 export default PolylineVolumeGeometry;