@hztxi/cesium-engine 25.0.7 → 26.2.2

package/Source/Scene/Scene.js

@@ -45,6 +45,7 @@ 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";
@@ -70,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";
@@ -109,9 +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 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.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.
@@ -245,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();
 
@@ -775,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();
@@ -1084,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
@@ -1232,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.
@@ -1530,11 +1573,12 @@ Object.defineProperties(Scene.prototype, {
   },
 
   /**
-   * Gets or sets whether the 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.COLUMBUS_VIEW}.
+   * 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}
@@ -1795,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)) {
@@ -1892,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;
@@ -1985,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;
@@ -2271,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)
@@ -2492,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) {
@@ -2993,6 +3069,77 @@ function executeColumbusWorldCopyClassification(
   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.
  *
@@ -3007,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;
@@ -3040,7 +3191,8 @@ function executeCommands(scene, passState) {
     !renderTranslucentDepthForPick &&
     useGlobeDepthFramebuffer &&
     frameState.columbusRepeatWorlds === true &&
-    scene.mode === SceneMode.COLUMBUS_VIEW &&
+    (scene.mode === SceneMode.SCENE2D ||
+      scene.mode === SceneMode.COLUMBUS_VIEW) &&
     (passes.render || passes.pick || passes.pickVoxel);
 
   const {
@@ -3212,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.
 
@@ -3321,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) {
@@ -3391,7 +3563,8 @@ function executeCommands(scene, passState) {
 
   if (
     frameState.columbusRepeatWorlds === true &&
-    frameState.mode === SceneMode.COLUMBUS_VIEW &&
+    (frameState.mode === SceneMode.SCENE2D ||
+      frameState.mode === SceneMode.COLUMBUS_VIEW) &&
     (passes.render || passes.pick || passes.pickVoxel)
   ) {
     executeColumbusWorldCopyCommands(
@@ -4125,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);
@@ -4137,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);
 
@@ -4155,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;
 
@@ -4260,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) {
@@ -4816,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;
@@ -4953,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.

package/Source/Scene/SceneTransforms.js

@@ -135,13 +135,14 @@ SceneTransforms.worldWithEyeOffsetToWindowCoordinates = function (
   const camera = scene.camera;
 
   if (
-    frameState.mode === SceneMode.COLUMBUS_VIEW &&
+    (frameState.mode === SceneMode.SCENE2D ||
+      frameState.mode === SceneMode.COLUMBUS_VIEW) &&
     frameState.columbusRepeatWorlds === true
   ) {
-    // Columbus repeat worlds: rendering replicates the data onto every world
-    // copy, so screen-space consumers (HTML overlays, editor handles) must
-    // project onto the copy nearest the camera as well. Columbus world
-    // coordinates are (height, u, v), so the copy offset applies to y.
+    // Repeat worlds: rendering replicates the data onto every world copy, so
+    // screen-space consumers (HTML overlays, editor handles) must project onto
+    // the copy nearest the camera as well. Both 2D and Columbus View place the
+    // map-u axis on world y, so the copy offset applies to y.
     actualPosition.y = ColumbusWorlds.nearestWorldU(
       camera.positionWC.y,
       actualPosition.y,

package/Source/Scene/ShadowMap.js

@@ -1719,20 +1719,25 @@ function createCastDerivedCommand(
     const isPointLight = shadowMap._isPointLight;
     const usesDepthTexture = shadowMap._usesDepthTexture;
 
+    const vertexShaderSource = shaderProgram.vertexShaderSource;
+    const fragmentShaderSource = shaderProgram.fragmentShaderSource;
+
+    const hasClipping =
+      isOpaque &&
+      ShadowMapShader.hasClippingForShadowCast(fragmentShaderSource);
+
     const keyword = ShadowMapShader.getShadowCastShaderKeyword(
       isPointLight,
       isTerrain,
       usesDepthTexture,
       isOpaque,
+      hasClipping,
     );
     castShader = context.shaderCache.getDerivedShaderProgram(
       shaderProgram,
       keyword,
     );
     if (!defined(castShader)) {
-      const vertexShaderSource = shaderProgram.vertexShaderSource;
-      const fragmentShaderSource = shaderProgram.fragmentShaderSource;
-
       const castVS = ShadowMapShader.createShadowCastVertexShader(
         vertexShaderSource,
         isPointLight,
@@ -1743,6 +1748,7 @@ function createCastDerivedCommand(
         isPointLight,
         usesDepthTexture,
         isOpaque,
+        hasClipping,
       );
 
       castShader = context.shaderCache.createDerivedShaderProgram(

package/Source/Scene/ShadowMapShader.js

@@ -6,13 +6,48 @@ import ShaderSource from "../Renderer/ShaderSource.js";
  */
 function ShadowMapShader() {}
 
+const clippingDefines = {
+  HAS_CLIPPING_PLANES: true,
+  ENABLE_CLIPPING_POLYGONS: true,
+};
+
+/**
+ * Returns true if the fragment shader clips fragments via a
+ * ClippingPlaneCollection or ClippingPolygonCollection, in which case the
+ * shadow cast pass must run the original main so that clipped fragments
+ * are discarded and do not cast shadows.
+ *
+ * @param {ShaderSource} fragmentShaderSource
+ * @returns {boolean}
+ */
+ShadowMapShader.hasClippingForShadowCast = function (fragmentShaderSource) {
+  const defines = fragmentShaderSource.defines;
+  return (
+    defined(defines) &&
+    defines.some(function (define) {
+      return clippingDefines[define] === true;
+    })
+  );
+};
+
+/**
+ * @param {boolean} isPointLight
+ * @param {boolean} isTerrain
+ * @param {boolean} usesDepthTexture
+ * @param {boolean} isOpaque
+ * @param {boolean} hasClipping True if the fragment shader discards clipped
+ *   fragments. Differentiates cached shader variants so that a shader that
+ *   must call czm_shadow_cast_main() is never reused for one that does not.
+ * @returns {string}
+ */
 ShadowMapShader.getShadowCastShaderKeyword = function (
   isPointLight,
   isTerrain,
   usesDepthTexture,
   isOpaque,
+  hasClipping,
 ) {
-  return `castShadow ${isPointLight} ${isTerrain} ${usesDepthTexture} ${isOpaque}`;
+  return `castShadow ${isPointLight} ${isTerrain} ${usesDepthTexture} ${isOpaque} ${hasClipping}`;
 };
 
 ShadowMapShader.createShadowCastVertexShader = function (
@@ -54,11 +89,22 @@ ShadowMapShader.createShadowCastVertexShader = function (
   });
 };
 
