@cesium/engine 7.0.0 → 8.0.0

package/Source/Scene/Picking.js

@@ -236,30 +236,38 @@ let scratchRectangle = new BoundingRectangle(
 const scratchPosition = new Cartesian2();
 const scratchColorZero = new Color(0.0, 0.0, 0.0, 0.0);
 
+/**
+ * Returns an object with a <code>primitive</code> property that contains the first (top) primitive in the scene
+ * at a particular window coordinate or undefined if nothing is at the location. Other properties may
+ * potentially be set depending on the type of primitive and may be used to further identify the picked object.
+ * <p>
+ * When a feature of a 3D Tiles tileset is picked, <code>pick</code> returns a {@link Cesium3DTileFeature} object.
+ * </p>
+ * @param {Scene} scene
+ * @param {Cartesian2} windowPosition Window coordinates to perform picking on.
+ * @param {number} [width=3] Width of the pick rectangle.
+ * @param {number} [height=3] Height of the pick rectangle.
+ * @returns {object} Object containing the picked primitive.
+ */
 Picking.prototype.pick = function (scene, windowPosition, width, height) {
   //>>includeStart('debug', pragmas.debug);
-  if (!defined(windowPosition)) {
-    throw new DeveloperError("windowPosition is undefined.");
-  }
+  Check.defined("windowPosition", windowPosition);
   //>>includeEnd('debug');
 
   scratchRectangleWidth = defaultValue(width, 3.0);
   scratchRectangleHeight = defaultValue(height, scratchRectangleWidth);
 
-  const context = scene.context;
-  const us = context.uniformState;
-  const frameState = scene.frameState;
+  const { context, frameState, defaultView } = scene;
+  const { viewport, pickFramebuffer } = defaultView;
 
-  const view = scene.defaultView;
-  scene.view = view;
+  scene.view = defaultView;
 
-  const viewport = view.viewport;
   viewport.x = 0;
   viewport.y = 0;
   viewport.width = context.drawingBufferWidth;
   viewport.height = context.drawingBufferHeight;
 
-  let passState = view.passState;
+  let passState = defaultView.passState;
   passState.viewport = BoundingRectangle.clone(viewport, passState.viewport);
 
   const drawingBufferPosition = SceneTransforms.transformWindowToDrawingBuffer(
@@ -282,7 +290,7 @@ Picking.prototype.pick = function (scene, windowPosition, width, height) {
   frameState.passes.pick = true;
   frameState.tilesetPassState = pickTilesetPassState;
 
-  us.update(frameState);
+  context.uniformState.update(frameState);
 
   scene.updateEnvironment();
 
@@ -294,32 +302,108 @@ Picking.prototype.pick = function (scene, windowPosition, width, height) {
     (scratchRectangleHeight - 1.0) * 0.5;
   scratchRectangle.width = scratchRectangleWidth;
   scratchRectangle.height = scratchRectangleHeight;
-  passState = view.pickFramebuffer.begin(scratchRectangle, view.viewport);
+  passState = pickFramebuffer.begin(scratchRectangle, viewport);
 
   scene.updateAndExecuteCommands(passState, scratchColorZero);
   scene.resolveFramebuffers(passState);
 
-  const object = view.pickFramebuffer.end(scratchRectangle);
+  const object = pickFramebuffer.end(scratchRectangle);
   context.endFrame();
   return object;
 };
 
+/**
+ * Returns an object with information about the voxel sample rendered at
+ * a particular window coordinate. Returns <code>undefined</code> if there is no
+ * voxel at that position.
+ *
+ * @param {Scene} scene
+ * @param {Cartesian2} windowPosition Window coordinates to perform picking on.
+ * @param {number} [width=3] Width of the pick rectangle.
+ * @param {number} [height=3] Height of the pick rectangle.
+ * @returns {object|undefined} Object containing the picked primitive.
+ */
+Picking.prototype.pickVoxelCoordinate = function (
+  scene,
+  windowPosition,
+  width,
+  height
+) {
+  //>>includeStart('debug', pragmas.debug);
+  Check.defined("windowPosition", windowPosition);
+  //>>includeEnd('debug');
+
+  scratchRectangleWidth = defaultValue(width, 3.0);
+  scratchRectangleHeight = defaultValue(height, scratchRectangleWidth);
+
+  const { context, frameState, defaultView } = scene;
+  const { viewport, pickFramebuffer } = defaultView;
+
+  scene.view = defaultView;
+
+  viewport.x = 0;
+  viewport.y = 0;
+  viewport.width = context.drawingBufferWidth;
+  viewport.height = context.drawingBufferHeight;
+
+  let passState = defaultView.passState;
+  passState.viewport = BoundingRectangle.clone(viewport, passState.viewport);
+
+  const drawingBufferPosition = SceneTransforms.transformWindowToDrawingBuffer(
+    scene,
+    windowPosition,
+    scratchPosition
+  );
+
+  scene.jobScheduler.disableThisFrame();
+
+  scene.updateFrameState();
+  frameState.cullingVolume = getPickCullingVolume(
+    scene,
+    drawingBufferPosition,
+    scratchRectangleWidth,
+    scratchRectangleHeight,
+    viewport
+  );
+  frameState.invertClassification = false;
+  frameState.passes.pickVoxel = true;
+  frameState.tilesetPassState = pickTilesetPassState;
+
+  context.uniformState.update(frameState);
+
+  scene.updateEnvironment();
+
+  scratchRectangle.x =
+    drawingBufferPosition.x - (scratchRectangleWidth - 1.0) * 0.5;
+  scratchRectangle.y =
+    scene.drawingBufferHeight -
+    drawingBufferPosition.y -
+    (scratchRectangleHeight - 1.0) * 0.5;
+  scratchRectangle.width = scratchRectangleWidth;
+  scratchRectangle.height = scratchRectangleHeight;
+  passState = pickFramebuffer.begin(scratchRectangle, viewport);
+
+  scene.updateAndExecuteCommands(passState, scratchColorZero);
+  scene.resolveFramebuffers(passState);
+
+  const voxelInfo = pickFramebuffer.readVoxelInfo(scratchRectangle);
+  context.endFrame();
+  return voxelInfo;
+};
+
 function renderTranslucentDepthForPick(scene, drawingBufferPosition) {
   // PERFORMANCE_IDEA: render translucent only and merge with the previous frame
-  const context = scene.context;
-  const frameState = scene.frameState;
-  const environmentState = scene.environmentState;
+  const { defaultView, context, frameState, environmentState } = scene;
+  const { viewport, pickDepthFramebuffer } = defaultView;
 
-  const view = scene.defaultView;
-  scene.view = view;
+  scene.view = defaultView;
 
-  const viewport = view.viewport;
   viewport.x = 0;
   viewport.y = 0;
   viewport.width = context.drawingBufferWidth;
   viewport.height = context.drawingBufferHeight;
 
-  let passState = view.passState;
+  let passState = defaultView.passState;
   passState.viewport = BoundingRectangle.clone(viewport, passState.viewport);
 
   scene.clearPasses(frameState.passes);
@@ -336,7 +420,7 @@ function renderTranslucentDepthForPick(scene, drawingBufferPosition) {
 
   scene.updateEnvironment();
   environmentState.renderTranslucentDepthForPick = true;
-  passState = view.pickDepthFramebuffer.update(
+  passState = pickDepthFramebuffer.update(
     context,
     drawingBufferPosition,
     viewport
@@ -363,9 +447,7 @@ Picking.prototype.pickPositionWorldCoordinates = function (
   }
 
   //>>includeStart('debug', pragmas.debug);
-  if (!defined(windowPosition)) {
-    throw new DeveloperError("windowPosition is undefined.");
-  }
+  Check.defined("windowPosition", windowPosition);
   if (!scene.context.depthTexture) {
     throw new DeveloperError(
       "Picking from the depth buffer is not supported. Check pickPositionSupported."
@@ -382,12 +464,10 @@ Picking.prototype.pickPositionWorldCoordinates = function (
     return Cartesian3.clone(this._pickPositionCache[cacheKey], result);
   }
 
-  const frameState = scene.frameState;
-  const context = scene.context;
-  const uniformState = context.uniformState;
+  const { context, frameState, camera, defaultView } = scene;
+  const { uniformState } = context;
 
-  const view = scene.defaultView;
-  scene.view = view;
+  scene.view = defaultView;
 
   const drawingBufferPosition = SceneTransforms.transformWindowToDrawingBuffer(
     scene,
@@ -403,8 +483,6 @@ Picking.prototype.pickPositionWorldCoordinates = function (
   }
   drawingBufferPosition.y = scene.drawingBufferHeight - drawingBufferPosition.y;
 
-  const camera = scene.camera;
-
   // Create a working frustum from the original camera frustum.
   let frustum;
   if (defined(camera.frustum.fov)) {
@@ -417,7 +495,7 @@ Picking.prototype.pickPositionWorldCoordinates = function (
     frustum = camera.frustum.clone(scratchOrthographicOffCenterFrustum);
   }
 
-  const frustumCommandsList = view.frustumCommandsList;
+  const frustumCommandsList = defaultView.frustumCommandsList;
   const numFrustums = frustumCommandsList.length;
   for (let i = 0; i < numFrustums; ++i) {
     const pickDepth = this.getPickDepth(scene, i);
@@ -636,9 +714,7 @@ function updateOffscreenCameraFromRay(picking, ray, width, camera) {
 function updateMostDetailedRayPick(picking, scene, rayPick) {
   const frameState = scene.frameState;
 
-  const ray = rayPick.ray;
-  const width = rayPick.width;
-  const tilesets = rayPick.tilesets;
+  const { ray, width, tilesets } = rayPick;
 
   const camera = picking._pickOffscreenView.camera;
   const cullingVolume = updateOffscreenCameraFromRay(
@@ -682,8 +758,7 @@ Picking.prototype.updateMostDetailedRayPicks = function (scene) {
 };
 
 function getTilesets(primitives, objectsToExclude, tilesets) {
-  const length = primitives.length;
-  for (let i = 0; i < length; ++i) {
+  for (let i = 0; i < primitives.length; ++i) {
     const primitive = primitives.get(i);
     if (primitive.show) {
       if (defined(primitive.isCesium3DTileset)) {
@@ -745,9 +820,8 @@ function getRayIntersection(
   requirePosition,
   mostDetailed
 ) {
-  const context = scene.context;
+  const { context, frameState } = scene;
   const uniformState = context.uniformState;
-  const frameState = scene.frameState;
 
   const view = picking._pickOffscreenView;
   scene.view = view;

package/Source/Scene/Primitive.js

@@ -1174,15 +1174,19 @@ function loadAsynchronous(primitive, frameState) {
       instanceIds.push(instances[i].id);
 
       //>>includeStart('debug', pragmas.debug);
-      if (!defined(geometry._workerName)) {
+      if (
+        (defined(geometry._workerName) && defined(geometry._workerPath)) ||
+        (!defined(geometry._workerName) && !defined(geometry._workerPath))
+      ) {
         throw new DeveloperError(
-          "_workerName must be defined for asynchronous geometry."
+          "Must define either _workerName or _workerPath for asynchronous geometry."
         );
       }
       //>>includeEnd('debug');
 
       subTasks.push({
         moduleName: geometry._workerName,
+        modulePath: geometry._workerPath,
         geometry: geometry,
       });
     }

package/Source/Scene/Scene.js

@@ -73,6 +73,8 @@ import SunPostProcess from "./SunPostProcess.js";
 import TweenCollection from "./TweenCollection.js";
 import View from "./View.js";
 import DebugInspector from "./DebugInspector.js";
+import VoxelCell from "./VoxelCell.js";
+import VoxelPrimitive from "./VoxelPrimitive.js";
 
 const requestRenderAfterFrame = function (scene) {
   return function () {
@@ -167,10 +169,11 @@ function Scene(options) {
   this._groundPrimitives = new PrimitiveCollection();
 
   this._globeHeight = undefined;
-  this._globeHeightDirty = undefined;
+  this._globeHeightDirty = true;
   this._cameraUnderground = false;
+  this._removeUpdateHeightCallback = undefined;
 
-  this._logDepthBuffer = context.fragmentDepth;
+  this._logDepthBuffer = Scene.defaultLogDepthBuffer && context.fragmentDepth;
   this._logDepthBufferDirty = true;
 
   this._tweens = new TweenCollection();
@@ -732,6 +735,12 @@ function Scene(options) {
   this.initializeFrame();
 }
 
+/**
+ * Use this to set the default value for {@link Scene#logarithmicDepthBuffer} in newly constructed Scenes
+ * This property relies on fragmentDepth being supported.
+ */
+Scene.defaultLogDepthBuffer = true;
+
 function updateGlobeListeners(scene, globe) {
   for (let i = 0; i < scene._removeGlobeCallbacks.length; ++i) {
     scene._removeGlobeCallbacks[i]();
@@ -750,11 +759,6 @@ function updateGlobeListeners(scene, globe) {
         requestRenderAfterFrame(scene)
       )
     );
-    removeGlobeCallbacks.push(
-      globe.tileLoadProgressEvent.addEventListener(() => {
-        scene._globeHeightDirty = true;
-      })
-    );
   }
   scene._removeGlobeCallbacks = removeGlobeCallbacks;
 }
@@ -1866,10 +1870,12 @@ function getOccluder(scene) {
 
 /**
  * @private
+ * @param {FrameState.Passes} passes
  */
 Scene.prototype.clearPasses = function (passes) {
   passes.render = false;
   passes.pick = false;
+  passes.pickVoxel = false;
   passes.depth = false;
   passes.postProcess = false;
   passes.offscreen = false;
@@ -2128,6 +2134,7 @@ function executeCommand(command, scene, context, passState, debugFramebuffer) {
   const passes = frameState.passes;
   if (
     !passes.pick &&
+    !passes.pickVoxel &&
     !passes.depth &&
     scene._hdr &&
     defined(command.derivedCommands) &&
@@ -2281,12 +2288,10 @@ const scratchOrthographicFrustum = new OrthographicFrustum();
 const scratchOrthographicOffCenterFrustum = new OrthographicOffCenterFrustum();
 
 function executeCommands(scene, passState) {
-  const camera = scene.camera;
-  const context = scene.context;
-  const frameState = scene.frameState;
-  const us = context.uniformState;
+  const { camera, context, frameState } = scene;
+  const { uniformState } = context;
 
-  us.updateCamera(camera);
+  uniformState.updateCamera(camera);
 
   // Create a working frustum from the original camera frustum.
   let frustum;
@@ -2304,11 +2309,11 @@ function executeCommands(scene, passState) {
   // early-z, but we would have to draw it in each frustum
   frustum.near = camera.frustum.near;
   frustum.far = camera.frustum.far;
-  us.updateFrustum(frustum);
-  us.updatePass(Pass.ENVIRONMENT);
+  uniformState.updateFrustum(frustum);
+  uniformState.updatePass(Pass.ENVIRONMENT);
 
   const passes = frameState.passes;
-  const picking = passes.pick;
+  const picking = passes.pick || passes.pickVoxel;
   const environmentState = scene._environmentState;
   const view = scene._view;
   const renderTranslucentDepthForPick =
@@ -2410,8 +2415,8 @@ function executeCommands(scene, passState) {
       camera.position.z = height2D - frustumCommands.near + 1.0;
       frustum.far = Math.max(1.0, frustumCommands.far - frustumCommands.near);
       frustum.near = 1.0;
-      us.update(frameState);
-      us.updateFrustum(frustum);
+      uniformState.update(frameState);
+      uniformState.updateFrustum(frustum);
     } else {
       // Avoid tearing artifacts between adjacent frustums in the opaque passes
       frustum.near =
@@ -2419,7 +2424,7 @@ function executeCommands(scene, passState) {
           ? frustumCommands.near * scene.opaqueFrustumNearOffset
           : frustumCommands.near;
       frustum.far = frustumCommands.far;
-      us.updateFrustum(frustum);
+      uniformState.updateFrustum(frustum);
     }
 
     clearDepth.execute(context, passState);
@@ -2428,7 +2433,7 @@ function executeCommands(scene, passState) {
       clearStencil.execute(context, passState);
     }
 
-    us.updatePass(Pass.GLOBE);
+    uniformState.updatePass(Pass.GLOBE);
     let commands = frustumCommands.commands[Pass.GLOBE];
     let length = frustumCommands.indices[Pass.GLOBE];
 
@@ -2453,7 +2458,7 @@ function executeCommands(scene, passState) {
 
     // Draw terrain classification
     if (!environmentState.renderTranslucentDepthForPick) {
-      us.updatePass(Pass.TERRAIN_CLASSIFICATION);
+      uniformState.updatePass(Pass.TERRAIN_CLASSIFICATION);
       commands = frustumCommands.commands[Pass.TERRAIN_CLASSIFICATION];
       length = frustumCommands.indices[Pass.TERRAIN_CLASSIFICATION];
 
@@ -2487,7 +2492,7 @@ function executeCommands(scene, passState) {
       // Common/fastest path. Draw 3D Tiles and classification normally.
 
       // Draw 3D Tiles
-      us.updatePass(Pass.CESIUM_3D_TILE);
+      uniformState.updatePass(Pass.CESIUM_3D_TILE);
       commands = frustumCommands.commands[Pass.CESIUM_3D_TILE];
       length = frustumCommands.indices[Pass.CESIUM_3D_TILE];
       for (j = 0; j < length; ++j) {
@@ -2509,7 +2514,7 @@ function executeCommands(scene, passState) {
 
         // Draw classifications. Modifies 3D Tiles color.
         if (!environmentState.renderTranslucentDepthForPick) {
-          us.updatePass(Pass.CESIUM_3D_TILE_CLASSIFICATION);
+          uniformState.updatePass(Pass.CESIUM_3D_TILE_CLASSIFICATION);
           commands =
             frustumCommands.commands[Pass.CESIUM_3D_TILE_CLASSIFICATION];
           length = frustumCommands.indices[Pass.CESIUM_3D_TILE_CLASSIFICATION];
@@ -2557,7 +2562,7 @@ function executeCommands(scene, passState) {
       passState.framebuffer = scene._invertClassification._fbo.framebuffer;
 
       // Draw normally
-      us.updatePass(Pass.CESIUM_3D_TILE);
+      uniformState.updatePass(Pass.CESIUM_3D_TILE);
       commands = frustumCommands.commands[Pass.CESIUM_3D_TILE];
       length = frustumCommands.indices[Pass.CESIUM_3D_TILE];
       for (j = 0; j < length; ++j) {
@@ -2575,7 +2580,7 @@ function executeCommands(scene, passState) {
       }
 
       // Set stencil
-      us.updatePass(Pass.CESIUM_3D_TILE_CLASSIFICATION_IGNORE_SHOW);
+      uniformState.updatePass(Pass.CESIUM_3D_TILE_CLASSIFICATION_IGNORE_SHOW);
       commands =
         frustumCommands.commands[
           Pass.CESIUM_3D_TILE_CLASSIFICATION_IGNORE_SHOW
@@ -2601,7 +2606,7 @@ function executeCommands(scene, passState) {
       }
 
       // Draw style over classification.
-      us.updatePass(Pass.CESIUM_3D_TILE_CLASSIFICATION);
+      uniformState.updatePass(Pass.CESIUM_3D_TILE_CLASSIFICATION);
       commands = frustumCommands.commands[Pass.CESIUM_3D_TILE_CLASSIFICATION];
       length = frustumCommands.indices[Pass.CESIUM_3D_TILE_CLASSIFICATION];
       for (j = 0; j < length; ++j) {
@@ -2613,13 +2618,13 @@ function executeCommands(scene, passState) {
       clearStencil.execute(context, passState);
     }
 
-    us.updatePass(Pass.VOXELS);
+    uniformState.updatePass(Pass.VOXELS);
     commands = frustumCommands.commands[Pass.VOXELS];
     length = frustumCommands.indices[Pass.VOXELS];
     commands.length = length;
     executeVoxelCommands(scene, executeCommand, passState, commands);
 
-    us.updatePass(Pass.OPAQUE);
+    uniformState.updatePass(Pass.OPAQUE);
     commands = frustumCommands.commands[Pass.OPAQUE];
     length = frustumCommands.indices[Pass.OPAQUE];
     for (j = 0; j < length; ++j) {
@@ -2629,7 +2634,7 @@ function executeCommands(scene, passState) {
     if (index !== 0 && scene.mode !== SceneMode.SCENE2D) {
       // Do not overlap frustums in the translucent pass to avoid blending artifacts
       frustum.near = frustumCommands.near;
-      us.updateFrustum(frustum);
+      uniformState.updateFrustum(frustum);
     }
 
     let invertClassification;
@@ -2643,7 +2648,7 @@ function executeCommands(scene, passState) {
       invertClassification = scene._invertClassification;
     }
 
-    us.updatePass(Pass.TRANSLUCENT);
+    uniformState.updatePass(Pass.TRANSLUCENT);
     commands = frustumCommands.commands[Pass.TRANSLUCENT];
     commands.length = frustumCommands.indices[Pass.TRANSLUCENT];
     executeTranslucentCommands(
@@ -2702,9 +2707,9 @@ function executeCommands(scene, passState) {
         ? frustumCommands.near * scene.opaqueFrustumNearOffset
         : frustumCommands.near;
     frustum.far = frustumCommands.far;
-    us.updateFrustum(frustum);
+    uniformState.updateFrustum(frustum);
 
-    us.updatePass(Pass.GLOBE);
+    uniformState.updatePass(Pass.GLOBE);
     commands = frustumCommands.commands[Pass.GLOBE];
     length = frustumCommands.indices[Pass.GLOBE];
 
@@ -2732,21 +2737,21 @@ function executeCommands(scene, passState) {
       depthPlane.execute(context, passState);
     }
 
-    us.updatePass(Pass.CESIUM_3D_TILE);
+    uniformState.updatePass(Pass.CESIUM_3D_TILE);
     commands = frustumCommands.commands[Pass.CESIUM_3D_TILE];
     length = frustumCommands.indices[Pass.CESIUM_3D_TILE];
     for (j = 0; j < length; ++j) {
       executeIdCommand(commands[j], scene, context, passState);
     }
 
-    us.updatePass(Pass.OPAQUE);
+    uniformState.updatePass(Pass.OPAQUE);
     commands = frustumCommands.commands[Pass.OPAQUE];
     length = frustumCommands.indices[Pass.OPAQUE];
     for (j = 0; j < length; ++j) {
       executeIdCommand(commands[j], scene, context, passState);
     }
 
-    us.updatePass(Pass.TRANSLUCENT);
+    uniformState.updatePass(Pass.TRANSLUCENT);
     commands = frustumCommands.commands[Pass.TRANSLUCENT];
     length = frustumCommands.indices[Pass.TRANSLUCENT];
     for (j = 0; j < length; ++j) {
@@ -3337,7 +3342,10 @@ function updateShadowMaps(scene) {
   const length = shadowMaps.length;
 
   const shadowsEnabled =
-    length > 0 && !frameState.passes.pick && scene.mode === SceneMode.SCENE3D;
+    length > 0 &&
+    !frameState.passes.pick &&
+    !frameState.passes.pickVoxel &&
+    scene.mode === SceneMode.SCENE3D;
   if (shadowsEnabled !== frameState.shadowState.shadowsEnabled) {
     // Update derived commands when shadowsEnabled changes
     ++frameState.shadowState.lastDirtyTime;
@@ -3401,7 +3409,7 @@ function updateAndClearFramebuffers(scene, passState, clearColor) {
   const view = scene._view;
 
   const passes = scene._frameState.passes;
-  const picking = passes.pick;
+  const picking = passes.pick || passes.pickVoxel;
   if (defined(view.globeDepth)) {
     view.globeDepth.picking = picking;
   }
@@ -3662,7 +3670,7 @@ Scene.prototype.getHeight = function (cartographic, heightReference) {
       if (
         !primitive.isCesium3DTileset ||
         !primitive.show ||
-        primitive.disableCollision
+        !primitive.enableCollision
       ) {
         continue;
       }
@@ -3741,8 +3749,8 @@ Scene.prototype.updateHeight = function (
   const createPrimitiveEventListener = (primitive) => {
     if (
       ignore3dTiles ||
-      !primitive.isCesium3DTileset ||
-      primitive.disableCollision
+      primitive.isDestroyed() ||
+      !primitive.isCesium3DTileset
     ) {
       return;
     }
@@ -3768,11 +3776,12 @@ Scene.prototype.updateHeight = function (
   );
   const removeRemovedListener = this.primitives.primitiveRemoved.addEventListener(
     (primitive) => {
-      if (!primitive.isCesium3DTileset) {
+      if (primitive.isDestroyed() || !primitive.isCesium3DTileset) {
         return;
       }
-
-      tilesetRemoveCallbacks[primitive.id]();
+      if (defined(tilesetRemoveCallbacks[primitive.id])) {
+        tilesetRemoveCallbacks[primitive.id]();
+      }
       delete tilesetRemoveCallbacks[primitive.id];
     }
   );
@@ -3828,8 +3837,25 @@ Scene.prototype.initializeFrame = function () {
   this._tweens.update();
 
   if (this._globeHeightDirty) {
+    if (defined(this._removeUpdateHeightCallback)) {
+      this._removeUpdateHeightCallback();
+      this._removeUpdateHeightCallback = undefined;
+    }
+
     this._globeHeight = getGlobeHeight(this);
     this._globeHeightDirty = false;
+
+    const cartographic = this.camera.positionCartographic;
+    this._removeUpdateHeightCallback = this.updateHeight(
+      cartographic,
+      (updatedCartographic) => {
+        if (this.isDestroyed()) {
+          return;
+        }
+
+        this._globeHeight = updatedCartographic.height;
+      }
+    );
   }
   this._cameraUnderground = isCameraUnderground(this);
   this._globeTranslucencyState.update(this);
@@ -4145,6 +4171,59 @@ Scene.prototype.pick = function (windowPosition, width, height) {
   return this._picking.pick(this, windowPosition, width, height);
 };
 
+/**
+ * Returns a {@link VoxelCell} for the voxel sample rendered at a particular window coordinate,
+ * or undefined if no voxel is rendered at that position.
+ *
+ * @example
+ * On left click, report the value of the "color" property at that voxel sample.
+ * handler.setInputAction(function(movement) {
+ *   const voxelCell = scene.pickVoxel(movement.position);
+ *   if (defined(voxelCell)) {
+ *     console.log(voxelCell.getProperty("color"));
+ *   }
+ * }, Cesium.ScreenSpaceEventType.LEFT_CLICK);
+ *
+ * @param {Cartesian2} windowPosition Window coordinates to perform picking on.
+ * @param {number} [width=3] Width of the pick rectangle.
+ * @param {number} [height=3] Height of the pick rectangle.
+ * @returns {VoxelCell|undefined} Information about the voxel cell rendered at the picked position.
+ *
+ * @experimental This feature is not final and is subject to change without Cesium's standard deprecation policy.
+ */
+Scene.prototype.pickVoxel = function (windowPosition, width, height) {
+  const pickedObject = this.pick(windowPosition, width, height);
+  if (!defined(pickedObject)) {
+    return;
+  }
+  const voxelPrimitive = pickedObject.primitive;
+  if (!(voxelPrimitive instanceof VoxelPrimitive)) {
+    return;
+  }
+  const voxelCoordinate = this._picking.pickVoxelCoordinate(
+    this,
+    windowPosition,
+    width,
+    height
+  );
+  // Look up the keyframeNode containing this picked cell
+  const tileIndex = 255 * voxelCoordinate[0] + voxelCoordinate[1];
+  const keyframeNode = voxelPrimitive._traversal.findKeyframeNode(tileIndex);
+  if (!defined(keyframeNode)) {
+    // The tile rendered at the pick position has since been discarded by
+    // a traversal update
+    return;
+  }
+  // Look up the metadata for the picked cell
+  const sampleIndex = 255 * voxelCoordinate[2] + voxelCoordinate[3];
+  return VoxelCell.fromKeyframeNode(
+    voxelPrimitive,
+    tileIndex,
+    sampleIndex,
+    keyframeNode
+  );
+};
+
 /**
  * Returns the cartesian position reconstructed from the depth buffer and window position.
  * The returned position is in world coordinates. Used internally by camera functions to
@@ -4738,6 +4817,11 @@ Scene.prototype.destroy = function () {
   }
   this._removeGlobeCallbacks.length = 0;
 
+  if (defined(this._removeUpdateHeightCallback)) {
+    this._removeUpdateHeightCallback();
+    this._removeUpdateHeightCallback = undefined;
+  }
+
   return destroyObject(this);
 };
 export default Scene;