Merge remote-tracking branch 'origin/main' into enh-1658_mesh-build-callbacks

Author: GhisBntly

CHANGES.md

@@ -1,6 +1,25 @@
 # Change Log {#changes}
 
-### ? - ?
+### ???
+
+##### Fixes :wrench:
+
+- Added a missing `CesiumRuntime.h` include in `CesiumPropertyAttribute.cpp` that broke compilation in v2.18.0 on Windows.
+
+### v2.18.0 - 2025-08-01
+
+##### Breaking Changes :mega:
+
+- Removed support for Unreal Engine 5.3. Unreal Engine 5.4 or later is now required.
+- `FCesiumPrimitiveMetadata::GetPropertyAttributeIndices` is now deprecated. Use `GetPropertyAttributes` to directly get the `FCesiumPropertyAttribute`s instead.
+
+##### 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`.
+- Added `UCesiumPropertyTexturePropertyBlueprintLibrary::GetInteger64`. Although 64-bit integers aren't directly supported by property textures, this enables the lossless retrieval of 32-bit unsigned integers.
 
 ##### Additions :tada:
 
@@ -9,7 +28,10 @@
 ##### Fixes :wrench:
 
 - Fixed error messages in the Unreal log about uninitialized fields in `FCesiumGeocoderServiceAttribution` and `FCesiumGeocoderServiceFeature`.
