@cesium/engine 10.0.0 → 11.0.0

package/Source/Scene/Scene.js

@@ -57,7 +57,6 @@ import GlobeTranslucencyState from "./GlobeTranslucencyState.js";
 import InvertClassification from "./InvertClassification.js";
 import JobScheduler from "./JobScheduler.js";
 import MapMode2D from "./MapMode2D.js";
-import OctahedralProjectedCubeMap from "./OctahedralProjectedCubeMap.js";
 import PerformanceDisplay from "./PerformanceDisplay.js";
 import PerInstanceColorAppearance from "./PerInstanceColorAppearance.js";
 import Picking from "./Picking.js";
@@ -69,6 +68,7 @@ import SceneTransforms from "./SceneTransforms.js";
 import SceneTransitioner from "./SceneTransitioner.js";
 import ScreenSpaceCameraController from "./ScreenSpaceCameraController.js";
 import ShadowMap from "./ShadowMap.js";
+import SpecularEnvironmentCubeMap from "./SpecularEnvironmentCubeMap.js";
 import StencilConstants from "./StencilConstants.js";
 import SunLight from "./SunLight.js";
 import SunPostProcess from "./SunPostProcess.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
@@ -738,7 +738,7 @@ function Scene(options) {
    * @type {string}
    */
   this.specularEnvironmentMaps = undefined;
-  this._specularEnvironmentMapAtlas = undefined;
+  this._specularEnvironmentCubeMap = undefined;
 
   /**
    * The light source for shading. Defaults to a directional light from the Sun.
@@ -927,7 +927,7 @@ Object.defineProperties(Scene.prototype, {
    */
   specularEnvironmentMapsSupported: {
     get: function () {
-      return OctahedralProjectedCubeMap.isSupported(this._context);
+      return SpecularEnvironmentCubeMap.isSupported(this._context);
     },
   },
 
@@ -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 () {
@@ -1964,11 +1964,11 @@ Scene.prototype.updateFrameState = function () {
   frameState.verticalExaggerationRelativeHeight = this.verticalExaggerationRelativeHeight;
 
   if (
-    defined(this._specularEnvironmentMapAtlas) &&
-    this._specularEnvironmentMapAtlas.ready
+    defined(this._specularEnvironmentCubeMap) &&
+    this._specularEnvironmentCubeMap.ready
   ) {
-    frameState.specularEnvironmentMaps = this._specularEnvironmentMapAtlas.texture;
-    frameState.specularEnvironmentMapsMaximumLOD = this._specularEnvironmentMapAtlas.maximumMipmapLevel;
+    frameState.specularEnvironmentMaps = this._specularEnvironmentCubeMap.texture;
+    frameState.specularEnvironmentMapsMaximumLOD = this._specularEnvironmentCubeMap.maximumMipmapLevel;
   } else {
     frameState.specularEnvironmentMaps = undefined;
     frameState.specularEnvironmentMapsMaximumLOD = undefined;
@@ -3328,20 +3328,18 @@ Scene.prototype.updateEnvironment = function () {
   );
 
   const envMaps = this.specularEnvironmentMaps;
-  let envMapAtlas = this._specularEnvironmentMapAtlas;
-  if (
-    defined(envMaps) &&
-    (!defined(envMapAtlas) || envMapAtlas.url !== envMaps)
-  ) {
-    envMapAtlas = envMapAtlas && envMapAtlas.destroy();
-    this._specularEnvironmentMapAtlas = new OctahedralProjectedCubeMap(envMaps);
-  } else if (!defined(envMaps) && defined(envMapAtlas)) {
-    envMapAtlas.destroy();
-    this._specularEnvironmentMapAtlas = undefined;
+  let specularEnvironmentCubeMap = this._specularEnvironmentCubeMap;
+  if (defined(envMaps) && specularEnvironmentCubeMap?.url !== envMaps) {
+    specularEnvironmentCubeMap =
+      specularEnvironmentCubeMap && specularEnvironmentCubeMap.destroy();
+    this._specularEnvironmentCubeMap = new SpecularEnvironmentCubeMap(envMaps);
+  } else if (!defined(envMaps) && defined(specularEnvironmentCubeMap)) {
+    specularEnvironmentCubeMap.destroy();
+    this._specularEnvironmentCubeMap = undefined;
   }
 
-  if (defined(this._specularEnvironmentMapAtlas)) {
-    this._specularEnvironmentMapAtlas.update(frameState);
+  if (defined(this._specularEnvironmentCubeMap)) {
+    this._specularEnvironmentCubeMap.update(frameState);
   }
 };
 

package/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();
 

package/Source/Scene/ScreenSpaceCameraController.js

@@ -137,6 +137,14 @@ function ScreenSpaceCameraController(scene) {
    * @default {@link Number.POSITIVE_INFINITY}
    */
   this.maximumZoomDistance = Number.POSITIVE_INFINITY;
+
+  /**
+   * A multiplier for the speed at which the camera will zoom.
+   * @type {Number}
+   * @default 5.0
+   */
+  this.zoomFactor = 5.0;
+
   /**
    * The input that allows the user to pan around the map. This only applies in 2D and Columbus view modes.
    * <p>
@@ -324,7 +332,6 @@ function ScreenSpaceCameraController(scene) {
   );
 
   // Constants, Make any of these public?
-  this._zoomFactor = 5.0;
   this._rotateFactor = undefined;
   this._rotateRateRangeAdjustment = undefined;
   this._maximumRotateRate = 1.77;
@@ -1005,7 +1012,7 @@ function zoom2D(controller, startPosition, movement) {
     controller,
     startPosition,
     movement,
-    controller._zoomFactor,
+    controller.zoomFactor,
     camera.getMagnitude()
   );
 }
@@ -1763,7 +1770,7 @@ function zoomCV(controller, startPosition, movement) {
     controller,
     startPosition,
     movement,
-    controller._zoomFactor,
+    controller.zoomFactor,
     distance
   );
 }
@@ -2363,7 +2370,7 @@ function zoom3D(controller, startPosition, movement) {
     controller,
     startPosition,
     movement,
-    controller._zoomFactor,
+    controller.zoomFactor,
     distance,
     Cartesian3.dot(unitPosition, camera.direction)
   );

package/Source/Scene/SkyBox.js

@@ -1,6 +1,7 @@
 import buildModuleUrl from "../Core/buildModuleUrl.js";
 import BoxGeometry from "../Core/BoxGeometry.js";
 import Cartesian3 from "../Core/Cartesian3.js";
+import Check from "../Core/Check.js";
 import defaultValue from "../Core/defaultValue.js";
 import defined from "../Core/defined.js";
 import destroyObject from "../Core/destroyObject.js";
@@ -95,49 +96,42 @@ function SkyBox(options) {
  */
 SkyBox.prototype.update = function (frameState, useHdr) {
   const that = this;
+  const { mode, passes, context } = frameState;
 
   if (!this.show) {
     return undefined;
   }
 
-  if (
-    frameState.mode !== SceneMode.SCENE3D &&
-    frameState.mode !== SceneMode.MORPHING
-  ) {
+  if (mode !== SceneMode.SCENE3D && mode !== SceneMode.MORPHING) {
     return undefined;
   }
 
   // The sky box is only rendered during the render pass; it is not pickable, it doesn't cast shadows, etc.
-  if (!frameState.passes.render) {
+  if (!passes.render) {
     return undefined;
   }
 
-  const context = frameState.context;
-
   if (this._sources !== this.sources) {
     this._sources = this.sources;
     const sources = this.sources;
 
     //>>includeStart('debug', pragmas.debug);
+    Check.defined("this.sources", sources);
     if (
-      !defined(sources.positiveX) ||
-      !defined(sources.negativeX) ||
-      !defined(sources.positiveY) ||
-      !defined(sources.negativeY) ||
-      !defined(sources.positiveZ) ||
-      !defined(sources.negativeZ)
+      Object.values(CubeMap.FaceName).some(
+        (faceName) => !defined(sources[faceName])
+      )
     ) {
       throw new DeveloperError(
-        "this.sources is required and must have positiveX, negativeX, positiveY, negativeY, positiveZ, and negativeZ properties."
+        "this.sources must have positiveX, negativeX, positiveY, negativeY, positiveZ, and negativeZ properties."
       );
     }
 
+    const sourceType = typeof sources.positiveX;
     if (
-      typeof sources.positiveX !== typeof sources.negativeX ||
-      typeof sources.positiveX !== typeof sources.positiveY ||
-      typeof sources.positiveX !== typeof sources.negativeY ||
-      typeof sources.positiveX !== typeof sources.positiveZ ||
-      typeof sources.positiveX !== typeof sources.negativeZ
+      Object.values(CubeMap.FaceName).some(
+        (faceName) => typeof sources[faceName] !== sourceType
+      )
     ) {
       throw new DeveloperError(
         "this.sources properties must all be the same type."

package/Source/Scene/SpecularEnvironmentCubeMap.js

@@ -0,0 +1,240 @@
+import defined from "../Core/defined.js";
+import destroyObject from "../Core/destroyObject.js";
+import Event from "../Core/Event.js";
+import loadKTX2 from "../Core/loadKTX2.js";
+import PixelFormat from "../Core/PixelFormat.js";
+import CubeMap from "../Renderer/CubeMap.js";
+import PixelDatatype from "../Renderer/PixelDatatype.js";
+import Sampler from "../Renderer/Sampler.js";
+import TextureMinificationFilter from "../Renderer/TextureMinificationFilter.js";
+
+/**
+ * Manages a cube map for use as a specular environment map.
+ *
+ * @alias SpecularEnvironmentCubeMap
+ * @constructor
+ *
+ * @param {string} url The url to the KTX2 file containing the specular environment map and convoluted mipmaps.
+ * @private
+ */
+function SpecularEnvironmentCubeMap(url) {
+  this._url = url;
+
+  this._cubeMapBuffers = undefined;
+  this._texture = undefined;
+
+  this._maximumMipmapLevel = undefined;
+
+  this._loading = false;
+  this._ready = false;
+
+  this._errorEvent = new Event();
+}
+
+Object.defineProperties(SpecularEnvironmentCubeMap.prototype, {
+  /**
+   * The url to the KTX2 file containing the specular environment map and convoluted mipmaps.
+   * @memberof SpecularEnvironmentCubeMap.prototype
+   * @type {string}
+   * @readonly
+   */
+  url: {
+    get: function () {
+      return this._url;
+    },
+  },
+  /**
+   * Gets an event that is raised when encountering an asynchronous error.  By subscribing
+   * to the event, you will be notified of the error and can potentially recover from it.
+   * @memberof SpecularEnvironmentCubeMap.prototype
+   * @type {Event}
+   * @readonly
+   */
+  errorEvent: {
+    get: function () {
+      return this._errorEvent;
+    },
+  },
+  /**
+   * A texture containing all the packed convolutions.
+   * @memberof SpecularEnvironmentCubeMap.prototype
+   * @type {Texture}
+   * @readonly
+   */
+  texture: {
+    get: function () {
+      return this._texture;
+    },
+  },
+  /**
+   * The maximum number of mip levels with valid environment map data.
+   * This may differ from the number of mips in the WebGL cubemap.
+   * The data loaded at <code>maximumMipmapLevel</code> is suitable for
+   * PBR rendering of a material with maximum roughness (1.0).
+   * @memberOf SpecularEnvironmentCubeMap.prototype
+   * @type {number}
+   * @readonly
+   */
+  maximumMipmapLevel: {
+    get: function () {
+      return this._maximumMipmapLevel;
+    },
+  },
+  /**
+   * Determines if the cube map is complete and ready to use.
+   * @memberof SpecularEnvironmentCubeMap.prototype
+   * @type {boolean}
+   * @readonly
+   */
+  ready: {
+    get: function () {
+      return this._ready;
+    },
+  },
+});
+
+SpecularEnvironmentCubeMap.isSupported = function (context) {
+  const supportsFloatBuffersAndTextures =
+    (context.colorBufferHalfFloat && context.halfFloatingPointTexture) ||
+    (context.floatingPointTexture && context.colorBufferFloat);
+  return supportsFloatBuffersAndTextures && context.supportsTextureLod;
+};
+
+function cleanupResources(map) {
+  map._cubeMapBuffers = undefined;
+}
+
+/**
+ * Loads the environment map image and constructs the cube map for specular radiance calculations.
+ * <p>
+ * Once the image is loaded, the next call cleans up unused resources. Every call after that is a no-op.
+ * </p>
+ * @param {FrameState} frameState The frame state.
+ *
+ * @private
+ */
+SpecularEnvironmentCubeMap.prototype.update = function (frameState) {
+  const { context } = frameState;
+
+  if (!SpecularEnvironmentCubeMap.isSupported(context)) {
+    return;
+  }
+
+  if (defined(this._texture)) {
+    cleanupResources(this);
+    return;
+  }
+
+  if (!defined(this._texture) && !this._loading) {
+    const cachedTexture = context.textureCache.getTexture(this._url);
+    if (defined(cachedTexture)) {
+      cleanupResources(this);
+      this._texture = cachedTexture;
+      this._maximumMipmapLevel = this._texture.maximumMipmapLevel;
+      this._ready = true;
+    }
+  }
+
+  const cubeMapBuffers = this._cubeMapBuffers;
+  if (!defined(cubeMapBuffers) && !this._loading) {
+    const that = this;
+    loadKTX2(this._url)
+      .then(function (buffers) {
+        that._cubeMapBuffers = buffers;
+        that._loading = false;
+      })
+      .catch(function (error) {
+        if (that.isDestroyed()) {
+          return;
+        }
+        that._errorEvent.raiseEvent(error);
+      });
+    this._loading = true;
+  }
+
+  if (!defined(this._cubeMapBuffers)) {
+    return;
+  }
+
+  // Datatype is defined if it is a normalized type (i.e. ..._UNORM, ..._SFLOAT)
+  let { pixelDatatype } = cubeMapBuffers[0].positiveX;
+  if (!defined(pixelDatatype)) {
+    pixelDatatype = context.halfFloatingPointTexture
+      ? PixelDatatype.HALF_FLOAT
+      : PixelDatatype.FLOAT;
+  }
+  const pixelFormat = PixelFormat.RGBA;
+
+  const mipLevels = cubeMapBuffers.length;
+  this._maximumMipmapLevel = mipLevels - 1;
+
+  const faceSize = cubeMapBuffers[0].positiveX.width;
+  const expectedMipLevels = Math.log2(faceSize) + 1;
+  if (mipLevels !== expectedMipLevels) {
+    // We assume the last supplied mip level was computed as the specular radiance
+    // for roughness 1.0.
+    // Fill the remaining levels with null values, to avoid WebGL errors.
+    const dummyMipLevel = {};
+    Object.values(CubeMap.FaceName).forEach((faceName) => {
+      dummyMipLevel[faceName] = undefined;
+    });
+    for (let mipLevel = mipLevels; mipLevel < expectedMipLevels; mipLevel++) {
+      cubeMapBuffers.push(dummyMipLevel);
+    }
+  }
+
+  const sampler = new Sampler({
+    minificationFilter: TextureMinificationFilter.LINEAR_MIPMAP_LINEAR,
+  });
+
+  const cubeMap = new CubeMap({
+    context: context,
+    source: cubeMapBuffers[0],
+    flipY: false,
+    pixelDatatype: pixelDatatype,
+    pixelFormat: pixelFormat,
+    sampler: sampler,
+  });
+  cubeMap.loadMipmaps(cubeMapBuffers.slice(1));
+  this._texture = cubeMap;
+
+  this._texture.maximumMipmapLevel = this._maximumMipmapLevel;
+  context.textureCache.addTexture(this._url, this._texture);
+
+  this._ready = true;
+};
+
+/**
+ * Returns true if this object was destroyed; otherwise, false.
+ * <p>
+ * If this object was destroyed, it should not be used; calling any function other than
+ * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.
+ * </p>
+ *
+ * @returns {boolean} <code>true</code> if this object was destroyed; otherwise, <code>false</code>.
+ *
+ * @see SpecularEnvironmentCubeMap#destroy
+ */
+SpecularEnvironmentCubeMap.prototype.isDestroyed = function () {
+  return false;
+};
+
+/**
+ * Destroys the WebGL resources held by this object.  Destroying an object allows for deterministic
+ * release of WebGL resources, instead of relying on the garbage collector to destroy this object.
+ * <p>
+ * Once an object is destroyed, it should not be used; calling any function other than
+ * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.  Therefore,
+ * assign the return value (<code>undefined</code>) to the object as done in the example.
+ * </p>
+ *
+ * @exception {DeveloperError} This object was destroyed, i.e., destroy() was called.
+ *
+ * @see SpecularEnvironmentCubeMap#isDestroyed
+ */
+SpecularEnvironmentCubeMap.prototype.destroy = function () {
+  cleanupResources(this);
+  this._texture = this._texture && this._texture.destroy();
+  return destroyObject(this);
+};
+export default SpecularEnvironmentCubeMap;

package/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);

package/Source/Scene/VoxelPrimitive.js

@@ -332,12 +332,6 @@ function VoxelPrimitive(options) {
   this._transformNormalLocalToWorld = new Matrix3();
 
   // Rendering
-  /**
-   * @type {boolean}
-   * @private
-   */
-  this._jitter = false;
-
   /**
    * @type {boolean}
    * @private
@@ -704,29 +698,6 @@ Object.defineProperties(VoxelPrimitive.prototype, {
     },
   },
 
-  /**
-   * Gets or sets whether or not to jitter the view ray during the raymarch.
-   * This reduces stair-step artifacts but introduces noise.
-   *
-   * @memberof VoxelPrimitive.prototype
-   * @type {boolean}
-   */
-  jitter: {
-    get: function () {
-      return this._jitter;
-    },
-    set: function (jitter) {
-      //>>includeStart('debug', pragmas.debug);
-      Check.typeOf.bool("jitter", jitter);
-      //>>includeEnd('debug');
-
-      if (this._jitter !== jitter) {
-        this._jitter = jitter;
-        this._shaderDirty = true;
-      }
-    },
-  },
-
   /**
    * Gets or sets the nearest sampling.
    *

package/Source/Scene/VoxelRenderResources.js

@@ -215,9 +215,6 @@ function VoxelRenderResources(primitive) {
       ShaderDestination.FRAGMENT
     );
   }
-  if (primitive._jitter) {
-    shaderBuilder.addDefine("JITTER", undefined, ShaderDestination.FRAGMENT);
-  }
   if (primitive._nearestSampling) {
     shaderBuilder.addDefine(
       "NEAREST_SAMPLING",