@cesium/engine 11.0.0 → 11.1.0

package/Source/Scene/TextureAtlas.js

@@ -17,7 +17,7 @@ function TextureAtlasNode(
   topRight,
   childNode1,
   childNode2,
-  imageIndex
+  imageIndex,
 ) {
   this.bottomLeft = defaultValue(bottomLeft, Cartesian2.ZERO);
   this.topRight = defaultValue(topRight, Cartesian2.ZERO);
@@ -60,7 +60,7 @@ function TextureAtlas(options) {
   }
   if (borderWidthInPixels < 0) {
     throw new DeveloperError(
-      "borderWidthInPixels must be greater than or equal to zero."
+      "borderWidthInPixels must be greater than or equal to zero.",
     );
   }
   if (initialSize.x < 1 || initialSize.y < 1) {
@@ -172,23 +172,23 @@ function resizeAtlas(textureAtlas, image) {
     // Create new node structure, putting the old root node in the bottom left.
     const nodeBottomRight = new TextureAtlasNode(
       new Cartesian2(oldAtlasWidth + borderWidthInPixels, borderWidthInPixels),
-      new Cartesian2(atlasWidth, oldAtlasHeight)
+      new Cartesian2(atlasWidth, oldAtlasHeight),
     );
     const nodeBottomHalf = new TextureAtlasNode(
       new Cartesian2(),
       new Cartesian2(atlasWidth, oldAtlasHeight),
       textureAtlas._root,
-      nodeBottomRight
+      nodeBottomRight,
     );
     const nodeTopHalf = new TextureAtlasNode(
       new Cartesian2(borderWidthInPixels, oldAtlasHeight + borderWidthInPixels),
-      new Cartesian2(atlasWidth, atlasHeight)
+      new Cartesian2(atlasWidth, atlasHeight),
     );
     const nodeMain = new TextureAtlasNode(
       new Cartesian2(),
       new Cartesian2(atlasWidth, atlasHeight),
       nodeBottomHalf,
-      nodeTopHalf
+      nodeTopHalf,
     );
 
     // Resize texture coordinates.
@@ -245,7 +245,7 @@ function resizeAtlas(textureAtlas, image) {
     });
     textureAtlas._root = new TextureAtlasNode(
       new Cartesian2(borderWidthInPixels, borderWidthInPixels),
-      new Cartesian2(initialWidth, initialHeight)
+      new Cartesian2(initialWidth, initialHeight),
     );
   }
 }
