@cesium/engine 6.2.0 → 7.0.0

package/Source/Core/GregorianDate.js

@@ -1,3 +1,10 @@
+import Check from "./Check.js";
+import defaultValue from "./defaultValue.js";
+import DeveloperError from "./DeveloperError.js";
+import isLeapYear from "./isLeapYear.js";
+
+const daysInYear = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+
 /**
  * Represents a Gregorian date in a more precise format than the JavaScript Date object.
  * In addition to submillisecond precision, this object can also represent leap seconds.
@@ -25,6 +32,27 @@ function GregorianDate(
   millisecond,
   isLeapSecond
 ) {
+  const minimumYear = 1;
+  const minimumMonth = 1;
+  const minimumDay = 1;
+  const minimumHour = 0;
+  const minimumMinute = 0;
+  const minimumSecond = 0;
+  const minimumMillisecond = 0;
+
+  year = defaultValue(year, minimumYear);
+  month = defaultValue(month, minimumMonth);
+  day = defaultValue(day, minimumDay);
+  hour = defaultValue(hour, minimumHour);
+  minute = defaultValue(minute, minimumMinute);
+  second = defaultValue(second, minimumSecond);
+  millisecond = defaultValue(millisecond, minimumMillisecond);
+  isLeapSecond = defaultValue(isLeapSecond, false);
+  //>>includeStart('debug', pragmas.debug);
+  validateRange();
+  validateDate();
+  //>>includeEnd('debug');
+
   /**
    * Gets or sets the year as a whole number.
    * @type {number}
@@ -65,5 +93,62 @@ function GregorianDate(
    * @type {boolean}
    */
   this.isLeapSecond = isLeapSecond;
+
+  function validateRange() {
+    const maximumYear = 9999;
+    const maximumMonth = 12;
+    const maximumDay = 31;
+    const maximumHour = 23;
+    const maximumMinute = 59;
+    const maximumSecond = 59;
+    const excludedMaximumMilisecond = 1000;
+
+    Check.typeOf.number.greaterThanOrEquals("Year", year, minimumYear);
+    Check.typeOf.number.lessThanOrEquals("Year", year, maximumYear);
+
+    Check.typeOf.number.greaterThanOrEquals("Month", month, minimumMonth);
+    Check.typeOf.number.lessThanOrEquals("Month", month, maximumMonth);
+
+    Check.typeOf.number.greaterThanOrEquals("Day", day, minimumDay);
+    Check.typeOf.number.lessThanOrEquals("Day", day, maximumDay);
+
+    Check.typeOf.number.greaterThanOrEquals("Hour", hour, minimumHour);
+    Check.typeOf.number.lessThanOrEquals("Hour", hour, maximumHour);
+
+    Check.typeOf.number.greaterThanOrEquals("Minute", minute, minimumMinute);
+    Check.typeOf.number.lessThanOrEquals("Minute", minute, maximumMinute);
+
+    Check.typeOf.bool("IsLeapSecond", isLeapSecond);
+
+    Check.typeOf.number.greaterThanOrEquals("Second", second, minimumSecond);
+    Check.typeOf.number.lessThanOrEquals(
+      "Second",
+      second,
+      isLeapSecond ? maximumSecond + 1 : maximumSecond
+    );
+
+    Check.typeOf.number.greaterThanOrEquals(
+      "Millisecond",
+      millisecond,
+      minimumMillisecond
+    );
+    Check.typeOf.number.lessThan(
+      "Millisecond",
+      millisecond,
+      excludedMaximumMilisecond
+    );
+  }
+
+  // Javascript date object supports only dates greater than 1901. Thus validating with custom logic
+  function validateDate() {
+    const daysInMonth =
+      month === 2 && isLeapYear(year)
+        ? daysInYear[month - 1] + 1
+        : daysInYear[month - 1];
+
+    if (day > daysInMonth) {
+      throw new DeveloperError("Month and Day represents invalid date");
+    }
+  }
 }
 export default GregorianDate;

package/Source/Core/HeadingPitchRange.js

