@cesium/engine 10.1.0 → 11.1.0

package/Source/Scene/Globe.js

@@ -69,7 +69,7 @@ function Globe(ellipsoid) {
     ellipsoid.maximumRadius / 1000.0,
     0.0,
     ellipsoid.maximumRadius / 5.0,
-    1.0
+    1.0,
   );
 
   this._translucency = new GlobeTranslucency();
@@ -612,13 +612,13 @@ Object.defineProperties(Globe.prototype, {
       //>>includeStart('debug', pragmas.debug);
       if (defined(value) && value.far < value.near) {
         throw new DeveloperError(
-          "far distance must be greater than near distance."
+          "far distance must be greater than near distance.",
         );
       }
       //>>includeEnd('debug');
       this._undergroundColorAlphaByDistance = NearFarScalar.clone(
         value,
-        this._undergroundColorAlphaByDistance
+        this._undergroundColorAlphaByDistance,
       );
     },
   },
@@ -673,11 +673,11 @@ function createComparePickTileFunction(rayOrigin) {
   return function (a, b) {
     const aDist = BoundingSphere.distanceSquaredTo(
       a.pickBoundingSphere,
-      rayOrigin
+      rayOrigin,
     );
     const bDist = BoundingSphere.distanceSquaredTo(
       b.pickBoundingSphere,
-      rayOrigin
+      rayOrigin,
     );
 
     return aDist - bDist;
@@ -705,7 +705,7 @@ Globe.prototype.pickWorldCoordinates = function (
   ray,
   scene,
   cullBackFaces,
-  result
+  result,
 ) {
   //>>includeStart('debug', pragmas.debug);
   if (!defined(ray)) {
@@ -740,23 +740,24 @@ Globe.prototype.pickWorldCoordinates = function (
 
     let boundingVolume = surfaceTile.pickBoundingSphere;
     if (mode !== SceneMode.SCENE3D) {
-      surfaceTile.pickBoundingSphere = boundingVolume = BoundingSphere.fromRectangleWithHeights2D(
-        tile.rectangle,
-        projection,
-        surfaceTile.tileBoundingRegion.minimumHeight,
-        surfaceTile.tileBoundingRegion.maximumHeight,
-        boundingVolume
-      );
+      surfaceTile.pickBoundingSphere = boundingVolume =
+        BoundingSphere.fromRectangleWithHeights2D(
+          tile.rectangle,
+          projection,
+          surfaceTile.tileBoundingRegion.minimumHeight,
+          surfaceTile.tileBoundingRegion.maximumHeight,
+          boundingVolume,
+        );
       Cartesian3.fromElements(
         boundingVolume.center.z,
         boundingVolume.center.x,
         boundingVolume.center.y,
-        boundingVolume.center
+        boundingVolume.center,
       );
     } else if (defined(surfaceTile.renderedMesh)) {
       BoundingSphere.clone(
         surfaceTile.tileBoundingRegion.boundingSphere,
-        boundingVolume
+        boundingVolume,
       );
     } else {
       // So wait how did we render this thing then? It shouldn't be possible to get here.
@@ -766,7 +767,7 @@ Globe.prototype.pickWorldCoordinates = function (
     const boundingSphereIntersection = IntersectionTests.raySphere(
       ray,
       boundingVolume,
-      scratchSphereIntersectionResult
+      scratchSphereIntersectionResult,
     );
     if (defined(boundingSphereIntersection)) {
       sphereIntersections.push(surfaceTile);
@@ -783,7 +784,7 @@ Globe.prototype.pickWorldCoordinates = function (
       scene.mode,
       scene.mapProjection,
       cullBackFaces,
-      result
+      result,
     );
     if (defined(intersection)) {
       break;
@@ -905,13 +906,13 @@ Globe.prototype.getHeight = function (cartographic) {
     cartographic.latitude,
     0.0,
     ellipsoid,
-    scratchGetHeightCartesian
+    scratchGetHeightCartesian,
   );
 
   const ray = scratchGetHeightRay;
   const surfaceNormal = ellipsoid.geodeticSurfaceNormal(
     cartesian,
-    ray.direction
+    ray.direction,
   );
 
   // Try to find the intersection point between the surface normal and z-axis.
@@ -919,7 +920,7 @@ Globe.prototype.getHeight = function (cartographic) {
   const rayOrigin = ellipsoid.getSurfaceNormalIntersectionWithZAxis(
     cartesian,
     11500.0,
-    ray.origin
+    ray.origin,
   );
 
   // Theoretically, not with Earth datums, the intersection point can be outside the ellipsoid
@@ -936,7 +937,7 @@ Globe.prototype.getHeight = function (cartographic) {
     const vectorToMinimumPoint = Cartesian3.multiplyByScalar(
       surfaceNormal,
       Math.abs(magnitude) + 1,
-      scratchGetHeightIntersection
+      scratchGetHeightIntersection,
     );
     Cartesian3.subtract(cartesian, vectorToMinimumPoint, ray.origin);
   }
@@ -946,7 +947,7 @@ Globe.prototype.getHeight = function (cartographic) {
     undefined,
     projection,
     false,
-    scratchGetHeightIntersection
+    scratchGetHeightIntersection,
   );
   if (!defined(intersection)) {
     return undefined;
@@ -954,7 +955,7 @@ Globe.prototype.getHeight = function (cartographic) {
 
   return ellipsoid.cartesianToCartographic(
     intersection,
-    scratchGetHeightCartographic
+    scratchGetHeightCartographic,
   ).height;
 };
 
@@ -979,7 +980,6 @@ Globe.prototype.beginFrame = function (frameState) {
   const tileProvider = surface.tileProvider;
   const terrainProvider = this.terrainProvider;
   const hasWaterMask =
-    this.showWaterEffect &&
     defined(terrainProvider) &&
     terrainProvider.hasWaterMask &&
     terrainProvider.hasWaterMask;
@@ -1034,15 +1034,19 @@ Globe.prototype.beginFrame = function (frameState) {
     tileProvider.zoomedOutOceanSpecularIntensity =
       mode === SceneMode.SCENE3D ? this._zoomedOutOceanSpecularIntensity : 0.0;
     tileProvider.hasWaterMask = hasWaterMask;
+    tileProvider.showWaterEffect = this.showWaterEffect;
     tileProvider.oceanNormalMap = this._oceanNormalMap;
     tileProvider.enableLighting = this.enableLighting;
     tileProvider.dynamicAtmosphereLighting = this.dynamicAtmosphereLighting;
-    tileProvider.dynamicAtmosphereLightingFromSun = this.dynamicAtmosphereLightingFromSun;
+    tileProvider.dynamicAtmosphereLightingFromSun =
+      this.dynamicAtmosphereLightingFromSun;
     tileProvider.showGroundAtmosphere = this.showGroundAtmosphere;
     tileProvider.atmosphereLightIntensity = this.atmosphereLightIntensity;
-    tileProvider.atmosphereRayleighCoefficient = this.atmosphereRayleighCoefficient;
+    tileProvider.atmosphereRayleighCoefficient =
+      this.atmosphereRayleighCoefficient;
     tileProvider.atmosphereMieCoefficient = this.atmosphereMieCoefficient;
-    tileProvider.atmosphereRayleighScaleHeight = this.atmosphereRayleighScaleHeight;
+    tileProvider.atmosphereRayleighScaleHeight =
+      this.atmosphereRayleighScaleHeight;
     tileProvider.atmosphereMieScaleHeight = this.atmosphereMieScaleHeight;
     tileProvider.atmosphereMieAnisotropy = this.atmosphereMieAnisotropy;
     tileProvider.shadows = this.shadows;
@@ -1054,7 +1058,8 @@ Globe.prototype.beginFrame = function (frameState) {
     tileProvider.backFaceCulling = this.backFaceCulling;
     tileProvider.vertexShadowDarkness = this.vertexShadowDarkness;
     tileProvider.undergroundColor = this._undergroundColor;
-    tileProvider.undergroundColorAlphaByDistance = this._undergroundColorAlphaByDistance;
+    tileProvider.undergroundColorAlphaByDistance =
+      this._undergroundColorAlphaByDistance;
     tileProvider.lambertDiffuseMultiplier = this.lambertDiffuseMultiplier;
 
     surface.beginFrame(frameState);

package/Source/Scene/GlobeDepth.js

@@ -14,6 +14,9 @@ import StencilFunction from "./StencilFunction.js";
 import StencilOperation from "./StencilOperation.js";
 
 /**
+ * @alias GlobeDepth
+ * @constructor
+ *
  * @private
  */
 function GlobeDepth() {
@@ -83,21 +86,14 @@ Object.defineProperties(GlobeDepth.prototype, {
   },
 });
 
-function destroyFramebuffers(globeDepth) {
-  globeDepth._pickColorFramebuffer.destroy();
-  globeDepth._outputFramebuffer.destroy();
-  globeDepth._copyDepthFramebuffer.destroy();
-  globeDepth._tempCopyDepthFramebuffer.destroy();
-  globeDepth._updateDepthFramebuffer.destroy();
-}
-
 function updateCopyCommands(globeDepth, context, width, height, passState) {
-  globeDepth._viewport.width = width;
-  globeDepth._viewport.height = height;
+  const viewport = globeDepth._viewport;
+  viewport.width = width;
+  viewport.height = height;
 
   const useScissorTest = !BoundingRectangle.equals(
-    globeDepth._viewport,
-    passState.viewport
+    viewport,
+    passState.viewport,
   );
   let updateScissor = useScissorTest !== globeDepth._useScissorTest;
   globeDepth._useScissorTest = useScissorTest;
@@ -107,25 +103,25 @@ function updateCopyCommands(globeDepth, context, width, height, passState) {
   ) {
     globeDepth._scissorRectangle = BoundingRectangle.clone(
       passState.viewport,
-      globeDepth._scissorRectangle
+      globeDepth._scissorRectangle,
     );
     updateScissor = true;
   }
 
   if (
     !defined(globeDepth._rs) ||
-    !BoundingRectangle.equals(globeDepth._viewport, globeDepth._rs.viewport) ||
+    !BoundingRectangle.equals(viewport, globeDepth._rs.viewport) ||
     updateScissor
   ) {
     globeDepth._rs = RenderState.fromCache({
-      viewport: globeDepth._viewport,
+      viewport: viewport,
       scissorTest: {
         enabled: globeDepth._useScissorTest,
         rectangle: globeDepth._scissorRectangle,
       },
     });
     globeDepth._rsBlend = RenderState.fromCache({
-      viewport: globeDepth._viewport,
+      viewport: viewport,
       scissorTest: {
         enabled: globeDepth._useScissorTest,
         rectangle: globeDepth._scissorRectangle,
@@ -135,7 +131,7 @@ function updateCopyCommands(globeDepth, context, width, height, passState) {
 
     // Copy packed depth only if the 3D Tiles bit is set
     globeDepth._rsUpdate = RenderState.fromCache({
-      viewport: globeDepth._viewport,
+      viewport: viewport,
       scissorTest: {
         enabled: globeDepth._useScissorTest,
         rectangle: globeDepth._scissorRectangle,
@@ -165,7 +161,7 @@ function updateCopyCommands(globeDepth, context, width, height, passState) {
           },
         },
         owner: globeDepth,
-      }
+      },
     );
   }
 
@@ -183,7 +179,7 @@ function updateCopyCommands(globeDepth, context, width, height, passState) {
           },
         },
         owner: globeDepth,
-      }
+      },
     );
   }
 
@@ -199,7 +195,7 @@ function updateCopyCommands(globeDepth, context, width, height, passState) {
           },
         },
         owner: globeDepth,
-      }
+      },
     );
   }
 
@@ -217,7 +213,7 @@ function updateCopyCommands(globeDepth, context, width, height, passState) {
           },
         },
         owner: globeDepth,
-      }
+      },
     );
   }
 
@@ -236,16 +232,27 @@ function updateCopyCommands(globeDepth, context, width, height, passState) {
   globeDepth._clearGlobeColorCommand.framebuffer = globeDepth.framebuffer;
 }
 
+/**
+ * Update framebuffers and render state.
+ *
+ * @param {Context} context The context used for rendering.
+ * @param {PassState} passState Rendering state for subsequent render passes.
+ * @param {BoundingRectangle} viewport The viewport for the rendering.
+ * @param {number} numSamples The number of samples for multi-sample anti-aliasing (MSAA).
+ * @param {boolean} hdr <code>true</code> if the color output needs to be floating point for HDR rendering.
+ * @param {boolean} clearGlobeDepth <code>true</code> if the depth buffer should be cleared before rendering 3D Tiles and opaque entities.
+ *
+ * @private
+ */
 GlobeDepth.prototype.update = function (
   context,
   passState,
   viewport,
   numSamples,
   hdr,
-  clearGlobeDepth
+  clearGlobeDepth,
 ) {
-  const width = viewport.width;
-  const height = viewport.height;
+  const { width, height } = viewport;
 
   const pixelDatatype = hdr
     ? context.halfFloatingPointTexture
@@ -261,17 +268,24 @@ GlobeDepth.prototype.update = function (
       width,
       height,
       numSamples,
-      pixelDatatype
+      pixelDatatype,
     );
   }
   this._copyDepthFramebuffer.update(context, width, height);
   updateCopyCommands(this, context, width, height, passState);
   context.uniformState.globeDepthTexture = undefined;
 
-  this._useHdr = hdr;
   this._clearGlobeDepth = clearGlobeDepth;
 };
 
+/**
+ * If using MSAA, resolve the stencil.
+ *
+ * @param {Context} context
+ * @param {boolean} blitStencil <code>true</code> if the stencil has been set.
+ *
+ * @private
+ */
 GlobeDepth.prototype.prepareColorTextures = function (context, blitStencil) {
   if (!this.picking && this._numSamples > 1) {
     this._outputFramebuffer.prepareTextures(context, blitStencil);
@@ -282,58 +296,65 @@ GlobeDepth.prototype.executeCopyDepth = function (context, passState) {
   if (defined(this._copyDepthCommand)) {
     this.prepareColorTextures(context);
     this._copyDepthCommand.execute(context, passState);
-    context.uniformState.globeDepthTexture = this._copyDepthFramebuffer.getColorTexture();
+    context.uniformState.globeDepthTexture =
+      this._copyDepthFramebuffer.getColorTexture();
   }
 };
 
+/**
+ * Update the existing depth texture using a stencil.
+ *
+ * @param {Context} context The context used for rendering.
+ * @param {PassState} passState Render state for subsequent rendering passes.
+ * @param {Texture} [depthTexture] The depth texture to copy.
+ */
 GlobeDepth.prototype.executeUpdateDepth = function (
   context,
   passState,
-  clearGlobeDepth,
-  depthTexture
+  depthTexture,
 ) {
   const depthTextureToCopy = defined(depthTexture)
     ? depthTexture
     : passState.framebuffer.depthStencilTexture;
   if (
-    clearGlobeDepth ||
-    depthTextureToCopy !== this.colorFramebufferManager.getDepthStencilTexture()
+    !this._clearGlobeDepth &&
+    depthTextureToCopy === this.colorFramebufferManager.getDepthStencilTexture()
   ) {
-    // First copy the depth to a temporary globe depth texture, then update the
-    // main globe depth texture where the stencil bit for 3D Tiles is set.
-    // This preserves the original globe depth except where 3D Tiles is rendered.
-    // The additional texture and framebuffer resources are created on demand.
-    if (defined(this._updateDepthCommand)) {
-      if (
-        !defined(this._updateDepthFramebuffer.framebuffer) ||
-        this._updateDepthFramebuffer.getDepthStencilTexture() !==
-          depthTextureToCopy ||
-        this._updateDepthFramebuffer.getColorTexture() !==
-          this._copyDepthFramebuffer.getColorTexture()
-      ) {
-        const width = this._copyDepthFramebuffer.getColorTexture().width;
-        const height = this._copyDepthFramebuffer.getColorTexture().height;
-        this._tempCopyDepthFramebuffer.destroy();
-        this._tempCopyDepthFramebuffer.update(context, width, height);
-
-        const colorTexture = this._copyDepthFramebuffer.getColorTexture();
-        this._updateDepthFramebuffer.setColorTexture(colorTexture, 0);
-        this._updateDepthFramebuffer.setDepthStencilTexture(depthTextureToCopy);
-        this._updateDepthFramebuffer.update(context, width, height);
-
-        updateCopyCommands(this, context, width, height, passState);
-      }
-      this._tempCopyDepthTexture = depthTextureToCopy;
-      this._tempCopyDepthCommand.execute(context, passState);
-      this._updateDepthCommand.execute(context, passState);
+    // Fast path - the depth texture can be copied normally.
+    if (defined(this._copyDepthCommand)) {
+      this._copyDepthCommand.execute(context, passState);
     }
     return;
   }
+  if (!defined(this._updateDepthCommand)) {
+    return;
+  }
 
-  // Fast path - the depth texture can be copied normally.
-  if (defined(this._copyDepthCommand)) {
-    this._copyDepthCommand.execute(context, passState);
+  // First copy the depth to a temporary globe depth texture, then update the
+  // main globe depth texture where the stencil bit for 3D Tiles is set.
+  // This preserves the original globe depth except where 3D Tiles is rendered.
+  // The additional texture and framebuffer resources are created on demand.
+  const updateDepthFramebuffer = this._updateDepthFramebuffer;
+  if (
+    !defined(updateDepthFramebuffer.framebuffer) ||
+    updateDepthFramebuffer.getDepthStencilTexture() !== depthTextureToCopy ||
+    updateDepthFramebuffer.getColorTexture() !==
+      this._copyDepthFramebuffer.getColorTexture()
+  ) {
+    const colorTexture = this._copyDepthFramebuffer.getColorTexture();
+    const { width, height } = colorTexture;
+    this._tempCopyDepthFramebuffer.destroy();
+    this._tempCopyDepthFramebuffer.update(context, width, height);
+
+    updateDepthFramebuffer.setColorTexture(colorTexture, 0);
+    updateDepthFramebuffer.setDepthStencilTexture(depthTextureToCopy);
+    updateDepthFramebuffer.update(context, width, height);
+
+    updateCopyCommands(this, context, width, height, passState);
   }
+  this._tempCopyDepthTexture = depthTextureToCopy;
+  this._tempCopyDepthCommand.execute(context, passState);
+  this._updateDepthCommand.execute(context, passState);
 };
 
 GlobeDepth.prototype.executeCopyColor = function (context, passState) {
@@ -355,22 +376,30 @@ GlobeDepth.prototype.isDestroyed = function () {
 };
 
 GlobeDepth.prototype.destroy = function () {
-  destroyFramebuffers(this);
+  this._pickColorFramebuffer.destroy();
+  this._outputFramebuffer.destroy();
+  this._copyDepthFramebuffer.destroy();
+  this._tempCopyDepthFramebuffer.destroy();
+  this._updateDepthFramebuffer.destroy();
 
   if (defined(this._copyColorCommand)) {
-    this._copyColorCommand.shaderProgram = this._copyColorCommand.shaderProgram.destroy();
+    this._copyColorCommand.shaderProgram =
+      this._copyColorCommand.shaderProgram.destroy();
   }
 
   if (defined(this._copyDepthCommand)) {
-    this._copyDepthCommand.shaderProgram = this._copyDepthCommand.shaderProgram.destroy();
+    this._copyDepthCommand.shaderProgram =
+      this._copyDepthCommand.shaderProgram.destroy();
   }
 
   if (defined(this._tempCopyDepthCommand)) {
-    this._tempCopyDepthCommand.shaderProgram = this._tempCopyDepthCommand.shaderProgram.destroy();
+    this._tempCopyDepthCommand.shaderProgram =
+      this._tempCopyDepthCommand.shaderProgram.destroy();
   }
 
   if (defined(this._updateDepthCommand)) {
-    this._updateDepthCommand.shaderProgram = this._updateDepthCommand.shaderProgram.destroy();
+    this._updateDepthCommand.shaderProgram =
+      this._updateDepthCommand.shaderProgram.destroy();
   }
 
   return destroyObject(this);

package/Source/Scene/GlobeSurfaceShaderSet.js

@@ -11,7 +11,7 @@ function GlobeSurfaceShader(
   material,
   shaderProgram,
   clippingShaderState,
-  clippingPolygonShaderState
+  clippingPolygonShaderState,
 ) {
   this.numberOfDayTextures = numberOfDayTextures;
   this.flags = flags;
@@ -109,6 +109,7 @@ GlobeSurfaceShaderSet.prototype.getShaderProgram = function (options) {
   const applyAlpha = options.applyAlpha;
   const applyDayNightAlpha = options.applyDayNightAlpha;
   const applySplit = options.applySplit;
+  const hasWaterMask = options.hasWaterMask;
   const showReflectiveOcean = options.showReflectiveOcean;
   const showOceanWaves = options.showOceanWaves;
   const enableLighting = options.enableLighting;
@@ -168,30 +169,31 @@ GlobeSurfaceShaderSet.prototype.getShaderProgram = function (options) {
     (applySaturation << 5) |
     (applyGamma << 6) |
     (applyAlpha << 7) |
-    (showReflectiveOcean << 8) |
-    (showOceanWaves << 9) |
-    (enableLighting << 10) |
-    (dynamicAtmosphereLighting << 11) |
-    (dynamicAtmosphereLightingFromSun << 12) |
-    (showGroundAtmosphere << 13) |
-    (perFragmentGroundAtmosphere << 14) |
-    (hasVertexNormals << 15) |
-    (useWebMercatorProjection << 16) |
-    (enableFog << 17) |
-    (quantization << 18) |
-    (applySplit << 19) |
-    (enableClippingPlanes << 20) |
-    (enableClippingPolygons << 21) |
-    (cartographicLimitRectangleFlag << 22) |
-    (imageryCutoutFlag << 23) |
-    (colorCorrect << 24) |
-    (highlightFillTile << 25) |
-    (colorToAlpha << 26) |
-    (hasGeodeticSurfaceNormals << 27) |
-    (hasExaggeration << 28) |
-    (showUndergroundColor << 29) |
-    (translucent << 30) |
-    (applyDayNightAlpha << 31);
+    (hasWaterMask << 8) |
+    (showReflectiveOcean << 9) |
+    (showOceanWaves << 10) |
+    (enableLighting << 11) |
+    (dynamicAtmosphereLighting << 12) |
+    (dynamicAtmosphereLightingFromSun << 13) |
+    (showGroundAtmosphere << 14) |
+    (perFragmentGroundAtmosphere << 15) |
+    (hasVertexNormals << 16) |
+    (useWebMercatorProjection << 17) |
+    (enableFog << 18) |
+    (quantization << 19) |
+    (applySplit << 20) |
+    (enableClippingPlanes << 21) |
+    (enableClippingPolygons << 22) |
+    (cartographicLimitRectangleFlag << 23) |
+    (imageryCutoutFlag << 24) |
+    (colorCorrect << 25) |
+    (highlightFillTile << 26) |
+    (colorToAlpha << 27) |
+    (hasGeodeticSurfaceNormals << 28) |
+    (hasExaggeration << 29) |
+    (showUndergroundColor << 30) |
+    (translucent << 31) |
+    (applyDayNightAlpha << 32);
 
   let currentClippingShaderState = 0;
   if (defined(clippingPlanes) && clippingPlanes.length > 0) {
@@ -241,7 +243,7 @@ GlobeSurfaceShaderSet.prototype.getShaderProgram = function (options) {
     // Need to go before GlobeFS
     if (currentClippingShaderState !== 0) {
       fs.sources.unshift(
-        getClippingFunction(clippingPlanes, frameState.context)
+        getClippingFunction(clippingPlanes, frameState.context),
       );
     }
 
@@ -255,7 +257,7 @@ GlobeSurfaceShaderSet.prototype.getShaderProgram = function (options) {
     fs.defines.push(
       `TEXTURE_UNITS ${numberOfDayTextures}`,
       cartographicLimitRectangleDefine,
-      imageryCutoutDefine
+      imageryCutoutDefine,
     );
 
     if (applyBrightness) {
@@ -279,6 +281,9 @@ GlobeSurfaceShaderSet.prototype.getShaderProgram = function (options) {
     if (applyDayNightAlpha) {
       fs.defines.push("APPLY_DAY_NIGHT_ALPHA");
     }
+    if (hasWaterMask) {
+      fs.defines.push("HAS_WATER_MASK");
+    }
     if (showReflectiveOcean) {
       fs.defines.push("SHOW_REFLECTIVE_OCEAN");
       vs.defines.push("SHOW_REFLECTIVE_OCEAN");
@@ -350,10 +355,10 @@ GlobeSurfaceShaderSet.prototype.getShaderProgram = function (options) {
       }
 
       fs.defines.push(
-        `CLIPPING_POLYGON_REGIONS_LENGTH ${clippingPolygons.extentsCount}`
+        `CLIPPING_POLYGON_REGIONS_LENGTH ${clippingPolygons.extentsCount}`,
       );
       vs.defines.push(
-        `CLIPPING_POLYGON_REGIONS_LENGTH ${clippingPolygons.extentsCount}`
+        `CLIPPING_POLYGON_REGIONS_LENGTH ${clippingPolygons.extentsCount}`,
       );
     }
 
@@ -393,7 +398,8 @@ GlobeSurfaceShaderSet.prototype.getShaderProgram = function (options) {
         texelUnclipped = v_textureCoordinates.x < cutoutAndColorResult.x || cutoutAndColorResult.z < v_textureCoordinates.x || v_textureCoordinates.y < cutoutAndColorResult.y || cutoutAndColorResult.w < v_textureCoordinates.y;\n\
         cutoutAndColorResult = sampleAndBlend(\n`;
       } else {
-        computeDayColor += "\
+        computeDayColor +=
+          "\
         color = sampleAndBlend(\n";
       }
       computeDayColor += `\
@@ -404,8 +410,8 @@ GlobeSurfaceShaderSet.prototype.getShaderProgram = function (options) {
             u_dayTextureTranslationAndScale[${i}],\n\
             ${applyAlpha ? `u_dayTextureAlpha[${i}]` : "1.0"},\n\
             ${applyDayNightAlpha ? `u_dayTextureNightAlpha[${i}]` : "1.0"},\n${
-        applyDayNightAlpha ? `u_dayTextureDayAlpha[${i}]` : "1.0"
-      },\n${applyBrightness ? `u_dayTextureBrightness[${i}]` : "0.0"},\n\
+              applyDayNightAlpha ? `u_dayTextureDayAlpha[${i}]` : "1.0"
+            },\n${applyBrightness ? `u_dayTextureBrightness[${i}]` : "0.0"},\n\
             ${applyContrast ? `u_dayTextureContrast[${i}]` : "0.0"},\n\
             ${applyHue ? `u_dayTextureHue[${i}]` : "0.0"},\n\
             ${applySaturation ? `u_dayTextureSaturation[${i}]` : "0.0"},\n\
@@ -421,7 +427,8 @@ GlobeSurfaceShaderSet.prototype.getShaderProgram = function (options) {
       }
     }
 
-    computeDayColor += "\
+    computeDayColor +=
+      "\
         return color;\n\
     }";
 
@@ -443,7 +450,7 @@ GlobeSurfaceShaderSet.prototype.getShaderProgram = function (options) {
       this.material,
       shader,
       currentClippingShaderState,
-      currentClippingPolygonsShaderState
+      currentClippingPolygonsShaderState,
     );
   }