LargeMapManager.h

Go to the documentation of this file.

// Copyright (c) 2026 Computer Vision Center (CVC) at the Universitat Autonoma de Barcelona (UAB).
// This work is licensed under the terms of the MIT license.
// For a copy, see <https://opensource.org/licenses/MIT>.
 
#pragma once
 
#include "Actor/CarlaActor.h"
#include "Math/DVector.h"
 
#include <util/ue-header-guard-begin.h>
#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "Engine/LevelStreamingDynamic.h"
#include <util/ue-header-guard-end.h>
 
#include "LargeMapManager.generated.h"
 
// TODO: Cache CarlaEpisode
 
USTRUCT()
struct FActiveActor
{
  GENERATED_BODY()
 
  FActiveActor() {}
 
  FActiveActor(
    const FCarlaActor* InCarlaActor,
    const FTransform& InTransform)
    : CarlaActor(InCarlaActor),
      WorldLocation(FDVector(InTransform.GetTranslation())),
      Rotation(InTransform.GetRotation()) {}
 
  const FCarlaActor* CarlaActor;
 
  FDVector WorldLocation;
 
  FQuat Rotation;
};
 
USTRUCT(BlueprintType)
struct FCarlaMapTile
{
  GENERATED_BODY()
 
  UPROPERTY(VisibleAnywhere, BlueprintReadWrite, Category = "Carla Map Tile")
  FString Name; // Tile_{TileID_X}_{TileID_Y}
 
  // Absolute location, does not depend on rebasing
  UPROPERTY(VisibleAnywhere,  BlueprintReadWrite, Category = "Carla Map Tile")
  FVector Location{0.0f};
  // TODO: not FVector
 
  UPROPERTY(VisibleAnywhere,  BlueprintReadWrite, Category = "Carla Map Tile")
  ULevelStreamingDynamic* StreamingLevel = nullptr;
 
  bool TilesSpawned = false;
};
 
UCLASS()
class CARLA_API ALargeMapManager : public AActor
{
  GENERATED_BODY()
 
public:
 
  using TileID = uint64;
 
  // Sets default values for this actor's properties
  ALargeMapManager();
 
  ~ALargeMapManager();
 
protected:
  // Called when the game starts or when spawned
  virtual void BeginPlay() override;
 
  void PreWorldOriginOffset(UWorld* InWorld, FIntVector InSrcOrigin, FIntVector InDstOrigin);
  void PostWorldOriginOffset(UWorld* InWorld, FIntVector InSrcOrigin, FIntVector InDstOrigin);
 
  void OnLevelAddedToWorld(ULevel* InLevel, UWorld* InWorld);
  void OnLevelRemovedFromWorld(ULevel* InLevel, UWorld* InWorld);
 
  // Snap the generated signs whose ground has streamed in (used after tiles
  // stream in), if the traffic light manager has the flag on.
  void AdjustSignsHeightToGround();
 
public:
 
  void RegisterInitialObjects();
 
  void OnActorSpawned(const FCarlaActor& CarlaActor);
 
  UFUNCTION(Category="Large Map Manager")
  void OnActorDestroyed(AActor* DestroyedActor);
 
  // Called every frame
  void Tick(float DeltaTime) override;
 
  UFUNCTION(BlueprintCallable, Category = "Large Map Manager")
  void GenerateMap(FString InAssetsPath);
 
  UFUNCTION(BlueprintCallable, Category = "Large Map Manager")
  void GenerateLargeMap();
 
  void GenerateMap(TArray<TPair<FString, FIntVector>> MapPathsIds);
 
  UFUNCTION(BlueprintCallable, CallInEditor, Category = "Large Map Manager")
  void ClearWorldAndTiles();
 
  UFUNCTION(BlueprintCallable, CallInEditor, Category = "Large Map Manager")
  void GenerateMap_Editor()
  {
    if (!LargeMapTilePath.IsEmpty()) GenerateMap(LargeMapTilePath);
  }
 
  void AddActorToUnloadedList(const FCarlaActor& CarlaActor, const FTransform& Transform);
 
  UFUNCTION(BlueprintCallable, Category = "Large Map Manager")
  FIntVector GetNumTilesInXY() const;
 
  UFUNCTION(BlueprintCallable, Category = "Large Map Manager")
  int GetNumTiles() const
  {
    return MapTiles.Num();
  }
 
