@cesium/engine 10.1.0 → 11.1.0

package/Source/Scene/GlobeSurfaceTileProvider.js

@@ -83,6 +83,7 @@ function GlobeSurfaceTileProvider(options) {
   this.lightingFadeOutDistance = 6500000.0;
   this.lightingFadeInDistance = 9000000.0;
   this.hasWaterMask = false;
+  this.showWaterEffect = false;
   this.oceanNormalMap = undefined;
   this.zoomedOutOceanSpecularIntensity = 0.5;
   this.enableLighting = false;
@@ -128,22 +129,26 @@ function GlobeSurfaceTileProvider(options) {
 
   this._errorEvent = new Event();
 
-  this._removeLayerAddedListener = this._imageryLayers.layerAdded.addEventListener(
-    GlobeSurfaceTileProvider.prototype._onLayerAdded,
-    this
-  );
-  this._removeLayerRemovedListener = this._imageryLayers.layerRemoved.addEventListener(
-    GlobeSurfaceTileProvider.prototype._onLayerRemoved,
-    this
-  );
-  this._removeLayerMovedListener = this._imageryLayers.layerMoved.addEventListener(
-    GlobeSurfaceTileProvider.prototype._onLayerMoved,
-    this
-  );
-  this._removeLayerShownListener = this._imageryLayers.layerShownOrHidden.addEventListener(
-    GlobeSurfaceTileProvider.prototype._onLayerShownOrHidden,
-    this
-  );
+  this._removeLayerAddedListener =
+    this._imageryLayers.layerAdded.addEventListener(
+      GlobeSurfaceTileProvider.prototype._onLayerAdded,
+      this,
+    );
+  this._removeLayerRemovedListener =
+    this._imageryLayers.layerRemoved.addEventListener(
+      GlobeSurfaceTileProvider.prototype._onLayerRemoved,
+      this,
+    );
+  this._removeLayerMovedListener =
+    this._imageryLayers.layerMoved.addEventListener(
+      GlobeSurfaceTileProvider.prototype._onLayerMoved,
+      this,
+    );
+  this._removeLayerShownListener =
+    this._imageryLayers.layerShownOrHidden.addEventListener(
+      GlobeSurfaceTileProvider.prototype._onLayerShownOrHidden,
+      this,
+    );
   this._imageryLayersUpdatedEvent = new Event();
 
   this._layerOrderChanged = false;
@@ -211,7 +216,7 @@ Object.defineProperties(GlobeSurfaceTileProvider.prototype, {
       this._baseColor = value;
       this._firstPassInitialColor = Cartesian4.fromColor(
         value,
-        this._firstPassInitialColor
+        this._firstPassInitialColor,
       );
     },
   },
@@ -476,7 +481,7 @@ GlobeSurfaceTileProvider.prototype.endUpdate = function (frameState) {
       this,
       this._quadtree._tilesToRender,
       frameState,
-      this._vertexArraysToDestroy
+      this._vertexArraysToDestroy,
     );
   }
 
@@ -533,7 +538,7 @@ GlobeSurfaceTileProvider.prototype.endUpdate = function (frameState) {
       addDrawCommandsForTile(this, tile, frameState);
       frameState.minimumTerrainHeight = Math.min(
         frameState.minimumTerrainHeight,
-        tileBoundingRegion.minimumHeight
+        tileBoundingRegion.minimumHeight,
       );
     }
   }
