diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index 2b4b8f98a54b..376bc86d12b8 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -14,7 +14,7 @@ jobs:
     steps:
       - name: message result in slack
         id: slack
-        uses: slackapi/slack-github-action@v1.26.0
+        uses: slackapi/slack-github-action@v1.27.0
         env:
           SLACK_BOT_TOKEN: ${{ secrets.SLACK_BOT_TOKEN }}
         with:
diff --git a/Apps/Sandcastle/gallery/Bathymetry.html b/Apps/Sandcastle/gallery/Bathymetry.html
index 34b650a4a0ea..2b7ad4eabbf7 100644
--- a/Apps/Sandcastle/gallery/Bathymetry.html
+++ b/Apps/Sandcastle/gallery/Bathymetry.html
@@ -106,9 +106,6 @@
 
         const scene = viewer.scene;
 
-        // prevent aliasing from countour lines
-        scene.msaaSamples = 4;
-
         const globe = scene.globe;
         globe.enableLighting = true;
         globe.maximumScreenSpaceError = 1.0; // Load higher resolution tiles for better seafloor shading
diff --git a/Apps/Sandcastle/gallery/Callback Position Property.html b/Apps/Sandcastle/gallery/Callback Position Property.html
new file mode 100644
index 000000000000..19dab3dadcad
--- /dev/null
+++ b/Apps/Sandcastle/gallery/Callback Position Property.html	
@@ -0,0 +1,221 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
+    <meta
+      name="viewport"
+      content="width=device-width, initial-scale=1, maximum-scale=1, minimum-scale=1, user-scalable=no"
+    />
+    <meta
+      name="description"
+      content="Use a CallbackPositionProperty when your data can't be pre-computed or needs to be derived from other properties at runtime."
+    />
+    <meta name="cesium-sandcastle-labels" content="Beginner, Showcases" />
+    <title>Cesium Demo</title>
+    <script type="text/javascript" src="../Sandcastle-header.js"></script>
+    <script
+      type="text/javascript"
+      src="../../../Build/CesiumUnminified/Cesium.js"
+      nomodule
+    ></script>
+    <script type="module" src="../load-cesium-es6.js"></script>
+  </head>
+  <body
+    class="sandcastle-loading"
+    data-sandcastle-bucket="bucket-requirejs.html"
+  >
+    <style>
+      @import url(../templates/bucket.css);
+    </style>
+    <div id="cesiumContainer" class="fullSize"></div>
+    <div id="loadingOverlay"><h1>Loading...</h1></div>
+    <div id="toolbar"></div>
+    <script id="cesium_sandcastle_script">
+      window.startup = async function (Cesium) {
+        "use strict";
+        //Sandcastle_Begin
+        // This example illustrates a Callback Position Property, a position property whose
+        // value is lazily evaluated by a callback function.
+        // Use a CallbackPositionProperty when your data can't be pre-computed
+        // or needs to be derived from other properties at runtime.
+        const viewer = new Cesium.Viewer("cesiumContainer", {
+          terrain: Cesium.Terrain.fromWorldTerrain(),
+        });
+
+        // Enable lighting based on the sun position.
+        viewer.scene.globe.enableLighting = true;
+
+        // Enable depth testing so things behind the terrain disappear.
+        viewer.scene.globe.depthTestAgainstTerrain = true;
+
+        // Set bounds of our simulation time.
+        const start = Cesium.JulianDate.fromDate(new Date(2015, 2, 25, 16));
+        const duration = 8;
+        const stop = Cesium.JulianDate.addSeconds(
+          start,
+          duration,
+          new Cesium.JulianDate()
+        );
+
+        // Make sure viewer is at the desired time.
+        viewer.clock.startTime = start.clone();
+        viewer.clock.stopTime = stop.clone();
+        viewer.clock.currentTime = start.clone();
+        viewer.clock.multiplier = 1.0;
+        viewer.clock.clockRange = Cesium.ClockRange.LOOP_STOP;
+        viewer.clock.shouldAnimate = true;
+
+        // Set timeline to simulation bounds.
+        viewer.timeline.zoomTo(start, stop);
+
+        // Prepare time samples.
+        const times = [0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0];
+        const firstTime = times[0];
+        const lastTime = times[times.length - 1];
+        const delta = lastTime - firstTime;
+
+        // Prepare point samples. Before and after points are used to
+        // calculate the first and last tangents for the spline.
+        const before = Cesium.Cartesian3.fromDegrees(
+          -112.87962,
+          36.27375,
+          620.01
+        );
+        const points = [
+          Cesium.Cartesian3.fromDegrees(-112.87709, 36.27782, 620.01),
+          Cesium.Cartesian3.fromDegrees(-112.87351, 36.27992, 617.9),
+          Cesium.Cartesian3.fromDegrees(-112.87081, 36.2816, 617.6),
+          Cesium.Cartesian3.fromDegrees(-112.86539, 36.28239, 625.36),
+          Cesium.Cartesian3.fromDegrees(-112.86108, 36.28137, 627.82),
+          Cesium.Cartesian3.fromDegrees(-112.85551, 36.27967, 625.54),
+          Cesium.Cartesian3.fromDegrees(-112.848, 36.27732, 628.9),
+          Cesium.Cartesian3.fromDegrees(-112.84086, 36.27739, 638.81),
+          Cesium.Cartesian3.fromDegrees(-112.83682, 36.27995, 643.31),
+        ];
+        const after = Cesium.Cartesian3.fromDegrees(
+          -112.83506,
+          36.2822,
+          643.31
+        );
+
+        // Calculate first and last tangents.
+        const firstTangent = Cesium.Cartesian3.subtract(
+          points[0],
+          before,
+          new Cesium.Cartesian3()
+        );
+        const lastTangent = Cesium.Cartesian3.subtract(
+          after,
+          points[8],
+          new Cesium.Cartesian3()
+        );
+
+        // Create the position spline.
+        const positionSpline = new Cesium.CatmullRomSpline({
+          times: times,
+          points: points,
+          firstTangent: firstTangent,
+          lastTangent: lastTangent,
+        });
+
+        // Create the callback position property and make it return spline evaluations.
+        const position = new Cesium.CallbackPositionProperty(function (
+          time,
+          result
+        ) {
+          const splineTime =
+            (delta * Cesium.JulianDate.secondsDifference(time, start)) /
+            duration;
+          if (splineTime < firstTime || splineTime > lastTime) {
+            return undefined;
+          }
+          return positionSpline.evaluate(splineTime, result);
+        },
+        false);
+
+        const orientation = new Cesium.VelocityOrientationProperty(position);
+
+        // Add a waypoints.
+        for (let i = 0; i < points.length; ++i) {
+          viewer.entities.add({
+            position: points[i],
+            point: {
+              pixelSize: 8,
+              color: Cesium.Color.TRANSPARENT,
+              outlineColor: Cesium.Color.YELLOW,
+              outlineWidth: 3,
+            },
+          });
+        }
+
+        // Create the entity and bind its position to the callback position property
+        viewer.entities.add({
+          availability: new Cesium.TimeIntervalCollection([
+            new Cesium.TimeInterval({
+              start: start,
+              stop: stop,
+            }),
+          ]),
+          position: position,
+          orientation: orientation,
+          model: {
+            uri: "../../SampleData/models/CesiumDrone/CesiumDrone.glb",
+            minimumPixelSize: 64,
+            maximumScale: 20000,
+          },
+          path: {
+            material: new Cesium.PolylineGlowMaterialProperty({
+              glowPower: 0.1,
+              color: Cesium.Color.YELLOW,
+            }),
+            width: 10,
+            resolution: 0.01,
+            leadTime: 1,
+            trailTime: 0.1,
+          },
+        });
+
+        const camera = viewer.camera;
+        const scene = viewer.scene;
+
+        const scratchPosition = new Cesium.Cartesian3();
+        const scratchOrientation = new Cesium.Quaternion();
+        const scratchTransform = new Cesium.Matrix4();
+        const offset = new Cesium.Cartesian3(-100, 0, 10);
+
+        // Update camera to follow entity's position and orientation
+        viewer.clock.onTick.addEventListener(function (clock) {
+          if (scene.mode === Cesium.Scene.MORPHING) {
+            return;
+          }
+          const time = clock.currentTime;
+          const entityPosition = position.getValue(time, scratchPosition);
+          const entityOrientation = orientation.getValue(
+            time,
+            scratchOrientation
+          );
+          if (entityPosition === undefined || entityOrientation === undefined) {
+            return;
+          }
+          const transform = Cesium.Matrix4.fromTranslationQuaternionRotationScale(
+            entityPosition,
+            entityOrientation,
+            Cesium.Cartesian3.ONE,
+            scratchTransform
+          );
+          camera.lookAtTransform(transform, offset);
+        });
+        //Sandcastle_End
+      };
+      if (typeof Cesium !== "undefined") {
+        window.startupCalled = true;
+        window.startup(Cesium).catch((error) => {
+          "use strict";
+          console.error(error);
+        });
+        Sandcastle.finishedLoading();
+      }
+    </script>
+  </body>
+</html>
diff --git a/Apps/Sandcastle/gallery/Callback Position Property.jpg b/Apps/Sandcastle/gallery/Callback Position Property.jpg
new file mode 100644
index 000000000000..3a4c588906fa
Binary files /dev/null and b/Apps/Sandcastle/gallery/Callback Position Property.jpg differ
diff --git "a/Apps/Sandcastle/gallery/Globe Materials \342\200\223 Water Mask Elevation Map.html" "b/Apps/Sandcastle/gallery/Globe Materials \342\200\223 Water Mask Elevation Map.html"
new file mode 100644
index 000000000000..b05b26863f85
--- /dev/null
+++ "b/Apps/Sandcastle/gallery/Globe Materials \342\200\223 Water Mask Elevation Map.html"	
@@ -0,0 +1,144 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
+    <meta
+      name="viewport"
+      content="width=device-width, initial-scale=1, maximum-scale=1, minimum-scale=1, user-scalable=no"
+    />
+    <meta name="description" content="Apply materials to the globe." />
+    <meta name="cesium-sandcastle-labels" content="Showcases" />
+    <title>Cesium Demo</title>
+    <script type="text/javascript" src="../Sandcastle-header.js"></script>
+    <script
+      type="text/javascript"
+      src="../../../Build/CesiumUnminified/Cesium.js"
+      nomodule
+    ></script>
+    <script type="module" src="../load-cesium-es6.js"></script>
+  </head>
+  <body
+    class="sandcastle-loading"
+    data-sandcastle-bucket="bucket-requirejs.html"
+  >
+    <style>
+      @import url(../templates/bucket.css);
+    </style>
+    <div id="cesiumContainer" class="fullSize"></div>
+    <div id="loadingOverlay"><h1>Loading...</h1></div>
+    <div id="toolbar">
+      <div id="zoomButtons"></div>
+    </div>
+    <script id="cesium_sandcastle_script">
+      window.startup = async function (Cesium) {
+        "use strict";
+        //Sandcastle_Begin
+        const viewer = new Cesium.Viewer("cesiumContainer", {
+          terrain: Cesium.Terrain.fromWorldTerrain({
+            requestVertexNormals: true, // Needed for hillshading
+            requestWaterMask: true, // Needed to distinguish land from water
+          }),
+          timeline: false,
+          animation: false,
+        });
+
+        // Create a globe material for shading elevation only on land
+        const customElevationMaterial = new Cesium.Material({
+          fabric: {
+            type: "ElevationLand",
+            materials: {
+              waterMaskMaterial: {
+                type: "WaterMask",
+              },
+              elevationRampMaterial: {
+                type: "ElevationRamp",
+              },
+            },
+            components: {
+              diffuse: "elevationRampMaterial.diffuse",
+              alpha: "1.0 - waterMaskMaterial.alpha", // We'll need the inverse of the watermask to shade land
+            },
+          },
+          translucent: false,
+        });
+
+        const minHeight = -414.0; // approximate dead sea elevation
+        const maxHeight = 8777.0; // approximate everest elevation
+        const elevationRamp = [0.0, 0.045, 0.45, 0.5, 0.55, 1.0];
+        function getColorRamp() {
+          const ramp = document.createElement("canvas");
+          ramp.width = 100;
+          ramp.height = 1;
+          const ctx = ramp.getContext("2d");
+
+          const values = elevationRamp;
+
+          const grd = ctx.createLinearGradient(0, 0, 100, 0);
+
+          // See https://gis.stackexchange.com/questions/25099/choosing-colour-ramp-to-use-for-elevation
+          grd.addColorStop(values[0], "#344f31");
+          grd.addColorStop(values[1], "#5b8742");
+          grd.addColorStop(values[2], "#e6daa5");
+          grd.addColorStop(values[3], "#fdc771");
+          grd.addColorStop(values[4], "#b99d89");
+          grd.addColorStop(values[5], "#f0f0f0");
+
+          ctx.fillStyle = grd;
+          ctx.fillRect(0, 0, 100, 1);
+
+          return ramp;
+        }
+
+        const globe = viewer.scene.globe;
+        const material = customElevationMaterial;
+        const shadingUniforms =
+          material.materials.elevationRampMaterial.uniforms;
+        shadingUniforms.minimumHeight = minHeight;
+        shadingUniforms.maximumHeight = maxHeight;
+        shadingUniforms.image = getColorRamp();
+
+        globe.material = material;
+        globe.showWaterEffect = false;
+        globe.enableLighting = true;
+        globe.maximumScreenSpaceError = 0.5; // Load higher resolution tiles for more detailed shading
+
+        // Light the scene with a hillshade effect similar to https://pro.arcgis.com/en/pro-app/latest/tool-reference/3d-analyst/how-hillshade-works.htm
+        const scene = viewer.scene;
+        scene.light = new Cesium.DirectionalLight({
+          direction: new Cesium.Cartesian3(1, 0, 0), // Updated every frame
+        });
+
+        // Update the light position base on the camera
+        const scratchNormal = new Cesium.Cartesian3();
+        scene.preRender.addEventListener(function (scene, time) {
+          const surfaceNormal = globe.ellipsoid.geodeticSurfaceNormal(
+            scene.camera.positionWC,
+            scratchNormal
+          );
+          const negativeNormal = Cesium.Cartesian3.negate(
+            surfaceNormal,
+            surfaceNormal
+          );
+          scene.light.direction = Cesium.Cartesian3.normalize(
+            Cesium.Cartesian3.add(
+              negativeNormal,
+              scene.camera.rightWC,
+              surfaceNormal
+            ),
+            scene.light.direction
+          );
+        });
+        //Sandcastle_End
+      };
+      if (typeof Cesium !== "undefined") {
+        window.startupCalled = true;
+        window.startup(Cesium).catch((error) => {
+          "use strict";
+          console.error(error);
+        });
+        Sandcastle.finishedLoading();
+      }
+    </script>
+  </body>
+</html>
diff --git "a/Apps/Sandcastle/gallery/Globe Materials \342\200\223 Water Mask Elevation Map.jpg" "b/Apps/Sandcastle/gallery/Globe Materials \342\200\223 Water Mask Elevation Map.jpg"
new file mode 100644
index 000000000000..c6750e9243d6
Binary files /dev/null and "b/Apps/Sandcastle/gallery/Globe Materials \342\200\223 Water Mask Elevation Map.jpg" differ
diff --git a/Apps/Sandcastle/gallery/Globe Materials.html b/Apps/Sandcastle/gallery/Globe Materials.html
index c87eae1e22c7..a957d77116bb 100644
--- a/Apps/Sandcastle/gallery/Globe Materials.html	
+++ b/Apps/Sandcastle/gallery/Globe Materials.html	
@@ -7,7 +7,7 @@
       name="viewport"
       content="width=device-width, initial-scale=1, maximum-scale=1, minimum-scale=1, user-scalable=no"
     />
-    <meta name="description" content="Apply materials to the globe." />
+    <meta name="description" content="Apply an elevation map to the globe." />
     <meta name="cesium-sandcastle-labels" content="Showcases" />
     <title>Cesium Demo</title>
     <script type="text/javascript" src="../Sandcastle-header.js"></script>
diff --git a/Apps/Sandcastle/gallery/High Dynamic Range.html b/Apps/Sandcastle/gallery/High Dynamic Range.html
index 597ab24155eb..4f1f3cb88ebd 100644
--- a/Apps/Sandcastle/gallery/High Dynamic Range.html	
+++ b/Apps/Sandcastle/gallery/High Dynamic Range.html	
@@ -24,10 +24,36 @@
   >
     <style>
       @import url(../templates/bucket.css);
+
+      #toolbar {
+        background: rgba(42, 42, 42, 0.8);
+        padding: 4px;
+        border-radius: 4px;
+      }
+
+      #toolbar input {
+        vertical-align: middle;
+        padding-top: 2px;
+        padding-bottom: 2px;
+      }
     </style>
     <div id="cesiumContainer" class="fullSize"></div>
     <div id="loadingOverlay"><h1>Loading...</h1></div>
-    <div id="toolbar"></div>
+    <div id="toolbar">
+      <div id="hdr-toggle"></div>
+      <span>Tonemap</span>
+      <span id="tonemap-select"></span>
+      <br />
+      <span>Exposure</span>
+      <input
+        type="range"
+        min="0.1"
+        max="10.0"
+        step="0.1"
+        data-bind="value: exposure, valueUpdate: 'input'"
+      />
+      <input type="text" size="5" data-bind="value: exposure" />
+    </div>
     <script id="cesium_sandcastle_script">
       window.startup = async function (Cesium) {
         "use strict";
@@ -35,31 +61,83 @@
         const viewer = new Cesium.Viewer("cesiumContainer", {
           terrain: Cesium.Terrain.fromWorldTerrain(),
           shadows: true,
+          timeline: false,
+          animation: false,
+          geocoder: false,
+          sceneModePicker: false,
+          baseLayerPicker: false,
         });
 
         if (!viewer.scene.highDynamicRangeSupported) {
           window.alert("This browser does not support high dynamic range.");
         }
 
-        viewer.scene.camera.setView({
-          destination: new Cesium.Cartesian3(
-            -1915097.7863741855,
-            -4783356.851539908,
-            3748887.43462683
-          ),
-          orientation: new Cesium.HeadingPitchRoll(
-            6.166004548388564,
-            -0.043242401760068994,
-            0.002179961955988574
-          ),
-          endTransform: Cesium.Matrix4.IDENTITY,
-        });
-
         viewer.scene.highDynamicRange = true;
 
-        Sandcastle.addToggleButton("HDR", true, function (checked) {
-          viewer.scene.highDynamicRange = checked;
-        });
+        Sandcastle.addToggleButton(
+          "HDR",
+          true,
+          function (checked) {
+            viewer.scene.highDynamicRange = checked;
+          },
+          "hdr-toggle"
+        );
+
+        const toneMapOptions = [
+          {
+            text: "PBR Neutral",
+            onselect: function () {
+              viewer.scene.postProcessStages.tonemapper =
+                Cesium.Tonemapper.PBR_NEUTRAL;
+            },
+          },
+          {
+            text: "Aces",
+            onselect: function () {
+              viewer.scene.postProcessStages.tonemapper =
+                Cesium.Tonemapper.ACES;
+            },
+          },
+          {
+            text: "Reinhard",
+            onselect: function () {
+              viewer.scene.postProcessStages.tonemapper =
+                Cesium.Tonemapper.REINHARD;
+            },
+          },
+          {
+            text: "Modified_Reinhard",
+            onselect: function () {
+              viewer.scene.postProcessStages.tonemapper =
+                Cesium.Tonemapper.MODIFIED_REINHARD;
+            },
+          },
+          {
+            text: "Filmic",
+            onselect: function () {
+              viewer.scene.postProcessStages.tonemapper =
+                Cesium.Tonemapper.FILMIC;
+            },
+          },
+        ];
+        Sandcastle.addDefaultToolbarMenu(toneMapOptions, "tonemap-select");
+
+        const viewModel = {
+          exposure: 1,
+        };
+        // Convert the viewModel members into knockout observables.
+        Cesium.knockout.track(viewModel);
+        // Bind the viewModel to the DOM elements of the UI that call for it.
+        const toolbar = document.getElementById("toolbar");
+        Cesium.knockout.applyBindings(viewModel, toolbar);
+
+        Cesium.knockout
+          .getObservable(viewModel, "exposure")
+          .subscribe(function (newValue) {
+            viewer.scene.postProcessStages.exposure = Number.parseFloat(
+              newValue
+            );
+          });
 
         const url =
           "../../SampleData/models/DracoCompressed/CesiumMilkTruck.gltf";
@@ -86,7 +164,46 @@
             uri: url,
             scale: scale,
           },
-        }); //Sandcastle_End
+        });
+
+        // set up canyon view
+        viewer.scene.camera.setView({
+          destination: new Cesium.Cartesian3(
+            -1915097.7863741855,
+            -4783356.851539908,
+            3748887.43462683
+          ),
+          orientation: new Cesium.HeadingPitchRoll(
+            6.166004548388564,
+            -0.043242401760068994,
+            0.002179961955988574
+          ),
+          endTransform: Cesium.Matrix4.IDENTITY,
+        });
+        // set time so the sun is overhead
+        viewer.clock.currentTime = new Cesium.JulianDate(2460550, 21637);
+
+        viewer.scene.debugShowFramesPerSecond = true;
+        // override the default home location to return to the start
+        viewer.homeButton.viewModel.command.beforeExecute.addEventListener(
+          (e) => {
+            e.cancel = true;
+            viewer.scene.camera.setView({
+              destination: new Cesium.Cartesian3(
+                -1915097.7863741855,
+                -4783356.851539908,
+                3748887.43462683
+              ),
+              orientation: new Cesium.HeadingPitchRoll(
+                6.166004548388564,
+                -0.043242401760068994,
+                0.002179961955988574
+              ),
+              endTransform: Cesium.Matrix4.IDENTITY,
+            });
+          }
+        );
+        //Sandcastle_End
       };
       if (typeof Cesium !== "undefined") {
         window.startupCalled = true;
diff --git a/Apps/Sandcastle/gallery/I3S Building Scene Layer.html b/Apps/Sandcastle/gallery/I3S Building Scene Layer.html
index 06de162a80fc..eaf58aada313 100644
--- a/Apps/Sandcastle/gallery/I3S Building Scene Layer.html	
+++ b/Apps/Sandcastle/gallery/I3S Building Scene Layer.html	
@@ -56,7 +56,6 @@ <h1>Loading...</h1>
           animation: false,
           timeline: false,
           orderIndependentTranslucency: false,
-          msaaSamples: 4, // enables multisample antialiasing for improved visual quality
         });
 
         // More datasets to tour can be added here...
diff --git a/Apps/Sandcastle/gallery/Japan Buildings.html b/Apps/Sandcastle/gallery/Japan Buildings.html
index 5534dd276bdf..c767e78b5860 100644
--- a/Apps/Sandcastle/gallery/Japan Buildings.html	
+++ b/Apps/Sandcastle/gallery/Japan Buildings.html	
@@ -45,7 +45,6 @@
           sceneModePicker: false,
           animation: false,
           timeline: false,
-          msaaSamples: 4,
         });
         const scene = viewer.scene;
         scene.globe.depthTestAgainstTerrain = true;
