@cesium/engine 11.0.0 → 11.1.0

package/Source/Scene/VoxelEllipsoidShape.js

@@ -170,7 +170,7 @@ VoxelEllipsoidShape.prototype.update = function (
   minBounds,
   maxBounds,
   clipMinBounds,
-  clipMaxBounds
+  clipMaxBounds,
 ) {
   const { DefaultMinBounds, DefaultMaxBounds } = VoxelEllipsoidShape;
   clipMinBounds = defaultValue(clipMinBounds, DefaultMinBounds);
@@ -191,7 +191,7 @@ VoxelEllipsoidShape.prototype.update = function (
   const radii = Matrix4.getScale(modelMatrix, scratchScale);
   const actualMinBounds = Cartesian3.clone(
     DefaultMinBounds,
-    scratchActualMinBounds
+    scratchActualMinBounds,
   );
   actualMinBounds.z = -Cartesian3.minimumComponent(radii);
 
@@ -199,35 +199,35 @@ VoxelEllipsoidShape.prototype.update = function (
     minBounds,
     actualMinBounds,
     DefaultMaxBounds,
-    scratchShapeMinBounds
+    scratchShapeMinBounds,
   );
   const shapeMaxBounds = Cartesian3.clamp(
     maxBounds,
     actualMinBounds,
     DefaultMaxBounds,
-    scratchShapeMaxBounds
+    scratchShapeMaxBounds,
   );
   const clampedClipMinBounds = Cartesian3.clamp(
     clipMinBounds,
     actualMinBounds,
     DefaultMaxBounds,
-    scratchClipMinBounds
+    scratchClipMinBounds,
   );
   const clampedClipMaxBounds = Cartesian3.clamp(
     clipMaxBounds,
     actualMinBounds,
     DefaultMaxBounds,
-    scratchClipMaxBounds
+    scratchClipMaxBounds,
   );
   const renderMinBounds = Cartesian3.maximumByComponent(
     shapeMinBounds,
     clampedClipMinBounds,
-    scratchRenderMinBounds
+    scratchRenderMinBounds,
   );
   const renderMaxBounds = Cartesian3.minimumByComponent(
     shapeMaxBounds,
     clampedClipMaxBounds,
-    scratchRenderMaxBounds
+    scratchRenderMaxBounds,
   );
 
   // Compute the farthest a point can be from the center of the ellipsoid.
@@ -237,9 +237,9 @@ VoxelEllipsoidShape.prototype.update = function (
       shapeMaxBounds.z,
       shapeMaxBounds.z,
       shapeMaxBounds.z,
-      scratchShapeOuterExtent
+      scratchShapeOuterExtent,
     ),
-    scratchShapeOuterExtent
+    scratchShapeOuterExtent,
   );
   const shapeMaxExtent = Cartesian3.maximumComponent(shapeOuterExtent);
 
@@ -249,9 +249,9 @@ VoxelEllipsoidShape.prototype.update = function (
       renderMaxBounds.z,
       renderMaxBounds.z,
       renderMaxBounds.z,
-      scratchRenderOuterExtent
+      scratchRenderOuterExtent,
     ),
-    scratchRenderOuterExtent
+    scratchRenderOuterExtent,
   );
 
   // Exit early if the shape is not visible.