@@ -3,7 +3,7 @@ import defined from "./defined.js";
 
 /**
  * Defines a heading angle, pitch angle, and range in a local frame.
- * Heading is the rotation from the local north direction where a positive angle is increasing eastward.
+ * Heading is the rotation from the local east direction where a positive angle is increasing southward.
  * Pitch is the rotation from the local xy-plane. Positive pitch angles are above the plane. Negative pitch
  * angles are below the plane. Range is the distance from the center of the frame.
  * @alias HeadingPitchRange
@@ -15,7 +15,7 @@ import defined from "./defined.js";
  */
 function HeadingPitchRange(heading, pitch, range) {
   /**
-   * Heading is the rotation from the local north direction where a positive angle is increasing eastward.
+   * Heading is the rotation from the local east direction where a positive angle is increasing southward.
    * @type {number}
    * @default 0.0
    */

package/Source/Core/Ion.js

@@ -4,7 +4,7 @@ import Resource from "./Resource.js";
 
 let defaultTokenCredit;
 const defaultAccessToken =
-  "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJqdGkiOiJkNzEwOTRhMi05YmYyLTQyY2EtYTU2My04YTM1MWE2YjhjNjAiLCJpZCI6MjU5LCJpYXQiOjE3MDQyMTcxMzh9.rE7KTaFyZydhuP1Z7ohzClO3J1tMOvaHODzt3_5jo7s";
+  "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJqdGkiOiJiOGQ5NjRhYy1lYzBmLTRjYjktODA5MC01M2FhYmE4YjliZTIiLCJpZCI6MjU5LCJpYXQiOjE3MDY4MDU1MTR9.3b1XUfaoUwtY0Mi87tOQUGTnU4oMyyzSwAYqkDENcHo";
 /**
  * Default settings for accessing the Cesium ion API.
  *

package/Source/Core/PolygonGeometry.js

@@ -8,10 +8,8 @@ import Check from "./Check.js";
 import ComponentDatatype from "./ComponentDatatype.js";
 import defaultValue from "./defaultValue.js";
 import defined from "./defined.js";
-import deprecationWarning from "./deprecationWarning.js";
 import DeveloperError from "./DeveloperError.js";
 import Ellipsoid from "./Ellipsoid.js";
-import EllipsoidGeodesic from "./EllipsoidGeodesic.js";
 import EllipsoidTangentPlane from "./EllipsoidTangentPlane.js";
 import Geometry from "./Geometry.js";
 import GeometryAttribute from "./GeometryAttribute.js";
@@ -425,123 +423,6 @@ function computeAttributes(options) {
   return geometry;
 }
 
-const startCartographicScratch = new Cartographic();
-const endCartographicScratch = new Cartographic();
-const idlCross = {
-  westOverIDL: 0.0,
-  eastOverIDL: 0.0,
-};
-let ellipsoidGeodesic = new EllipsoidGeodesic();
-function computeRectangle(positions, ellipsoid, arcType, granularity, result) {
-  result = defaultValue(result, new Rectangle());
-  if (!defined(positions) || positions.length < 3) {
-    result.west = 0.0;
-    result.north = 0.0;
-    result.south = 0.0;
-    result.east = 0.0;
-    return result;
-  }
-
-  if (arcType === ArcType.RHUMB) {
-    return Rectangle.fromCartesianArray(positions, ellipsoid, result);
-  }
-
-  if (!ellipsoidGeodesic.ellipsoid.equals(ellipsoid)) {
-    ellipsoidGeodesic = new EllipsoidGeodesic(undefined, undefined, ellipsoid);
-  }
-
-  result.west = Number.POSITIVE_INFINITY;
-  result.east = Number.NEGATIVE_INFINITY;
-  result.south = Number.POSITIVE_INFINITY;
-  result.north = Number.NEGATIVE_INFINITY;
-
-  idlCross.westOverIDL = Number.POSITIVE_INFINITY;
-  idlCross.eastOverIDL = Number.NEGATIVE_INFINITY;
-
-  const inverseChordLength =
-    1.0 / CesiumMath.chordLength(granularity, ellipsoid.maximumRadius);
-  const positionsLength = positions.length;
-  let endCartographic = ellipsoid.cartesianToCartographic(
-    positions[0],
-    endCartographicScratch
-  );
-  let startCartographic = startCartographicScratch;
-  let swap;
-
-  for (let i = 1; i < positionsLength; i++) {
-    swap = startCartographic;
-    startCartographic = endCartographic;
-    endCartographic = ellipsoid.cartesianToCartographic(positions[i], swap);
-    ellipsoidGeodesic.setEndPoints(startCartographic, endCartographic);
-    interpolateAndGrowRectangle(
-      ellipsoidGeodesic,
-      inverseChordLength,
-      result,
-      idlCross
-    );
-  }
-
-  swap = startCartographic;
-  startCartographic = endCartographic;
-  endCartographic = ellipsoid.cartesianToCartographic(positions[0], swap);
-  ellipsoidGeodesic.setEndPoints(startCartographic, endCartographic);
-  interpolateAndGrowRectangle(
-    ellipsoidGeodesic,
-    inverseChordLength,
-    result,
-    idlCross
-  );
-
-  if (result.east - result.west > idlCross.eastOverIDL - idlCross.westOverIDL) {
-    result.west = idlCross.westOverIDL;
-    result.east = idlCross.eastOverIDL;
-
-    if (result.east > CesiumMath.PI) {
-      result.east = result.east - CesiumMath.TWO_PI;
-    }
-    if (result.west > CesiumMath.PI) {
-      result.west = result.west - CesiumMath.TWO_PI;
-    }
-  }
-
-  return result;
-}
-
-const interpolatedCartographicScratch = new Cartographic();
-function interpolateAndGrowRectangle(
-  ellipsoidGeodesic,
-  inverseChordLength,
-  result,
-  idlCross
-) {
-  const segmentLength = ellipsoidGeodesic.surfaceDistance;
-
-  const numPoints = Math.ceil(segmentLength * inverseChordLength);
-  const subsegmentDistance =
-    numPoints > 0 ? segmentLength / (numPoints - 1) : Number.POSITIVE_INFINITY;
-  let interpolationDistance = 0.0;
-
-  for (let i = 0; i < numPoints; i++) {
-    const interpolatedCartographic = ellipsoidGeodesic.interpolateUsingSurfaceDistance(
-      interpolationDistance,
-      interpolatedCartographicScratch
-    );
-    interpolationDistance += subsegmentDistance;
-    const longitude = interpolatedCartographic.longitude;
-    const latitude = interpolatedCartographic.latitude;
-
-    result.west = Math.min(result.west, longitude);
-    result.east = Math.max(result.east, longitude);
-    result.south = Math.min(result.south, latitude);
-    result.north = Math.max(result.north, latitude);
-
-    const lonAdjusted =
-      longitude >= 0 ? longitude : longitude + CesiumMath.TWO_PI;
-    idlCross.westOverIDL = Math.min(idlCross.westOverIDL, lonAdjusted);
-    idlCross.eastOverIDL = Math.max(idlCross.eastOverIDL, lonAdjusted);
-  }
-}
-
 const createGeometryFromPositionsExtrudedPositions = [];
 
 function createGeometryFromPositionsExtruded(
@@ -1264,56 +1145,6 @@ PolygonGeometry.computeRectangleFromPositions = function (
   return result;
 };
 
-/**
- * Returns the bounding rectangle given the provided options
- *
- * @param {object} options Object with the following properties:
- * @param {PolygonHierarchy} options.polygonHierarchy A polygon hierarchy that can include holes.
- * @param {number} [options.granularity=CesiumMath.RADIANS_PER_DEGREE] The distance, in radians, between each latitude and longitude. Determines the number of positions sampled.
- * @param {ArcType} [options.arcType=ArcType.GEODESIC] The type of line the polygon edges must follow. Valid options are {@link ArcType.GEODESIC} and {@link ArcType.RHUMB}.
- * @param {Ellipsoid} [options.ellipsoid=Ellipsoid.WGS84] The ellipsoid to be used as a reference.
- * @param {Rectangle} [result] An object in which to store the result.
- *
- * @returns {Rectangle} The result rectangle
- *
- * @deprecated
- */
-PolygonGeometry.computeRectangle = function (options, result) {
-  //>>includeStart('debug', pragmas.debug);
-  Check.typeOf.object("options", options);
-  Check.typeOf.object("options.polygonHierarchy", options.polygonHierarchy);
-  //>>includeEnd('debug');
-
-  deprecationWarning(
-    "PolygonGeometry.computeRectangle",
-    "PolygonGeometry.computeRectangle was deprecated in CesiumJS 1.110.  It will be removed in CesiumJS 1.112. Use PolygonGeometry.computeRectangleFromPositions instead."
-  );
-
-  const granularity = defaultValue(
-    options.granularity,
-    CesiumMath.RADIANS_PER_DEGREE
-  );
-  const arcType = defaultValue(options.arcType, ArcType.GEODESIC);
-  //>>includeStart('debug', pragmas.debug);
-  if (arcType !== ArcType.GEODESIC && arcType !== ArcType.RHUMB) {
-    throw new DeveloperError(
-      "Invalid arcType. Valid options are ArcType.GEODESIC and ArcType.RHUMB."
-    );
-  }
-  //>>includeEnd('debug');
-
-  const polygonHierarchy = options.polygonHierarchy;
-  const ellipsoid = defaultValue(options.ellipsoid, Ellipsoid.WGS84);
-
-  return computeRectangle(
-    polygonHierarchy.positions,
-    ellipsoid,
-    arcType,
-    granularity,
-    result
-  );
-};
-
 const scratchPolarForPlane = new Stereographic();
 function getTangentPlane(rectangle, positions, ellipsoid) {
   if (rectangle.height >= CesiumMath.PI || rectangle.width >= CesiumMath.PI) {

package/Source/Core/Resource.js

@@ -2045,17 +2045,6 @@ Resource.createImageBitmapFromBlob = function (blob, options) {
   });
 };
 
-function decodeResponse(loadWithHttpResponse, responseType) {
-  switch (responseType) {
-    case "text":
-      return loadWithHttpResponse.toString("utf8");
-    case "json":
-      return JSON.parse(loadWithHttpResponse.toString("utf8"));
-    default:
-      return new Uint8Array(loadWithHttpResponse).buffer;
-  }
-}
-
 function loadWithHttpRequest(
   url,
   responseType,
@@ -2066,64 +2055,36 @@ function loadWithHttpRequest(
   overrideMimeType
 ) {
   // Note: only the 'json' and 'text' responseTypes transforms the loaded buffer
-  let URL;
-  let zlib;
-  Promise.all([import("url"), import("zlib")])
-    .then(([urlImport, zlibImport]) => {
-      URL = urlImport.parse(url);
-      zlib = zlibImport;
-
-      return URL.protocol === "https:" ? import("https") : import("http");
-    })
-    .then((http) => {
-      const options = {
-        protocol: URL.protocol,
-        hostname: URL.hostname,
-        port: URL.port,
-        path: URL.path,
-        query: URL.query,
-        method: method,
-        headers: headers,
-      };
-      http
-        .request(options)
-        .on("response", function (res) {
-          if (res.statusCode < 200 || res.statusCode >= 300) {
-            deferred.reject(
-              new RequestErrorEvent(res.statusCode, res, res.headers)
-            );
-            return;
-          }
-
-          const chunkArray = [];
-          res.on("data", function (chunk) {
-            chunkArray.push(chunk);
-          });
+  fetch(url, {
+    method,
+    headers,
+  })
+    .then(async (response) => {
+      if (!response.ok) {
+        const responseHeaders = {};
+        response.headers.forEach((value, key) => {
+          responseHeaders[key] = value;
+        });
+        deferred.reject(
+          new RequestErrorEvent(response.status, response, responseHeaders)
+        );
+        return;
+      }
 
-          res.on("end", function () {
-            // eslint-disable-next-line no-undef
-            const result = Buffer.concat(chunkArray);
-            if (res.headers["content-encoding"] === "gzip") {
-              zlib.gunzip(result, function (error, resultUnzipped) {
-                if (error) {
-                  deferred.reject(
-                    new RuntimeError("Error decompressing response.")
-                  );
-                } else {
-                  deferred.resolve(
-                    decodeResponse(resultUnzipped, responseType)
-                  );
-                }
-              });
-            } else {
-              deferred.resolve(decodeResponse(result, responseType));
-            }
-          });
-        })
-        .on("error", function (e) {
-          deferred.reject(new RequestErrorEvent());
-        })
-        .end();
+      switch (responseType) {
+        case "text":
+          deferred.resolve(response.text());
+          break;
+        case "json":
+          deferred.resolve(response.json());
+          break;
+        default:
+          deferred.resolve(new Uint8Array(await response.arrayBuffer()).buffer);
+          break;
+      }
+    })
+    .catch(() => {
+      deferred.reject(new RequestErrorEvent());
     });
 }
 
@@ -2226,7 +2187,7 @@ Resource._Implementations.loadWithXhr = function (
     //or do not support the xhr.response property.
     if (xhr.status === 204) {
       // accept no content
-      deferred.resolve();
+      deferred.resolve(undefined);
     } else if (
       defined(response) &&
       (!defined(responseType) || browserResponseType === responseType)

package/Source/Core/Transforms.js

@@ -360,7 +360,7 @@ const scratchHPRMatrix4 = new Matrix4();
 
 /**
  * Computes a 4x4 transformation matrix from a reference frame with axes computed from the heading-pitch-roll angles
- * centered at the provided origin to the provided ellipsoid's fixed reference frame. Heading is the rotation from the local north
+ * centered at the provided origin to the provided ellipsoid's fixed reference frame. Heading is the rotation from the local east
  * direction where a positive angle is increasing eastward. Pitch is the rotation from the local east-north plane. Positive pitch angles
  * are above the plane. Negative pitch angles are below the plane. Roll is the first rotation applied about the local east axis.
  *
@@ -415,7 +415,7 @@ const scratchHPRMatrix3 = new Matrix3();
 
 /**
  * Computes a quaternion from a reference frame with axes computed from the heading-pitch-roll angles
- * centered at the provided origin. Heading is the rotation from the local north
+ * centered at the provided origin. Heading is the rotation from the local east
  * direction where a positive angle is increasing eastward. Pitch is the rotation from the local east-north plane. Positive pitch angles
  * are above the plane. Negative pitch angles are below the plane. Roll is the first rotation applied about the local east axis.
  *
@@ -465,7 +465,7 @@ const hprTransformScratch = new Matrix4();
 const hprRotationScratch = new Matrix3();
 const hprQuaternionScratch = new Quaternion();
 /**
- * Computes heading-pitch-roll angles from a transform in a particular reference frame. Heading is the rotation from the local north
+ * Computes heading-pitch-roll angles from a transform in a particular reference frame. Heading is the rotation from the local east
  * direction where a positive angle is increasing eastward. Pitch is the rotation from the local east-north plane. Positive pitch angles
  * are above the plane. Negative pitch angles are below the plane. Roll is the first rotation applied about the local east axis.
  *
@@ -1045,21 +1045,30 @@ Transforms.basisTo2D = function (projection, matrix, result) {
   const rtcCenter = Matrix4.getTranslation(matrix, scratchCenter);
   const ellipsoid = projection.ellipsoid;
 
-  // Get the 2D Center
-  const cartographic = ellipsoid.cartesianToCartographic(
-    rtcCenter,
-    scratchCartographic
-  );
-  const projectedPosition = projection.project(
-    cartographic,
-    scratchCartesian3Projection
-  );
-  Cartesian3.fromElements(
-    projectedPosition.z,
-    projectedPosition.x,
-    projectedPosition.y,
-    projectedPosition
-  );
+  let projectedPosition;
+  if (Cartesian3.equals(rtcCenter, Cartesian3.ZERO)) {
+    projectedPosition = Cartesian3.clone(
+      Cartesian3.ZERO,
+      scratchCartesian3Projection
+    );
+  } else {
+    // Get the 2D Center
+    const cartographic = ellipsoid.cartesianToCartographic(
+      rtcCenter,
+      scratchCartographic
+    );
+
+    projectedPosition = projection.project(
+      cartographic,
+      scratchCartesian3Projection
+    );
+    Cartesian3.fromElements(
+      projectedPosition.z,
+      projectedPosition.x,
+      projectedPosition.y,
+      projectedPosition
+    );
+  }
 
   // Assuming the instance are positioned in WGS84, invert the WGS84 transform to get the local transform and then convert to 2D
   const fromENU = Transforms.eastNorthUpToFixedFrame(

package/Source/Core/createWorldBathymetryAsync.js

@@ -0,0 +1,45 @@
+import CesiumTerrainProvider from "./CesiumTerrainProvider.js";
+import defaultValue from "./defaultValue.js";
+
+/**
+ * Creates a {@link CesiumTerrainProvider} instance for the {@link https://cesium.com/content/#cesium-world-bathymetry|Cesium World Bathymetry}.
+ *
+ * @function
+ *
+ * @param {Object} [options] Object with the following properties:
+ * @param {Boolean} [options.requestVertexNormals=false] Flag that indicates if the client should request additional lighting information from the server if available.
+ * @returns {Promise<CesiumTerrainProvider>} A promise that resolves to the created CesiumTerrainProvider
+ *
+ * @see Ion
+ *
+ * @example
+ * // Create Cesium World Bathymetry with default settings
+ * try {
+ *   const viewer = new Cesium.Viewer("cesiumContainer", {
+ *     terrainProvider: await Cesium.createWorldBathymetryAsync();
+ *   });
+ * } catch (error) {
+ *   console.log(error);
+ * }
+ *
+ * @example
+ * // Create Cesium World Bathymetry with normals.
+ * try {
+ *   const viewer1 = new Cesium.Viewer("cesiumContainer", {
+ *     terrainProvider: await Cesium.createWorldBathymetryAsync({
+ *       requestVertexNormals: true
+ *     });
+ *   });
+ * } catch (error) {
+ *   console.log(error);
+ * }
+ *
+ */
+function createWorldBathymetryAsync(options) {
+  options = defaultValue(options, defaultValue.EMPTY_OBJECT);
+
+  return CesiumTerrainProvider.fromIonAssetId(2426648, {
+    requestVertexNormals: defaultValue(options.requestVertexNormals, false),
+  });
+}
+export default createWorldBathymetryAsync;

package/Source/DataSources/EllipsoidGeometryUpdater.js

@@ -547,11 +547,10 @@ DynamicEllipsoidGeometryUpdater.prototype.update = function (time) {
     options.radii = Cartesian3.clone(in3D ? unitSphere : radii, options.radii);
     if (defined(innerRadii)) {
       if (in3D) {
-        const mag = Cartesian3.magnitude(radii);
         options.innerRadii = Cartesian3.fromElements(
-          innerRadii.x / mag,
-          innerRadii.y / mag,
-          innerRadii.z / mag,
+          innerRadii.x / radii.x,
+          innerRadii.y / radii.y,
+          innerRadii.z / radii.z,
           options.innerRadii
         );
       } else {

package/Source/DataSources/Entity.js

@@ -13,7 +13,9 @@ import Quaternion from "../Core/Quaternion.js";
 import Transforms from "../Core/Transforms.js";
 import GroundPolylinePrimitive from "../Scene/GroundPolylinePrimitive.js";
 import GroundPrimitive from "../Scene/GroundPrimitive.js";
-import HeightReference from "../Scene/HeightReference.js";
+import HeightReference, {
+  isHeightReferenceClamp,
+} from "../Scene/HeightReference.js";
 import BillboardGraphics from "./BillboardGraphics.js";
 import BoxGraphics from "./BoxGraphics.js";
 import ConstantPositionProperty from "./ConstantPositionProperty.js";
@@ -71,8 +73,8 @@ function createPropertyTypeDescriptor(name, Type) {
  * @property {boolean} [show] A boolean value indicating if the entity and its children are displayed.
  * @property {Property | string} [description] A string Property specifying an HTML description for this entity.
  * @property {PositionProperty | Cartesian3} [position] A Property specifying the entity position.
- * @property {Property} [orientation] A Property specifying the entity orientation.
- * @property {Property} [viewFrom] A suggested initial offset for viewing this object.
+ * @property {Property | Quaternion} [orientation=Transforms.eastNorthUpToFixedFrame(position)] A Property specifying the entity orientation in respect to Earth-fixed-Earth-centered (ECEF). If undefined, east-north-up at entity position is used.
+ * @property {Property | Cartesian3} [viewFrom] A suggested initial offset for viewing this object.
  * @property {Entity} [parent] A parent entity to associate with this entity.
  * @property {BillboardGraphics | BillboardGraphics.ConstructorOptions} [billboard] A billboard to associate with this entity.
  * @property {BoxGraphics | BoxGraphics.ConstructorOptions} [box] A box to associate with this entity.
@@ -413,7 +415,8 @@ Object.defineProperties(Entity.prototype, {
    */
   tileset: createPropertyTypeDescriptor("tileset", Cesium3DTilesetGraphics),
   /**
-   * Gets or sets the orientation.
+   * Gets or sets the orientation in respect to Earth-fixed-Earth-centered (ECEF).
+   * Defaults to east-north-up at entity position.
    * @memberof Entity.prototype
    * @type {Property|undefined}
    */
@@ -706,7 +709,7 @@ Entity.prototype.computeModelMatrixForHeightReference = function (
   }
 
   const carto = ellipsoid.cartesianToCartographic(position, cartoScratch);
-  if (heightReference === HeightReference.CLAMP_TO_GROUND) {
+  if (isHeightReferenceClamp(heightReference)) {
     carto.height = heightOffset;
   } else {
     carto.height += heightOffset;

package/Source/DataSources/EntityCollection.js

@@ -5,7 +5,6 @@ import DeveloperError from "../Core/DeveloperError.js";
 import Event from "../Core/Event.js";
 import Iso8601 from "../Core/Iso8601.js";
 import JulianDate from "../Core/JulianDate.js";
-import RuntimeError from "../Core/RuntimeError.js";
 import TimeInterval from "../Core/TimeInterval.js";
 import Entity from "./Entity.js";
 
@@ -281,7 +280,7 @@ EntityCollection.prototype.add = function (entity) {
   const id = entity.id;
   const entities = this._entities;
   if (entities.contains(id)) {
-    throw new RuntimeError(
+    throw new DeveloperError(
       `An entity with id ${id} already exists in this collection.`
     );
   }

package/Source/DataSources/GeometryUpdater.js

@@ -233,8 +233,7 @@ Object.defineProperties(GeometryUpdater.prototype, {
   },
   /**
    * Gets a value indicating if the geometry is time-varying.
-   * If true, all visualization is delegated to a DynamicGeometryUpdater
-   * returned by GeometryUpdater#createDynamicUpdater.
+   *
    * @memberof GeometryUpdater.prototype
    *
    * @type {boolean}

package/Source/DataSources/GroundGeometryUpdater.js

@@ -5,7 +5,9 @@ import DeveloperError from "../Core/DeveloperError.js";
 import GeometryOffsetAttribute from "../Core/GeometryOffsetAttribute.js";
 import oneTimeWarning from "../Core/oneTimeWarning.js";
 import GroundPrimitive from "../Scene/GroundPrimitive.js";
-import HeightReference from "../Scene/HeightReference.js";
+import HeightReference, {
+  isHeightReferenceClamp,
+} from "../Scene/HeightReference.js";
 import CallbackProperty from "./CallbackProperty.js";
 import ConstantProperty from "./ConstantProperty.js";
 import GeometryUpdater from "./GeometryUpdater.js";
@@ -164,9 +166,10 @@ GroundGeometryUpdater.getGeometryHeight = function (height, heightReference) {
     return;
   }
 
-  if (heightReference !== HeightReference.CLAMP_TO_GROUND) {
+  if (!isHeightReferenceClamp(heightReference)) {
     return height;
   }
+
   return 0.0;
 };
 
@@ -186,7 +189,7 @@ GroundGeometryUpdater.getGeometryExtrudedHeight = function (
     }
     return;
   }
-  if (extrudedHeightReference !== HeightReference.CLAMP_TO_GROUND) {
+  if (!isHeightReferenceClamp(extrudedHeightReference)) {
     return extrudedHeight;
   }