Add height-query function to Tileset

Cesium3DTilesSelection/include/Cesium3DTilesSelection/Tileset.h

@@ -15,14 +15,17 @@
 
 #include <rapidjson/fwd.h>
 
+#include <list>
 #include <memory>
 #include <optional>
+#include <set>
 #include <string>
 #include <vector>
 
 namespace Cesium3DTilesSelection {
 class TilesetContentManager;
 class TilesetMetadata;
+class TerrainQuery;
 
 /**
  * @brief A <a
@@ -270,6 +273,19 @@ class CESIUM3DTILESSELECTION_API Tileset final {
    */
   CesiumAsync::Future<const TilesetMetadata*> loadMetadata();
 
+  struct HeightResults {
+    struct CoordinateResult {
+      bool heightAvailable = false;
+      CesiumGeospatial::Cartographic coordinate = {-1, -1, -1};
+    };
+
+    std::vector<CoordinateResult> coordinateResults;
+    std::vector<std::string> warnings;
+  };
+
+  CesiumAsync::Future<HeightResults> getHeightsAtCoordinates(
+      const std::vector<CesiumGeospatial::Cartographic>& coordinates);
+
 private:
   /**
    * @brief The result of traversing one branch of the tile hierarchy.
@@ -423,6 +439,11 @@ class CESIUM3DTILESSELECTION_API Tileset final {
       double tilePriority,
       bool queuedForLoad);
 
+  struct HeightRequest {
+    std::vector<TerrainQuery> queries;
+    CesiumAsync::Promise<Tileset::HeightResults> promise;
+  };
+
   void _processWorkerThreadLoadQueue();
   void _processMainThreadLoadQueue();
 
@@ -509,11 +530,19 @@ class CESIUM3DTILESSELECTION_API Tileset final {
   CesiumUtility::IntrusivePointer<TilesetContentManager>
       _pTilesetContentManager;
 
+  std::list<HeightRequest> _heightRequests;
+
   void addTileToLoadQueue(
       Tile& tile,
       TileLoadPriorityGroup priorityGroup,
       double priority);
 
+  void visitHeightRequests();
+
+  bool tryCompleteHeightRequest(
+      HeightRequest& request,
+      std::set<Tile*>& tilesNeedingLoading);
+
   static TraversalDetails createTraversalDetailsForSingleTile(
       const FrameState& frameState,
       const Tile& tile,

Cesium3DTilesSelection/src/TerrainQuery.cpp

@@ -0,0 +1,138 @@
+#include "TerrainQuery.h"
+
+#include "TileUtilities.h"
+#include "TilesetContentManager.h"
+
+#include <CesiumGeometry/IntersectionTests.h>
+#include <CesiumGeospatial/GlobeRectangle.h>
+#include <CesiumGltfContent/GltfUtilities.h>
+
+using namespace Cesium3DTilesSelection;
+using namespace CesiumGeospatial;
+using namespace CesiumGeometry;
+using namespace CesiumUtility;
+using namespace CesiumAsync;
+
+namespace {
+bool boundingVolumeContainsCoordinate(
+    const BoundingVolume& boundingVolume,
+    const Ray& ray,
+    const Cartographic& coordinate) {
+  struct Operation {
+    const Ray& ray;
+    const Cartographic& coordinate;
+
+    bool operator()(const OrientedBoundingBox& boundingBox) noexcept {
+      std::optional<double> t =
+          IntersectionTests::rayOBBParametric(ray, boundingBox);
+      return t && t.value() >= 0;
+    }
+
+    bool operator()(const BoundingRegion& boundingRegion) noexcept {
+      return boundingRegion.getRectangle().contains(coordinate);
+    }
+
+    bool operator()(const BoundingSphere& boundingSphere) noexcept {
+      std::optional<double> t =
+          IntersectionTests::raySphereParametric(ray, boundingSphere);
+      return t && t.value() >= 0;
+    }
+
+    bool operator()(
+        const BoundingRegionWithLooseFittingHeights& boundingRegion) noexcept {
+      return boundingRegion.getBoundingRegion().getRectangle().contains(
+          coordinate);
+    }
+
+    bool operator()(const S2CellBoundingVolume& s2Cell) noexcept {
+      return s2Cell.computeBoundingRegion().getRectangle().contains(coordinate);
+    }
+  };
+
+  return std::visit(Operation{ray, coordinate}, boundingVolume);
+}
+
+} // namespace
+
+void TerrainQuery::intersectVisibleTile(Tile* pTile) {
+  TileRenderContent* pRenderContent = pTile->getContent().getRenderContent();
+  if (!pRenderContent)
+    return;
+
+  auto gltfIntersectResult =
+      CesiumGltfContent::GltfUtilities::intersectRayGltfModel(
+          this->ray,
+          pRenderContent->getModel(),
+          true,
+          pTile->getTransform());
+
+  if (!gltfIntersectResult.hit.has_value())
+    return;
+
+  // Set ray info to this hit if closer, or the first hit
+  if (!this->intersectResult.hit.has_value()) {
+    this->intersectResult = std::move(gltfIntersectResult);
+  } else {
+    double prevDistSq = this->intersectResult.hit->rayToWorldPointDistanceSq;
+    double thisDistSq = intersectResult.hit->rayToWorldPointDistanceSq;
+    if (thisDistSq < prevDistSq)
+      this->intersectResult = std::move(gltfIntersectResult);
+  }
+}
+
+void TerrainQuery::findCandidateTiles(
+    Tile* pTile,
+    std::vector<std::string>& warnings) {
+
+  // If tile failed to load, this means we can't complete the intersection
+  if (pTile->getState() == TileLoadState::Failed) {
+    warnings.push_back("Tile load failed during query. Ignoring.");
+    return;
+  }
+
+  auto& contentBoundingVolume = pTile->getContentBoundingVolume();
+
+  if (pTile->getChildren().empty()) {
+    // This is a leaf node, it's a candidate
+
+    // If optional content bounding volume exists, test against it
+    if (contentBoundingVolume) {
+      if (boundingVolumeContainsCoordinate(
+              *contentBoundingVolume,
+              this->ray,
+              this->inputCoordinate))
+        candidateTiles.push_back(pTile);
+    } else {
+      candidateTiles.push_back(pTile);
+    }
+  } else {
+    // We have children
+
+    // If additive refinement, add parent to the list with children
+    if (pTile->getRefine() == TileRefine::Add) {
+      // If optional content bounding volume exists, test against it
+      if (contentBoundingVolume) {
+        if (boundingVolumeContainsCoordinate(
+                *contentBoundingVolume,
+                this->ray,
+                this->inputCoordinate))
+          candidateTiles.push_back(pTile);
+      } else {
+        candidateTiles.push_back(pTile);
+      }
+    }
+
+    // Traverse children
+    for (Tile& child : pTile->getChildren()) {
+      // if bounding volume doesn't intersect this ray, we can skip it
+      if (!boundingVolumeContainsCoordinate(
+              child.getBoundingVolume(),
+              this->ray,
+              this->inputCoordinate))
+        continue;
+
+      // Child is a candidate, traverse it and its children
+      findCandidateTiles(&child, warnings);
+    }
+  }
+}

Cesium3DTilesSelection/src/TerrainQuery.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <Cesium3DTilesSelection/Tileset.h>
+#include <CesiumGeometry/Ray.h>
+#include <CesiumGeospatial/Cartographic.h>
+#include <CesiumGltfContent/GltfUtilities.h>
+
+#include <set>
+#include <vector>
+
+namespace Cesium3DTilesSelection {
+
+class TerrainQuery {
+public:
+  CesiumGeospatial::Cartographic inputCoordinate;
+  CesiumGeometry::Ray ray;
+  CesiumGltfContent::GltfUtilities::IntersectResult intersectResult = {};
+  std::vector<Tile*> candidateTiles = {};
+
+  void intersectVisibleTile(Tile* pTile);
+
+  void findCandidateTiles(Tile* pTile, std::vector<std::string>& warnings);
+};
+
+} // namespace Cesium3DTilesSelection