@@ -284,7 +284,7 @@ function findNode(textureAtlas, node, image) {
     if (widthDifference > heightDifference) {
       node.childNode1 = new TextureAtlasNode(
         new Cartesian2(node.bottomLeft.x, node.bottomLeft.y),
-        new Cartesian2(node.bottomLeft.x + image.width, node.topRight.y)
+        new Cartesian2(node.bottomLeft.x + image.width, node.topRight.y),
       );
       // Only make a second child if the border gives enough space.
       const childNode2BottomLeftX =
@@ -292,7 +292,7 @@ function findNode(textureAtlas, node, image) {
       if (childNode2BottomLeftX < node.topRight.x) {
         node.childNode2 = new TextureAtlasNode(
           new Cartesian2(childNode2BottomLeftX, node.bottomLeft.y),
-          new Cartesian2(node.topRight.x, node.topRight.y)
+          new Cartesian2(node.topRight.x, node.topRight.y),
         );
       }
     }
@@ -300,7 +300,7 @@ function findNode(textureAtlas, node, image) {
     else {
       node.childNode1 = new TextureAtlasNode(
         new Cartesian2(node.bottomLeft.x, node.bottomLeft.y),
-        new Cartesian2(node.topRight.x, node.bottomLeft.y + image.height)
+        new Cartesian2(node.topRight.x, node.bottomLeft.y + image.height),
       );
       // Only make a second child if the border gives enough space.
       const childNode2BottomLeftY =
@@ -308,7 +308,7 @@ function findNode(textureAtlas, node, image) {
       if (childNode2BottomLeftY < node.topRight.y) {
         node.childNode2 = new TextureAtlasNode(
           new Cartesian2(node.bottomLeft.x, childNode2BottomLeftY),
-          new Cartesian2(node.topRight.x, node.topRight.y)
+          new Cartesian2(node.topRight.x, node.topRight.y),
         );
       }
     }

package/Source/Scene/TileBoundingRegion.js

@@ -145,11 +145,11 @@ TileBoundingRegion.prototype.computeBoundingVolumes = function (ellipsoid) {
     this.rectangle,
     this.minimumHeight,
     this.maximumHeight,
-    ellipsoid
+    ellipsoid,
   );
 
   this._boundingSphere = BoundingSphere.fromOrientedBoundingBox(
-    this._orientedBoundingBox
+    this._orientedBoundingBox,
   );
 };
 
@@ -167,11 +167,11 @@ const rayScratch = new Ray();
 function computeBox(tileBB, rectangle, ellipsoid) {
   ellipsoid.cartographicToCartesian(
     Rectangle.southwest(rectangle),
-    tileBB.southwestCornerCartesian
+    tileBB.southwestCornerCartesian,
   );
   ellipsoid.cartographicToCartesian(
     Rectangle.northeast(rectangle),
-    tileBB.northeastCornerCartesian
+    tileBB.northeastCornerCartesian,
   );
 
   // The middle latitude on the western edge.
@@ -180,14 +180,14 @@ function computeBox(tileBB, rectangle, ellipsoid) {
   cartographicScratch.height = 0.0;
   const westernMidpointCartesian = ellipsoid.cartographicToCartesian(
     cartographicScratch,
-    westernMidpointScratch
+    westernMidpointScratch,
   );
 
   // Compute the normal of the plane on the western edge of the tile.
   const westNormal = Cartesian3.cross(
     westernMidpointCartesian,
     Cartesian3.UNIT_Z,
-    westNormalScratch
+    westNormalScratch,
   );
   Cartesian3.normalize(westNormal, tileBB.westNormal);
 
@@ -195,21 +195,21 @@ function computeBox(tileBB, rectangle, ellipsoid) {
   cartographicScratch.longitude = rectangle.east;
   const easternMidpointCartesian = ellipsoid.cartographicToCartesian(
     cartographicScratch,
-    easternMidpointScratch
+    easternMidpointScratch,
   );
 
   // Compute the normal of the plane on the eastern edge of the tile.
   const eastNormal = Cartesian3.cross(
     Cartesian3.UNIT_Z,
     easternMidpointCartesian,
-    cartesian3Scratch
+    cartesian3Scratch,
   );
   Cartesian3.normalize(eastNormal, tileBB.eastNormal);
 
   let westVector = Cartesian3.subtract(
     westernMidpointCartesian,
     easternMidpointCartesian,
-    cartesian3Scratch
+    cartesian3Scratch,
   );
 
   if (Cartesian3.magnitude(westVector) === 0.0) {
@@ -218,7 +218,7 @@ function computeBox(tileBB, rectangle, ellipsoid) {
 
   const eastWestNormal = Cartesian3.normalize(
     westVector,
-    eastWestNormalScratch
+    eastWestNormalScratch,
   );
 
   // Compute the normal of the plane bounding the southern edge of the tile.
@@ -231,34 +231,34 @@ function computeBox(tileBB, rectangle, ellipsoid) {
     cartographicScratch.latitude = south;
     const southCenterCartesian = ellipsoid.cartographicToCartesian(
       cartographicScratch,
-      rayScratch.origin
+      rayScratch.origin,
     );
     Cartesian3.clone(eastWestNormal, rayScratch.direction);
     const westPlane = Plane.fromPointNormal(
       tileBB.southwestCornerCartesian,
       tileBB.westNormal,
-      planeScratch
+      planeScratch,
     );
     // Find a point that is on the west and the south planes
     IntersectionTests.rayPlane(
       rayScratch,
       westPlane,
-      tileBB.southwestCornerCartesian
+      tileBB.southwestCornerCartesian,
     );
     southSurfaceNormal = ellipsoid.geodeticSurfaceNormal(
       southCenterCartesian,
-      cartesian3Scratch2
+      cartesian3Scratch2,
     );
   } else {
     southSurfaceNormal = ellipsoid.geodeticSurfaceNormalCartographic(
       Rectangle.southeast(rectangle),
-      cartesian3Scratch2
+      cartesian3Scratch2,
     );
   }
   const southNormal = Cartesian3.cross(
     southSurfaceNormal,
     westVector,
-    cartesian3Scratch3
+    cartesian3Scratch3,
   );
   Cartesian3.normalize(southNormal, tileBB.southNormal);
 
@@ -272,34 +272,34 @@ function computeBox(tileBB, rectangle, ellipsoid) {
     cartographicScratch.latitude = north;
     const northCenterCartesian = ellipsoid.cartographicToCartesian(
       cartographicScratch,
-      rayScratch.origin
+      rayScratch.origin,
     );
     Cartesian3.negate(eastWestNormal, rayScratch.direction);
     const eastPlane = Plane.fromPointNormal(
       tileBB.northeastCornerCartesian,
       tileBB.eastNormal,
-      planeScratch
+      planeScratch,
     );
     // Find a point that is on the east and the north planes
     IntersectionTests.rayPlane(
       rayScratch,
       eastPlane,
-      tileBB.northeastCornerCartesian
+      tileBB.northeastCornerCartesian,
     );
     northSurfaceNormal = ellipsoid.geodeticSurfaceNormal(
       northCenterCartesian,
-      cartesian3Scratch2
+      cartesian3Scratch2,
     );
   } else {
     northSurfaceNormal = ellipsoid.geodeticSurfaceNormalCartographic(
       Rectangle.northwest(rectangle),
-      cartesian3Scratch2
+      cartesian3Scratch2,
     );
   }
   const northNormal = Cartesian3.cross(
     westVector,
     northSurfaceNormal,
-    cartesian3Scratch3
+    cartesian3Scratch3,
   );
   Cartesian3.normalize(northNormal, tileBB.northNormal);
 }
@@ -327,14 +327,14 @@ function distanceToCameraRegion(tileBB, frameState) {
     if (frameState.mode !== SceneMode.SCENE3D) {
       southwestCornerCartesian = frameState.mapProjection.project(
         Rectangle.southwest(tileBB.rectangle),
-        southwestCornerScratch
+        southwestCornerScratch,
       );
       southwestCornerCartesian.z = southwestCornerCartesian.y;
       southwestCornerCartesian.y = southwestCornerCartesian.x;
       southwestCornerCartesian.x = 0.0;
       northeastCornerCartesian = frameState.mapProjection.project(
         Rectangle.northeast(tileBB.rectangle),
-        northeastCornerScratch
+        northeastCornerScratch,
       );
       northeastCornerCartesian.z = northeastCornerCartesian.y;
       northeastCornerCartesian.y = northeastCornerCartesian.x;
@@ -348,29 +348,29 @@ function distanceToCameraRegion(tileBB, frameState) {
     const vectorFromSouthwestCorner = Cartesian3.subtract(
       cameraCartesianPosition,
       southwestCornerCartesian,
-      vectorScratch
+      vectorScratch,
     );
     const distanceToWestPlane = Cartesian3.dot(
       vectorFromSouthwestCorner,
-      westNormal
+      westNormal,
     );
     const distanceToSouthPlane = Cartesian3.dot(
       vectorFromSouthwestCorner,
-      southNormal
+      southNormal,
     );
 
     const vectorFromNortheastCorner = Cartesian3.subtract(
       cameraCartesianPosition,
       northeastCornerCartesian,
-      vectorScratch
+      vectorScratch,
     );
     const distanceToEastPlane = Cartesian3.dot(
       vectorFromNortheastCorner,
-      eastNormal
+      eastNormal,
     );
     const distanceToNorthPlane = Cartesian3.dot(
       vectorFromNortheastCorner,
-      northNormal
+      northNormal,
     );
 
     if (distanceToWestPlane > 0.0) {
@@ -427,7 +427,7 @@ TileBoundingRegion.prototype.distanceToCamera = function (frameState) {
     defined(this._orientedBoundingBox)
   ) {
     const obbResult = Math.sqrt(
-      this._orientedBoundingBox.distanceSquaredTo(frameState.camera.positionWC)
+      this._orientedBoundingBox.distanceSquaredTo(frameState.camera.positionWC),
     );
     return Math.max(regionResult, obbResult);
   }

package/Source/Scene/TileBoundingS2Cell.js

@@ -53,7 +53,7 @@ function TileBoundingS2Cell(options) {
     s2Cell,
     minimumHeight,
     maximumHeight,
-    ellipsoid
+    ellipsoid,
   );
   this._boundingPlanes = boundingPlanes;
 
@@ -66,7 +66,7 @@ function TileBoundingS2Cell(options) {
 
   this._edgeNormals[0] = computeEdgeNormals(
     boundingPlanes[0],
-    vertices.slice(0, 4)
+    vertices.slice(0, 4),
   );
   let i;
   // Based on the way the edge normals are computed, the edge normals all point away from the "face"
@@ -75,13 +75,13 @@ function TileBoundingS2Cell(options) {
   for (i = 0; i < 4; i++) {
     this._edgeNormals[0][i] = Cartesian3.negate(
       this._edgeNormals[0][i],
-      this._edgeNormals[0][i]
+      this._edgeNormals[0][i],
     );
   }
 
   this._edgeNormals[1] = computeEdgeNormals(
     boundingPlanes[1],
-    vertices.slice(4, 8)
+    vertices.slice(4, 8),
   );
   for (i = 0; i < 4; i++) {
     // For each plane, iterate through the vertices in CCW order.
@@ -109,12 +109,12 @@ function TileBoundingS2Cell(options) {
   const center = s2Cell.getCenter();
   centerCartographicScratch = ellipsoid.cartesianToCartographic(
     center,
-    centerCartographicScratch
+    centerCartographicScratch,
   );
   centerCartographicScratch.height = (maximumHeight + minimumHeight) / 2;
   this.center = ellipsoid.cartographicToCartesian(
     centerCartographicScratch,
-    center
+    center,
   );
 
   this._boundingSphere = BoundingSphere.fromPoints(vertices);
@@ -136,7 +136,7 @@ function computeBoundingPlanes(
   s2Cell,
   minimumHeight,
   maximumHeight,
-  ellipsoid
+  ellipsoid,
 ) {
   const planes = new Array(6);
   const centerPoint = s2Cell.getCenter();
@@ -147,11 +147,11 @@ function computeBoundingPlanes(
   // - Create top plane from surface normal and top point.
   const centerSurfaceNormal = ellipsoid.geodeticSurfaceNormal(
     centerPoint,
-    centerGeodeticNormalScratch
+    centerGeodeticNormalScratch,
   );
   const topCartographic = ellipsoid.cartesianToCartographic(
     centerPoint,
-    topCartographicScratch
+    topCartographicScratch,
   );
   topCartographic.height = maximumHeight;
   const top = ellipsoid.cartographicToCartesian(topCartographic, topScratch);
@@ -172,12 +172,12 @@ function computeBoundingPlanes(
     vertices[i] = vertex;
     vertexCartographic = ellipsoid.cartesianToCartographic(
       vertex,
-      vertexCartographicScratch
+      vertexCartographicScratch,
     );
     vertexCartographic.height = minimumHeight;
     const distance = Plane.getPointDistance(
       topPlane,
-      ellipsoid.cartographicToCartesian(vertexCartographic, vertexScratch)
+      ellipsoid.cartographicToCartesian(vertexCartographic, vertexScratch),
     );
     if (distance < maxDistance) {
       maxDistance = distance;
@@ -187,7 +187,7 @@ function computeBoundingPlanes(
   // Negate the normal of the bottom plane since we want all normals to point "outwards".
   bottomPlane.normal = Cartesian3.negate(
     bottomPlane.normal,
-    bottomPlane.normal
+    bottomPlane.normal,
   );
   bottomPlane.distance = bottomPlane.distance * -1 + maxDistance;
   planes[1] = bottomPlane;
@@ -203,7 +203,7 @@ function computeBoundingPlanes(
     const adjacentVertex = vertices[(i + 1) % 4];
     const geodeticNormal = ellipsoid.geodeticSurfaceNormal(
       vertex,
-      vertexGeodeticNormalScratch
+      vertexGeodeticNormalScratch,
     );
     const side = Cartesian3.subtract(adjacentVertex, vertex, sideScratch);
     let sideNormal = Cartesian3.cross(side, geodeticNormal, sideNormalScratch);
@@ -244,17 +244,17 @@ function computeIntersection(p0, p1, p2) {
   f0Scratch = Cartesian3.multiplyByScalar(
     Cartesian3.cross(n1Scratch, n2Scratch, t0Scratch),
     Cartesian3.dot(x0Scratch, n0Scratch),
-    f0Scratch
+    f0Scratch,
   );
   f1Scratch = Cartesian3.multiplyByScalar(
     Cartesian3.cross(n2Scratch, n0Scratch, t1Scratch),
     Cartesian3.dot(x1Scratch, n1Scratch),
-    f1Scratch
+    f1Scratch,
   );
   f2Scratch = Cartesian3.multiplyByScalar(
     Cartesian3.cross(n0Scratch, n1Scratch, t2Scratch),
     Cartesian3.dot(x2Scratch, n2Scratch),
-    f2Scratch
+    f2Scratch,
   );
 
   matrixScratch[0] = n0Scratch.x;
@@ -272,7 +272,7 @@ function computeIntersection(p0, p1, p2) {
   return new Cartesian3(
     sScratch.x / determinant,
     sScratch.y / determinant,
-    sScratch.z / determinant
+    sScratch.z / determinant,
   );
 }
 /**
@@ -286,13 +286,13 @@ function computeVertices(boundingPlanes) {
     vertices[i] = computeIntersection(
       boundingPlanes[0],
       boundingPlanes[2 + ((i + 3) % 4)],
-      boundingPlanes[2 + (i % 4)]
+      boundingPlanes[2 + (i % 4)],
     );
     // Vertices on the bottom plane.
     vertices[i + 4] = computeIntersection(
       boundingPlanes[1],
       boundingPlanes[2 + ((i + 3) % 4)],
-      boundingPlanes[2 + (i % 4)]
+      boundingPlanes[2 + (i % 4)],
     );
   }
   return vertices;
@@ -310,16 +310,16 @@ function computeEdgeNormals(plane, vertices) {
     edgeScratch = Cartesian3.subtract(
       vertices[(i + 1) % 4],
       vertices[i],
-      edgeScratch
+      edgeScratch,
     );
     edgeNormalScratch = Cartesian3.cross(
       plane.normal,
       edgeScratch,
-      edgeNormalScratch
+      edgeNormalScratch,
     );
     edgeNormalScratch = Cartesian3.normalize(
       edgeNormalScratch,
-      edgeNormalScratch
+      edgeNormalScratch,
     );
     edgeNormals[i] = Cartesian3.clone(edgeNormalScratch);
   }
@@ -438,7 +438,7 @@ TileBoundingS2Cell.prototype.distanceToCamera = function (frameState) {
       Plane.projectPointOntoPlane(selectedPlane, point, facePointScratch),
       vertices[0],
       selectedPlane,
-      edgeNormals
+      edgeNormals,
     );
 
     return Cartesian3.distance(facePoint, point);
@@ -466,7 +466,7 @@ TileBoundingS2Cell.prototype.distanceToCamera = function (frameState) {
         Plane.projectPointOntoPlane(selectedPlane, point, facePointScratch),
         vertices[i],
         selectedPlane,
-        this._edgeNormals[selectedPlaneIndices[i]]
+        this._edgeNormals[selectedPlaneIndices[i]],
       );
 
       distance = Cartesian3.distanceSquared(facePoint, point);
@@ -481,11 +481,11 @@ TileBoundingS2Cell.prototype.distanceToCamera = function (frameState) {
       Plane.projectPointOntoPlane(
         this._boundingPlanes[1],
         point,
-        facePointScratch
+        facePointScratch,
       ),
       this._planeVertices[1],
       this._boundingPlanes[1],
-      this._edgeNormals[1]
+      this._edgeNormals[1],
     );
     return Cartesian3.distance(facePoint, point);
   }
@@ -498,14 +498,14 @@ TileBoundingS2Cell.prototype.distanceToCamera = function (frameState) {
   if (selectedPlaneIndices[0] === 0) {
     return Cartesian3.distance(
       point,
-      this._vertices[(selectedPlaneIndices[1] - 2 + skip) % 4]
+      this._vertices[(selectedPlaneIndices[1] - 2 + skip) % 4],
     );
   }
 
   // Vertex is on bottom plane.
   return Cartesian3.distance(
     point,
-    this._vertices[4 + ((selectedPlaneIndices[1] - 2 + skip) % 4)]
+    this._vertices[4 + ((selectedPlaneIndices[1] - 2 + skip) % 4)],
   );
 };
 
@@ -533,7 +533,7 @@ function closestPointLineSegment(p, l0, l1) {
   return new Cartesian3(
     (1 - t) * l0.x + t * l1.x,
     (1 - t) * l0.y + t * l1.y,
-    (1 - t) * l0.z + t * l1.z
+    (1 - t) * l0.z + t * l1.z,
   );
 }
 
@@ -553,7 +553,7 @@ function closestPointPolygon(p, vertices, plane, edgeNormals) {
     const edgePlane = Plane.fromPointNormal(
       vertices[i],
       edgeNormals[i],
-      edgePlaneScratch
+      edgePlaneScratch,
     );
     const edgePlaneDistance = Plane.getPointDistance(edgePlane, p);
 
@@ -566,7 +566,7 @@ function closestPointPolygon(p, vertices, plane, edgeNormals) {
     closestPointOnEdge = closestPointLineSegment(
       p,
       vertices[i],
-      vertices[(i + 1) % 4]
+      vertices[(i + 1) % 4],
     );
 
     distance = Cartesian3.distance(p, closestPointOnEdge);
@@ -634,9 +634,8 @@ TileBoundingS2Cell.prototype.createDebugVolume = function (color) {
       positions: this._planeVertices[0],
     },
   });
-  const topPlaneGeometry = CoplanarPolygonOutlineGeometry.createGeometry(
-    topPlanePolygon
-  );
+  const topPlaneGeometry =
+    CoplanarPolygonOutlineGeometry.createGeometry(topPlanePolygon);
   const topPlaneInstance = new GeometryInstance({
     geometry: topPlaneGeometry,
     id: "outline",
@@ -651,9 +650,8 @@ TileBoundingS2Cell.prototype.createDebugVolume = function (color) {
       positions: this._planeVertices[1],
     },
   });
-  const bottomPlaneGeometry = CoplanarPolygonOutlineGeometry.createGeometry(
-    bottomPlanePolygon
-  );
+  const bottomPlaneGeometry =
+    CoplanarPolygonOutlineGeometry.createGeometry(bottomPlanePolygon);
   const bottomPlaneInstance = new GeometryInstance({
     geometry: bottomPlaneGeometry,
     id: "outline",
@@ -670,9 +668,8 @@ TileBoundingS2Cell.prototype.createDebugVolume = function (color) {
         positions: this._planeVertices[2 + i],
       },
     });
-    const sidePlaneGeometry = CoplanarPolygonOutlineGeometry.createGeometry(
-      sidePlanePolygon
-    );
+    const sidePlaneGeometry =
+      CoplanarPolygonOutlineGeometry.createGeometry(sidePlanePolygon);
     sideInstances[i] = new GeometryInstance({
       geometry: sidePlaneGeometry,
       id: "outline",

package/Source/Scene/TileBoundingSphere.js

@@ -98,7 +98,7 @@ TileBoundingSphere.prototype.distanceToCamera = function (frameState) {
   return Math.max(
     0.0,
     Cartesian3.distance(boundingSphere.center, frameState.camera.positionWC) -
-      boundingSphere.radius
+      boundingSphere.radius,
   );
 };
 
@@ -144,7 +144,7 @@ TileBoundingSphere.prototype.createDebugVolume = function (color) {
   });
   const modelMatrix = Matrix4.fromTranslation(
     this.center,
-    new Matrix4.clone(Matrix4.IDENTITY)
+    new Matrix4.clone(Matrix4.IDENTITY),
   );
   const instance = new GeometryInstance({
     geometry: geometry,

package/Source/Scene/TileCoordinatesImageryProvider.js

@@ -205,7 +205,7 @@ Object.defineProperties(TileCoordinatesImageryProvider.prototype, {
 TileCoordinatesImageryProvider.prototype.getTileCredits = function (
   x,
   y,
-  level
+  level,
 ) {
   return undefined;
 };
@@ -223,7 +223,7 @@ TileCoordinatesImageryProvider.prototype.requestImage = function (
   x,
   y,
   level,
-  request
+  request,
 ) {
   const canvas = document.createElement("canvas");
   canvas.width = 256;
@@ -262,7 +262,7 @@ TileCoordinatesImageryProvider.prototype.pickFeatures = function (
   y,
   level,
   longitude,
-  latitude
+  latitude,
 ) {
   return undefined;
 };

package/Source/Scene/TileImagery.js

@@ -46,7 +46,7 @@ TileImagery.prototype.freeResources = function () {
 TileImagery.prototype.processStateMachine = function (
   tile,
   frameState,
-  skipLoading
+  skipLoading,
 ) {
   const loadingImagery = this.loadingImagery;
   const imageryLayer = loadingImagery.imageryLayer;
@@ -54,7 +54,7 @@ TileImagery.prototype.processStateMachine = function (
   loadingImagery.processStateMachine(
     frameState,
     !this.useWebMercatorT,
-    skipLoading
+    skipLoading,
   );
 
   if (loadingImagery.state === ImageryState.READY) {
@@ -63,10 +63,8 @@ TileImagery.prototype.processStateMachine = function (
     }
     this.readyImagery = this.loadingImagery;
     this.loadingImagery = undefined;
-    this.textureTranslationAndScale = imageryLayer._calculateTextureTranslationAndScale(
-      tile,
-      this
-    );
+    this.textureTranslationAndScale =
+      imageryLayer._calculateTextureTranslationAndScale(tile, this);
     return true; // done loading
   }
 
@@ -98,10 +96,8 @@ TileImagery.prototype.processStateMachine = function (
 
     if (defined(ancestor)) {
       ancestor.addReference();
-      this.textureTranslationAndScale = imageryLayer._calculateTextureTranslationAndScale(
-        tile,
-        this
-      );
+      this.textureTranslationAndScale =
+        imageryLayer._calculateTextureTranslationAndScale(tile, this);
     }
   }
 
@@ -117,7 +113,7 @@ TileImagery.prototype.processStateMachine = function (
       closestAncestorThatNeedsLoading.processStateMachine(
         frameState,
         !this.useWebMercatorT,
-        skipLoading
+        skipLoading,
       );
       return false; // not done loading
     }