LandscapeInfo.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/Guid.h"
#include "UObject/LazyObjectPtr.h"
#include "UObject/ScriptInterface.h"
#include "ILandscapeSplineInterface.h"
 
#if WITH_EDITOR
#include "WorldPartition/WorldPartitionHandle.h"
#endif
 
#include "LandscapeInfo.generated.h"
 
class ALandscape;
class ALandscapeProxy;
class ALandscapeStreamingProxy;
class ALandscapeSplineActor;
class ULandscapeComponent;
class ULandscapeLayerInfoObject;
class ULevel;
class UMaterialInstanceConstant;
struct FLandscapeEditorLayerSettings;
struct FLandscapeTargetLayerSettings;
class ULandscapeSplinesComponent;
class ULandscapeSplineControlPoint;
class ULandscapeSplineSegment;
class ULandscapeHeightfieldCollisionComponent;
class FModulateAlpha;
 
#if WITH_EDITORONLY_DATA
struct FLandscapeAddCollision
{
    FVector Corners[4];
 
    FLandscapeAddCollision()
    {
        Corners[0] = Corners[1] = Corners[2] = Corners[3] = FVector::ZeroVector;
    }
};
#endif // WITH_EDITORONLY_DATA
 
class ULandscapeInfo;
 
#if WITH_EDITOR
struct FLandscapeDirtyOnlyInModeScope
{
    FLandscapeDirtyOnlyInModeScope() = delete;
    FLandscapeDirtyOnlyInModeScope(ULandscapeInfo* InLandscapeInfo);
    FLandscapeDirtyOnlyInModeScope(ULandscapeInfo* InLandscapeInfo, bool bInOverrideDirtyMode); /* Override the dirtying in Landscape mode behaviour*/
    ~FLandscapeDirtyOnlyInModeScope();
 
private:
    ULandscapeInfo* LandscapeInfo;
    bool bDirtyOnlyInModePrevious;
};
#endif
 
USTRUCT()
struct FLandscapeInfoLayerSettings
{
    GENERATED_USTRUCT_BODY()
 
    UPROPERTY()
    TObjectPtr<ULandscapeLayerInfoObject> LayerInfoObj;
 
    UPROPERTY()
    FName LayerName;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY(transient)
    TObjectPtr<UMaterialInstanceConstant> ThumbnailMIC;
 
    UPROPERTY()
    TWeakObjectPtr<ALandscapeProxy> Owner;
 
    UPROPERTY(transient)
    int32 DebugColorChannel;
#endif // WITH_EDITORONLY_DATA
 
    FLandscapeInfoLayerSettings()
        : LayerInfoObj(nullptr)
        , LayerName(NAME_None)
#if WITH_EDITORONLY_DATA
        , ThumbnailMIC(nullptr)
        , Owner(nullptr)
        , DebugColorChannel(0)
#endif // WITH_EDITORONLY_DATA
    {
    }
 
    LANDSCAPE_API FLandscapeInfoLayerSettings(ULandscapeLayerInfoObject* InLayerInfo, ALandscapeProxy* InProxy);
    LANDSCAPE_API FLandscapeInfoLayerSettings(FName InPlaceholderLayerName, ALandscapeProxy* InProxy);
 
    LANDSCAPE_API FName GetLayerName() const;
 
#if WITH_EDITORONLY_DATA
    LANDSCAPE_API const FLandscapeTargetLayerSettings& GetTargetLayerSettings() const;
#endif // WITH_EDITORONLY_DATA
};
 
UCLASS(Transient)
class ULandscapeInfo : public UObject
{
    GENERATED_UCLASS_BODY()
 
    friend class ALandscapeProxy;
 
    UPROPERTY()
    TWeakObjectPtr<ALandscape> LandscapeActor;
 
    UPROPERTY()
    FGuid LandscapeGuid;
 
    UPROPERTY()
    int32 ComponentSizeQuads;
    
    UPROPERTY()
    int32 SubsectionSizeQuads;
 
    UPROPERTY()
    int32 ComponentNumSubsections;
    
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    bool bDrawScaleSetByActor = false;
 
    UPROPERTY()
    FVector DrawScale = FVector(100.0);
 
