Support for vector styling callback

Author: azrogers

Source/CesiumRuntime/Private/CesiumVectorDocumentRasterOverlay.cpp

@@ -11,6 +11,31 @@
 
 #include "CesiumRuntime.h"
 
+namespace {
+CesiumVectorData::VectorStyle
+unrealToNativeVectorStyle(const FCesiumVectorStyle& style) {
+  return CesiumVectorData::VectorStyle{
+      CesiumVectorData::LineStyle{
+          CesiumVectorData::Color{
+              style.LineStyle.Color.R,
+              style.LineStyle.Color.G,
+              style.LineStyle.Color.B,
+              style.LineStyle.Color.A},
+          (CesiumVectorData::ColorMode)style.LineStyle.ColorMode,
+          style.LineStyle.Width,
+          (CesiumVectorData::LineWidthMode)style.LineStyle.WidthMode},
+      CesiumVectorData::PolygonStyle{
+          CesiumVectorData::Color{
+              style.PolygonStyle.Color.R,
+              style.PolygonStyle.Color.G,
+              style.PolygonStyle.Color.B,
+              style.PolygonStyle.Color.A},
+          (CesiumVectorData::ColorMode)style.PolygonStyle.ColorMode,
+          style.PolygonStyle.Fill,
+          style.PolygonStyle.Stroke}};
+}
+} // namespace
+
 std::unique_ptr<CesiumRasterOverlays::RasterOverlay>
 UCesiumVectorDocumentRasterOverlay::CreateOverlay(
     const CesiumRasterOverlays::RasterOverlayOptions& options) {
@@ -20,24 +45,37 @@ UCesiumVectorDocumentRasterOverlay::CreateOverlay(
     return nullptr;
   }
 
-  const CesiumGeospatial::Ellipsoid& ellipsoid = options.ellipsoid;
-
   CesiumGeospatial::Projection projection;
   if (this->Projection ==
       ECesiumVectorDocumentRasterOverlayProjection::Geographic) {
-    projection = CesiumGeospatial::GeographicProjection(ellipsoid);
+    projection = CesiumGeospatial::GeographicProjection(options.ellipsoid);
   } else {
-    projection = CesiumGeospatial::WebMercatorProjection(ellipsoid);
+    projection = CesiumGeospatial::WebMercatorProjection(options.ellipsoid);
+  }
+
+  CesiumVectorData::VectorStyle style =
+      unrealToNativeVectorStyle(this->DefaultStyle);
+
+  std::optional<CesiumRasterOverlays::VectorDocumentRasterOverlayStyleCallback>
+      callbackOpt = std::nullopt;
+
+  if (this->StyleCallback.IsBound()) {
+    callbackOpt = [Callback = this->StyleCallback](
+                      const CesiumUtility::IntrusivePointer<
+                          CesiumVectorData::VectorDocument>& doc,
+                      const CesiumVectorData::VectorNode* pNode) {
+      return Callback.Execute(FCesiumVectorNode(doc, pNode)).toNative();
+    };
   }
 
-  CesiumVectorData::VectorRasterizerStyle style{
-      CesiumVectorData::Color{
-          std::byte{this->Color.R},
-          std::byte{this->Color.G},
-          std::byte{this->Color.B},
-          std::byte{this->Color.A}},
-      this->LineWidth,
-      (CesiumVectorData::VectorLineWidthMode)this->LineWidthMode};
+  CesiumRasterOverlays::VectorDocumentRasterOverlayOptions vectorOptions{
+      unrealToNativeVectorStyle(this->DefaultStyle),
+      callbackOpt,
+      std::move(projection),
+      options.ellipsoid,
+      this->MipLevels};
+
+  const CesiumGeospatial::Ellipsoid& ellipsoid = options.ellipsoid;
 
   if (this->Source == ECesiumVectorDocumentRasterOverlaySource::FromCesiumIon) {
     if (!IsValid(this->CesiumIonServer)) {
@@ -50,19 +88,13 @@ UCesiumVectorDocumentRasterOverlay::CreateOverlay(
             this->IonAssetID,
             TCHAR_TO_UTF8(*this->CesiumIonServer->DefaultIonAccessToken),
             TCHAR_TO_UTF8(*this->CesiumIonServer->ApiUrl)},
-        style,
-        projection,
-        ellipsoid,
-        (uint32_t)this->MipLevels,
+        vectorOptions,
         options);
   }
 
   return std::make_unique<CesiumRasterOverlays::VectorDocumentRasterOverlay>(
       TCHAR_TO_UTF8(*this->MaterialLayerKey),
       this->VectorDocument.GetDocument(),
-      style,
-      projection,
-      ellipsoid,
-      (uint32_t)this->MipLevels,
+      vectorOptions,
       options);
 }

