@cesium/engine 14.0.0 → 15.0.0

package/Source/Scene/VoxelCylinderShape.js

@@ -26,6 +26,7 @@ function VoxelCylinderShape() {
   /**
    * An oriented bounding box containing the bounded shape.
    * The update function must be called before accessing this value.
+   * @private
    * @type {OrientedBoundingBox}
    * @readonly
    */
@@ -34,6 +35,7 @@ function VoxelCylinderShape() {
   /**
    * A bounding sphere containing the bounded shape.
    * The update function must be called before accessing this value.
+   * @private
    * @type {BoundingSphere}
    * @readonly
    */
@@ -42,6 +44,7 @@ function VoxelCylinderShape() {
   /**
    * A transformation matrix containing the bounded shape.
    * The update function must be called before accessing this value.
+   * @private
    * @type {Matrix4}
    * @readonly
    */
@@ -50,6 +53,7 @@ function VoxelCylinderShape() {
   /**
    * A transformation matrix containing the shape, ignoring the bounds.
    * The update function must be called before accessing this value.
+   * @private
    * @type {Matrix4}
    * @readonly
    */
@@ -71,42 +75,44 @@ function VoxelCylinderShape() {
    * @type {number}
    * @private
    */
-  this._minimumHeight = VoxelCylinderShape.DefaultMinBounds.y;
+  this._minimumAngle = VoxelCylinderShape.DefaultMinBounds.y;
 
   /**
    * @type {number}
    * @private
    */
-  this._maximumHeight = VoxelCylinderShape.DefaultMaxBounds.y;
+  this._maximumAngle = VoxelCylinderShape.DefaultMaxBounds.y;
 
   /**
    * @type {number}
    * @private
    */
-  this._minimumAngle = VoxelCylinderShape.DefaultMinBounds.z;
+  this._minimumHeight = VoxelCylinderShape.DefaultMinBounds.z;
 
   /**
    * @type {number}
    * @private
    */
-  this._maximumAngle = VoxelCylinderShape.DefaultMaxBounds.z;
+  this._maximumHeight = VoxelCylinderShape.DefaultMaxBounds.z;
 
   /**
+   * @private
    * @type {Object<string, any>}
    * @readonly
    */
   this.shaderUniforms = {
-    cylinderRenderHeightMinMax: new Cartesian2(),
     cylinderRenderRadiusMinMax: new Cartesian2(),
     cylinderRenderAngleMinMax: new Cartesian2(),
+    cylinderRenderHeightMinMax: new Cartesian2(),
     cylinderUvToShapeUvRadius: new Cartesian2(),
-    cylinderUvToShapeUvHeight: new Cartesian2(),
     cylinderUvToShapeUvAngle: new Cartesian2(),
+    cylinderUvToShapeUvHeight: new Cartesian2(),
     cylinderShapeUvAngleMinMax: new Cartesian2(),
     cylinderShapeUvAngleRangeZeroMid: 0.0,
   };
 
   /**
+   * @private
    * @type {Object<string, any>}
    * @readonly
    */
@@ -132,6 +138,7 @@ function VoxelCylinderShape() {
 
   /**
    * The maximum number of intersections against the shape for any ray direction.
+   * @private
    * @type {number}
    * @readonly
    */
@@ -142,7 +149,7 @@ const scratchScale = new Cartesian3();
 
 /**
  * Update the shape's state.
- *
+ * @private
  * @param {Matrix4} modelMatrix The model matrix.
  * @param {Cartesian3} minBounds The minimum bounds.
  * @param {Cartesian3} maxBounds The maximum bounds.
@@ -173,10 +180,10 @@ VoxelCylinderShape.prototype.update = function (
 
   const defaultMinRadius = VoxelCylinderShape.DefaultMinBounds.x;
   const defaultMaxRadius = VoxelCylinderShape.DefaultMaxBounds.x;
-  const defaultMinHeight = VoxelCylinderShape.DefaultMinBounds.y;
-  const defaultMaxHeight = VoxelCylinderShape.DefaultMaxBounds.y;
-  const defaultMinAngle = VoxelCylinderShape.DefaultMinBounds.z;
-  const defaultMaxAngle = VoxelCylinderShape.DefaultMaxBounds.z;
+  const defaultMinAngle = VoxelCylinderShape.DefaultMinBounds.y;
+  const defaultMaxAngle = VoxelCylinderShape.DefaultMaxBounds.y;
+  const defaultMinHeight = VoxelCylinderShape.DefaultMinBounds.z;
+  const defaultMaxHeight = VoxelCylinderShape.DefaultMaxBounds.z;
   const defaultAngleRange = defaultMaxAngle - defaultMinAngle;
   const defaultAngleRangeHalf = 0.5 * defaultAngleRange;
 
@@ -208,38 +215,38 @@ VoxelCylinderShape.prototype.update = function (
   const renderMinRadius = Math.max(shapeMinRadius, clipMinRadius);
   const renderMaxRadius = Math.min(shapeMaxRadius, clipMaxRadius);
 
+  // Clamp the angles to the valid range
+  const shapeMinAngle = CesiumMath.negativePiToPi(minBounds.y);
+  const shapeMaxAngle = CesiumMath.negativePiToPi(maxBounds.y);
+  const clipMinAngle = CesiumMath.negativePiToPi(clipMinBounds.y);
+  const clipMaxAngle = CesiumMath.negativePiToPi(clipMaxBounds.y);
+  const renderMinAngle = Math.max(shapeMinAngle, clipMinAngle);
+  const renderMaxAngle = Math.min(shapeMaxAngle, clipMaxAngle);
+
   // Clamp the heights to the valid range
   const shapeMinHeight = CesiumMath.clamp(
-    minBounds.y,
+    minBounds.z,
     defaultMinHeight,
     defaultMaxHeight,
   );
   const shapeMaxHeight = CesiumMath.clamp(
-    maxBounds.y,
+    maxBounds.z,
     defaultMinHeight,
     defaultMaxHeight,
   );
   const clipMinHeight = CesiumMath.clamp(
-    clipMinBounds.y,
+    clipMinBounds.z,
     defaultMinHeight,
     defaultMaxHeight,
   );
   const clipMaxHeight = CesiumMath.clamp(
-    clipMaxBounds.y,
+    clipMaxBounds.z,
     defaultMinHeight,
     defaultMaxHeight,
   );
   const renderMinHeight = Math.max(shapeMinHeight, clipMinHeight);
   const renderMaxHeight = Math.min(shapeMaxHeight, clipMaxHeight);
 
-  // Clamp the angles to the valid range
-  const shapeMinAngle = CesiumMath.negativePiToPi(minBounds.z);
-  const shapeMaxAngle = CesiumMath.negativePiToPi(maxBounds.z);
-  const clipMinAngle = CesiumMath.negativePiToPi(clipMinBounds.z);
-  const clipMaxAngle = CesiumMath.negativePiToPi(clipMaxBounds.z);
-  const renderMinAngle = Math.max(shapeMinAngle, clipMinAngle);
-  const renderMaxAngle = Math.min(shapeMaxAngle, clipMaxAngle);
-
   const scale = Matrix4.getScale(modelMatrix, scratchScale);
 
   // Exit early if the shape is not visible.
@@ -263,20 +270,20 @@ VoxelCylinderShape.prototype.update = function (
 
   this._minimumRadius = shapeMinRadius; // [0,1]
   this._maximumRadius = shapeMaxRadius; // [0,1]
-  this._minimumHeight = shapeMinHeight; // [-1,+1]
-  this._maximumHeight = shapeMaxHeight; // [-1,+1]
   this._minimumAngle = shapeMinAngle; // [-pi,+pi]
   this._maximumAngle = shapeMaxAngle; // [-pi,+pi]
+  this._minimumHeight = shapeMinHeight; // [-1,+1]
+  this._maximumHeight = shapeMaxHeight; // [-1,+1]
 
   this.shapeTransform = Matrix4.clone(modelMatrix, this.shapeTransform);
 
   this.orientedBoundingBox = getCylinderChunkObb(
     renderMinRadius,
     renderMaxRadius,
-    renderMinHeight,
-    renderMaxHeight,
     renderMinAngle,
     renderMaxAngle,
+    renderMinHeight,
+    renderMaxHeight,
     this.shapeTransform,
     this.orientedBoundingBox,
   );
@@ -296,8 +303,6 @@ VoxelCylinderShape.prototype.update = function (
   const shapeIsDefaultMinRadius = shapeMinRadius === defaultMinRadius;
   const shapeIsDefaultRadius =
     shapeIsDefaultMinRadius && shapeIsDefaultMaxRadius;
-  const shapeIsDefaultHeight =
-    shapeMinHeight === defaultMinHeight && shapeMaxHeight === defaultMaxHeight;
   const shapeIsAngleReversed = shapeMaxAngle < shapeMinAngle;
   const shapeAngleRange =
     shapeMaxAngle - shapeMinAngle + shapeIsAngleReversed * defaultAngleRange;
@@ -323,6 +328,8 @@ VoxelCylinderShape.prototype.update = function (
     undefined,
     epsilonAngleDiscontinuity,
   );
+  const shapeIsDefaultHeight =
+    shapeMinHeight === defaultMinHeight && shapeMaxHeight === defaultMaxHeight;
 
   const renderIsDefaultMinRadius = renderMinRadius === defaultMinRadius;
   const renderIsAngleReversed = renderMaxAngle < renderMinAngle;
@@ -504,7 +511,7 @@ VoxelCylinderShape.prototype.update = function (
 /**
  * Computes an oriented bounding box for a specified tile.
  * The update function must be called before calling this function.
- *
+ * @private
  * @param {number} tileLevel The tile's level.
  * @param {number} tileX The tile's x coordinate.
  * @param {number} tileY The tile's y coordinate.
@@ -529,10 +536,10 @@ VoxelCylinderShape.prototype.computeOrientedBoundingBoxForTile = function (
 
   const minimumRadius = this._minimumRadius;
   const maximumRadius = this._maximumRadius;
-  const minimumHeight = this._minimumHeight;
-  const maximumHeight = this._maximumHeight;
   const minimumAngle = this._minimumAngle;
   const maximumAngle = this._maximumAngle;
+  const minimumHeight = this._minimumHeight;
+  const maximumHeight = this._maximumHeight;
 
   const sizeAtLevel = 1.0 / Math.pow(2.0, tileLevel);
 
@@ -546,34 +553,34 @@ VoxelCylinderShape.prototype.computeOrientedBoundingBoxForTile = function (
     maximumRadius,
     (tileX + 1) * sizeAtLevel,
   );
-  const heightStart = CesiumMath.lerp(
-    minimumHeight,
-    maximumHeight,
-    tileY * sizeAtLevel,
-  );
-  const heightEnd = CesiumMath.lerp(
-    minimumHeight,
-    maximumHeight,
-    (tileY + 1) * sizeAtLevel,
-  );
   const angleStart = CesiumMath.lerp(
     minimumAngle,
     maximumAngle,
-    tileZ * sizeAtLevel,
+    tileY * sizeAtLevel,
   );
   const angleEnd = CesiumMath.lerp(
     minimumAngle,
     maximumAngle,
+    (tileY + 1) * sizeAtLevel,
+  );
+  const heightStart = CesiumMath.lerp(
+    minimumHeight,
+    maximumHeight,
+    tileZ * sizeAtLevel,
+  );
+  const heightEnd = CesiumMath.lerp(
+    minimumHeight,
+    maximumHeight,
     (tileZ + 1) * sizeAtLevel,
   );
 
   return getCylinderChunkObb(
     radiusStart,
     radiusEnd,
-    heightStart,
-    heightEnd,
     angleStart,
     angleEnd,
+    heightStart,
+    heightEnd,
     this.shapeTransform,
     result,
   );
@@ -586,7 +593,7 @@ const scratchTileMaxBounds = new Cartesian3();
 /**
  * Computes an oriented bounding box for a specified sample within a specified tile.
  * The update function must be called before calling this function.
- *
+ * @private
  * @param {SpatialNode} spatialNode The spatial node containing the sample
  * @param {Cartesian3} tileDimensions The size of the tile in number of samples, before padding
  * @param {Cartesian3} tileUv The sample coordinate within the tile
@@ -651,10 +658,10 @@ VoxelCylinderShape.prototype.computeOrientedBoundingBoxForSample = function (
   return getCylinderChunkObb(
     radiusStart,
     radiusEnd,
-    heightStart,
-    heightEnd,
     angleStart,
     angleEnd,
+    heightStart,
+    heightEnd,
     this.shapeTransform,
     result,
   );
@@ -670,7 +677,7 @@ VoxelCylinderShape.prototype.computeOrientedBoundingBoxForSample = function (
  * @private
  */
 VoxelCylinderShape.DefaultMinBounds = Object.freeze(
-  new Cartesian3(0.0, -1.0, -CesiumMath.PI),
+  new Cartesian3(0.0, -CesiumMath.PI, -1.0),
 );
 
 /**
@@ -683,7 +690,7 @@ VoxelCylinderShape.DefaultMinBounds = Object.freeze(
  * @private
  */
 VoxelCylinderShape.DefaultMaxBounds = Object.freeze(
-  new Cartesian3(1.0, +1.0, +CesiumMath.PI),
+  new Cartesian3(1.0, +CesiumMath.PI, +1.0),
 );
 
 const maxTestAngles = 5;
@@ -744,10 +751,10 @@ function computeLooseOrientedBoundingBox(matrix, result) {
  *
  * @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} heightStart The heightStart.
+ * @param {number} heightEnd The heightEnd.
  * @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.
@@ -757,10 +764,10 @@ function computeLooseOrientedBoundingBox(matrix, result) {
 function getCylinderChunkObb(
   radiusStart,
   radiusEnd,
-  heightStart,
-  heightEnd,
   angleStart,
   angleEnd,
+  heightStart,
+  heightEnd,
   matrix,
   result,
 ) {
@@ -768,10 +775,10 @@ function getCylinderChunkObb(
   const defaultMaxBounds = VoxelCylinderShape.DefaultMaxBounds;
   const defaultMinRadius = defaultMinBounds.x; // 0
   const defaultMaxRadius = defaultMaxBounds.x; // 1
-  const defaultMinHeight = defaultMinBounds.y; // -1
-  const defaultMaxHeight = defaultMaxBounds.y; // +1
-  const defaultMinAngle = defaultMinBounds.z; // -pi
-  const defaultMaxAngle = defaultMaxBounds.z; // +pi
+  const defaultMinAngle = defaultMinBounds.y; // -pi
+  const defaultMaxAngle = defaultMaxBounds.y; // +pi
+  const defaultMinHeight = defaultMinBounds.z; // -1
+  const defaultMaxHeight = defaultMaxBounds.z; // +1
 
   // Return early if using the default bounds
   if (

package/Source/Scene/VoxelEllipsoidShape.js

@@ -29,6 +29,7 @@ function VoxelEllipsoidShape() {
    * The update function must be called before accessing this value.
    * @type {OrientedBoundingBox}
    * @readonly
+   * @private
    */
   this.orientedBoundingBox = new OrientedBoundingBox();
 
@@ -37,6 +38,7 @@ function VoxelEllipsoidShape() {
    * The update function must be called before accessing this value.
    * @type {BoundingSphere}
    * @readonly
+   * @private
    */
   this.boundingSphere = new BoundingSphere();
 
@@ -45,6 +47,7 @@ function VoxelEllipsoidShape() {
    * The update function must be called before accessing this value.
    * @type {Matrix4}
    * @readonly
+   * @private
    */
   this.boundTransform = new Matrix4();
 
@@ -53,11 +56,13 @@ function VoxelEllipsoidShape() {
    * The update function must be called before accessing this value.
    * @type {Matrix4}
    * @readonly
+   * @private
    */
   this.shapeTransform = new Matrix4();
 
   /**
    * @type {Rectangle}
+   * @private
    */
   this._rectangle = new Rectangle();
 
@@ -81,17 +86,20 @@ function VoxelEllipsoidShape() {
 
   /**
    * @type {Cartesian3}
+   * @private
    */
   this._translation = new Cartesian3();
 
   /**
    * @type {Matrix3}
+   * @private
    */
   this._rotation = new Matrix3();
 
   /**
    * @type {Object<string, any>}
    * @readonly
+   * @private
    */
   this.shaderUniforms = {
     ellipsoidRadiiUv: new Cartesian3(),
@@ -110,6 +118,7 @@ function VoxelEllipsoidShape() {
   /**
    * @type {Object<string, any>}
    * @readonly
+   * @private
    */
   this.shaderDefines = {
     ELLIPSOID_HAS_RENDER_BOUNDS_LONGITUDE: undefined,
@@ -138,6 +147,7 @@ function VoxelEllipsoidShape() {
    * The maximum number of intersections against the shape for any ray direction.
    * @type {number}
    * @readonly
+   * @private
    */
   this.shaderMaximumIntersectionsLength = 0; // not known until update
 }
@@ -157,7 +167,7 @@ const scratchRenderRectangle = new Rectangle();
 
 /**
  * Update the shape's state.
- *
+ * @private
  * @param {Matrix4} modelMatrix The model matrix.
  * @param {Cartesian3} minBounds The minimum bounds.
  * @param {Cartesian3} maxBounds The maximum bounds.
@@ -660,7 +670,7 @@ const scratchRectangle = new Rectangle();
 /**
  * Computes an oriented bounding box for a specified tile.
  * The update function must be called before calling this function.
- *
+ * @private
  * @param {number} tileLevel The tile's level.
  * @param {number} tileX The tile's x coordinate.
  * @param {number} tileY The tile's y coordinate.
@@ -730,7 +740,7 @@ const scratchTileMaxBounds = new Cartesian3();
 /**
  * Computes an oriented bounding box for a specified sample within a specified tile.
  * The update function must be called before calling this function.
- *
+ * @private
  * @param {SpatialNode} spatialNode The spatial node containing the sample
  * @param {Cartesian3} tileDimensions The size of the tile in number of samples, before padding
  * @param {Cartesian3} tileUv The sample coordinate within the tile
@@ -851,7 +861,7 @@ function getEllipsoidChunkObb(
 
 /**
  * Defines the minimum bounds of the shape. Corresponds to minimum longitude, latitude, height.
- *
+ * @private
  * @type {Cartesian3}
  * @constant
  * @readonly
@@ -866,7 +876,7 @@ VoxelEllipsoidShape.DefaultMinBounds = Object.freeze(
 
 /**
  * Defines the maximum bounds of the shape. Corresponds to maximum longitude, latitude, height.
- *
+ * @private
  * @type {Cartesian3}
  * @constant
  * @readonly

package/Source/Scene/VoxelMetadataOrder.js

@@ -0,0 +1,12 @@
+/**
+ * Metadata ordering for voxel content.
+ * In all cases, x data is contiguous in strides along the y axis,
+ * and each group of y strides represents a z slice.
+ * However, the orientation of the axes follows different conventions.
+ * @enum {number}
+ */
+const VoxelMetadataOrder = {
+  XYZ: 0, // Default ordering following the 3D Tiles convention. Z-axis points upward.
+  GLTF: 1, // Ordering following the glTF convention. Y-axis points upward.
+};
+export default Object.freeze(VoxelMetadataOrder);