    UPROPERTY()
    TArray<FLandscapeInfoLayerSettings> Layers;
 
    UPROPERTY()
    int32 RegionSizeInComponents;
#endif // WITH_EDITORONLY_DATA
 
public:
    TMap<FIntPoint, ULandscapeComponent*> XYtoComponentMap;
    TMap<FIntPoint, ULandscapeHeightfieldCollisionComponent*> XYtoCollisionComponentMap;
 
#if WITH_EDITORONLY_DATA
    TMap<FIntPoint, FLandscapeAddCollision> XYtoAddCollisionMap;
#endif // WITH_EDITORONLY_DATA
 
    UE_DEPRECATED(5.7, "StreamingProxies rely on a sorted state and should not be modified outside of ULandscapeInfo. Use GetSortedStreamingProxies instead.")
    UPROPERTY()
    TArray<TWeakObjectPtr<ALandscapeStreamingProxy>> StreamingProxies_DEPRECATED;
 
private:
#if WITH_EDITORONLY_DATA
    // SORTED list of all actors implementing the spline interface that are registered with this landscape info
    UPROPERTY()
    TArray<TScriptInterface<ILandscapeSplineInterface>> SplineActors;
 
    // Not properties since these shouldn't be modified through transactions (no undo/redo)
    TSet<TWeakObjectPtr<UPackage>, TWeakObjectPtrSetKeyFuncs<TWeakObjectPtr<UPackage>>> ModifiedPackages;
    TSet<TWeakObjectPtr<AActor>, TWeakObjectPtrSetKeyFuncs<TWeakObjectPtr<AActor>>> ActorsToDelete;
 
    bool bDirtyOnlyInMode;
 
    friend struct FLandscapeDirtyOnlyInModeScope;
#endif // WITH_EDITORONLY_DATA
 
    TSet<ULandscapeComponent*> SelectedComponents;
 
    TSet<ULandscapeComponent*> SelectedRegionComponents;
 
    FIntRect XYComponentBounds;
 
public:
    TMap<FIntPoint,float> SelectedRegion;
 
    //~ Begin UObject Interface.
    virtual void Serialize(FArchive& Ar) override;
    //~ End UObject Interface
 
    LANDSCAPE_API FBox GetLoadedBounds() const;
 
#if WITH_EDITOR
    LANDSCAPE_API FBox GetCompleteBounds() const;
#endif
 
#if WITH_EDITOR
    // @todo document 
    // all below.
    LANDSCAPE_API bool SupportsLandscapeEditing() const;
    // False if landscape editing not supported, in PIE world, or in a Commandlet
    LANDSCAPE_API bool IsLandscapeEditableWorld() const;
 
    LANDSCAPE_API bool AreAllComponentsRegistered() const;
    LANDSCAPE_API void GetComponentsInRegion(int32 X1, int32 Y1, int32 X2, int32 Y2, TSet<ULandscapeComponent*>& OutComponents, bool bOverlap = true) const;
    LANDSCAPE_API bool HasUnloadedComponentsInRegion(int32 X1, int32 Y1, int32 X2, int32 Y2) const;
    LANDSCAPE_API bool GetLandscapeExtent(ALandscapeProxy* Proxy, FIntRect& ProxyExtent) const;
    LANDSCAPE_API bool GetLandscapeExtent(FIntRect& LandscapeExtent) const;
    LANDSCAPE_API bool GetLandscapeExtent(int32& MinX, int32& MinY, int32& MaxX, int32& MaxY) const;
    LANDSCAPE_API FIntRect GetCompleteLandscapeExtent() const;
    LANDSCAPE_API bool GetLandscapeXYComponentBounds(FIntRect& OutXYComponentBounds) const;
    LANDSCAPE_API void ForAllLandscapeComponents(TFunctionRef<void(ULandscapeComponent*)> Fn) const;
    LANDSCAPE_API void ExportHeightmap(const FString& Filename);
    LANDSCAPE_API void ExportHeightmap(const FString& Filename, const FIntRect& ExportRegion);
    LANDSCAPE_API void ExportLayer(ULandscapeLayerInfoObject* LayerInfo, const FString& Filename);
    LANDSCAPE_API void ExportLayer(ULandscapeLayerInfoObject* LayerInfo, const FString& Filename, const FIntRect& ExportRegion);
    UE_DEPRECATED(5.7, "Use ApplySplines without bOnlySelected. Edit layer landscapes update all splines regardless of selection state")
    LANDSCAPE_API bool ApplySplines(bool bOnlySelected, TSet<TObjectPtr<ULandscapeComponent>>* OutModifiedComponents = nullptr, bool bMarkPackageDirty = true);
    LANDSCAPE_API bool ApplySplines(TSet<TObjectPtr<ULandscapeComponent>>* OutModifiedComponents = nullptr, bool bMarkPackageDirty = true);
 
