@cesium/engine 1.1.0 → 2.1.0

package/Source/Scene/VoxelBoxShape.js

@@ -72,31 +72,28 @@ function VoxelBoxShape() {
   );
 
   /**
-   * @type {Object.<string, any>}
+   * @type {Object<string, any>}
    * @readonly
    */
   this.shaderUniforms = {
-    boxUvToRenderBoundsTransform: new Matrix4(),
-    boxUvToRenderBoundsScale: new Cartesian3(),
-    boxUvToRenderBoundsTranslate: new Cartesian3(),
+    renderMinBounds: new Cartesian3(),
+    renderMaxBounds: new Cartesian3(),
     boxUvToShapeUvScale: new Cartesian3(),
     boxUvToShapeUvTranslate: new Cartesian3(),
   };
 
   /**
-   * @type {Object.<string, any>}
+   * @type {Object<string, any>}
    * @readonly
    */
   this.shaderDefines = {
     BOX_INTERSECTION_INDEX: undefined,
-    BOX_HAS_RENDER_BOUNDS: undefined,
     BOX_HAS_SHAPE_BOUNDS: undefined,
-    BOX_IS_2D: undefined,
   };
 
   /**
    * The maximum number of intersections against the shape for any ray direction.
-   * @type {Number}
+   * @type {number}
    * @readonly
    */
   this.shaderMaximumIntersectionsLength = 0; // not known until update
