geoJSON tilesets with glTF translation

Cesium3DTilesSelection/CMakeLists.txt

@@ -52,6 +52,7 @@ target_link_libraries(Cesium3DTilesSelection
         CesiumQuantizedMeshTerrain
         CesiumRasterOverlays
         CesiumUtility
+        CesiumVectorData
         spdlog::spdlog
 # PRIVATE
         libmorton::libmorton

Cesium3DTilesSelection/include/Cesium3DTilesSelection/TilesetOptions.h

@@ -55,6 +55,12 @@ struct CESIUM3DTILESSELECTION_API TilesetContentOptions {
    * shader.
    */
   bool applyTextureTransform = true;
+
+  /**
+   * @brief Whether to translate vector feature data, e.g. GeoJSON content, to
+   * glTF, or leave it in its native format.
+   */
+  bool translateVectorFeatures = true;
 };
 
 /**

Cesium3DTilesSelection/src/EllipsoidTilesetLoader.cpp

@@ -63,6 +63,11 @@ EllipsoidTilesetLoader::EllipsoidTilesetLoader(const Ellipsoid& ellipsoid)
 
   pRootTile->setRefine(TileRefine::Replace);
   pRootTile->setUnconditionallyRefine();
+  pRootTile->setBoundingVolume(BoundingRegion(
+      pCustomLoader->_projection.MAXIMUM_GLOBE_RECTANGLE,
+      0.0,
+      0.0,
+      pCustomLoader->_projection.getEllipsoid()));
 
   std::vector<Tile> children;
   uint32_t rootTilesX = pCustomLoader->_tilingScheme.getRootTilesX();

Cesium3DTilesSelection/src/TilesetJsonLoader.cpp

@@ -41,6 +41,8 @@
 #include <CesiumUtility/ErrorList.h>
 #include <CesiumUtility/JsonHelpers.h>
 #include <CesiumUtility/Uri.h>
+#include <CesiumVectorData/GeoJsonDocument.h>
+#include <CesiumVectorData/GltfConverter.h>
 
 #include <fmt/format.h>
 #include <glm/common.hpp>
@@ -770,27 +772,11 @@ TileLoadResult parseExternalTilesetInWorkerThread(
     const std::shared_ptr<CesiumAsync::IAssetAccessor>& pAssetAccessor,
     std::shared_ptr<CesiumAsync::IAssetRequest>&& pCompletedRequest,
     ExternalContentInitializer&& externalContentInitializer,
-    const CesiumGeospatial::Ellipsoid& ellipsoid) {
+    const CesiumGeospatial::Ellipsoid& ellipsoid,
+    rapidjson::Document& tilesetJson) {
   // create external tileset
-  const CesiumAsync::IAssetResponse* pResponse = pCompletedRequest->response();
-  const auto& responseData = pResponse->data();
   const auto& tileUrl = pCompletedRequest->url();
 
-  rapidjson::Document tilesetJson;
-  tilesetJson.Parse(
-      reinterpret_cast<const char*>(responseData.data()),
-      responseData.size());
-  if (tilesetJson.HasParseError()) {
-    SPDLOG_LOGGER_ERROR(
-        pLogger,
-        "Error when parsing tileset JSON, error code {} at byte offset {}",
-        tilesetJson.GetParseError(),
-        tilesetJson.GetErrorOffset());
-    return TileLoadResult::createFailedResult(
-        pAssetAccessor,
-        std::move(pCompletedRequest));
-  }
-
   // Save the parsed external tileset into custom data.
   // We will propagate it back to tile later in the main
   // thread
@@ -841,6 +827,77 @@ TileLoadResult parseExternalTilesetInWorkerThread(
       ellipsoid};
 }
 
+TileLoadResult parseJsonContentInWorkerThread(
+    const glm::dmat4& tileTransform,
+    CesiumGeometry::Axis upAxis,
+    TileRefine tileRefine,
+    const std::shared_ptr<spdlog::logger>& pLogger,
+    const std::shared_ptr<CesiumAsync::IAssetAccessor>& pAssetAccessor,
+    std::shared_ptr<CesiumAsync::IAssetRequest>&& pCompletedRequest,
+    ExternalContentInitializer&& externalContentInitializer,
+    const CesiumGeospatial::Ellipsoid& ellipsoid,
+    bool translateToGltf) {
+  const CesiumAsync::IAssetResponse* pResponse = pCompletedRequest->response();
+  const auto& responseData = pResponse->data();
+
+  rapidjson::Document tilesetJson;
+  tilesetJson.Parse(
+      reinterpret_cast<const char*>(responseData.data()),
+      responseData.size());
+  if (tilesetJson.HasParseError()) {
+    SPDLOG_LOGGER_ERROR(
+        pLogger,
+        "Error when parsing tileset JSON, error code {} at byte offset {}",
+        tilesetJson.GetParseError(),
+        tilesetJson.GetErrorOffset());
+    return TileLoadResult::createFailedResult(
+        pAssetAccessor,
+        std::move(pCompletedRequest));
+  }
+  if (const auto typeIt = tilesetJson.FindMember("type");
+      typeIt != tilesetJson.MemberEnd()) {
+    auto geoJson = CesiumVectorData::GeoJsonDocument::fromGeoJson(tilesetJson);
+    if (!(geoJson.value.has_value() && !geoJson.errors.hasErrors() &&
+          translateToGltf)) {
+      return TileLoadResult::createFailedResult(
+          pAssetAccessor,
+          std::move(pCompletedRequest));
+    } else {
+
+      CesiumVectorData::ConverterResult converterResult =
+          CesiumVectorData::GltfConverter::convert(*geoJson.value);
+      if (converterResult.model.has_value() &&
+          !converterResult.errors.hasErrors()) {
+        return TileLoadResult{
+            std::move(*converterResult.model),
+            CesiumGeometry::Axis::Z,
+            std::nullopt,
+            std::nullopt,
+            std::nullopt,
+            pAssetAccessor,
+            std::move(pCompletedRequest),
+            {},
+            TileLoadResultState::Success,
+            ellipsoid};
+      } else {
+        return TileLoadResult::createFailedResult(
+            pAssetAccessor,
+            std::move(pCompletedRequest));
+      }
+    }
+  } else {
+    return parseExternalTilesetInWorkerThread(
+        tileTransform,
+        upAxis,
+        tileRefine,
+        pLogger,
+        pAssetAccessor,
+        std::move(pCompletedRequest),
+        std::move(externalContentInitializer),
+        ellipsoid,
+        tilesetJson);
+  }
+}
 } // namespace
 
 TilesetJsonLoader::TilesetJsonLoader(
@@ -1155,15 +1212,16 @@ TilesetJsonLoader::loadTileContent(const TileLoadInput& loadInput) {
             } else {
               // not a renderable content, then it must be external tileset
               return asyncSystem.createResolvedFuture(
-                  parseExternalTilesetInWorkerThread(
+                  parseJsonContentInWorkerThread(
                       tileTransform,
                       upAxis,
                       tileRefine,
                       pLogger,
                       pAssetAccessor,
                       std::move(pCompletedRequest),
                       std::move(externalContentInitializer),
-                      ellipsoid));
+                      ellipsoid,
+                      contentOptions.translateVectorFeatures));
             }
           });
 }

CesiumVectorData/CMakeLists.txt

@@ -55,7 +55,9 @@ target_link_libraries(CesiumVectorData
         CesiumGeospatial
         CesiumAsync
         CesiumGltf
+        CesiumGltfContent
     PRIVATE
         blend2d::blend2d
+        $<BUILD_INTERFACE:earcut>
         ${CESIUM_VECTOR_DATA_ASMJIT_DEPENDENCY}
 )

CesiumVectorData/include/CesiumVectorData/GltfConverter.h

@@ -0,0 +1,39 @@
+#pragma once
+
+#include <CesiumGltf/Model.h>
+#include <CesiumVectorData/GeoJsonDocument.h>
+
+namespace CesiumVectorData {
+
+/**
+ * @brief The result of converting a GeoJSON file to a glTF model.
+ */
+struct CESIUMVECTORDATA_API ConverterResult {
+  /**
+   * @brief The gltf model converted from GeoJSON. This is empty if
+   * there are errors during the conversion
+   */
+  std::optional<CesiumGltf::Model> model;
+
+  /**
+   * @brief The error and warning list when converting to a gltf
+   * model. This is empty if there are no errors during the conversion
+   */
+  CesiumUtility::ErrorList errors;
+};
+
+/**
+ * @brief Functional for converting GeoJSON documents to glTF.
+ */
+class CESIUMVECTORDATA_API GltfConverter {
+public:
+  /**
+   * @brief Convert geoJSON document to a result which includes a glTF Model
+   * object.
+   *
+   * @param geoJson The GeoJSON document.
+   * @returns A result object that includes the glTF Model and any errors.
+   */
+  static ConverterResult convert(const GeoJsonDocument& geoJson);
+};
+} // namespace CesiumVectorData