    LANDSCAPE_API bool GetSelectedExtent(int32& MinX, int32& MinY, int32& MaxX, int32& MaxY) const;
    FVector GetLandscapeCenterPos(float& LengthZ, int32 MinX = MAX_int32, int32 MinY = MAX_int32, int32 MaxX = MIN_int32, int32 MaxY = MIN_int32);
    LANDSCAPE_API bool IsValidPosition(int32 X, int32 Y);
    LANDSCAPE_API void DeleteLayer(ULandscapeLayerInfoObject* LayerInfo, const FName& LayerName);
    LANDSCAPE_API void ReplaceLayer(ULandscapeLayerInfoObject* FromLayerInfo, ULandscapeLayerInfoObject* ToLayerInfo);
    LANDSCAPE_API void GetUsedPaintLayers(const FGuid& InLayerGuid, TArray<ULandscapeLayerInfoObject*>& OutUsedLayerInfos) const;
 
    LANDSCAPE_API void UpdateDebugColorMaterial();
 
    LANDSCAPE_API TSet<ULandscapeComponent*> GetSelectedComponents() const;
    LANDSCAPE_API TSet<ULandscapeComponent*> GetSelectedRegionComponents() const;
    LANDSCAPE_API void UpdateSelectedComponents(TSet<ULandscapeComponent*>& NewComponents, bool bIsComponentwise = true);
    LANDSCAPE_API void ClearSelectedRegion(bool bIsComponentwise = true);
 
    // only for use by the "add component" tool. Todo - move into the tool?
    LANDSCAPE_API void UpdateAllAddCollisions();
    LANDSCAPE_API void UpdateAddCollision(FIntPoint LandscapeKey);
 
    LANDSCAPE_API const FLandscapeTargetLayerSettings& GetTargetLayerSettings(ULandscapeLayerInfoObject* LayerInfo) const;
 
    LANDSCAPE_API void CreateTargetLayerSettingsFor(ULandscapeLayerInfoObject* LayerInfo);
 
    LANDSCAPE_API ULandscapeLayerInfoObject* GetLayerInfoByName(FName LayerName, ALandscapeProxy* Owner = nullptr) const;
    LANDSCAPE_API int32 GetLayerInfoIndex(FName LayerName, ALandscapeProxy* Owner = nullptr) const;
    LANDSCAPE_API int32 GetLayerInfoIndex(ULandscapeLayerInfoObject* LayerInfo, ALandscapeProxy* Owner = nullptr) const;
    LANDSCAPE_API bool UpdateLayerInfoMap(ALandscapeProxy* Proxy = nullptr, bool bInvalidate = false);
 
    LANDSCAPE_API bool CanDeleteLandscape(FText& OutReason) const;
 
    LANDSCAPE_API ALandscapeProxy* GetLandscapeProxyForLevel(ULevel* Level) const;
 
    LANDSCAPE_API bool GetDirtyOnlyInMode() const;
 
    LANDSCAPE_API void OnModifiedPackageSaved(UPackage* InPackage);
    LANDSCAPE_API int32 GetModifiedPackageCount() const;
    LANDSCAPE_API TArray<UPackage*> GetModifiedPackages() const;
    LANDSCAPE_API bool IsPackageModified(UPackage* InPackage) const;
    LANDSCAPE_API int32 MarkModifiedPackagesAsDirty();
 
    LANDSCAPE_API bool ModifyObject(UObject* InObject, bool bAlwaysMarkDirty = true);
    LANDSCAPE_API bool MarkObjectDirty(UObject* InObject, bool bInForceResave = false, const ALandscape* InLandscapeOverride = nullptr);
 