@@ -265,7 +265,7 @@ VoxelEllipsoidShape.prototype.update = function (
       renderOuterExtent,
       Cartesian3.ZERO,
       undefined,
-      epsilonZeroScale
+      epsilonZeroScale,
     )
   ) {
     return false;
@@ -275,7 +275,7 @@ VoxelEllipsoidShape.prototype.update = function (
     shapeMinBounds.x,
     shapeMinBounds.y,
     shapeMaxBounds.x,
-    shapeMaxBounds.y
+    shapeMaxBounds.y,
   );
   this._translation = Matrix4.getTranslation(modelMatrix, this._translation);
   this._rotation = Matrix4.getRotation(modelMatrix, this._rotation);
@@ -288,7 +288,7 @@ VoxelEllipsoidShape.prototype.update = function (
     renderMinBounds.y,
     renderMaxBounds.x,
     renderMaxBounds.y,
-    scratchRenderRectangle
+    scratchRenderRectangle,
   );
 
   this.orientedBoundingBox = getEllipsoidChunkObb(
@@ -298,24 +298,24 @@ VoxelEllipsoidShape.prototype.update = function (
     this._ellipsoid,
     this._translation,
     this._rotation,
-    this.orientedBoundingBox
+    this.orientedBoundingBox,
   );
 
   this.shapeTransform = Matrix4.fromRotationTranslation(
     Matrix3.setScale(this._rotation, shapeOuterExtent, scratchRotationScale),
     this._translation,
-    this.shapeTransform
+    this.shapeTransform,
   );
 
   this.boundTransform = Matrix4.fromRotationTranslation(
     this.orientedBoundingBox.halfAxes,
     this.orientedBoundingBox.center,
-    this.boundTransform
+    this.boundTransform,
   );
 
   this.boundingSphere = BoundingSphere.fromOrientedBoundingBox(
     this.orientedBoundingBox,
-    this.boundingSphere
+    this.boundingSphere,
   );
 
   // Longitude
@@ -419,7 +419,7 @@ VoxelEllipsoidShape.prototype.update = function (
   shaderUniforms.ellipsoidRadiiUv = Cartesian3.divideByScalar(
     shapeOuterExtent,
     shapeMaxExtent,
-    shaderUniforms.ellipsoidRadiiUv
+    shaderUniforms.ellipsoidRadiiUv,
   );
   const { x: radiiUvX, z: radiiUvZ } = shaderUniforms.ellipsoidRadiiUv;
   const axisRatio = radiiUvZ / radiiUvX;
@@ -427,7 +427,7 @@ VoxelEllipsoidShape.prototype.update = function (
   shaderUniforms.evoluteScale = Cartesian2.fromElements(
     (radiiUvX * radiiUvX - radiiUvZ * radiiUvZ) / radiiUvX,
     (radiiUvZ * radiiUvZ - radiiUvX * radiiUvX) / radiiUvZ,
-    shaderUniforms.evoluteScale
+    shaderUniforms.evoluteScale,
   );
 
   // Used to compute geodetic surface normal.
@@ -436,9 +436,9 @@ VoxelEllipsoidShape.prototype.update = function (
     Cartesian3.multiplyComponents(
       shaderUniforms.ellipsoidRadiiUv,
       shaderUniforms.ellipsoidRadiiUv,
-      shaderUniforms.ellipsoidInverseRadiiSquaredUv
+      shaderUniforms.ellipsoidInverseRadiiSquaredUv,
     ),
-    shaderUniforms.ellipsoidInverseRadiiSquaredUv
+    shaderUniforms.ellipsoidInverseRadiiSquaredUv,
   );
 
   // Keep track of how many intersections there are going to be.
@@ -453,7 +453,7 @@ VoxelEllipsoidShape.prototype.update = function (
   shaderUniforms.clipMinMaxHeight = Cartesian2.fromElements(
     (renderMinBounds.z - shapeMaxBounds.z) / shapeMaxExtent,
     (renderMaxBounds.z - shapeMaxBounds.z) / shapeMaxExtent,
-    shaderUniforms.clipMinMaxHeight
+    shaderUniforms.clipMinMaxHeight,
   );
 
   // The percent of space that is between the inner and outer ellipsoid.
@@ -469,26 +469,23 @@ VoxelEllipsoidShape.prototype.update = function (
     shaderDefines["ELLIPSOID_INTERSECTION_INDEX_LONGITUDE"] = intersectionCount;
 
     if (renderIsLongitudeRangeUnderHalf) {
-      shaderDefines[
-        "ELLIPSOID_HAS_RENDER_BOUNDS_LONGITUDE_RANGE_UNDER_HALF"
-      ] = true;
+      shaderDefines["ELLIPSOID_HAS_RENDER_BOUNDS_LONGITUDE_RANGE_UNDER_HALF"] =
+        true;
       intersectionCount += 1;
     } else if (renderIsLongitudeRangeOverHalf) {
-      shaderDefines[
-        "ELLIPSOID_HAS_RENDER_BOUNDS_LONGITUDE_RANGE_OVER_HALF"
-      ] = true;
+      shaderDefines["ELLIPSOID_HAS_RENDER_BOUNDS_LONGITUDE_RANGE_OVER_HALF"] =
+        true;
       intersectionCount += 2;
     } else if (renderIsLongitudeRangeZero) {
-      shaderDefines[
-        "ELLIPSOID_HAS_RENDER_BOUNDS_LONGITUDE_RANGE_EQUAL_ZERO"
-      ] = true;
+      shaderDefines["ELLIPSOID_HAS_RENDER_BOUNDS_LONGITUDE_RANGE_EQUAL_ZERO"] =
+        true;
       intersectionCount += 2;
     }
 
     shaderUniforms.ellipsoidRenderLongitudeMinMax = Cartesian2.fromElements(
       renderMinBounds.x,
       renderMaxBounds.x,
-      shaderUniforms.ellipsoidRenderLongitudeMinMax
+      shaderUniforms.ellipsoidRenderLongitudeMinMax,
     );
   }
 
@@ -498,9 +495,8 @@ VoxelEllipsoidShape.prototype.update = function (
     const shapeIsLongitudeReversed = shapeMaxBounds.x < shapeMinBounds.x;
 
     if (shapeIsLongitudeReversed) {
-      shaderDefines[
-        "ELLIPSOID_HAS_SHAPE_BOUNDS_LONGITUDE_MIN_MAX_REVERSED"
-      ] = true;
+      shaderDefines["ELLIPSOID_HAS_SHAPE_BOUNDS_LONGITUDE_MIN_MAX_REVERSED"] =
+        true;
     }
 
     // delerp(longitudeUv, minLongitudeUv, maxLongitudeUv)
@@ -516,7 +512,7 @@ VoxelEllipsoidShape.prototype.update = function (
       shaderUniforms.ellipsoidUvToShapeUvLongitude = Cartesian2.fromElements(
         0.0,
         1.0,
-        shaderUniforms.ellipsoidUvToShapeUvLongitude
+        shaderUniforms.ellipsoidUvToShapeUvLongitude,
       );
     } else {
       const scale = defaultLongitudeRange / shapeLongitudeRange;
@@ -525,7 +521,7 @@ VoxelEllipsoidShape.prototype.update = function (
       shaderUniforms.ellipsoidUvToShapeUvLongitude = Cartesian2.fromElements(
         scale,
         offset,
-        shaderUniforms.ellipsoidUvToShapeUvLongitude
+        shaderUniforms.ellipsoidUvToShapeUvLongitude,
       );
     }
   }
@@ -535,24 +531,22 @@ VoxelEllipsoidShape.prototype.update = function (
       renderMinBounds.x,
       DefaultMinBounds.x,
       undefined,
-      epsilonLongitudeDiscontinuity
+      epsilonLongitudeDiscontinuity,
     );
     const renderIsMaxLongitudeDiscontinuity = CesiumMath.equalsEpsilon(
       renderMaxBounds.x,
       DefaultMaxBounds.x,
       undefined,
-      epsilonLongitudeDiscontinuity
+      epsilonLongitudeDiscontinuity,
     );
 
     if (renderIsMinLongitudeDiscontinuity) {
-      shaderDefines[
-        "ELLIPSOID_HAS_RENDER_BOUNDS_LONGITUDE_MIN_DISCONTINUITY"
-      ] = true;
+      shaderDefines["ELLIPSOID_HAS_RENDER_BOUNDS_LONGITUDE_MIN_DISCONTINUITY"] =
+        true;
     }
     if (renderIsMaxLongitudeDiscontinuity) {
-      shaderDefines[
-        "ELLIPSOID_HAS_RENDER_BOUNDS_LONGITUDE_MAX_DISCONTINUITY"
-      ] = true;
+      shaderDefines["ELLIPSOID_HAS_RENDER_BOUNDS_LONGITUDE_MAX_DISCONTINUITY"] =
+        true;
     }
     const uvShapeMinLongitude =
       (shapeMinBounds.x - DefaultMinBounds.x) / defaultLongitudeRange;
@@ -570,7 +564,7 @@ VoxelEllipsoidShape.prototype.update = function (
       uvShapeMinLongitude,
       uvShapeMaxLongitude,
       uvRenderLongitudeRangeZeroMid,
-      shaderUniforms.ellipsoidShapeUvLongitudeMinMaxMid
+      shaderUniforms.ellipsoidShapeUvLongitudeMinMaxMid,
     );
   }
 
@@ -578,24 +572,20 @@ VoxelEllipsoidShape.prototype.update = function (
     // Intersects a cone for min latitude
     if (renderHasLatitudeMin) {
       shaderDefines["ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE_MIN"] = true;
-      shaderDefines[
-        "ELLIPSOID_INTERSECTION_INDEX_LATITUDE_MIN"
-      ] = intersectionCount;
+      shaderDefines["ELLIPSOID_INTERSECTION_INDEX_LATITUDE_MIN"] =
+        intersectionCount;
 
       if (renderIsLatitudeMinUnderHalf) {
-        shaderDefines[
-          "ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE_MIN_UNDER_HALF"
-        ] = true;
+        shaderDefines["ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE_MIN_UNDER_HALF"] =
+          true;
         intersectionCount += 1;
       } else if (renderIsLatitudeMinHalf) {
-        shaderDefines[
-          "ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE_MIN_EQUAL_HALF"
-        ] = true;
+        shaderDefines["ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE_MIN_EQUAL_HALF"] =
+          true;
         intersectionCount += 1;
       } else if (renderIsLatitudeMinOverHalf) {
-        shaderDefines[
-          "ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE_MIN_OVER_HALF"
-        ] = true;
+        shaderDefines["ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE_MIN_OVER_HALF"] =
+          true;
         intersectionCount += 2;
       }
     }
@@ -603,24 +593,20 @@ VoxelEllipsoidShape.prototype.update = function (
     // Intersects a cone for max latitude
     if (renderHasLatitudeMax) {
       shaderDefines["ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE_MAX"] = true;
-      shaderDefines[
-        "ELLIPSOID_INTERSECTION_INDEX_LATITUDE_MAX"
-      ] = intersectionCount;
+      shaderDefines["ELLIPSOID_INTERSECTION_INDEX_LATITUDE_MAX"] =
+        intersectionCount;
 
       if (renderIsLatitudeMaxUnderHalf) {
-        shaderDefines[
-          "ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE_MAX_UNDER_HALF"
-        ] = true;
+        shaderDefines["ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE_MAX_UNDER_HALF"] =
+          true;
         intersectionCount += 2;
       } else if (renderIsLatitudeMaxHalf) {
-        shaderDefines[
-          "ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE_MAX_EQUAL_HALF"
-        ] = true;
+        shaderDefines["ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE_MAX_EQUAL_HALF"] =
+          true;
         intersectionCount += 1;
       } else if (renderIsLatitudeMaxOverHalf) {
-        shaderDefines[
-          "ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE_MAX_OVER_HALF"
-        ] = true;
+        shaderDefines["ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE_MAX_OVER_HALF"] =
+          true;
         intersectionCount += 1;
       }
     }
@@ -628,7 +614,7 @@ VoxelEllipsoidShape.prototype.update = function (
     shaderUniforms.ellipsoidRenderLatitudeSinMinMax = Cartesian2.fromElements(
       Math.sin(renderMinBounds.y),
       Math.sin(renderMaxBounds.y),
-      shaderUniforms.ellipsoidRenderLatitudeSinMinMax
+      shaderUniforms.ellipsoidRenderLatitudeSinMinMax,
     );
   }
 
@@ -649,7 +635,7 @@ VoxelEllipsoidShape.prototype.update = function (
       shaderUniforms.ellipsoidUvToShapeUvLatitude = Cartesian2.fromElements(
         0.0,
         1.0,
-        shaderUniforms.ellipsoidUvToShapeUvLatitude
+        shaderUniforms.ellipsoidUvToShapeUvLatitude,
       );
     } else {
       const defaultLatitudeRange = DefaultMaxBounds.y - DefaultMinBounds.y;
@@ -659,7 +645,7 @@ VoxelEllipsoidShape.prototype.update = function (
       shaderUniforms.ellipsoidUvToShapeUvLatitude = Cartesian2.fromElements(
         scale,
         offset,
-        shaderUniforms.ellipsoidUvToShapeUvLatitude
+        shaderUniforms.ellipsoidUvToShapeUvLatitude,
       );
     }
   }
@@ -687,7 +673,7 @@ VoxelEllipsoidShape.prototype.computeOrientedBoundingBoxForTile = function (
   tileX,
   tileY,
   tileZ,
-  result
+  result,
 ) {
   //>>includeStart('debug', pragmas.debug);
   Check.typeOf.number("tileLevel", tileLevel);
@@ -711,19 +697,19 @@ VoxelEllipsoidShape.prototype.computeOrientedBoundingBoxForTile = function (
     minLatitudeLerp,
     maxLongitudeLerp,
     maxLatitudeLerp,
-    scratchRectangle
+    scratchRectangle,
   );
 
   const minHeight = CesiumMath.lerp(
     this._minimumHeight,
     this._maximumHeight,
-    minHeightLerp
+    minHeightLerp,
   );
 
   const maxHeight = CesiumMath.lerp(
     this._minimumHeight,
     this._maximumHeight,
-    maxHeightLerp
+    maxHeightLerp,
   );
 
   return getEllipsoidChunkObb(
@@ -733,7 +719,7 @@ VoxelEllipsoidShape.prototype.computeOrientedBoundingBoxForTile = function (
     this._ellipsoid,
     this._translation,
     this._rotation,
-    result
+    result,
   );
 };
 
@@ -755,7 +741,7 @@ VoxelEllipsoidShape.prototype.computeOrientedBoundingBoxForSample = function (
   spatialNode,
   tileDimensions,
   tileUv,
-  result
+  result,
 ) {
   //>>includeStart('debug', pragmas.debug);
   Check.typeOf.object("spatialNode", spatialNode);
@@ -768,12 +754,12 @@ VoxelEllipsoidShape.prototype.computeOrientedBoundingBoxForSample = function (
   const sampleSize = Cartesian3.divideComponents(
     Cartesian3.ONE,
     tileDimensions,
-    sampleSizeScratch
+    sampleSizeScratch,
   );
   const sampleSizeAtLevel = Cartesian3.multiplyByScalar(
     sampleSize,
     tileSizeAtLevel,
-    sampleSizeScratch
+    sampleSizeScratch,
   );
 
   const minLerp = Cartesian3.multiplyByScalar(
@@ -781,15 +767,15 @@ VoxelEllipsoidShape.prototype.computeOrientedBoundingBoxForSample = function (
       spatialNode.x + tileUv.x,
       spatialNode.y + tileUv.y,
       spatialNode.z + tileUv.z,
-      scratchTileMinBounds
+      scratchTileMinBounds,
     ),
     tileSizeAtLevel,
-    scratchTileMinBounds
+    scratchTileMinBounds,
   );
   const maxLerp = Cartesian3.add(
     minLerp,
     sampleSizeAtLevel,
-    scratchTileMaxBounds
+    scratchTileMaxBounds,
   );
 
   const rectangle = Rectangle.subsection(
@@ -798,17 +784,17 @@ VoxelEllipsoidShape.prototype.computeOrientedBoundingBoxForSample = function (
     minLerp.y,
     maxLerp.x,
     maxLerp.y,
-    scratchRectangle
+    scratchRectangle,
   );
   const minHeight = CesiumMath.lerp(
     this._minimumHeight,
     this._maximumHeight,
-    minLerp.z
+    minLerp.z,
   );
   const maxHeight = CesiumMath.lerp(
     this._minimumHeight,
     this._maximumHeight,
-    maxLerp.z
+    maxLerp.z,
   );
 
   return getEllipsoidChunkObb(
@@ -818,7 +804,7 @@ VoxelEllipsoidShape.prototype.computeOrientedBoundingBoxForSample = function (
     this._ellipsoid,
     this._translation,
     this._rotation,
-    result
+    result,
   );
 };
 
@@ -845,20 +831,20 @@ function getEllipsoidChunkObb(
   ellipsoid,
   translation,
   rotation,
-  result
+  result,
 ) {
   result = OrientedBoundingBox.fromRectangle(
     rectangle,
     minHeight,
     maxHeight,
     ellipsoid,
-    result
+    result,
   );
   result.center = Cartesian3.add(result.center, translation, result.center);
   result.halfAxes = Matrix3.multiply(
     result.halfAxes,
     rotation,
-    result.halfAxes
+    result.halfAxes,
   );
   return result;
 }
@@ -874,8 +860,8 @@ VoxelEllipsoidShape.DefaultMinBounds = Object.freeze(
   new Cartesian3(
     -CesiumMath.PI,
     -CesiumMath.PI_OVER_TWO,
-    -Ellipsoid.WGS84.minimumRadius
-  )
+    -Ellipsoid.WGS84.minimumRadius,
+  ),
 );
 
 /**
@@ -889,8 +875,8 @@ VoxelEllipsoidShape.DefaultMaxBounds = Object.freeze(
   new Cartesian3(
     CesiumMath.PI,
     CesiumMath.PI_OVER_TWO,
-    10.0 * Ellipsoid.WGS84.maximumRadius
-  )
+    10.0 * Ellipsoid.WGS84.maximumRadius,
+  ),
 );
 
 export default VoxelEllipsoidShape;