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/CHANGES.md b/CHANGES.md
index f25962e4bed8..63bc192167b7 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -9,6 +9,9 @@
 - Enable MSAA by default with 4 samples. To turn MSAA off set `scene.msaaSamples = 1` [#12158](https://github.com/CesiumGS/cesium/pull/12158)
 - 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)
+- 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)
 
 ##### Fixes :wrench:
@@ -23,13 +26,12 @@
 
 ##### 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
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/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/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/GlobeFS.glsl b/packages/engine/Source/Shaders/GlobeFS.glsl
index a2a5c8778a7c..2c9df10caf02 100644
--- a/packages/engine/Source/Shaders/GlobeFS.glsl
+++ b/packages/engine/Source/Shaders/GlobeFS.glsl
@@ -428,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
@@ -495,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/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/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/Specs/Scene/Cesium3DTilesetSpec.js b/packages/engine/Specs/Scene/Cesium3DTilesetSpec.js
index c462f5195096..768b8ace075f 100644
--- a/packages/engine/Specs/Scene/Cesium3DTilesetSpec.js
+++ b/packages/engine/Specs/Scene/Cesium3DTilesetSpec.js
@@ -702,25 +702,25 @@ 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);
         });
@@ -3331,10 +3331,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 +3346,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 +3361,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 +3381,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 +3395,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 +3427,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 +3479,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/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 d4d393001d62..ebc2462f28f1 100644
--- a/packages/engine/Specs/Scene/SceneSpec.js
+++ b/packages/engine/Specs/Scene/SceneSpec.js
@@ -822,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
@@ -836,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);
       });
     });