    LANDSCAPE_API void DeleteActorWhenApplyingModifiedStatus(AActor* InActor, bool bInAllowUI);
 
    LANDSCAPE_API void DirtyRuntimeVirtualTextureForLandscapeArea(int32 X1, int32 Y1, int32 X2, int32 Y2) const;
#endif //WITH_EDITOR
 
    LANDSCAPE_API ALandscapeProxy* GetCurrentLevelLandscapeProxy(bool bRegistered) const;
    
    LANDSCAPE_API ALandscapeProxy* GetLandscapeProxy() const;
 
#if WITH_EDITOR
 
    LANDSCAPE_API void Reset();
 
    LANDSCAPE_API static void RecreateLandscapeInfo(UWorld* InWorld, bool bMapCheck, bool bKeepRegistrationStatus = false);
 
    LANDSCAPE_API void FixupProxiesTransform(bool bDirty = false);
    
    // Update per-component layer allow list to include the currently painted layers
    LANDSCAPE_API void UpdateComponentLayerAllowList();
 
    LANDSCAPE_API void RecreateCollisionComponents();
 
    LANDSCAPE_API void RemoveXYOffsets();
 
    UE_DEPRECATED(5.7, "Non-edit layer landscapes are deprecated, all landscapes use the edit layer system now.")
    LANDSCAPE_API bool CanHaveLayersContent() const;
 
    LANDSCAPE_API void ClearDirtyData();
 
    LANDSCAPE_API ALandscapeProxy* MoveComponentsToLevel(const TArray<ULandscapeComponent*>& InComponents, ULevel* TargetLevel, FName NewProxyName = NAME_None);
 
    LANDSCAPE_API ALandscapeProxy* MoveComponentsToProxy(const TArray<ULandscapeComponent*>& InComponents, ALandscapeProxy* LandscapeProxy, bool bSetPositionAndOffset = false, ULevel* TargetLevel = nullptr);
 
    LANDSCAPE_API void MoveSplineToLevel(ULandscapeSplineControlPoint* InControlPoint, ULevel* TargetLevel);
 
    LANDSCAPE_API void MoveSplinesToLevel(ULandscapeSplinesComponent* InSplineComponent, ULevel* TargetLevel);
 
    LANDSCAPE_API void MoveSplineToProxy(ULandscapeSplineControlPoint* InControlPoint, ALandscapeProxy* InLandscapeProxy);
 
    LANDSCAPE_API void MoveSplinesToProxy(ULandscapeSplinesComponent* InSplineComponent, ALandscapeProxy* InLandscapeProxy);
 
    LANDSCAPE_API void MoveSpline(ULandscapeSplineControlPoint* InControlPoint, TScriptInterface<ILandscapeSplineInterface> InNewOwner);
 
    LANDSCAPE_API void MoveSplines(ULandscapeSplinesComponent* InSplineComponent, TScriptInterface<ILandscapeSplineInterface> InNewOwner);
 
    LANDSCAPE_API void UpdateAllComponentMaterialInstances(bool bInInvalidateCombinationMaterials = false);
 
    LANDSCAPE_API uint32 GetGridSize(uint32 InGridSizeInComponents) const;
 
    LANDSCAPE_API bool AreNewLandscapeActorsSpatiallyLoaded() const;
#endif
    LANDSCAPE_API static ULandscapeInfo* Find(UWorld* InWorld, const FGuid& LandscapeGuid);
    LANDSCAPE_API static ULandscapeInfo* FindOrCreate(UWorld* InWorld, const FGuid& LandscapeGuid);
    LANDSCAPE_API static int32 RemoveLandscapeInfo(UWorld* InWorld, const FGuid& LandscapeGuid);
 
    void Initialize(UWorld* InWorld, const FGuid& InLandscapeGuid);
 
    LANDSCAPE_API const TArray<TWeakObjectPtr<ALandscapeStreamingProxy>>& GetSortedStreamingProxies() const;
 
    LANDSCAPE_API void ForEachLandscapeProxy(TFunctionRef<bool(ALandscapeProxy*)> Fn) const;
 
    void UpdateNanite(const ITargetPlatform* InTargetPlatform);
 
