Add iTwin support to Cesium for Unreal

Source/CesiumRuntime/CesiumRuntime.Build.cs

@@ -91,7 +91,9 @@ public CesiumRuntime(ReadOnlyTargetRules Target) : base(Target)
                 "DeveloperSettings",
                 "UMG",
                 "Renderer",
-                "OpenSSL"
+                "OpenSSL",
+                "Json",
+                "JsonUtilities"
             }
         );
 

Source/CesiumRuntime/Private/Cesium3DTileset.cpp

@@ -4,7 +4,11 @@
 #include "Async/Async.h"
 #include "Camera/CameraTypes.h"
 #include "Camera/PlayerCameraManager.h"
+#include "Cesium3DTilesSelection/CesiumIonTilesetContentLoaderFactory.h"
 #include "Cesium3DTilesSelection/EllipsoidTilesetLoader.h"
+#include "Cesium3DTilesSelection/IModelMeshExportContentLoaderFactory.h"
+#include "Cesium3DTilesSelection/ITwinCesiumCuratedContentLoaderFactory.h"
+#include "Cesium3DTilesSelection/ITwinRealityDataContentLoaderFactory.h"
 #include "Cesium3DTilesSelection/Tile.h"
 #include "Cesium3DTilesSelection/TilesetLoadFailureDetails.h"
 #include "Cesium3DTilesSelection/TilesetOptions.h"
@@ -433,6 +437,54 @@ void ACesium3DTileset::SetIonAccessToken(const FString& InAccessToken) {
   }
 }
 