@@ -546,7 +551,7 @@ function pushCommand(command, frameState) {
     globeTranslucencyState.pushDerivedCommands(
       command,
       isBlendCommand,
-      frameState
+      frameState,
     );
   } else {
     frameState.commandList.push(command);
@@ -580,7 +585,7 @@ GlobeSurfaceTileProvider.prototype.cancelReprojections = function () {
  * @returns {number} The maximum geometric error in meters.
  */
 GlobeSurfaceTileProvider.prototype.getLevelMaximumGeometricError = function (
-  level
+  level,
 ) {
   if (!defined(this._terrainProvider)) {
     return 0;
@@ -620,7 +625,7 @@ GlobeSurfaceTileProvider.prototype.loadTile = function (frameState, tile) {
     this._imageryLayers,
     this.quadtree,
     this._vertexArraysToDestroy,
-    terrainOnly
+    terrainOnly,
   );
 
   surfaceTile = tile.data;
@@ -642,7 +647,7 @@ GlobeSurfaceTileProvider.prototype.loadTile = function (frameState, tile) {
         this._imageryLayers,
         this.quadtree,
         this._vertexArraysToDestroy,
-        terrainOnly
+        terrainOnly,
       );
     }
   }
@@ -660,7 +665,7 @@ function clipRectangleAntimeridian(tileRectangle, cartographicLimitRectangle) {
   }
   const splitRectangle = Rectangle.clone(
     cartographicLimitRectangle,
-    splitCartographicLimitRectangleScratch
+    splitCartographicLimitRectangleScratch,
   );
   const tileCenter = Rectangle.center(tileRectangle, rectangleCenterScratch);
   if (tileCenter.longitude > 0.0) {
@@ -697,7 +702,7 @@ function isUndergroundVisible(tileProvider, frameState) {
   if (
     !Rectangle.equals(
       tileProvider.cartographicLimitRectangle,
-      Rectangle.MAX_VALUE
+      Rectangle.MAX_VALUE,
     )
   ) {
     return true;
@@ -722,7 +727,7 @@ function isUndergroundVisible(tileProvider, frameState) {
 GlobeSurfaceTileProvider.prototype.computeTileVisibility = function (
   tile,
   frameState,
-  occluders
+  occluders,
 ) {
   const distance = this.computeDistanceToTile(tile, frameState);
   tile._distance = distance;
@@ -755,12 +760,12 @@ GlobeSurfaceTileProvider.prototype.computeTileVisibility = function (
   surfaceTile.clippedByBoundaries = false;
   const clippedCartographicLimitRectangle = clipRectangleAntimeridian(
     tile.rectangle,
-    this.cartographicLimitRectangle
+    this.cartographicLimitRectangle,
   );
   const areaLimitIntersection = Rectangle.simpleIntersection(
     clippedCartographicLimitRectangle,
     tile.rectangle,
-    rectangleIntersectionScratch
+    rectangleIntersectionScratch,
   );
   if (!defined(areaLimitIntersection)) {
     return Visibility.NONE;
@@ -776,13 +781,13 @@ GlobeSurfaceTileProvider.prototype.computeTileVisibility = function (
       frameState.mapProjection,
       tileBoundingRegion.minimumHeight,
       tileBoundingRegion.maximumHeight,
-      boundingVolume
+      boundingVolume,
     );
     Cartesian3.fromElements(
       boundingVolume.center.z,
       boundingVolume.center.x,
       boundingVolume.center.y,
-      boundingVolume.center
+      boundingVolume.center,
     );
 
     if (
@@ -792,7 +797,7 @@ GlobeSurfaceTileProvider.prototype.computeTileVisibility = function (
       boundingVolume = BoundingSphere.union(
         tileBoundingRegion.boundingSphere,
         boundingVolume,
-        boundingVolume
+        boundingVolume,
       );
     }
   }
@@ -803,9 +808,8 @@ GlobeSurfaceTileProvider.prototype.computeTileVisibility = function (
 
   const clippingPlanes = this._clippingPlanes;
   if (defined(clippingPlanes) && clippingPlanes.enabled) {
-    const planeIntersection = clippingPlanes.computeIntersectionWithBoundingVolume(
-      boundingVolume
-    );
+    const planeIntersection =
+      clippingPlanes.computeIntersectionWithBoundingVolume(boundingVolume);
     tile.isClipped = planeIntersection !== Intersect.INSIDE;
     if (planeIntersection === Intersect.OUTSIDE) {
       return Visibility.NONE;
@@ -814,9 +818,10 @@ GlobeSurfaceTileProvider.prototype.computeTileVisibility = function (
 
   const clippingPolygons = this._clippingPolygons;
   if (defined(clippingPolygons) && clippingPolygons.enabled) {
-    const polygonIntersection = clippingPolygons.computeIntersectionWithBoundingVolume(
-      tileBoundingRegion
-    );
+    const polygonIntersection =
+      clippingPolygons.computeIntersectionWithBoundingVolume(
+        tileBoundingRegion,
+      );
     tile.isClipped = polygonIntersection !== Intersect.OUTSIDE;
     // Polygon clipping intersections are determined by outer rectangles, therefore we cannot
     // preemptively determine if a tile is completely clipped or not here.
@@ -854,7 +859,7 @@ GlobeSurfaceTileProvider.prototype.computeTileVisibility = function (
     if (
       occluders.ellipsoid.isScaledSpacePointVisiblePossiblyUnderEllipsoid(
         occludeePointInScaledSpace,
-        tileBoundingRegion.minimumHeight
+        tileBoundingRegion.minimumHeight,
       )
     ) {
       return visibility;
@@ -882,7 +887,7 @@ GlobeSurfaceTileProvider.prototype.canRefine = function (tile) {
   const childAvailable = this.terrainProvider.getTileDataAvailable(
     tile.x * 2,
     tile.y * 2,
-    tile.level + 1
+    tile.level + 1,
   );
   return childAvailable !== undefined;
 };
@@ -900,7 +905,7 @@ const canRenderTraversalStack = [];
  */
 GlobeSurfaceTileProvider.prototype.canRenderWithoutLosingDetail = function (
   tile,
-  frameState
+  frameState,
 ) {
   const surfaceTile = tile.data;
 
@@ -956,7 +961,7 @@ GlobeSurfaceTileProvider.prototype.canRenderWithoutLosingDetail = function (
     tile.southwestChild,
     tile.southeastChild,
     tile.northwestChild,
-    tile.northeastChild
+    tile.northeastChild,
   );
 
   while (stack.length > 0) {
@@ -1006,7 +1011,7 @@ GlobeSurfaceTileProvider.prototype.canRenderWithoutLosingDetail = function (
         descendant.southwestChild,
         descendant.southeastChild,
         descendant.northwestChild,
-        descendant.northeastChild
+        descendant.northeastChild,
       );
     }
   }
@@ -1024,7 +1029,7 @@ const tileDirectionScratch = new Cartesian3();
  */
 GlobeSurfaceTileProvider.prototype.computeTileLoadPriority = function (
   tile,
-  frameState
+  frameState,
 ) {
   const surfaceTile = tile.data;
   if (surfaceTile === undefined) {
@@ -1041,7 +1046,7 @@ GlobeSurfaceTileProvider.prototype.computeTileLoadPriority = function (
   const tileDirection = Cartesian3.subtract(
     obb.center,
     cameraPosition,
-    tileDirectionScratch
+    tileDirectionScratch,
   );
   const magnitude = Cartesian3.magnitude(tileDirection);
   if (magnitude < CesiumMath.EPSILON5) {
@@ -1073,7 +1078,7 @@ const northeastScratch = new Cartesian3();
  */
 GlobeSurfaceTileProvider.prototype.showTileThisFrame = function (
   tile,
-  frameState
+  frameState,
 ) {
   let readyTextureCount = 0;
   const tileImageryCollection = tile.data.imagery;
@@ -1120,7 +1125,7 @@ function computeOccludeePoint(
   rectangle,
   minimumHeight,
   maximumHeight,
-  result
+  result,
 ) {
   const ellipsoidalOccluder = tileProvider.quadtree._occluders.ellipsoid;
   const ellipsoid = ellipsoidalOccluder.ellipsoid;
@@ -1131,35 +1136,35 @@ function computeOccludeePoint(
     rectangle.south,
     maximumHeight,
     ellipsoid,
-    cornerPositions[0]
+    cornerPositions[0],
   );
   Cartesian3.fromRadians(
     rectangle.east,
     rectangle.south,
     maximumHeight,
     ellipsoid,
-    cornerPositions[1]
+    cornerPositions[1],
   );
   Cartesian3.fromRadians(
     rectangle.west,
     rectangle.north,
     maximumHeight,
     ellipsoid,
-    cornerPositions[2]
+    cornerPositions[2],
   );
   Cartesian3.fromRadians(
     rectangle.east,
     rectangle.north,
     maximumHeight,
     ellipsoid,
-    cornerPositions[3]
+    cornerPositions[3],
   );
 
   return ellipsoidalOccluder.computeHorizonCullingPointPossiblyUnderEllipsoid(
     center,
     cornerPositions,
     minimumHeight,
-    result
+    result,
   );
 }
 
@@ -1173,7 +1178,7 @@ function computeOccludeePoint(
  */
 GlobeSurfaceTileProvider.prototype.computeDistanceToTile = function (
   tile,
-  frameState
+  frameState,
 ) {
   // The distance should be:
   // 1. the actual distance to the tight-fitting bounding volume, or
@@ -1314,12 +1319,12 @@ function updateTileBoundingRegion(tile, tileProvider, frameState) {
       tileBoundingRegion.minimumHeight = VerticalExaggeration.getHeight(
         tileBoundingRegion.minimumHeight,
         exaggeration,
-        exaggerationRelativeHeight
+        exaggerationRelativeHeight,
       );
       tileBoundingRegion.maximumHeight = VerticalExaggeration.getHeight(
         tileBoundingRegion.maximumHeight,
         exaggeration,
-        exaggerationRelativeHeight
+        exaggerationRelativeHeight,
       );
     }
 
@@ -1327,15 +1332,15 @@ function updateTileBoundingRegion(tile, tileProvider, frameState) {
       if (!surfaceTile.boundingVolumeIsFromMesh) {
         tileBoundingRegion._orientedBoundingBox = OrientedBoundingBox.clone(
           mesh.orientedBoundingBox,
-          tileBoundingRegion._orientedBoundingBox
+          tileBoundingRegion._orientedBoundingBox,
         );
         tileBoundingRegion._boundingSphere = BoundingSphere.clone(
           mesh.boundingSphere3D,
-          tileBoundingRegion._boundingSphere
+          tileBoundingRegion._boundingSphere,
         );
         surfaceTile.occludeePointInScaledSpace = Cartesian3.clone(
           mesh.occludeePointInScaledSpace,
-          surfaceTile.occludeePointInScaledSpace
+          surfaceTile.occludeePointInScaledSpace,
         );
 
         // If the occludee point is not defined, fallback to calculating it from the OBB
@@ -1346,7 +1351,7 @@ function updateTileBoundingRegion(tile, tileProvider, frameState) {
             tile.rectangle,
             tileBoundingRegion.minimumHeight,
             tileBoundingRegion.maximumHeight,
-            surfaceTile.occludeePointInScaledSpace
+            surfaceTile.occludeePointInScaledSpace,
           );
         }
       }
@@ -1366,7 +1371,7 @@ function updateTileBoundingRegion(tile, tileProvider, frameState) {
           tile.rectangle,
           tileBoundingRegion.minimumHeight,
           tileBoundingRegion.maximumHeight,
-          surfaceTile.occludeePointInScaledSpace
+          surfaceTile.occludeePointInScaledSpace,
         );
       }
     }
@@ -1437,7 +1442,7 @@ function getTileReadyCallback(tileImageriesToFree, layer, terrainProvider) {
       tileImagery = tileImageryCollection[i];
       imagery = defaultValue(
         tileImagery.readyImagery,
-        tileImagery.loadingImagery
+        tileImagery.loadingImagery,
       );
       if (imagery.imageryLayer === layer) {
         startIndex = i;
@@ -1457,7 +1462,7 @@ function getTileReadyCallback(tileImageriesToFree, layer, terrainProvider) {
         return !layer._createTileImagerySkeletons(
           tile,
           terrainProvider,
-          endIndex
+          endIndex,
         );
       }
 
@@ -1503,7 +1508,7 @@ GlobeSurfaceTileProvider.prototype._onLayerAdded = function (layer, index) {
           const tileImagery = tileImageryCollection[i];
           const imagery = defaultValue(
             tileImagery.readyImagery,
-            tileImagery.loadingImagery
+            tileImagery.loadingImagery,
           );
           if (imagery.imageryLayer === layer) {
             if (startIndex === -1) {
@@ -1529,14 +1534,14 @@ GlobeSurfaceTileProvider.prototype._onLayerAdded = function (layer, index) {
           layer._createTileImagerySkeletons(
             tile,
             terrainProvider,
-            insertionPoint
+            insertionPoint,
           )
         ) {
           // Add callback to remove old TileImageries when the new TileImageries are ready
           tile._loadedCallbacks[layer._layerIndex] = getTileReadyCallback(
             tileImageriesToFree,
             layer,
-            terrainProvider
+            terrainProvider,
           );
 
           tile.state = QuadtreeTileLoadState.LOADING;
@@ -1613,7 +1618,7 @@ GlobeSurfaceTileProvider.prototype._onLayerRemoved = function (layer, index) {
 GlobeSurfaceTileProvider.prototype._onLayerMoved = function (
   layer,
   newIndex,
-  oldIndex
+  oldIndex,
 ) {
   this._layerOrderChanged = true;
   this._imageryLayersUpdatedEvent.raiseEvent();
@@ -1622,7 +1627,7 @@ GlobeSurfaceTileProvider.prototype._onLayerMoved = function (
 GlobeSurfaceTileProvider.prototype._onLayerShownOrHidden = function (
   layer,
   index,
-  show
+  show,
 ) {
   if (show) {
     this._onLayerAdded(layer, index);
@@ -1685,7 +1690,7 @@ function createTileUniformMap(frameState, globeSurfaceTileProvider) {
       const centerEye = Matrix4.multiplyByPoint(
         viewMatrix,
         this.properties.rtc,
-        centerEyeScratch
+        centerEyeScratch,
       );
       Matrix4.setTranslation(viewMatrix, centerEye, modifiedModelViewScratch);
       return modifiedModelViewScratch;
@@ -1696,17 +1701,17 @@ function createTileUniformMap(frameState, globeSurfaceTileProvider) {
       const centerEye = Matrix4.multiplyByPoint(
         viewMatrix,
         this.properties.rtc,
-        centerEyeScratch
+        centerEyeScratch,
       );
       Matrix4.setTranslation(
         viewMatrix,
         centerEye,
-        modifiedModelViewProjectionScratch
+        modifiedModelViewProjectionScratch,
       );
       Matrix4.multiply(
         projectionMatrix,
         modifiedModelViewProjectionScratch,
-        modifiedModelViewProjectionScratch
+        modifiedModelViewProjectionScratch,
       );
       return modifiedModelViewProjectionScratch;
     },
@@ -1790,13 +1795,13 @@ function createTileUniformMap(frameState, globeSurfaceTileProvider) {
         ? Matrix4.multiply(
             frameState.context.uniformState.view,
             clippingPlanes.modelMatrix,
-            scratchClippingPlanesMatrix
+            scratchClippingPlanesMatrix,
           )
         : Matrix4.IDENTITY;
 
       return Matrix4.inverseTranspose(
         transform,
-        scratchInverseTransposeClippingPlanesMatrix
+        scratchInverseTransposeClippingPlanesMatrix,
       );
     },
     u_clippingPlanesEdgeStyle: function () {
@@ -1954,7 +1959,7 @@ function createWireframeVertexArrayIfNecessary(context, provider, tile) {
   surfaceTile.wireframeVertexArray = createWireframeVertexArray(
     context,
     vertexArray,
-    mesh
+    mesh,
   );
   surfaceTile.wireframeVertexArray.mesh = mesh;
 }
@@ -1986,7 +1991,7 @@ function createWireframeVertexArray(context, vertexArray, terrainMesh) {
     typedArray: wireframeIndices,
     usage: BufferUsage.STATIC_DRAW,
     indexDatatype: IndexDatatype.fromSizeInBytes(
-      wireframeIndices.BYTES_PER_ELEMENT
+      wireframeIndices.BYTES_PER_ELEMENT,
     ),
   });
   return new VertexArray({
@@ -2034,13 +2039,12 @@ let debugDestroyPrimitive;
     modelMatrix = Matrix4.fromRotationTranslation(
       obb.halfAxes,
       obb.center,
-      modelMatrix
+      modelMatrix,
     );
 
     instanceOBB.modelMatrix = modelMatrix;
-    instanceOBB.attributes.color = ColorGeometryInstanceAttribute.fromColor(
-      color
-    );
+    instanceOBB.attributes.color =
+      ColorGeometryInstanceAttribute.fromColor(color);
 
     primitive = createDebugPrimitive(instanceOBB);
     return primitive;
@@ -2057,13 +2061,12 @@ let debugDestroyPrimitive;
     modelMatrix = Matrix4.multiplyByUniformScale(
       modelMatrix,
       sphere.radius,
-      modelMatrix
+      modelMatrix,
     );
 
     instanceSphere.modelMatrix = modelMatrix;
-    instanceSphere.attributes.color = ColorGeometryInstanceAttribute.fromColor(
-      color
-    );
+    instanceSphere.attributes.color =
+      ColorGeometryInstanceAttribute.fromColor(color);
 
     primitive = createDebugPrimitive(instanceSphere);
     return primitive;
@@ -2165,11 +2168,11 @@ function addDrawCommandsForTile(tileProvider, tile, frameState) {
 
   const undergroundColor = defaultValue(
     tileProvider.undergroundColor,
-    defaultUndergroundColor
+    defaultUndergroundColor,
   );
   const undergroundColorAlphaByDistance = defaultValue(
     tileProvider.undergroundColorAlphaByDistance,
-    defaultUndergroundColorAlphaByDistance
+    defaultUndergroundColorAlphaByDistance,
   );
   const showUndergroundColor =
     isUndergroundVisible(tileProvider, frameState) &&
@@ -2181,8 +2184,8 @@ function addDrawCommandsForTile(tileProvider, tile, frameState) {
   const lambertDiffuseMultiplier = tileProvider.lambertDiffuseMultiplier;
   const vertexShadowDarkness = tileProvider.vertexShadowDarkness;
 
-  const showReflectiveOcean =
-    tileProvider.hasWaterMask && defined(waterMaskTexture);
+  const hasWaterMask = tileProvider.hasWaterMask && defined(waterMaskTexture);
+  const showReflectiveOcean = hasWaterMask && tileProvider.showWaterEffect;
   const oceanNormalMap = tileProvider.oceanNormalMap;
   const showOceanWaves = showReflectiveOcean && defined(oceanNormalMap);
   const terrainProvider = tileProvider.terrainProvider;
@@ -2214,7 +2217,7 @@ function addDrawCommandsForTile(tileProvider, tile, frameState) {
     perFragmentGroundAtmosphere = cameraDistance > fadeOutDistance;
   }
 
-  if (showReflectiveOcean) {
+  if (hasWaterMask) {
     --maxTextures;
   }
   if (showOceanWaves) {
@@ -2268,11 +2271,11 @@ function addDrawCommandsForTile(tileProvider, tile, frameState) {
     const projection = frameState.mapProjection;
     const southwest = projection.project(
       Rectangle.southwest(tile.rectangle),
-      southwestScratch
+      southwestScratch,
     );
     const northeast = projection.project(
       Rectangle.northeast(tile.rectangle),
-      northeastScratch
+      northeastScratch,
     );
 
     tileRectangle.x = southwest.x;
@@ -2313,9 +2316,8 @@ function addDrawCommandsForTile(tileProvider, tile, frameState) {
       southLatitude = tile.rectangle.south;
       northLatitude = tile.rectangle.north;
 
-      southMercatorY = WebMercatorProjection.geodeticLatitudeToMercatorAngle(
-        southLatitude
-      );
+      southMercatorY =
+        WebMercatorProjection.geodeticLatitudeToMercatorAngle(southLatitude);
 
       oneOverMercatorHeight =
         1.0 /
@@ -2329,6 +2331,7 @@ function addDrawCommandsForTile(tileProvider, tile, frameState) {
   const surfaceShaderSetOptions = surfaceShaderSetOptionsScratch;
   surfaceShaderSetOptions.frameState = frameState;
   surfaceShaderSetOptions.surfaceTile = surfaceTile;
+  surfaceShaderSetOptions.hasWaterMask = hasWaterMask;
   surfaceShaderSetOptions.showReflectiveOcean = showReflectiveOcean;
   surfaceShaderSetOptions.showOceanWaves = showOceanWaves;
   surfaceShaderSetOptions.enableLighting = tileProvider.enableLighting;
@@ -2349,7 +2352,8 @@ function addDrawCommandsForTile(tileProvider, tile, frameState) {
     tileProvider.atmosphereMieScaleHeight;
   surfaceShaderSetOptions.atmosphereMieAnisotropy =
     tileProvider.atmosphereMieAnisotropy;
-  surfaceShaderSetOptions.perFragmentGroundAtmosphere = perFragmentGroundAtmosphere;
+  surfaceShaderSetOptions.perFragmentGroundAtmosphere =
+    perFragmentGroundAtmosphere;
   surfaceShaderSetOptions.hasVertexNormals = hasVertexNormals;
   surfaceShaderSetOptions.useWebMercatorProjection = useWebMercatorProjection;
   surfaceShaderSetOptions.clippedByBoundaries = surfaceTile.clippedByBoundaries;
@@ -2388,7 +2392,7 @@ function addDrawCommandsForTile(tileProvider, tile, frameState) {
     for (let i = 0; i < drawCommandsLength; ++i) {
       tileProvider._uniformMaps[i] = createTileUniformMap(
         frameState,
-        tileProvider
+        tileProvider,
       );
     }
   }
@@ -2470,14 +2474,14 @@ function addDrawCommandsForTile(tileProvider, tile, frameState) {
         frontFaceAlphaByDistanceFinal.nearValue,
         frontFaceAlphaByDistanceFinal.far,
         frontFaceAlphaByDistanceFinal.farValue,
-        uniformMapProperties.frontFaceAlphaByDistance
+        uniformMapProperties.frontFaceAlphaByDistance,
       );
       Cartesian4.fromElements(
         backFaceAlphaByDistanceFinal.near,
         backFaceAlphaByDistanceFinal.nearValue,
         backFaceAlphaByDistanceFinal.far,
         backFaceAlphaByDistanceFinal.farValue,
-        uniformMapProperties.backFaceAlphaByDistance
+        uniformMapProperties.backFaceAlphaByDistance,
       );
     }
 
@@ -2486,7 +2490,7 @@ function addDrawCommandsForTile(tileProvider, tile, frameState) {
       undergroundColorAlphaByDistance.nearValue,
       undergroundColorAlphaByDistance.far,
       undergroundColorAlphaByDistance.farValue,
-      uniformMapProperties.undergroundColorAlphaByDistance
+      uniformMapProperties.undergroundColorAlphaByDistance,
     );
     Color.clone(undergroundColor, uniformMapProperties.undergroundColor);
 
@@ -2500,12 +2504,13 @@ function addDrawCommandsForTile(tileProvider, tile, frameState) {
     if (highlightFillTile) {
       Color.clone(
         tileProvider.fillHighlightColor,
-        uniformMapProperties.fillHighlightColor
+        uniformMapProperties.fillHighlightColor,
       );
     }
 
     uniformMapProperties.verticalExaggerationAndRelativeHeight.x = exaggeration;
-    uniformMapProperties.verticalExaggerationAndRelativeHeight.y = exaggerationRelativeHeight;
+    uniformMapProperties.verticalExaggerationAndRelativeHeight.y =
+      exaggerationRelativeHeight;
 
     uniformMapProperties.center3D = mesh.center;
     Cartesian3.clone(rtc, uniformMapProperties.rtc);
@@ -2514,26 +2519,29 @@ function addDrawCommandsForTile(tileProvider, tile, frameState) {
     uniformMapProperties.southAndNorthLatitude.x = southLatitude;
     uniformMapProperties.southAndNorthLatitude.y = northLatitude;
     uniformMapProperties.southMercatorYAndOneOverHeight.x = southMercatorY;
-    uniformMapProperties.southMercatorYAndOneOverHeight.y = oneOverMercatorHeight;
+    uniformMapProperties.southMercatorYAndOneOverHeight.y =
+      oneOverMercatorHeight;
 
     // Convert tile limiter rectangle from cartographic to texture space using the tileRectangle.
-    const localizedCartographicLimitRectangle = localizedCartographicLimitRectangleScratch;
+    const localizedCartographicLimitRectangle =
+      localizedCartographicLimitRectangleScratch;
     const cartographicLimitRectangle = clipRectangleAntimeridian(
       tile.rectangle,
-      tileProvider.cartographicLimitRectangle
+      tileProvider.cartographicLimitRectangle,
     );
 
-    const localizedTranslucencyRectangle = localizedTranslucencyRectangleScratch;
+    const localizedTranslucencyRectangle =
+      localizedTranslucencyRectangleScratch;
     const clippedTranslucencyRectangle = clipRectangleAntimeridian(
       tile.rectangle,
-      translucencyRectangle
+      translucencyRectangle,
     );
 
     Cartesian3.fromElements(
       hueShift,
       saturationShift,
       brightnessShift,
-      uniformMapProperties.hsbShift
+      uniformMapProperties.hsbShift,
     );
 
     const cartographicTileRectangle = tile.rectangle;
@@ -2554,7 +2562,7 @@ function addDrawCommandsForTile(tileProvider, tile, frameState) {
 
     Cartesian4.clone(
       localizedCartographicLimitRectangle,
-      uniformMapProperties.localizedCartographicLimitRectangle
+      uniformMapProperties.localizedCartographicLimitRectangle,
     );
 
     localizedTranslucencyRectangle.x =
@@ -2572,7 +2580,7 @@ function addDrawCommandsForTile(tileProvider, tile, frameState) {
 
     Cartesian4.clone(
       localizedTranslucencyRectangle,
-      uniformMapProperties.localizedTranslucencyRectangle
+      uniformMapProperties.localizedTranslucencyRectangle,
     );
 
     // For performance, render fog only when fog is enabled and the effect of
@@ -2627,10 +2635,8 @@ function addDrawCommandsForTile(tileProvider, tile, frameState) {
       const imageryLayer = imagery.imageryLayer;
 
       if (!defined(tileImagery.textureTranslationAndScale)) {
-        tileImagery.textureTranslationAndScale = imageryLayer._calculateTextureTranslationAndScale(
-          tile,
-          tileImagery
-        );
+        tileImagery.textureTranslationAndScale =
+          imageryLayer._calculateTextureTranslationAndScale(tile, tileImagery);
       }
 
       uniformMapProperties.dayTextures[numberOfDayTextures] = texture;
@@ -2704,21 +2710,21 @@ function addDrawCommandsForTile(tileProvider, tile, frameState) {
       let dayTextureCutoutRectangle =
         uniformMapProperties.dayTextureCutoutRectangles[numberOfDayTextures];
       if (!defined(dayTextureCutoutRectangle)) {
-        dayTextureCutoutRectangle = uniformMapProperties.dayTextureCutoutRectangles[
-          numberOfDayTextures
-        ] = new Cartesian4();
+        dayTextureCutoutRectangle =
+          uniformMapProperties.dayTextureCutoutRectangles[numberOfDayTextures] =
+            new Cartesian4();
       }
 
       Cartesian4.clone(Cartesian4.ZERO, dayTextureCutoutRectangle);
       if (defined(imageryLayer.cutoutRectangle)) {
         const cutoutRectangle = clipRectangleAntimeridian(
           cartographicTileRectangle,
-          imageryLayer.cutoutRectangle
+          imageryLayer.cutoutRectangle,
         );
         const intersection = Rectangle.simpleIntersection(
           cutoutRectangle,
           cartographicTileRectangle,
-          rectangleIntersectionScratch
+          rectangleIntersectionScratch,
         );
         applyCutout = defined(intersection) || applyCutout;
 
@@ -2740,9 +2746,8 @@ function addDrawCommandsForTile(tileProvider, tile, frameState) {
       let colorToAlpha =
         uniformMapProperties.colorsToAlpha[numberOfDayTextures];
       if (!defined(colorToAlpha)) {
-        colorToAlpha = uniformMapProperties.colorsToAlpha[
-          numberOfDayTextures
-        ] = new Cartesian4();
+        colorToAlpha = uniformMapProperties.colorsToAlpha[numberOfDayTextures] =
+          new Cartesian4();
       }
 
       const hasColorToAlpha =
@@ -2780,7 +2785,7 @@ function addDrawCommandsForTile(tileProvider, tile, frameState) {
     uniformMapProperties.waterMask = waterMaskTexture;
     Cartesian4.clone(
       waterMaskTranslationAndScale,
-      uniformMapProperties.waterMaskTranslationAndScale
+      uniformMapProperties.waterMaskTranslationAndScale,
     );
 
     uniformMapProperties.minMaxHeight.x = encoding.minimumHeight;
@@ -2794,7 +2799,7 @@ function addDrawCommandsForTile(tileProvider, tile, frameState) {
     if (clippingPlanesEnabled) {
       uniformMapProperties.clippingPlanesEdgeColor = Color.clone(
         clippingPlanes.edgeColor,
-        uniformMapProperties.clippingPlanesEdgeColor
+        uniformMapProperties.clippingPlanesEdgeColor,
       );
       uniformMapProperties.clippingPlanesEdgeWidth = clippingPlanes.edgeWidth;
     }
@@ -2831,7 +2836,7 @@ function addDrawCommandsForTile(tileProvider, tile, frameState) {
     }
 
     command.shaderProgram = tileProvider._surfaceShaderSet.getShaderProgram(
-      surfaceShaderSetOptions
+      surfaceShaderSetOptions,
     );
     command.castShadows = castShadows;
     command.receiveShadows = receiveShadows;
@@ -2861,30 +2866,30 @@ function addDrawCommandsForTile(tileProvider, tile, frameState) {
         frameState.mapProjection,
         tileBoundingRegion.minimumHeight,
         tileBoundingRegion.maximumHeight,
-        boundingVolume
+        boundingVolume,
       );
       Cartesian3.fromElements(
         boundingVolume.center.z,
         boundingVolume.center.x,
         boundingVolume.center.y,
-        boundingVolume.center
+        boundingVolume.center,
       );
 
       if (frameState.mode === SceneMode.MORPHING) {
         boundingVolume = BoundingSphere.union(
           tileBoundingRegion.boundingSphere,
           boundingVolume,
-          boundingVolume
+          boundingVolume,
         );
       }
     } else {
       command.boundingVolume = BoundingSphere.clone(
         tileBoundingRegion.boundingSphere,
-        boundingVolume
+        boundingVolume,
       );
       command.orientedBoundingBox = OrientedBoundingBox.clone(
         tileBoundingRegion.boundingVolume,
-        orientedBoundingBox
+        orientedBoundingBox,
       );
     }