  UFUNCTION(BlueprintCallable, Category = "Large Map Manager")
  bool IsLevelOfTileLoaded(FIntVector InTileID) const;
 
  bool IsTileLoaded(TileID TileId) const
  {
    return CurrentTilesLoaded.Contains(TileId);
  }
 
  bool IsTileLoaded(FVector Location) const
  {
    return IsTileLoaded(GetTileID(Location));
  }
 
  bool IsTileLoaded(FDVector Location) const
  {
    return IsTileLoaded(GetTileID(Location));
  }
 
  FTransform GlobalToLocalTransform(const FTransform& InTransform) const;
  FVector GlobalToLocalLocation(const FVector& InLocation) const;
 
  FTransform LocalToGlobalTransform(const FTransform& InTransform) const;
  FVector LocalToGlobalLocation(const FVector& InLocation) const;
 
  UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Large Map Manager")
  FString LargeMapTilePath = "/Game/Carla/Maps/testmap";
  UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Large Map Manager")
  FString LargeMapName = "testmap";
 
  void SetTile0Offset(const FVector& Offset);
 
  void SetTileSize(float Size);
 
  float GetTileSize();
 
  FVector GetTile0Offset();
 
  void SetLayerStreamingDistance(float Distance);
 
  void SetActorStreamingDistance(float Distance);
 
  float GetLayerStreamingDistance() const;
 
  float GetActorStreamingDistance() const;
 
  UFUNCTION(BlueprintCallable, Category = "Large Map Manager")
  FIntVector GetTileVectorID(FVector TileLocation) const;
 
  FIntVector GetTileVectorID(FDVector TileLocation) const;
 
  FIntVector GetTileVectorID(TileID TileID) const;
 
  FVector GetTileLocation(TileID TileID) const;
  
  UFUNCTION(BlueprintCallable, Category = "Large Map Manager")
  FVector GetTileLocation(FIntVector TileVectorID) const;
 
  FDVector GetTileLocationD(TileID TileID) const;
 
  FDVector GetTileLocationD(FIntVector TileVectorID) const;
 
  /// From a given location it retrieves the TileID that covers that area
  TileID GetTileID(FVector TileLocation) const;
 
  TileID GetTileID(FDVector TileLocation) const;
 
  TileID GetTileID(FIntVector TileVectorID) const;
public:
  FCarlaMapTile* GetCarlaMapTile(FVector Location);
 
  FCarlaMapTile& GetCarlaMapTile(ULevel* InLevel);
 
  UFUNCTION(BlueprintCallable, Category = "Large Map Manager")
  FCarlaMapTile& GetCarlaMapTile(FIntVector TileVectorID);
 
  FCarlaMapTile* GetCarlaMapTilePointer(FIntVector TileVectorID);
 
  FCarlaMapTile* GetCarlaMapTile(TileID TileID);
 
  FCarlaMapTile& LoadCarlaMapTile(FString TileMapPath, TileID TileId);
 
  ACarlaWheeledVehicle* GetHeroVehicle();
 
  // The spectator is treated as an ego vehicle by default when no other egos are around,
  // but this can be changed from the Python API, which ends up in this function.
  bool SpectatorAsEgo = false;
  void ConsiderSpectatorAsEgo(bool _SpectatorAsEgo);
 
protected:
 
  void RemoveLandscapeCollisionIfHaveTerraMechanics(ULevel* InLevel);
 
  void UpdateTilesState();
 
  void RemovePendingActorsToRemove();
 
  // Check if any active actor has to be converted into dormant actor
  // because it went out of range (ActorStreamingDistance)
  // Just stores the array of selected actors
  void CheckActiveActors();
 
  // Converts active actors that went out of range to dormant actors
  void ConvertActiveToDormantActors();
 
  // Check if any dormant actor has to be converted into active actor
  // because it enter in range (ActorStreamingDistance)
  // Just stores the array of selected actors
  void CheckDormantActors();
 
  // Converts active actors that went out of range to dormant actors
  void ConvertDormantToActiveActors();
 
  void CheckIfRebaseIsNeeded();
 
  void GetTilesToConsider(
    const AActor* ActorToConsider,
    TSet<TileID>& OutTilesToConsider);
 
  void GetTilesThatNeedToChangeState(
    const TSet<TileID>& InTilesToConsider,
    TSet<TileID>& OutTilesToBeVisible,
    TSet<TileID>& OutTilesToHidde);
 