+void ACesium3DTileset::SetITwinCesiumContentID(int64 InContentID) {
+  if (InContentID >= 0 && InContentID != this->ITwinCesiumContentID) {
+    if (this->TilesetSource == ETilesetSource::FromITwinCesiumCuratedContent) {
+      this->DestroyTileset();
+    }
+    this->ITwinCesiumContentID = InContentID;
+  }
+}
+
+void ACesium3DTileset::SetIModelID(const FString& InModelID) {
+  if (InModelID != this->IModelID) {
+    if (this->TilesetSource == ETilesetSource::FromIModelMeshExportService) {
+      this->DestroyTileset();
+    }
+    this->IModelID = InModelID;
+  }
+}
+
+void ACesium3DTileset::SetRealityDataID(const FString& InRealityDataID) {
+  if (InRealityDataID != this->RealityDataID) {
+    if (this->TilesetSource == ETilesetSource::FromITwinRealityData) {
+      this->DestroyTileset();
+    }
+    this->RealityDataID = InRealityDataID;
+  }
+}
+
+void ACesium3DTileset::SetITwinID(const FString& InITwinID) {
+  if (InITwinID != this->ITwinID) {
+    if (this->TilesetSource == ETilesetSource::FromITwinRealityData) {
+      this->DestroyTileset();
+    }
+    this->ITwinID = InITwinID;
+  }
+}
+
+void ACesium3DTileset::SetITwinConnection(
+    UCesiumITwinConnection* InConnection) {
+  if (this->ITwinConnection != InConnection) {
+    if (this->TilesetSource == ETilesetSource::FromITwinCesiumCuratedContent ||
+        this->TilesetSource == ETilesetSource::FromIModelMeshExportService ||
+        this->TilesetSource == ETilesetSource::FromITwinRealityData) {
+      this->DestroyTileset();
+    }
+    this->ITwinConnection = InConnection;
+  }
+}
+
 void ACesium3DTileset::SetCesiumIonServer(UCesiumIonServer* Server) {
   if (this->CesiumIonServer != Server) {
     if (this->TilesetSource == ETilesetSource::FromCesiumIon) {
@@ -1107,30 +1159,106 @@ void ACesium3DTileset::LoadTileset() {
         Log,
         TEXT("Loading tileset for asset ID %d"),
         this->IonAssetID);
-    FString token = this->IonAccessToken.IsEmpty()
-                        ? this->CesiumIonServer->DefaultIonAccessToken
-                        : this->IonAccessToken;
+    {
+      FString token = this->IonAccessToken.IsEmpty()
+                          ? this->CesiumIonServer->DefaultIonAccessToken
+                          : this->IonAccessToken;
 
 #if WITH_EDITOR
-    this->CesiumIonServer->ResolveApiUrl();
+      this->CesiumIonServer->ResolveApiUrl();
 #endif
 
-    std::string ionAssetEndpointUrl =
-        TCHAR_TO_UTF8(*this->CesiumIonServer->ApiUrl);
+      std::string ionAssetEndpointUrl =
+          TCHAR_TO_UTF8(*this->CesiumIonServer->ApiUrl);
 
-    if (!ionAssetEndpointUrl.empty()) {
-      // Make sure the URL ends with a slash
-      if (!ionAssetEndpointUrl.empty() && *ionAssetEndpointUrl.rbegin() != '/')
-        ionAssetEndpointUrl += '/';
+      if (!ionAssetEndpointUrl.empty()) {
+        // Make sure the URL ends with a slash
+        if (!ionAssetEndpointUrl.empty() &&
+            *ionAssetEndpointUrl.rbegin() != '/')
+          ionAssetEndpointUrl += '/';
 
-      this->_pTileset = MakeUnique<Cesium3DTilesSelection::Tileset>(
-          externals,
-          static_cast<uint32_t>(this->IonAssetID),
-          TCHAR_TO_UTF8(*token),
-          options,
-          ionAssetEndpointUrl);
+        this->_pTileset = MakeUnique<Cesium3DTilesSelection::Tileset>(
+            externals,
+            static_cast<uint32_t>(this->IonAssetID),
+            TCHAR_TO_UTF8(*token),
+            options,
+            ionAssetEndpointUrl);
+      }
     }
     break;
+  case ETilesetSource::FromITwinCesiumCuratedContent:
+    UE_LOG(
+        LogCesium,
+        Log,
+        TEXT("Loading tileset for asset ID %d"),
+        this->ITwinCesiumContentID);
+
+    this->_pTileset = MakeUnique<Cesium3DTilesSelection::Tileset>(
+        externals,
+        Cesium3DTilesSelection::ITwinCesiumCuratedContentLoaderFactory(
+            static_cast<uint32_t>(this->ITwinCesiumContentID),
+            this->ITwinConnection->GetConnection()->getAuthToken().getToken()),
+        options);
+    break;
+  case ETilesetSource::FromIModelMeshExportService:
+    UE_LOG(
+        LogCesium,
+        Log,
+        TEXT("Loading mesh export for iModel ID %s"),
+        *this->IModelID);
+
+    this->_pTileset = MakeUnique<Cesium3DTilesSelection::Tileset>(
+        externals,
+        Cesium3DTilesSelection::IModelMeshExportContentLoaderFactory(
+            TCHAR_TO_UTF8(*this->IModelID),
+            std::nullopt,
+            this->ITwinConnection->GetConnection()->getAuthToken().getToken()),
+        options);
+    break;
+  case ETilesetSource::FromITwinRealityData:
+    UE_LOG(
+        LogCesium,
+        Log,
+        TEXT("Loading reality data ID %s"),
+        *this->RealityDataID);
+
+    this->_pTileset = MakeUnique<Cesium3DTilesSelection::Tileset>(
+        externals,
+        Cesium3DTilesSelection::ITwinRealityDataContentLoaderFactory(
+            TCHAR_TO_UTF8(*this->RealityDataID),
+            this->ITwinID.IsEmpty() ? std::nullopt
+                                    : std::make_optional<std::string>(
+                                          TCHAR_TO_UTF8(*this->ITwinID)),
+            this->ITwinConnection->GetConnection()->getAuthToken().getToken(),
+            [asyncSystem, pConnection = this->ITwinConnection->GetConnection()](
+                const std::string&) {
+              if (!pConnection->getRefreshToken()) {
+                return asyncSystem.createResolvedFuture<
+                    CesiumUtility::
+                        Result<std::string>>(CesiumUtility::ErrorList::error(
+                    "Access token for reality data is expired, no refresh token available."));
+              }
+
+              return pConnection->me().thenImmediately(
+                  [pConnection](
+                      CesiumUtility::Result<CesiumITwinClient::UserProfile>&&
+                          result) -> CesiumUtility::Result<std::string> {
+                    if (!result.value) {
+                      return CesiumUtility::Result<std::string>(result.errors);
+                    }
+
+                    if (!pConnection->getAuthToken().isValid()) {
+                      return CesiumUtility::Result<
+                          std::string>(CesiumUtility::ErrorList::error(
+                          "Tried to refresh access token for reality data, but was not able to obtain valid token."));
+                    }
+
+                    return CesiumUtility::Result<std::string>(
+                        pConnection->getAuthToken().getToken());
+                  });
+            }),
+        options);
+    break;
   }
 
 #ifdef CESIUM_DEBUG_TILE_STATES
@@ -1180,6 +1308,27 @@ void ACesium3DTileset::LoadTileset() {
         TEXT("Loading tileset for asset ID %d done"),
         this->IonAssetID);
     break;
+  case ETilesetSource::FromITwinCesiumCuratedContent:
+    UE_LOG(
+        LogCesium,
+        Log,
+        TEXT("Loading tileset for asset ID %d done"),
+        this->ITwinCesiumContentID);
+    break;
+  case ETilesetSource::FromIModelMeshExportService:
+    UE_LOG(
+        LogCesium,
+        Log,
+        TEXT("Loading mesh export for iModel ID %s done"),
+        *this->IModelID);
+    break;
+  case ETilesetSource::FromITwinRealityData:
+    UE_LOG(
+        LogCesium,
+        Log,
+        TEXT("Loading reality data ID %s done"),
+        *this->RealityDataID);
+    break;
   }
 
   switch (ApplyDpiScaling) {
@@ -1221,6 +1370,27 @@ void ACesium3DTileset::DestroyTileset() {
         TEXT("Destroying tileset for asset ID %d"),
         this->IonAssetID);
     break;
+  case ETilesetSource::FromITwinCesiumCuratedContent:
+    UE_LOG(
+        LogCesium,
+        Verbose,
+        TEXT("Destroying tileset for asset ID %d"),
+        this->ITwinCesiumContentID);
+    break;
+  case ETilesetSource::FromIModelMeshExportService:
+    UE_LOG(
+        LogCesium,
+        Log,
+        TEXT("Destroying tileset for iModel ID %s"),
+        *this->IModelID);
+    break;
+  case ETilesetSource::FromITwinRealityData:
+    UE_LOG(
+        LogCesium,
+        Log,
+        TEXT("Destroying tileset for reality data ID %s done"),
+        *this->RealityDataID);
+    break;
   }
 
   // The way CesiumRasterOverlay::add is currently implemented, destroying the
@@ -1279,6 +1449,27 @@ void ACesium3DTileset::DestroyTileset() {
         TEXT("Destroying tileset for asset ID %d done"),
         this->IonAssetID);
     break;
+  case ETilesetSource::FromITwinCesiumCuratedContent:
+    UE_LOG(
+        LogCesium,
+        Verbose,
+        TEXT("Destroying tileset for asset ID %d done"),
+        this->ITwinCesiumContentID);
+    break;
+  case ETilesetSource::FromIModelMeshExportService:
+    UE_LOG(
+        LogCesium,
+        Log,
+        TEXT("Destroying tileset for iModel ID %s done"),
+        *this->IModelID);
+    break;
+  case ETilesetSource::FromITwinRealityData:
+    UE_LOG(
+        LogCesium,
+        Log,
+        TEXT("Destroying tileset for reality data ID %s done"),
+        *this->RealityDataID);
+    break;
   }
 }
 