Source/CesiumRuntime/Private/CesiumVectorNode.cpp

@@ -256,6 +256,29 @@ bool UCesiumVectorNodeBlueprintLibrary::FindNodeByIntId(
   return false;
 }
 
+bool UCesiumVectorNodeBlueprintLibrary::GetStyle(
+    const FCesiumVectorNode& InVectorNode,
+    FCesiumVectorStyle& OutStyle) {
+  if (!InVectorNode._document || InVectorNode._node == nullptr ||
+      !InVectorNode._node->style) {
+    return false;
+  }
+
+  OutStyle = FCesiumVectorStyle::fromNative(*InVectorNode._node->style);
+  return true;
+}
+
+FCesiumVectorStyle UCesiumVectorNodeBlueprintLibrary::GetStyleOrDefault(
+    const FCesiumVectorNode& InVectorNode,
+    const FCesiumVectorStyle& InDefaultStyle) {
+  if (!InVectorNode._document || InVectorNode._node == nullptr ||
+      !InVectorNode._node->style) {
+    return InDefaultStyle;
+  }
+
+  return FCesiumVectorStyle::fromNative(*InVectorNode._node->style);
+}
+
 ECesiumVectorPrimitiveType
 UCesiumVectorPrimitiveBlueprintLibrary::GetPrimitiveType(
     const FCesiumVectorPrimitive& InPrimitive) {

Source/CesiumRuntime/Private/CesiumVectorStyle.cpp

@@ -0,0 +1,45 @@
+#include "CesiumVectorStyle.h"
+
+CesiumVectorData::VectorStyle FCesiumVectorStyle::toNative() const  {
+  return CesiumVectorData::VectorStyle{
+      CesiumVectorData::LineStyle{
+          CesiumVectorData::Color{
+              this->LineStyle.Color.R,
+              this->LineStyle.Color.G,
+              this->LineStyle.Color.B,
+              this->LineStyle.Color.A},
+          (CesiumVectorData::ColorMode)this->LineStyle.ColorMode,
+          this->LineStyle.Width,
+          (CesiumVectorData::LineWidthMode)this->LineStyle.WidthMode},
+      CesiumVectorData::PolygonStyle{
+          CesiumVectorData::Color{
+              this->PolygonStyle.Color.R,
+              this->PolygonStyle.Color.G,
+              this->PolygonStyle.Color.B,
+              this->PolygonStyle.Color.A},
+          (CesiumVectorData::ColorMode)this->PolygonStyle.ColorMode,
+          this->PolygonStyle.Fill,
+          this->PolygonStyle.Outline}};
+}
+
+FCesiumVectorStyle FCesiumVectorStyle::fromNative(const CesiumVectorData::VectorStyle& style) {
+  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{
+          FColor(
+              (uint8)style.polygon.color.r,
+              (uint8)style.polygon.color.g,
+              (uint8)style.polygon.color.b,
+              (uint8)style.polygon.color.a),
+          (ECesiumVectorColorMode)style.polygon.colorMode,
+          style.polygon.fill,
+          style.polygon.outline}};
+}

Source/CesiumRuntime/Public/CesiumVectorDocumentRasterOverlay.h

@@ -5,10 +5,15 @@
 #include "CesiumIonServer.h"
 #include "CesiumRasterOverlay.h"
 #include "CesiumVectorDocument.h"
+#include "CesiumVectorStyle.h"
 #include "Components/ActorComponent.h"
 #include "CoreMinimal.h"
+#include "Delegates/Delegate.h"
 #include "CesiumVectorDocumentRasterOverlay.generated.h"
 