@@ -105,34 +102,14 @@ function VoxelBoxShape() {
 const scratchCenter = new Cartesian3();
 const scratchScale = new Cartesian3();
 const scratchRotation = new Matrix3();
-const scratchTransformLocalToBounds = new Matrix4();
-const scratchBoundsTranslation = new Cartesian3();
-const scratchBoundsScale = new Cartesian3();
-const scratchBoundsScaleMatrix = new Matrix3();
 const scratchClipMinBounds = new Cartesian3();
 const scratchClipMaxBounds = new Cartesian3();
 const scratchRenderMinBounds = new Cartesian3();
 const scratchRenderMaxBounds = new Cartesian3();
 
-const transformUvToLocal = Matrix4.fromRotationTranslation(
-  Matrix3.fromUniformScale(2.0, new Matrix3()),
-  new Cartesian3(-1.0, -1.0, -1.0),
-  new Matrix4()
-);
-
-const transformXYZToZYX = Matrix4.fromRotation(
-  Matrix3.fromColumnMajorArray(
-    [0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 0.0],
-    new Matrix3()
-  ),
-  new Matrix4()
-);
-
-const transformXYZToXZY = Matrix4.fromRotation(
-  Matrix3.fromColumnMajorArray(
-    [1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0],
-    new Matrix3()
-  ),
+const transformLocalToUv = Matrix4.fromRotationTranslation(
+  Matrix3.fromUniformScale(0.5, new Matrix3()),
+  new Cartesian3(0.5, 0.5, 0.5),
   new Matrix4()
 );
 
@@ -144,7 +121,7 @@ const transformXYZToXZY = Matrix4.fromRotation(
  * @param {Cartesian3} maxBounds The maximum bounds.
  * @param {Cartesian3} [clipMinBounds=VoxelBoxShape.DefaultMinBounds] The minimum clip bounds.
  * @param {Cartesian3} [clipMaxBounds=VoxelBoxShape.DefaultMaxBounds] The maximum clip bounds.
- * @returns {Boolean} Whether the shape is visible.
+ * @returns {boolean} Whether the shape is visible.
  */
 VoxelBoxShape.prototype.update = function (
   modelMatrix,
@@ -253,8 +230,7 @@ VoxelBoxShape.prototype.update = function (
     this.boundingSphere
   );
 
-  const shaderUniforms = this.shaderUniforms;
-  const shaderDefines = this.shaderDefines;
+  const { shaderUniforms, shaderDefines } = this;
 
   // To keep things simple, clear the defines every time
   for (const key in shaderDefines) {
@@ -263,21 +239,9 @@ VoxelBoxShape.prototype.update = function (
     }
   }
 
-  const hasRenderBounds =
-    renderMinBounds.x !== defaultMinBounds.x ||
-    renderMaxBounds.x !== defaultMaxBounds.x ||
-    renderMinBounds.y !== defaultMinBounds.y ||
-    renderMaxBounds.y !== defaultMaxBounds.y ||
-    renderMinBounds.z !== defaultMinBounds.z ||
-    renderMaxBounds.z !== defaultMaxBounds.z;
-
   const hasShapeBounds =
-    minBounds.x !== defaultMinBounds.x ||
-    maxBounds.x !== defaultMaxBounds.x ||
-    minBounds.y !== defaultMinBounds.y ||
-    maxBounds.y !== defaultMaxBounds.y ||
-    minBounds.z !== defaultMinBounds.z ||
-    maxBounds.z !== defaultMaxBounds.z;
+    !Cartesian3.equals(minBounds, defaultMinBounds) ||
+    !Cartesian3.equals(maxBounds, defaultMaxBounds);
 
   // Keep track of how many intersections there are going to be.
   let intersectionCount = 0;
@@ -285,71 +249,16 @@ VoxelBoxShape.prototype.update = function (
   shaderDefines["BOX_INTERSECTION_INDEX"] = intersectionCount;
   intersectionCount += 1;
 
-  if (hasRenderBounds) {
-    shaderDefines["BOX_HAS_RENDER_BOUNDS"] = true;
-
-    const min = renderMinBounds;
-    const max = renderMaxBounds;
-
-    // inverse(scale)
-    // inverse(maxBoundsUv - minBoundsUv)
-    // inverse((maxBounds * 0.5 + 0.5) - (minBounds * 0.5 + 0.5))
-    // inverse(0.5 * (maxBounds - minBounds))
-    // 2.0 / (maxBounds - minBounds) // with divide by zero protection
-    const scaleLocalToBounds = Cartesian3.fromElements(
-      2.0 / (min.x === max.x ? 1.0 : max.x - min.x),
-      2.0 / (min.y === max.y ? 1.0 : max.y - min.y),
-      2.0 / (min.z === max.z ? 1.0 : max.z - min.z),
-      scratchBoundsScale
-    );
-
-    // -inverse(scale) * translation // affine inverse
-    // -inverse(scale) * 0.5 * (minBounds + maxBounds)
-    const translateLocalToBounds = Cartesian3.fromElements(
-      -scaleLocalToBounds.x * 0.5 * (min.x + max.x),
-      -scaleLocalToBounds.y * 0.5 * (min.y + max.y),
-      -scaleLocalToBounds.z * 0.5 * (min.z + max.z),
-      scratchBoundsTranslation
-    );
-
-    let transformLocalToBounds = Matrix4.fromRotationTranslation(
-      Matrix3.fromScale(scaleLocalToBounds, scratchBoundsScaleMatrix),
-      translateLocalToBounds,
-      scratchTransformLocalToBounds
-    );
-
-    if (min.x === max.x || min.y === max.y || min.z === max.z) {
-      shaderDefines["BOX_IS_2D"] = true;
-
-      let transformAxisConversion;
-      if (min.x === max.x) {
-        transformAxisConversion = transformXYZToZYX;
-      } else if (min.y === max.y) {
-        transformAxisConversion = transformXYZToXZY;
-      } else if (min.z === max.z) {
-        transformAxisConversion = Matrix4.IDENTITY;
-      }
-      transformLocalToBounds = Matrix4.multiplyTransformation(
-        transformAxisConversion,
-        transformLocalToBounds,
-        transformLocalToBounds
-      );
-    }
-
-    shaderUniforms.boxUvToRenderBoundsTransform = Matrix4.multiplyTransformation(
-      transformLocalToBounds,
-      transformUvToLocal,
-      shaderUniforms.boxUvToRenderBoundsTransform
-    );
-    shaderUniforms.boxUvToRenderBoundsScale = Matrix4.getScale(
-      shaderUniforms.boxUvToRenderBoundsTransform,
-      shaderUniforms.boxUvToRenderBoundsScale
-    );
-    shaderUniforms.boxUvToRenderBoundsTranslate = Matrix4.getTranslation(
-      shaderUniforms.boxUvToRenderBoundsTransform,
-      shaderUniforms.boxUvToRenderBoundsTranslate
-    );
-  }
+  shaderUniforms.renderMinBounds = Matrix4.multiplyByPoint(
+    transformLocalToUv,
+    renderMinBounds,
+    shaderUniforms.renderMinBounds
+  );
+  shaderUniforms.renderMaxBounds = Matrix4.multiplyByPoint(
+    transformLocalToUv,
+    renderMaxBounds,
+    shaderUniforms.renderMaxBounds
+  );
 
   if (hasShapeBounds) {
     shaderDefines["BOX_HAS_SHAPE_BOUNDS"] = true;
@@ -394,10 +303,10 @@ const scratchTileMaxBounds = new Cartesian3();
  * Computes an oriented bounding box for a specified tile.
  * The update function must be called before calling this function.
  *
- * @param {Number} tileLevel The tile's level.
- * @param {Number} tileX The tile's x coordinate.
- * @param {Number} tileY The tile's y coordinate.
- * @param {Number} tileZ The tile's z coordinate.
+ * @param {number} tileLevel The tile's level.
+ * @param {number} tileX The tile's x coordinate.
+ * @param {number} tileY The tile's y coordinate.
+ * @param {number} tileZ The tile's z coordinate.
  * @param {OrientedBoundingBox} result The oriented bounding box that will be set to enclose the specified tile
  * @returns {OrientedBoundingBox} The oriented bounding box.
  */
@@ -447,7 +356,7 @@ VoxelBoxShape.prototype.computeOrientedBoundingBoxForTile = function (
  * 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.
+ * @returns {number} The step size.
  */
 VoxelBoxShape.prototype.computeApproximateStepSize = function (dimensions) {
   //>>includeStart('debug', pragmas.debug);

package/Source/Scene/VoxelContent.js

@@ -11,7 +11,7 @@ import MetadataTable from "./MetadataTable.js";
  * @constructor
  *
  * @param {Resource} resource The resource for this voxel content. This is used for fetching external buffers as needed.
- * @param {Object} [json] Voxel JSON contents. Mutually exclusive with binary.
+ * @param {object} [json] Voxel JSON contents. Mutually exclusive with binary.
  * @param {Uint8Array} [binary] Voxel binary contents. Mutually exclusive with json.
  * @param {MetadataSchema} metadataSchema The metadata schema used by property tables in the voxel content
  *
@@ -128,8 +128,8 @@ function requestBuffers(content, json, binary) {
 /**
  * A helper object for storing the two parts of the binary voxel content
  *
- * @typedef {Object} VoxelChunks
- * @property {Object} json The json chunk of the binary voxel content
+ * @typedef {object} VoxelChunks
+ * @property {object} json The json chunk of the binary voxel content
  * @property {Uint8Array} binary The binary chunk of the binary voxel content. This represents the internal buffer.
  * @private
  */

package/Source/Scene/VoxelCylinderShape.js

@@ -56,43 +56,43 @@ function VoxelCylinderShape() {
   this.shapeTransform = new Matrix4();
 
   /**
-   * @type {Number}
+   * @type {number}
    * @private
    */
   this._minimumRadius = VoxelCylinderShape.DefaultMinBounds.x;
 
   /**
-   * @type {Number}
+   * @type {number}
    * @private
    */
   this._maximumRadius = VoxelCylinderShape.DefaultMaxBounds.x;
 
   /**
-   * @type {Number}
+   * @type {number}
    * @private
    */
   this._minimumHeight = VoxelCylinderShape.DefaultMinBounds.y;
 
   /**
-   * @type {Number}
+   * @type {number}
    * @private
    */
   this._maximumHeight = VoxelCylinderShape.DefaultMaxBounds.y;
 
   /**
-   * @type {Number}
+   * @type {number}
    * @private
    */
   this._minimumAngle = VoxelCylinderShape.DefaultMinBounds.z;
 
   /**
-   * @type {Number}
+   * @type {number}
    * @private
    */
   this._maximumAngle = VoxelCylinderShape.DefaultMaxBounds.z;
 
   /**
-   * @type {Object.<string, any>}
+   * @type {Object<string, any>}
    * @readonly
    */
   this.shaderUniforms = {
@@ -108,7 +108,7 @@ function VoxelCylinderShape() {
   };
 
   /**
-   * @type {Object.<string, any>}
+   * @type {Object<string, any>}
    * @readonly
    */
   this.shaderDefines = {
@@ -140,7 +140,7 @@ function VoxelCylinderShape() {
 
   /**
    * The maximum number of intersections against the shape for any ray direction.
-   * @type {Number}
+   * @type {number}
    * @readonly
    */
   this.shaderMaximumIntersectionsLength = 0; // not known until update
@@ -167,7 +167,7 @@ const transformUvToLocal = Matrix4.fromRotationTranslation(
  * @param {Cartesian3} maxBounds The maximum bounds.
  * @param {Cartesian3} [clipMinBounds=VoxelCylinderShape.DefaultMinBounds] The minimum clip bounds.
  * @param {Cartesian3} [clipMaxBounds=VoxelCylinderShape.DefaultMaxBounds] The maximum clip bounds.
- * @returns {Boolean} Whether the shape is visible.
+ * @returns {boolean} Whether the shape is visible.
  */
 VoxelCylinderShape.prototype.update = function (
   modelMatrix,
@@ -571,10 +571,10 @@ VoxelCylinderShape.prototype.update = function (
  * Computes an oriented bounding box for a specified tile.
  * The update function must be called before calling this function.
  *
- * @param {Number} tileLevel The tile's level.
- * @param {Number} tileX The tile's x coordinate.
- * @param {Number} tileY The tile's y coordinate.
- * @param {Number} tileZ The tile's z coordinate.
+ * @param {number} tileLevel The tile's level.
+ * @param {number} tileX The tile's x coordinate.
+ * @param {number} tileY The tile's y coordinate.
+ * @param {number} tileZ The tile's z coordinate.
  * @param {OrientedBoundingBox} result The oriented bounding box that will be set to enclose the specified tile
  * @returns {OrientedBoundingBox} The oriented bounding box.
  */
@@ -655,7 +655,7 @@ const scratchScaleRatio = new Cartesian3();
  * 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.
+ * @returns {number} The step size.
  */
 VoxelCylinderShape.prototype.computeApproximateStepSize = function (
   dimensions
@@ -788,12 +788,12 @@ function computeLooseOrientedBoundingBox(matrix, result) {
  *
  * @function
  *
- * @param {Number} radiusStart The radiusStart.
- * @param {Number} radiusEnd The radiusEnd.
- * @param {Number} heightStart The heightStart.
- * @param {Number} heightEnd The heightEnd.
- * @param {Number} angleStart The angleStart.
- * @param {Number} angleEnd The angleEnd.
+ * @param {number} radiusStart The radiusStart.
+ * @param {number} radiusEnd The radiusEnd.
+ * @param {number} heightStart The heightStart.
+ * @param {number} heightEnd The heightEnd.
+ * @param {number} angleStart The angleStart.
+ * @param {number} angleEnd The angleEnd.
  * @param {Matrix4} matrix The matrix to transform the points.
  * @param {OrientedBoundingBox} result The object onto which to store the result.
  * @returns {OrientedBoundingBox} The oriented bounding box that contains this subregion.

package/Source/Scene/VoxelEllipsoidShape.js

@@ -62,13 +62,13 @@ function VoxelEllipsoidShape() {
   this._rectangle = new Rectangle();
 
   /**
-   * @type {Number}
+   * @type {number}
    * @private
    */
   this._minimumHeight = VoxelEllipsoidShape.DefaultMinBounds.z;
 
   /**
-   * @type {Number}
+   * @type {number}
    * @private
    */
   this._maximumHeight = VoxelEllipsoidShape.DefaultMaxBounds.z;
@@ -90,7 +90,7 @@ function VoxelEllipsoidShape() {
   this._rotation = new Matrix3();
 
   /**
-   * @type {Object.<string, any>}
+   * @type {Object<string, any>}
    * @readonly
    */
   this.shaderUniforms = {
@@ -104,10 +104,11 @@ function VoxelEllipsoidShape() {
     ellipsoidInverseHeightDifferenceUv: 0.0,
     ellipseInnerRadiiUv: new Cartesian2(),
     ellipsoidInverseInnerScaleUv: 0.0,
+    ellipsoidInverseOuterScaleUv: 0.0,
   };
 
   /**
-   * @type {Object.<string, any>}
+   * @type {Object<string, any>}
    * @readonly
    */
   this.shaderDefines = {
@@ -131,7 +132,9 @@ function VoxelEllipsoidShape() {
     ELLIPSOID_HAS_RENDER_BOUNDS_LATITUDE_RANGE_EQUAL_ZERO: undefined,
     ELLIPSOID_HAS_SHAPE_BOUNDS_LATITUDE: undefined,
     ELLIPSOID_HAS_SHAPE_BOUNDS_LATITUDE_RANGE_EQUAL_ZERO: undefined,
+    ELLIPSOID_HAS_RENDER_BOUNDS_HEIGHT_MAX: undefined,
     ELLIPSOID_HAS_RENDER_BOUNDS_HEIGHT_MIN: undefined,
+    ELLIPSOID_HAS_RENDER_BOUNDS_HEIGHT_FLAT: undefined,
     ELLIPSOID_HAS_SHAPE_BOUNDS_HEIGHT_MIN: undefined,
     ELLIPSOID_HAS_SHAPE_BOUNDS_HEIGHT_FLAT: undefined,
     ELLIPSOID_IS_SPHERE: undefined,
@@ -144,7 +147,7 @@ function VoxelEllipsoidShape() {
 
   /**
    * The maximum number of intersections against the shape for any ray direction.
-   * @type {Number}
+   * @type {number}
    * @readonly
    */
   this.shaderMaximumIntersectionsLength = 0; // not known until update
@@ -166,7 +169,7 @@ const scratchRenderRectangle = new Rectangle();
  * @param {Cartesian3} maxBounds The maximum bounds.
  * @param {Cartesian3} [clipMinBounds=VoxelEllipsoidShape.DefaultMinBounds] The minimum clip bounds.
  * @param {Cartesian3} [clipMaxBounds=VoxelEllipsoidShape.DefaultMaxBounds] The maximum clip bounds.
- * @returns {Boolean} Whether the shape is visible.
+ * @returns {boolean} Whether the shape is visible.
  */
 VoxelEllipsoidShape.prototype.update = function (
   modelMatrix,
@@ -305,7 +308,6 @@ VoxelEllipsoidShape.prototype.update = function (
     ),
     scratchRenderOuterExtent
   );
-  const renderMaxExtent = Cartesian3.maximumComponent(renderOuterExtent);
 
   // Exit early if the shape is not visible.
   // Note that minLongitude may be greater than maxLongitude when crossing the 180th meridian.
@@ -355,7 +357,7 @@ VoxelEllipsoidShape.prototype.update = function (
   );
 
   this.shapeTransform = Matrix4.fromRotationTranslation(
-    Matrix3.setScale(this._rotation, renderOuterExtent, scratchRotationScale),
+    Matrix3.setScale(this._rotation, shapeOuterExtent, scratchRotationScale),
     this._translation,
     this.shapeTransform
   );
@@ -393,7 +395,7 @@ VoxelEllipsoidShape.prototype.update = function (
     renderIsLongitudeRangeHalf ||
     renderIsLongitudeRangeOverHalf;
 
-  const shapeIsLongitudeReversed = renderMaxLongitude < renderMinLongitude;
+  const shapeIsLongitudeReversed = shapeMaxLongitude < shapeMinLongitude;
   const shapeLongitudeRange =
     shapeMaxLongitude -
     shapeMinLongitude +
@@ -532,12 +534,18 @@ VoxelEllipsoidShape.prototype.update = function (
       ] = intersectionCount;
       intersectionCount += 1;
 
-      // The inverse of the percent of space that is taken up by the inner ellipsoid.
+      // 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 - (renderMaxHeight - renderMinHeight) / renderMaxExtent)
-      // renderMaxExtent / (renderMaxExtent - (renderMaxHeight - renderMinHeight))
+      // 1.0 / (1.0 - (shapeMaxHeight - renderMinHeight) / shapeMaxExtent)
+      // shapeMaxExtent / (shapeMaxExtent - (shapeMaxHeight - renderMinHeight))
       shaderUniforms.ellipsoidInverseInnerScaleUv =
-        renderMaxExtent / (renderMaxExtent - renderHeightRange);
+        shapeMaxExtent / (shapeMaxExtent - (shapeMaxHeight - renderMinHeight));
+    }
+
+    if (renderHasMaxHeight) {
+      shaderDefines["ELLIPSOID_HAS_RENDER_BOUNDS_HEIGHT_MAX"] = true;
+      shaderUniforms.ellipsoidInverseOuterScaleUv =
+        shapeMaxExtent / (shapeMaxExtent - (shapeMaxHeight - renderMaxHeight));
     }
   }
 
@@ -784,10 +792,10 @@ const scratchRectangle = new Rectangle();
  * Computes an oriented bounding box for a specified tile.
  * The update function must be called before calling this function.
  *
- * @param {Number} tileLevel The tile's level.
- * @param {Number} tileX The tile's x coordinate.
- * @param {Number} tileY The tile's y coordinate.
- * @param {Number} tileZ The tile's z coordinate.
+ * @param {number} tileLevel The tile's level.
+ * @param {number} tileX The tile's x coordinate.
+ * @param {number} tileY The tile's y coordinate.
+ * @param {number} tileZ The tile's z coordinate.
  * @param {OrientedBoundingBox} result The oriented bounding box that will be set to enclose the specified tile
  * @returns {OrientedBoundingBox} The oriented bounding box.
  */
@@ -851,7 +859,7 @@ VoxelEllipsoidShape.prototype.computeOrientedBoundingBoxForTile = function (
  * 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.
+ * @returns {number} The step size.
  */
 VoxelEllipsoidShape.prototype.computeApproximateStepSize = function (
   dimensions
@@ -877,8 +885,8 @@ VoxelEllipsoidShape.prototype.computeApproximateStepSize = function (
  * @function
  *
  * @param {Rectangle} rectangle The rectangle.
- * @param {Number} minHeight The minimumZ.
- * @param {Number} maxHeight The maximumZ.
+ * @param {number} minHeight The minimumZ.
+ * @param {number} maxHeight The maximumZ.
  * @param {Ellipsoid} ellipsoid The ellipsoid.
  * @param {Cartesian3} translation The translation applied to the shape
  * @param {Matrix3} rotation The rotation applied to the shape