@cesium/engine 8.0.0 → 9.1.0

package/Source/Scene/VoxelEllipsoidShape.js

@@ -95,16 +95,16 @@ function VoxelEllipsoidShape() {
    */
   this.shaderUniforms = {
     ellipsoidRadiiUv: new Cartesian3(),
+    eccentricitySquared: 0.0,
+    evoluteScale: new Cartesian2(),
     ellipsoidInverseRadiiSquaredUv: new Cartesian3(),
     ellipsoidRenderLongitudeMinMax: new Cartesian2(),
     ellipsoidShapeUvLongitudeMinMaxMid: new Cartesian3(),
     ellipsoidUvToShapeUvLongitude: new Cartesian2(),
     ellipsoidUvToShapeUvLatitude: new Cartesian2(),
-    ellipsoidRenderLatitudeCosSqrHalfMinMax: new Cartesian2(),
+    ellipsoidRenderLatitudeSinMinMax: new Cartesian2(),
     ellipsoidInverseHeightDifferenceUv: 0.0,
-    ellipseInnerRadiiUv: new Cartesian2(),
-    ellipsoidInverseInnerScaleUv: 0.0,
-    ellipsoidInverseOuterScaleUv: 0.0,
+    clipMinMaxHeight: new Cartesian2(),
   };
 
   /**
@@ -127,10 +127,6 @@ function VoxelEllipsoidShape() {
     ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE_MIN_EQUAL_HALF: undefined,
     ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE_MIN_OVER_HALF: undefined,
     ELLIPSOID_HAS_SHAPE_BOUNDS_LATITUDE: undefined,
-    ELLIPSOID_HAS_RENDER_BOUNDS_HEIGHT_MAX: undefined,
-    ELLIPSOID_HAS_RENDER_BOUNDS_HEIGHT_MIN: undefined,
-    ELLIPSOID_HAS_SHAPE_BOUNDS_HEIGHT_FLAT: undefined,
-    ELLIPSOID_IS_SPHERE: undefined,
     ELLIPSOID_INTERSECTION_INDEX_LONGITUDE: undefined,
     ELLIPSOID_INTERSECTION_INDEX_LATITUDE_MAX: undefined,
     ELLIPSOID_INTERSECTION_INDEX_LATITUDE_MIN: undefined,
@@ -146,11 +142,17 @@ function VoxelEllipsoidShape() {
   this.shaderMaximumIntersectionsLength = 0; // not known until update
 }
 
+const scratchActualMinBounds = new Cartesian3();
+const scratchShapeMinBounds = new Cartesian3();
+const scratchShapeMaxBounds = new Cartesian3();
+const scratchClipMinBounds = new Cartesian3();
+const scratchClipMaxBounds = new Cartesian3();
+const scratchRenderMinBounds = new Cartesian3();
+const scratchRenderMaxBounds = new Cartesian3();
 const scratchScale = new Cartesian3();
 const scratchRotationScale = new Matrix3();
 const scratchShapeOuterExtent = new Cartesian3();
 const scratchRenderOuterExtent = new Cartesian3();
-const scratchRenderInnerExtent = new Cartesian3();
 const scratchRenderRectangle = new Rectangle();
 
 /**
@@ -170,122 +172,83 @@ VoxelEllipsoidShape.prototype.update = function (
   clipMinBounds,
   clipMaxBounds
 ) {
-  clipMinBounds = defaultValue(
-    clipMinBounds,
-    VoxelEllipsoidShape.DefaultMinBounds
-  );
-  clipMaxBounds = defaultValue(
-    clipMaxBounds,
-    VoxelEllipsoidShape.DefaultMaxBounds
-  );
+  const { DefaultMinBounds, DefaultMaxBounds } = VoxelEllipsoidShape;
+  clipMinBounds = defaultValue(clipMinBounds, DefaultMinBounds);
+  clipMaxBounds = defaultValue(clipMaxBounds, DefaultMaxBounds);
   //>>includeStart('debug', pragmas.debug);
   Check.typeOf.object("modelMatrix", modelMatrix);
   Check.typeOf.object("minBounds", minBounds);
   Check.typeOf.object("maxBounds", maxBounds);
   //>>includeEnd('debug');
 
-  const defaultMinLongitude = VoxelEllipsoidShape.DefaultMinBounds.x;
-  const defaultMaxLongitude = VoxelEllipsoidShape.DefaultMaxBounds.x;
-  const defaultLongitudeRange = defaultMaxLongitude - defaultMinLongitude;
-  const defaultLongitudeRangeHalf = 0.5 * defaultLongitudeRange;
-  const defaultMinLatitude = VoxelEllipsoidShape.DefaultMinBounds.y;
-  const defaultMaxLatitude = VoxelEllipsoidShape.DefaultMaxBounds.y;
-  const defaultLatitudeRange = defaultMaxLatitude - defaultMinLatitude;
-
   const epsilonZeroScale = CesiumMath.EPSILON10;
   const epsilonLongitudeDiscontinuity = CesiumMath.EPSILON3; // 0.001 radians = 0.05729578 degrees
   const epsilonLongitude = CesiumMath.EPSILON10;
   const epsilonLatitude = CesiumMath.EPSILON10;
   const epsilonLatitudeFlat = CesiumMath.EPSILON3; // 0.001 radians = 0.05729578 degrees
 
-  // Clamp the longitude / latitude to the valid range
-  const shapeMinLongitude = CesiumMath.clamp(
-    minBounds.x,
-    defaultMinLongitude,
-    defaultMaxLongitude
-  );
-  const shapeMaxLongitude = CesiumMath.clamp(
-    maxBounds.x,
-    defaultMinLongitude,
-    defaultMaxLongitude
+  // Don't let the height go below the center of the ellipsoid.
+  const radii = Matrix4.getScale(modelMatrix, scratchScale);
+  const actualMinBounds = Cartesian3.clone(
+    DefaultMinBounds,
+    scratchActualMinBounds
   );
-  const clipMinLongitude = CesiumMath.clamp(
-    clipMinBounds.x,
-    defaultMinLongitude,
-    defaultMaxLongitude
+  actualMinBounds.z = -Cartesian3.minimumComponent(radii);
+
+  const shapeMinBounds = Cartesian3.clamp(
+    minBounds,
+    actualMinBounds,
+    DefaultMaxBounds,
+    scratchShapeMinBounds
   );
-  const clipMaxLongitude = CesiumMath.clamp(
-    clipMaxBounds.x,
-    defaultMinLongitude,
-    defaultMaxLongitude
+  const shapeMaxBounds = Cartesian3.clamp(
+    maxBounds,
+    actualMinBounds,
+    DefaultMaxBounds,
+    scratchShapeMaxBounds
   );
-  const renderMinLongitude = Math.max(shapeMinLongitude, clipMinLongitude);
-  const renderMaxLongitude = Math.min(shapeMaxLongitude, clipMaxLongitude);
-
-  const shapeMinLatitude = CesiumMath.clamp(
-    minBounds.y,
-    defaultMinLatitude,
-    defaultMaxLatitude
+  const clampedClipMinBounds = Cartesian3.clamp(
+    clipMinBounds,
+    actualMinBounds,
+    DefaultMaxBounds,
+    scratchClipMinBounds
   );
-  const shapeMaxLatitude = CesiumMath.clamp(
-    maxBounds.y,
-    defaultMinLatitude,
-    defaultMaxLatitude
+  const clampedClipMaxBounds = Cartesian3.clamp(
+    clipMaxBounds,
+    actualMinBounds,
+    DefaultMaxBounds,
+    scratchClipMaxBounds
   );
-  const clipMinLatitude = CesiumMath.clamp(
-    clipMinBounds.y,
-    defaultMinLatitude,
-    defaultMaxLatitude
+  const renderMinBounds = Cartesian3.maximumByComponent(
+    shapeMinBounds,
+    clampedClipMinBounds,
+    scratchRenderMinBounds
   );
-  const clipMaxLatitude = CesiumMath.clamp(
-    clipMaxBounds.y,
-    defaultMinLatitude,
-    defaultMaxLatitude
+  const renderMaxBounds = Cartesian3.minimumByComponent(
+    shapeMaxBounds,
+    clampedClipMaxBounds,
+    scratchRenderMaxBounds
   );
 
-  const renderMinLatitude = Math.max(shapeMinLatitude, clipMinLatitude);
-  const renderMaxLatitude = Math.min(shapeMaxLatitude, clipMaxLatitude);
-
-  // Don't let the height go below the center of the ellipsoid.
-  const radii = Matrix4.getScale(modelMatrix, scratchScale);
-  const isSphere = radii.x === radii.y && radii.y === radii.z;
-  const minRadius = Cartesian3.minimumComponent(radii);
-  const shapeMinHeight = Math.max(minBounds.z, -minRadius);
-  const shapeMaxHeight = Math.max(maxBounds.z, -minRadius);
-  const clipMinHeight = Math.max(clipMinBounds.z, -minRadius);
-  const clipMaxHeight = Math.max(clipMaxBounds.z, -minRadius);
-  const renderMinHeight = Math.max(shapeMinHeight, clipMinHeight);
-  const renderMaxHeight = Math.min(shapeMaxHeight, clipMaxHeight);
-
   // Compute the farthest a point can be from the center of the ellipsoid.
   const shapeOuterExtent = Cartesian3.add(
     radii,
     Cartesian3.fromElements(
-      shapeMaxHeight,
-      shapeMaxHeight,
-      shapeMaxHeight,
+      shapeMaxBounds.z,
+      shapeMaxBounds.z,
+      shapeMaxBounds.z,
       scratchShapeOuterExtent
     ),
     scratchShapeOuterExtent
   );
   const shapeMaxExtent = Cartesian3.maximumComponent(shapeOuterExtent);
 
-  const renderInnerExtent = Cartesian3.add(
-    radii,
-    Cartesian3.fromElements(
-      renderMinHeight,
-      renderMinHeight,
-      renderMinHeight,
-      scratchRenderInnerExtent
-    ),
-    scratchRenderInnerExtent
-  );
   const renderOuterExtent = Cartesian3.add(
     radii,
     Cartesian3.fromElements(
-      renderMaxHeight,
-      renderMaxHeight,
-      renderMaxHeight,
+      renderMaxBounds.z,
+      renderMaxBounds.z,
+      renderMaxBounds.z,
       scratchRenderOuterExtent
     ),
     scratchRenderOuterExtent
@@ -294,10 +257,10 @@ VoxelEllipsoidShape.prototype.update = function (
   // Exit early if the shape is not visible.
   // Note that minLongitude may be greater than maxLongitude when crossing the 180th meridian.
   if (
-    renderMinLatitude > renderMaxLatitude ||
-    renderMinLatitude === defaultMaxLatitude ||
-    renderMaxLatitude === defaultMinLatitude ||
-    renderMinHeight > renderMaxHeight ||
+    renderMinBounds.y > renderMaxBounds.y ||
+    renderMinBounds.y === DefaultMaxBounds.y ||
+    renderMaxBounds.y === DefaultMinBounds.y ||
+    renderMinBounds.z > renderMaxBounds.z ||
     CesiumMath.equalsEpsilon(
       renderOuterExtent,
       Cartesian3.ZERO,
@@ -309,29 +272,29 @@ VoxelEllipsoidShape.prototype.update = function (
   }
 
   this._rectangle = Rectangle.fromRadians(
-    shapeMinLongitude,
-    shapeMinLatitude,
-    shapeMaxLongitude,
-    shapeMaxLatitude
+    shapeMinBounds.x,
+    shapeMinBounds.y,
+    shapeMaxBounds.x,
+    shapeMaxBounds.y
   );
   this._translation = Matrix4.getTranslation(modelMatrix, this._translation);
   this._rotation = Matrix4.getRotation(modelMatrix, this._rotation);
   this._ellipsoid = Ellipsoid.fromCartesian3(radii, this._ellipsoid);
-  this._minimumHeight = shapeMinHeight;
-  this._maximumHeight = shapeMaxHeight;
+  this._minimumHeight = shapeMinBounds.z;
+  this._maximumHeight = shapeMaxBounds.z;
 
   const renderRectangle = Rectangle.fromRadians(
-    renderMinLongitude,
-    renderMinLatitude,
-    renderMaxLongitude,
-    renderMaxLatitude,
+    renderMinBounds.x,
+    renderMinBounds.y,
+    renderMaxBounds.x,
+    renderMaxBounds.y,
     scratchRenderRectangle
   );
 
   this.orientedBoundingBox = getEllipsoidChunkObb(
     renderRectangle,
-    renderMinHeight,
-    renderMaxHeight,
+    renderMinBounds.z,
+    renderMaxBounds.z,
     this._ellipsoid,
     this._translation,
     this._rotation,
@@ -356,10 +319,12 @@ VoxelEllipsoidShape.prototype.update = function (
   );
 
   // Longitude
-  const renderIsLongitudeReversed = renderMaxLongitude < renderMinLongitude;
+  const defaultLongitudeRange = DefaultMaxBounds.x - DefaultMinBounds.x;
+  const defaultLongitudeRangeHalf = 0.5 * defaultLongitudeRange;
+  const renderIsLongitudeReversed = renderMaxBounds.x < renderMinBounds.x;
   const renderLongitudeRange =
-    renderMaxLongitude -
-    renderMinLongitude +
+    renderMaxBounds.x -
+    renderMinBounds.x +
     renderIsLongitudeReversed * defaultLongitudeRange;
   const renderIsLongitudeRangeZero = renderLongitudeRange <= epsilonLongitude;
   const renderIsLongitudeRangeUnderHalf =
@@ -373,10 +338,10 @@ VoxelEllipsoidShape.prototype.update = function (
     renderIsLongitudeRangeUnderHalf ||
     renderIsLongitudeRangeOverHalf;
 
-  const shapeIsLongitudeReversed = shapeMaxLongitude < shapeMinLongitude;
+  const shapeIsLongitudeReversed = shapeMaxBounds.x < shapeMinBounds.x;
   const shapeLongitudeRange =
-    shapeMaxLongitude -
-    shapeMinLongitude +
+    shapeMaxBounds.x -
+    shapeMinBounds.x +
     shapeIsLongitudeReversed * defaultLongitudeRange;
   const shapeIsLongitudeRangeUnderHalf =
     shapeLongitudeRange > defaultLongitudeRangeHalf + epsilonLongitude &&
@@ -392,65 +357,55 @@ VoxelEllipsoidShape.prototype.update = function (
     shapeIsLongitudeRangeOverHalf;
 
   // Latitude
-  const renderIsLatitudeMaxUnderHalf = renderMaxLatitude < -epsilonLatitudeFlat;
+  const renderIsLatitudeMaxUnderHalf = renderMaxBounds.y < -epsilonLatitudeFlat;
   const renderIsLatitudeMaxHalf =
-    renderMaxLatitude >= -epsilonLatitudeFlat &&
-    renderMaxLatitude <= +epsilonLatitudeFlat;
+    renderMaxBounds.y >= -epsilonLatitudeFlat &&
+    renderMaxBounds.y <= +epsilonLatitudeFlat;
   const renderIsLatitudeMaxOverHalf =
-    renderMaxLatitude > +epsilonLatitudeFlat &&
-    renderMaxLatitude < defaultMaxLatitude - epsilonLatitude;
+    renderMaxBounds.y > +epsilonLatitudeFlat &&
+    renderMaxBounds.y < DefaultMaxBounds.y - epsilonLatitude;
   const renderHasLatitudeMax =
     renderIsLatitudeMaxUnderHalf ||
     renderIsLatitudeMaxHalf ||
     renderIsLatitudeMaxOverHalf;
   const renderIsLatitudeMinUnderHalf =
-    renderMinLatitude > defaultMinLatitude + epsilonLatitude &&
-    renderMinLatitude < -epsilonLatitudeFlat;
+    renderMinBounds.y > DefaultMinBounds.y + epsilonLatitude &&
+    renderMinBounds.y < -epsilonLatitudeFlat;
   const renderIsLatitudeMinHalf =
-    renderMinLatitude >= -epsilonLatitudeFlat &&
-    renderMinLatitude <= +epsilonLatitudeFlat;
-  const renderIsLatitudeMinOverHalf = renderMinLatitude > +epsilonLatitudeFlat;
+    renderMinBounds.y >= -epsilonLatitudeFlat &&
+    renderMinBounds.y <= +epsilonLatitudeFlat;
+  const renderIsLatitudeMinOverHalf = renderMinBounds.y > +epsilonLatitudeFlat;
   const renderHasLatitudeMin =
     renderIsLatitudeMinUnderHalf ||
     renderIsLatitudeMinHalf ||
     renderIsLatitudeMinOverHalf;
   const renderHasLatitude = renderHasLatitudeMax || renderHasLatitudeMin;
 
-  const shapeLatitudeRange = shapeMaxLatitude - shapeMinLatitude;
-  const shapeIsLatitudeMaxUnderHalf = shapeMaxLatitude < -epsilonLatitudeFlat;
+  const shapeLatitudeRange = shapeMaxBounds.y - shapeMinBounds.y;
+  const shapeIsLatitudeMaxUnderHalf = shapeMaxBounds.y < -epsilonLatitudeFlat;
   const shapeIsLatitudeMaxHalf =
-    shapeMaxLatitude >= -epsilonLatitudeFlat &&
-    shapeMaxLatitude <= +epsilonLatitudeFlat;
+    shapeMaxBounds.y >= -epsilonLatitudeFlat &&
+    shapeMaxBounds.y <= +epsilonLatitudeFlat;
   const shapeIsLatitudeMaxOverHalf =
-    shapeMaxLatitude > +epsilonLatitudeFlat &&
-    shapeMaxLatitude < defaultMaxLatitude - epsilonLatitude;
+    shapeMaxBounds.y > +epsilonLatitudeFlat &&
+    shapeMaxBounds.y < DefaultMaxBounds.y - epsilonLatitude;
   const shapeHasLatitudeMax =
     shapeIsLatitudeMaxUnderHalf ||
     shapeIsLatitudeMaxHalf ||
     shapeIsLatitudeMaxOverHalf;
   const shapeIsLatitudeMinUnderHalf =
-    shapeMinLatitude > defaultMinLatitude + epsilonLatitude &&
-    shapeMinLatitude < -epsilonLatitudeFlat;
+    shapeMinBounds.y > DefaultMinBounds.y + epsilonLatitude &&
+    shapeMinBounds.y < -epsilonLatitudeFlat;
   const shapeIsLatitudeMinHalf =
-    shapeMinLatitude >= -epsilonLatitudeFlat &&
-    shapeMinLatitude <= +epsilonLatitudeFlat;
-  const shapeIsLatitudeMinOverHalf = shapeMinLatitude > +epsilonLatitudeFlat;
+    shapeMinBounds.y >= -epsilonLatitudeFlat &&
+    shapeMinBounds.y <= +epsilonLatitudeFlat;
+  const shapeIsLatitudeMinOverHalf = shapeMinBounds.y > +epsilonLatitudeFlat;
   const shapeHasLatitudeMin =
     shapeIsLatitudeMinUnderHalf ||
     shapeIsLatitudeMinHalf ||
     shapeIsLatitudeMinOverHalf;
   const shapeHasLatitude = shapeHasLatitudeMax || shapeHasLatitudeMin;
 
-  // Height
-  const renderHasMinHeight = !Cartesian3.equals(
-    renderInnerExtent,
-    Cartesian3.ZERO
-  );
-  const renderHasMaxHeight = !Cartesian3.equals(
-    renderOuterExtent,
-    Cartesian3.ZERO
-  );
-
   const { shaderUniforms, shaderDefines } = this;
 
   // To keep things simple, clear the defines every time
@@ -466,6 +421,14 @@ VoxelEllipsoidShape.prototype.update = function (
     shapeMaxExtent,
     shaderUniforms.ellipsoidRadiiUv
   );
+  const { x: radiiUvX, z: radiiUvZ } = shaderUniforms.ellipsoidRadiiUv;
+  const axisRatio = radiiUvZ / radiiUvX;
+  shaderUniforms.eccentricitySquared = 1.0 - axisRatio * axisRatio;
+  shaderUniforms.evoluteScale = Cartesian2.fromElements(
+    (radiiUvX * radiiUvX - radiiUvZ * radiiUvZ) / radiiUvX,
+    (radiiUvZ * radiiUvZ - radiiUvX * radiiUvX) / radiiUvZ,
+    shaderUniforms.evoluteScale
+  );
 
   // Used to compute geodetic surface normal.
   shaderUniforms.ellipsoidInverseRadiiSquaredUv = Cartesian3.divideComponents(
@@ -481,41 +444,23 @@ VoxelEllipsoidShape.prototype.update = function (
   // Keep track of how many intersections there are going to be.
   let intersectionCount = 0;
 
-  // Intersects an outer ellipsoid for the max height.
+  // Intersects outer and inner ellipsoid for the max and min height.
   shaderDefines["ELLIPSOID_INTERSECTION_INDEX_HEIGHT_MAX"] = intersectionCount;
   intersectionCount += 1;
+  shaderDefines["ELLIPSOID_INTERSECTION_INDEX_HEIGHT_MIN"] = intersectionCount;
+  intersectionCount += 1;
 
-  if (renderHasMinHeight) {
-    shaderDefines["ELLIPSOID_HAS_RENDER_BOUNDS_HEIGHT_MIN"] = true;
-    shaderDefines[
-      "ELLIPSOID_INTERSECTION_INDEX_HEIGHT_MIN"
-    ] = intersectionCount;
-    intersectionCount += 1;
-
-    // The inverse of the percent of space that is taken up by the inner ellipsoid, relative to the shape bounds
-    // 1.0 / (1.0 - thickness) // thickness = percent of space that is between the min and max height.
-    // 1.0 / (1.0 - (shapeMaxHeight - renderMinHeight) / shapeMaxExtent)
-    // shapeMaxExtent / (shapeMaxExtent - (shapeMaxHeight - renderMinHeight))
-    shaderUniforms.ellipsoidInverseInnerScaleUv =
-      shapeMaxExtent / (shapeMaxExtent - (shapeMaxHeight - renderMinHeight));
-  }
-
-  if (renderHasMaxHeight) {
-    shaderDefines["ELLIPSOID_HAS_RENDER_BOUNDS_HEIGHT_MAX"] = true;
-    shaderUniforms.ellipsoidInverseOuterScaleUv =
-      shapeMaxExtent / (shapeMaxExtent - (shapeMaxHeight - renderMaxHeight));
-  }
+  shaderUniforms.clipMinMaxHeight = Cartesian2.fromElements(
+    (renderMinBounds.z - shapeMaxBounds.z) / shapeMaxExtent,
+    (renderMaxBounds.z - shapeMaxBounds.z) / shapeMaxExtent,
+    shaderUniforms.clipMinMaxHeight
+  );
 
   // The percent of space that is between the inner and outer ellipsoid.
-  const thickness = (shapeMaxHeight - shapeMinHeight) / shapeMaxExtent;
+  const thickness = (shapeMaxBounds.z - shapeMinBounds.z) / shapeMaxExtent;
   shaderUniforms.ellipsoidInverseHeightDifferenceUv = 1.0 / thickness;
-  shaderUniforms.ellipseInnerRadiiUv = Cartesian2.fromElements(
-    shaderUniforms.ellipsoidRadiiUv.x * (1.0 - thickness),
-    shaderUniforms.ellipsoidRadiiUv.z * (1.0 - thickness),
-    shaderUniforms.ellipseInnerRadiiUv
-  );
-  if (shapeMinHeight === shapeMaxHeight) {
-    shaderDefines["ELLIPSOID_HAS_SHAPE_BOUNDS_HEIGHT_FLAT"] = true;
+  if (shapeMinBounds.z === shapeMaxBounds.z) {
+    shaderUniforms.ellipsoidInverseHeightDifferenceUv = 0.0;
   }
 
   // Intersects a wedge for the min and max longitude.
@@ -541,8 +486,8 @@ VoxelEllipsoidShape.prototype.update = function (
     }
 
     shaderUniforms.ellipsoidRenderLongitudeMinMax = Cartesian2.fromElements(
-      renderMinLongitude,
-      renderMaxLongitude,
+      renderMinBounds.x,
+      renderMaxBounds.x,
       shaderUniforms.ellipsoidRenderLongitudeMinMax
     );
   }
@@ -550,7 +495,7 @@ VoxelEllipsoidShape.prototype.update = function (
   if (shapeHasLongitude) {
     shaderDefines["ELLIPSOID_HAS_SHAPE_BOUNDS_LONGITUDE"] = true;
 
-    const shapeIsLongitudeReversed = shapeMaxLongitude < shapeMinLongitude;
+    const shapeIsLongitudeReversed = shapeMaxBounds.x < shapeMinBounds.x;
 
     if (shapeIsLongitudeReversed) {
       shaderDefines[
@@ -576,7 +521,7 @@ VoxelEllipsoidShape.prototype.update = function (
     } else {
       const scale = defaultLongitudeRange / shapeLongitudeRange;
       const offset =
-        -(shapeMinLongitude - defaultMinLongitude) / shapeLongitudeRange;
+        -(shapeMinBounds.x - DefaultMinBounds.x) / shapeLongitudeRange;
       shaderUniforms.ellipsoidUvToShapeUvLongitude = Cartesian2.fromElements(
         scale,
         offset,
@@ -587,14 +532,14 @@ VoxelEllipsoidShape.prototype.update = function (
 
   if (renderHasLongitude) {
     const renderIsMinLongitudeDiscontinuity = CesiumMath.equalsEpsilon(
-      renderMinLongitude,
-      defaultMinLongitude,
+      renderMinBounds.x,
+      DefaultMinBounds.x,
       undefined,
       epsilonLongitudeDiscontinuity
     );
     const renderIsMaxLongitudeDiscontinuity = CesiumMath.equalsEpsilon(
-      renderMaxLongitude,
-      defaultMaxLongitude,
+      renderMaxBounds.x,
+      DefaultMaxBounds.x,
       undefined,
       epsilonLongitudeDiscontinuity
     );
@@ -610,12 +555,12 @@ VoxelEllipsoidShape.prototype.update = function (
       ] = true;
     }
     const uvShapeMinLongitude =
-      (shapeMinLongitude - defaultMinLongitude) / defaultLongitudeRange;
+      (shapeMinBounds.x - DefaultMinBounds.x) / defaultLongitudeRange;
     const uvShapeMaxLongitude =
-      (shapeMaxLongitude - defaultMinLongitude) / defaultLongitudeRange;
+      (shapeMaxBounds.x - DefaultMinBounds.x) / defaultLongitudeRange;
 
     const uvRenderMaxLongitude =
-      (renderMaxLongitude - defaultMinLongitude) / defaultLongitudeRange;
+      (renderMaxBounds.x - DefaultMinBounds.x) / defaultLongitudeRange;
     const uvRenderLongitudeRangeZero =
       1.0 - renderLongitudeRange / defaultLongitudeRange;
     const uvRenderLongitudeRangeZeroMid =
@@ -680,18 +625,10 @@ VoxelEllipsoidShape.prototype.update = function (
       }
     }
 
-    const minCosHalfAngleSqr = Math.pow(
-      Math.cos(CesiumMath.PI_OVER_TWO - Math.abs(renderMinLatitude)),
-      2.0
-    );
-    const maxCosHalfAngleSqr = Math.pow(
-      Math.cos(CesiumMath.PI_OVER_TWO - Math.abs(renderMaxLatitude)),
-      2.0
-    );
-    shaderUniforms.ellipsoidRenderLatitudeCosSqrHalfMinMax = Cartesian2.fromElements(
-      minCosHalfAngleSqr,
-      maxCosHalfAngleSqr,
-      shaderUniforms.ellipsoidRenderLatitudeCosSqrHalfMinMax
+    shaderUniforms.ellipsoidRenderLatitudeSinMinMax = Cartesian2.fromElements(
+      Math.sin(renderMinBounds.y),
+      Math.sin(renderMaxBounds.y),
+      shaderUniforms.ellipsoidRenderLatitudeSinMinMax
     );
   }
 
@@ -715,9 +652,10 @@ VoxelEllipsoidShape.prototype.update = function (
         shaderUniforms.ellipsoidUvToShapeUvLatitude
       );
     } else {
+      const defaultLatitudeRange = DefaultMaxBounds.y - DefaultMinBounds.y;
       const scale = defaultLatitudeRange / shapeLatitudeRange;
       const offset =
-        (defaultMinLatitude - shapeMinLatitude) / shapeLatitudeRange;
+        (DefaultMinBounds.y - shapeMinBounds.y) / shapeLatitudeRange;
       shaderUniforms.ellipsoidUvToShapeUvLatitude = Cartesian2.fromElements(
         scale,
         offset,
@@ -726,10 +664,6 @@ VoxelEllipsoidShape.prototype.update = function (
     }
   }
 
-  if (isSphere) {
-    shaderDefines["ELLIPSOID_IS_SPHERE"] = true;
-  }
-
   this.shaderMaximumIntersectionsLength = intersectionCount;
 
   return true;
@@ -888,31 +822,6 @@ VoxelEllipsoidShape.prototype.computeOrientedBoundingBoxForSample = function (
   );
 };
 
-/**
- * Computes an approximate step size for raymarching the root tile of a voxel grid.
- * The update function must be called before calling this function.
- *
- * @param {Cartesian3} dimensions The voxel grid dimensions for a tile.
- * @returns {number} The step size.
- */
-VoxelEllipsoidShape.prototype.computeApproximateStepSize = function (
-  dimensions
-) {
-  //>>includeStart('debug', pragmas.debug);
-  Check.typeOf.object("dimensions", dimensions);
-  //>>includeEnd('debug');
-
-  const ellipsoid = this._ellipsoid;
-  const ellipsoidMaximumRadius = ellipsoid.maximumRadius;
-  const minimumHeight = this._minimumHeight;
-  const maximumHeight = this._maximumHeight;
-
-  const shellToEllipsoidRatio =
-    (maximumHeight - minimumHeight) / (ellipsoidMaximumRadius + maximumHeight);
-  const stepSize = (0.5 * shellToEllipsoidRatio) / dimensions.z;
-  return stepSize;
-};
-
 /**
  * Computes an {@link OrientedBoundingBox} for a subregion of the shape.
  *