diff --git a/Apps/Sandcastle/gallery/Star Burst.html b/Apps/Sandcastle/gallery/Star Burst.html
index ba67dfb41de9..539b432f3e28 100644
--- a/Apps/Sandcastle/gallery/Star Burst.html	
+++ b/Apps/Sandcastle/gallery/Star Burst.html	
@@ -320,7 +320,7 @@
 
           // Remove the star burst if the mouse exits the screen space circle.
           // If the mouse is inside the circle, show the label of the billboard the mouse is hovering over.
-          const screenPosition = Cesium.SceneTransforms.wgs84ToWindowCoordinates(
+          const screenPosition = Cesium.SceneTransforms.worldToWindowCoordinates(
             scene,
             starBurstState.center
           );
diff --git a/Apps/Sandcastle/gallery/glTF PBR Extensions.html b/Apps/Sandcastle/gallery/glTF PBR Extensions.html
index 44b5dbc9f4d4..3029425bd1de 100644
--- a/Apps/Sandcastle/gallery/glTF PBR Extensions.html	
+++ b/Apps/Sandcastle/gallery/glTF PBR Extensions.html	
@@ -47,8 +47,6 @@
           );
         }
 
-        scene.msaaSamples = 4;
-
         const height = 20.0;
         const hpr = new Cesium.HeadingPitchRoll(0.0, 0.0, 0.0);
         const origin = Cesium.Cartesian3.fromDegrees(
diff --git a/CHANGES.md b/CHANGES.md
index fe8be5370f47..fd7d009a4a94 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,33 +1,57 @@
 # Change Log
 
-### 1.121 - 2024-09-01
+### 1.122 - 2024-10-01
 
 #### @cesium/engine
 
 ##### Additions :tada:
 
-- Made the `time` parameter optional for `Property`, using `JulianDate.now()` as default. [#12099](https://github.com/CesiumGS/cesium/pull/12099)
+- Added `enableVerticalExaggeration` option to models. Set this value to `false` to prevent model exaggeration when `Scene.verticalExaggeration` is set to a value other than `1.0`. [#12141](https://github.com/CesiumGS/cesium/pull/12141)
+- Added `CallbackPositionProperty` to allow lazy entity position evaluation. [#12170](https://github.com/CesiumGS/cesium/pull/12170)
+
+##### Fixes :wrench:
+
+- Use first geometryBuffer if no best match found in I3SNode [#12132](https://github.com/CesiumGS/cesium/pull/12132)
+- Update type definitions to allow undefined for optional parameters [#12193](https://github.com/CesiumGS/cesium/pull/12193)
+- Fixed noise in ambient occlusion post process. [#12201](https://github.com/CesiumGS/cesium/pull/12201)
+
+### 1.121.1 - 2024-09-04
+
+This is an npm-only release to extra source maps included in 1.121
+
+### 1.121 - 2024-09-03
 
+#### @cesium/engine
+
+##### Additions :tada:
+
+- Enable MSAA by default with 4 samples. To turn MSAA off set `scene.msaaSamples = 1` [#12158](https://github.com/CesiumGS/cesium/pull/12158)
+- Expose the `tonemapper` property of `PostProcessStageCollection` to allow changing the tonemap used when HDR is turned on. This defaults to the [PBR Neutral Tonemap from Khronos](https://github.com/KhronosGroup/ToneMapping/tree/main/PBR_Neutral) [#12160](https://github.com/CesiumGS/cesium/pull/12160)
+  - The enum `Tonemapper` contains the list of valid tonemap options to use with the `tonemapper` setting
+- Expose the `exposure` property of `PostProcessStageCollection` to allow changing the exposure used for the current HDR tonemap [#12160](https://github.com/CesiumGS/cesium/pull/12160)
+- Added `WaterMask` globe material, which visualizes areas of water or land based on the terrain's water mask. [#12149](https://github.com/CesiumGS/cesium/pull/12149)
+- Made the `time` parameter optional for `Property`, using `JulianDate.now()` as default. [#12099](https://github.com/CesiumGS/cesium/pull/12099)
 - Exposes `ScreenSpaceCameraController.zoomFactor` to allow adjusting the zoom factor (speed). [#9145](https://github.com/CesiumGS/cesium/pull/9145)
 
 ##### Fixes :wrench:
 
-- Update CameraEventAggregator to only trigger events for the currently held modifier while dragging. Events are canceled for all modifiers when the mouse is lifted. [#11903](https://github.com/CesiumGS/cesium/pull/11903)
+- Update `CameraEventAggregator` to only trigger events for the currently held modifier while dragging. Events are canceled for all modifiers when the mouse is lifted. [#11903](https://github.com/CesiumGS/cesium/pull/11903)
 - Fixed cube-mapping artifacts in image-based lighting. [#12100](https://github.com/CesiumGS/cesium/pull/12100)
 - Fixed specular reflection artifact in PBR direct lighting. [#12116](https://github.com/CesiumGS/cesium/pull/12116)
 - Added multiscattering terms to diffuse BRDF in image-based lighting. [#12118](https://github.com/CesiumGS/cesium/pull/12118)
-- Fixed CallbackProperty type not being present on entity position. [#12120](https://github.com/CesiumGS/cesium/pull/12120)
-- Additional TypeScript types export in package.json to assist some project configurations using Cesium. [#12122](https://github.com/CesiumGS/cesium/pull/12122)
+- Fixed `CallbackProperty` type not being present on entity position. [#12120](https://github.com/CesiumGS/cesium/pull/12120)
+- Additional TypeScript types export in `package.json` to assist some project configurations using Cesium. [#12122](https://github.com/CesiumGS/cesium/pull/12122)
 - Fixed documentation about default values for Label origins [#12139](https://github.com/CesiumGS/cesium/pull/12139)
 
 ##### Breaking Changes :mega:
 
+- Switched the default (non-HDR) tonemapping for models, atmosphere, and globe from ACES to [PBR Neutral Tonemap from Khronos](https://github.com/KhronosGroup/ToneMapping/tree/main/PBR_Neutral). The widens the gamut of possible colors, and provides more consistent color appearances across renderers. [#12160](https://github.com/CesiumGS/cesium/pull/12160)
+- Switched the default tonemapper when HDR is turned _on_ from ACES to [PBR Neutral Tonemap from Khronos](https://github.com/KhronosGroup/ToneMapping/tree/main/PBR_Neutral). To preserve the previous behavior set `viewer.scene.postProcessStages.tonemapper = Cesium.Tonemapper.ACES;` [#12160](https://github.com/CesiumGS/cesium/pull/12160)
+- `SceneTransforms.wgs84ToWindowCoordinates` has been removed. Use `SceneTransforms.worldToWindowCoordinates` instead.
+- `SceneTransforms.wgs84ToDrawingBufferCoordinates` has been removed. Use `SceneTransforms.worldToDrawingBufferCoordinates` instead.
 - Removed `jitter` option from `VoxelPrimitive.js`, `VoxelRenderResources.js`, and related test code in `VoxelPrimitiveSpec.js`. [#11913](https://github.com/CesiumGS/cesium/issues/11913)
-
 - Custom specular environment maps in `ImageBasedLighting` now require either a WebGL2 context or a WebGL1 context that supports the [`EXT_shader_texture_lod` extension](https://registry.khronos.org/webgl/extensions/EXT_shader_texture_lod/).
 
-- `ScreenSpaceCameraController._zoomFactor` replaced with public zoomFactor attribute.
-
 ### 1.120 - 2024-08-01
 
 #### @cesium/engine
diff --git a/CONTRIBUTORS.md b/CONTRIBUTORS.md
index 767e31f76f16..173c361b963a 100644
--- a/CONTRIBUTORS.md
+++ b/CONTRIBUTORS.md
@@ -5,6 +5,7 @@ See [CONTRIBUTING.md](CONTRIBUTING.md) for details on how to contribute to Cesiu
 ## [Corporate CLA](Documentation/Contributors/CLAs/corporate-contributor-license-agreement-v1.0.pdf)
 
 - [Analytical Graphics, Inc.](http://www.agi.com/)
+  - [Korey Hines](https://github.com/devkthines)
   - [Patrick Cozzi](https://github.com/pjcozzi)
   - [Kristian Calhoun](https://github.com/kristiancalhoun)
   - [Kevin Ring](https://github.com/kring)
@@ -166,6 +167,7 @@ See [CONTRIBUTING.md](CONTRIBUTING.md) for details on how to contribute to Cesiu
   - [jjspace](https://github.com/jjspace)
   - [Siddhesh Ranade](https://github.com/siddheshranade)
   - [Adam Morris](https://github.com/weegeekps)
+  - [Luke McKinstry](https://github.com/lukemckinstry)
 - [Northrop Grumman](http://www.northropgrumman.com)
   - [Joseph Stein](https://github.com/nahgrin)
 - [EOX IT Services GmbH](https://eox.at)
@@ -196,6 +198,8 @@ See [CONTRIBUTING.md](CONTRIBUTING.md) for details on how to contribute to Cesiu
 - [T2 Software](http://t2.com.tr/)
   - [Hüseyin ATEŞ](https://github.com/ateshuseyin)
   - [İbrahim Furkan Aygar](https://github.com/furkanaygar)
+- MSA
+  - [Timothy Eichfeld](https://github.com/timeichfeld-msa)
 - [EMapGis](http://emapgis.com)
   - [IKangXu](https://github.com/IKangXu)
   - [EMapGIS](https://github.com/EMapGIS)
@@ -405,5 +409,6 @@ See [CONTRIBUTING.md](CONTRIBUTING.md) for details on how to contribute to Cesiu
 - [Levi Montgomery](https://github.com/Levi-Montgomery)
 - [Brandon Berisford](https://github.com/BeyondBelief96)
 - [Jay Yong](https://github.com/Alforoan)
-- [Adam Wirth](https://https://github.com/adamwirth)
-
+- [Lawrence Owen](https://github.com/ljowen)
+- [Javier Sanchez](https://github.com/jvrjsanchez)
+- [Jérôme Fayot](https://github.com/jfayot)
diff --git a/Documentation/Contributors/BuildGuide/README.md b/Documentation/Contributors/BuildGuide/README.md
index df4fa912da65..1c3075bf371e 100644
--- a/Documentation/Contributors/BuildGuide/README.md
+++ b/Documentation/Contributors/BuildGuide/README.md
@@ -21,13 +21,19 @@
     npm install
    ```
 
-3. Start the [server](#development-server)
+3. Build the project
+
+   ```bash
+   npm run build
+   ```
+
+4. Start the [server](#development-server)
 
    ```bash
    npm start
    ```
 
-4. Navigate to : [`http://localhost:8080/`](http://localhost:8080)
+5. Navigate to : [`http://localhost:8080/`](http://localhost:8080)
 
 ---
 
@@ -61,8 +67,13 @@ Cesium uses [npm modules](https://docs.npmjs.com/getting-started/what-is-npm) fo
 npm install
 ```
 
-Cesium ships with a simple HTTP server for testing.
-Once all modules have been installed, run `npm start` to use it:
+Cesium ships with a simple HTTP server for testing. Once all modules have been installed, run `npm run build` to build the project:
+
+```bash
+npm run build
+```
+
+Then, run the development server:
 
 ```bash
 npm start
diff --git a/Documentation/Contributors/ReleaseGuide/README.md b/Documentation/Contributors/ReleaseGuide/README.md
index 43cb9175713a..7a6cb7b11309 100644
--- a/Documentation/Contributors/ReleaseGuide/README.md
+++ b/Documentation/Contributors/ReleaseGuide/README.md
@@ -8,7 +8,7 @@ There is no release manager; instead, our community shares the responsibility. A
 
 1. Check for any outdated dependencies with `npm outdated`.
 2. If one or more dependencies are outdated, checkout a new branch and run `npm install <packagename>@latest` for each package to increment the version.
-3. Verify each update. If an update can be resolved, open a PR with your changes. If an update is incompatible, open an issue.
+3. Verify each update. If an update can be resolved, open a PR with your changes. If an update is incompatible, open an issue. Check the [`dependencies` label](https://github.com/CesiumGS/cesium/issues?q=is%3Aissue+is%3Aopen+label%3Adependencies) for any open issues pinning versions.
 4. Check the [`priority - next release` issues and PRs](https://github.com/CesiumGS/cesium/labels/priority%20-%20next%20release). If there are any outstanding items, post a message to the `#cesiumjs` channel in Slack to figure out what needs to be addressed before we can release.
 5. Ensure you've generated valid [end to end testing snapshots](../TestingGuide/README.md) against a previous release tag with `npm run test-e2e-update`.
 
@@ -22,10 +22,18 @@ There is no release manager; instead, our community shares the responsibility. A
 4. Ensure you've generated valid [end to end testing snapshots](../TestingGuide/README.md) against a previous release tag with `npm run test-e2e-update`.
 5. Pull down the latest `main` branch and run `npm install`.
 6. Update the Cesium ion demo token in `Ion.js` with a new token from the CesiumJS ion team account with read and geocode permissions. These tokens are named like this: `1.85 Release - Delete on November 1st, 2021`. Delete the token from 2 releases ago.
-7. Update the ArcGIS Developer API key in `ArcGisMapService.js` with a new API key from the CesiumJS ArcGIS Developer account. These API keys are named like this: `1.85 Release - Delete on November 1st, 2021`. Delete the API key from the last release.
+7. Update the ArcGIS Developer API key in `ArcGisMapService.js` with a new API key from the [CesiumJS ArcGIS Developer](https://links.esri.com/agol-sign-in) account. These API keys are named like this: `1.85 Release - Delete on November 1st, 2021`. Delete the API key from the last release.
+   1. Sign in with LastPass
+   2. Go to Content at the top
+   3. Click "New Item" -> Developer Credentials -> API Key credentials
+   4. Set the expiration date to the day after the next release (no referrer URLs)
+   5. Only turn on "Basemaps" permissions
+   6. Skip adding items
+   7. Set the title and copy the API key on the last screen
+   8. Open the previous release's item and Delete it
 8. Proofread [`CHANGES.md`](../../../CHANGES.md) with the date of the release. Adjust the order of changes so that prominent/popular changes come first. Ensure each change is in the section for the relevant workspace.
-9. Based on `CHANGES.md`, update each workspace version following the rules of [semantic versioning](https://semver.org/), e.g.,  
-   `npm version minor -w @cesium/engine --no-git-tag-version`.  
+9. Based on `CHANGES.md`, update each workspace version following the rules of [semantic versioning](https://semver.org/), e.g.,
+   `npm version minor -w @cesium/engine --no-git-tag-version`.
    Changes in one workspace may require version updates in other workspaces that depend on it. For example, if `CHANGES.md` reports changes in `@cesium/engine` only, the version for `@cesium/widgets` should also be incremented to reflect the updated dependency.
 10. Update the version in `package.json` to match, e.g. `1.115.0` -> `1.116.0`.
 11. Commit these changes.
@@ -45,8 +53,8 @@ There is no release manager; instead, our community shares the responsibility. A
 25. Push your commits to main
     - `git push`
 26. Create and push a [tag](https://git-scm.com/book/en/v2/Git-Basics-Tagging), e.g.,
-    - `git tag -a 1.1 -m "1.1 release"`
-    - `git push origin 1.1` (this assumes origin is the primary cesium repository, do not use `git push --tags` as it pushes all tags from all remotes you have on your system.)
+    - `git tag -a 1.121 -m "1.121 release"`
+    - `git push origin 1.121` (this assumes origin is the primary cesium repository, do not use `git push --tags` as it pushes all tags from all remotes you have on your system.)
 27. Publish the release zip file to GitHub
     - https://github.com/CesiumGS/cesium/releases/new
     - Select the tag you use pushed
diff --git a/Specs/createScene.js b/Specs/createScene.js
index 93e87b42406a..619ec4c6f4a8 100644
--- a/Specs/createScene.js
+++ b/Specs/createScene.js
@@ -49,6 +49,13 @@ function createScene(options) {
   const scene = new Scene(options);
   scene.highDynamicRange = false;
 
+  if (
+    scene.context.drawingBufferWidth <= 2 ||
+    scene.context.drawingBufferHeight <= 2
+  ) {
+    scene.msaaSamples = 1;
+  }
+
   if (!!window.webglValidation) {
     const context = scene.context;
     context.validateShaderProgram = true;
diff --git a/ThirdParty.json b/ThirdParty.json
index a619b37b99a7..b0ff49d7e9ae 100644
--- a/ThirdParty.json
+++ b/ThirdParty.json
@@ -4,7 +4,7 @@
     "license": [
       "MIT"
     ],
-    "version": "23.1.3",
+    "version": "25.0.0",
     "url": "https://www.npmjs.com/package/@tweenjs/tween.js"
   },
   {
@@ -12,7 +12,7 @@
     "license": [
       "BSD-3-Clause"
     ],
-    "version": "2.7.48",
+    "version": "2.7.52",
     "url": "https://www.npmjs.com/package/@zip.js/zip.js"
   },
   {
@@ -158,7 +158,7 @@
     "license": [
       "BSD-3-Clause"
     ],
-    "version": "7.3.2",
+    "version": "7.4.0",
     "url": "https://www.npmjs.com/package/protobufjs"
   },
   {
@@ -166,7 +166,7 @@
     "license": [
       "MIT"
     ],
-    "version": "4.0.0",
+    "version": "4.0.1",
     "url": "https://www.npmjs.com/package/rbush"
   },
   {
diff --git a/package.json b/package.json
index e3a813f1e087..476a98470f69 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "cesium",
-  "version": "1.120.0",
+  "version": "1.121.1",
   "description": "CesiumJS is a JavaScript library for creating 3D globes and 2D maps in a web browser without a plugin.",
   "homepage": "http://cesium.com/cesiumjs/",
   "license": "Apache-2.0",
@@ -51,13 +51,13 @@
     "./Specs/**/*"
   ],
   "dependencies": {
-    "@cesium/engine": "^10.1.0",
-    "@cesium/widgets": "^7.1.0"
+    "@cesium/engine": "^11.0.0",
+    "@cesium/widgets": "^8.0.0"
   },
   "devDependencies": {
     "@playwright/test": "^1.41.1",
     "chokidar": "^3.5.3",
-    "cloc": "^2.0.0-cloc",
+    "cloc": "^2.2.0-cloc",
     "compression": "^1.7.4",
     "esbuild": "^0.23.0",
     "eslint": "^9.1.1",
diff --git a/packages/engine/Source/Core/Geometry.js b/packages/engine/Source/Core/Geometry.js
index d9e6873a919a..bbde3c60b1d0 100644
--- a/packages/engine/Source/Core/Geometry.js
+++ b/packages/engine/Source/Core/Geometry.js
@@ -104,8 +104,6 @@ function Geometry(options) {
    *
    * @type GeometryAttributes
    *
-   * @default undefined
-   *
    *
    * @example
    * geometry.attributes.position = new Cesium.GeometryAttribute({
@@ -123,7 +121,7 @@ function Geometry(options) {
    * Optional index data that - along with {@link Geometry#primitiveType} -
    * determines the primitives in the geometry.
    *
-   * @type {Array}
+   * @type {Array|undefined}
    *
    * @default undefined
    */
@@ -133,9 +131,9 @@ function Geometry(options) {
    * The type of primitives in the geometry.  This is most often {@link PrimitiveType.TRIANGLES},
    * but can varying based on the specific geometry.
    *
-   * @type PrimitiveType
+   * @type {PrimitiveType|undefined}
    *
-   * @default undefined
+   * @default PrimitiveType.TRIANGLES
    */
   this.primitiveType = defaultValue(
     options.primitiveType,
@@ -146,7 +144,7 @@ function Geometry(options) {
    * An optional bounding sphere that fully encloses the geometry.  This is
    * commonly used for culling.
    *
-   * @type BoundingSphere
+   * @type {BoundingSphere|undefined}
    *
    * @default undefined
    */
diff --git a/packages/engine/Source/Core/GeometryAttribute.js b/packages/engine/Source/Core/GeometryAttribute.js
index 18c27af5d07e..91713c415120 100644
--- a/packages/engine/Source/Core/GeometryAttribute.js
+++ b/packages/engine/Source/Core/GeometryAttribute.js
@@ -11,10 +11,10 @@ import DeveloperError from "./DeveloperError.js";
  * @constructor
  *
  * @param {object} [options] Object with the following properties:
- * @param {ComponentDatatype} [options.componentDatatype] The datatype of each component in the attribute, e.g., individual elements in values.
- * @param {number} [options.componentsPerAttribute] A number between 1 and 4 that defines the number of components in an attributes.
+ * @param {ComponentDatatype} options.componentDatatype The datatype of each component in the attribute, e.g., individual elements in values.
+ * @param {number} options.componentsPerAttribute A number between 1 and 4 that defines the number of components in an attributes.
  * @param {boolean} [options.normalize=false] When <code>true</code> and <code>componentDatatype</code> is an integer format, indicate that the components should be mapped to the range [0, 1] (unsigned) or [-1, 1] (signed) when they are accessed as floating-point for rendering.
- * @param {number[]|Int8Array|Uint8Array|Int16Array|Uint16Array|Int32Array|Uint32Array|Float32Array|Float64Array} [options.values] The values for the attributes stored in a typed array.
+ * @param {number[]|Int8Array|Uint8Array|Int16Array|Uint16Array|Int32Array|Uint32Array|Float32Array|Float64Array} options.values The values for the attributes stored in a typed array.
  *
  * @exception {DeveloperError} options.componentsPerAttribute must be between 1 and 4.
  *
@@ -66,7 +66,6 @@ function GeometryAttribute(options) {
    *
    * @type {ComponentDatatype}
    *
-   * @default undefined
    */
   this.componentDatatype = options.componentDatatype;
 
@@ -77,8 +76,6 @@ function GeometryAttribute(options) {
    *
    * @type {number}
    *
-   * @default undefined
-   *
    * @example
    * attribute.componentDatatype = Cesium.ComponentDatatype.FLOAT;
    * attribute.componentsPerAttribute = 3;
@@ -122,8 +119,6 @@ function GeometryAttribute(options) {
    *
    * @type {number[]|Int8Array|Uint8Array|Int16Array|Uint16Array|Int32Array|Uint32Array|Float32Array|Float64Array}
    *
-   * @default undefined
-   *
    * @example
    * attribute.componentDatatype = Cesium.ComponentDatatype.FLOAT;
    * attribute.componentsPerAttribute = 3;
diff --git a/packages/engine/Source/Core/GeometryAttributes.js b/packages/engine/Source/Core/GeometryAttributes.js
index a681ded710bd..522d76dd2ed5 100644
--- a/packages/engine/Source/Core/GeometryAttributes.js
+++ b/packages/engine/Source/Core/GeometryAttributes.js
@@ -19,7 +19,7 @@ function GeometryAttributes(options) {
    * 64-bit floating-point (for precision).  3 components per attribute.
    * </p>
    *
-   * @type GeometryAttribute
+   * @type {GeometryAttribute|undefined}
    *
    * @default undefined
    */
@@ -31,7 +31,7 @@ function GeometryAttributes(options) {
    * 32-bit floating-point.  3 components per attribute.
    * </p>
    *
-   * @type GeometryAttribute
+   * @type {GeometryAttribute|undefined}
    *
    * @default undefined
    */
@@ -43,7 +43,7 @@ function GeometryAttributes(options) {
    * 32-bit floating-point.  2 components per attribute
    * </p>
    *
-   * @type GeometryAttribute
+   * @type {GeometryAttribute|undefined}
    *
    * @default undefined
    */
@@ -55,7 +55,7 @@ function GeometryAttributes(options) {
    * 32-bit floating-point.  3 components per attribute.
    * </p>
    *
-   * @type GeometryAttribute
+   * @type {GeometryAttribute|undefined}
    *
    * @default undefined
    */
@@ -67,7 +67,7 @@ function GeometryAttributes(options) {
    * 32-bit floating-point.  3 components per attribute.
    * </p>
    *
-   * @type GeometryAttribute
+   * @type {GeometryAttribute|undefined}
    *
    * @default undefined
    */
@@ -79,7 +79,7 @@ function GeometryAttributes(options) {
    * 8-bit unsigned integer. 4 components per attribute.
    * </p>
    *
-   * @type GeometryAttribute
+   * @type {GeometryAttribute|undefined}
    *
    * @default undefined
    */
diff --git a/packages/engine/Source/Core/GeometryInstance.js b/packages/engine/Source/Core/GeometryInstance.js
index 572d9b81ef68..da62fe0f302f 100644
--- a/packages/engine/Source/Core/GeometryInstance.js
+++ b/packages/engine/Source/Core/GeometryInstance.js
@@ -62,7 +62,6 @@ function GeometryInstance(options) {
    *
    * @type Geometry
    *
-   * @default undefined
    */
   this.geometry = options.geometry;
 
@@ -83,7 +82,7 @@ function GeometryInstance(options) {
   /**
    * User-defined object returned when the instance is picked or used to get/set per-instance attributes.
    *
-   * @type {object}
+   * @type {object|undefined}
    *
    * @default undefined
    *
@@ -105,7 +104,7 @@ function GeometryInstance(options) {
    *
    * @type {object}
    *
-   * @default undefined
+   * @default {}
    */
   this.attributes = defaultValue(options.attributes, {});
 
diff --git a/packages/engine/Source/Core/GeometryInstanceAttribute.js b/packages/engine/Source/Core/GeometryInstanceAttribute.js
index f857326cf747..240ced324bd4 100644
--- a/packages/engine/Source/Core/GeometryInstanceAttribute.js
+++ b/packages/engine/Source/Core/GeometryInstanceAttribute.js
@@ -68,7 +68,6 @@ function GeometryInstanceAttribute(options) {
    *
    * @type ComponentDatatype
    *
-   * @default undefined
    */
   this.componentDatatype = options.componentDatatype;
 
@@ -79,8 +78,6 @@ function GeometryInstanceAttribute(options) {
    *
    * @type {number}
    *
-   * @default undefined
-   *
    * @example
    * show : new Cesium.GeometryInstanceAttribute({
    *   componentDatatype : Cesium.ComponentDatatype.UNSIGNED_BYTE,
@@ -123,8 +120,6 @@ function GeometryInstanceAttribute(options) {
    *
    * @type {number[]}
    *
-   * @default undefined
-   *
    * @example
    * show : new Cesium.GeometryInstanceAttribute({
    *   componentDatatype : Cesium.ComponentDatatype.UNSIGNED_BYTE,
diff --git a/packages/engine/Source/Core/GoogleEarthEnterpriseMetadata.js b/packages/engine/Source/Core/GoogleEarthEnterpriseMetadata.js
index 4cbb8c58a9fa..50dc850c7e2c 100644
--- a/packages/engine/Source/Core/GoogleEarthEnterpriseMetadata.js
+++ b/packages/engine/Source/Core/GoogleEarthEnterpriseMetadata.js
@@ -54,7 +54,7 @@ function GoogleEarthEnterpriseMetadata(resourceOrUrl) {
 
   /**
    * True if imagery is sent as a protocol buffer, false if sent as plain images. If undefined we will try both.
-   * @type {boolean}
+   * @type {boolean|undefined}
    * @default undefined
    */
   this.protoImagery = undefined;
diff --git a/packages/engine/Source/Core/Ion.js b/packages/engine/Source/Core/Ion.js
index 49476cca4456..baae7c0b52c7 100644
--- a/packages/engine/Source/Core/Ion.js
+++ b/packages/engine/Source/Core/Ion.js
@@ -4,7 +4,7 @@ import Resource from "./Resource.js";
 
 let defaultTokenCredit;
 const defaultAccessToken =
-  "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJqdGkiOiIxY2UxZDdkOS02YTJkLTQ2Y2EtYmMxNS03ZDI2NWQ1NzUzMjAiLCJpZCI6MjU5LCJpYXQiOjE3MjI1Mjg0MTl9.IMe1VGs-5blTCJJA1y76M8WNixMgms2C87kIkXQVcww";
+  "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJqdGkiOiIxMjY5YWQzZS04ZGIyLTRlMjEtYjcwNS1iYmY0NDNmN2E3ZjAiLCJpZCI6MjU5LCJpYXQiOjE3MjUzNzYwMzZ9.L0mzOLcquvnxOpG5DnqWQmivpRCwePDt3WAgzb8VlVA";
 /**
  * Default settings for accessing the Cesium ion API.
  *
diff --git a/packages/engine/Source/Core/OrthographicFrustum.js b/packages/engine/Source/Core/OrthographicFrustum.js
index e94dcb868101..2153564288b1 100644
--- a/packages/engine/Source/Core/OrthographicFrustum.js
+++ b/packages/engine/Source/Core/OrthographicFrustum.js
@@ -34,7 +34,7 @@ function OrthographicFrustum(options) {
 
   /**
    * The horizontal width of the frustum in meters.
-   * @type {number}
+   * @type {number|undefined}
    * @default undefined
    */
   this.width = options.width;
@@ -42,7 +42,7 @@ function OrthographicFrustum(options) {
 
   /**
    * The aspect ratio of the frustum's width to it's height.
-   * @type {number}
+   * @type {number|undefined}
    * @default undefined
    */
   this.aspectRatio = options.aspectRatio;
diff --git a/packages/engine/Source/Core/OrthographicOffCenterFrustum.js b/packages/engine/Source/Core/OrthographicOffCenterFrustum.js
index b99d0c5065bf..ad203f1570ca 100644
--- a/packages/engine/Source/Core/OrthographicOffCenterFrustum.js
+++ b/packages/engine/Source/Core/OrthographicOffCenterFrustum.js
@@ -40,7 +40,7 @@ function OrthographicOffCenterFrustum(options) {
 
   /**
    * The left clipping plane.
-   * @type {number}
+   * @type {number|undefined}
    * @default undefined
    */
   this.left = options.left;
@@ -48,7 +48,7 @@ function OrthographicOffCenterFrustum(options) {
 
   /**
    * The right clipping plane.
-   * @type {number}
+   * @type {number|undefined}
    * @default undefined
    */
   this.right = options.right;
@@ -56,7 +56,7 @@ function OrthographicOffCenterFrustum(options) {
 
   /**
    * The top clipping plane.
-   * @type {number}
+   * @type {number|undefined}
    * @default undefined
    */
   this.top = options.top;
@@ -64,7 +64,7 @@ function OrthographicOffCenterFrustum(options) {
 
   /**
    * The bottom clipping plane.
-   * @type {number}
+   * @type {number|undefined}
    * @default undefined
    */
   this.bottom = options.bottom;
diff --git a/packages/engine/Source/Core/PerspectiveFrustum.js b/packages/engine/Source/Core/PerspectiveFrustum.js
index 0442961c533f..451f4c9f0a49 100644
--- a/packages/engine/Source/Core/PerspectiveFrustum.js
+++ b/packages/engine/Source/Core/PerspectiveFrustum.js
@@ -41,7 +41,7 @@ function PerspectiveFrustum(options) {
    * The angle of the field of view (FOV), in radians.  This angle will be used
    * as the horizontal FOV if the width is greater than the height, otherwise
    * it will be the vertical FOV.
-   * @type {number}
+   * @type {number|undefined}
    * @default undefined
    */
   this.fov = options.fov;
@@ -52,7 +52,7 @@ function PerspectiveFrustum(options) {
 
   /**
    * The aspect ratio of the frustum's width to it's height.
-   * @type {number}
+   * @type {number|undefined}
    * @default undefined
    */
   this.aspectRatio = options.aspectRatio;
@@ -253,7 +253,7 @@ Object.defineProperties(PerspectiveFrustum.prototype, {
   /**
    * Gets the angle of the vertical field of view, in radians.
    * @memberof PerspectiveFrustum.prototype
-   * @type {number}
+   * @type {number|undefined}
    * @readonly
    * @default undefined
    */
diff --git a/packages/engine/Source/Core/PerspectiveOffCenterFrustum.js b/packages/engine/Source/Core/PerspectiveOffCenterFrustum.js
index 00339b199d60..9535202049e0 100644
--- a/packages/engine/Source/Core/PerspectiveOffCenterFrustum.js
+++ b/packages/engine/Source/Core/PerspectiveOffCenterFrustum.js
@@ -41,7 +41,7 @@ function PerspectiveOffCenterFrustum(options) {
 
   /**
    * Defines the left clipping plane.
-   * @type {number}
+   * @type {number|undefined}
    * @default undefined
    */
   this.left = options.left;
@@ -49,7 +49,7 @@ function PerspectiveOffCenterFrustum(options) {
 
   /**
    * Defines the right clipping plane.
-   * @type {number}
+   * @type {number|undefined}
    * @default undefined
    */
   this.right = options.right;
@@ -57,7 +57,7 @@ function PerspectiveOffCenterFrustum(options) {
 
   /**
    * Defines the top clipping plane.
-   * @type {number}
+   * @type {number|undefined}
    * @default undefined
    */
   this.top = options.top;
@@ -65,7 +65,7 @@ function PerspectiveOffCenterFrustum(options) {
 
   /**
    * Defines the bottom clipping plane.
-   * @type {number}
+   * @type {number|undefined}
    * @default undefined
    */
   this.bottom = options.bottom;
diff --git a/packages/engine/Source/DataSources/CallbackPositionProperty.js b/packages/engine/Source/DataSources/CallbackPositionProperty.js
new file mode 100644
index 000000000000..61909f995668
--- /dev/null
+++ b/packages/engine/Source/DataSources/CallbackPositionProperty.js
@@ -0,0 +1,173 @@
+import defaultValue from "../Core/defaultValue.js";
+import defined from "../Core/defined.js";
+import DeveloperError from "../Core/DeveloperError.js";
+import Event from "../Core/Event.js";
+import JulianDate from "../Core/JulianDate.js";
+import ReferenceFrame from "../Core/ReferenceFrame.js";
+import PositionProperty from "./PositionProperty.js";
+
+/**
+ * A {@link PositionProperty} whose value is lazily evaluated by a callback function.
+ *
+ * @alias CallbackPositionProperty
+ * @constructor
+ *
+ * @param {CallbackPositionProperty.Callback} callback The function to be called when the position property is evaluated.
+ * @param {boolean} isConstant <code>true</code> when the callback function returns the same value every time, <code>false</code> if the value will change.
+ * @param {ReferenceFrame} [referenceFrame=ReferenceFrame.FIXED] The reference frame in which the position is defined.
+ *
+ * @demo {@link https://sandcastle.cesium.com/index.html?src=Callback%20Position%20Property.html|Cesium Sandcastle Callback Position Property Demo}
+ */
+function CallbackPositionProperty(callback, isConstant, referenceFrame) {
+  this._callback = undefined;
+  this._isConstant = undefined;
+  this._referenceFrame = defaultValue(referenceFrame, ReferenceFrame.FIXED);
+  this._definitionChanged = new Event();
+  this.setCallback(callback, isConstant);
+}
+
+Object.defineProperties(CallbackPositionProperty.prototype, {
+  /**
+   * Gets a value indicating if this property is constant.
+   * @memberof CallbackPositionProperty.prototype
+   *
+   * @type {boolean}
+   * @readonly
+   */
+  isConstant: {
+    get: function () {
+      return this._isConstant;
+    },
+  },
+  /**
+   * Gets the event that is raised whenever the definition of this property changes.
+   * The definition is considered to have changed if a call to getValue would return
+   * a different result for the same time.
+   * @memberof CallbackPositionProperty.prototype
+   *
+   * @type {Event}
+   * @readonly
+   */
+  definitionChanged: {
+    get: function () {
+      return this._definitionChanged;
+    },
+  },
+  /**
+   * Gets the reference frame in which the position is defined.
+   * @memberof CallbackPositionProperty.prototype
+   * @type {ReferenceFrame}
+   * @default ReferenceFrame.FIXED;
+   */
+  referenceFrame: {
+    get: function () {
+      return this._referenceFrame;
+    },
+  },
+});
+
+const timeScratch = new JulianDate();
+
+/**
+ * Gets the value of the property at the provided time in the fixed frame.
+ *
+ * @param {JulianDate} [time=JulianDate.now()] The time for which to retrieve the value. If omitted, the current system time is used.
+ * @param {Cartesian3} [result] The object to store the value into, if omitted, a new instance is created and returned.
+ * @returns {Cartesian3 | undefined} The modified result parameter or a new instance if the result parameter was not supplied.
+ */
+CallbackPositionProperty.prototype.getValue = function (time, result) {
+  if (!defined(time)) {
+    time = JulianDate.now(timeScratch);
+  }
+  return this.getValueInReferenceFrame(time, ReferenceFrame.FIXED, result);
+};
+
+/**
+ * Sets the callback to be used.
+ *
+ * @param {CallbackPositionProperty.Callback} callback The function to be called when the property is evaluated.
+ * @param {boolean} isConstant <code>true</code> when the callback function returns the same value every time, <code>false</code> if the value will change.
+ */
+CallbackPositionProperty.prototype.setCallback = function (
+  callback,
+  isConstant
+) {
+  //>>includeStart('debug', pragmas.debug);
+  if (!defined(callback)) {
+    throw new DeveloperError("callback is required.");
+  }
+  if (!defined(isConstant)) {
+    throw new DeveloperError("isConstant is required.");
+  }
+  //>>includeEnd('debug');
+
+  const changed =
+    this._callback !== callback || this._isConstant !== isConstant;
+
+  this._callback = callback;
+  this._isConstant = isConstant;
+
+  if (changed) {
+    this._definitionChanged.raiseEvent(this);
+  }
+};
+
+/**
+ * Gets the value of the property at the provided time and in the provided reference frame.
+ *
+ * @param {JulianDate} time The time for which to retrieve the value.
+ * @param {ReferenceFrame} referenceFrame The desired referenceFrame of the result.
+ * @param {Cartesian3} [result] The object to store the value into, if omitted, a new instance is created and returned.
+ * @returns {Cartesian3 | undefined} The modified result parameter or a new instance if the result parameter was not supplied.
+ */
+CallbackPositionProperty.prototype.getValueInReferenceFrame = function (
+  time,
+  referenceFrame,
+  result
+) {
+  //>>includeStart('debug', pragmas.debug);
+  if (!defined(time)) {
+    throw new DeveloperError("time is required.");
+  }
+  if (!defined(referenceFrame)) {
+    throw new DeveloperError("referenceFrame is required.");
+  }
+  //>>includeEnd('debug');
+
+  const value = this._callback(time, result);
+
+  return PositionProperty.convertToReferenceFrame(
+    time,
+    value,
+    this._referenceFrame,
+    referenceFrame,
+    result
+  );
+};
+
+/**
+ * Compares this property to the provided property and returns
+ * <code>true</code> if they are equal, <code>false</code> otherwise.
+ *
+ * @param {Property} [other] The other property.
+ * @returns {boolean} <code>true</code> if left and right are equal, <code>false</code> otherwise.
+ */
+CallbackPositionProperty.prototype.equals = function (other) {
+  return (
+    this === other ||
+    (other instanceof CallbackPositionProperty &&
+      this._callback === other._callback &&
+      this._isConstant === other._isConstant &&
+      this._referenceFrame === other._referenceFrame)
+  );
+};
+
+/**
+ * A function that returns the value of the position property.
+ * @callback CallbackPositionProperty.Callback
+ *
+ * @param {JulianDate} [time=JulianDate.now()] The time for which to retrieve the value. If omitted, the current system time is used.
+ * @param {Cartesian3} [result] The object to store the value into. If omitted, the function must create and return a new instance.
+ * @returns {Cartesian3 | undefined} The modified result parameter, or a new instance if the result parameter was not supplied or is unsupported.
+ */
+export default CallbackPositionProperty;
diff --git a/packages/engine/Source/DataSources/ModelGraphics.js b/packages/engine/Source/DataSources/ModelGraphics.js
index 2c4f33792469..1814566bad1c 100644
--- a/packages/engine/Source/DataSources/ModelGraphics.js
+++ b/packages/engine/Source/DataSources/ModelGraphics.js
@@ -26,6 +26,7 @@ function createArticulationStagePropertyBag(value) {
  * @property {Property | boolean} [show=true] A boolean Property specifying the visibility of the model.
  * @property {Property | string | Resource} [uri] A string or Resource Property specifying the URI of the glTF asset.
  * @property {Property | number} [scale=1.0] A numeric Property specifying a uniform linear scale.
+ * @property {Property | boolean} [enableVerticalExaggeration=true] A boolean Property specifying if the model is exaggerated along the ellipsoid normal when {@link Scene.verticalExaggeration} is set to a value other than <code>1.0</code>.
  * @property {Property | number} [minimumPixelSize=0.0] A numeric Property specifying the approximate minimum pixel size of the model regardless of zoom.
  * @property {Property | number} [maximumScale] The maximum scale size of a model. An upper limit for minimumPixelSize.
  * @property {Property | boolean} [incrementallyLoadTextures=true] Determine if textures may continue to stream in after the model is loaded.
@@ -70,6 +71,10 @@ function ModelGraphics(options) {
   this._uriSubscription = undefined;
   this._scale = undefined;
   this._scaleSubscription = undefined;
+  this._hasVerticalExaggeration = undefined;
+  this._hasVerticalExaggerationSubscription = undefined;
+  this._enableVerticalExaggeration = undefined;
+  this._enableVerticalExaggerationSubscription = undefined;
   this._minimumPixelSize = undefined;
   this._minimumPixelSizeSubscription = undefined;
   this._maximumScale = undefined;
@@ -150,6 +155,16 @@ Object.defineProperties(ModelGraphics.prototype, {
    */
   scale: createPropertyDescriptor("scale"),
 
+  /**
+   * Gets or sets the boolean Property specifying if the model is exaggerated along the ellipsoid normal when {@link Scene.verticalExaggeration} is set to a value other than <code>1.0</code>.
+   * @memberof ModelGraphics.prototype
+   * @type {Property|undefined}
+   * @default true
+   */
+  enableVerticalExaggeration: createPropertyDescriptor(
+    "enableVerticalExaggeration"
+  ),
+
   /**
    * Gets or sets the numeric Property specifying the approximate minimum
    * pixel size of the model regardless of zoom. This can be used to ensure that
@@ -333,6 +348,7 @@ ModelGraphics.prototype.clone = function (result) {
   result.show = this.show;
   result.uri = this.uri;
   result.scale = this.scale;
+  result.enableVerticalExaggeration = this.enableVerticalExaggeration;
   result.minimumPixelSize = this.minimumPixelSize;
   result.maximumScale = this.maximumScale;
   result.incrementallyLoadTextures = this.incrementallyLoadTextures;
@@ -370,6 +386,10 @@ ModelGraphics.prototype.merge = function (source) {
   this.show = defaultValue(this.show, source.show);
   this.uri = defaultValue(this.uri, source.uri);
   this.scale = defaultValue(this.scale, source.scale);
+  this.enableVerticalExaggeration = defaultValue(
+    this.enableVerticalExaggeration,
+    source.enableVerticalExaggeration
+  );
   this.minimumPixelSize = defaultValue(
     this.minimumPixelSize,
     source.minimumPixelSize
diff --git a/packages/engine/Source/DataSources/ModelVisualizer.js b/packages/engine/Source/DataSources/ModelVisualizer.js
index 393345358aee..ab326dbc44c3 100644
--- a/packages/engine/Source/DataSources/ModelVisualizer.js
+++ b/packages/engine/Source/DataSources/ModelVisualizer.js
@@ -23,6 +23,7 @@ import Property from "./Property.js";
 import Cartographic from "../Core/Cartographic.js";
 
 const defaultScale = 1.0;
+const defaultEnableVerticalExaggeration = true;
 const defaultMinimumPixelSize = 0.0;
 const defaultIncrementallyLoadTextures = true;
 const defaultClampAnimations = true;
@@ -198,6 +199,13 @@ ModelVisualizer.prototype.update = function (time) {
       time,
       defaultScale
     );
+
+    model.enableVerticalExaggeration = Property.getValueOrDefault(
+      modelGraphics._enableVerticalExaggeration,
+      time,
+      defaultEnableVerticalExaggeration
+    );
+
     model.minimumPixelSize = Property.getValueOrDefault(
       modelGraphics._minimumPixelSize,
       time,
diff --git a/packages/engine/Source/DataSources/PathVisualizer.js b/packages/engine/Source/DataSources/PathVisualizer.js
index 8ae9a415fff1..6c99fc36815a 100644
--- a/packages/engine/Source/DataSources/PathVisualizer.js
+++ b/packages/engine/Source/DataSources/PathVisualizer.js
@@ -11,6 +11,7 @@ import TimeInterval from "../Core/TimeInterval.js";
 import Transforms from "../Core/Transforms.js";
 import PolylineCollection from "../Scene/PolylineCollection.js";
 import SceneMode from "../Scene/SceneMode.js";
+import CallbackPositionProperty from "./CallbackPositionProperty.js";
 import CompositePositionProperty from "./CompositePositionProperty.js";
 import ConstantPositionProperty from "./ConstantPositionProperty.js";
 import MaterialProperty from "./MaterialProperty.js";
@@ -135,6 +136,58 @@ function subSampleSampledProperty(
   return r;
 }
 
+function subSampleCallbackPositionProperty(
+  property,
+  start,
+  stop,
+  updateTime,
+  referenceFrame,
+  maximumStep,
+  startingIndex,
+  result
+) {
+  let tmp;
+  let i = 0;
+  let index = startingIndex;
+  let time = start;
+  let steppedOnNow =
+    !defined(updateTime) ||
+    JulianDate.lessThanOrEquals(updateTime, start) ||
+    JulianDate.greaterThanOrEquals(updateTime, stop);
+  while (JulianDate.lessThan(time, stop)) {
+    if (!steppedOnNow && JulianDate.greaterThanOrEquals(time, updateTime)) {
+      steppedOnNow = true;
+      tmp = property.getValueInReferenceFrame(
+        updateTime,
+        referenceFrame,
+        result[index]
+      );
+      if (defined(tmp)) {
+        result[index] = tmp;
+        index++;
+      }
+    }
+    tmp = property.getValueInReferenceFrame(
+      time,
+      referenceFrame,
+      result[index]
+    );
+    if (defined(tmp)) {
+      result[index] = tmp;
+      index++;
+    }
+    i++;
+    time = JulianDate.addSeconds(start, maximumStep * i, new JulianDate());
+  }
+  //Always sample stop.
+  tmp = property.getValueInReferenceFrame(stop, referenceFrame, result[index]);
+  if (defined(tmp)) {
+    result[index] = tmp;
+    index++;
+  }
+  return index;
+}
+
 function subSampleGenericProperty(
   property,
   start,
@@ -339,6 +392,17 @@ function reallySubSample(
       index,
       result
     );
+  } else if (property instanceof CallbackPositionProperty) {
+    index = subSampleCallbackPositionProperty(
+      property,
+      start,
+      stop,
+      updateTime,
+      referenceFrame,
+      maximumStep,
+      index,
+      result
+    );
   } else if (property instanceof CompositePositionProperty) {
     index = subSampleCompositeProperty(
       property,
diff --git a/packages/engine/Source/DataSources/PositionProperty.js b/packages/engine/Source/DataSources/PositionProperty.js
index 66a9c384b67a..17bce66ed195 100644
--- a/packages/engine/Source/DataSources/PositionProperty.js
+++ b/packages/engine/Source/DataSources/PositionProperty.js
@@ -14,6 +14,7 @@ import Transforms from "../Core/Transforms.js";
  * @constructor
  * @abstract
  *
+ * @see CallbackPositionProperty
  * @see CompositePositionProperty
  * @see ConstantPositionProperty
  * @see SampledPositionProperty
diff --git a/packages/engine/Source/Renderer/ShaderProgram.js b/packages/engine/Source/Renderer/ShaderProgram.js
index c3e5d067efb4..d9df800dc518 100644
--- a/packages/engine/Source/Renderer/ShaderProgram.js
+++ b/packages/engine/Source/Renderer/ShaderProgram.js
@@ -556,6 +556,13 @@ ShaderProgram.prototype._setUniforms = function (
     len = manualUniforms.length;
     for (i = 0; i < len; ++i) {
       const mu = manualUniforms[i];
+
+      //>>includeStart('debug', pragmas.debug);
+      if (!defined(uniformMap[mu.name])) {
+        throw new DeveloperError(`Unknown uniform: ${mu.name}`);
+      }
+      //>>includeEnd('debug');
+
       mu.value = uniformMap[mu.name]();
     }
   }
diff --git a/packages/engine/Source/Scene/ArcGisMapService.js b/packages/engine/Source/Scene/ArcGisMapService.js
index 0d48547786b3..0210f776e946 100644
--- a/packages/engine/Source/Scene/ArcGisMapService.js
+++ b/packages/engine/Source/Scene/ArcGisMapService.js
@@ -4,7 +4,7 @@ import Resource from "../Core/Resource.js";
 
 let defaultTokenCredit;
 const defaultAccessToken =
-  "AAPTxy8BH1VEsoebNVZXo8HurEOF051kAEKlhkOhBEc9BmTRbx8gaNqtBYKRq3vEnwSKnwUE1aRn2Siyo0gHWzzPwpJd-ZUeTyDgQZPqW8C6pXNLOE3bRO6-Jz3NFmp-qNquqGBQTATcCHbNsL-h9CPyMMPGsTcUvzPlIInazMfkWJNbFmqJeSzPj_1DHshXa0XCfkQn5mVxlF2dFt10Mq2bGo0HkpdpXwNQdoGwdphsLoU.AT1_CpQKgEim";
+  "AAPTxy8BH1VEsoebNVZXo8HurEOF051kAEKlhkOhBEc9BmSXu8_pRnGhnW6yZLct-ukUzbJaZRAVfnmUrxDcAu_FaFDIC3M57EwfRm_DuTw9D5oHdLBTYIMD3tpUeFsNDjHHqar5fb1FGIN9KIV1Gk64dNBmhHhuOHY8cq2IhI0XFLj2qnAlqtKnM-lLsO6JpHuHPVD799V1o9VFm9vMW6a66vEi8-e--2QzKQecPYiaq98.AT1_p4pHwb3n";
 /**
  * Default options for accessing the ArcGIS image tile service.
  *
diff --git a/packages/engine/Source/Scene/Globe.js b/packages/engine/Source/Scene/Globe.js
index a1452c96c61b..db02bc0f922f 100644
--- a/packages/engine/Source/Scene/Globe.js
+++ b/packages/engine/Source/Scene/Globe.js
@@ -979,7 +979,6 @@ Globe.prototype.beginFrame = function (frameState) {
   const tileProvider = surface.tileProvider;
   const terrainProvider = this.terrainProvider;
   const hasWaterMask =
-    this.showWaterEffect &&
     defined(terrainProvider) &&
     terrainProvider.hasWaterMask &&
     terrainProvider.hasWaterMask;
@@ -1034,6 +1033,7 @@ Globe.prototype.beginFrame = function (frameState) {
     tileProvider.zoomedOutOceanSpecularIntensity =
       mode === SceneMode.SCENE3D ? this._zoomedOutOceanSpecularIntensity : 0.0;
     tileProvider.hasWaterMask = hasWaterMask;
+    tileProvider.showWaterEffect = this.showWaterEffect;
     tileProvider.oceanNormalMap = this._oceanNormalMap;
     tileProvider.enableLighting = this.enableLighting;
     tileProvider.dynamicAtmosphereLighting = this.dynamicAtmosphereLighting;
diff --git a/packages/engine/Source/Scene/GlobeSurfaceShaderSet.js b/packages/engine/Source/Scene/GlobeSurfaceShaderSet.js
index a7a48d624b87..b0c4b8063b4f 100644
--- a/packages/engine/Source/Scene/GlobeSurfaceShaderSet.js
+++ b/packages/engine/Source/Scene/GlobeSurfaceShaderSet.js
@@ -109,6 +109,7 @@ GlobeSurfaceShaderSet.prototype.getShaderProgram = function (options) {
   const applyAlpha = options.applyAlpha;
   const applyDayNightAlpha = options.applyDayNightAlpha;
   const applySplit = options.applySplit;
+  const hasWaterMask = options.hasWaterMask;
   const showReflectiveOcean = options.showReflectiveOcean;
   const showOceanWaves = options.showOceanWaves;
   const enableLighting = options.enableLighting;
@@ -168,30 +169,31 @@ GlobeSurfaceShaderSet.prototype.getShaderProgram = function (options) {
     (applySaturation << 5) |
     (applyGamma << 6) |
     (applyAlpha << 7) |
-    (showReflectiveOcean << 8) |
-    (showOceanWaves << 9) |
-    (enableLighting << 10) |
-    (dynamicAtmosphereLighting << 11) |
-    (dynamicAtmosphereLightingFromSun << 12) |
-    (showGroundAtmosphere << 13) |
-    (perFragmentGroundAtmosphere << 14) |
-    (hasVertexNormals << 15) |
-    (useWebMercatorProjection << 16) |
-    (enableFog << 17) |
-    (quantization << 18) |
-    (applySplit << 19) |
-    (enableClippingPlanes << 20) |
-    (enableClippingPolygons << 21) |
-    (cartographicLimitRectangleFlag << 22) |
-    (imageryCutoutFlag << 23) |
-    (colorCorrect << 24) |
-    (highlightFillTile << 25) |
-    (colorToAlpha << 26) |
-    (hasGeodeticSurfaceNormals << 27) |
-    (hasExaggeration << 28) |
-    (showUndergroundColor << 29) |
-    (translucent << 30) |
-    (applyDayNightAlpha << 31);
+    (hasWaterMask << 8) |
+    (showReflectiveOcean << 9) |
+    (showOceanWaves << 10) |
+    (enableLighting << 11) |
+    (dynamicAtmosphereLighting << 12) |
+    (dynamicAtmosphereLightingFromSun << 13) |
+    (showGroundAtmosphere << 14) |
+    (perFragmentGroundAtmosphere << 15) |
+    (hasVertexNormals << 16) |
+    (useWebMercatorProjection << 17) |
+    (enableFog << 18) |
+    (quantization << 19) |
+    (applySplit << 20) |
+    (enableClippingPlanes << 21) |
+    (enableClippingPolygons << 22) |
+    (cartographicLimitRectangleFlag << 23) |
+    (imageryCutoutFlag << 24) |
+    (colorCorrect << 25) |
+    (highlightFillTile << 26) |
+    (colorToAlpha << 27) |
+    (hasGeodeticSurfaceNormals << 28) |
+    (hasExaggeration << 29) |
+    (showUndergroundColor << 30) |
+    (translucent << 31) |
+    (applyDayNightAlpha << 32);
 
   let currentClippingShaderState = 0;
   if (defined(clippingPlanes) && clippingPlanes.length > 0) {
@@ -279,6 +281,9 @@ GlobeSurfaceShaderSet.prototype.getShaderProgram = function (options) {
     if (applyDayNightAlpha) {
       fs.defines.push("APPLY_DAY_NIGHT_ALPHA");
     }
+    if (hasWaterMask) {
+      fs.defines.push("HAS_WATER_MASK");
+    }
     if (showReflectiveOcean) {
       fs.defines.push("SHOW_REFLECTIVE_OCEAN");
       vs.defines.push("SHOW_REFLECTIVE_OCEAN");
diff --git a/packages/engine/Source/Scene/GlobeSurfaceTileProvider.js b/packages/engine/Source/Scene/GlobeSurfaceTileProvider.js
index ab4ec1e9a9e7..385a602b7307 100644
--- a/packages/engine/Source/Scene/GlobeSurfaceTileProvider.js
+++ b/packages/engine/Source/Scene/GlobeSurfaceTileProvider.js
@@ -83,6 +83,7 @@ function GlobeSurfaceTileProvider(options) {
   this.lightingFadeOutDistance = 6500000.0;
   this.lightingFadeInDistance = 9000000.0;
   this.hasWaterMask = false;
+  this.showWaterEffect = false;
   this.oceanNormalMap = undefined;
   this.zoomedOutOceanSpecularIntensity = 0.5;
   this.enableLighting = false;
@@ -2181,8 +2182,8 @@ function addDrawCommandsForTile(tileProvider, tile, frameState) {
   const lambertDiffuseMultiplier = tileProvider.lambertDiffuseMultiplier;
   const vertexShadowDarkness = tileProvider.vertexShadowDarkness;
 
-  const showReflectiveOcean =
-    tileProvider.hasWaterMask && defined(waterMaskTexture);
+  const hasWaterMask = tileProvider.hasWaterMask && defined(waterMaskTexture);
+  const showReflectiveOcean = hasWaterMask && tileProvider.showWaterEffect;
   const oceanNormalMap = tileProvider.oceanNormalMap;
   const showOceanWaves = showReflectiveOcean && defined(oceanNormalMap);
   const terrainProvider = tileProvider.terrainProvider;
@@ -2214,7 +2215,7 @@ function addDrawCommandsForTile(tileProvider, tile, frameState) {
     perFragmentGroundAtmosphere = cameraDistance > fadeOutDistance;
   }
 
-  if (showReflectiveOcean) {
+  if (hasWaterMask) {
     --maxTextures;
   }
   if (showOceanWaves) {
@@ -2329,6 +2330,7 @@ function addDrawCommandsForTile(tileProvider, tile, frameState) {
   const surfaceShaderSetOptions = surfaceShaderSetOptionsScratch;
   surfaceShaderSetOptions.frameState = frameState;
   surfaceShaderSetOptions.surfaceTile = surfaceTile;
+  surfaceShaderSetOptions.hasWaterMask = hasWaterMask;
   surfaceShaderSetOptions.showReflectiveOcean = showReflectiveOcean;
   surfaceShaderSetOptions.showOceanWaves = showOceanWaves;
   surfaceShaderSetOptions.enableLighting = tileProvider.enableLighting;
diff --git a/packages/engine/Source/Scene/I3SLayer.js b/packages/engine/Source/Scene/I3SLayer.js
index 8ea3f13c2e58..59378e374db5 100644
--- a/packages/engine/Source/Scene/I3SLayer.js
+++ b/packages/engine/Source/Scene/I3SLayer.js
@@ -291,9 +291,15 @@ I3SLayer.prototype._findBestGeometryBuffers = function (
         };
       }
     }
+    // If no match found return first geometryBuffer
+    if (defined(geometryDefinition[0])) {
+      return {
+        bufferIndex: 0,
+        definition: geometryDefinition,
+        geometryBufferInfo: geometryDefinition[0],
+      };
+    }
   }
-
-  return 0;
 };
 
 /**
diff --git a/packages/engine/Source/Scene/I3SNode.js b/packages/engine/Source/Scene/I3SNode.js
index 48be9519abbc..fb8c548c0fb3 100644
--- a/packages/engine/Source/Scene/I3SNode.js
+++ b/packages/engine/Source/Scene/I3SNode.js
@@ -219,7 +219,7 @@ I3SNode.prototype.load = async function () {
     const uriIndex = node.mesh.geometry.resource;
     uri = `../${uriIndex}/`;
   }
-  if (defined(uri)) {
+  if (defined(uri) && defined(that._parent.resource)) {
     that._resource = that._parent.resource.getDerivedResource({ url: uri });
   }
 
diff --git a/packages/engine/Source/Scene/Material.js b/packages/engine/Source/Scene/Material.js
index 53d4155dcc2d..ba0e598d3c53 100644
--- a/packages/engine/Source/Scene/Material.js
+++ b/packages/engine/Source/Scene/Material.js
@@ -34,6 +34,7 @@ import SlopeRampMaterial from "../Shaders/Materials/SlopeRampMaterial.js";
 import StripeMaterial from "../Shaders/Materials/StripeMaterial.js";
 import TextureMagnificationFilter from "../Renderer/TextureMagnificationFilter.js";
 import TextureMinificationFilter from "../Renderer/TextureMinificationFilter.js";
+import WaterMaskMaterial from "../Shaders/Materials/WaterMaskMaterial.js";
 import WaterMaterial from "../Shaders/Materials/Water.js";
 
 /**
@@ -219,6 +220,11 @@ import WaterMaterial from "../Shaders/Materials/Water.js";
  *      <li><code>heights</code>: image of heights sorted from lowest to highest.</li>
  *      <li><code>colors</code>: image of colors at the corresponding heights.</li>
  * </ul>
+ * <li>WaterMask</li>
+ * <ul>
+ *      <li><code>waterColor</code>: diffuse color and alpha for the areas covered by water.</li>
+ *      <li><code>landColor</code>: diffuse color and alpha for the areas covered by land.</li>
+ * </ul>
  * </ul>
  * </ul>
  * </div>
@@ -233,7 +239,6 @@ import WaterMaterial from "../Shaders/Materials/Water.js";
  * @param {TextureMinificationFilter} [options.minificationFilter=TextureMinificationFilter.LINEAR] The {@link TextureMinificationFilter} to apply to this material's textures.
  * @param {TextureMagnificationFilter} [options.magnificationFilter=TextureMagnificationFilter.LINEAR] The {@link TextureMagnificationFilter} to apply to this material's textures.
  * @param {object} options.fabric The fabric JSON used to generate the material.
- *ructor
  *
  * @exception {DeveloperError} fabric: uniform has invalid type.
  * @exception {DeveloperError} fabric: uniforms and materials cannot share the same property.
@@ -245,7 +250,6 @@ import WaterMaterial from "../Shaders/Materials/Water.js";
  * @exception {DeveloperError} strict: shader source does not use material.
  *
  * @see {@link https://github.com/CesiumGS/cesium/wiki/Fabric|Fabric wiki page} for a more detailed options of Fabric.
- *
  * @demo {@link https://sandcastle.cesium.com/index.html?src=Materials.html|Cesium Sandcastle Materials Demo}
  *
  * @example
@@ -1739,4 +1743,22 @@ Material._materialCache.addMaterial(Material.ElevationBandType, {
   translucent: true,
 });
 
+/**
+ * Gets the name of the water mask material.
+ * @type {string}
+ * @readonly
+ */
+Material.WaterMaskType = "WaterMask";
+Material._materialCache.addMaterial(Material.WaterMaskType, {
+  fabric: {
+    type: Material.WaterMaskType,
+    source: WaterMaskMaterial,
+    uniforms: {
+      waterColor: new Color(1.0, 1.0, 1.0, 1.0),
+      landColor: new Color(0.0, 0.0, 0.0, 0.0),
+    },
+  },
+  translucent: false,
+});
+
 export default Material;
diff --git a/packages/engine/Source/Scene/Model/Model.js b/packages/engine/Source/Scene/Model/Model.js
index 3da886945f37..e5415a11587c 100644
--- a/packages/engine/Source/Scene/Model/Model.js
+++ b/packages/engine/Source/Scene/Model/Model.js
@@ -123,6 +123,7 @@ import pickModel from "./pickModel.js";
  * @privateParam {boolean} [options.show=true] Whether or not to render the model.
  * @privateParam {Matrix4} [options.modelMatrix=Matrix4.IDENTITY]  The 4x4 transformation matrix that transforms the model from model to world coordinates.
  * @privateParam {number} [options.scale=1.0] A uniform scale applied to this model.
+ * @privateParam {boolean} [options.enableVerticalExaggeration=true] If <code>true</code>, the model is exaggerated along the ellipsoid normal when {@link Scene.verticalExaggeration} is set to a value other than <code>1.0</code>.
  * @privateParam {number} [options.minimumPixelSize=0.0] The approximate minimum pixel size of the model regardless of zoom.
  * @privateParam {number} [options.maximumScale] The maximum scale size of a model. An upper limit for minimumPixelSize.
  * @privateParam {object} [options.id] A user-defined object to return when the model is picked with {@link Scene#pick}.
@@ -161,7 +162,7 @@ import pickModel from "./pickModel.js";
  * @privateParam {string|number} [options.instanceFeatureIdLabel="instanceFeatureId_0"] Label of the instance feature ID set used for picking and styling. If instanceFeatureIdLabel is set to an integer N, it is converted to the string "instanceFeatureId_N" automatically. If both per-primitive and per-instance feature IDs are present, the instance feature IDs take priority.
  * @privateParam {object} [options.pointCloudShading] Options for constructing a {@link PointCloudShading} object to control point attenuation based on geometric error and lighting.
  * @privateParam {ClassificationType} [options.classificationType] Determines whether terrain, 3D Tiles or both will be classified by this model. This cannot be set after the model has loaded.
-
+ *
  *
  * @see Model.fromGltfAsync
  *
@@ -340,7 +341,11 @@ function Model(options) {
   this._heightDirty = this._heightReference !== HeightReference.NONE;
   this._removeUpdateHeightCallback = undefined;
 
-  this._verticalExaggerationOn = false;
+  this._enableVerticalExaggeration = defaultValue(
+    options.enableVerticalExaggeration,
+    true
+  );
+  this._hasVerticalExaggeration = false;
 
   this._clampedModelMatrix = undefined; // For use with height reference
 
@@ -1339,6 +1344,45 @@ Object.defineProperties(Model.prototype, {
     },
   },
 
+  /**
+   * If <code>true</code>, the model is exaggerated along the ellipsoid normal when {@link Scene.verticalExaggeration} is set to a value other than <code>1.0</code>.
+   *
+   * @memberof Model.prototype
+   * @type {boolean}
+   * @default true
+   *
+   * @example
+   * // Exaggerate terrain by a factor of 2, but prevent model exaggeration
+   * scene.verticalExaggeration = 2.0;
+   * model.enableVerticalExaggeration = false;
+   */
+  enableVerticalExaggeration: {
+    get: function () {
+      return this._enableVerticalExaggeration;
+    },
+    set: function (value) {
+      if (value !== this._enableVerticalExaggeration) {
+        this.resetDrawCommands();
+      }
+      this._enableVerticalExaggeration = value;
+    },
+  },
+
+  /**
+   * If <code>true</code>, the model is vertically exaggerated along the ellipsoid normal.
+   *
+   * @memberof Model.prototype
+   * @type {boolean}
+   * @default true
+   * @readonly
+   * @private
+   */
+  hasVerticalExaggeration: {
+    get: function () {
+      return this._hasVerticalExaggeration;
+    },
+  },
+
   /**
    * The light color when shading the model. When <code>undefined</code> the scene's light color is used instead.
    * <p>
@@ -2062,10 +2106,15 @@ function updateFog(model, frameState) {
 }
 
 function updateVerticalExaggeration(model, frameState) {
-  const verticalExaggerationNeeded = frameState.verticalExaggeration !== 1.0;
-  if (model._verticalExaggerationOn !== verticalExaggerationNeeded) {
-    model.resetDrawCommands();
-    model._verticalExaggerationOn = verticalExaggerationNeeded;
+  if (model.enableVerticalExaggeration) {
+    const verticalExaggerationNeeded = frameState.verticalExaggeration !== 1.0;
+    if (model.hasVerticalExaggeration !== verticalExaggerationNeeded) {
+      model.resetDrawCommands();
+      model._hasVerticalExaggeration = verticalExaggerationNeeded;
+    }
+  } else if (model.hasVerticalExaggeration) {
+    model.resetDrawCommands(); //if verticalExaggeration was on, reset.
+    model._hasVerticalExaggeration = false;
   }
 }
 
@@ -2748,6 +2797,7 @@ Model.prototype.destroyModelResources = function () {
  * @param {boolean} [options.show=true] Whether or not to render the model.
  * @param {Matrix4} [options.modelMatrix=Matrix4.IDENTITY] The 4x4 transformation matrix that transforms the model from model to world coordinates.
  * @param {number} [options.scale=1.0] A uniform scale applied to this model.
+ * @param {boolean} [options.enableVerticalExaggeration=true] If <code>true</code>, the model is exaggerated along the ellipsoid normal when {@link Scene.verticalExaggeration} is set to a value other than <code>1.0</code>.
  * @param {number} [options.minimumPixelSize=0.0] The approximate minimum pixel size of the model regardless of zoom.
  * @param {number} [options.maximumScale] The maximum scale size of a model. An upper limit for minimumPixelSize.
  * @param {object} [options.id] A user-defined object to return when the model is picked with {@link Scene#pick}.
@@ -3116,6 +3166,7 @@ function makeModelOptions(loader, modelType, options) {
     show: options.show,
     modelMatrix: options.modelMatrix,
     scale: options.scale,
+    enableVerticalExaggeration: options.enableVerticalExaggeration,
     minimumPixelSize: options.minimumPixelSize,
     maximumScale: options.maximumScale,
     id: options.id,
diff --git a/packages/engine/Source/Scene/Model/ModelRuntimePrimitive.js b/packages/engine/Source/Scene/Model/ModelRuntimePrimitive.js
index ed82ca255cf4..fb4b7b083249 100644
--- a/packages/engine/Source/Scene/Model/ModelRuntimePrimitive.js
+++ b/packages/engine/Source/Scene/Model/ModelRuntimePrimitive.js
@@ -199,7 +199,8 @@ ModelRuntimePrimitive.prototype.configurePipeline = function (frameState) {
   const mode = frameState.mode;
   const use2D =
     mode !== SceneMode.SCENE3D && !frameState.scene3DOnly && model._projectTo2D;
-  const exaggerateTerrain = frameState.verticalExaggeration !== 1.0;
+  const hasVerticalExaggeration =
+    frameState.verticalExaggeration !== 1.0 && model.hasVerticalExaggeration;
 
   const hasMorphTargets =
     defined(primitive.morphTargets) && primitive.morphTargets.length > 0;
@@ -283,7 +284,7 @@ ModelRuntimePrimitive.prototype.configurePipeline = function (frameState) {
     pipelineStages.push(CPUStylingPipelineStage);
   }
 
-  if (exaggerateTerrain) {
+  if (hasVerticalExaggeration) {
     pipelineStages.push(VerticalExaggerationPipelineStage);
   }
 
diff --git a/packages/engine/Source/Scene/PostProcessStageCollection.js b/packages/engine/Source/Scene/PostProcessStageCollection.js
index 1bdb38ca5e34..10cfeb5be476 100644
--- a/packages/engine/Source/Scene/PostProcessStageCollection.js
+++ b/packages/engine/Source/Scene/PostProcessStageCollection.js
@@ -12,7 +12,7 @@ import TextureWrap from "../Renderer/TextureWrap.js";
 import PassThrough from "../Shaders/PostProcessStages/PassThrough.js";
 import PostProcessStageLibrary from "./PostProcessStageLibrary.js";
 import PostProcessStageTextureCache from "./PostProcessStageTextureCache.js";
-import Tonemapper from "./Tonemapper.js";
+import Tonemapper, { validateTonemapper } from "./Tonemapper.js";
 
 const stackScratch = [];
 
@@ -41,11 +41,12 @@ function PostProcessStageCollection() {
   // Some shaders, such as the atmosphere and ground atmosphere, output values slightly over 1.0.
   this._autoExposureEnabled = false;
   this._autoExposure = PostProcessStageLibrary.createAutoExposureStage();
+  this._exposure = 1.0;
   this._tonemapping = undefined;
   this._tonemapper = undefined;
 
-  // set tonemapper and tonemapping
-  this.tonemapper = Tonemapper.ACES;
+  // set tonemapper and tonemapping using the setter
+  this.tonemapper = Tonemapper.PBR_NEUTRAL;
 
   const tonemapping = this._tonemapping;
 
@@ -313,11 +314,14 @@ Object.defineProperties(PostProcessStageCollection.prototype, {
   },
 
   /**
-   * Gets and sets the tonemapping algorithm used when rendering with high dynamic range.
+   * Specifies the tonemapping algorithm used when rendering with high dynamic range.
+   * {@link https://sandcastle.cesium.com/?src=High%20Dynamic%20Range.html|Sandcastle Demo}
    *
+   * @example viewer.scene.postProcessStages.tonemapper = Cesium.Tonemapper.ACES;
+   *
+   * @default Tonemapper.PBR_NEUTRAL
    * @memberof PostProcessStageCollection.prototype
    * @type {Tonemapper}
-   * @private
    */
   tonemapper: {
     get: function () {
@@ -328,7 +332,7 @@ Object.defineProperties(PostProcessStageCollection.prototype, {
         return;
       }
       //>>includeStart('debug', pragmas.debug);
-      if (!Tonemapper.validate(value)) {
+      if (!validateTonemapper(value)) {
         throw new DeveloperError("tonemapper was set to an invalid value.");
       }
       //>>includeEnd('debug');
@@ -339,26 +343,31 @@ Object.defineProperties(PostProcessStageCollection.prototype, {
       }
 
       const useAutoExposure = this._autoExposureEnabled;
-      let tonemapper;
+      let tonemapping;
 
       switch (value) {
         case Tonemapper.REINHARD:
-          tonemapper = PostProcessStageLibrary.createReinhardTonemappingStage(
+          tonemapping = PostProcessStageLibrary.createReinhardTonemappingStage(
             useAutoExposure
           );
           break;
         case Tonemapper.MODIFIED_REINHARD:
-          tonemapper = PostProcessStageLibrary.createModifiedReinhardTonemappingStage(
+          tonemapping = PostProcessStageLibrary.createModifiedReinhardTonemappingStage(
             useAutoExposure
           );
           break;
         case Tonemapper.FILMIC:
-          tonemapper = PostProcessStageLibrary.createFilmicTonemappingStage(
+          tonemapping = PostProcessStageLibrary.createFilmicTonemappingStage(
+            useAutoExposure
+          );
+          break;
+        case Tonemapper.PBR_NEUTRAL:
+          tonemapping = PostProcessStageLibrary.createPbrNeutralTonemappingStage(
             useAutoExposure
           );
           break;
         default:
-          tonemapper = PostProcessStageLibrary.createAcesTonemappingStage(
+          tonemapping = PostProcessStageLibrary.createAcesTonemappingStage(
             useAutoExposure
           );
           break;
@@ -366,22 +375,43 @@ Object.defineProperties(PostProcessStageCollection.prototype, {
 
       if (useAutoExposure) {
         const autoexposure = this._autoExposure;
-        tonemapper.uniforms.autoExposure = function () {
+        tonemapping.uniforms.autoExposure = function () {
           return autoexposure.outputTexture;
         };
+      } else {
+        tonemapping.uniforms.exposure = this._exposure;
       }
 
       this._tonemapper = value;
-      this._tonemapping = tonemapper;
+      this._tonemapping = tonemapping;
 
       if (defined(this._stageNames)) {
-        this._stageNames[tonemapper.name] = tonemapper;
-        tonemapper._textureCache = this._textureCache;
+        this._stageNames[tonemapping.name] = tonemapping;
+        tonemapping._textureCache = this._textureCache;
       }
 
       this._textureCacheDirty = true;
     },
   },
+
+  /**
+   * Control the exposure when HDR is on. Less than 1.0 makes the tonemapping darker while greater than 1.0 makes it brighter.
+   *
+   * @example viewer.scene.postProcessStages.exposure = 1.0;
+   *
+   * @default 1.0
+   * @memberof PostProcessStageCollection.prototype
+   * @type {number}
+   */
+  exposure: {
+    get: function () {
+      return this._exposure;
+    },
+    set: function (value) {
+      this._tonemapping.uniforms.exposure = value;
+      this._exposure = value;
+    },
+  },
 });
 
 function removeStages(collection) {
diff --git a/packages/engine/Source/Scene/PostProcessStageLibrary.js b/packages/engine/Source/Scene/PostProcessStageLibrary.js
index 9d3f8a2fd7e2..18aaa1d974b5 100644
--- a/packages/engine/Source/Scene/PostProcessStageLibrary.js
+++ b/packages/engine/Source/Scene/PostProcessStageLibrary.js
@@ -14,6 +14,7 @@ import DepthOfField from "../Shaders/PostProcessStages/DepthOfField.js";
 import DepthView from "../Shaders/PostProcessStages/DepthView.js";
 import EdgeDetection from "../Shaders/PostProcessStages/EdgeDetection.js";
 import FilmicTonemapping from "../Shaders/PostProcessStages/FilmicTonemapping.js";
+import PbrNeutralTonemapping from "../Shaders/PostProcessStages/PbrNeutralTonemapping.js";
 import FXAA from "../Shaders/PostProcessStages/FXAA.js";
 import GaussianBlur1D from "../Shaders/PostProcessStages/GaussianBlur1D.js";
 import LensFlare from "../Shaders/PostProcessStages/LensFlare.js";
@@ -669,6 +670,7 @@ PostProcessStageLibrary.createAcesTonemappingStage = function (
     fragmentShader: fs,
     uniforms: {
       autoExposure: undefined,
+      exposure: 1.0,
     },
   });
 };
@@ -689,6 +691,28 @@ PostProcessStageLibrary.createFilmicTonemappingStage = function (
     fragmentShader: fs,
     uniforms: {
       autoExposure: undefined,
+      exposure: 1.0,
+    },
+  });
+};
+
+/**
+ * Creates a post-process stage that applies filmic tonemapping operator.
+ * @param {boolean} useAutoExposure Whether or not to use auto-exposure.
+ * @return {PostProcessStage} A post-process stage that applies filmic tonemapping operator.
+ * @private
+ */
+PostProcessStageLibrary.createPbrNeutralTonemappingStage = function (
+  useAutoExposure
+) {
+  let fs = useAutoExposure ? "#define AUTO_EXPOSURE\n" : "";
+  fs += PbrNeutralTonemapping;
+  return new PostProcessStage({
+    name: "czm_pbr_neutral",
+    fragmentShader: fs,
+    uniforms: {
+      autoExposure: undefined,
+      exposure: 1.0,
     },
   });
 };
@@ -709,6 +733,7 @@ PostProcessStageLibrary.createReinhardTonemappingStage = function (
     fragmentShader: fs,
     uniforms: {
       autoExposure: undefined,
+      exposure: 1.0,
     },
   });
 };
@@ -730,6 +755,7 @@ PostProcessStageLibrary.createModifiedReinhardTonemappingStage = function (
     uniforms: {
       white: Color.WHITE,
       autoExposure: undefined,
+      exposure: 1.0,
     },
   });
 };
diff --git a/packages/engine/Source/Scene/Scene.js b/packages/engine/Source/Scene/Scene.js
index 985e19cc0509..2191d9f1ff93 100644
--- a/packages/engine/Source/Scene/Scene.js
+++ b/packages/engine/Source/Scene/Scene.js
@@ -107,7 +107,7 @@ const requestRenderAfterFrame = function (scene) {
  * @param {boolean} [options.requestRenderMode=false] If true, rendering a frame will only occur when needed as determined by changes within the scene. Enabling improves performance of the application, but requires using {@link Scene#requestRender} to render a new frame explicitly in this mode. This will be necessary in many cases after making changes to the scene in other parts of the API. See {@link https://cesium.com/blog/2018/01/24/cesium-scene-rendering-performance/|Improving Performance with Explicit Rendering}.
  * @param {number} [options.maximumRenderTimeChange=0.0] If requestRenderMode is true, this value defines the maximum change in simulation time allowed before a render is requested. See {@link https://cesium.com/blog/2018/01/24/cesium-scene-rendering-performance/|Improving Performance with Explicit Rendering}.
  * @param {number} [options.depthPlaneEllipsoidOffset=0.0] Adjust the DepthPlane to address rendering artefacts below ellipsoid zero elevation.
- * @param {number} [options.msaaSamples=1] If provided, this value controls the rate of multisample antialiasing. Typical multisampling rates are 2, 4, and sometimes 8 samples per pixel. Higher sampling rates of MSAA may impact performance in exchange for improved visual quality. This value only applies to WebGL2 contexts that support multisample render targets.
+ * @param {number} [options.msaaSamples=4] If provided, this value controls the rate of multisample antialiasing. Typical multisampling rates are 2, 4, and sometimes 8 samples per pixel. Higher sampling rates of MSAA may impact performance in exchange for improved visual quality. This value only applies to WebGL2 contexts that support multisample render targets. Set to 1 to disable MSAA.
  *
  * @see CesiumWidget
  * @see {@link http://www.khronos.org/registry/webgl/specs/latest/#5.2|WebGLContextAttributes}
@@ -228,7 +228,7 @@ function Scene(options) {
   this._minimumDisableDepthTestDistance = 0.0;
   this._debugInspector = new DebugInspector();
 
-  this._msaaSamples = defaultValue(options.msaaSamples, 1);
+  this._msaaSamples = defaultValue(options.msaaSamples, 4);
 
   /**
    * Exceptions occurring in <code>render</code> are always caught in order to raise the
@@ -1630,7 +1630,7 @@ Object.defineProperties(Scene.prototype, {
    * The sample rate of multisample antialiasing (values greater than 1 enable MSAA).
    * @memberof Scene.prototype
    * @type {number}
-   * @default 1
+   * @default 4
    */
   msaaSamples: {
     get: function () {
diff --git a/packages/engine/Source/Scene/SceneTransforms.js b/packages/engine/Source/Scene/SceneTransforms.js
index df0954df2132..84ae7a032b52 100644
--- a/packages/engine/Source/Scene/SceneTransforms.js
+++ b/packages/engine/Source/Scene/SceneTransforms.js
@@ -4,7 +4,6 @@ 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";
@@ -53,33 +52,6 @@ SceneTransforms.worldToWindowCoordinates = function (scene, position, 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.
- *
- * @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|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.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));
- * }, Cesium.ScreenSpaceEventType.MOUSE_MOVE);
- */
-SceneTransforms.wgs84ToWindowCoordinates = function (scene, position, 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();
 const scratchEyeOffset = new Cartesian3();
 
@@ -320,40 +292,6 @@ SceneTransforms.worldToDrawingBufferCoordinates = 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();
 
diff --git a/packages/engine/Source/Scene/Tonemapper.js b/packages/engine/Source/Scene/Tonemapper.js
index b799e43ee7be..e4dd5aaff29b 100644
--- a/packages/engine/Source/Scene/Tonemapper.js
+++ b/packages/engine/Source/Scene/Tonemapper.js
@@ -1,52 +1,64 @@
 /**
  * A tonemapping algorithm when rendering with high dynamic range.
  *
- * @enum {number}
- * @private
+ * @enum {string}
  */
 const Tonemapper = {
   /**
-   * Use the Reinhard tonemapping operator.
+   * Use the Reinhard tonemapping.
    *
-   * @type {number}
+   * @type {string}
    * @constant
    */
-  REINHARD: 0,
+  REINHARD: "REINHARD",
 
   /**
-   * Use the modified Reinhard tonemapping operator.
+   * Use the modified Reinhard tonemapping.
    *
-   * @type {number}
+   * @type {string}
    * @constant
    */
-  MODIFIED_REINHARD: 1,
+  MODIFIED_REINHARD: "MODIFIED_REINHARD",
 
   /**
-   * Use the Filmic tonemapping operator.
+   * Use the Filmic tonemapping.
    *
-   * @type {number}
+   * @type {string}
    * @constant
    */
-  FILMIC: 2,
+  FILMIC: "FILMIC",
 
   /**
-   * Use the ACES tonemapping operator.
+   * Use the ACES tonemapping.
    *
-   * @type {number}
+   * @type {string}
    * @constant
    */
-  ACES: 3,
+  ACES: "ACES",
 
   /**
-   * @private
+   * Use the PBR Neutral tonemapping {@link https://github.com/KhronosGroup/ToneMapping/tree/main/PBR_Neutral|from Khronos}.
+   *
+   * @type {string}
+   * @constant
    */
-  validate: function (tonemapper) {
-    return (
-      tonemapper === Tonemapper.REINHARD ||
-      tonemapper === Tonemapper.MODIFIED_REINHARD ||
-      tonemapper === Tonemapper.FILMIC ||
-      tonemapper === Tonemapper.ACES
-    );
-  },
+  PBR_NEUTRAL: "PBR_NEUTRAL",
 };
+
+/**
+ * Validate whether the provided value is a known Tonemapper type
+ * @private
+ *
+ * @param {string} tonemapper
+ */
+export function validateTonemapper(tonemapper) {
+  return (
+    tonemapper === Tonemapper.REINHARD ||
+    tonemapper === Tonemapper.MODIFIED_REINHARD ||
+    tonemapper === Tonemapper.FILMIC ||
+    tonemapper === Tonemapper.ACES ||
+    tonemapper === Tonemapper.PBR_NEUTRAL
+  );
+}
+
 export default Object.freeze(Tonemapper);
diff --git a/packages/engine/Source/Shaders/Builtin/Functions/pbrNeutralTonemapping.glsl b/packages/engine/Source/Shaders/Builtin/Functions/pbrNeutralTonemapping.glsl
new file mode 100644
index 000000000000..9861b3369d84
--- /dev/null
+++ b/packages/engine/Source/Shaders/Builtin/Functions/pbrNeutralTonemapping.glsl
@@ -0,0 +1,23 @@
+// KhronosGroup https://github.com/KhronosGroup/ToneMapping/tree/main/PBR_Neutral
+
+// Input color is non-negative and resides in the Linear Rec. 709 color space.
+// Output color is also Linear Rec. 709, but in the [0, 1] range.
+
+vec3 czm_pbrNeutralTonemapping(vec3 color) {
+    const float startCompression = 0.8 - 0.04;
+    const float desaturation = 0.15;
+
+    float x = min(color.r, min(color.g, color.b));
+    float offset = czm_branchFreeTernary(x < 0.08, x - 6.25 * x * x, 0.04);
+    color -= offset;
+
+    float peak = max(color.r, max(color.g, color.b));
+    if (peak < startCompression) return color;
+
+    const float d = 1.0 - startCompression;
+    float newPeak = 1.0 - d * d / (peak + d - startCompression);
+    color *= newPeak / peak;
+
+    float g = 1.0 - 1.0 / (desaturation * (peak - newPeak) + 1.0);
+    return mix(color, newPeak * vec3(1.0, 1.0, 1.0), g);
+}
diff --git a/packages/engine/Source/Shaders/Builtin/Structs/materialInput.glsl b/packages/engine/Source/Shaders/Builtin/Structs/materialInput.glsl
index 597558d31b59..e23cbee5a93b 100644
--- a/packages/engine/Source/Shaders/Builtin/Structs/materialInput.glsl
+++ b/packages/engine/Source/Shaders/Builtin/Structs/materialInput.glsl
@@ -13,6 +13,7 @@
  * @property {float} height The height of the terrain in meters above or below the ellipsoid.  Only available for globe materials.
  * @property {float} slope The slope of the terrain in radians.  0 is flat; pi/2 is vertical.  Only available for globe materials.
  * @property {float} aspect The aspect of the terrain in radians.  0 is East, pi/2 is North, pi is West, 3pi/2 is South.  Only available for globe materials.
+* @property {float} waterMask The value of the water mask. 0 is land, 1 is water. Only available for globe materials.
  */
 struct czm_materialInput
 {
@@ -25,4 +26,5 @@ struct czm_materialInput
     float height;
     float slope;
     float aspect;
+    float waterMask;
 };
diff --git a/packages/engine/Source/Shaders/GlobeFS.glsl b/packages/engine/Source/Shaders/GlobeFS.glsl
index 3f9f9f0609fa..2c9df10caf02 100644
--- a/packages/engine/Source/Shaders/GlobeFS.glsl
+++ b/packages/engine/Source/Shaders/GlobeFS.glsl
@@ -49,7 +49,7 @@ uniform vec4 u_colorsToAlpha[TEXTURE_UNITS];
 uniform vec4 u_dayTextureTexCoordsRectangle[TEXTURE_UNITS];
 #endif
 
-#ifdef SHOW_REFLECTIVE_OCEAN
+#if defined(HAS_WATER_MASK) && (defined(SHOW_REFLECTIVE_OCEAN) || defined(APPLY_MATERIAL))
 uniform sampler2D u_waterMask;
 uniform vec4 u_waterMaskTranslationAndScale;
 uniform float u_zoomedOutOceanSpecularIntensity;
@@ -362,7 +362,7 @@ void main()
     float fade = 0.0;
 #endif
 
-#ifdef SHOW_REFLECTIVE_OCEAN
+#if defined(HAS_WATER_MASK) && (defined(SHOW_REFLECTIVE_OCEAN) || defined(APPLY_MATERIAL))
     vec2 waterMaskTranslation = u_waterMaskTranslationAndScale.xy;
     vec2 waterMaskScale = u_waterMaskTranslationAndScale.zw;
     vec2 waterMaskTextureCoordinates = v_textureCoordinates.xy * waterMaskScale + waterMaskTranslation;
@@ -370,6 +370,7 @@ void main()
 
     float mask = texture(u_waterMask, waterMaskTextureCoordinates).r;
 
+    #ifdef SHOW_REFLECTIVE_OCEAN
     if (mask > 0.0)
     {
         mat3 enuToEye = czm_eastNorthUpToEyeCoordinates(v_positionMC, normalEC);
@@ -381,6 +382,7 @@ void main()
 
         color = computeWaterColor(v_positionEC, textureCoordinates, enuToEye, color, mask, fade);
     }
+    #endif
 #endif
 
 #ifdef APPLY_MATERIAL
@@ -392,6 +394,10 @@ void main()
     materialInput.slope = v_slope;
     materialInput.height = v_height;
     materialInput.aspect = v_aspect;
+    #ifdef HAS_WATER_MASK
+        materialInput.waterMask = mask;
+    #endif
+
     czm_material material = czm_getMaterial(materialInput);
     vec4 materialColor = vec4(material.diffuse, material.alpha);
     color = alphaBlend(materialColor, color);
@@ -422,7 +428,7 @@ void main()
 #ifdef ENABLE_CLIPPING_POLYGONS
     vec2 clippingPosition = v_clippingPosition;
     int regionIndex = v_regionIndex;
-    clipPolygons(u_clippingDistance, CLIPPING_POLYGON_REGIONS_LENGTH, clippingPosition, regionIndex);    
+    clipPolygons(u_clippingDistance, CLIPPING_POLYGON_REGIONS_LENGTH, clippingPosition, regionIndex);
 #endif
 
 #ifdef HIGHLIGHT_FILL_TILE
@@ -489,7 +495,7 @@ void main()
             #endif
 
             #ifndef HDR
-                fogColor.rgb = czm_acesTonemapping(fogColor.rgb);
+                fogColor.rgb = czm_pbrNeutralTonemapping(fogColor.rgb);
                 fogColor.rgb = czm_inverseGamma(fogColor.rgb);
             #endif
 
diff --git a/packages/engine/Source/Shaders/Materials/WaterMaskMaterial.glsl b/packages/engine/Source/Shaders/Materials/WaterMaskMaterial.glsl
new file mode 100644
index 000000000000..50cc972460f4
--- /dev/null
+++ b/packages/engine/Source/Shaders/Materials/WaterMaskMaterial.glsl
@@ -0,0 +1,15 @@
+uniform vec4 waterColor;
+uniform vec4 landColor;
+
+czm_material czm_getMaterial(czm_materialInput materialInput)
+{
+    czm_material material = czm_getDefaultMaterial(materialInput);
+
+    vec4 outColor = mix(landColor, waterColor, materialInput.waterMask);
+    outColor = czm_gammaCorrect(outColor);
+
+    material.diffuse = outColor.rgb;
+    material.alpha = outColor.a;
+
+    return material;
+}
diff --git a/packages/engine/Source/Shaders/Model/AtmosphereStageFS.glsl b/packages/engine/Source/Shaders/Model/AtmosphereStageFS.glsl
index 3a0b20e86fa0..e46dc6e68782 100644
--- a/packages/engine/Source/Shaders/Model/AtmosphereStageFS.glsl
+++ b/packages/engine/Source/Shaders/Model/AtmosphereStageFS.glsl
@@ -52,7 +52,7 @@ void applyFog(inout vec4 color, vec4 groundAtmosphereColor, vec3 lightDirection,
 
     // Tonemap if HDR rendering is disabled
     #ifndef HDR
-        fogColor.rgb = czm_acesTonemapping(fogColor.rgb);
+        fogColor.rgb = czm_pbrNeutralTonemapping(fogColor.rgb);
         fogColor.rgb = czm_inverseGamma(fogColor.rgb);
     #endif
 
diff --git a/packages/engine/Source/Shaders/Model/LightingStageFS.glsl b/packages/engine/Source/Shaders/Model/LightingStageFS.glsl
index 244c0f16aefd..e51c17ede10f 100644
--- a/packages/engine/Source/Shaders/Model/LightingStageFS.glsl
+++ b/packages/engine/Source/Shaders/Model/LightingStageFS.glsl
@@ -120,7 +120,7 @@ void lightingStage(inout czm_modelMaterial material, ProcessedAttributes attribu
         // tonemapping. However, if HDR is not enabled, we must tonemap else large
         // values may be clamped to 1.0
         #ifndef HDR
-            color = czm_acesTonemapping(color);
+            color = czm_pbrNeutralTonemapping(color);
         #endif
     #else // unlit
         vec3 color = material.diffuse;
diff --git a/packages/engine/Source/Shaders/PostProcessStages/AcesTonemappingStage.glsl b/packages/engine/Source/Shaders/PostProcessStages/AcesTonemappingStage.glsl
index 2844ca752f17..57e63c06b6a4 100644
--- a/packages/engine/Source/Shaders/PostProcessStages/AcesTonemappingStage.glsl
+++ b/packages/engine/Source/Shaders/PostProcessStages/AcesTonemappingStage.glsl
@@ -4,6 +4,8 @@ in vec2 v_textureCoordinates;
 
 #ifdef AUTO_EXPOSURE
 uniform sampler2D autoExposure;
+#else
+uniform float exposure;
 #endif
 
 void main()
@@ -13,6 +15,8 @@ void main()
 
 #ifdef AUTO_EXPOSURE
     color /= texture(autoExposure, vec2(0.5)).r;
+#else
+    color *= vec3(exposure);
 #endif
     color = czm_acesTonemapping(color);
     color = czm_inverseGamma(color);
diff --git a/packages/engine/Source/Shaders/PostProcessStages/AmbientOcclusionGenerate.glsl b/packages/engine/Source/Shaders/PostProcessStages/AmbientOcclusionGenerate.glsl
index 0aecd38e231f..42535230cbdc 100644
--- a/packages/engine/Source/Shaders/PostProcessStages/AmbientOcclusionGenerate.glsl
+++ b/packages/engine/Source/Shaders/PostProcessStages/AmbientOcclusionGenerate.glsl
@@ -1,3 +1,5 @@
+precision highp float;
+
 uniform sampler2D randomTexture;
 uniform sampler2D depthTexture;
 uniform float intensity;
@@ -6,109 +8,107 @@ uniform float lengthCap;
 uniform float stepSize;
 uniform float frustumLength;
 
-in vec2 v_textureCoordinates;
-
-vec4 clipToEye(vec2 uv, float depth)
+vec3 pixelToEye(vec2 screenCoordinate)
 {
-    vec2 xy = vec2((uv.x * 2.0 - 1.0), ((1.0 - uv.y) * 2.0 - 1.0));
+    vec2 uv = screenCoordinate / czm_viewport.zw;
+    float depth = czm_readDepth(depthTexture, uv);
+    vec2 xy = 2.0 * uv - vec2(1.0);
     vec4 posEC = czm_inverseProjection * vec4(xy, depth, 1.0);
-    posEC = posEC / posEC.w;
-    return posEC;
+    return posEC.xyz / posEC.w;
 }
 
-//Reconstruct Normal Without Edge Removation
-vec3 getNormalXEdge(vec3 posInCamera, float depthU, float depthD, float depthL, float depthR, vec2 pixelSize)
+// Reconstruct surface normal in eye coordinates, avoiding edges
+vec3 getNormalXEdge(vec3 positionEC)
 {
-    vec4 posInCameraUp = clipToEye(v_textureCoordinates - vec2(0.0, pixelSize.y), depthU);
-    vec4 posInCameraDown = clipToEye(v_textureCoordinates + vec2(0.0, pixelSize.y), depthD);
-    vec4 posInCameraLeft = clipToEye(v_textureCoordinates - vec2(pixelSize.x, 0.0), depthL);
-    vec4 posInCameraRight = clipToEye(v_textureCoordinates + vec2(pixelSize.x, 0.0), depthR);
-
-    vec3 up = posInCamera.xyz - posInCameraUp.xyz;
-    vec3 down = posInCameraDown.xyz - posInCamera.xyz;
-    vec3 left = posInCamera.xyz - posInCameraLeft.xyz;
-    vec3 right = posInCameraRight.xyz - posInCamera.xyz;
-
-    vec3 DX = length(left) < length(right) ? left : right;
-    vec3 DY = length(up) < length(down) ? up : down;
-
-    return normalize(cross(DY, DX));
+    // Find the 3D surface positions at adjacent screen pixels
+    vec2 centerCoord = gl_FragCoord.xy;
+    vec3 positionLeft = pixelToEye(centerCoord + vec2(-1.0, 0.0));
+    vec3 positionRight = pixelToEye(centerCoord + vec2(1.0, 0.0));
+    vec3 positionUp = pixelToEye(centerCoord + vec2(0.0, 1.0));
+    vec3 positionDown = pixelToEye(centerCoord + vec2(0.0, -1.0));
+
+    // Compute potential tangent vectors
+    vec3 dx0 = positionEC - positionLeft;
+    vec3 dx1 = positionRight - positionEC;
+    vec3 dy0 = positionEC - positionDown;
+    vec3 dy1 = positionUp - positionEC;
+
+    // The shorter tangent is more likely to be on the same surface
+    vec3 dx = length(dx0) < length(dx1) ? dx0 : dx1;
+    vec3 dy = length(dy0) < length(dy1) ? dy0 : dy1;
+
+    return normalize(cross(dx, dy));
 }
 
 void main(void)
 {
-    float depth = czm_readDepth(depthTexture, v_textureCoordinates);
-    vec4 posInCamera = clipToEye(v_textureCoordinates, depth);
+    vec3 positionEC = pixelToEye(gl_FragCoord.xy);
 
-    if (posInCamera.z > frustumLength)
+    if (positionEC.z > frustumLength)
     {
         out_FragColor = vec4(1.0);
         return;
     }
 
-    vec2 pixelSize = czm_pixelRatio / czm_viewport.zw;
-    float depthU = czm_readDepth(depthTexture, v_textureCoordinates - vec2(0.0, pixelSize.y));
-    float depthD = czm_readDepth(depthTexture, v_textureCoordinates + vec2(0.0, pixelSize.y));
-    float depthL = czm_readDepth(depthTexture, v_textureCoordinates - vec2(pixelSize.x, 0.0));
-    float depthR = czm_readDepth(depthTexture, v_textureCoordinates + vec2(pixelSize.x, 0.0));
-    vec3 normalInCamera = getNormalXEdge(posInCamera.xyz, depthU, depthD, depthL, depthR, pixelSize);
+    vec3 normalEC = getNormalXEdge(positionEC);
 
     float ao = 0.0;
-    vec2 sampleDirection = vec2(1.0, 0.0);
-    float gapAngle = 90.0 * czm_radiansPerDegree;
 
-    // RandomNoise
-    float randomVal = texture(randomTexture, v_textureCoordinates / pixelSize / 255.0).x;
-
-    //Loop for each direction
-    for (int i = 0; i < 4; i++)
+    const int ANGLE_STEPS = 4;
+    float angleStepScale = 1.0 / float(ANGLE_STEPS);
+    float angleStep = angleStepScale * czm_twoPi;
+    float cosStep = cos(angleStep);
+    float sinStep = sin(angleStep);
+    mat2 rotateStep = mat2(cosStep, sinStep, -sinStep, cosStep);
+
+    // Initial sampling direction (different for each pixel)
+    const float randomTextureSize = 255.0;
+    vec2 randomTexCoord = fract(gl_FragCoord.xy / randomTextureSize);
+    float randomVal = texture(randomTexture, randomTexCoord).x;
+    vec2 sampleDirection = vec2(cos(angleStep * randomVal), sin(angleStep * randomVal));
+
+    // Loop over sampling directions
+    for (int i = 0; i < ANGLE_STEPS; i++)
     {
-        float newGapAngle = gapAngle * (float(i) + randomVal);
-        float cosVal = cos(newGapAngle);
-        float sinVal = sin(newGapAngle);
+        sampleDirection = rotateStep * sampleDirection;
 
-        //Rotate Sampling Direction
-        vec2 rotatedSampleDirection = vec2(cosVal * sampleDirection.x - sinVal * sampleDirection.y, sinVal * sampleDirection.x + cosVal * sampleDirection.y);
         float localAO = 0.0;
-        float localStepSize = stepSize;
+        vec2 radialStep = stepSize * sampleDirection;
 
-        //Loop for each step
         for (int j = 0; j < 6; j++)
         {
-            vec2 newCoords = v_textureCoordinates + rotatedSampleDirection * localStepSize * pixelSize;
+            // Step along sampling direction, away from output pixel
+            vec2 newCoords = floor(gl_FragCoord.xy + float(j + 1) * radialStep) + vec2(0.5);
 
-            //Exception Handling
-            if(newCoords.x > 1.0 || newCoords.y > 1.0 || newCoords.x < 0.0 || newCoords.y < 0.0)
+            // Exit if we stepped off the screen
+            if (clamp(newCoords, vec2(0.0), czm_viewport.zw) != newCoords)
             {
                 break;
             }
 
-            float stepDepthInfo = czm_readDepth(depthTexture, newCoords);
-            vec4 stepPosInCamera = clipToEye(newCoords, stepDepthInfo);
-            vec3 diffVec = stepPosInCamera.xyz - posInCamera.xyz;
-            float len = length(diffVec);
+            vec3 stepPositionEC = pixelToEye(newCoords);
+            vec3 stepVector = stepPositionEC - positionEC;
+            float stepLength = length(stepVector);
 
-            if (len > lengthCap)
+            if (stepLength > lengthCap)
             {
                 break;
             }
 
-            float dotVal = clamp(dot(normalInCamera, normalize(diffVec)), 0.0, 1.0 );
-            float weight = len / lengthCap;
-            weight = 1.0 - weight * weight;
-
+            float dotVal = clamp(dot(normalEC, normalize(stepVector)), 0.0, 1.0);
             if (dotVal < bias)
             {
                 dotVal = 0.0;
             }
 
+            float weight = stepLength / lengthCap;
+            weight = 1.0 - weight * weight;
             localAO = max(localAO, dotVal * weight);
-            localStepSize += stepSize;
         }
         ao += localAO;
     }
 
-    ao /= 4.0;
+    ao *= angleStepScale;
     ao = 1.0 - clamp(ao, 0.0, 1.0);
     ao = pow(ao, intensity);
     out_FragColor = vec4(vec3(ao), 1.0);
diff --git a/packages/engine/Source/Shaders/PostProcessStages/FilmicTonemapping.glsl b/packages/engine/Source/Shaders/PostProcessStages/FilmicTonemapping.glsl
index c226da15727a..9f3cc80108c4 100644
--- a/packages/engine/Source/Shaders/PostProcessStages/FilmicTonemapping.glsl
+++ b/packages/engine/Source/Shaders/PostProcessStages/FilmicTonemapping.glsl
@@ -4,6 +4,8 @@ in vec2 v_textureCoordinates;
 
 #ifdef AUTO_EXPOSURE
 uniform sampler2D autoExposure;
+#else
+uniform float exposure;
 #endif
 
 // See slides 142 and 143:
@@ -17,6 +19,8 @@ void main()
 #ifdef AUTO_EXPOSURE
     float exposure = texture(autoExposure, vec2(0.5)).r;
     color /= exposure;
+#else
+    color *= vec3(exposure);
 #endif
 
 	const float A = 0.22; // shoulder strength
diff --git a/packages/engine/Source/Shaders/PostProcessStages/ModifiedReinhardTonemapping.glsl b/packages/engine/Source/Shaders/PostProcessStages/ModifiedReinhardTonemapping.glsl
index 7547560177f5..5fa088763524 100644
--- a/packages/engine/Source/Shaders/PostProcessStages/ModifiedReinhardTonemapping.glsl
+++ b/packages/engine/Source/Shaders/PostProcessStages/ModifiedReinhardTonemapping.glsl
@@ -5,6 +5,8 @@ in vec2 v_textureCoordinates;
 
 #ifdef AUTO_EXPOSURE
 uniform sampler2D autoExposure;
+#else
+uniform float exposure;
 #endif
 
 // See equation 4:
@@ -17,6 +19,8 @@ void main()
 #ifdef AUTO_EXPOSURE
     float exposure = texture(autoExposure, vec2(0.5)).r;
     color /= exposure;
+#else
+    color *= vec3(exposure);
 #endif
     color = (color * (1.0 + color / white)) / (1.0 + color);
     color = czm_inverseGamma(color);
diff --git a/packages/engine/Source/Shaders/PostProcessStages/PbrNeutralTonemapping.glsl b/packages/engine/Source/Shaders/PostProcessStages/PbrNeutralTonemapping.glsl
new file mode 100644
index 000000000000..028839db729e
--- /dev/null
+++ b/packages/engine/Source/Shaders/PostProcessStages/PbrNeutralTonemapping.glsl
@@ -0,0 +1,25 @@
+uniform sampler2D colorTexture;
+
+in vec2 v_textureCoordinates;
+
+#ifdef AUTO_EXPOSURE
+uniform sampler2D autoExposure;
+#else
+uniform float exposure;
+#endif
+
+void main()
+{
+    vec4 fragmentColor = texture(colorTexture, v_textureCoordinates);
+    vec3 color = fragmentColor.rgb;
+
+#ifdef AUTO_EXPOSURE
+    color /= texture(autoExposure, vec2(0.5)).r;
+#else
+    color *= vec3(exposure);
+#endif
+    color = czm_pbrNeutralTonemapping(color);
+    color = czm_inverseGamma(color);
+
+    out_FragColor = vec4(color, fragmentColor.a);
+}
diff --git a/packages/engine/Source/Shaders/PostProcessStages/ReinhardTonemapping.glsl b/packages/engine/Source/Shaders/PostProcessStages/ReinhardTonemapping.glsl
index 582c92e8ec3b..0da78654e4fd 100644
--- a/packages/engine/Source/Shaders/PostProcessStages/ReinhardTonemapping.glsl
+++ b/packages/engine/Source/Shaders/PostProcessStages/ReinhardTonemapping.glsl
@@ -4,6 +4,8 @@ in vec2 v_textureCoordinates;
 
 #ifdef AUTO_EXPOSURE
 uniform sampler2D autoExposure;
+#else
+uniform float exposure;
 #endif
 
 // See equation 3:
@@ -16,6 +18,8 @@ void main()
 #ifdef AUTO_EXPOSURE
     float exposure = texture(autoExposure, vec2(0.5)).r;
     color /= exposure;
+#else
+    color *= vec3(exposure);
 #endif
     color = color / (1.0 + color);
     color = czm_inverseGamma(color);
diff --git a/packages/engine/Source/Shaders/SkyAtmosphereFS.glsl b/packages/engine/Source/Shaders/SkyAtmosphereFS.glsl
index d8f213396452..06a3f630c327 100644
--- a/packages/engine/Source/Shaders/SkyAtmosphereFS.glsl
+++ b/packages/engine/Source/Shaders/SkyAtmosphereFS.glsl
@@ -38,7 +38,7 @@ void main (void)
     vec4 color = computeAtmosphereColor(v_outerPositionWC, lightDirection, rayleighColor, mieColor, opacity);
 
     #ifndef HDR
-        color.rgb = czm_acesTonemapping(color.rgb);
+        color.rgb = czm_pbrNeutralTonemapping(color.rgb);
         color.rgb = czm_inverseGamma(color.rgb);
     #endif
 
diff --git a/packages/engine/Source/Widget/CesiumWidget.js b/packages/engine/Source/Widget/CesiumWidget.js
index 7e45d1e0fb54..20b2e7172ec2 100644
--- a/packages/engine/Source/Widget/CesiumWidget.js
+++ b/packages/engine/Source/Widget/CesiumWidget.js
@@ -143,7 +143,7 @@ function configureCameraFrustum(widget) {
  * @param {boolean} [options.blurActiveElementOnCanvasFocus=true] If true, the active element will blur when the viewer's canvas is clicked. Setting this to false is useful for cases when the canvas is clicked only for retrieving position or an entity data without actually meaning to set the canvas to be the active element.
  * @param {boolean} [options.requestRenderMode=false] If true, rendering a frame will only occur when needed as determined by changes within the scene. Enabling improves performance of the application, but requires using {@link Scene#requestRender} to render a new frame explicitly in this mode. This will be necessary in many cases after making changes to the scene in other parts of the API. See {@link https://cesium.com/blog/2018/01/24/cesium-scene-rendering-performance/|Improving Performance with Explicit Rendering}.
  * @param {number} [options.maximumRenderTimeChange=0.0] If requestRenderMode is true, this value defines the maximum change in simulation time allowed before a render is requested. See {@link https://cesium.com/blog/2018/01/24/cesium-scene-rendering-performance/|Improving Performance with Explicit Rendering}.
- * @param {number} [options.msaaSamples=1] If provided, this value controls the rate of multisample antialiasing. Typical multisampling rates are 2, 4, and sometimes 8 samples per pixel. Higher sampling rates of MSAA may impact performance in exchange for improved visual quality. This value only applies to WebGL2 contexts that support multisample render targets.
+ * @param {number} [options.msaaSamples=4] If provided, this value controls the rate of multisample antialiasing. Typical multisampling rates are 2, 4, and sometimes 8 samples per pixel. Higher sampling rates of MSAA may impact performance in exchange for improved visual quality. This value only applies to WebGL2 contexts that support multisample render targets. Set to 1 to disable MSAA.
  *
  * @exception {DeveloperError} Element with id "container" does not exist in the document.
  *
diff --git a/packages/engine/Specs/DataSources/CallbackPositionPropertySpec.js b/packages/engine/Specs/DataSources/CallbackPositionPropertySpec.js
new file mode 100644
index 000000000000..c9c2470f89aa
--- /dev/null
+++ b/packages/engine/Specs/DataSources/CallbackPositionPropertySpec.js
@@ -0,0 +1,196 @@
+import {
+  JulianDate,
+  CallbackPositionProperty,
+  Cartesian3,
+  PositionProperty,
+  ReferenceFrame,
+} from "../../index.js";
+
+describe("DataSources/CallbackPositionProperty", function () {
+  const time = JulianDate.now();
+
+  it("constructor throws with undefined isConstant", function () {
+    expect(function () {
+      return new CallbackPositionProperty(function () {}, undefined);
+    }).toThrowDeveloperError();
+  });
+
+  it("constructor throws with undefined callback", function () {
+    expect(function () {
+      return new CallbackPositionProperty(undefined, true);
+    }).toThrowDeveloperError();
+  });
+
+  it("constructor sets expected defaults", function () {
+    const callback = jasmine.createSpy("callback");
+    let property = new CallbackPositionProperty(callback, true);
+    expect(property.referenceFrame).toBe(ReferenceFrame.FIXED);
+
+    property = new CallbackPositionProperty(
+      callback,
+      true,
+      ReferenceFrame.INERTIAL
+    );
+    expect(property.referenceFrame).toBe(ReferenceFrame.INERTIAL);
+  });
+
+  it("callback received proper parameters", function () {
+    const result = {};
+    const callback = jasmine.createSpy("callback");
+    const property = new CallbackPositionProperty(callback, true);
+    property.getValue(time, result);
+    expect(callback).toHaveBeenCalledWith(time, result);
+  });
+
+  it("getValue returns callback result", function () {
+    const value = new Cartesian3(1, 2, 3);
+    const callback = function (_time, result) {
+      return value.clone(result);
+    };
+    const property = new CallbackPositionProperty(callback, true);
+    const result = property.getValue(time);
+    expect(result).not.toBe(value);
+    expect(result).toEqual(value);
+
+    const value2 = new Cartesian3();
+    expect(property.getValue(time, value2)).toBe(value2);
+  });
+
+  it("getValue returns in fixed frame", function () {
+    const valueInertial = new Cartesian3(1, 2, 3);
+    const valueFixed = PositionProperty.convertToReferenceFrame(
+      time,
+      valueInertial,
+      ReferenceFrame.INERTIAL,
+      ReferenceFrame.FIXED
+    );
+    const callback = function (_time, result) {
+      return valueInertial.clone(result);
+    };
+    const property = new CallbackPositionProperty(
+      callback,
+      true,
+      ReferenceFrame.INERTIAL
+    );
+
+    const result = property.getValue(time);
+    expect(result).toEqual(valueFixed);
+  });
+
+  it("getValue uses JulianDate.now() if time parameter is undefined", function () {
+    spyOn(JulianDate, "now").and.callThrough();
+
+    const value = new Cartesian3(1, 2, 3);
+    const callback = function (_time, result) {
+      return value.clone(result);
+    };
+    const property = new CallbackPositionProperty(callback, true);
+    const actualResult = property.getValue();
+    expect(JulianDate.now).toHaveBeenCalled();
+    expect(actualResult).toEqual(value);
+  });
+
+  it("getValueInReferenceFrame works without a result parameter", function () {
+    const value = new Cartesian3(1, 2, 3);
+    const callback = function (_time, result) {
+      return value.clone(result);
+    };
+    const property = new CallbackPositionProperty(callback, true);
+
+    const result = property.getValueInReferenceFrame(
+      time,
+      ReferenceFrame.INERTIAL
+    );
+    expect(result).not.toBe(value);
+    expect(result).toEqual(
+      PositionProperty.convertToReferenceFrame(
+        time,
+        value,
+        ReferenceFrame.FIXED,
+        ReferenceFrame.INERTIAL
+      )
+    );
+  });
+
+  it("getValueInReferenceFrame works with a result parameter", function () {
+    const value = new Cartesian3(1, 2, 3);
+    const callback = function (_time, result) {
+      return value.clone(result);
+    };
+    const property = new CallbackPositionProperty(
+      callback,
+      true,
+      ReferenceFrame.INERTIAL
+    );
+
+    const expected = new Cartesian3();
+    const result = property.getValueInReferenceFrame(
+      time,
+      ReferenceFrame.FIXED,
+      expected
+    );
+    expect(result).toBe(expected);
+    expect(expected).toEqual(
+      PositionProperty.convertToReferenceFrame(
+        time,
+        value,
+        ReferenceFrame.INERTIAL,
+        ReferenceFrame.FIXED
+      )
+    );
+  });
+
+  it("getValueInReferenceFrame throws with undefined time", function () {
+    const property = new CallbackPositionProperty(function () {}, true);
+
+    expect(function () {
+      property.getValueInReferenceFrame(undefined, ReferenceFrame.FIXED);
+    }).toThrowDeveloperError();
+  });
+
+  it("getValueInReferenceFrame throws with undefined reference frame", function () {
+    const property = new CallbackPositionProperty(function () {}, true);
+
+    expect(function () {
+      property.getValueInReferenceFrame(time, undefined);
+    }).toThrowDeveloperError();
+  });
+
+  it("isConstant returns correct value", function () {
+    const property = new CallbackPositionProperty(function () {}, true);
+    expect(property.isConstant).toBe(true);
+    property.setCallback(function () {}, false);
+    expect(property.isConstant).toBe(false);
+  });
+
+  it("setCallback raises definitionChanged event", function () {
+    const property = new CallbackPositionProperty(function () {}, true);
+    const listener = jasmine.createSpy("listener");
+    property.definitionChanged.addEventListener(listener);
+    property.setCallback(function () {}, false);
+    expect(listener).toHaveBeenCalledWith(property);
+  });
+
+  it("equals works", function () {
+    const callback = function () {};
+    const left = new CallbackPositionProperty(callback, true);
+    let right = new CallbackPositionProperty(callback, true);
+
+    expect(left.equals(right)).toEqual(true);
+
+    right.setCallback(callback, false);
+    expect(left.equals(right)).toEqual(false);
+
+    right.setCallback(function () {
+      return undefined;
+    }, true);
+    expect(left.equals(right)).toEqual(false);
+
+    right = new CallbackPositionProperty(
+      callback,
+      true,
+      ReferenceFrame.INERTIAL
+    );
+    expect(left.equals(right)).toEqual(false);
+  });
+});
diff --git a/packages/engine/Specs/DataSources/ConstantPositionPropertySpec.js b/packages/engine/Specs/DataSources/ConstantPositionPropertySpec.js
index 7c1442cdef94..0d4c734aeef8 100644
--- a/packages/engine/Specs/DataSources/ConstantPositionPropertySpec.js
+++ b/packages/engine/Specs/DataSources/ConstantPositionPropertySpec.js
@@ -61,7 +61,7 @@ describe("DataSources/ConstantPositionProperty", function () {
     expect(property.getValue(time)).toBeUndefined();
   });
 
-  it("getValue work swith undefined inertial value", function () {
+  it("getValue works with undefined inertial value", function () {
     const property = new ConstantPositionProperty(
       undefined,
       ReferenceFrame.INERTIAL
diff --git a/packages/engine/Specs/DataSources/PathVisualizerSpec.js b/packages/engine/Specs/DataSources/PathVisualizerSpec.js
index c34f20ce89d9..ce9ecfff2787 100644
--- a/packages/engine/Specs/DataSources/PathVisualizerSpec.js
+++ b/packages/engine/Specs/DataSources/PathVisualizerSpec.js
@@ -16,6 +16,8 @@ import {
   PolylineOutlineMaterialProperty,
   ReferenceProperty,
   SampledPositionProperty,
+  CallbackPositionProperty,
+  LinearSpline,
   ScaledPositionProperty,
   TimeIntervalCollectionPositionProperty,
   SceneMode,
@@ -733,6 +735,58 @@ describe(
       expect(result).toEqual([new Cartesian3(0, 0, 3)]);
     });
 
+    it("subSample works for callback position properties", function () {
+      const t1 = new JulianDate(0, 0);
+      const t2 = new JulianDate(2, 0);
+      const updateTime = new JulianDate(1, 1);
+      const duration = JulianDate.secondsDifference(t2, t1);
+      const spline = new LinearSpline({
+        times: [0, 1],
+        points: [new Cartesian3(0, 0, 0), new Cartesian3(0, 0, 1)],
+      });
+      const callback = function (time, result) {
+        if (JulianDate.lessThan(time, t1) || JulianDate.greaterThan(time, t2)) {
+          return undefined;
+        }
+        if (result === undefined) {
+          result = new Cartesian3();
+        }
+        const delta = JulianDate.secondsDifference(time, t1);
+        return spline.evaluate(delta / duration, result);
+      };
+
+      const property = new CallbackPositionProperty(callback, false);
+
+      const referenceFrame = ReferenceFrame.FIXED;
+      const maximumStep = 43200;
+      const result = [];
+      PathVisualizer._subSample(
+        property,
+        t1,
+        t2,
+        updateTime,
+        referenceFrame,
+        maximumStep,
+        result
+      );
+      expect(result).toEqual([
+        property.getValue(t1),
+        property.getValue(
+          JulianDate.addSeconds(t1, maximumStep, new JulianDate())
+        ),
+        property.getValue(
+          JulianDate.addSeconds(t1, maximumStep * 2, new JulianDate())
+        ),
+        property.getValue(updateTime),
+        property.getValue(
+          JulianDate.addSeconds(t1, maximumStep * 3, new JulianDate())
+        ),
+        property.getValue(
+          JulianDate.addSeconds(t1, maximumStep * 4, new JulianDate())
+        ),
+      ]);
+    });
+
     function CustomPositionProperty(innerProperty) {
       this.SampledProperty = innerProperty;
       this.isConstant = innerProperty.isConstant;
diff --git a/packages/engine/Specs/Scene/Cesium3DTilesetSpec.js b/packages/engine/Specs/Scene/Cesium3DTilesetSpec.js
index c462f5195096..0419ed73eb27 100644
--- a/packages/engine/Specs/Scene/Cesium3DTilesetSpec.js
+++ b/packages/engine/Specs/Scene/Cesium3DTilesetSpec.js
@@ -702,32 +702,33 @@ describe(
         scene.camera.lookAt(center, viewEast);
         expect(renderOptions).toRenderAndCall(function (rgba) {
           expect(rgba[0]).toBeGreaterThan(190);
-          expect(rgba[1]).toBeLessThan(64);
-          expect(rgba[2]).toBeLessThan(64);
+          expect(rgba[1]).toBeLessThanOrEqual(108);
+          expect(rgba[2]).toBeLessThanOrEqual(108);
           expect(rgba[3]).toEqual(255);
         });
 
         // The north (+y) face of the cube is green
         scene.camera.lookAt(center, viewNorth);
         expect(renderOptions).toRenderAndCall(function (rgba) {
-          expect(rgba[0]).toBeLessThan(64);
+          expect(rgba[0]).toBeLessThanOrEqual(108);
           expect(rgba[1]).toBeGreaterThan(190);
-          expect(rgba[2]).toBeLessThan(64);
+          expect(rgba[2]).toBeLessThanOrEqual(108);
           expect(rgba[3]).toEqual(255);
         });
 
         // The up (+z) face of the cube is blue
         scene.camera.lookAt(center, viewUp);
         expect(renderOptions).toRenderAndCall(function (rgba) {
-          expect(rgba[0]).toBeLessThan(64);
-          expect(rgba[1]).toBeLessThan(64);
+          expect(rgba[0]).toBeLessThanOrEqual(108);
+          expect(rgba[1]).toBeLessThanOrEqual(108);
           expect(rgba[2]).toBeGreaterThan(190);
           expect(rgba[3]).toEqual(255);
         });
       });
     });
 
-    it("verify statistics", async function () {
+    xit("verify statistics", async function () {
+      // Excluded due to frequent CI errors https://github.com/CesiumGS/cesium/issues/11958
       const tileset = await Cesium3DTileset.fromUrl(tilesetUrl, options);
 
       // Verify initial values after root and children are requested
@@ -2598,7 +2599,7 @@ describe(
         tileset.boundingSphere.center
       );
       const height = tileset.getHeight(center, scene);
-      expect(height).toEqualEpsilon(78.1558019795064, CesiumMath.EPSILON12);
+      expect(height).toEqualEpsilon(78.1558019795064, CesiumMath.EPSILON8);
     });
 
     it("getHeight samples height accounting for vertical exaggeration", async function () {
@@ -2614,7 +2615,7 @@ describe(
         tileset.boundingSphere.center
       );
       const height = tileset.getHeight(center, scene);
-      expect(height).toEqualEpsilon(156.31161477299992, CesiumMath.EPSILON12);
+      expect(height).toEqualEpsilon(156.31161477299992, CesiumMath.EPSILON8);
     });
 
     it("destroys", function () {
@@ -3331,10 +3332,10 @@ describe(
       });
 
       expect(renderOptions).toRenderAndCall(function (rgba) {
-        expect(rgba[0]).toBeGreaterThan(200);
-        expect(rgba[1]).toBeLessThan(25);
-        expect(rgba[2]).toBeLessThan(25);
-        expect(rgba[3]).toEqual(255);
+        expect(rgba[0]).withContext("starting red .r").toBeGreaterThan(200);
+        expect(rgba[1]).withContext("starting red .g").toEqualEpsilon(116, 1);
+        expect(rgba[2]).withContext("starting red .b").toEqualEpsilon(116, 1);
+        expect(rgba[3]).withContext("starting red .a").toEqual(255);
       });
 
       // Use HIGHLIGHT blending
@@ -3346,11 +3347,13 @@ describe(
       });
 
       expect(renderOptions).toRenderAndCall(function (rgba) {
-        expect(rgba[0]).toBeGreaterThan(100);
-        expect(rgba[0]).toBeLessThan(sourceRed);
-        expect(rgba[1]).toBeLessThan(25);
-        expect(rgba[2]).toBeLessThan(25);
-        expect(rgba[3]).toEqual(255);
+        expect(rgba[0]).withContext("hl dark yellow .r").toBeGreaterThan(100);
+        expect(rgba[0])
+          .withContext("hl dark yellow .r")
+          .toBeLessThan(sourceRed);
+        expect(rgba[1]).withContext("hl dark yellow .g").toEqualEpsilon(58, 1);
+        expect(rgba[2]).withContext("hl dark yellow .b").toEqualEpsilon(0, 1);
+        expect(rgba[3]).withContext("hl dark yellow .a").toEqual(255);
       });
 
       // Style with yellow + alpha. Expect the red channel to be darker than before.
@@ -3359,11 +3362,13 @@ describe(
       });
 
       expect(renderOptions).toRenderAndCall(function (rgba) {
-        expect(rgba[0]).toBeGreaterThan(100);
-        expect(rgba[0]).toBeLessThan(sourceRed);
-        expect(rgba[1]).toBeLessThan(25);
-        expect(rgba[2]).toBeLessThan(25);
-        expect(rgba[3]).toEqual(255);
+        expect(rgba[0]).withContext("hl yellow+alpha .r").toBeGreaterThan(100);
+        expect(rgba[0])
+          .withContext("hl yellow+alpha .r")
+          .toBeLessThan(sourceRed);
+        expect(rgba[1]).withContext("hl yellow+alpha .g").toEqualEpsilon(43, 1);
+        expect(rgba[2]).withContext("hl yellow+alpha .b").toEqualEpsilon(0, 1);
+        expect(rgba[3]).withContext("hl yellow+alpha .a").toEqual(255);
       });
 
       // Use REPLACE blending
@@ -3377,12 +3382,12 @@ describe(
       expect(renderOptions).toRenderAndCall(function (rgba) {
         replaceRed = rgba[0];
         replaceGreen = rgba[1];
-        expect(rgba[0]).toBeGreaterThan(100);
-        expect(rgba[0]).toBeLessThan(255);
-        expect(rgba[1]).toBeGreaterThan(100);
-        expect(rgba[1]).toBeLessThan(255);
-        expect(rgba[2]).toBeLessThan(25);
-        expect(rgba[3]).toEqual(255);
+        expect(rgba[0]).withContext("replace yellow .r").toBeGreaterThan(100);
+        expect(rgba[0]).withContext("replace yellow .r").toBeLessThan(255);
+        expect(rgba[1]).withContext("replace yellow .g").toBeGreaterThan(100);
+        expect(rgba[1]).withContext("replace yellow .g").toBeLessThan(255);
+        expect(rgba[2]).withContext("replace yellow .b").toEqualEpsilon(73, 1);
+        expect(rgba[3]).withContext("replace yellow .a").toEqual(255);
       });
 
       // Style with yellow + alpha. Expect the red and green channels to be a shade of yellow.
@@ -3391,12 +3396,22 @@ describe(
       });
 
       expect(renderOptions).toRenderAndCall(function (rgba) {
-        expect(rgba[0]).toBeGreaterThan(100);
-        expect(rgba[0]).toBeLessThan(255);
-        expect(rgba[1]).toBeGreaterThan(100);
-        expect(rgba[1]).toBeLessThan(255);
-        expect(rgba[2]).toBeLessThan(25);
-        expect(rgba[3]).toEqual(255);
+        expect(rgba[0])
+          .withContext("replace yellow+alpha .r")
+          .toBeGreaterThan(100);
+        expect(rgba[0])
+          .withContext("replace yellow+alpha .r")
+          .toBeLessThan(255);
+        expect(rgba[1])
+          .withContext("replace yellow+alpha .g")
+          .toBeGreaterThan(100);
+        expect(rgba[1])
+          .withContext("replace yellow+alpha .g")
+          .toBeLessThan(255);
+        expect(rgba[2])
+          .withContext("replace yellow+alpha .b")
+          .toEqualEpsilon(48, 1);
+        expect(rgba[3]).withContext("replace yellow+alpha .a").toEqual(255);
       });
 
       // Use MIX blending
@@ -3413,41 +3428,49 @@ describe(
       expect(renderOptions).toRenderAndCall(function (rgba) {
         mixRed = rgba[0];
         mixGreen = rgba[1];
-        expect(rgba[0]).toBeGreaterThan(replaceRed);
-        expect(rgba[0]).toBeLessThan(sourceRed);
-        expect(rgba[1]).toBeGreaterThan(sourceGreen);
-        expect(rgba[1]).toBeLessThan(replaceGreen);
-        expect(rgba[2]).toBeLessThan(25);
-        expect(rgba[3]).toEqual(255);
+        expect(rgba[0])
+          .withContext("mix yellow .r")
+          .toBeGreaterThan(replaceRed);
+        expect(rgba[0]).withContext("mix yellow .r").toBeLessThan(sourceRed);
+        expect(rgba[1])
+          .withContext("mix yellow .g")
+          .toBeGreaterThan(sourceGreen);
+        expect(rgba[1]).withContext("mix yellow .g").toBeLessThan(replaceGreen);
+        expect(rgba[2]).withContext("mix yellow .b").toEqualEpsilon(94, 1);
+        expect(rgba[3]).withContext("mix yellow .a").toEqual(255);
       });
 
       // Set colorBlendAmount to 0.25. Expect color to be closer to the source color.
       tileset.colorBlendAmount = 0.25;
       expect(renderOptions).toRenderAndCall(function (rgba) {
-        expect(rgba[0]).toBeGreaterThan(mixRed);
-        expect(rgba[0]).toBeLessThan(sourceRed);
-        expect(rgba[1]).toBeGreaterThan(0);
-        expect(rgba[1]).toBeLessThan(mixGreen);
-        expect(rgba[2]).toBeLessThan(25);
-        expect(rgba[3]).toEqual(255);
+        expect(rgba[0])
+          .withContext("mix blend 0.25 .r")
+          .toBeGreaterThan(mixRed);
+        expect(rgba[0])
+          .withContext("mix blend 0.25 .r")
+          .toBeLessThanOrEqual(sourceRed);
+        expect(rgba[1]).withContext("mix blend 0.25 .g").toBeGreaterThan(0);
+        expect(rgba[1]).withContext("mix blend 0.25 .g").toBeLessThan(mixGreen);
+        expect(rgba[2]).withContext("mix blend 0.25 .b").toEqualEpsilon(106, 1);
+        expect(rgba[3]).withContext("mix blend 0.25 .a").toEqual(255);
       });
 
       // Set colorBlendAmount to 0.0. Expect color to equal the source color
       tileset.colorBlendAmount = 0.0;
       expect(renderOptions).toRenderAndCall(function (rgba) {
-        expect(rgba[0]).toEqual(sourceRed);
-        expect(rgba[1]).toBeLessThan(25);
-        expect(rgba[2]).toBeLessThan(25);
-        expect(rgba[3]).toEqual(255);
+        expect(rgba[0]).withContext("mix blend 0.0 .r").toEqual(sourceRed);
+        expect(rgba[1]).withContext("mix blend 0.0 .g").toEqualEpsilon(116, 1);
+        expect(rgba[2]).withContext("mix blend 0.0 .b").toEqualEpsilon(116, 1);
+        expect(rgba[3]).withContext("mix blend 0.0 .a").toEqual(255);
       });
 
       // Set colorBlendAmount to 1.0. Expect color to equal the style color
       tileset.colorBlendAmount = 1.0;
       expect(renderOptions).toRenderAndCall(function (rgba) {
-        expect(rgba[0]).toEqual(replaceRed);
-        expect(rgba[1]).toEqual(replaceGreen);
-        expect(rgba[2]).toBeLessThan(25);
-        expect(rgba[3]).toEqual(255);
+        expect(rgba[0]).withContext("mix blend 1.0 .r").toEqual(replaceRed);
+        expect(rgba[1]).withContext("mix blend 1.0 .g").toEqual(replaceGreen);
+        expect(rgba[2]).withContext("mix blend 1.0 .b").toEqualEpsilon(73, 1);
+        expect(rgba[3]).withContext("mix blend 1.0 .a").toEqual(255);
       });
 
       // Style with yellow + alpha. Expect color to be a mix of the source and style colors.
@@ -3457,10 +3480,12 @@ describe(
       });
 
       expect(renderOptions).toRenderAndCall(function (rgba) {
-        expect(rgba[0]).toBeGreaterThan(0);
-        expect(rgba[1]).toBeGreaterThan(0);
-        expect(rgba[2]).toBeLessThan(25);
-        expect(rgba[3]).toEqual(255);
+        expect(rgba[0]).withContext("mix yellow+alpha .r").toBeGreaterThan(0);
+        expect(rgba[1]).withContext("mix yellow+alpha .g").toBeGreaterThan(0);
+        expect(rgba[2])
+          .withContext("mix yellow+alpha .b")
+          .toEqualEpsilon(43, 1);
+        expect(rgba[3]).withContext("mix yellow+alpha .a").toEqual(255);
       });
     }
 
diff --git a/packages/engine/Specs/Scene/GlobeSurfaceTileProviderSpec.js b/packages/engine/Specs/Scene/GlobeSurfaceTileProviderSpec.js
index 1d14e3bffe09..b591e61c10c6 100644
--- a/packages/engine/Specs/Scene/GlobeSurfaceTileProviderSpec.js
+++ b/packages/engine/Specs/Scene/GlobeSurfaceTileProviderSpec.js
@@ -1635,6 +1635,52 @@ describe(
         });
       });
     });
+
+    it("hasWaterMask returns expected value", async function () {
+      // Mock terrain tile loading
+      Resource._Implementations.loadWithXhr = function (
+        url,
+        responseType,
+        method,
+        data,
+        headers,
+        deferred,
+        overrideMimeType
+      ) {
+        if (defined(url.match(/\/\d+\/\d+\/\d+\.terrain/))) {
+          Resource._DefaultImplementations.loadWithXhr(
+            "Data/CesiumTerrainTileJson/tile.32bitIndices.terrain",
+            responseType,
+            method,
+            data,
+            headers,
+            deferred
+          );
+          return;
+        }
+
+        Resource._DefaultImplementations.loadWithXhr(
+          url,
+          responseType,
+          method,
+          data,
+          headers,
+          deferred,
+          overrideMimeType
+        );
+      };
+      scene.terrainProvider = await CesiumTerrainProvider.fromUrl(
+        "Data/CesiumTerrainTileJson/QuantizedMesh.tile.json",
+        {
+          requestWaterMask: true,
+        }
+      );
+      scene.globe.showWaterEffect = false;
+
+      await updateUntilDone(scene.globe);
+
+      expect(scene.globe._surface.tileProvider.hasWaterMask).toBeTrue();
+    });
   },
   "WebGL"
 );
diff --git a/packages/engine/Specs/Scene/GroundPolylinePrimitiveSpec.js b/packages/engine/Specs/Scene/GroundPolylinePrimitiveSpec.js
index fd9f8eeb639c..e7e7347483e8 100644
--- a/packages/engine/Specs/Scene/GroundPolylinePrimitiveSpec.js
+++ b/packages/engine/Specs/Scene/GroundPolylinePrimitiveSpec.js
@@ -56,6 +56,7 @@ describe(
         canvas: canvas,
       });
       scene.postProcessStages.fxaa.enabled = false;
+      scene.msaaSamples = 1;
 
       context = scene.context;
 
diff --git a/packages/engine/Specs/Scene/Model/Model3DTileContentSpec.js b/packages/engine/Specs/Scene/Model/Model3DTileContentSpec.js
index 9977725b918f..1aa9a724e95c 100644
--- a/packages/engine/Specs/Scene/Model/Model3DTileContentSpec.js
+++ b/packages/engine/Specs/Scene/Model/Model3DTileContentSpec.js
@@ -1169,6 +1169,7 @@ describe(
         const scene = createScene({
           canvas: createCanvas(10, 10),
         });
+        scene.msaaSamples = 1;
         noAttenuationPixelCount = scene.logarithmicDepthBuffer ? 20 : 16;
         const center = new Cartesian3.fromRadians(
           centerLongitude,
diff --git a/packages/engine/Specs/Scene/Model/ModelRuntimePrimitiveSpec.js b/packages/engine/Specs/Scene/Model/ModelRuntimePrimitiveSpec.js
index 6e73cc3fbc8b..273a138e3dcb 100644
--- a/packages/engine/Specs/Scene/Model/ModelRuntimePrimitiveSpec.js
+++ b/packages/engine/Specs/Scene/Model/ModelRuntimePrimitiveSpec.js
@@ -44,6 +44,7 @@ describe("Scene/Model/ModelRuntimePrimitive", function () {
     type: ModelType.GLTF,
     allowPicking: true,
     featureIdLabel: "featureId_0",
+    hasVerticalExaggeration: true,
   };
   const mockWebgl1Context = {
     webgl2: false,
@@ -992,4 +993,31 @@ describe("Scene/Model/ModelRuntimePrimitive", function () {
     primitive.configurePipeline(frameState);
     verifyExpectedStages(primitive.pipelineStages, expectedStages);
   });
+
+  it("configures pipeline stages for vertical exaggeration when enableVerticalExaggeration is false", function () {
+    const primitive = new ModelRuntimePrimitive({
+      primitive: mockPrimitive,
+      node: mockNode,
+      model: {
+        ...mockModel,
+        hasVerticalExaggeration: false,
+      },
+    });
+    const frameState = createFrameState(mockWebgl2Context);
+    frameState.verticalExaggeration = 2.0;
+
+    const expectedStages = [
+      GeometryPipelineStage,
+      MaterialPipelineStage,
+      FeatureIdPipelineStage,
+      MetadataPipelineStage,
+      LightingPipelineStage,
+      PickingPipelineStage,
+      AlphaPipelineStage,
+      PrimitiveStatisticsPipelineStage,
+    ];
+
+    primitive.configurePipeline(frameState);
+    verifyExpectedStages(primitive.pipelineStages, expectedStages);
+  });
 });
diff --git a/packages/engine/Specs/Scene/Model/ModelSpec.js b/packages/engine/Specs/Scene/Model/ModelSpec.js
index b3ab7a92e0fb..8a6386bd7c18 100644
--- a/packages/engine/Specs/Scene/Model/ModelSpec.js
+++ b/packages/engine/Specs/Scene/Model/ModelSpec.js
@@ -517,6 +517,8 @@ describe(
       expect(model.id).toBeUndefined();
       expect(model.allowPicking).toEqual(true);
 
+      expect(model.enableVerticalExaggeration).toEqual(true);
+
       expect(model.activeAnimations).toBeDefined();
       expect(model.clampAnimations).toEqual(true);
 
@@ -3769,7 +3771,28 @@ describe(
       scene.verticalExaggeration = 2.0;
       scene.renderForSpecs();
       expect(resetDrawCommands).toHaveBeenCalled();
-      scene.verticalExaggeration = 1.0;
+    });
+
+    it("resets draw commands when enableVerticalExaggeration changes", async function () {
+      scene.verticalExaggeration = 2.0;
+      const model = await loadAndZoomToModelAsync(
+        {
+          gltf: boxTexturedGltfUrl,
+        },
+        scene
+      );
+      const resetDrawCommands = spyOn(
+        model,
+        "resetDrawCommands"
+      ).and.callThrough();
+      expect(model.ready).toBe(true);
+      expect(model.hasVerticalExaggeration).toBe(true);
+
+      model.enableVerticalExaggeration = false;
+
+      scene.renderForSpecs();
+      expect(resetDrawCommands).toHaveBeenCalled();
+      expect(model.hasVerticalExaggeration).toBe(false);
     });
 
     it("does not issue draw commands when ignoreCommands is true", async function () {
diff --git a/packages/engine/Specs/Scene/PostProcessStageCollectionSpec.js b/packages/engine/Specs/Scene/PostProcessStageCollectionSpec.js
index 85bca942fbfb..20f2260bb231 100644
--- a/packages/engine/Specs/Scene/PostProcessStageCollectionSpec.js
+++ b/packages/engine/Specs/Scene/PostProcessStageCollectionSpec.js
@@ -381,110 +381,212 @@ describe(
       expect(scene).toRender([0, 255, 255, 255]);
     });
 
-    it("uses Reinhard tonemapping", function () {
-      if (!scene.highDynamicRangeSupported) {
-        return;
+    describe("HDR tonemapping", () => {
+      const black = [0, 0, 0, 255];
+      const grey = [0.5, 0.5, 0.5, 1.0];
+      const white = [4.0, 4.0, 4.0, 1.0];
+      const red = [4.0, 0.0, 0.0, 1.0];
+      const green = [0.0, 4.0, 0.0, 1.0];
+      const blue = [0.0, 0.0, 4.0, 1.0];
+
+      /**
+       * @param {Tonemapper} tonemapper
+       * @param {number[]} inputFragColor rgba in float values to use in fragment shader
+       * @param {number[]} expectedColor rgba in rgb 0-255 to use for expected rendered colors
+       */
+      function validateTonemapper(tonemapper, inputFragColor, expectedColor) {
+        if (!scene.highDynamicRangeSupported) {
+          return;
+        }
+
+        scene.postProcessStages.tonemapper = tonemapper;
+
+        const inputColorRgb = inputFragColor.map((n) =>
+          Math.floor(Math.min(Math.max(n * 255, 0), 255))
+        );
+        const fs =
+          "void main() { \n" +
+          `    out_FragColor = vec4(${inputFragColor.join(", ")}); \n` +
+          "} \n";
+        scene.primitives.add(new ViewportPrimitive(fs));
+
+        // validate we start by rendering the expected color
+        expect(scene)
+          .withContext(`without HDR`)
+          .toRenderAndCall((rgba) => {
+            expect(rgba[0])
+              .withContext("r")
+              .toEqualEpsilon(inputColorRgb[0], 1);
+            expect(rgba[1])
+              .withContext("g")
+              .toEqualEpsilon(inputColorRgb[1], 1);
+            expect(rgba[2])
+              .withContext("b")
+              .toEqualEpsilon(inputColorRgb[2], 1);
+            expect(rgba[3]).withContext("a").toEqual(inputColorRgb[3]);
+          });
+        // toggle HDR on
+        scene.highDynamicRange = true;
+        // validate we render a DIFFERENT color, not black, and that it matches the expected color
+        expect(scene).toRenderAndCall(function (rgba) {
+          expect(rgba).not.toEqual(black);
+          expect(rgba).withContext(`with HDR`).not.toEqual(inputColorRgb);
+          expect(rgba[0]).withContext("r").toEqual(expectedColor[0]);
+          expect(rgba[1]).withContext("g").toEqual(expectedColor[1]);
+          expect(rgba[2]).withContext("b").toEqual(expectedColor[2]);
+          expect(rgba[3]).withContext("a").toEqual(expectedColor[3]);
+        });
       }
 
-      const fs =
-        "void main() { \n" +
-        "    out_FragColor = vec4(4.0, 0.0, 0.0, 1.0); \n" +
-        "} \n";
-      scene.primitives.add(new ViewportPrimitive(fs));
-
-      scene.postProcessStages.tonemapper = Tonemapper.REINHARD;
-
-      expect(scene).toRender([255, 0, 0, 255]);
-      scene.highDynamicRange = true;
-      expect(scene).toRenderAndCall(function (rgba) {
-        expect(rgba).not.toEqual([0, 0, 0, 255]);
-        expect(rgba).not.toEqual([255, 0, 0, 255]);
-        expect(rgba[0]).toBeGreaterThan(0);
-        expect(rgba[1]).toEqual(0);
-        expect(rgba[2]).toEqual(0);
-        expect(rgba[3]).toEqual(255);
+      describe("Reinhard", () => {
+        it("white", () => {
+          validateTonemapper(Tonemapper.REINHARD, white, [230, 230, 230, 255]);
+        });
+        it("grey", () => {
+          validateTonemapper(Tonemapper.REINHARD, grey, [155, 155, 155, 255]);
+        });
+        it("red", () => {
+          validateTonemapper(Tonemapper.REINHARD, red, [230, 0, 0, 255]);
+        });
+        it("green", () => {
+          validateTonemapper(Tonemapper.REINHARD, green, [0, 230, 0, 255]);
+        });
+        it("blue", () => {
+          validateTonemapper(Tonemapper.REINHARD, blue, [0, 0, 230, 255]);
+        });
       });
-      scene.highDynamicRange = false;
-    });
-
-    it("uses modified Reinhard tonemapping", function () {
-      if (!scene.highDynamicRangeSupported) {
-        return;
-      }
 
-      const fs =
-        "void main() { \n" +
-        "    out_FragColor = vec4(0.5, 0.0, 0.0, 1.0); \n" +
-        "} \n";
-      scene.primitives.add(new ViewportPrimitive(fs));
-
-      scene.postProcessStages.tonemapper = Tonemapper.MODIFIED_REINHARD;
-
-      expect(scene).toRenderAndCall(function (rgba) {
-        expect(rgba).toEqualEpsilon([127, 0, 0, 255], 5);
+      describe("Modified Reinhard", () => {
+        it("white", () => {
+          // our white point is currently set to 1.0 which means pure white in = pure white out
+          // this is a special check the helper cannot account for
+          if (!scene.highDynamicRangeSupported) {
+            return;
+          }
+
+          const fs =
+            "void main() { \n" +
+            "    out_FragColor = vec4(4.0, 4.0, 4.0, 1.0); \n" +
+            "} \n";
+          scene.primitives.add(new ViewportPrimitive(fs));
+
+          scene.postProcessStages.tonemapper = Tonemapper.MODIFIED_REINHARD;
+
+          expect(scene).toRender([255, 255, 255, 255]);
+          scene.highDynamicRange = true;
+          expect(scene).toRenderAndCall(function (rgba) {
+            expect(rgba).not.toEqual(black);
+            expect(rgba).toEqual([255, 255, 255, 255]);
+            expect(rgba[0]).withContext("r").toEqual(255);
+            expect(rgba[1]).withContext("g").toEqual(255);
+            expect(rgba[2]).withContext("b").toEqual(255);
+            expect(rgba[3]).withContext("a").toEqual(255);
+          });
+          scene.highDynamicRange = false;
+        });
+        it("grey", () => {
+          validateTonemapper(
+            Tonemapper.MODIFIED_REINHARD,
+            [0.5, 0.5, 0.5, 1.0],
+            [186, 186, 186, 255]
+          );
+        });
+        it("red", () => {
+          validateTonemapper(
+            Tonemapper.MODIFIED_REINHARD,
+            [0.5, 0.0, 0.0, 1.0],
+            [186, 0, 0, 255]
+          );
+        });
+        it("green", () => {
+          validateTonemapper(
+            Tonemapper.MODIFIED_REINHARD,
+            [0.0, 0.5, 0.0, 1.0],
+            [0, 186, 0, 255]
+          );
+        });
+        it("blue", () => {
+          validateTonemapper(
+            Tonemapper.MODIFIED_REINHARD,
+            [0.0, 0.0, 0.5, 1.0],
+            [0, 0, 186, 255]
+          );
+        });
       });
-      scene.highDynamicRange = true;
-      expect(scene).toRenderAndCall(function (rgba) {
-        expect(rgba).not.toEqual([0, 0, 0, 255]);
-        expect(rgba).not.toEqual([127, 0, 0, 255]);
-        expect(rgba[0]).toBeGreaterThan(0);
-        expect(rgba[1]).toEqual(0);
-        expect(rgba[2]).toEqual(0);
-        expect(rgba[3]).toEqual(255);
-      });
-      scene.highDynamicRange = false;
-    });
-
-    it("uses filmic tonemapping", function () {
-      if (!scene.highDynamicRangeSupported) {
-        return;
-      }
 
-      const fs =
-        "void main() { \n" +
-        "    out_FragColor = vec4(4.0, 0.0, 0.0, 1.0); \n" +
-        "} \n";
-      scene.primitives.add(new ViewportPrimitive(fs));
-
-      scene.postProcessStages.tonemapper = Tonemapper.FILMIC;
-
-      expect(scene).toRender([255, 0, 0, 255]);
-      scene.highDynamicRange = true;
-      expect(scene).toRenderAndCall(function (rgba) {
-        expect(rgba).not.toEqual([0, 0, 0, 255]);
-        expect(rgba).not.toEqual([255, 0, 0, 255]);
-        expect(rgba[0]).toBeGreaterThan(0);
-        expect(rgba[1]).toEqual(0);
-        expect(rgba[2]).toEqual(0);
-        expect(rgba[3]).toEqual(255);
+      describe("Filmic", () => {
+        it("white", () => {
+          validateTonemapper(Tonemapper.FILMIC, white, [236, 236, 236, 255]);
+        });
+        it("grey", () => {
+          validateTonemapper(Tonemapper.FILMIC, grey, [142, 142, 142, 255]);
+        });
+        it("red", () => {
+          validateTonemapper(Tonemapper.FILMIC, red, [236, 0, 0, 255]);
+        });
+        it("green", () => {
+          validateTonemapper(Tonemapper.FILMIC, green, [0, 236, 0, 255]);
+        });
+        it("blue", () => {
+          validateTonemapper(Tonemapper.FILMIC, blue, [0, 0, 236, 255]);
+        });
       });
-      scene.highDynamicRange = false;
-    });
 
-    it("uses ACES tonemapping", function () {
-      if (!scene.highDynamicRangeSupported) {
-        return;
-      }
+      describe("ACES", () => {
+        it("white", () => {
+          validateTonemapper(Tonemapper.ACES, white, [245, 245, 245, 255]);
+        });
+        it("grey", () => {
+          validateTonemapper(Tonemapper.ACES, grey, [169, 169, 169, 255]);
+        });
+        it("red", () => {
+          validateTonemapper(Tonemapper.ACES, red, [245, 0, 0, 255]);
+        });
+        it("green", () => {
+          validateTonemapper(Tonemapper.ACES, green, [0, 245, 0, 255]);
+        });
+        it("blue", () => {
+          validateTonemapper(Tonemapper.ACES, blue, [0, 0, 245, 255]);
+        });
+      });
 
-      const fs =
-        "void main() { \n" +
-        "    out_FragColor = vec4(4.0, 0.0, 0.0, 1.0); \n" +
-        "} \n";
-      scene.primitives.add(new ViewportPrimitive(fs));
-
-      scene.postProcessStages.tonemapper = Tonemapper.ACES;
-
-      expect(scene).toRender([255, 0, 0, 255]);
-      scene.highDynamicRange = true;
-      expect(scene).toRenderAndCall(function (rgba) {
-        expect(rgba).not.toEqual([0, 0, 0, 255]);
-        expect(rgba).not.toEqual([255, 0, 0, 255]);
-        expect(rgba[0]).toBeGreaterThan(0);
-        expect(rgba[1]).toEqual(0);
-        expect(rgba[2]).toEqual(0);
-        expect(rgba[3]).toEqual(255);
+      describe("PBR Neutral", () => {
+        it("white", () => {
+          validateTonemapper(Tonemapper.PBR_NEUTRAL, white, [
+            253,
+            253,
+            253,
+            255,
+          ]);
+        });
+        it("grey", () => {
+          validateTonemapper(Tonemapper.PBR_NEUTRAL, grey, [
+            179,
+            179,
+            179,
+            255,
+          ]);
+        });
+        it("red", () => {
+          validateTonemapper(Tonemapper.PBR_NEUTRAL, red, [253, 149, 149, 255]);
+        });
+        it("green", () => {
+          validateTonemapper(Tonemapper.PBR_NEUTRAL, green, [
+            149,
+            253,
+            149,
+            255,
+          ]);
+        });
+        it("blue", () => {
+          validateTonemapper(Tonemapper.PBR_NEUTRAL, blue, [
+            149,
+            149,
+            253,
+            255,
+          ]);
+        });
       });
-      scene.highDynamicRange = false;
     });
 
     it("destroys", function () {
diff --git a/packages/engine/Specs/Scene/SceneSpec.js b/packages/engine/Specs/Scene/SceneSpec.js
index 78f0eb33fe18..ebc2462f28f1 100644
--- a/packages/engine/Specs/Scene/SceneSpec.js
+++ b/packages/engine/Specs/Scene/SceneSpec.js
@@ -128,6 +128,10 @@ describe(
 
     describe("constructor", () => {
       it("has expected defaults", function () {
+        const scene = createScene({
+          canvas: createCanvas(5, 5),
+        });
+
         expect(scene.canvas).toBeInstanceOf(HTMLCanvasElement);
         expect(scene.primitives).toBeInstanceOf(PrimitiveCollection);
         expect(scene.camera).toBeInstanceOf(Camera);
@@ -137,6 +141,7 @@ describe(
         expect(scene.mapProjection).toBeInstanceOf(GeographicProjection);
         expect(scene.frameState).toBeInstanceOf(FrameState);
         expect(scene.tweens).toBeInstanceOf(TweenCollection);
+        expect(scene.msaaSamples).toEqual(4);
 
         const contextAttributes = scene.context._gl.getContextAttributes();
         // Do not check depth and antialias since they are requests not requirements
@@ -145,6 +150,7 @@ describe(
         expect(contextAttributes.premultipliedAlpha).toEqual(true);
         expect(contextAttributes.preserveDrawingBuffer).toEqual(false);
         expect(scene._depthPlane._ellipsoidOffset).toEqual(0);
+        scene.destroyForSpecs();
       });
 
       it("respects default log depth buffer override", () => {
@@ -816,7 +822,7 @@ describe(
 
       const rectanglePrimitive = createRectangle(rectangle, 1000.0);
       rectanglePrimitive.appearance.material.uniforms.color = new Color(
-        10.0,
+        4.0,
         0.0,
         0.0,
         1.0
@@ -830,8 +836,8 @@ describe(
       expect(scene).toRenderAndCall(function (rgba) {
         expect(rgba[0]).toBeGreaterThan(0);
         expect(rgba[0]).toBeLessThanOrEqual(255);
-        expect(rgba[1]).toEqual(0);
-        expect(rgba[2]).toEqual(0);
+        expect(rgba[1]).toEqualEpsilon(223, 1);
+        expect(rgba[2]).toEqualEpsilon(223, 1);
       });
     });
 
diff --git a/packages/engine/Specs/Scene/SceneTransformsSpec.js b/packages/engine/Specs/Scene/SceneTransformsSpec.js
index 0839423d89ec..180a57ed4451 100644
--- a/packages/engine/Specs/Scene/SceneTransformsSpec.js
+++ b/packages/engine/Specs/Scene/SceneTransformsSpec.js
@@ -40,13 +40,13 @@ describe(
     it("throws an exception without scene", function () {
       const position = Cartesian3.fromDegrees(0.0, 0.0);
       expect(function () {
-        SceneTransforms.wgs84ToWindowCoordinates(undefined, position);
+        SceneTransforms.worldToWindowCoordinates(undefined, position);
       }).toThrowDeveloperError();
     });
 
     it("throws an exception without position", function () {
       expect(function () {
-        SceneTransforms.wgs84ToWindowCoordinates(scene);
+        SceneTransforms.worldToWindowCoordinates(scene);
       }).toThrowDeveloperError();
     });
 
@@ -61,7 +61,7 @@ describe(
       // Update scene state
       scene.renderForSpecs();
 
-      const windowCoordinates = SceneTransforms.wgs84ToWindowCoordinates(
+      const windowCoordinates = SceneTransforms.worldToWindowCoordinates(
         scene,
         position
       );
@@ -80,7 +80,7 @@ describe(
       // Update scene state
       scene.renderForSpecs();
 
-      const drawingBufferCoordinates = SceneTransforms.wgs84ToDrawingBufferCoordinates(
+      const drawingBufferCoordinates = SceneTransforms.worldToDrawingBufferCoordinates(
         scene,
         position
       );
@@ -105,7 +105,7 @@ describe(
       // Update scene state
       scene.renderForSpecs();
 
-      const windowCoordinates = SceneTransforms.wgs84ToWindowCoordinates(
+      const windowCoordinates = SceneTransforms.worldToWindowCoordinates(
         scene,
         position
       );
@@ -123,7 +123,7 @@ describe(
       // Update scene state
       scene.renderForSpecs();
 
-      const drawingBufferCoordinates = SceneTransforms.wgs84ToDrawingBufferCoordinates(
+      const drawingBufferCoordinates = SceneTransforms.worldToDrawingBufferCoordinates(
         scene,
         position
       );
@@ -138,7 +138,7 @@ describe(
       const actualWindowCoordinates = new Cartesian2(0.5, 0.5);
       const position = scene.camera.pickEllipsoid(actualWindowCoordinates);
 
-      const windowCoordinates = SceneTransforms.wgs84ToWindowCoordinates(
+      const windowCoordinates = SceneTransforms.worldToWindowCoordinates(
         scene,
         position
       );
@@ -158,7 +158,7 @@ describe(
         actualDrawingBufferCoordinates
       );
 
-      const drawingBufferCoordinates = SceneTransforms.wgs84ToDrawingBufferCoordinates(
+      const drawingBufferCoordinates = SceneTransforms.worldToDrawingBufferCoordinates(
         scene,
         position
       );
@@ -182,7 +182,7 @@ describe(
         scene.camera.direction
       );
 
-      const windowCoordinates = SceneTransforms.wgs84ToWindowCoordinates(
+      const windowCoordinates = SceneTransforms.worldToWindowCoordinates(
         scene,
         position
       );
@@ -203,7 +203,7 @@ describe(
         scene.camera.direction
       );
 
-      const drawingBufferCoordinates = SceneTransforms.wgs84ToDrawingBufferCoordinates(
+      const drawingBufferCoordinates = SceneTransforms.worldToDrawingBufferCoordinates(
         scene,
         position
       );
@@ -225,7 +225,7 @@ describe(
       scene.renderForSpecs();
 
       const position = Cartesian3.fromDegrees(0, 0);
-      const windowCoordinates = SceneTransforms.wgs84ToWindowCoordinates(
+      const windowCoordinates = SceneTransforms.worldToWindowCoordinates(
         scene,
         position
       );
@@ -256,7 +256,7 @@ describe(
       });
 
       const position = Cartesian3.fromDegrees(0, 0);
-      const windowCoordinates = SceneTransforms.wgs84ToWindowCoordinates(
+      const windowCoordinates = SceneTransforms.worldToWindowCoordinates(
         scene,
         position
       );
@@ -283,7 +283,7 @@ describe(
       scene.renderForSpecs();
 
       const position = Cartesian3.fromDegrees(0, 0);
-      const drawingBufferCoordinates = SceneTransforms.wgs84ToDrawingBufferCoordinates(
+      const drawingBufferCoordinates = SceneTransforms.worldToDrawingBufferCoordinates(
         scene,
         position
       );
@@ -306,7 +306,7 @@ describe(
       scene.renderForSpecs();
 
       const position = Cartesian3.fromDegrees(-80, 25);
-      const windowCoordinates = SceneTransforms.wgs84ToWindowCoordinates(
+      const windowCoordinates = SceneTransforms.worldToWindowCoordinates(
         scene,
         position
       );
diff --git a/packages/engine/package.json b/packages/engine/package.json
index bc74fc1d261e..b485eeb060d3 100644
--- a/packages/engine/package.json
+++ b/packages/engine/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@cesium/engine",
-  "version": "10.1.0",
+  "version": "11.0.0",
   "description": "CesiumJS is a JavaScript library for creating 3D globes and 2D maps in a web browser without a plugin.",
   "keywords": [
     "3D",
@@ -32,7 +32,7 @@
     "./Specs/**/*"
   ],
   "dependencies": {
-    "@tweenjs/tween.js": "^23.1.1",
+    "@tweenjs/tween.js": "^25.0.0",
     "@zip.js/zip.js": "^2.7.34",
     "autolinker": "^4.0.0",
     "bitmap-sdf": "^1.0.3",
@@ -48,7 +48,7 @@
     "meshoptimizer": "^0.21.0",
     "pako": "^2.0.4",
     "protobufjs": "^7.1.0",
-    "rbush": "^4.0.0",
+    "rbush": "3.0.1",
     "topojson-client": "^3.1.0",
     "urijs": "^1.19.7"
   },
diff --git a/packages/widgets/Source/Viewer/Viewer.js b/packages/widgets/Source/Viewer/Viewer.js
index 20572ebece87..4b4f8cf35e26 100644
--- a/packages/widgets/Source/Viewer/Viewer.js
+++ b/packages/widgets/Source/Viewer/Viewer.js
@@ -342,7 +342,7 @@ function enableVRUI(viewer, enabled) {
  * @property {boolean} [requestRenderMode=false] If true, rendering a frame will only occur when needed as determined by changes within the scene. Enabling reduces the CPU/GPU usage of your application and uses less battery on mobile, but requires using {@link Scene#requestRender} to render a new frame explicitly in this mode. This will be necessary in many cases after making changes to the scene in other parts of the API. See {@link https://cesium.com/blog/2018/01/24/cesium-scene-rendering-performance/|Improving Performance with Explicit Rendering}.
  * @property {number} [maximumRenderTimeChange=0.0] If requestRenderMode is true, this value defines the maximum change in simulation time allowed before a render is requested. See {@link https://cesium.com/blog/2018/01/24/cesium-scene-rendering-performance/|Improving Performance with Explicit Rendering}.
  * @property {number} [depthPlaneEllipsoidOffset=0.0] Adjust the DepthPlane to address rendering artefacts below ellipsoid zero elevation.
- * @property {number} [msaaSamples=1] If provided, this value controls the rate of multisample antialiasing. Typical multisampling rates are 2, 4, and sometimes 8 samples per pixel. Higher sampling rates of MSAA may impact performance in exchange for improved visual quality. This value only applies to WebGL2 contexts that support multisample render targets.
+ * @property {number} [msaaSamples=4] If provided, this value controls the rate of multisample antialiasing. Typical multisampling rates are 2, 4, and sometimes 8 samples per pixel. Higher sampling rates of MSAA may impact performance in exchange for improved visual quality. This value only applies to WebGL2 contexts that support multisample render targets. Set to 1 to disable MSAA.
  */
 
 /**
diff --git a/packages/widgets/package.json b/packages/widgets/package.json
index 5712399a2d93..85cae775170a 100644
--- a/packages/widgets/package.json
+++ b/packages/widgets/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@cesium/widgets",
-  "version": "7.1.0",
+  "version": "8.0.0",
   "description": "A widgets library for use with CesiumJS. CesiumJS is a JavaScript library for creating 3D globes and 2D maps in a web browser without a plugin.",
   "keywords": [
     "3D",
@@ -28,7 +28,7 @@
     "node": ">=14.0.0"
   },
   "dependencies": {
-    "@cesium/engine": "^10.1.0",
+    "@cesium/engine": "^11.0.0",
     "nosleep.js": "^0.12.0"
   },
   "type": "module",
