@cesium/engine 2.1.0 → 2.3.0

package/Source/Scene/createWorldImagery.js

@@ -1,4 +1,5 @@
 import defaultValue from "../Core/defaultValue.js";
+import deprecationWarning from "../Core/deprecationWarning.js";
 import IonImageryProvider from "./IonImageryProvider.js";
 import IonWorldImageryStyle from "./IonWorldImageryStyle.js";
 
@@ -10,17 +11,18 @@ import IonWorldImageryStyle from "./IonWorldImageryStyle.js";
  * @param {object} [options] Object with the following properties:
  * @param {IonWorldImageryStyle} [options.style=IonWorldImageryStyle] The style of base imagery, only AERIAL, AERIAL_WITH_LABELS, and ROAD are currently supported.
  * @returns {IonImageryProvider}
+ * @deprecated
  *
  * @see Ion
  *
  * @example
- * // Create Cesium World Terrain with default settings
+ * // Create Cesium World Imagery with default settings
  * const viewer = new Cesium.Viewer('cesiumContainer', {
  *     imageryProvider : Cesium.createWorldImagery();
  * });
  *
  * @example
- * // Create Cesium World Terrain with water and normals.
+ * // Create Cesium World Imagery with a different style
  * const viewer = new Cesium.Viewer('cesiumContainer', {
  *     imageryProvider : Cesium.createWorldImagery({
  *         style: Cesium.IonWorldImageryStyle.AERIAL_WITH_LABELS
@@ -29,10 +31,17 @@ import IonWorldImageryStyle from "./IonWorldImageryStyle.js";
  *
  */
 function createWorldImagery(options) {
+  deprecationWarning(
+    "createWorldImagery",
+    "createWorldImagery was deprecated in CesiumJS 1.104.  It will be in CesiumJS 1.107.  Use createWorldImageryAsync instead."
+  );
+
   options = defaultValue(options, defaultValue.EMPTY_OBJECT);
   const style = defaultValue(options.style, IonWorldImageryStyle.AERIAL);
-  return new IonImageryProvider({
-    assetId: style,
-  });
+  const provider = new IonImageryProvider();
+
+  // This is here for backwards compatibility
+  IonImageryProvider._initialize(provider, style, options);
+  return provider;
 }
 export default createWorldImagery;

package/Source/Scene/createWorldImageryAsync.js

@@ -0,0 +1,39 @@
+import defaultValue from "../Core/defaultValue.js";
+import IonImageryProvider from "./IonImageryProvider.js";
+import IonWorldImageryStyle from "./IonWorldImageryStyle.js";
+
+/**
+ * Creates an {@link IonImageryProvider} instance for ion's default global base imagery layer, currently Bing Maps.
+ *
+ * @function
+ *
+ * @param {Object} [options] Object with the following properties:
+ * @param {IonWorldImageryStyle} [options.style=IonWorldImageryStyle] The style of base imagery, only AERIAL, AERIAL_WITH_LABELS, and ROAD are currently supported.
+ * @returns {Promise<IonImageryProvider>}
+ *
+ * @see Ion
+ *
+ * @example
+ * // Create a Cesium World Imagery base layer with default settings
+ * try {
+ *   const imageryProvider = await Cesium.createWorldImageryAsync();
+ * } catch (error) {
+ *   console.log(`There was an error creating world imagery: ${error}`);
+ * }
+ *
+ * @example
+ * // Create Cesium World Imagery with different style
+ * try {
+ *   const imageryProvider = await Cesium.createWorldImageryAsync({
+ *         style: Cesium.IonWorldImageryStyle.AERIAL_WITH_LABELS
+ *   });
+ * } catch (error) {
+ *   console.log(`There was an error creating world imagery: ${error}`);
+ * }
+ */
+function createWorldImageryAsync(options) {
+  options = defaultValue(options, defaultValue.EMPTY_OBJECT);
+  const style = defaultValue(options.style, IonWorldImageryStyle.AERIAL);
+  return IonImageryProvider.fromAssetId(style);
+}
+export default createWorldImageryAsync;

package/Source/Shaders/AtmosphereCommon.glsl

@@ -8,8 +8,16 @@ uniform vec3 u_atmosphereRayleighCoefficient;
 uniform vec3 u_atmosphereMieCoefficient;
 
 const float ATMOSPHERE_THICKNESS = 111e3; // The thickness of the atmosphere in meters.
-const int PRIMARY_STEPS = 16; // Number of times the ray from the camera to the world position (primary ray) is sampled.
-const int LIGHT_STEPS = 4; // Number of times the light is sampled from the light source's intersection with the atmosphere to a sample position on the primary ray.
+const int PRIMARY_STEPS_MAX = 16; // Maximum number of times the ray from the camera to the world position (primary ray) is sampled.
+const int LIGHT_STEPS_MAX = 4; // Maximum number of times the light is sampled from the light source's intersection with the atmosphere to a sample position on the primary ray.
+
+/**
+ * Rational approximation to tanh(x)
+*/
+float approximateTanh(float x) {
+    float x2 = x * x;
+    return max(-1.0, min(+1.0, x * (27.0 + x2) / (27.0 + 9.0 * x2)));
+}
 
 /**
  * This function computes the colors contributed by Rayliegh and Mie scattering on a given ray, as well as
@@ -50,14 +58,36 @@ void computeScattering(
         return;
     }
 
+    // To deal with smaller values of PRIMARY_STEPS (e.g. 4)
+    // we implement a split strategy: sky or horizon.
+    // For performance reasons, instead of a if/else branch
+    // a soft choice is implemented through a weight 0.0 <= w_stop_gt_lprl <= 1.0
+    float x = 1e-7 * primaryRayAtmosphereIntersect.stop / length(primaryRayLength);
+    // Value close to 0.0: close to the horizon
+    // Value close to 1.0: above in the sky
+    float w_stop_gt_lprl = 0.5 * (1.0 + approximateTanh(x));
+    
     // The ray should start from the first intersection with the outer atmopshere, or from the camera position, if it is inside the atmosphere.
+    float start_0 = primaryRayAtmosphereIntersect.start;
     primaryRayAtmosphereIntersect.start = max(primaryRayAtmosphereIntersect.start, 0.0);
     // The ray should end at the exit from the atmosphere or at the distance to the vertex, whichever is smaller.
     primaryRayAtmosphereIntersect.stop = min(primaryRayAtmosphereIntersect.stop, length(primaryRayLength));
 
+    // For the number of ray steps, distinguish inside or outside atmosphere (outer space)
+    // (1) from outer space we have to use more ray steps to get a realistic rendering
+    // (2) within atmosphere we need fewer steps for faster rendering
+    float x_o_a = start_0 - ATMOSPHERE_THICKNESS; // ATMOSPHERE_THICKNESS used as an ad-hoc constant, no precise meaning here, only the order of magnitude matters
+    float w_inside_atmosphere = 1.0 - 0.5 * (1.0 + approximateTanh(x_o_a));
+    int PRIMARY_STEPS = PRIMARY_STEPS_MAX - int(w_inside_atmosphere * 12.0); // Number of times the ray from the camera to the world position (primary ray) is sampled.
+    int LIGHT_STEPS = LIGHT_STEPS_MAX - int(w_inside_atmosphere * 2.0); // Number of times the light is sampled from the light source's intersection with the atmosphere to a sample position on the primary ray.
+
     // Setup for sampling positions along the ray - starting from the intersection with the outer ring of the atmosphere.
-    float rayStepLength = (primaryRayAtmosphereIntersect.stop - primaryRayAtmosphereIntersect.start) / float(PRIMARY_STEPS);
     float rayPositionLength = primaryRayAtmosphereIntersect.start;
+    // (1) Outside the atmosphere: constant rayStepLength
+    // (2) Inside atmosphere: variable rayStepLength to compensate the rough rendering of the smaller number of ray steps
+    float totalRayLength = primaryRayAtmosphereIntersect.stop - rayPositionLength;
+    float rayStepLengthIncrease = w_inside_atmosphere * ((1.0 - w_stop_gt_lprl) * totalRayLength / (float(PRIMARY_STEPS * (PRIMARY_STEPS + 1)) / 2.0));
+    float rayStepLength = max(1.0 - w_inside_atmosphere, w_stop_gt_lprl) * totalRayLength / max(7.0 * w_inside_atmosphere, float(PRIMARY_STEPS));
 
     vec3 rayleighAccumulation = vec3(0.0);
     vec3 mieAccumulation = vec3(0.0);
@@ -65,10 +95,17 @@ void computeScattering(
     vec2 heightScale = vec2(u_atmosphereRayleighScaleHeight, u_atmosphereMieScaleHeight);
 
     // Sample positions on the primary ray.
-    for (int i = 0; i < PRIMARY_STEPS; i++) {
+    for (int i = 0; i < PRIMARY_STEPS_MAX; ++i) {
+
+        // The loop should be: for (int i = 0; i < PRIMARY_STEPS; ++i) {...} but WebGL1 cannot
+        // loop with non-constant condition, so it has to break early instead
+        if (i >= PRIMARY_STEPS) {
+            break;
+        }
+
         // Calculate sample position along viewpoint ray.
         vec3 samplePosition = primaryRay.origin + primaryRay.direction * (rayPositionLength + rayStepLength);
-        
+
         // Calculate height of sample position above ellipsoid.
         float sampleHeight = length(samplePosition) - atmosphereInnerRadius;
 
@@ -79,14 +116,20 @@ void computeScattering(
         // Generate ray from the sample position segment to the light source, up to the outer ring of the atmosphere.
         czm_ray lightRay = czm_ray(samplePosition, lightDirection);
         czm_raySegment lightRayAtmosphereIntersect = czm_raySphereIntersectionInterval(lightRay, origin, atmosphereOuterRadius);
-        
+
         float lightStepLength = lightRayAtmosphereIntersect.stop / float(LIGHT_STEPS);
         float lightPositionLength = 0.0;
 
         vec2 lightOpticalDepth = vec2(0.0);
 
         // Sample positions along the light ray, to accumulate incidence of light on the latest sample segment.
-        for (int j = 0; j < LIGHT_STEPS; j++) {
+        for (int j = 0; j < LIGHT_STEPS_MAX; ++j) {
+
+            // The loop should be: for (int j = 0; i < LIGHT_STEPS; ++j) {...} but WebGL1 cannot
+            // loop with non-constant condition, so it has to break early instead
+            if (j >= LIGHT_STEPS) {
+                break;
+            }
 
             // Calculate sample position along light ray.
             vec3 lightPosition = samplePosition + lightDirection * (lightPositionLength + lightStepLength * 0.5);
@@ -109,7 +152,7 @@ void computeScattering(
         mieAccumulation += sampleDensity.y * attenuation;
 
         // Increment distance on primary ray.
-        rayPositionLength += rayStepLength;
+        rayPositionLength += (rayStepLength += rayStepLengthIncrease);
     }
 
     // Compute the scattering amount.

package/Source/Shaders/AtmosphereCommon.js

@@ -9,8 +9,16 @@ uniform vec3 u_atmosphereRayleighCoefficient;\n\
 uniform vec3 u_atmosphereMieCoefficient;\n\
 \n\
 const float ATMOSPHERE_THICKNESS = 111e3; // The thickness of the atmosphere in meters.\n\
-const int PRIMARY_STEPS = 16; // Number of times the ray from the camera to the world position (primary ray) is sampled.\n\
-const int LIGHT_STEPS = 4; // Number of times the light is sampled from the light source's intersection with the atmosphere to a sample position on the primary ray.\n\
+const int PRIMARY_STEPS_MAX = 16; // Maximum number of times the ray from the camera to the world position (primary ray) is sampled.\n\
+const int LIGHT_STEPS_MAX = 4; // Maximum number of times the light is sampled from the light source's intersection with the atmosphere to a sample position on the primary ray.\n\
+\n\
+/**\n\
+ * Rational approximation to tanh(x)\n\
+*/\n\
+float approximateTanh(float x) {\n\
+    float x2 = x * x;\n\
+    return max(-1.0, min(+1.0, x * (27.0 + x2) / (27.0 + 9.0 * x2)));\n\
+}\n\
 \n\
 /**\n\
  * This function computes the colors contributed by Rayliegh and Mie scattering on a given ray, as well as\n\
@@ -51,14 +59,36 @@ void computeScattering(\n\
         return;\n\
     }\n\
 \n\
+    // To deal with smaller values of PRIMARY_STEPS (e.g. 4)\n\
+    // we implement a split strategy: sky or horizon.\n\
+    // For performance reasons, instead of a if/else branch\n\
+    // a soft choice is implemented through a weight 0.0 <= w_stop_gt_lprl <= 1.0\n\
+    float x = 1e-7 * primaryRayAtmosphereIntersect.stop / length(primaryRayLength);\n\
+    // Value close to 0.0: close to the horizon\n\
+    // Value close to 1.0: above in the sky\n\
+    float w_stop_gt_lprl = 0.5 * (1.0 + approximateTanh(x));\n\
+    \n\
     // The ray should start from the first intersection with the outer atmopshere, or from the camera position, if it is inside the atmosphere.\n\
+    float start_0 = primaryRayAtmosphereIntersect.start;\n\
     primaryRayAtmosphereIntersect.start = max(primaryRayAtmosphereIntersect.start, 0.0);\n\
     // The ray should end at the exit from the atmosphere or at the distance to the vertex, whichever is smaller.\n\
     primaryRayAtmosphereIntersect.stop = min(primaryRayAtmosphereIntersect.stop, length(primaryRayLength));\n\
+\n\
+    // For the number of ray steps, distinguish inside or outside atmosphere (outer space)\n\
+    // (1) from outer space we have to use more ray steps to get a realistic rendering\n\
+    // (2) within atmosphere we need fewer steps for faster rendering\n\
+    float x_o_a = start_0 - ATMOSPHERE_THICKNESS; // ATMOSPHERE_THICKNESS used as an ad-hoc constant, no precise meaning here, only the order of magnitude matters\n\
+    float w_inside_atmosphere = 1.0 - 0.5 * (1.0 + approximateTanh(x_o_a));\n\
+    int PRIMARY_STEPS = PRIMARY_STEPS_MAX - int(w_inside_atmosphere * 12.0); // Number of times the ray from the camera to the world position (primary ray) is sampled.\n\
+    int LIGHT_STEPS = LIGHT_STEPS_MAX - int(w_inside_atmosphere * 2.0); // Number of times the light is sampled from the light source's intersection with the atmosphere to a sample position on the primary ray.\n\
 \n\
     // Setup for sampling positions along the ray - starting from the intersection with the outer ring of the atmosphere.\n\
-    float rayStepLength = (primaryRayAtmosphereIntersect.stop - primaryRayAtmosphereIntersect.start) / float(PRIMARY_STEPS);\n\
     float rayPositionLength = primaryRayAtmosphereIntersect.start;\n\
+    // (1) Outside the atmosphere: constant rayStepLength\n\
+    // (2) Inside atmosphere: variable rayStepLength to compensate the rough rendering of the smaller number of ray steps\n\
+    float totalRayLength = primaryRayAtmosphereIntersect.stop - rayPositionLength;\n\
+    float rayStepLengthIncrease = w_inside_atmosphere * ((1.0 - w_stop_gt_lprl) * totalRayLength / (float(PRIMARY_STEPS * (PRIMARY_STEPS + 1)) / 2.0));\n\
+    float rayStepLength = max(1.0 - w_inside_atmosphere, w_stop_gt_lprl) * totalRayLength / max(7.0 * w_inside_atmosphere, float(PRIMARY_STEPS));\n\
 \n\
     vec3 rayleighAccumulation = vec3(0.0);\n\
     vec3 mieAccumulation = vec3(0.0);\n\
@@ -66,10 +96,17 @@ void computeScattering(\n\
     vec2 heightScale = vec2(u_atmosphereRayleighScaleHeight, u_atmosphereMieScaleHeight);\n\
 \n\
     // Sample positions on the primary ray.\n\
-    for (int i = 0; i < PRIMARY_STEPS; i++) {\n\
+    for (int i = 0; i < PRIMARY_STEPS_MAX; ++i) {\n\
+\n\
+        // The loop should be: for (int i = 0; i < PRIMARY_STEPS; ++i) {...} but WebGL1 cannot\n\
+        // loop with non-constant condition, so it has to break early instead\n\
+        if (i >= PRIMARY_STEPS) {\n\
+            break;\n\
+        }\n\
+\n\
         // Calculate sample position along viewpoint ray.\n\
         vec3 samplePosition = primaryRay.origin + primaryRay.direction * (rayPositionLength + rayStepLength);\n\
-        \n\
+\n\
         // Calculate height of sample position above ellipsoid.\n\
         float sampleHeight = length(samplePosition) - atmosphereInnerRadius;\n\
 \n\
@@ -80,14 +117,20 @@ void computeScattering(\n\
         // Generate ray from the sample position segment to the light source, up to the outer ring of the atmosphere.\n\
         czm_ray lightRay = czm_ray(samplePosition, lightDirection);\n\
         czm_raySegment lightRayAtmosphereIntersect = czm_raySphereIntersectionInterval(lightRay, origin, atmosphereOuterRadius);\n\
-        \n\
+\n\
         float lightStepLength = lightRayAtmosphereIntersect.stop / float(LIGHT_STEPS);\n\
         float lightPositionLength = 0.0;\n\
 \n\
         vec2 lightOpticalDepth = vec2(0.0);\n\
 \n\
         // Sample positions along the light ray, to accumulate incidence of light on the latest sample segment.\n\
-        for (int j = 0; j < LIGHT_STEPS; j++) {\n\
+        for (int j = 0; j < LIGHT_STEPS_MAX; ++j) {\n\
+\n\
+            // The loop should be: for (int j = 0; i < LIGHT_STEPS; ++j) {...} but WebGL1 cannot\n\
+            // loop with non-constant condition, so it has to break early instead\n\
+            if (j >= LIGHT_STEPS) {\n\
+                break;\n\
+            }\n\
 \n\
             // Calculate sample position along light ray.\n\
             vec3 lightPosition = samplePosition + lightDirection * (lightPositionLength + lightStepLength * 0.5);\n\
@@ -110,7 +153,7 @@ void computeScattering(\n\
         mieAccumulation += sampleDensity.y * attenuation;\n\
 \n\
         // Increment distance on primary ray.\n\
-        rayPositionLength += rayStepLength;\n\
+        rayPositionLength += (rayStepLength += rayStepLengthIncrease);\n\
     }\n\
 \n\
     // Compute the scattering amount.\n\

package/Source/Shaders/PostProcessStages/AmbientOcclusionGenerate.glsl

@@ -58,7 +58,7 @@ void main(void)
     float gapAngle = 90.0 * czm_radiansPerDegree;
 
     // RandomNoise
-    float randomVal = texture(randomTexture, v_textureCoordinates).x;
+    float randomVal = texture(randomTexture, v_textureCoordinates / pixelSize / 255.0).x;
 
     //Loop for each direction
     for (int i = 0; i < 4; i++)

package/Source/Shaders/PostProcessStages/AmbientOcclusionGenerate.js

@@ -59,7 +59,7 @@ void main(void)\n\
     float gapAngle = 90.0 * czm_radiansPerDegree;\n\
 \n\
     // RandomNoise\n\
-    float randomVal = texture(randomTexture, v_textureCoordinates).x;\n\
+    float randomVal = texture(randomTexture, v_textureCoordinates / pixelSize / 255.0).x;\n\
 \n\
     //Loop for each direction\n\
     for (int i = 0; i < 4; i++)\n\

package/Source/Shaders/PostProcessStages/AmbientOcclusionModulate.glsl

@@ -5,7 +5,7 @@ in vec2 v_textureCoordinates;
 
 void main(void)
 {
-    vec3 color = texture(colorTexture, v_textureCoordinates).rgb;
-    vec3 ao = texture(ambientOcclusionTexture, v_textureCoordinates).rgb;
-    out_FragColor.rgb = ambientOcclusionOnly ? ao : ao * color;
+    vec4 color = texture(colorTexture, v_textureCoordinates);
+    vec4 ao = texture(ambientOcclusionTexture, v_textureCoordinates);
+    out_FragColor = ambientOcclusionOnly ? ao : ao * color;
 }

package/Source/Shaders/PostProcessStages/AmbientOcclusionModulate.js

@@ -6,8 +6,8 @@ in vec2 v_textureCoordinates;\n\
 \n\
 void main(void)\n\
 {\n\
-    vec3 color = texture(colorTexture, v_textureCoordinates).rgb;\n\
-    vec3 ao = texture(ambientOcclusionTexture, v_textureCoordinates).rgb;\n\
-    out_FragColor.rgb = ambientOcclusionOnly ? ao : ao * color;\n\
+    vec4 color = texture(colorTexture, v_textureCoordinates);\n\
+    vec4 ao = texture(ambientOcclusionTexture, v_textureCoordinates);\n\
+    out_FragColor = ambientOcclusionOnly ? ao : ao * color;\n\
 }\n\
 ";

package/Source/Widget/CesiumWidget.js

@@ -1,9 +1,9 @@
 import buildModuleUrl from "../Core/buildModuleUrl.js";
-import createWorldImagery from "../Scene/createWorldImagery.js";
 import Cartesian3 from "../Core/Cartesian3.js";
 import Clock from "../Core/Clock.js";
 import defaultValue from "../Core/defaultValue.js";
 import defined from "../Core/defined.js";
+import deprecationWarning from "../Core/deprecationWarning.js";
 import destroyObject from "../Core/destroyObject.js";
 import DeveloperError from "../Core/DeveloperError.js";
 import Ellipsoid from "../Core/Ellipsoid.js";
@@ -11,6 +11,7 @@ import FeatureDetection from "../Core/FeatureDetection.js";
 import formatError from "../Core/formatError.js";
 import getElement from "../DataSources/getElement.js";
 import Globe from "../Scene/Globe.js";
+import ImageryLayer from "../Scene/ImageryLayer.js";
 import Moon from "../Scene/Moon.js";
 import Scene from "../Scene/Scene.js";
 import SceneMode from "../Scene/SceneMode.js";
@@ -123,8 +124,10 @@ function configureCameraFrustum(widget) {
  * @param {Element|string} container The DOM element or ID that will contain the widget.
  * @param {object} [options] Object with the following properties:
  * @param {Clock} [options.clock=new Clock()] The clock to use to control current time.
- * @param {ImageryProvider | false} [options.imageryProvider=createWorldImagery()] The imagery provider to serve as the base layer. If set to <code>false</code>, no imagery provider will be added.
+ * @param {ImageryProvider | false} [options.imageryProvider=createWorldImagery()] The imagery provider to serve as the base layer. If set to <code>false</code>, no imagery provider will be added. Deprecated.
+ * @param {ImageryLayer|false} [baseLayer=ImageryLayer.fromWorldImagery()] The bottommost imagery layer applied to the globe. If set to <code>false</code>, no imagery provider will be added.
  * @param {TerrainProvider} [options.terrainProvider=new EllipsoidTerrainProvider] The terrain provider.
+ * @param {Terrain} [options.terrain] A terrain object which handles asynchronous terrain provider. Can only specify if options.terrainProvider is undefined.
  * @param {SkyBox| false} [options.skyBox] The skybox used to render the stars.  When <code>undefined</code>, the default stars are used. If set to <code>false</code>, no skyBox, Sun, or Moon will be added.
  * @param {SkyAtmosphere | false} [options.skyAtmosphere] Blue sky, and the glow around the Earth's limb.  Set to <code>false</code> to turn it off.
  * @param {SceneMode} [options.sceneMode=SceneMode.SCENE3D] The initial scene mode.
@@ -156,26 +159,26 @@ function configureCameraFrustum(widget) {
  * // For each example, include a link to CesiumWidget.css stylesheet in HTML head,
  * // and in the body, include: <div id="cesiumContainer"></div>
  *
- * //Widget with no terrain and default Bing Maps imagery provider.
- * const widget = new Cesium.CesiumWidget('cesiumContainer');
+ * // Widget with no terrain and default Bing Maps imagery provider.
+ * const widget = new Cesium.CesiumWidget("cesiumContainer");
  *
- * //Widget with ion imagery and Cesium World Terrain.
- * const widget2 = new Cesium.CesiumWidget('cesiumContainer', {
- *     imageryProvider : Cesium.createWorldImagery(),
- *     terrainProvider : Cesium.createWorldTerrain(),
- *     skyBox : new Cesium.SkyBox({
- *         sources : {
- *           positiveX : 'stars/TychoSkymapII.t3_08192x04096_80_px.jpg',
- *           negativeX : 'stars/TychoSkymapII.t3_08192x04096_80_mx.jpg',
- *           positiveY : 'stars/TychoSkymapII.t3_08192x04096_80_py.jpg',
- *           negativeY : 'stars/TychoSkymapII.t3_08192x04096_80_my.jpg',
- *           positiveZ : 'stars/TychoSkymapII.t3_08192x04096_80_pz.jpg',
- *           negativeZ : 'stars/TychoSkymapII.t3_08192x04096_80_mz.jpg'
- *         }
+ * // Widget with ion imagery and Cesium World Terrain.
+ * const widget2 = new Cesium.CesiumWidget("cesiumContainer", {
+ *     baseLayer: Cesium.ImageryLayer.fromWorldTerrain(),
+ *     terrain: Cesium.Terrain.fromWorldTerrain()
+ *     skyBox: new Cesium.SkyBox({
+ *       sources: {
+ *         positiveX: "stars/TychoSkymapII.t3_08192x04096_80_px.jpg",
+ *         negativeX: "stars/TychoSkymapII.t3_08192x04096_80_mx.jpg",
+ *         positiveY: "stars/TychoSkymapII.t3_08192x04096_80_py.jpg",
+ *         negativeY: "stars/TychoSkymapII.t3_08192x04096_80_my.jpg",
+ *         positiveZ: "stars/TychoSkymapII.t3_08192x04096_80_pz.jpg",
+ *         negativeZ: "stars/TychoSkymapII.t3_08192x04096_80_mz.jpg"
+ *       }
  *     }),
  *     // Show Columbus View map with Web Mercator projection
- *     sceneMode : Cesium.SceneMode.COLUMBUS_VIEW,
- *     mapProjection : new Cesium.WebMercatorProjection()
+ *     sceneMode: Cesium.SceneMode.COLUMBUS_VIEW,
+ *     mapProjection: new Cesium.WebMercatorProjection()
  * });
  */
 function CesiumWidget(container, options) {
@@ -340,22 +343,47 @@ function CesiumWidget(container, options) {
       scene.skyAtmosphere = skyAtmosphere;
     }
 
-    //Set the base imagery layer
-    let imageryProvider =
-      options.globe === false ? false : options.imageryProvider;
-    if (!defined(imageryProvider)) {
-      imageryProvider = createWorldImagery();
+    if (defined(options.imageryProvider)) {
+      deprecationWarning(
+        "CesiumWidget options.imageryProvider",
+        "options.imageryProvider was deprecated in CesiumJS 1.104.  It will be in CesiumJS 1.107.  Use options.baseLayer instead."
+      );
     }
 
-    if (imageryProvider !== false) {
-      scene.imageryLayers.addImageryProvider(imageryProvider);
+    // Set the base imagery layer
+    let baseLayer = options.baseLayer;
+    if (
+      options.globe !== false &&
+      baseLayer !== false &&
+      options.imageryProvider !== false
+    ) {
+      if (defined(options.imageryProvider) && !defined(baseLayer)) {
+        baseLayer = new ImageryLayer(options.imageryProvider);
+      }
+
+      if (!defined(baseLayer)) {
+        baseLayer = ImageryLayer.fromWorldImagery();
+      }
+      scene.imageryLayers.add(baseLayer);
     }
 
-    //Set the terrain provider if one is provided.
+    // Set the terrain provider if one is provided.
     if (defined(options.terrainProvider) && options.globe !== false) {
       scene.terrainProvider = options.terrainProvider;
     }
 
+    if (defined(options.terrain) && options.globe !== false) {
+      //>>includeStart('debug', pragmas.debug);
+      if (defined(options.terrainProvider)) {
+        throw new DeveloperError(
+          "Specify either options.terrainProvider or options.terrain."
+        );
+      }
+      //>>includeEnd('debug')
+
+      scene.setTerrain(options.terrain);
+    }
+
     this._screenSpaceEventHandler = new ScreenSpaceEventHandler(canvas);
 
     if (defined(options.sceneMode)) {
@@ -492,6 +520,18 @@ Object.defineProperties(CesiumWidget.prototype, {
     },
   },
 
+  /**
+   * Manages the list of credits to display on screen and in the lightbox.
+   * @memberof CesiumWidget.prototype
+   *
+   * @type {CreditDisplay}
+   */
+  creditDisplay: {
+    get: function () {
+      return this._scene.frameState.creditDisplay;
+    },
+  },
+
   /**
    * Gets the camera.
    * @memberof CesiumWidget.prototype