    LANDSCAPE_API void RegisterActor(ALandscapeProxy* Proxy, bool bMapCheck = false, bool bUpdateAllAddCollisions = true);
 
    LANDSCAPE_API void UnregisterActor(ALandscapeProxy* Proxy);
 
    bool IsRegistered(const ALandscapeProxy* Proxy) const;
 
    LANDSCAPE_API void RegisterActorComponent(ULandscapeComponent* Component, bool bMapCheck = false);
 
    LANDSCAPE_API void UnregisterActorComponent(ULandscapeComponent* Component);
 
    LANDSCAPE_API void RegisterCollisionComponent(ULandscapeHeightfieldCollisionComponent* Component);
    LANDSCAPE_API void UnregisterCollisionComponent(ULandscapeHeightfieldCollisionComponent* Component);
 
    // TODO [jonathan.bard] : There should be multiple versions of this. 
    //  1. This currently performs AABB to AABB checks and is therefore not optimal (but faster than OOBB to OOBB could ever be, which is why we might need 2 versions) :
    //  2. Returning a TMap<> is a bit overkill, since the component key can be retrieved trivially from the component
    LANDSCAPE_API bool GetOverlappedComponents(const FTransform& InAreaWorldTransform, const FBox2D& InAreaExtents, TMap<FIntPoint, ULandscapeComponent*>& OutOverlappedComponents, FIntRect& OutComponentIndicesBoundingRect);
 
#if WITH_EDITOR
    LANDSCAPE_API ALandscapeSplineActor* CreateSplineActor(const FVector& Location);
 
    LANDSCAPE_API void ForAllSplineActors(TFunctionRef<void(TScriptInterface<ILandscapeSplineInterface>)> Fn) const;
    LANDSCAPE_API TArray<TScriptInterface<ILandscapeSplineInterface>> GetSplineActors() const;
 
    LANDSCAPE_API void RegisterSplineActor(TScriptInterface<ILandscapeSplineInterface> SplineActor);
    LANDSCAPE_API void UnregisterSplineActor(TScriptInterface<ILandscapeSplineInterface> SplineActor);
 
    LANDSCAPE_API static void UpdateRegistrationForSplineActor(UWorld* InWorld, TScriptInterface<ILandscapeSplineInterface> InSplineActor);
 
    LANDSCAPE_API void RequestSplineLayerUpdate();
    LANDSCAPE_API void ForceLayersFullUpdate();
 
    static void SetForceNonSpatiallyLoadedByDefault(bool bInForceNonSpatiallyLoadedByDefault) { bForceNonSpatiallyLoadedByDefault = bInForceNonSpatiallyLoadedByDefault; }
 
private:
    inline static bool bForceNonSpatiallyLoadedByDefault = false;
 
    bool ApplySplinesInternal(TScriptInterface<ILandscapeSplineInterface> SplineOwner, TSet<TObjectPtr<ULandscapeComponent>>* OutModifiedComponents, bool bMarkPackageDirty, int32 LandscapeMinX, int32 LandscapeMinY, int32 LandscapeMaxX, int32 LandscapeMaxY, TFunctionRef<TSharedPtr<FModulateAlpha>(ULandscapeLayerInfoObject*)> GetOrCreateModulate);
    void MoveSegment(ULandscapeSplineSegment* InSegment, TScriptInterface<ILandscapeSplineInterface> From, TScriptInterface<ILandscapeSplineInterface> To);
    void MoveControlPoint(ULandscapeSplineControlPoint* InControlPoint, TScriptInterface<ILandscapeSplineInterface> From, TScriptInterface<ILandscapeSplineInterface> To);
    bool UpdateLayerInfoMapInternal(ALandscapeProxy* Proxy);
    bool TryAddToModifiedPackages(UPackage* InPackage, const ALandscape* InLandscapeOverride = nullptr);
    void ProcessDeferredDeletions();
 
    void OnMarkPackageDirty(UPackage* InPackage, bool bIsDirty);
#endif
 
private:
    void RegisterLandscapeActorWithProxyInternal(ALandscapeProxy* Proxy, bool bMapCheck);
 
    void SortStreamingProxies();
 
    UPROPERTY()
    TArray<TWeakObjectPtr<ALandscapeStreamingProxy>> SortedStreamingProxies;
};