+/**
+ * The projection used by a CesiumVectorDocumentRasterOverlay.
+ */
 UENUM(BlueprintType)
 enum class ECesiumVectorDocumentRasterOverlayProjection : uint8 {
   /**
@@ -22,19 +27,33 @@ enum class ECesiumVectorDocumentRasterOverlayProjection : uint8 {
   Geographic
 };
 
+/**
+ * Configures where the CesiumVectorDocumentRasterOverlay should load its vector
+ * data from.
+ */
 UENUM(BlueprintType)
 enum class ECesiumVectorDocumentRasterOverlaySource : uint8 {
+  /**
+   * The raster overlay will display the provided VectorDocument.
+   */
   FromDocument = 0,
+  /**
+   * The raster overlay will load the VectorDocument from Cesium ion.
+   */
   FromCesiumIon = 1
 };
 
-UENUM(BlueprintType)
-enum class ECesiumVectorDocumentRasterOverlayLineWidthMode : uint8 {
-  Pixels = 0,
-  Meters = 1
-};
-
-UCLASS(ClassGroup = Cesium, meta = (BlueprintSpawnableComponent))
+DECLARE_DYNAMIC_DELEGATE_RetVal_OneParam(
+    FCesiumVectorStyle,
+    FCesiumVectorDocumentRasterOverlayStyleCallback,
+    FCesiumVectorNode,
+    InNode);
+
+UCLASS(
+    ClassGroup = Cesium,
+    BlueprintType,
+    Blueprintable,
+    meta = (BlueprintSpawnableComponent))
 class CESIUMRUNTIME_API UCesiumVectorDocumentRasterOverlay
     : public UCesiumRasterOverlay {
   GENERATED_BODY()
@@ -56,7 +75,13 @@ class CESIUMRUNTIME_API UCesiumVectorDocumentRasterOverlay
   /**
    * The ID of the Cesium ion asset to use.
    */
-  UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Cesium", meta=(EditCondition="Source == ECesiumVectorDocumentRasterOverlaySource::FromCesiumIon"))
+  UPROPERTY(
+      EditAnywhere,
+      BlueprintReadWrite,
+      Category = "Cesium",
+      meta =
+          (EditCondition =
+               "Source == ECesiumVectorDocumentRasterOverlaySource::FromCesiumIon"))
   int64 IonAssetID;
 
   /**
@@ -89,14 +114,13 @@ class CESIUMRUNTIME_API UCesiumVectorDocumentRasterOverlay
   int32 MipLevels = 0;
 
   UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Cesium")
-  FColor Color = FColor(0, 0, 0, 255);
-
-  UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Cesium", meta=(ClampMin = "0"))
-  double LineWidth = 1.0;
+  FCesiumVectorStyle DefaultStyle;
 
-  UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Cesium")
-  ECesiumVectorDocumentRasterOverlayLineWidthMode LineWidthMode =
-      ECesiumVectorDocumentRasterOverlayLineWidthMode::Pixels;
+  UPROPERTY(
+      EditAnywhere,
+      BlueprintReadWrite,
+      Category = "Cesium")
+  FCesiumVectorDocumentRasterOverlayStyleCallback StyleCallback;
 
 protected:
   virtual std::unique_ptr<CesiumRasterOverlays::RasterOverlay> CreateOverlay(

Source/CesiumRuntime/Public/CesiumVectorNode.h

@@ -5,6 +5,7 @@
 #include "CesiumUtility/IntrusivePointer.h"
 #include "CesiumVectorData/VectorDocument.h"
 #include "CesiumVectorData/VectorNode.h"
+#include "CesiumVectorStyle.h"
 #include "JsonObjectWrapper.h"
 #include "Kismet/BlueprintFunctionLibrary.h"
 #include "Templates/SharedPointer.h"
@@ -179,6 +180,26 @@ class UCesiumVectorNodeBlueprintLibrary : public UBlueprintFunctionLibrary {
       const FCesiumVectorNode& InVectorNode,
       int64 InNodeId,
       FCesiumVectorNode& OutNode);
+
+  /**
+   * @brief Returns true if this node has a style, or false if no style is
+   * attached. If this node has a style, OutStyle will be set to that style.
+   */
+  UFUNCTION(
+      BlueprintCallable,
+      Category = "Cesium|Vector|Node",
+      meta = (DisplayName = "Get Node Style"))
+  static UPARAM(DisplayName = "Has Style") bool GetStyle(
+      const FCesiumVectorNode& InVectorNode,
+      FCesiumVectorStyle& OutStyle);
+
+  /**
+   * @brief Returns the style on this node, or the default style if this node
+   * has no style attached.
+   */
+  static FCesiumVectorStyle GetStyleOrDefault(
+      const FCesiumVectorNode& InVectorNode,
+      const FCesiumVectorStyle& InDefaultStyle);
 };
 
 /**