+/**
+ * @param {ShaderSource} fs
+ * @param {boolean} isPointLight
+ * @param {boolean} usesDepthTexture
+ * @param {boolean} opaque
+ * @param {boolean} hasClipping True if the fragment shader discards clipped
+ *   fragments. When true, czm_shadow_cast_main() (the renamed original main)
+ *   is called first so that clipping discards execute during the shadow cast pass.
+ * @returns {ShaderSource}
+ */
 ShadowMapShader.createShadowCastFragmentShader = function (
   fs,
   isPointLight,
   usesDepthTexture,
   opaque,
+  hasClipping,
 ) {
   const defines = fs.defines.slice(0);
   const sources = fs.sources.slice(0);
@@ -85,7 +131,9 @@ ShadowMapShader.createShadowCastFragmentShader = function (
     fsSource += "uniform vec4 shadowMap_lightPositionEC; \n";
   }
 
-  if (opaque) {
+  if (opaque && hasClipping) {
+    fsSource += "void main() \n" + "{ \n" + "    czm_shadow_cast_main(); \n";
+  } else if (opaque) {
     fsSource += "void main() \n" + "{ \n";
   } else {
     fsSource +=

package/Source/Scene/SnapFramebuffer.js

@@ -0,0 +1,121 @@
+import BoundingRectangle from "../Core/BoundingRectangle.js";
+import defined from "../Core/defined.js";
+import destroyObject from "../Core/destroyObject.js";
+import PixelFormat from "../Core/PixelFormat.js";
+import FramebufferManager from "../Renderer/FramebufferManager.js";
+import PassState from "../Renderer/PassState.js";
+import PixelDatatype from "../Renderer/PixelDatatype.js";
+
+/**
+ * @private
+ */
+function SnapFramebuffer(context) {
+  const passState = new PassState(context);
+  passState.blendingEnabled = false;
+  passState.scissorTest = {
+    enabled: true,
+    rectangle: new BoundingRectangle(),
+  };
+  passState.viewport = new BoundingRectangle();
+
+  this._context = context;
+  this._fb = new FramebufferManager({
+    depthStencil: true,
+    pixelDatatype: PixelDatatype.FLOAT,
+    pixelFormat: PixelFormat.RGBA,
+  });
+  this._passState = passState;
+}
+
+function getSnapObjectsFromPixels(context, pixels, width, height) {
+  const max = Math.max(width, height);
+  const length = max * max;
+  const halfWidth = Math.floor(width * 0.5);
+  const halfHeight = Math.floor(height * 0.5);
+
+  let x = 0;
+  let y = 0;
+  let dx = 0;
+  let dy = -1;
+
+  const results = [];
+  for (let i = 0; i < length; ++i) {
+    if (
+      -halfWidth <= x &&
+      x <= halfWidth &&
+      -halfHeight <= y &&
+      y <= halfHeight
+    ) {
+      const index = 4 * ((halfHeight - y) * width + x + halfWidth);
+
+      const pickColor = pixels[index];
+      const object = context.getObjectByPickColor(pickColor);
+      if (defined(object)) {
+        results.push({
+          object: object,
+          isEdge: pixels[index + 1] > 0.0,
+          depth: pixels[index + 2],
+          x: x,
+          y: y,
+        });
+      }
+    }
+
+    if (x === y || (x < 0 && -x === y) || (x > 0 && x === 1 - y)) {
+      const temp = dx;
+      dx = -dy;
+      dy = temp;
+    }
+
+    x += dx;
+    y += dy;
+  }
+
+  return results;
+}
+
+SnapFramebuffer.prototype.begin = function (screenSpaceRectangle, viewport) {
+  const context = this._context;
+  const { width, height } = viewport;
+
+  BoundingRectangle.clone(
+    screenSpaceRectangle,
+    this._passState.scissorTest.rectangle,
+  );
+
+  this._fb.update(context, width, height);
+  this._passState.framebuffer = this._fb.framebuffer;
+
+  this._passState.viewport.width = width;
+  this._passState.viewport.height = height;
+
+  return this._passState;
+};
+
+SnapFramebuffer.prototype.end = function (screenSpaceRectangle) {
+  const width = screenSpaceRectangle.width ?? 1.0;
+  const height = screenSpaceRectangle.height ?? 1.0;
+
+  const context = this._context;
+  const pixels = context.readPixels({
+    x: screenSpaceRectangle.x,
+    y: screenSpaceRectangle.y,
+    width: width,
+    height: height,
+    pixelDatatype: PixelDatatype.FLOAT,
+    framebuffer: this._fb.framebuffer,
+  });
+
+  return getSnapObjectsFromPixels(context, pixels, width, height);
+};
+
+SnapFramebuffer.prototype.isDestroyed = function () {
+  return false;
+};
+
+SnapFramebuffer.prototype.destroy = function () {
+  this._fb.destroy();
+  return destroyObject(this);
+};
+
+export default SnapFramebuffer;