Implement CesiumRasterOverlays::VectorDocumentRasterOverlay in Unreal

CHANGES.md

@@ -9,6 +9,7 @@
 
 ##### Additions :tada:
 
+- Added `CesiumGeoJsonDocumentRasterOverlay`, allowing stylized GeoJSON to be rasterized and draped over terrain and other 3D Tiles.
 - Added `FCesiumPropertyAttributeProperty` to represent glTF property attribute properties and `UCesiumPropertyAttributePropertyBlueprintLibrary` to retrieve their values.
 - Added `FCesiumPropertyAttribute` to represent glTF property attributes and `UCesiumPropertyAttributeBlueprintLibrary` to act upon them with Blueprints.
 - Added `UCesiumPrimitiveMetadataBlueprintLibrary::GetPropertyAttributes` to retrieve the property attributes from a `FCesiumPrimitiveMetadata`.

Source/CesiumRuntime/Private/CesiumGeoJsonDocument.cpp

@@ -13,6 +13,15 @@ FCesiumGeoJsonDocument::FCesiumGeoJsonDocument(
     std::shared_ptr<CesiumVectorData::GeoJsonDocument>&& document)
     : _pDocument(std::move(document)) {}
 
+bool FCesiumGeoJsonDocument::IsValid() const {
+  return this->_pDocument != nullptr;
+}
+
+const std::shared_ptr<CesiumVectorData::GeoJsonDocument>&
+FCesiumGeoJsonDocument::GetDocument() const {
+  return this->_pDocument;
+}
+
 bool UCesiumGeoJsonDocumentBlueprintLibrary::LoadGeoJsonFromString(
     const FString& InString,
     FCesiumGeoJsonDocument& OutGeoJsonDocument) {

Source/CesiumRuntime/Private/CesiumGeoJsonDocumentRasterOverlay.cpp

@@ -0,0 +1,111 @@
+// Copyright 2020-2024 CesiumGS, Inc. and Contributors
+
+#include "CesiumGeoJsonDocumentRasterOverlay.h"
+
+#include "CesiumCustomVersion.h"
+#include "CesiumGeometry/QuadtreeTilingScheme.h"
+#include "CesiumGeospatial/GlobeRectangle.h"
+#include "CesiumGeospatial/Projection.h"
+#include "CesiumRasterOverlays/GeoJsonDocumentRasterOverlay.h"
+#include "CesiumVectorData/VectorStyle.h"
+
+#include "CesiumRuntime.h"
+
+namespace {
+CesiumAsync::Future<std::shared_ptr<CesiumVectorData::GeoJsonDocument>>
+wrapLoaderFuture(
+    UCesiumGeoJsonDocumentRasterOverlay* pThis,
+    CesiumAsync::Future<
+        CesiumUtility::Result<CesiumVectorData::GeoJsonDocument>>&& future) {
+  return std::move(future).thenInMainThread(
+      [pThis](CesiumUtility::Result<CesiumVectorData::GeoJsonDocument>&&
+                  documentResult)
+          -> std::shared_ptr<CesiumVectorData::GeoJsonDocument> {
+        if (documentResult.errors) {
+          documentResult.errors.logError(
+              spdlog::default_logger(),
+              "Errors loading GeoJSON document: ");
+          return nullptr;
+        }
+
+        std::shared_ptr<CesiumVectorData::GeoJsonDocument> pGeoJsonDocument =
+            std::make_shared<CesiumVectorData::GeoJsonDocument>(
+                std::move(*documentResult.value));
+
+        if (pThis->OnDocumentLoaded.IsBound()) {
+          pThis->OnDocumentLoaded.Execute(FCesiumGeoJsonDocument(
+              std::shared_ptr<CesiumVectorData::GeoJsonDocument>(
+                  pGeoJsonDocument)));
+        }
+
+        return pGeoJsonDocument;
+      });
+}
+} // namespace
+
+std::unique_ptr<CesiumRasterOverlays::RasterOverlay>
+UCesiumGeoJsonDocumentRasterOverlay::CreateOverlay(
+    const CesiumRasterOverlays::RasterOverlayOptions& options) {
+  if (this->Source == ECesiumGeoJsonDocumentRasterOverlaySource::FromDocument &&
+      !this->GeoJsonDocument.IsValid()) {
+    // Don't create an overlay with an invalid document.
+    return nullptr;
+  }
+
+  CesiumRasterOverlays::GeoJsonDocumentRasterOverlayOptions vectorOptions{
+      this->DefaultStyle.toNative(),
+      options.ellipsoid,
+      this->MipLevels};
+
+  if (this->Source ==
+      ECesiumGeoJsonDocumentRasterOverlaySource::FromCesiumIon) {
+    if (!IsValid(this->CesiumIonServer)) {
+      this->CesiumIonServer = UCesiumIonServer::GetServerForNewObjects();
+    }
+
+    return std::make_unique<CesiumRasterOverlays::GeoJsonDocumentRasterOverlay>(
+        TCHAR_TO_UTF8(*this->MaterialLayerKey),
+        wrapLoaderFuture(
+            this,
+            CesiumVectorData::GeoJsonDocument::fromCesiumIonAsset(
+                getAsyncSystem(),
+                getAssetAccessor(),
+                this->IonAssetID,
+                TCHAR_TO_UTF8(*this->CesiumIonServer->DefaultIonAccessToken),
+                std::string(TCHAR_TO_UTF8(*this->CesiumIonServer->ApiUrl)) +
+                    "/")),
+        vectorOptions,
+        options);
+  } else if (
+      this->Source == ECesiumGeoJsonDocumentRasterOverlaySource::FromUrl) {
+    std::vector<CesiumAsync::IAssetAccessor::THeader> headers;
+    headers.reserve(this->RequestHeaders.Num());
+
+    for (auto& [k, v] : this->RequestHeaders) {
+      headers.push_back({TCHAR_TO_UTF8(*k), TCHAR_TO_UTF8(*v)});
+    }
+
+    return std::make_unique<CesiumRasterOverlays::GeoJsonDocumentRasterOverlay>(
+        TCHAR_TO_UTF8(*this->MaterialLayerKey),
+        wrapLoaderFuture(
+            this,
+            CesiumVectorData::GeoJsonDocument::fromUrl(
+                getAsyncSystem(),
+                getAssetAccessor(),
+                TCHAR_TO_UTF8(*this->Url),
+                std::move(headers))),
+        vectorOptions,
+        options);
+  }
+
+  if (this->OnDocumentLoaded.IsBound()) {
+    this->OnDocumentLoaded.Execute(this->GeoJsonDocument);
+  }
+
+  return std::make_unique<CesiumRasterOverlays::GeoJsonDocumentRasterOverlay>(
+      getAsyncSystem(),
+      TCHAR_TO_UTF8(*this->MaterialLayerKey),
+      this->GeoJsonDocument.GetDocument(),
+      vectorOptions,
+      options);
+}

Source/CesiumRuntime/Private/CesiumGeoJsonObject.cpp

@@ -451,6 +451,41 @@ UCesiumGeoJsonObjectBlueprintLibrary::GetObjectAsFeatureCollection(
   return Features;
 }
 
+FCesiumVectorStyle UCesiumGeoJsonObjectBlueprintLibrary::GetStyle(
+    const FCesiumGeoJsonObject& InObject,
+    EHasValue& Branches) {
+  if (!InObject._pDocument || !InObject._pObject) {
+    Branches = EHasValue::NoValue;
+    return FCesiumVectorStyle();
+  }
+
+  const std::optional<CesiumVectorData::VectorStyle> style =
+      InObject._pObject->getStyle();
+  Branches = style ? EHasValue::HasValue : EHasValue::NoValue;
+  return style ? FCesiumVectorStyle::fromNative(*style) : FCesiumVectorStyle();
+}
+
+void UCesiumGeoJsonObjectBlueprintLibrary::SetStyle(
+    UPARAM(Ref) FCesiumGeoJsonObject& InObject,
+    const FCesiumVectorStyle& InStyle) {
+  if (!InObject._pDocument || !InObject._pObject) {
+    return;
+  }
+
+  const_cast<CesiumVectorData::GeoJsonObject*>(InObject._pObject)->getStyle() =
+      InStyle.toNative();
+}
+
+void UCesiumGeoJsonObjectBlueprintLibrary::ClearStyle(
+    UPARAM(Ref) FCesiumGeoJsonObject& InObject) {
+  if (!InObject._pDocument || !InObject._pObject) {
+    return;
+  }
+
+  const_cast<CesiumVectorData::GeoJsonObject*>(InObject._pObject)->getStyle() =
+      std::nullopt;
+}
+
 FCesiumGeoJsonLineString::FCesiumGeoJsonLineString(TArray<FVector>&& InPoints)
     : Points(MoveTemp(InPoints)) {}
 

Source/CesiumRuntime/Private/CesiumVectorStyle.cpp

@@ -0,0 +1,97 @@
+#include "CesiumVectorStyle.h"
+
+#include "CesiumUtility/Color.h"
+
+namespace {
+CesiumVectorData::LineStyle
+lineStyleToNative(const FCesiumVectorLineStyle& InLineStyle) {
+  return CesiumVectorData::LineStyle{
+      {CesiumUtility::Color{
+           InLineStyle.Color.R,
+           InLineStyle.Color.G,
+           InLineStyle.Color.B,
+           InLineStyle.Color.A},
+       (CesiumVectorData::ColorMode)InLineStyle.ColorMode},
+      InLineStyle.Width,
+      (CesiumVectorData::LineWidthMode)InLineStyle.WidthMode};
+}
+} // namespace
+
+CesiumVectorData::VectorStyle FCesiumVectorStyle::toNative() const {
+  // Assert that enums are equivalent to catch any issues.
+  static_assert(
+      (uint8)CesiumVectorData::ColorMode::Normal ==
+      (uint8)ECesiumVectorColorMode::Normal);
+  static_assert(
+      (uint8)CesiumVectorData::ColorMode::Random ==
+      (uint8)ECesiumVectorColorMode::Random);
+  static_assert(
+      (uint8)CesiumVectorData::LineWidthMode::Meters ==
+      (uint8)ECesiumVectorLineWidthMode::Meters);
+  static_assert(
+      (uint8)CesiumVectorData::LineWidthMode::Pixels ==
+      (uint8)ECesiumVectorLineWidthMode::Pixels);
+
+  std::optional<CesiumVectorData::ColorStyle> fillStyle;
+  if (this->PolygonStyle.Fill) {
+    fillStyle = CesiumVectorData::ColorStyle{
+        CesiumUtility::Color{
+            this->PolygonStyle.FillStyle.Color.R,
+            this->PolygonStyle.FillStyle.Color.G,
+            this->PolygonStyle.FillStyle.Color.B,
+            this->PolygonStyle.FillStyle.Color.A},
+        (CesiumVectorData::ColorMode)this->LineStyle.ColorMode};
+  }
+
+  return CesiumVectorData::VectorStyle{
+      lineStyleToNative(this->LineStyle),
+      CesiumVectorData::PolygonStyle{
+          fillStyle,
+          this->PolygonStyle.Outline
+              ? std::optional<CesiumVectorData::LineStyle>(
+                    lineStyleToNative(this->PolygonStyle.OutlineStyle))
+              : std::nullopt}};
+}
+
+FCesiumVectorStyle
+FCesiumVectorStyle::fromNative(const CesiumVectorData::VectorStyle& style) {
+  FCesiumVectorLineStyle OutlineStyle;
+  if (style.polygon.outline) {
+    OutlineStyle = FCesiumVectorLineStyle{
+        FColor(
+            (uint8)style.polygon.outline->color.r,
+            (uint8)style.polygon.outline->color.g,
+            (uint8)style.polygon.outline->color.b,
+            (uint8)style.polygon.outline->color.a),
+        (ECesiumVectorColorMode)style.polygon.outline->colorMode,
+        style.polygon.outline->width,
+        (ECesiumVectorLineWidthMode)style.polygon.outline->widthMode};
+  }
+
+  FCesiumVectorPolygonFillStyle FillStyle;
+  if (style.polygon.fill) {
+    FillStyle = FCesiumVectorPolygonFillStyle{
+        FColor(
+            (uint8)style.polygon.fill->color.r,
+            (uint8)style.polygon.fill->color.g,
+            (uint8)style.polygon.fill->color.b,
+            (uint8)style.polygon.fill->color.a),
+        (ECesiumVectorColorMode)style.polygon.fill->colorMode};
+  }
+
+  return FCesiumVectorStyle{
+      FCesiumVectorLineStyle{
+          FColor(
+              (uint8)style.line.color.r,
+              (uint8)style.line.color.g,
+              (uint8)style.line.color.b,
+              (uint8)style.line.color.a),
+          (ECesiumVectorColorMode)style.line.colorMode,
+          style.line.width,
+          (ECesiumVectorLineWidthMode)style.line.widthMode},
+      FCesiumVectorPolygonStyle{
+          style.polygon.fill.has_value(),
+          FillStyle,
+          style.polygon.outline.has_value(),
+          OutlineStyle}};
+}

Source/CesiumRuntime/Public/CesiumGeoJsonDocument.h

@@ -34,6 +34,17 @@ struct FCesiumGeoJsonDocument {
   FCesiumGeoJsonDocument(
       std::shared_ptr<CesiumVectorData::GeoJsonDocument>&& document);
 
+  /**
+   * @brief Checks if this FCesiumGeoJsonDocument is valid (document is not
+   * nullptr).
+   */
+  bool IsValid() const;
+
+  /**
+   * @brief Returns the `CesiumVectorData::GeoJsonDocument` this wraps.
+   */
+  const std::shared_ptr<CesiumVectorData::GeoJsonDocument>& GetDocument() const;
+
 private:
   std::shared_ptr<CesiumVectorData::GeoJsonDocument> _pDocument;