  void UpdateTileState(
    const TSet<TileID>& InTilesToUpdate,
    bool InShouldBlockOnLoad,
    bool InShouldBeLoaded,
    bool InShouldBeVisible);
 
  void UpdateCurrentTilesLoaded(
    const TSet<TileID>& InTilesToBeVisible,
    const TSet<TileID>& InTilesToHidde);
 
  UPROPERTY(VisibleAnywhere, Category = "Large Map Manager")
  TMap<uint64, FCarlaMapTile> MapTiles;
 
  // All actors to be consider for tile loading (all hero vehicles)
  // The first actor in the array is the one selected for rebase
  // TODO: support rebase in more than one hero vehicle
  UPROPERTY(VisibleAnywhere, Category = "Large Map Manager")
  TArray<AActor*> ActorsToConsider;
 
  UPROPERTY(VisibleAnywhere, Category = "Large Map Manager")
  AActor* Spectator = nullptr;
  //UPROPERTY(VisibleAnywhere, Category = "Large Map Manager")
  TArray<FCarlaActor::IdType> ActiveActors;
  TArray<FCarlaActor::IdType> DormantActors;
 
  // Temporal sets to remove actors. Just to avoid removing them in the update loop
  TSet<AActor*> ActorsToRemove;
  TSet<FCarlaActor::IdType> ActivesToRemove;
  TSet<FCarlaActor::IdType> DormantsToRemove;
 
  // Helpers to move Actors from one array to another.
  TSet<FCarlaActor::IdType> ActiveToDormantActors;
  TSet<FCarlaActor::IdType> DormantToActiveActors;
 
  UPROPERTY(VisibleAnywhere, Category = "Large Map Manager")
  TSet<uint64> CurrentTilesLoaded;
 
  // Current Origin after rebase
  UPROPERTY(VisibleAnywhere, Category = "Large Map Manager")
  FIntVector CurrentOriginInt{ 0 };
 
  FDVector CurrentOriginD;
 
  UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Large Map Manager")
  FVector Tile0Offset = FVector(0,0,0);
 
  UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Large Map Manager")
  float TickInterval = 0.0f;
 
  UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Large Map Manager")
  float LayerStreamingDistance = 3.0f * 1000.0f * 100.0f;
 
  UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Large Map Manager")
  float ActorStreamingDistance = 2.0f * 1000.0f * 100.0f;
 
  UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Large Map Manager")
  float RebaseOriginDistance = 2.0f * 1000.0f * 100.0f;
 
  float LayerStreamingDistanceSquared = LayerStreamingDistance * LayerStreamingDistance;
  float ActorStreamingDistanceSquared = ActorStreamingDistance * ActorStreamingDistance;
  float RebaseOriginDistanceSquared = RebaseOriginDistance * RebaseOriginDistance;
 
  UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Large Map Manager")
  float TileSide = 2.0f * 1000.0f * 100.0f; // 2km
 
  UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Large Map Manager")
  FVector LocalTileOffset = FVector(0,0,0);
 
  UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Large Map Manager")
  bool ShouldTilesBlockOnLoad = false;
 
 
  void RegisterTilesInWorldComposition();
 
  FString GenerateTileName(TileID TileID);
 
  FString TileIDToString(TileID TileID);
 
  void DumpTilesTable() const;
 
  void PrintMapInfo();
 
  UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Large Map Manager")
  FString AssetsPath = "";
 
  FString BaseTileMapPath = "/Game/Carla/Maps/LargeMap/EmptyTileBase";
 
  FColor PositonMsgColor = FColor::Purple;
 
  const int32 TilesDistMsgIndex = 100;
  const int32 MaxTilesDistMsgIndex = TilesDistMsgIndex + 10;
 
  const int32 ClientLocMsgIndex = 200;
  const int32 MaxClientLocMsgIndex = ClientLocMsgIndex + 10;
 
  UPROPERTY(EditAnywhere, Category = "Large Map Manager")
  float MsgTime = 1.0f;
 
  UPROPERTY(EditAnywhere, Category = "Large Map Manager")
  bool bPrintMapInfo = true;
 
  UPROPERTY(EditAnywhere, Category = "Large Map Manager")
  bool bPrintErrors = false;
 
  UPROPERTY(VisibleAnywhere, Category = "Large Map Manager")
  bool bHasTerramechanics = false;
};