WorldComposition.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
#pragma once
 
#include "CoreMinimal.h"
#include "UObject/ObjectMacros.h"
#include "UObject/Object.h"
#include "Misc/WorldCompositionUtility.h"
#include "WorldComposition.generated.h"
 
class ULevel;
class ULevelStreaming;
 
struct FWorldCompositionTile
{
    FWorldCompositionTile()
        : StreamingLevelStateChangeTime(0.0)
    {
    }
    
    // Long package name
    FName                   PackageName;
    // Found LOD levels since last rescan
    TArray<FName>           LODPackageNames;
    // Tile information
    FWorldTileInfo          Info;
    // Timestamp when we have changed streaming level state
    double                  StreamingLevelStateChangeTime;
 
    friend FArchive& operator<<( FArchive& Ar, FWorldCompositionTile& D )
    {
        Ar << D.PackageName << D.Info << D.LODPackageNames;
        return Ar;
    }
                        
    struct FPackageNameMatcher
    {
        FPackageNameMatcher( const FName& InPackageName )
            : PackageName( InPackageName )
        {
        }
 
        bool Matches( const FWorldCompositionTile& Candidate ) const
        {
            return Candidate.PackageName == PackageName;
        }
 
        const FName& PackageName;
    };
};
 
struct FDistanceVisibleLevel
{
    int32               TileIdx;    
    ULevelStreaming*    StreamingLevel;
    int32               LODIndex; 
};
 
UCLASS(config=Engine, MinimalAPI)
class UWorldComposition : public UObject
{
    GENERATED_UCLASS_BODY()
 
    typedef TArray<FWorldCompositionTile> FTilesList;
 
    ENGINE_API void UpdateStreamingState();
    
    ENGINE_API void UpdateStreamingState(const FVector& InLocation);
    ENGINE_API void UpdateStreamingState(const FVector* InLocation, int32 Num);
    ENGINE_API void UpdateStreamingStateCinematic(const FVector* InLocation, int32 Num);
 
#if WITH_EDITOR
    ENGINE_API bool UpdateEditorStreamingState(const FVector& InLocation);
 
    ENGINE_API TArray<FWorldTileLayer> GetDistanceDependentLayers() const;
#endif// WITH_EDITOR
 
    ENGINE_API void EvaluateWorldOriginLocation(const FVector& ViewLocation);
 
    ENGINE_API void GetDistanceVisibleLevels(const FVector& InLocation, TArray<FDistanceVisibleLevel>& OutVisibleLevels, TArray<FDistanceVisibleLevel>& OutHiddenLevels) const;
    ENGINE_API void GetDistanceVisibleLevels(const FVector* InLocations, int32 Num, TArray<FDistanceVisibleLevel>& OutVisibleLevels, TArray<FDistanceVisibleLevel>& OutHiddenLevels) const;
 
    ENGINE_API bool IsDistanceDependentLevel(FName PackageName) const;
 
    ENGINE_API FString GetWorldRoot() const;
    
    ENGINE_API UWorld* GetWorld() const override final;
    
    static ENGINE_API void OnLevelPostLoad(ULevel* InLevel);
 
    ENGINE_API void OnLevelPreSave(ULevel* InLevel);
    
    ENGINE_API void OnLevelPostSave(ULevel* InLevel);
    
    ENGINE_API void OnLevelAddedToWorld(ULevel* InLevel);
 
    ENGINE_API void OnLevelRemovedFromWorld(ULevel* InLevel);
 
    ENGINE_API FIntVector GetLevelOffset(ULevel* InLevel) const;
 
    ENGINE_API FBox GetLevelBounds(ULevel* InLevel) const;
 
    ENGINE_API void Rescan();
 
    ENGINE_API void ReinitializeForPIE();
 
    ENGINE_API bool DoesTileExists(const FName& TilePackageName) const;
 
    ENGINE_API FTilesList& GetTilesList();
 
#if WITH_EDITOR
    ENGINE_API FWorldTileInfo GetTileInfo(const FName& InPackageName) const;
    
    ENGINE_API void OnTileInfoUpdated(const FName& InPackageName, const FWorldTileInfo& InInfo);
 
    ENGINE_API void RestoreDirtyTilesInfo(const FTilesList& TilesPrevState);
    
    ENGINE_API void CollectTilesToCook(TArray<FString>& PackageNames);
 
    // Event to enable/disable world composition in the world
    DECLARE_DELEGATE_RetVal_TwoParams(bool, FEnableWorldCompositionEvent, UWorld*, bool);
    static ENGINE_API FEnableWorldCompositionEvent EnableWorldCompositionEvent;
    
    // Event when world composition was successfully enabled/disabled in the world
    DECLARE_MULTICAST_DELEGATE_OneParam(FWorldCompositionChangedEvent, UWorld*);
    static ENGINE_API FWorldCompositionChangedEvent WorldCompositionChangedEvent;
 
#endif //WITH_EDITOR
 
private:
    // UObject interface
    ENGINE_API virtual void PostInitProperties() override;
    ENGINE_API virtual void Serialize(FArchive& Ar) override;
    ENGINE_API virtual void PostDuplicate(bool bDuplicateForPIE) override;
    ENGINE_API virtual void PostLoad() override;
    // UObject interface
 
    void PopulateStreamingLevels();
 
    void CaclulateTilesAbsolutePositions();
 
    void Reset();
    
    ULevelStreaming* CreateStreamingLevel(const FWorldCompositionTile& Info) const;
        
    void FixupForPIE(int32 PIEInstanceID);
 
    int32 FindTileIndexByName(const FName& InPackageName) const;
    FWorldCompositionTile* FindTileByName(const FName& InPackageName) const;
    
    bool IsDistanceDependentLevel(int32 TileIdx) const;
 
    bool CommitTileStreamingState(UWorld* PersistentWorld, int32 TileIdx, bool bShouldBeLoaded, bool bShouldBeVisible, bool bShouldBlock, int32 LODIdx);
 
public:
#if WITH_EDITOR
    UE_DEPRECATED(4.26, "No longer used; use bTemporarilyDisableOriginTracking instead.")
    bool                        bTemporallyDisableOriginTracking;
 
    // Hack for a World Browser to be able to temporarily show hidden levels 
    // regardless of current world origin and without offsetting them temporarily 
    bool                        bTemporarilyDisableOriginTracking;
#endif //WITH_EDITOR
 
private:
    // Path to current world composition (long PackageName)
    FString                     WorldRoot;
    
    // List of all tiles participating in the world composition
    FTilesList                  Tiles;
 
public:
    // Streaming level objects for each tile
    UPROPERTY(transient)
    TArray<TObjectPtr<ULevelStreaming>> TilesStreaming;
 
    // Time threshold between tile streaming state changes
    UPROPERTY(config)
    double                      TilesStreamingTimeThreshold;
 
    // Whether all distance dependent tiles should be loaded and visible during cinematic
    UPROPERTY(config)
    bool                        bLoadAllTilesDuringCinematic;
 
    // Whether to rebase origin in 3D space, otherwise only on XY plane
    UPROPERTY(config)
    bool                        bRebaseOriginIn3DSpace;
 
#if WITH_EDITORONLY_DATA
    // Whether all tiles locations are locked
    UPROPERTY()
    bool                        bLockTilesLocation;
#endif
 
    // Maximum distance to current view point where we should initiate origin rebasing
    UPROPERTY(config)
    float                       RebaseOriginDistance;
};