Merge pull request #9961 from DanielLeone/fastPickingWithOctree

Fast terrain picking (via quadtree)

Author: lilleyse

CHANGES.md

@@ -11,6 +11,7 @@
 #### Additions :tada:
 
 - Added `scene.pickAsync` for non GPU blocking picking using WebGL2 [#12983](https://github.com/CesiumGS/cesium/pull/12983)
+- Improves performance of terrain picks via new terrain picking quadtrees [#8481](https://github.com/CesiumGS/cesium/issues/8481)
 
 ## 1.135 - 2025-11-03
 

packages/engine/Source/Core/AxisAlignedBoundingBox.js

@@ -222,6 +222,30 @@ AxisAlignedBoundingBox.intersectPlane = function (box, plane) {
   return Intersect.INTERSECTING;
 };
 
+/**
+ * Determines whether two axis aligned bounding boxes intersect.
+ *
+ * @param {AxisAlignedBoundingBox} box first box
+ * @param {AxisAlignedBoundingBox} other second box
+ * @returns {boolean} <code>true</code> if the boxes intersect; otherwise, <code>false</code>.
+ */
+AxisAlignedBoundingBox.intersectAxisAlignedBoundingBox = function (box, other) {
+  //>>includeStart('debug', pragmas.debug);
+  Check.defined("box", box);
+  Check.defined("other", other);
+  //>>includeEnd('debug');
+
+  // This short circuits in favor of AABBs that do not intersect.
+  return (
+    box.minimum.x <= other.maximum.x &&
+    box.maximum.x >= other.minimum.x &&
+    box.minimum.y <= other.maximum.y &&
+    box.maximum.y >= other.minimum.y &&
+    box.minimum.z <= other.maximum.z &&
+    box.maximum.z >= other.minimum.z
+  );
+};
+
 /**
  * Duplicates this AxisAlignedBoundingBox instance.
  *
@@ -245,6 +269,18 @@ AxisAlignedBoundingBox.prototype.intersectPlane = function (plane) {
   return AxisAlignedBoundingBox.intersectPlane(this, plane);
 };
 
+/**
+ * Determines whether some other axis aligned bounding box intersects this box.
+ *
+ * @param {AxisAlignedBoundingBox} other The other axis aligned bounding box.
+ * @returns {boolean} <code>true</code> if the boxes intersect; otherwise, <code>false</code>.
+ */
+AxisAlignedBoundingBox.prototype.intersectAxisAlignedBoundingBox = function (
+  other,
+) {
+  return AxisAlignedBoundingBox.intersectAxisAlignedBoundingBox(this, other);
+};
+
 /**
  * Compares this AxisAlignedBoundingBox against the provided AxisAlignedBoundingBox componentwise and returns
  * <code>true</code> if they are equal, <code>false</code> otherwise.

packages/engine/Source/Core/Cesium3DTilesTerrainData.js

@@ -305,6 +305,7 @@ Cesium3DTilesTerrainData.prototype.createMesh = function (options) {
       vertexCountWithoutSkirts,
       minimumHeight,
       maximumHeight,
+      rectangle,
       boundingSphere,
       horizonOcclusionPoint,
       encoding.stride,
@@ -831,6 +832,7 @@ function upsampleMesh(
       vertexCountWithoutSkirts,
       minimumHeight,
       maximumHeight,
+      upsampleRectangle,
       boundingSphere,
       horizonOcclusionPoint,
       stride,

packages/engine/Source/Core/Cesium3DTilesTerrainGeometryProcessor.js

@@ -384,6 +384,7 @@ Cesium3DTilesTerrainGeometryProcessor.createMesh = async function (options) {
     vertexCountWithoutSkirts,
     minimumHeight,
     maximumHeight,
+    rectangle,
     BoundingSphere.clone(boundingSphere, new BoundingSphere()),
     Cartesian3.clone(horizonOcclusionPoint, new Cartesian3()),
     tempBufferStride,
@@ -1063,6 +1064,7 @@ Cesium3DTilesTerrainGeometryProcessor.upsampleMesh = function (options) {
     upsampledVertexCountWithoutSkirts,
     minimumHeight,
     maximumHeight,
+    upsampleRectangle,
     BoundingSphere.clone(boundingSphere),
     Cartesian3.clone(horizonOcclusionPoint),
     upsampledVertexBufferStride,

packages/engine/Source/Core/GoogleEarthEnterpriseTerrainData.js

@@ -210,6 +210,7 @@ GoogleEarthEnterpriseTerrainData.prototype.createMesh = function (options) {
       result.vertexCountWithoutSkirts,
       result.minimumHeight,
       result.maximumHeight,
+      rectangleScratch,
       BoundingSphere.clone(result.boundingSphere3D),
       Cartesian3.clone(result.occludeePointInScaledSpace),
       result.numberOfAttributes,

packages/engine/Source/Core/HeightmapTerrainData.js

@@ -283,6 +283,7 @@ HeightmapTerrainData.prototype.createMesh = function (options) {
       vertexCountWithoutSkirts,
       result.minimumHeight,
       result.maximumHeight,
+      rectangle,
       BoundingSphere.clone(result.boundingSphere3D),
       Cartesian3.clone(result.occludeePointInScaledSpace),
       result.numberOfAttributes,
@@ -389,6 +390,7 @@ HeightmapTerrainData.prototype._createMeshSync = function (options) {
     vertexCountWithoutSkirts,
     result.minimumHeight,
     result.maximumHeight,
+    rectangle,
     result.boundingSphere3D,
     result.occludeePointInScaledSpace,
     result.encoding.stride,

packages/engine/Source/Core/IntersectionTests.js

@@ -495,6 +495,86 @@ IntersectionTests.rayEllipsoid = function (ray, ellipsoid) {
   return undefined;
 };
 
+const scratchRayIntervalX = new Interval();
+const scratchRayIntervalY = new Interval();
+const scratchRayIntervalZ = new Interval();
+
+/**
+ * Computes the intersection points of a ray with an axis-aligned bounding box. (axis-aligned in the same space as the ray)
+ *
+ * @param {Ray} ray The ray.
+ * @param {AxisAlignedBoundingBox} box The axis-aligned bounding box.
+ * @param {Interval | undefined} result The interval containing scalar points along the ray or undefined if there are no intersections.
+ */
+IntersectionTests.rayAxisAlignedBoundingBox = function (ray, box, result) {
+  //>>includeStart('debug', pragmas.debug);
+  if (!defined(ray)) {
+    throw new DeveloperError("ray is required.");
+  }
+  if (!defined(box)) {
+    throw new DeveloperError("box is required.");
+  }
+  //>>includeEnd('debug');
+
+  if (!defined(result)) {
+    result = new Interval();
+  }
+
+  const tx = rayIntervalAlongAABBAxis(
+    ray.origin.x,
+    ray.direction.x,
+    box.minimum.x,
+    box.maximum.x,
+    scratchRayIntervalX,
+  );
+  const ty = rayIntervalAlongAABBAxis(
+    ray.origin.y,
+    ray.direction.y,
+    box.minimum.y,
+    box.maximum.y,
+    scratchRayIntervalY,
+  );
+  const tz = rayIntervalAlongAABBAxis(
+    ray.origin.z,
+    ray.direction.z,
+    box.minimum.z,
+    box.maximum.z,
+    scratchRayIntervalZ,
+  );
+
+  result.start = tx.start > ty.start ? tx.start : ty.start; //Get Greatest Min
+  result.stop = tx.stop < ty.stop ? tx.stop : ty.stop; //Get Smallest Max
+
+  if (tx.start > ty.stop || ty.start > tx.stop) {
+    return undefined;
+  }
+
+  if (result.start > tz.stop || tz.start > result.stop) {
+    return undefined;
+  }
+
+  if (tz.start > result.start) {
+    result.start = tz.start;
+  }
+  if (tz.stop < result.stop) {
+    result.stop = tz.stop;
+  }
+
+  return result;
+};
+
+function rayIntervalAlongAABBAxis(origin, direction, min, max, result) {
+  result.start = (min - origin) / direction;
+  result.stop = (max - origin) / direction;
+  if (result.stop < result.start) {
+    const tmp = result.stop;
+    result.stop = result.start;
+    result.start = tmp;
+  }
+
+  return result;
+}
+
 function addWithCancellationCheck(left, right, tolerance) {
   const difference = left + right;
   if (

packages/engine/Source/Core/QuantizedMeshTerrainData.js

@@ -349,6 +349,7 @@ QuantizedMeshTerrainData.prototype.createMesh = function (options) {
       vertexCountWithoutSkirts,
       minimumHeight,
       maximumHeight,
+      rectangle,
       boundingSphere,
       occludeePointInScaledSpace,
       stride,