@@ -2175,6 +2366,12 @@ void ACesium3DTileset::PostEditChangeProperty(
       PropName == GET_MEMBER_NAME_CHECKED(ACesium3DTileset, Url) ||
       PropName == GET_MEMBER_NAME_CHECKED(ACesium3DTileset, IonAssetID) ||
       PropName == GET_MEMBER_NAME_CHECKED(ACesium3DTileset, IonAccessToken) ||
+      PropName ==
+          GET_MEMBER_NAME_CHECKED(ACesium3DTileset, ITwinCesiumContentID) ||
+      PropName == GET_MEMBER_NAME_CHECKED(ACesium3DTileset, IModelID) ||
+      PropName == GET_MEMBER_NAME_CHECKED(ACesium3DTileset, RealityDataID) ||
+      PropName == GET_MEMBER_NAME_CHECKED(ACesium3DTileset, ITwinID) ||
+      PropName == GET_MEMBER_NAME_CHECKED(ACesium3DTileset, ITwinConnection) ||
       PropName ==
           GET_MEMBER_NAME_CHECKED(ACesium3DTileset, CreatePhysicsMeshes) ||
       PropName ==

Source/CesiumRuntime/Private/CesiumCartographicPolygon.cpp

@@ -48,7 +48,7 @@ ACesiumCartographicPolygon::CreateCartographicPolygon(
   int32 splinePointsCount = this->Polygon->GetNumberOfSplinePoints();
 
   if (splinePointsCount < 3) {
-    return CartographicPolygon({});
+    return CartographicPolygon(std::vector<glm::dvec2>{});
   }
 
   std::vector<glm::dvec2> polygon(splinePointsCount);

Source/CesiumRuntime/Private/CesiumGeoJsonDocument.cpp

@@ -0,0 +1,92 @@
+#include "CesiumGeoJsonDocument.h"
+#include "CesiumRuntime.h"
+
+#include "CesiumUtility/Result.h"
+
+#include <span>
+
+bool UCesiumGeoJsonDocumentBlueprintLibrary::LoadGeoJsonFromString(
+    const FString& InString,
+    FCesiumGeoJsonDocument& OutVectorDocument) {
+  const std::string str = TCHAR_TO_UTF8(*InString);
+  std::span<const std::byte> bytes(
+      reinterpret_cast<const std::byte*>(str.data()),
+      str.size());
+  CesiumUtility::Result<
+      CesiumUtility::IntrusivePointer<CesiumVectorData::GeoJsonDocument>>
+      documentResult = CesiumVectorData::GeoJsonDocument::fromGeoJson(bytes);
+
+  if (!documentResult.errors.errors.empty()) {
+    documentResult.errors.logError(
+        spdlog::default_logger(),
+        "Errors while loading GeoJSON from string");
+  }
+
+  if (!documentResult.errors.warnings.empty()) {
+    documentResult.errors.logWarning(
+        spdlog::default_logger(),
+        "Warnings while loading GeoJSON from string");
+  }
+
+  if (documentResult.pValue) {
+    OutVectorDocument =
+        FCesiumGeoJsonDocument(std::move(documentResult.pValue));
+    return true;
+  }
+
+  return false;
+}
+
+FCesiumGeoJsonObject UCesiumGeoJsonDocumentBlueprintLibrary::GetRootObject(
+    const FCesiumGeoJsonDocument& InVectorDocument) {
+  if (!InVectorDocument._document) {
+    return FCesiumGeoJsonObject();
+  }
+
+  return FCesiumGeoJsonObject(
+      InVectorDocument._document,
+      &InVectorDocument._document->getRootObject());
+}
+
+UCesiumLoadVectorDocumentFromIonAsyncAction*
+UCesiumLoadVectorDocumentFromIonAsyncAction::LoadFromIon(
+    int64 AssetId,
+    const FString& IonAccessToken,
+    const FString& IonAssetEndpointUrl) {
+  UCesiumLoadVectorDocumentFromIonAsyncAction* pAction =
+      NewObject<UCesiumLoadVectorDocumentFromIonAsyncAction>();
+  pAction->AssetId = AssetId;
+  pAction->IonAccessToken = IonAccessToken;
+  pAction->IonAssetEndpointUrl = IonAssetEndpointUrl;
+  return pAction;
+}
+
+void UCesiumLoadVectorDocumentFromIonAsyncAction::Activate() {
+  CesiumVectorData::GeoJsonDocument::fromCesiumIonAsset(
+      getAsyncSystem(),
+      getAssetAccessor(),
+      this->AssetId,
+      TCHAR_TO_UTF8(*this->IonAccessToken),
+      TCHAR_TO_UTF8(*this->IonAssetEndpointUrl))
+      .thenInMainThread(
+          [Callback = this->OnLoadResult](
+              CesiumUtility::Result<CesiumUtility::IntrusivePointer<
+                  CesiumVectorData::GeoJsonDocument>>&& result) {
+            if (result.errors.hasErrors()) {
+              result.errors.logError(
+                  spdlog::default_logger(),
+                  "Errors loading GeoJSON:");
+              result.errors.logWarning(
+                  spdlog::default_logger(),
+                  "Warnings loading GeoJSON:");
+            }
+
+            if (result.pValue) {
+              Callback.Broadcast(
+                  true,
+                  FCesiumGeoJsonDocument(MoveTemp(result.pValue)));
+            } else {
+              Callback.Broadcast(false, {});
+            }
+          });
+}