-- Fixed a bug where `CesiumEllipsoidFunctions` was inaccessible outside of the plugin. 
+- Fixed a bug where `CesiumEllipsoidFunctions` was inaccessible outside of the plugin.
+- Fixed an issue where `UCesiumGlobeAnchorComponent::SetEastSouthUpRotation()` would throw an exception if no `ACesiumGeoreference` was found in the level. 
+
+In addition to the above, this release updates [cesium-native](https://github.com/CesiumGS/cesium-native) from v0.49.0 to v0.50.0. See the [changelog](https://github.com/CesiumGS/cesium-native/blob/main/CHANGES.md) for a complete list of changes in cesium-native.
 
 ### v2.17.0 - 2025-07-01
 

CesiumForUnreal.uplugin

@@ -1,7 +1,7 @@
 {
 	"FileVersion": 3,
-	"Version": 77,
-	"VersionName": "2.17.0",
+	"Version": 78,
+	"VersionName": "2.18.0",
 	"FriendlyName": "Cesium for Unreal",
 	"Description": "Unlock the 3D geospatial ecosystem in Unreal Engine with real-world 3D content and a high accuracy full-scale WGS84 globe.",
 	"Category": "Geospatial",

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/CesiumGlobeAnchorComponent.cpp

@@ -411,15 +411,18 @@ void UCesiumGlobeAnchorComponent::SetEastSouthUpRotation(
           VecMath::createQuaternion(EastSouthUpRotation),
           scale);
 
-  const CesiumGeospatial::Ellipsoid& ellipsoid =
-      this->ResolveGeoreference()->GetEllipsoid()->GetNativeEllipsoid();
-
-  anchor.setAnchorToLocalTransform(
-      eastSouthUp,
-      newModelToEastSouthUp,
-      false,
-      ellipsoid);
-  this->_updateFromNativeGlobeAnchor(anchor);
+  const ACesiumGeoreference* pGeoreference = this->ResolveGeoreference();
+  if (pGeoreference) {
+    const CesiumGeospatial::Ellipsoid& ellipsoid =
+        pGeoreference->GetEllipsoid()->GetNativeEllipsoid();
+
+    anchor.setAnchorToLocalTransform(
+        eastSouthUp,
+        newModelToEastSouthUp,
+        false,
+        ellipsoid);
+    this->_updateFromNativeGlobeAnchor(anchor);
+  }
 }
 
 FQuat UCesiumGlobeAnchorComponent::GetEarthCenteredEarthFixedRotation() const {

Source/CesiumRuntime/Private/CesiumGltfComponent.cpp

@@ -1095,7 +1095,7 @@ static void loadPrimitiveFeaturesMetadata(
       pFeatures ? FCesiumPrimitiveFeatures(model, primitive, *pFeatures)
                 : FCesiumPrimitiveFeatures();
   primitiveResult.Metadata =
-      pMetadata ? FCesiumPrimitiveMetadata(primitive, *pMetadata)
+      pMetadata ? FCesiumPrimitiveMetadata(model, primitive, *pMetadata)
                 : FCesiumPrimitiveMetadata();
 
   PRAGMA_DISABLE_DEPRECATION_WARNINGS

Source/CesiumRuntime/Private/CesiumPrimitiveMetadata.cpp

@@ -1,26 +1,51 @@
 // Copyright 2020-2024 CesiumGS, Inc. and Contributors
 
 #include "CesiumPrimitiveMetadata.h"
-#include "CesiumGltf/AccessorView.h"
-#include "CesiumGltf/ExtensionMeshPrimitiveExtStructuralMetadata.h"
-#include "CesiumGltf/Model.h"
 #include "CesiumGltfPrimitiveComponent.h"
+#include "CesiumPropertyAttribute.h"
+
+#include <CesiumGltf/ExtensionMeshPrimitiveExtStructuralMetadata.h>
+#include <CesiumGltf/ExtensionModelExtStructuralMetadata.h>
+#include <CesiumGltf/Model.h>
 
 static FCesiumPrimitiveMetadata EmptyPrimitiveMetadata;
 
 FCesiumPrimitiveMetadata::FCesiumPrimitiveMetadata(
-    const CesiumGltf::MeshPrimitive& Primitive,
-    const CesiumGltf::ExtensionMeshPrimitiveExtStructuralMetadata& Metadata)
-    : _propertyTextureIndices(), _propertyAttributeIndices() {
-  this->_propertyTextureIndices.Reserve(Metadata.propertyTextures.size());
-  for (const int64 propertyTextureIndex : Metadata.propertyTextures) {
+    const CesiumGltf::Model& model,
+    const CesiumGltf::MeshPrimitive& primitive,
+    const CesiumGltf::ExtensionMeshPrimitiveExtStructuralMetadata& metadata)
+    : _propertyTextureIndices(),
+      _propertyAttributes(),
+      _propertyAttributeIndices() {
+  this->_propertyTextureIndices.Reserve(metadata.propertyTextures.size());
+  for (const int64 propertyTextureIndex : metadata.propertyTextures) {
     this->_propertyTextureIndices.Emplace(propertyTextureIndex);
   }
 
-  this->_propertyAttributeIndices.Reserve(Metadata.propertyAttributes.size());
-  for (const int64 propertyAttributeIndex : Metadata.propertyAttributes) {
+  // For backwards compatibility with GetPropertyAttributeIndices().
+  this->_propertyAttributeIndices.Reserve(metadata.propertyAttributes.size());
+  for (const int64 propertyAttributeIndex : metadata.propertyAttributes) {
     this->_propertyAttributeIndices.Emplace(propertyAttributeIndex);
   }
+
+  const auto* pModelMetadata =
+      model.getExtension<CesiumGltf::ExtensionModelExtStructuralMetadata>();
+  if (!pModelMetadata) {
+    return;
+  }
+
+  for (const int64 propertyAttributeIndex : metadata.propertyAttributes) {
+    if (propertyAttributeIndex < 0 ||
+        propertyAttributeIndex >=
+            int64_t(pModelMetadata->propertyAttributes.size())) {
+      continue;
+    }
+
+    this->_propertyAttributes.Emplace(FCesiumPropertyAttribute(
+        model,
+        primitive,
+        pModelMetadata->propertyAttributes[propertyAttributeIndex]));
+  }
 }
 
 const FCesiumPrimitiveMetadata&
@@ -41,6 +66,12 @@ UCesiumPrimitiveMetadataBlueprintLibrary::GetPropertyTextureIndices(
   return PrimitiveMetadata._propertyTextureIndices;
 }
 
+const TArray<FCesiumPropertyAttribute>&
+UCesiumPrimitiveMetadataBlueprintLibrary::GetPropertyAttributes(
+    UPARAM(ref) const FCesiumPrimitiveMetadata& PrimitiveMetadata) {
+  return PrimitiveMetadata._propertyAttributes;
+}
+
 const TArray<int64>&
 UCesiumPrimitiveMetadataBlueprintLibrary::GetPropertyAttributeIndices(
     UPARAM(ref) const FCesiumPrimitiveMetadata& PrimitiveMetadata) {