@cesium/engine 6.1.1 → 7.0.0

package/Source/Scene/Billboard.js

@@ -10,10 +10,13 @@ import defaultValue from "../Core/defaultValue.js";
 import defined from "../Core/defined.js";
 import DeveloperError from "../Core/DeveloperError.js";
 import DistanceDisplayCondition from "../Core/DistanceDisplayCondition.js";
+import Ellipsoid from "../Core/Ellipsoid.js";
 import Matrix4 from "../Core/Matrix4.js";
 import NearFarScalar from "../Core/NearFarScalar.js";
 import Resource from "../Core/Resource.js";
-import HeightReference from "./HeightReference.js";
+import HeightReference, {
+  isHeightReferenceRelative,
+} from "./HeightReference.js";
 import HorizontalOrigin from "./HorizontalOrigin.js";
 import SceneMode from "./SceneMode.js";
 import SceneTransforms from "./SceneTransforms.js";
@@ -1056,15 +1059,13 @@ Billboard.prototype._updateClamping = function () {
 };
 
 const scratchCartographic = new Cartographic();
-const scratchPosition = new Cartesian3();
-
 Billboard._updateClamping = function (collection, owner) {
   const scene = collection._scene;
-  if (!defined(scene) || !defined(scene.globe)) {
+  if (!defined(scene)) {
     //>>includeStart('debug', pragmas.debug);
     if (owner._heightReference !== HeightReference.NONE) {
       throw new DeveloperError(
-        "Height reference is not supported without a scene and globe."
+        "Height reference is not supported without a scene."
       );
     }
     //>>includeEnd('debug');
@@ -1072,8 +1073,7 @@ Billboard._updateClamping = function (collection, owner) {
   }
 
   const globe = scene.globe;
-  const ellipsoid = globe.ellipsoid;
-  const surface = globe._surface;
+  const ellipsoid = defaultValue(globe?.ellipsoid, Ellipsoid.WGS84);
 
   const mode = scene.frameState.mode;
 
@@ -1096,45 +1096,48 @@ Billboard._updateClamping = function (collection, owner) {
     return;
   }
 
+  if (defined(owner._removeCallbackFunc)) {
+    owner._removeCallbackFunc();
+  }
+
   const position = ellipsoid.cartesianToCartographic(owner._position);
   if (!defined(position)) {
     owner._actualClampedPosition = undefined;
     return;
   }
 
-  if (defined(owner._removeCallbackFunc)) {
-    owner._removeCallbackFunc();
-  }
-
   function updateFunction(clampedPosition) {
-    if (owner._heightReference === HeightReference.RELATIVE_TO_GROUND) {
+    owner._clampedPosition = ellipsoid.cartographicToCartesian(
+      clampedPosition,
+      owner._clampedPosition
+    );
+
+    if (isHeightReferenceRelative(owner._heightReference)) {
       if (owner._mode === SceneMode.SCENE3D) {
-        const clampedCart = ellipsoid.cartesianToCartographic(
+        clampedPosition.height += position.height;
+        ellipsoid.cartographicToCartesian(
           clampedPosition,
-          scratchCartographic
+          owner._clampedPosition
         );
-        clampedCart.height += position.height;
-        ellipsoid.cartographicToCartesian(clampedCart, clampedPosition);
       } else {
-        clampedPosition.x += position.height;
+        owner._clampedPosition.x += position.height;
       }
     }
-    owner._clampedPosition = Cartesian3.clone(
-      clampedPosition,
-      owner._clampedPosition
-    );
   }
-  owner._removeCallbackFunc = surface.updateHeight(position, updateFunction);
+
+  owner._removeCallbackFunc = scene.updateHeight(
+    position,
+    updateFunction,
+    owner._heightReference
+  );
 
   Cartographic.clone(position, scratchCartographic);
-  const height = globe.getHeight(position);
+  const height = scene.getHeight(position, owner._heightReference);
   if (defined(height)) {
     scratchCartographic.height = height;
   }
 
-  ellipsoid.cartographicToCartesian(scratchCartographic, scratchPosition);
-
-  updateFunction(scratchPosition);
+  updateFunction(scratchCartographic);
 };
 
 Billboard.prototype._loadImage = function () {

package/Source/Scene/BillboardCollection.js

@@ -28,7 +28,7 @@ import BillboardCollectionVS from "../Shaders/BillboardCollectionVS.js";
 import Billboard from "./Billboard.js";
 import BlendingState from "./BlendingState.js";
 import BlendOption from "./BlendOption.js";
-import HeightReference from "./HeightReference.js";
+import HeightReference, { isHeightReferenceClamp } from "./HeightReference.js";
 import HorizontalOrigin from "./HorizontalOrigin.js";
 import SceneMode from "./SceneMode.js";
 import SDFSettings from "./SDFSettings.js";
@@ -1375,7 +1375,7 @@ function writeCompressedAttribute3(
 
   let disableDepthTestDistance = billboard.disableDepthTestDistance;
   const clampToGround =
-    billboard.heightReference === HeightReference.CLAMP_TO_GROUND &&
+    isHeightReferenceClamp(billboard.heightReference) &&
     frameState.context.depthTexture;
   if (!defined(disableDepthTestDistance)) {
     disableDepthTestDistance = clampToGround ? 5000.0 : 0.0;
@@ -1448,7 +1448,7 @@ function writeTextureCoordinateBoundsOrLabelTranslate(
   vafWriters,
   billboard
 ) {
-  if (billboard.heightReference === HeightReference.CLAMP_TO_GROUND) {
+  if (isHeightReferenceClamp(billboard.heightReference)) {
     const scene = billboardCollection._scene;
     const context = frameState.context;
     const globeTranslucent = frameState.globeTranslucencyState.translucent;

package/Source/Scene/Camera.js

@@ -197,7 +197,7 @@ function Camera(scene) {
   this.defaultZoomAmount = 100000.0;
   /**
    * If set, the camera will not be able to rotate past this axis in either direction.
-   * @type {Cartesian3}
+   * @type {Cartesian3 | undefined}
    * @default undefined
    */
   this.constrainedAxis = undefined;

package/Source/Scene/Cesium3DTile.js

@@ -43,6 +43,7 @@ import TileBoundingS2Cell from "./TileBoundingS2Cell.js";
 import TileBoundingSphere from "./TileBoundingSphere.js";
 import TileOrientedBoundingBox from "./TileOrientedBoundingBox.js";
 import Pass from "../Renderer/Pass.js";
+import VerticalExaggeration from "../Core/VerticalExaggeration.js";
 
 /**
  * A tile in a {@link Cesium3DTileset}.  When a tile is first created, its content is not loaded;
@@ -119,6 +120,9 @@ function Cesium3DTile(tileset, baseResource, header, parent) {
    */
   this.metadata = findTileMetadata(tileset, header);
 
+  this._verticalExaggeration = 1.0;
+  this._verticalExaggerationRelativeHeight = 0.0;
+
   // Important: tile metadata must be parsed before this line so that the
   // metadata semantics TILE_BOUNDING_BOX, TILE_BOUNDING_REGION, or TILE_BOUNDING_SPHERE
   // can override header.boundingVolume (if necessary)
@@ -470,6 +474,7 @@ function Cesium3DTile(tileset, baseResource, header, parent) {
   this._touchedFrame = 0;
   this._visitedFrame = 0;
   this._selectedFrame = 0;
+  this._wasSelectedLastFrame = false;
   this._requestedFrame = 0;
   this._ancestorWithContent = undefined;
   this._ancestorWithContentAvailable = undefined;
@@ -1018,7 +1023,7 @@ Cesium3DTile.prototype.updateVisibility = function (frameState) {
   const parentVisibilityPlaneMask = defined(parent)
     ? parent._visibilityPlaneMask
     : CullingVolume.MASK_INDETERMINATE;
-  this.updateTransform(parentTransform);
+  this.updateTransform(parentTransform, frameState);
   this._distanceToCamera = this.distanceToTile(frameState);
   this._centerZDepth = this.distanceToTileCenter(frameState);
   this._screenSpaceError = this.getScreenSpaceError(frameState, false);
@@ -1709,12 +1714,18 @@ function createRegion(region, transform, initialTransform, result) {
     );
   }
 
+  const rectangleRegion = Rectangle.unpack(region, 0, scratchRectangle);
+
   if (defined(result)) {
+    result.rectangle = Rectangle.clone(rectangleRegion, result.rectangle);
+    result.minimumHeight = region[4];
+    result.maximumHeight = region[5];
+    // The TileBoundingRegion was already constructed with the default
+    // WGS84 ellipsoid, so keep it consistent when updating.
+    result.computeBoundingVolumes(Ellipsoid.WGS84);
     return result;
   }
 
-  const rectangleRegion = Rectangle.unpack(region, 0, scratchRectangle);
-
   return new TileBoundingRegion({
     rectangle: rectangleRegion,
     minimumHeight: region[4],
@@ -1793,26 +1804,117 @@ Cesium3DTile.prototype.createBoundingVolume = function (
 
   const { box, region, sphere } = boundingVolumeHeader;
   if (defined(box)) {
-    return createBox(box, transform, result);
+    const tileOrientedBoundingBox = createBox(box, transform, result);
+    if (this._verticalExaggeration !== 1.0) {
+      exaggerateBoundingBox(
+        tileOrientedBoundingBox,
+        this._verticalExaggeration,
+        this._verticalExaggerationRelativeHeight
+      );
+    }
+    return tileOrientedBoundingBox;
   }
   if (defined(region)) {
-    return createRegion(region, transform, this._initialTransform, result);
+    const tileBoundingVolume = createRegion(
+      region,
+      transform,
+      this._initialTransform,
+      result
+    );
+    if (this._verticalExaggeration === 1.0) {
+      return tileBoundingVolume;
+    }
+    if (tileBoundingVolume instanceof TileOrientedBoundingBox) {
+      exaggerateBoundingBox(
+        tileBoundingVolume,
+        this._verticalExaggeration,
+        this._verticalExaggerationRelativeHeight
+      );
+    } else {
+      tileBoundingVolume.minimumHeight = VerticalExaggeration.getHeight(
+        tileBoundingVolume.minimumHeight,
+        this._verticalExaggeration,
+        this._verticalExaggerationRelativeHeight
+      );
+      tileBoundingVolume.maximumHeight = VerticalExaggeration.getHeight(
+        tileBoundingVolume.maximumHeight,
+        this._verticalExaggeration,
+        this._verticalExaggerationRelativeHeight
+      );
+      tileBoundingVolume.computeBoundingVolumes(Ellipsoid.WGS84);
+    }
+    return tileBoundingVolume;
   }
   if (defined(sphere)) {
-    return createSphere(sphere, transform, result);
+    const tileBoundingSphere = createSphere(sphere, transform, result);
+    if (this._verticalExaggeration !== 1.0) {
+      const exaggeratedCenter = VerticalExaggeration.getPosition(
+        tileBoundingSphere.center,
+        Ellipsoid.WGS84,
+        this._verticalExaggeration,
+        this._verticalExaggerationRelativeHeight,
+        scratchCenter
+      );
+      const exaggeratedRadius =
+        tileBoundingSphere.radius * this._verticalExaggeration;
+      tileBoundingSphere.update(exaggeratedCenter, exaggeratedRadius);
+    }
+    return tileBoundingSphere;
   }
   throw new RuntimeError(
     "boundingVolume must contain a sphere, region, or box"
   );
 };
 
+const scratchExaggeratedCorners = Cartesian3.unpackArray(
+  new Array(8 * 3).fill(0)
+);
+
+/**
+ * Exaggerates the bounding box of a tile based on the provided exaggeration factors.
+ *
+ * @private
+ * @param {TileOrientedBoundingBox} tileOrientedBoundingBox - The oriented bounding box of the tile.
+ * @param {number} exaggeration - The exaggeration factor to apply to the tile's bounding box.
+ * @param {number} exaggerationRelativeHeight - The height relative to which exaggeration will be applied.
+ */
+function exaggerateBoundingBox(
+  tileOrientedBoundingBox,
+  exaggeration,
+  exaggerationRelativeHeight
+) {
+  const exaggeratedCorners = tileOrientedBoundingBox.boundingVolume
+    .computeCorners(scratchExaggeratedCorners)
+    .map((corner) =>
+      VerticalExaggeration.getPosition(
+        corner,
+        Ellipsoid.WGS84,
+        exaggeration,
+        exaggerationRelativeHeight,
+        corner
+      )
+    );
+  const exaggeratedBox = OrientedBoundingBox.fromPoints(
+    exaggeratedCorners,
+    scratchOrientedBoundingBox
+  );
+  tileOrientedBoundingBox.update(
+    exaggeratedBox.center,
+    exaggeratedBox.halfAxes
+  );
+}
+
 /**
  * Update the tile's transform. The transform is applied to the tile's bounding volumes.
  *
  * @private
  * @param {Matrix4} parentTransform
+ * @param {FrameState} [frameState]
  */
-Cesium3DTile.prototype.updateTransform = function (parentTransform) {
+Cesium3DTile.prototype.updateTransform = function (
+  parentTransform,
+  frameState
+) {
   parentTransform = defaultValue(parentTransform, Matrix4.IDENTITY);
   const computedTransform = Matrix4.multiplyTransformation(
     parentTransform,
@@ -1823,12 +1925,23 @@ Cesium3DTile.prototype.updateTransform = function (parentTransform) {
     computedTransform,
     this.computedTransform
   );
+  const exaggerationChanged =
+    defined(frameState) &&
+    (this._verticalExaggeration !== frameState.verticalExaggeration ||
+      this._verticalExaggerationRelativeHeight !==
+        frameState.verticalExaggerationRelativeHeight);
 
-  if (!transformChanged) {
+  if (!transformChanged && !exaggerationChanged) {
     return;
   }
-
-  Matrix4.clone(computedTransform, this.computedTransform);
+  if (transformChanged) {
+    Matrix4.clone(computedTransform, this.computedTransform);
+  }
+  if (exaggerationChanged) {
+    this._verticalExaggeration = frameState.verticalExaggeration;
+    this._verticalExaggerationRelativeHeight =
+      frameState.verticalExaggerationRelativeHeight;
+  }
 
   // Update the bounding volumes
   const header = this._header;

package/Source/Scene/Cesium3DTileContent.js

@@ -350,6 +350,20 @@ Cesium3DTileContent.prototype.update = function (tileset, frameState) {
   DeveloperError.throwInstantiationError();
 };
 
+/**
+ * Find an intersection between a ray and the tile content surface that was rendered. The ray must be given in world coordinates.
+ *
+ * @param {Ray} ray The ray to test for intersection.
+ * @param {FrameState} frameState The frame state.
+ * @param {Cartesian3|undefined} [result] The intersection or <code>undefined</code> if none was found.
+ * @returns {Cartesian3|undefined} The intersection or <code>undefined</code> if none was found.
+ *
+ * @private
+ */
+Cesium3DTileContent.prototype.pick = function (ray, frameState, result) {
+  DeveloperError.throwInstantiationError();
+};
+
 /**
  * Returns true if this object was destroyed; otherwise, false.
  * <br /><br />