@hztxi/cesium-engine 25.0.6 → 26.2.1

package/Source/Scene/Scene.js

@@ -45,6 +45,8 @@ import BrdfLutGenerator from "./BrdfLutGenerator.js";
 import Camera from "./Camera.js";
 import Cesium3DTilePass from "./Cesium3DTilePass.js";
 import Cesium3DTilePassState from "./Cesium3DTilePassState.js";
+import ControllerHost from "./Controllers/ControllerHost.js";
+import ColumbusWorlds from "./ColumbusWorlds.js";
 import CreditDisplay from "./CreditDisplay.js";
 import DebugCameraPrimitive from "./DebugCameraPrimitive.js";
 import DepthPlane from "./DepthPlane.js";
@@ -69,6 +71,7 @@ import SceneTransitioner from "./SceneTransitioner.js";
 import ScreenSpaceCameraController from "./ScreenSpaceCameraController.js";
 import ShadowMap from "./ShadowMap.js";
 import SharedContext from "../Renderer/SharedContext.js";
+import Snapping from "./Snapping.js";
 import SpecularEnvironmentCubeMap from "./SpecularEnvironmentCubeMap.js";
 import StencilConstants from "./StencilConstants.js";
 import SunLight from "./SunLight.js";
@@ -108,6 +111,9 @@ const requestRenderAfterFrame = function (scene) {
  * @param {boolean} [options.scene3DOnly=false] If true, optimizes memory use and performance for 3D mode but disables the ability to use 2D or Columbus View.
  * @param {boolean} [options.shadows=false] Determines if shadows are cast by light sources.
  * @param {MapMode2D} [options.mapMode2D=MapMode2D.INFINITE_SCROLL] Determines if the 2D map is rotatable or can be scrolled infinitely in the horizontal direction.
+ * @param {boolean} [options.columbusRepeatWorlds=false] If true, the 2D or Columbus View map repeats horizontally:
+ *        translated copies of the globe surface tiles are rendered beyond the ±180° meridian so the map, entity
+ *        placement, and picking continue seamlessly across the antimeridian.
  * @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.
@@ -241,6 +247,8 @@ function Scene(options) {
   this._preRender = new Event();
   this._postRender = new Event();
 
+  this._controllerHost = new ControllerHost();
+
   this._minimumDisableDepthTestDistance = 0.0;
   this._debugInspector = new DebugInspector();
 
@@ -627,6 +635,7 @@ function Scene(options) {
   this._screenSpaceCameraController = new ScreenSpaceCameraController(this);
   this._cameraUnderground = false;
   this._mapMode2D = options.mapMode2D ?? MapMode2D.INFINITE_SCROLL;
+  this._columbusRepeatWorlds = options.columbusRepeatWorlds ?? false;
 
   // Keeps track of the state of a frame. FrameState is the state across
   // the primitives of the scene. This state is for internally keeping track
@@ -770,6 +779,15 @@ function Scene(options) {
    */
   this._enableEdgeVisibility = false;
 
+  /**
+   * Whether or not to enable the planar fill feature-ID pre-pass.
+   * Updated each frame from FrameState.planarFillRequested.
+   * @type {boolean}
+   * @default false
+   * @private
+   */
+  this._enablePlanarFillId = false;
+
   // Give frameState, camera, and screen space camera controller initial state before rendering
   updateFrameNumber(this, 0.0, JulianDate.now());
   this.updateFrameState();
@@ -1079,6 +1097,25 @@ Object.defineProperties(Scene.prototype, {
     },
   },
 
+  /**
+   * Collects an array of <code>Controller</code> objects that can be registered with the scene to handle input events, camera animations, and other interactions.
+   * @see {@link Controller}
+   * @type {ControllerHost}
+   * @memberof Scene.prototype
+   * @readonly
+   * @example
+   * scene.screenSpaceCameraController.enableInputs = false;
+   * scene.screenSpaceCameraController.enableCollisionDetection = false;
+   *
+   * const tiltOrbitController = new Cesium.ScreenSpaceTiltOrbitCameraController();
+   * scene.controllerHost.registerController(tiltOrbitController, scene.canvas.parentNode);
+   */
+  controllerHost: {
+    get: function () {
+      return this._controllerHost;
+    },
+  },
+
   /**
    * Gets the controller for camera input handling.
    * @memberof Scene.prototype
@@ -1227,6 +1264,17 @@ Object.defineProperties(Scene.prototype, {
     },
   },
 
+  /**
+   * @memberof Scene.prototype
+   * @type {VectorProvider}
+   * @ignore
+   */
+  vectorProvider: {
+    get: function () {
+      return this.globe?.vectorProvider;
+    },
+  },
+
   /**
    * Gets the event that will be raised before the scene is updated or rendered.  Subscribers to the event
    * receive the Scene instance as the first parameter and the current time as the second parameter.
@@ -1524,6 +1572,27 @@ Object.defineProperties(Scene.prototype, {
     },
   },
 
+  /**
+   * Gets or sets whether the 2D or Columbus View map repeats horizontally. When
+   * true, translated copies of the globe surface tiles are rendered beyond the
+   * ±180° meridian, and entity placement/picking wrap to the copy nearest the
+   * camera, so editing and animation work seamlessly across the antimeridian.
+   * Only has an effect in {@link SceneMode.SCENE2D} and
+   * {@link SceneMode.COLUMBUS_VIEW}.
+   * @memberof Scene.prototype
+   *
+   * @type {boolean}
+   * @default false
+   */
+  columbusRepeatWorlds: {
+    get: function () {
+      return this._columbusRepeatWorlds;
+    },
+    set: function (value) {
+      this._columbusRepeatWorlds = value;
+    },
+  },
+
   /**
    * Gets or sets the position of the splitter within the viewport.  Valid values are between 0.0 and 1.0.
    * @memberof Scene.prototype
@@ -1770,6 +1839,16 @@ function updateDerivedCommands(scene, command, shadowsDirty) {
       derivedCommands.picking,
     );
   }
+  // Snap derived commands are only created on demand, during a snapping pass,
+  // so applications that never call Scene.snap pay no shader-derivation cost.
+  if (defined(command.snapId) && frameState.passes.snap) {
+    derivedCommands.snapping = DerivedCommand.createSnapDerivedCommand(
+      scene,
+      command,
+      context,
+      derivedCommands.snapping,
+    );
+  }
   if (frameState.pickingMetadata && command.pickMetadataAllowed) {
     command.pickedMetadataInfo = frameState.pickedMetadataInfo;
     if (defined(command.pickedMetadataInfo)) {
@@ -1867,12 +1946,17 @@ Scene.prototype.updateDerivedCommands = function (command) {
   const needsUpdateForMetadataPicking =
     frameState.pickingMetadata &&
     pickedMetadataInfoChanged(command, frameState);
+  const needsUpdateForSnap =
+    frameState.passes.snap &&
+    defined(command.snapId) &&
+    !defined(derivedCommands.snapping);
   command.dirty =
     command.dirty ||
     needsLogDepthDerivedCommands ||
     needsHdrCommands ||
     needsDerivedCommands ||
-    needsUpdateForMetadataPicking;
+    needsUpdateForMetadataPicking ||
+    needsUpdateForSnap;
 
   if (!command.dirty) {
     return;
@@ -1960,6 +2044,7 @@ Scene.prototype.clearPasses = function (passes) {
   passes.render = false;
   passes.pick = false;
   passes.pickVoxel = false;
+  passes.snap = false;
   passes.depth = false;
   passes.postProcess = false;
   passes.offscreen = false;
@@ -1985,6 +2070,7 @@ Scene.prototype.updateFrameState = function () {
   frameState.mode = this._mode;
   frameState.morphTime = this.morphTime;
   frameState.mapProjection = this.mapProjection;
+  frameState.columbusRepeatWorlds = this._columbusRepeatWorlds;
   frameState.camera = camera;
   frameState.cullingVolume = camera.frustum.computeCullingVolume(
     camera.positionWC,
@@ -2245,6 +2331,21 @@ function executeCommand(command, scene, passState, debugFramebuffer) {
 
   if (passes.pick || passes.depth) {
     if (passes.pick && !passes.depth) {
+      if (frameState.passes.snap) {
+        // Snapping pass: only commands with a snap variant write the float
+        // snap payload. Commands without one (no snapId, e.g. globe/terrain)
+        // execute depth-only so they still occlude snappable geometry behind
+        // them without polluting the RGBA32F snap framebuffer with RGBA8
+        // pick colors.
+        if (defined(command.derivedCommands.snapping)) {
+          command = command.derivedCommands.snapping.snapCommand;
+          command.execute(context, passState);
+        } else if (defined(command.derivedCommands.depth)) {
+          command = command.derivedCommands.depth.depthOnlyCommand;
+          command.execute(context, passState);
+        }
+        return;
+      }
       if (
         frameState.pickingMetadata &&
         defined(command.derivedCommands.pickingMetadata)
@@ -2466,6 +2567,7 @@ function createWorkingFrustum(camera) {
  *
  * @param {Scene} scene The scene.
  * @returns {Function} A function to execute translucent commands.
+ * @ignore
  */
 function obtainTranslucentCommandExecutionFunction(scene) {
   if (scene._environmentState.useOIT) {
@@ -2618,6 +2720,426 @@ function performCesium3DTileEdgesPass(scene, passState, frustumCommands) {
   passState.framebuffer = originalFramebuffer;
 }
 
+const COLUMBUS_MAX_COPY_WORLDS = 2;
+const columbusWorldIndicesScratch = [];
+
+/**
+ * Finds the primary pass' frustum whose depth range best matches a copy's
+ * frustum. A copy's visible set is culled from the shifted camera, so its
+ * frustum split can differ from the primary pass' (the globe emits translated
+ * tile commands whose distances change under the shift). Pairing by index then
+ * matches a copy's terrain commands with a primary frustum that holds no
+ * terrain, and the classification shader samples that frustum's empty globe
+ * depth copy, discarding every fragment. Pair by depth range instead: a frustum
+ * whose midpoint falls inside a primary range maps to that range, and a frustum
+ * outside every range maps to the closest one.
+ *
+ * @param {FrustumCommands[]} primaryFrustumCommandsList The primary pass' bins.
+ * @param {FrustumCommands} frustumCommands The copy's bin.
+ * @returns {number} The index of the matching primary frustum, or -1 when the primary visible set is empty.
+ * @private
+ */
+function matchPrimaryFrustumIndex(primaryFrustumCommandsList, frustumCommands) {
+  const count = primaryFrustumCommandsList.length;
+  if (count === 0) {
+    return -1;
+  }
+
+  const midpoint = (frustumCommands.near + frustumCommands.far) * 0.5;
+  let bestIndex = count - 1;
+  let bestDistance = Number.POSITIVE_INFINITY;
+  for (let i = 0; i < count; ++i) {
+    const primary = primaryFrustumCommandsList[i];
+    let distance = 0.0;
+    if (midpoint < primary.near) {
+      distance = primary.near - midpoint;
+    } else if (midpoint > primary.far) {
+      distance = midpoint - primary.far;
+    }
+    if (distance < bestDistance) {
+      bestDistance = distance;
+      bestIndex = i;
+    }
+  }
+  return bestIndex;
+}
+
+const columbusCopyCullingVolume = new CullingVolume();
+const columbusSavedPositionWC = new Cartesian3();
+const columbusSavedViewMatrix = new Matrix4();
+const columbusSavedInvViewMatrix = new Matrix4();
+
+/**
+ * Renders the data passes again for each visible world copy when Columbus
+ * repeat worlds is enabled, so primitives authored in the primary world also
+ * appear on the copies around the camera. Each copy is the primary-world
+ * command list viewed by a camera shifted a whole world along map-u, which
+ * replicates every draw command type (and its pick derived command) without
+ * duplicating geometry, memory or per-element placement logic.
+ *
+ * Globe tiles are deliberately excluded: {@link GlobeSurfaceTileProvider}
+ * already emits its own translated tile commands, which the regular GLOBE
+ * pass renders once.
+ *
+ * @param {Scene} scene The scene.
+ * @param {PassState} passState The render pass state.
+ * @param {Frustum} frustum The working frustum used by executeCommands.
+ * @param {Function} performPass Executes a pass for a frustum's command bin.
+ * @param {boolean} classifyInline Whether the copies' ground classification was already executed by executeCommands.
+ * @private
+ */
+function executeColumbusWorldCopyCommands(
+  scene,
+  passState,
+  frustum,
+  performPass,
+  classifyInline,
+) {
+  const { camera, context, frameState } = scene;
+  const { uniformState } = context;
+
+  const worldWidth = ColumbusWorlds.getWorldWidth(frameState.mapProjection);
+  const worldIndices = ColumbusWorlds.getVisibleWorldIndices(
+    camera._positionWC.y,
+    worldWidth,
+    frameState.cullingVolume,
+    COLUMBUS_MAX_COPY_WORLDS,
+    columbusWorldIndicesScratch,
+  );
+  if (worldIndices.length === 0) {
+    return;
+  }
+
+  const view = scene._view;
+
+  // The globe depth texture is produced inside the primary pass' frustum loop.
+  // That loop is skipped when no command is visible from the camera's own copy
+  // (the camera can sit on a non-primary copy, with all data a world away), so
+  // billboards, labels and other shaders sampling czm_globeDepthTexture would
+  // get an undefined uniform while the copies draw. Produce the (cleared) globe
+  // depth once here - the copies share the primary pass' screen space, so the
+  // texture is as valid for them as it would be for a regular frame.
+  if (!defined(uniformState.globeDepthTexture) && defined(view.globeDepth)) {
+    view.globeDepth.executeCopyDepth(context, passState);
+  }
+
+  const baseFrustumCommandsList = view.frustumCommandsList;
+  let copyFrustumCommandsList = scene._columbusFrustumCommands;
+  if (!defined(copyFrustumCommandsList)) {
+    copyFrustumCommandsList = scene._columbusFrustumCommands = [];
+  }
+
+  const cullingVolume = frameState.cullingVolume;
+  const positionWC = Cartesian3.clone(
+    camera._positionWC,
+    columbusSavedPositionWC,
+  );
+  const viewMatrix = Matrix4.clone(camera._viewMatrix, columbusSavedViewMatrix);
+  const invViewMatrix = Matrix4.clone(
+    camera._invViewMatrix,
+    columbusSavedInvViewMatrix,
+  );
+
+  for (let c = 0; c < worldIndices.length; ++c) {
+    const worldOffset = worldIndices[c] * worldWidth;
+
+    // Shift the camera to the copy and cull the data against its frustum,
+    // building the bins in a list private to the copies so the primary
+    // world's bins (used by pickPosition) stay intact.
+    ColumbusWorlds.applyCameraWorldOffset(camera, worldOffset);
+    frameState.cullingVolume = ColumbusWorlds.translateCullingVolume(
+      cullingVolume,
+      worldOffset,
+      columbusCopyCullingVolume,
+    );
+
+    view.frustumCommandsList = copyFrustumCommandsList;
+    view.createPotentiallyVisibleSet(scene);
+    view.frustumCommandsList = baseFrustumCommandsList;
+
+    uniformState.update(frameState);
+
+    const numFrustums = copyFrustumCommandsList.length;
+    for (let i = 0; i < numFrustums; ++i) {
+      const index = numFrustums - i - 1;
+      const frustumCommands = copyFrustumCommandsList[index];
+
+      // Draw with the primary pass' frustum ranges. Shifting the camera does
+      // not change any distance, so a copy's commands must be depth-encoded
+      // exactly like the primary pass - the depth buffer was written with
+      // these ranges, and log depth (or any frustum-dependent depth math) only
+      // decodes correctly against them. The copy's bins are not guaranteed to
+      // split at the same distances as the primary's, so match by range rather
+      // than by position in the list.
+      //
+      // The primary visible set is empty when nothing of the camera's own world
+      // is on screen (the camera can sit on a world copy with all data a world
+      // away). There is then no primary depth to match, so the copy falls back
+      // to its own ranges instead of indexing past the empty list.
+      const primaryIndex = matchPrimaryFrustumIndex(
+        baseFrustumCommandsList,
+        frustumCommands,
+      );
+      const primaryFrustum =
+        primaryIndex >= 0
+          ? baseFrustumCommandsList[primaryIndex]
+          : frustumCommands;
+      frustum.near =
+        primaryIndex !== 0
+          ? primaryFrustum.near * scene.opaqueFrustumNearOffset
+          : primaryFrustum.near;
+      frustum.far = primaryFrustum.far;
+      uniformState.updateFrustum(frustum);
+
+      if (context.stencilBuffer) {
+        scene._stencilClearCommand.execute(context, passState);
+      }
+
+      // Classic ground classification samples czm_globeDepthTexture. Bind the
+      // copy that the primary pass produced for the matching frustum: each copy
+      // is packed against its own frustum's near/far, so sampling another
+      // frustum's copy decodes garbage - the near frustum contains no terrain
+      // and packs to zero, which the ground polyline shader treats as sky, so
+      // every clamped line in the copy would be discarded.
+      const globeDepth = view.globeDepth;
+      const copyFrustumIndex = primaryIndex >= 0 ? primaryIndex : index;
+
+      // This bin's classification was already executed by the primary loop
+      // (executeColumbusWorldCopyClassification) against the live terrain
+      // depth. Replaying it here would only re-do the stencil work against a
+      // restored copy of that depth, so it is skipped - except when the primary
+      // loop could not cover it: pick passes, or a bin matching no primary
+      // frustum (the primary visible set can be empty).
+      const classifiedInline = classifyInline && primaryIndex >= 0;
+
+      let restoredDepth = false;
+      if (defined(globeDepth)) {
+        globeDepth.useCopyDepth(context, copyFrustumIndex);
+
+        // Ground classification is resolved against the terrain depth in the
+        // depth buffer (its stencil pass depth tests the shadow volume against
+        // it), not against czm_globeDepthTexture. The primary loop clears the
+        // globe depth right after its classification pass when the globe does
+        // not depth test against terrain - the default. Put the matching
+        // frustum's globe depth back before re-running the classification
+        // commands, otherwise every copy's ground element is classified
+        // against an empty buffer and silently dropped.
+        restoredDepth =
+          !classifiedInline &&
+          frameState.passes.render &&
+          scene._environmentState.clearGlobeDepth &&
+          frustumCommands.indices[Pass.TERRAIN_CLASSIFICATION] > 0;
+        if (restoredDepth) {
+          globeDepth.executeRestoreDepth(context, passState, copyFrustumIndex);
+        }
+      }
+
+      if (!classifiedInline) {
+        performPass(frustumCommands, Pass.TERRAIN_CLASSIFICATION);
+      }
+
+      // Mirror the primary pass, which clears the globe depth before its opaque
+      // commands so primitives drawn on the ground are not occluded by the
+      // terrain. The restore above is only for the classification.
+      if (restoredDepth) {
+        scene._depthClearCommand.execute(context, passState);
+      }
+
+      performPass(frustumCommands, Pass.OPAQUE);
+      performTranslucentPass(scene, passState, frustumCommands);
+    }
+
+    Cartesian3.clone(positionWC, camera._positionWC);
+    Matrix4.clone(viewMatrix, camera._viewMatrix);
+    Matrix4.clone(invViewMatrix, camera._invViewMatrix);
+  }
+
+  frameState.cullingVolume = cullingVolume;
+  uniformState.update(frameState);
+}
+
+/**
+ * Executes the world copies' terrain classification while the primary pass'
+ * terrain depth is still in the depth buffer.
+ *
+ * Ground classification is resolved by depth testing the shadow volume against
+ * the terrain depth (z-fail stencil counting), so it needs the live buffer.
+ * Replaying those commands later - after `clearGlobeDepth` wiped the buffer -
+ * only works off a restored copy of the globe depth, and a restored copy is not
+ * equivalent to the live buffer: it is a resolved, packed copy of it, so
+ * coplanar ground surfaces miss the comparison and drop out once the view is
+ * oblique (partial or speckled fills). Running the copies here, right after the
+ * primary classification and before the depth clear, hands them exactly the
+ * depth buffer the primary classification used.
+ *
+ * @param {Scene} scene The scene.
+ * @param {PassState} passState The render pass state.
+ * @param {Frustum} frustum The working frustum, already set to the primary frustum's depth ranges.
+ * @param {number} frustumIndex The primary frustum index currently being drawn.
+ * @param {Function} performPass Executes a pass for a frustum's command bin.
+ * @private
+ */
+function executeColumbusWorldCopyClassification(
+  scene,
+  passState,
+  frustum,
+  frustumIndex,
+  performPass,
+) {
+  const { camera, frameState } = scene;
+  const { uniformState } = scene.context;
+
+  const worldWidth = ColumbusWorlds.getWorldWidth(frameState.mapProjection);
+  const worldIndices = ColumbusWorlds.getVisibleWorldIndices(
+    camera._positionWC.y,
+    worldWidth,
+    frameState.cullingVolume,
+    COLUMBUS_MAX_COPY_WORLDS,
+    columbusWorldIndicesScratch,
+  );
+  if (worldIndices.length === 0) {
+    return;
+  }
+
+  const view = scene._view;
+  const baseFrustumCommandsList = view.frustumCommandsList;
+  let copyFrustumCommandsList = scene._columbusFrustumCommands;
+  if (!defined(copyFrustumCommandsList)) {
+    copyFrustumCommandsList = scene._columbusFrustumCommands = [];
+  }
+
+  const cullingVolume = frameState.cullingVolume;
+  const positionWC = Cartesian3.clone(
+    camera._positionWC,
+    columbusSavedPositionWC,
+  );
+  const viewMatrix = Matrix4.clone(camera._viewMatrix, columbusSavedViewMatrix);
+  const invViewMatrix = Matrix4.clone(
+    camera._invViewMatrix,
+    columbusSavedInvViewMatrix,
+  );
+
+  for (let c = 0; c < worldIndices.length; ++c) {
+    const worldOffset = worldIndices[c] * worldWidth;
+
+    ColumbusWorlds.applyCameraWorldOffset(camera, worldOffset);
+    frameState.cullingVolume = ColumbusWorlds.translateCullingVolume(
+      cullingVolume,
+      worldOffset,
+      columbusCopyCullingVolume,
+    );
+
+    view.frustumCommandsList = copyFrustumCommandsList;
+    view.createPotentiallyVisibleSet(scene);
+    view.frustumCommandsList = baseFrustumCommandsList;
+
+    // Draw with the primary frustum's ranges: the depth buffer was written
+    // with them, and the copies are only translations of the same distances.
+    uniformState.update(frameState);
+    uniformState.updateFrustum(frustum);
+
+    const numFrustums = copyFrustumCommandsList.length;
+    for (let i = 0; i < numFrustums; ++i) {
+      const copyFrustumCommands = copyFrustumCommandsList[numFrustums - i - 1];
+      // Every copy bin belongs to exactly one primary frustum, so it is
+      // classified once while that frustum is drawn.
+      if (
+        matchPrimaryFrustumIndex(
+          baseFrustumCommandsList,
+          copyFrustumCommands,
+        ) !== frustumIndex
+      ) {
+        continue;
+      }
+
+      if (scene.context.stencilBuffer) {
+        scene._stencilClearCommand.execute(scene.context, passState);
+      }
+
+      performPass(copyFrustumCommands, Pass.TERRAIN_CLASSIFICATION);
+    }
+
+    Cartesian3.clone(positionWC, camera._positionWC);
+    Matrix4.clone(viewMatrix, camera._viewMatrix);
+    Matrix4.clone(invViewMatrix, camera._invViewMatrix);
+  }
+
+  frameState.cullingVolume = cullingVolume;
+  uniformState.update(frameState);
+  uniformState.updateFrustum(frustum);
+}
+
+/**
+ * Execute the planar fill feature-ID pre-pass.
+ *
+ * Non-behind planar fill geometry writes its per-fragment feature ID into the
+ * planar fill ID framebuffer. This allows behind fills in the main 3D tile
+ * pass to check whether the existing pixel belongs to the same logical object.
+ *
+ * @param {Scene} scene
+ * @param {PassState} passState
+ * @param {FrustumCommands} frustumCommands
+ * @private
+ */
+function performPlanarFillIdPass(scene, passState, frustumCommands) {
+  const { context } = scene;
+  const { uniformState } = context;
+
+  uniformState.updatePass(Pass.CESIUM_3D_TILE_PLANAR_FILL_ID);
+
+  // Default to a blank texture so shaders always have something to sample.
+  uniformState.planarFillIdTexture = context.defaultTexture;
+
+  const view = scene._view;
+  const fb = view && view.planarFillIdFramebuffer;
+
+  const commands = frustumCommands.commands[Pass.CESIUM_3D_TILE_PLANAR_FILL_ID];
+  const commandCount =
+    frustumCommands.indices[Pass.CESIUM_3D_TILE_PLANAR_FILL_ID];
+
+  if (commandCount === 0) {
+    return;
+  }
+
+  if (scene._enablePlanarFillId && defined(fb) && defined(fb.framebuffer)) {
+    const originalFramebuffer = passState.framebuffer;
+    passState.framebuffer = fb.framebuffer;
+
+    // Clear to (0,0,0,0) — feature ID 0 means "no planar fill here".
+    const clearCommand = fb.getClearCommand(new Color(0.0, 0.0, 0.0, 0.0));
+    clearCommand.execute(context, passState);
+
+    for (let j = 0; j < commandCount; ++j) {
+      executeCommand(commands[j], scene, passState);
+    }
+
+    passState.framebuffer = originalFramebuffer;
+  }
+}
+
+/**
+ * Execute edge commands that should render directly to the main framebuffer
+ * (EDGES_ONLY mode). These edges bypass the MRT edge framebuffer and render
+ * on top of surface geometry.
+ *
+ * @param {Scene} scene
+ * @param {PassState} passState
+ * @param {FrustumCommands} frustumCommands
+ *
+ * @private
+ */
+function performCesium3DTileEdgesDirectPass(scene, passState, frustumCommands) {
+  scene.context.uniformState.updatePass(Pass.CESIUM_3D_TILE_EDGES_DIRECT);
+
+  const commands = frustumCommands.commands[Pass.CESIUM_3D_TILE_EDGES_DIRECT];
+  const commandCount =
+    frustumCommands.indices[Pass.CESIUM_3D_TILE_EDGES_DIRECT];
+
+  for (let j = 0; j < commandCount; ++j) {
+    executeCommand(commands[j], scene, passState);
+  }
+}
+
 /**
  * Execute the draw commands for all the render passes.
  *
@@ -2632,6 +3154,10 @@ function executeCommands(scene, passState) {
 
   uniformState.updateCamera(camera);
 
+  // Ensure planar fill ID texture is always available (even during edge pass)
+  // so that shaders referencing czm_planarFillIdTexture never see undefined.
+  uniformState.planarFillIdTexture = context.defaultTexture;
+
   const frustum = createWorkingFrustum(camera);
   frustum.near = camera.frustum.near;
   frustum.far = camera.frustum.far;
@@ -2655,6 +3181,20 @@ function executeCommands(scene, passState) {
     usePostProcessSelected,
   } = scene._environmentState;
 
+  // World copies classify per frustum, inside the loop below, so they see the
+  // live terrain depth of the frustum they belong to - for color and for pick
+  // passes alike, since the primary loop classifies in both. Requires the globe
+  // depth framebuffer: that is what the primary loop packs for the frustum and
+  // what ground classification shaders sample. Everything else (no globe depth,
+  // translucent depth pick) keeps classifying in the copy pass further down.
+  const classifyCopyInline =
+    !renderTranslucentDepthForPick &&
+    useGlobeDepthFramebuffer &&
+    frameState.columbusRepeatWorlds === true &&
+    (scene.mode === SceneMode.SCENE2D ||
+      scene.mode === SceneMode.COLUMBUS_VIEW) &&
+    (passes.render || passes.pick || passes.pickVoxel);
+
   const {
     globeDepth,
     globeTranslucencyFramebuffer,
@@ -2733,7 +3273,16 @@ function executeCommands(scene, passState) {
     }
 
     if (useGlobeDepthFramebuffer) {
-      globeDepth.executeCopyDepth(context, passState);
+      // Keep one globe depth copy per frustum when the Columbus world copies
+      // are drawn: they re-execute a primary frustum's classification, which
+      // decodes depth against that frustum's near/far, so they need the copy
+      // packed with those same ranges. Without the copies a single shared
+      // texture is enough (and avoids allocating a texture per frustum).
+      globeDepth.executeCopyDepth(
+        context,
+        passState,
+        frameState.columbusRepeatWorlds === true ? index : 0,
+      );
     }
 
     // Draw terrain classification
@@ -2752,6 +3301,19 @@ function executeCommands(scene, passState) {
       }
     }
 
+    // The world copies classify while this frustum's terrain depth is still
+    // live - the depth clear below destroys it, and a restored copy of it is
+    // not good enough for an oblique view.
+    if (classifyCopyInline) {
+      executeColumbusWorldCopyClassification(
+        scene,
+        passState,
+        frustum,
+        index,
+        performPass,
+      );
+    }
+
     if (clearGlobeDepth) {
       clearDepth.execute(context, passState);
       if (useDepthPlane) {
@@ -2802,6 +3364,23 @@ function executeCommands(scene, passState) {
         scene.context.defaultTexture;
     }
 
+    // Planar fill feature-ID pre-pass: write feature IDs from non-behind
+    // planar fill geometry so that behind fills can test same-object.
+    performPlanarFillIdPass(scene, passState, frustumCommands);
+
+    if (
+      scene._enablePlanarFillId &&
+      defined(scene._view) &&
+      defined(scene._view.planarFillIdFramebuffer)
+    ) {
+      const pfIdTexture = scene._view.planarFillIdFramebuffer.idTexture;
+      uniformState.planarFillIdTexture = defined(pfIdTexture)
+        ? pfIdTexture
+        : context.defaultTexture;
+    } else {
+      uniformState.planarFillIdTexture = context.defaultTexture;
+    }
+
     if (!useInvertClassification || picking || renderTranslucentDepthForPick) {
       // Common/fastest path. Draw 3D Tiles and classification normally.
 
@@ -2865,7 +3444,7 @@ function executeCommands(scene, passState) {
       passState.framebuffer = scene._invertClassification._fbo.framebuffer;
 
       // Draw normally
-      commandCount = performPass(frustumCommands, Pass.CESIUM_3D_TILE);
+      performPass(frustumCommands, Pass.CESIUM_3D_TILE);
 
       if (useGlobeDepthFramebuffer) {
         scene._invertClassification.prepareTextures(context);
@@ -2911,6 +3490,9 @@ function executeCommands(scene, passState) {
 
     performPass(frustumCommands, Pass.OPAQUE);
 
+    // Draw direct edges (EDGES_ONLY mode) after opaque surfaces
+    performCesium3DTileEdgesDirectPass(scene, passState, frustumCommands);
+
     performGaussianSplatPass(scene, passState, frustumCommands);
 
     if (index !== 0 && scene.mode !== SceneMode.SCENE2D) {
@@ -2978,6 +3560,21 @@ function executeCommands(scene, passState) {
 
     passState.framebuffer = originalFramebuffer;
   }
+
+  if (
+    frameState.columbusRepeatWorlds === true &&
+    (frameState.mode === SceneMode.SCENE2D ||
+      frameState.mode === SceneMode.COLUMBUS_VIEW) &&
+    (passes.render || passes.pick || passes.pickVoxel)
+  ) {
+    executeColumbusWorldCopyCommands(
+      scene,
+      passState,
+      frustum,
+      performPass,
+      classifyCopyInline,
+    );
+  }
 }
 
 /**
@@ -3609,10 +4206,9 @@ Scene.prototype.updateEnvironment = function () {
   );
 
   const envMaps = this.specularEnvironmentMaps;
-  let specularEnvironmentCubeMap = this._specularEnvironmentCubeMap;
+  const specularEnvironmentCubeMap = this._specularEnvironmentCubeMap;
   if (defined(envMaps) && specularEnvironmentCubeMap?.url !== envMaps) {
-    specularEnvironmentCubeMap =
-      specularEnvironmentCubeMap && specularEnvironmentCubeMap.destroy();
+    specularEnvironmentCubeMap?.destroy();
     this._specularEnvironmentCubeMap = new SpecularEnvironmentCubeMap(envMaps);
   } else if (!defined(envMaps) && defined(specularEnvironmentCubeMap)) {
     specularEnvironmentCubeMap.destroy();
@@ -3702,6 +4298,7 @@ function updateAndRenderPrimitives(scene) {
 
   // Reset per-frame edge visibility request flag before primitives update
   frameState.edgeVisibilityRequested = false;
+  frameState.planarFillRequested = false;
 
   scene._groundPrimitives.update(frameState);
   scene._primitives.update(frameState);
@@ -3714,6 +4311,10 @@ function updateAndRenderPrimitives(scene) {
     scene._enableEdgeVisibility = true;
   }
 
+  // True only while at least one planar fill primitive is rendering;
+  // the request flag is renewed each frame by ModelSceneGraph.
+  scene._enablePlanarFillId = frameState.planarFillRequested;
+
   updateDebugFrustumPlanes(scene);
   updateShadowMaps(scene);
 
@@ -3732,6 +4333,7 @@ function updateAndClearFramebuffers(scene, passState, clearColor) {
   const picking = passes.pick || passes.pickVoxel;
   if (defined(view.globeDepth)) {
     view.globeDepth.picking = picking;
+    view.globeDepth.snapping = passes.snap;
   }
   const useWebVR = environmentState.useWebVR;
 
@@ -3837,6 +4439,15 @@ function updateAndClearFramebuffers(scene, passState, clearColor) {
     view.edgeFramebuffer.update(context, view.viewport, scene._hdr);
   }
 
+  // Update planar fill ID framebuffer
+  const usePlanarFillIdFramebuffer = !picking && scene._enablePlanarFillId;
+  if (usePlanarFillIdFramebuffer) {
+    view.planarFillIdFramebuffer.update(context, view.viewport, scene._hdr);
+  } else if (!picking) {
+    // Release GPU resources while unused; recreated on demand by update().
+    view.planarFillIdFramebuffer.releaseResources();
+  }
+
   if (useInvertClassification) {
     let depthFramebuffer;
     if (frameState.invertClassificationColor.alpha === 1.0) {
@@ -4393,6 +5004,8 @@ Scene.prototype.render = function (time) {
     time = JulianDate.now();
   }
 
+  this._controllerHost.update(this, time);
+
   const cameraChanged = this._view.checkForCameraUpdates(this);
   if (cameraChanged) {
     this._globeHeightDirty = true;
@@ -4530,6 +5143,42 @@ Scene.prototype.pick = function (windowPosition, width, height) {
   return this._picking.pick(this, windowPosition, width, height, 1)[0];
 };
 
+/**
+ * The result of a snap operation. See {@link Scene#snap}.
+ *
+ * @typedef {object} SceneSnapResult
+ * @property {object} object The snapped primitive or feature.
+ * @property {Cartesian3} position The world-space position of the snap point, un-projected from the snap framebuffer's eye-space depth.
+ * @property {Cartesian2} screenPosition The window coordinates of the snap point.
+ * @property {boolean} isEdge <code>true</code> if the snap point lies on an edge; <code>false</code> if it lies on a surface.
+ *
+ * @experimental This feature is not final and is subject to change without Cesium's standard deprecation policy.
+ */
+
+/**
+ * Returns the best snap target in a screen-space region around <code>windowPosition</code>.
+ * Edges are preferred over surfaces; among hits of the same kind the one
+ * nearest the cursor wins. Returns <code>undefined</code> if the region contains
+ * no snappable geometry.
+ * <p>
+ * Only primitives rendered through the Model pipeline (e.g. 3D Tiles and glTF
+ * models) are snappable. Snapping requires float color attachments
+ * (WebGL2 with <code>EXT_color_buffer_float</code>); if unsupported, this
+ * function returns <code>undefined</code>.
+ * </p>
+ *
+ * @param {Cartesian2} windowPosition Window coordinates at the center of the search region.
+ * @param {object} [options] Object with the following properties:
+ * @param {number} [options.width=25] Width of the search region in pixels.
+ * @param {number} [options.height=options.width] Height of the search region in pixels.
+ * @returns {SceneSnapResult | undefined} The best snap target in the region, or <code>undefined</code> if there is none.
+ *
+ * @experimental This feature is not final and is subject to change without Cesium's standard deprecation policy.
+ */
+Scene.prototype.snap = function (windowPosition, options) {
+  return Snapping.snap(this, windowPosition, options);
+};
+
 /**
  * Performs the same operation as Scene.pick but asynchonosly without blocking the main render thread.
  * Requires WebGL2 else using fallback.