@cesium/engine 9.1.0 → 10.0.0

package/Source/Scene/Scene.js

@@ -13,6 +13,7 @@ import defaultValue from "../Core/defaultValue.js";
 import defined from "../Core/defined.js";
 import destroyObject from "../Core/destroyObject.js";
 import DeveloperError from "../Core/DeveloperError.js";
+import Ellipsoid from "../Core/Ellipsoid.js";
 import EllipsoidGeometry from "../Core/EllipsoidGeometry.js";
 import Event from "../Core/Event.js";
 import GeographicProjection from "../Core/GeographicProjection.js";
@@ -29,6 +30,7 @@ import OrthographicFrustum from "../Core/OrthographicFrustum.js";
 import OrthographicOffCenterFrustum from "../Core/OrthographicOffCenterFrustum.js";
 import PerspectiveFrustum from "../Core/PerspectiveFrustum.js";
 import PerspectiveOffCenterFrustum from "../Core/PerspectiveOffCenterFrustum.js";
+import Rectangle from "../Core/Rectangle.js";
 import RequestScheduler from "../Core/RequestScheduler.js";
 import TaskProcessor from "../Core/TaskProcessor.js";
 import Transforms from "../Core/Transforms.js";
@@ -96,7 +98,8 @@ const requestRenderAfterFrame = function (scene) {
  * @param {ContextOptions} [options.contextOptions] Context and WebGL creation properties.
  * @param {Element} [options.creditContainer] The HTML element in which the credits will be displayed.
  * @param {Element} [options.creditViewport] The HTML element in which to display the credit popup.  If not specified, the viewport will be a added as a sibling of the canvas.
- * @param {MapProjection} [options.mapProjection=new GeographicProjection()] The map projection to use in 2D and Columbus View modes.
+ * @param {Ellipsoid} [options.ellipsoid=Ellipsoid.default] The default ellipsoid. If not specified, the default ellipsoid is used.
+ * @param {MapProjection} [options.mapProjection=new GeographicProjection(options.ellipsoid)] The map projection to use in 2D and Columbus View modes.
  * @param {boolean} [options.orderIndependentTranslucency=true] If true and the configuration supports it, use order independent translucency.
  * @param {boolean} [options.scene3DOnly=false] If true, optimizes memory use and performance for 3D mode but disables the ability to use 2D or Columbus View.
  * @param {boolean} [options.shadows=false] Determines if shadows are cast by light sources.
@@ -153,7 +156,7 @@ function Scene(options) {
   this._jobScheduler = new JobScheduler();
   this._frameState = new FrameState(
     context,
-    new CreditDisplay(creditContainer, " • ", creditViewport),
+    new CreditDisplay(creditContainer, "•", creditViewport),
     this._jobScheduler
   );
   this._frameState.scene3DOnly = defaultValue(options.scene3DOnly, false);
@@ -163,6 +166,8 @@ function Scene(options) {
   this._canvas = canvas;
   this._context = context;
   this._computeEngine = new ComputeEngine(context);
+
+  this._ellipsoid = defaultValue(options.ellipsoid, Ellipsoid.default);
   this._globe = undefined;
   this._globeTranslucencyState = new GlobeTranslucencyState();
   this._primitives = new PrimitiveCollection();
@@ -316,7 +321,7 @@ function Scene(options) {
 
   this._mapProjection = defined(options.mapProjection)
     ? options.mapProjection
-    : new GeographicProjection();
+    : new GeographicProjection(this._ellipsoid);
 
   /**
    * The current morph transition time between 2D/Columbus View and 3D,
@@ -530,9 +535,21 @@ function Scene(options) {
   /**
    * Blends the atmosphere to geometry far from the camera for horizon views. Allows for additional
    * performance improvements by rendering less geometry and dispatching less terrain requests.
+   *
+   * Disbaled by default if an ellipsoid other than WGS84 is used.
    * @type {Fog}
    */
   this.fog = new Fog();
+  this.fog.enabled = Ellipsoid.WGS84.equals(this._ellipsoid);
+
+  if (!Ellipsoid.WGS84.equals(this._ellipsoid)) {
+    Camera.DEFAULT_VIEW_RECTANGLE = Rectangle.fromDegrees(
+      -45.0,
+      -45.0,
+      45.0,
+      45.0
+    );
+  }
 
   this._shadowMapCamera = new Camera(this);
 
@@ -914,6 +931,19 @@ Object.defineProperties(Scene.prototype, {
     },
   },
 
+  /**
+   * The ellipsoid.  If not specified, the default ellipsoid is used.
+   * @memberof Scene.prototype
+   *
+   * @type {Ellipsoid}
+   * @readonly
+   */
+  ellipsoid: {
+    get: function () {
+      return this._ellipsoid;
+    },
+  },
+
   /**
    * Gets or sets the depth-test ellipsoid.
    * @memberof Scene.prototype
@@ -1853,7 +1883,7 @@ function getOccluder(scene) {
     !scene._cameraUnderground &&
     !scene._globeTranslucencyState.translucent
   ) {
-    const ellipsoid = globe.ellipsoid;
+    const ellipsoid = scene.ellipsoid;
     const minimumTerrainHeight = scene.frameState.minimumTerrainHeight;
     scratchOccluderBoundingSphere.radius =
       ellipsoid.minimumRadius + minimumTerrainHeight;
@@ -3745,7 +3775,7 @@ Scene.prototype.updateHeight = function (
   }
 
   let tilesetRemoveCallbacks = {};
-  const ellipsoid = this.globe?.ellipsoid;
+  const ellipsoid = this._ellipsoid;
   const createPrimitiveEventListener = (primitive) => {
     if (
       ignore3dTiles ||
@@ -4607,7 +4637,6 @@ Scene.prototype.clampToHeightMostDetailed = function (
  * @example
  * // Output the canvas position of longitude/latitude (0, 0) every time the mouse moves.
  * const scene = widget.scene;
- * const ellipsoid = scene.globe.ellipsoid;
  * const position = Cesium.Cartesian3.fromDegrees(0.0, 0.0);
  * const handler = new Cesium.ScreenSpaceEventHandler(scene.canvas);
  * handler.setInputAction(function(movement) {
@@ -4615,7 +4644,7 @@ Scene.prototype.clampToHeightMostDetailed = function (
  * }, Cesium.ScreenSpaceEventType.MOUSE_MOVE);
  */
 Scene.prototype.cartesianToCanvasCoordinates = function (position, result) {
-  return SceneTransforms.wgs84ToWindowCoordinates(this, position, result);
+  return SceneTransforms.worldToWindowCoordinates(this, position, result);
 };
 
 /**
@@ -4630,15 +4659,8 @@ Scene.prototype.completeMorph = function () {
  * @param {number} [duration=2.0] The amount of time, in seconds, for transition animations to complete.
  */
 Scene.prototype.morphTo2D = function (duration) {
-  let ellipsoid;
-  const globe = this.globe;
-  if (defined(globe)) {
-    ellipsoid = globe.ellipsoid;
-  } else {
-    ellipsoid = this.mapProjection.ellipsoid;
-  }
   duration = defaultValue(duration, 2.0);
-  this._transitioner.morphTo2D(duration, ellipsoid);
+  this._transitioner.morphTo2D(duration, this._ellipsoid);
 };
 
 /**
@@ -4646,15 +4668,8 @@ Scene.prototype.morphTo2D = function (duration) {
  * @param {number} [duration=2.0] The amount of time, in seconds, for transition animations to complete.
  */
 Scene.prototype.morphToColumbusView = function (duration) {
-  let ellipsoid;
-  const globe = this.globe;
-  if (defined(globe)) {
-    ellipsoid = globe.ellipsoid;
-  } else {
-    ellipsoid = this.mapProjection.ellipsoid;
-  }
   duration = defaultValue(duration, 2.0);
-  this._transitioner.morphToColumbusView(duration, ellipsoid);
+  this._transitioner.morphToColumbusView(duration, this._ellipsoid);
 };
 
 /**
@@ -4662,15 +4677,8 @@ Scene.prototype.morphToColumbusView = function (duration) {
  * @param {number} [duration=2.0] The amount of time, in seconds, for transition animations to complete.
  */
 Scene.prototype.morphTo3D = function (duration) {
-  let ellipsoid;
-  const globe = this.globe;
-  if (defined(globe)) {
-    ellipsoid = globe.ellipsoid;
-  } else {
-    ellipsoid = this.mapProjection.ellipsoid;
-  }
   duration = defaultValue(duration, 2.0);
-  this._transitioner.morphTo3D(duration, ellipsoid);
+  this._transitioner.morphTo3D(duration, this._ellipsoid);
 };
 
 function setTerrain(scene, terrain) {

package/Source/Scene/SceneTransforms.js

@@ -4,6 +4,7 @@ import Cartesian3 from "../Core/Cartesian3.js";
 import Cartesian4 from "../Core/Cartesian4.js";
 import Cartographic from "../Core/Cartographic.js";
 import defined from "../Core/defined.js";
+import deprecationWarning from "../Core/deprecationWarning.js";
 import DeveloperError from "../Core/DeveloperError.js";
 import CesiumMath from "../Core/Math.js";
 import Matrix4 from "../Core/Matrix4.js";
@@ -26,6 +27,32 @@ const scratchViewport = new BoundingRectangle();
 const scratchWindowCoord0 = new Cartesian2();
 const scratchWindowCoord1 = new Cartesian2();
 
+/**
+ * Transforms a position in world (WGS84 or alternative ellipsoid) coordinates to window coordinates.  This is commonly used to place an
+ * HTML element at the same screen position as an object in the scene.
+ *
+ * @param {Scene} scene The scene.
+ * @param {Cartesian3} position The position in world (WGS84 or alternative ellipsoid) coordinates.
+ * @param {Cartesian2} [result] An optional object to return the input position transformed to window coordinates.
+ * @returns {Cartesian2|undefined} The modified result parameter or a new Cartesian2 instance if one was not provided.  This may be <code>undefined</code> if the input position is near the center of the ellipsoid.
+ *
+ * @example
+ * // Output the window position of longitude/latitude (0, 0) every time the mouse moves.
+ * const position = Cesium.Cartesian3.fromDegrees(0.0, 0.0);
+ * const handler = new Cesium.ScreenSpaceEventHandler(scene.canvas);
+ * handler.setInputAction(function(movement) {
+ *     console.log(Cesium.SceneTransforms.worldToWindowCoordinates(scene, position));
+ * }, Cesium.ScreenSpaceEventType.MOUSE_MOVE);
+ */
+SceneTransforms.worldToWindowCoordinates = function (scene, position, result) {
+  return SceneTransforms.worldWithEyeOffsetToWindowCoordinates(
+    scene,
+    position,
+    Cartesian3.ZERO,
+    result
+  );
+};
+
 /**
  * Transforms a position in WGS84 coordinates to window coordinates.  This is commonly used to place an
  * HTML element at the same screen position as an object in the scene.
@@ -33,12 +60,12 @@ const scratchWindowCoord1 = new Cartesian2();
  * @param {Scene} scene The scene.
  * @param {Cartesian3} position The position in WGS84 (world) coordinates.
  * @param {Cartesian2} [result] An optional object to return the input position transformed to window coordinates.
- * @returns {Cartesian2} The modified result parameter or a new Cartesian2 instance if one was not provided.  This may be <code>undefined</code> if the input position is near the center of the ellipsoid.
+ * @returns {Cartesian2|undefined} The modified result parameter or a new Cartesian2 instance if one was not provided.  This may be <code>undefined</code> if the input position is near the center of the ellipsoid.
  *
  * @example
  * // Output the window position of longitude/latitude (0, 0) every time the mouse moves.
  * const scene = widget.scene;
- * const ellipsoid = scene.globe.ellipsoid;
+ * const ellipsoid = scene.ellipsoid;
  * const position = Cesium.Cartesian3.fromDegrees(0.0, 0.0);
  * const handler = new Cesium.ScreenSpaceEventHandler(scene.canvas);
  * handler.setInputAction(function(movement) {
@@ -46,12 +73,11 @@ const scratchWindowCoord1 = new Cartesian2();
  * }, Cesium.ScreenSpaceEventType.MOUSE_MOVE);
  */
 SceneTransforms.wgs84ToWindowCoordinates = function (scene, position, result) {
-  return SceneTransforms.wgs84WithEyeOffsetToWindowCoordinates(
-    scene,
-    position,
-    Cartesian3.ZERO,
-    result
+  deprecationWarning(
+    "SceneTransforms.wgs84ToWindowCoordinates",
+    "SceneTransforms.wgs84ToWindowCoordinates has been deprecated. It will be removed in 1.21. Use SceneTransforms.worldToWindowCoordinates instead."
   );
+  return SceneTransforms.worldToWindowCoordinates(scene, position, result);
 };
 
 const scratchCartesian4 = new Cartesian4();
@@ -98,7 +124,7 @@ const scratchCameraPosition = new Cartesian3();
 /**
  * @private
  */
-SceneTransforms.wgs84WithEyeOffsetToWindowCoordinates = function (
+SceneTransforms.worldWithEyeOffsetToWindowCoordinates = function (
   scene,
   position,
   eyeOffset,
@@ -115,7 +141,7 @@ SceneTransforms.wgs84WithEyeOffsetToWindowCoordinates = function (
 
   // Transform for 3D, 2D, or Columbus view
   const frameState = scene.frameState;
-  const actualPosition = SceneTransforms.computeActualWgs84Position(
+  const actualPosition = SceneTransforms.computeActualEllipsoidPosition(
     frameState,
     position,
     actualPositionScratch
@@ -265,30 +291,28 @@ SceneTransforms.wgs84WithEyeOffsetToWindowCoordinates = function (
 };
 
 /**
- * Transforms a position in WGS84 coordinates to drawing buffer coordinates.  This may produce different
- * results from SceneTransforms.wgs84ToWindowCoordinates when the browser zoom is not 100%, or on high-DPI displays.
+ * Transforms a position in world coordinates to drawing buffer coordinates.  This may produce different
+ * results from SceneTransforms.worldToWindowCoordinates when the browser zoom is not 100%, or on high-DPI displays.
  *
  * @param {Scene} scene The scene.
- * @param {Cartesian3} position The position in WGS84 (world) coordinates.
+ * @param {Cartesian3} position The position in world (WGS84 or alternative ellipsoid) coordinates.
  * @param {Cartesian2} [result] An optional object to return the input position transformed to window coordinates.
- * @returns {Cartesian2} The modified result parameter or a new Cartesian2 instance if one was not provided.  This may be <code>undefined</code> if the input position is near the center of the ellipsoid.
+ * @returns {Cartesian2|undefined} The modified result parameter or a new Cartesian2 instance if one was not provided.  This may be <code>undefined</code> if the input position is near the center of the ellipsoid.
  *
  * @example
  * // Output the window position of longitude/latitude (0, 0) every time the mouse moves.
- * const scene = widget.scene;
- * const ellipsoid = scene.globe.ellipsoid;
  * const position = Cesium.Cartesian3.fromDegrees(0.0, 0.0);
  * const handler = new Cesium.ScreenSpaceEventHandler(scene.canvas);
  * handler.setInputAction(function(movement) {
- *     console.log(Cesium.SceneTransforms.wgs84ToWindowCoordinates(scene, position));
+ *     console.log(Cesium.SceneTransforms.worldToDrawingBufferCoordinates(scene, position));
  * }, Cesium.ScreenSpaceEventType.MOUSE_MOVE);
  */
-SceneTransforms.wgs84ToDrawingBufferCoordinates = function (
+SceneTransforms.worldToDrawingBufferCoordinates = function (
   scene,
   position,
   result
 ) {
-  result = SceneTransforms.wgs84ToWindowCoordinates(scene, position, result);
+  result = SceneTransforms.worldToWindowCoordinates(scene, position, result);
   if (!defined(result)) {
     return undefined;
   }
@@ -296,13 +320,47 @@ SceneTransforms.wgs84ToDrawingBufferCoordinates = function (
   return SceneTransforms.transformWindowToDrawingBuffer(scene, result, result);
 };
 
+/**
+ * Transforms a position in world coordinates to drawing buffer coordinates.  This may produce different
+ * results from SceneTransforms.wgs84ToWindowCoordinates when the browser zoom is not 100%, or on high-DPI displays.
+ *
+ * @param {Scene} scene The scene.
+ * @param {Cartesian3} position The position in world (WGS84 or alternative ellipsoid) coordinates.
+ * @param {Cartesian2} [result] An optional object to return the input position transformed to window coordinates.
+ * @returns {Cartesian2|undefined} The modified result parameter or a new Cartesian2 instance if one was not provided.  This may be <code>undefined</code> if the input position is near the center of the ellipsoid.
+ *
+ * @example
+ * // Output the window position of longitude/latitude (0, 0) every time the mouse moves.
+ * const position = Cesium.Cartesian3.fromDegrees(0.0, 0.0);
+ * const handler = new Cesium.ScreenSpaceEventHandler(scene.canvas);
+ * handler.setInputAction(function(movement) {
+ *     console.log(Cesium.SceneTransforms.wgs84ToWindowCoordinates(scene, position));
+ * }, Cesium.ScreenSpaceEventType.MOUSE_MOVE);
+ */
+SceneTransforms.wgs84ToDrawingBufferCoordinates = function (
+  scene,
+  position,
+  result
+) {
+  deprecationWarning(
+    "SceneTransforms.wgs84ToDrawingBufferCoordinates",
+    "SceneTransforms.wgs84ToDrawingBufferCoordinates has been deprecated. It will be removed in 1.21. Use SceneTransforms.worldToDrawingBufferCoordinates instead."
+  );
+
+  return SceneTransforms.worldToDrawingBufferCoordinates(
+    scene,
+    position,
+    result
+  );
+};
+
 const projectedPosition = new Cartesian3();
 const positionInCartographic = new Cartographic();
 
 /**
  * @private
  */
-SceneTransforms.computeActualWgs84Position = function (
+SceneTransforms.computeActualEllipsoidPosition = function (
   frameState,
   position,
   result
@@ -398,7 +456,7 @@ const scratchWorldCoords = new Cartesian4();
 /**
  * @private
  */
-SceneTransforms.drawingBufferToWgs84Coordinates = function (
+SceneTransforms.drawingBufferToWorldCoordinates = function (
   scene,
   drawingBufferPosition,
   depth,

package/Source/Scene/SceneTransitioner.js

@@ -627,7 +627,7 @@ function morphFromColumbusViewTo2D(transitioner, duration) {
 
   if (duration > 0.0) {
     Cartesian3.clone(Cartesian3.ZERO, scratchCVTo2DEndPos);
-    endPos.z = 5.0 * scene.mapProjection.ellipsoid.maximumRadius;
+    endPos.z = 5.0 * scene.ellipsoid.maximumRadius;
   } else {
     Cartesian3.clone(startPos, scratchCVTo2DEndPos);
 
@@ -1050,7 +1050,7 @@ function complete2DCallback(camera2D) {
 
     const camera = scene.camera;
     Cartesian3.clone(camera2D.position, camera.position);
-    camera.position.z = scene.mapProjection.ellipsoid.maximumRadius * 2.0;
+    camera.position.z = scene.ellipsoid.maximumRadius * 2.0;
     Cartesian3.clone(camera2D.direction, camera.direction);
     Cartesian3.clone(camera2D.up, camera.up);
     Cartesian3.cross(camera.direction, camera.up, camera.right);

package/Source/Scene/ScreenSpaceCameraController.js

@@ -216,33 +216,46 @@ function ScreenSpaceCameraController(scene) {
     eventType: CameraEventType.LEFT_DRAG,
     modifier: KeyboardEventModifier.SHIFT,
   };
+
+  const ellipsoid = defaultValue(scene.ellipsoid, Ellipsoid.default);
+
   /**
-   * The minimum height the camera must be before picking the terrain or scene content instead of the ellipsoid.
+   * The minimum height the camera must be before picking the terrain or scene content instead of the ellipsoid. Defaults to scene.ellipsoid.minimumRadius * 0.025 when another ellipsoid than WGS84 is used.
    * @type {number}
-   * @default 150000.0
+   * @default 150000.0 or scene.ellipsoid.minimumRadius * 0.025
    */
-  this.minimumPickingTerrainHeight = 150000.0;
+  this.minimumPickingTerrainHeight = Ellipsoid.WGS84.equals(ellipsoid)
+    ? 150000.0
+    : ellipsoid.minimumRadius * 0.025;
   this._minimumPickingTerrainHeight = this.minimumPickingTerrainHeight;
   /**
-   * The minimum distance the camera must be before testing for collision with terrain when zoom with inertia.
+   * The minimum distance the camera must be before testing for collision with terrain when zoom with inertia. Default to scene.ellipsoid.minimumRadius * 0.00063 when another ellipsoid than WGS84 is used.
    * @type {number}
-   * @default 4000.0
+   * @default 4000.0 or scene.ellipsoid.minimumRadius * 0.00063
    */
-  this.minimumPickingTerrainDistanceWithInertia = 4000.0;
+  this.minimumPickingTerrainDistanceWithInertia = Ellipsoid.WGS84.equals(
+    ellipsoid
+  )
+    ? 4000.0
+    : ellipsoid.minimumRadius * 0.00063;
   /**
-   * The minimum height the camera must be before testing for collision with terrain.
+   * The minimum height the camera must be before testing for collision with terrain. Default to scene.ellipsoid.minimumRadius * 0.0025 when another ellipsoid than WGS84 is used.
    * @type {number}
-   * @default 15000.0
+   * @default 15000.0 or scene.ellipsoid.minimumRadius * 0.0025.
    */
-  this.minimumCollisionTerrainHeight = 15000.0;
+  this.minimumCollisionTerrainHeight = Ellipsoid.WGS84.equals(ellipsoid)
+    ? 15000.0
+    : ellipsoid.minimumRadius * 0.0025;
   this._minimumCollisionTerrainHeight = this.minimumCollisionTerrainHeight;
   /**
    * The minimum height the camera must be before switching from rotating a track ball to
-   * free look when clicks originate on the sky or in space.
+   * free look when clicks originate on the sky or in space. Defaults to ellipsoid.minimumRadius * 1.175 when another ellipsoid than WGS84 is used.
    * @type {number}
-   * @default 7500000.0
+   * @default 7500000.0 or scene.ellipsoid.minimumRadius * 1.175
    */
-  this.minimumTrackBallHeight = 7500000.0;
+  this.minimumTrackBallHeight = Ellipsoid.WGS84.equals(ellipsoid)
+    ? 7500000.0
+    : ellipsoid.minimumRadius * 1.175;
   this._minimumTrackBallHeight = this.minimumTrackBallHeight;
   /**
    * When disabled, the values of <code>maximumZoomDistance</code> and <code>minimumZoomDistance</code> are ignored.
@@ -253,7 +266,7 @@ function ScreenSpaceCameraController(scene) {
 
   this._scene = scene;
   this._globe = undefined;
-  this._ellipsoid = undefined;
+  this._ellipsoid = ellipsoid;
 
   this._lastGlobeHeight = 0.0;
 
@@ -920,7 +933,7 @@ function handleZoom(
 
   if ((!sameStartPosition && zoomOnVector) || zoomingOnVector) {
     let ray;
-    const zoomMouseStart = SceneTransforms.wgs84ToWindowCoordinates(
+    const zoomMouseStart = SceneTransforms.worldToWindowCoordinates(
       scene,
       object._zoomWorldPosition,
       scratchZoomOffset
@@ -2861,14 +2874,13 @@ function adjustHeightForTerrain(controller, cameraChanged) {
 
   const scene = controller._scene;
   const mode = scene.mode;
-  const globe = scene.globe;
 
   if (mode === SceneMode.SCENE2D || mode === SceneMode.MORPHING) {
     return;
   }
 
   const camera = scene.camera;
-  const ellipsoid = defaultValue(globe?.ellipsoid, Ellipsoid.WGS84);
+  const ellipsoid = defaultValue(scene.ellipsoid, Ellipsoid.WGS84);
   const projection = scene.mapProjection;
 
   let transform;
@@ -2967,9 +2979,7 @@ ScreenSpaceCameraController.prototype.update = function () {
     this._ellipsoid = Ellipsoid.UNIT_SPHERE;
   } else {
     this._globe = globe;
-    this._ellipsoid = defined(this._globe)
-      ? this._globe.ellipsoid
-      : scene.mapProjection.ellipsoid;
+    this._ellipsoid = defaultValue(scene.ellipsoid, Ellipsoid.default);
   }
 
   const { verticalExaggeration, verticalExaggerationRelativeHeight } = scene;

package/Source/Scene/SkyBox.js

@@ -1,3 +1,4 @@
+import buildModuleUrl from "../Core/buildModuleUrl.js";
 import BoxGeometry from "../Core/BoxGeometry.js";
 import Cartesian3 from "../Core/Cartesian3.js";
 import defaultValue from "../Core/defaultValue.js";
@@ -249,4 +250,29 @@ SkyBox.prototype.destroy = function () {
   this._cubeMap = this._cubeMap && this._cubeMap.destroy();
   return destroyObject(this);
 };
+
+function getDefaultSkyBoxUrl(suffix) {
+  return buildModuleUrl(`Assets/Textures/SkyBox/tycho2t3_80_${suffix}.jpg`);
+}
+
+/**
+ * Creates a skybox instance with the default starmap for the Earth.
+ * @return {SkyBox} The default skybox for the Earth
+ *
+ * @example
+ * viewer.scene.skyBox = Cesium.SkyBox.createEarthSkyBox();
+ */
+SkyBox.createEarthSkyBox = function () {
+  return new SkyBox({
+    sources: {
+      positiveX: getDefaultSkyBoxUrl("px"),
+      negativeX: getDefaultSkyBoxUrl("mx"),
+      positiveY: getDefaultSkyBoxUrl("py"),
+      negativeY: getDefaultSkyBoxUrl("my"),
+      positiveZ: getDefaultSkyBoxUrl("pz"),
+      negativeZ: getDefaultSkyBoxUrl("mz"),
+    },
+  });
+};
+
 export default SkyBox;

package/Source/Scene/Sun.js

@@ -267,7 +267,7 @@ Sun.prototype.update = function (frameState, passState, useHdr) {
     BoundingSphere.clone(boundingVolume2D, drawCommand.boundingVolume);
   }
 
-  const position = SceneTransforms.computeActualWgs84Position(
+  const position = SceneTransforms.computeActualEllipsoidPosition(
     frameState,
     sunPosition,
     scratchCartesian4

package/Source/Shaders/Builtin/CzmBuiltins.js

@@ -42,7 +42,6 @@ import czm_material from './Structs/material.js'
 import czm_materialInput from './Structs/materialInput.js'
 import czm_modelMaterial from './Structs/modelMaterial.js'
 import czm_modelVertexOutput from './Structs/modelVertexOutput.js'
-import czm_pbrParameters from './Structs/pbrParameters.js'
 import czm_ray from './Structs/ray.js'
 import czm_raySegment from './Structs/raySegment.js'
 import czm_shadowParameters from './Structs/shadowParameters.js'
@@ -72,11 +71,10 @@ import czm_computePosition from './Functions/computePosition.js'
 import czm_computeScattering from './Functions/computeScattering.js'
 import czm_cosineAndSine from './Functions/cosineAndSine.js'
 import czm_decompressTextureCoordinates from './Functions/decompressTextureCoordinates.js'
-import czm_defaultPbrMaterial from './Functions/defaultPbrMaterial.js'
 import czm_depthClamp from './Functions/depthClamp.js'
 import czm_eastNorthUpToEyeCoordinates from './Functions/eastNorthUpToEyeCoordinates.js'
 import czm_ellipsoidContainsPoint from './Functions/ellipsoidContainsPoint.js'
-import czm_ellipsoidWgs84TextureCoordinates from './Functions/ellipsoidWgs84TextureCoordinates.js'
+import czm_ellipsoidTextureCoordinates from './Functions/ellipsoidTextureCoordinates.js'
 import czm_equalsEpsilon from './Functions/equalsEpsilon.js'
 import czm_eyeOffset from './Functions/eyeOffset.js'
 import czm_eyeToWindowCoordinates from './Functions/eyeToWindowCoordinates.js'
@@ -97,6 +95,7 @@ import czm_latitudeToWebMercatorFraction from './Functions/latitudeToWebMercator
 import czm_lineDistance from './Functions/lineDistance.js'
 import czm_linearToSrgb from './Functions/linearToSrgb.js'
 import czm_luminance from './Functions/luminance.js'
+import czm_maximumComponent from './Functions/maximumComponent.js'
 import czm_metersPerPixel from './Functions/metersPerPixel.js'
 import czm_modelToWindowCoordinates from './Functions/modelToWindowCoordinates.js'
 import czm_multiplyWithColorBalance from './Functions/multiplyWithColorBalance.js'
@@ -104,8 +103,6 @@ import czm_nearFarScalar from './Functions/nearFarScalar.js'
 import czm_octDecode from './Functions/octDecode.js'
 import czm_packDepth from './Functions/packDepth.js'
 import czm_pbrLighting from './Functions/pbrLighting.js'
-import czm_pbrMetallicRoughnessMaterial from './Functions/pbrMetallicRoughnessMaterial.js'
-import czm_pbrSpecularGlossinessMaterial from './Functions/pbrSpecularGlossinessMaterial.js'
 import czm_phong from './Functions/phong.js'
 import czm_planeDistance from './Functions/planeDistance.js'
 import czm_pointAlongRay from './Functions/pointAlongRay.js'
@@ -183,7 +180,6 @@ export default {
     czm_materialInput : czm_materialInput,
     czm_modelMaterial : czm_modelMaterial,
     czm_modelVertexOutput : czm_modelVertexOutput,
-    czm_pbrParameters : czm_pbrParameters,
     czm_ray : czm_ray,
     czm_raySegment : czm_raySegment,
     czm_shadowParameters : czm_shadowParameters,
@@ -213,11 +209,10 @@ export default {
     czm_computeScattering : czm_computeScattering,
     czm_cosineAndSine : czm_cosineAndSine,
     czm_decompressTextureCoordinates : czm_decompressTextureCoordinates,
-    czm_defaultPbrMaterial : czm_defaultPbrMaterial,
     czm_depthClamp : czm_depthClamp,
     czm_eastNorthUpToEyeCoordinates : czm_eastNorthUpToEyeCoordinates,
     czm_ellipsoidContainsPoint : czm_ellipsoidContainsPoint,
-    czm_ellipsoidWgs84TextureCoordinates : czm_ellipsoidWgs84TextureCoordinates,
+    czm_ellipsoidTextureCoordinates : czm_ellipsoidTextureCoordinates,
     czm_equalsEpsilon : czm_equalsEpsilon,
     czm_eyeOffset : czm_eyeOffset,
     czm_eyeToWindowCoordinates : czm_eyeToWindowCoordinates,
@@ -238,6 +233,7 @@ export default {
     czm_lineDistance : czm_lineDistance,
     czm_linearToSrgb : czm_linearToSrgb,
     czm_luminance : czm_luminance,
+    czm_maximumComponent : czm_maximumComponent,
     czm_metersPerPixel : czm_metersPerPixel,
     czm_modelToWindowCoordinates : czm_modelToWindowCoordinates,
     czm_multiplyWithColorBalance : czm_multiplyWithColorBalance,
@@ -245,8 +241,6 @@ export default {
     czm_octDecode : czm_octDecode,
     czm_packDepth : czm_packDepth,
     czm_pbrLighting : czm_pbrLighting,
-    czm_pbrMetallicRoughnessMaterial : czm_pbrMetallicRoughnessMaterial,
-    czm_pbrSpecularGlossinessMaterial : czm_pbrSpecularGlossinessMaterial,
     czm_phong : czm_phong,
     czm_planeDistance : czm_planeDistance,
     czm_pointAlongRay : czm_pointAlongRay,

package/Source/Shaders/Builtin/Functions/ellipsoidTextureCoordinates.glsl

@@ -0,0 +1,10 @@
+/**
+ * Approximate uv coordinates based on the ellipsoid normal.
+ *
+ * @name czm_ellipsoidTextureCoordinates
+ * @glslFunction
+ */
+vec2 czm_ellipsoidTextureCoordinates(vec3 normal)
+{
+    return vec2(atan(normal.y, normal.x) * czm_oneOverTwoPi + 0.5, asin(normal.z) * czm_oneOverPi + 0.5);
+}

package/Source/Shaders/Builtin/Functions/{ellipsoidWgs84TextureCoordinates.js → ellipsoidTextureCoordinates.js}

@@ -1,11 +1,11 @@
 //This file is automatically rebuilt by the Cesium build process.
 export default "/**\n\
- * DOC_TBA\n\
+ * Approximate uv coordinates based on the ellipsoid normal.\n\
  *\n\
- * @name czm_ellipsoidWgs84TextureCoordinates\n\
+ * @name czm_ellipsoidTextureCoordinates\n\
  * @glslFunction\n\
  */\n\
-vec2 czm_ellipsoidWgs84TextureCoordinates(vec3 normal)\n\
+vec2 czm_ellipsoidTextureCoordinates(vec3 normal)\n\
 {\n\
     return vec2(atan(normal.y, normal.x) * czm_oneOverTwoPi + 0.5, asin(normal.z) * czm_oneOverPi + 0.5);\n\
 }\n\

package/Source/Shaders/Builtin/Functions/maximumComponent.glsl

@@ -0,0 +1,21 @@
+/**
+ * Find the maximum component of a vector.
+ *
+ * @name czm_maximumComponent
+ * @glslFunction
+ *
+ * @param {vec2|vec3|vec4} v The input vector.
+ * @returns {float} The value of the largest component.
+ */
+float czm_maximumComponent(vec2 v)
+{
+    return max(v.x, v.y);
+}
+float czm_maximumComponent(vec3 v)
+{
+    return max(max(v.x, v.y), v.z);
+}
+float czm_maximumComponent(vec4 v)
+{
+    return max(max(max(v.x, v.y), v.z), v.w);
+}