LandscapeProxy.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
#pragma once
 
#include "CoreMinimal.h"
#include "Stats/Stats.h"
#include "UObject/ObjectMacros.h"
#include "Misc/Guid.h"
#include "Engine/EngineTypes.h"
#include "GameFramework/Actor.h"
#include "PhysicsEngine/BodyInstance.h"
#include "Async/AsyncWork.h"
#include "Engine/Texture.h"
#include "UObject/PerPlatformProperties.h"
#include "LandscapeNaniteComponent.h"
#include "LandscapeWeightmapUsage.h"
#include "LandscapeHeightfieldCollisionComponent.h"
#include "VT/RuntimeVirtualTextureEnum.h"
#include "ActorPartition/PartitionActor.h"
#include "ILandscapeSplineInterface.h"
#include "Engine/Texture2DArray.h"
 
#if WITH_EDITOR
#include "WorldPartition/WorldPartitionHandle.h"
#endif
 
#include "LandscapeProxy.generated.h"
 
class ALandscape;
class ALandscapeProxy;
class UHierarchicalInstancedStaticMeshComponent;
class ULandscapeNaniteComponent;
class ULandscapeComponent;
class ULandscapeGrassType;
class ULandscapeHeightfieldCollisionComponent;
class ULandscapeInfo;
class ULandscapeLayerInfoObject;
class ULandscapeMaterialInstanceConstant;
class ULandscapeSplinesComponent;
class UMaterialInstanceConstant;
class UMaterialInterface;
class UPhysicalMaterial;
class USplineComponent;
class UTexture2D;
class FLandscapeEditLayerReadback;
class FMaterialUpdateContext;
struct FAsyncGrassBuilder;
struct FLandscapeInfoLayerSettings;
struct FLandscapePerLODMaterialOverride;
struct FOnLandscapeLayerInfoDataChangedParams;
class FLandscapeProxyComponentDataChangedParams;
struct FMeshDescription;
 
enum class ENavDataGatheringMode : uint8;
namespace UE::Landscape
{
    enum class EOutdatedDataFlags : uint8;
    enum class EBuildFlags : uint8;
 
    namespace Nanite
    {
        struct FAsyncBuildData;
    } // end of namespace UE::Landscape::Nanite
} // end of namespace UE::Landscape
 
#if WITH_EDITOR
LANDSCAPE_API extern bool GLandscapeEditModeActive;
extern int32 GGrassMapUseRuntimeGeneration;
 
DECLARE_MULTICAST_DELEGATE_TwoParams(FOnLandscapeProxyComponentDataChanged, ALandscapeProxy*, const FLandscapeProxyComponentDataChangedParams&);
 
struct FOnLandscapeProxyMaterialChangedParams
{
};
DECLARE_MULTICAST_DELEGATE_TwoParams(FOnLandscapeProxyMaterialChanged, ALandscapeProxy*, const FOnLandscapeProxyMaterialChangedParams&);
 
struct FOnLandscapeProxyFixupSharedDataParams
{
    ALandscape* Landscape = nullptr;
    bool bUpgradeSharedPropertiesPerformed = false;
};
DECLARE_MULTICAST_DELEGATE_TwoParams(FOnLandscapeProxyFixupSharedDataDelegate, ALandscapeProxy* /*InProxy*/, const FOnLandscapeProxyFixupSharedDataParams& /*InParams*/);
#endif // WITH_EDITOR
 
 
// ----------------------------------------------------------------------------------
 
USTRUCT()
struct FLandscapeTargetLayerSettings
{
    GENERATED_USTRUCT_BODY()
 
    UPROPERTY(Category = "General", EditAnywhere)
    TObjectPtr<ULandscapeLayerInfoObject> LayerInfoObj;
    
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    FString ReimportLayerFilePath;
 
    FLandscapeTargetLayerSettings() = default;
 
    explicit FLandscapeTargetLayerSettings(ULandscapeLayerInfoObject* InLayerInfo, const FString& InFilePath = FString())
        : LayerInfoObj(InLayerInfo)
        , ReimportLayerFilePath(InFilePath)
    {
    }
 
    bool operator==(const FLandscapeTargetLayerSettings& Other) const
    {
        return LayerInfoObj == Other.LayerInfoObj;
    }
#endif // WITH_EDITORONLY_DATA
};
 
USTRUCT()
struct UE_DEPRECATED(all, "FLandscapeEditorLayerSettings is deprecated; please use FLandscapeTargetLayerSettings instead")  FLandscapeEditorLayerSettings
{
    GENERATED_USTRUCT_BODY()
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    TObjectPtr<ULandscapeLayerInfoObject> LayerInfoObj;
 
    UPROPERTY()
    FString ReimportLayerFilePath;
 
    FLandscapeEditorLayerSettings()
        : LayerInfoObj(nullptr)
        , ReimportLayerFilePath()
    {
    }
 
    explicit FLandscapeEditorLayerSettings(ULandscapeLayerInfoObject* InLayerInfo, const FString& InFilePath = FString())
        : LayerInfoObj(InLayerInfo)
        , ReimportLayerFilePath(InFilePath)
    {
    }
 
    // To allow FindByKey etc
    bool operator==(const ULandscapeLayerInfoObject* LayerInfo) const
    {
        return LayerInfoObj == LayerInfo;
    }
#endif // WITH_EDITORONLY_DATA
};
 
UENUM()
enum class ELandscapeImportAlphamapType : uint8
{
    // Three layers blended 50/30/20 represented as 0.5, 0.3, and 0.2 in the alpha maps
    // All alpha maps for blended layers total to 1.0
    // This is the style used by UE internally for blended layers
    Additive,
 
    // Three layers blended 50/30/20 represented as 0.5, 0.6, and 1.0 in the alpha maps
    // Each alpha map only specifies the remainder from previous layers, so the last layer used will always be 1.0
    // Some other tools use this format
    Layered,
};
 
USTRUCT()
struct FLandscapeImportLayerInfo
{
    GENERATED_USTRUCT_BODY()
 
#if WITH_EDITORONLY_DATA
    UPROPERTY(Category="Import", VisibleAnywhere)
    FName LayerName;
 
    UPROPERTY(Category="Import", EditAnywhere, meta=(NoCreate))
    TObjectPtr<ULandscapeLayerInfoObject> LayerInfo;
 
    UPROPERTY(Category="Import", EditAnywhere, meta=(DisplayName="Layer File"))
    FString SourceFilePath; // Optional
    
    // Raw weightmap data
    TArray<uint8> LayerData;
#endif
 
#if WITH_EDITOR
    FLandscapeImportLayerInfo(FName InLayerName = NAME_None)
    :   LayerName(InLayerName)
    ,   LayerInfo(nullptr)
    ,   SourceFilePath("")
    {
    }
 
    LANDSCAPE_API FLandscapeImportLayerInfo(const FLandscapeInfoLayerSettings& InLayerSettings);
#endif
};
 
// this is only here because putting it in LandscapeEditorObject.h (where it belongs)
// results in Engine being dependent on LandscapeEditor, as the actual landscape editing
// code (e.g. LandscapeEdit.h) is in /Engine/ for some reason...
UENUM()
enum class ELandscapeLayerPaintingRestriction : uint8
{
    None         UMETA(DisplayName="None"),
 
    UseMaxLayers UMETA(DisplayName="Limit Layer Count"),
 
    ExistingOnly UMETA(DisplayName="Existing Layers Only"),
 
    UseComponentAllowList UMETA(DisplayName="Component Allow List"),
};
 
UENUM()
enum class ELandscapeLayerDisplayMode : uint8
{
    Default,
 
    Alphabetical,
 
    UserSpecific,
 
    ByBlendMethod,
};
 
UENUM()
enum class ELandscapeHLODTextureSizePolicy : uint8
{
    AutomaticSize,
 
    SpecificSize
};
 
UENUM()
enum class ELandscapeHLODMeshSourceLODPolicy : uint8
{
    AutomaticLOD,
 
    SpecificLOD,
 
    LowestDetailLOD
};
 
UENUM()
namespace ELandscapeLODFalloff
{
    enum Type : int
    {
        Linear          UMETA(DisplayName = "Linear"),
        SquareRoot      UMETA(DisplayName = "Square Root"),
    };
}
 
struct FCachedLandscapeFoliage
{
    struct FGrassCompKey
    {
        TWeakObjectPtr<ULandscapeComponent> BasedOn;
        TWeakObjectPtr<ULandscapeGrassType> GrassType;
        int32 SqrtSubsections;
        int32 CachedMaxInstancesPerComponent;
        int32 SubsectionX;
        int32 SubsectionY;
        int32 NumVarieties;
        int32 VarietyIndex;
 
        FGrassCompKey()
            : SqrtSubsections(0)
            , CachedMaxInstancesPerComponent(0)
            , SubsectionX(0)
            , SubsectionY(0)
            , NumVarieties(0)
            , VarietyIndex(-1)
        {
        }
        inline bool operator==(const FGrassCompKey& Other) const
        {
            return 
                SqrtSubsections == Other.SqrtSubsections &&
                CachedMaxInstancesPerComponent == Other.CachedMaxInstancesPerComponent &&
                SubsectionX == Other.SubsectionX &&
                SubsectionY == Other.SubsectionY &&
                BasedOn == Other.BasedOn &&
                GrassType == Other.GrassType &&
                NumVarieties == Other.NumVarieties &&
                VarietyIndex == Other.VarietyIndex;
        }
 
        friend uint32 GetTypeHash(const FGrassCompKey& Key)
        {
            return GetTypeHash(Key.BasedOn) ^ GetTypeHash(Key.GrassType) ^ Key.SqrtSubsections ^ Key.CachedMaxInstancesPerComponent ^ (Key.SubsectionX << 16) ^ (Key.SubsectionY << 24) ^ (Key.NumVarieties << 3) ^ (Key.VarietyIndex << 13);
        }
 
    };
 
    struct FGrassComp
    {
        FGrassCompKey Key;
        TWeakObjectPtr<UHierarchicalInstancedStaticMeshComponent> Foliage;
        TWeakObjectPtr<UHierarchicalInstancedStaticMeshComponent> PreviousFoliage;
        TArray<FBox> ExcludedBoxes;
        uint32 LastUsedFrameNumber;
        uint32 ExclusionChangeTag;
        double LastUsedTime;
        bool Pending;
        bool PendingRemovalRebuild;
 
        FGrassComp()
            : ExclusionChangeTag(0)
            , Pending(true)
            , PendingRemovalRebuild(false)
        {
            Touch();
        }
        void Touch()
        {
            LastUsedFrameNumber = GFrameNumber;
            LastUsedTime = FPlatformTime::Seconds();
        }
    };
 
    struct FGrassCompKeyFuncs : BaseKeyFuncs<FGrassComp,FGrassCompKey>
    {
        static KeyInitType GetSetKey(const FGrassComp& Element)
        {
            return Element.Key;
        }
 
        static bool Matches(KeyInitType A, KeyInitType B)
        {
            return A == B;
        }
 
        static uint32 GetKeyHash(KeyInitType Key)
        {
            return GetTypeHash(Key);
        }
    };
 
    typedef TSet<FGrassComp, FGrassCompKeyFuncs> TGrassSet;
    TSet<FGrassComp, FGrassCompKeyFuncs> CachedGrassComps;
 
    void ClearCache()
    {
        CachedGrassComps.Empty();
    }
};
 
class FAsyncGrassTask : public FNonAbandonableTask
{
public:
    FAsyncGrassBuilder* Builder;
    FCachedLandscapeFoliage::FGrassCompKey Key;
    TWeakObjectPtr<UHierarchicalInstancedStaticMeshComponent> Foliage;
 
    FAsyncGrassTask(FAsyncGrassBuilder* InBuilder, const FCachedLandscapeFoliage::FGrassCompKey& InKey, UHierarchicalInstancedStaticMeshComponent* InFoliage);
    void DoWork();
 
    FORCEINLINE TStatId GetStatId() const
    {
        RETURN_QUICK_DECLARE_CYCLE_STAT(FAsyncGrassTask, STATGROUP_ThreadPoolAsyncTasks);
    }
 
    ~FAsyncGrassTask();
};
 
USTRUCT(meta = (Deprecated = "5.1"))
struct UE_DEPRECATED(all, "FLandscapeProxyMaterialOverride is deprecated; please use FLandscapePerLODMaterialOverride instead") FLandscapeProxyMaterialOverride
{
    GENERATED_USTRUCT_BODY()
 
    UPROPERTY()
    FPerPlatformInt LODIndex;
 
    UPROPERTY()
    TObjectPtr<UMaterialInterface> Material = nullptr;
};
 
 
#if WITH_EDITOR
// Tracks delayed updates triggered by landscape updates.
// It's responsible for preventing expensive async operations while the user is still editing the landscape
struct FAsyncWorkMonitor 
{
public:
    enum class EAsyncWorkType : uint8
    {
        BuildNaniteMeshes,
        Max
    };
 
    bool CheckIfUpdateTriggeredAndClear(EAsyncWorkType WorkType);
    void SetDelayedUpdateTimer(EAsyncWorkType WorkType, float InSecondsUntilDelayedUpdateTrigger);
    void Tick(float Detaltime);
 
private:
    struct FAsyncWorkTypeInfo
    {
        bool bUpdateTriggered = false;
        float SecondsUntilDelayedUpdateTrigger = 0.0f;
    };
 
    TStaticArray<FAsyncWorkTypeInfo, static_cast<uint32>(EAsyncWorkType::Max)> WorkTypeInfos; // [static_cast<uint32>(EAsyncWorkType::Max)] ;
};
#endif 
UCLASS(Abstract, MinimalAPI, NotBlueprintable, NotPlaceable, hidecategories=(Display, Attachment, Physics, Debug, Lighting), showcategories=(Lighting, Rendering, Transformation), hidecategories=(Mobility))
class ALandscapeProxy : public APartitionActor, public ILandscapeSplineInterface
{
    GENERATED_BODY()
 
public:
    ALandscapeProxy(const FObjectInitializer& ObjectInitializer);
 
    virtual ~ALandscapeProxy();
 
protected:
 
#if WITH_EDITORONLY_DATA
    TSet<FWorldPartitionReference> ActorDescReferences;
 
    friend class FLandscapeActorDesc;
#endif // WITH_EDITORONLY_DATA
 
    UPROPERTY()
    TObjectPtr<ULandscapeSplinesComponent> SplineComponent;
 
    UPROPERTY(meta = (LandscapeInherited))
    FGuid LandscapeGuid;
 
    UPROPERTY(Transient, DuplicateTransient, meta = (LandscapeInherited))
    FGuid OriginalLandscapeGuid;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Nanite, meta = (LandscapeInherited))
    bool bEnableNanite = false;
 
    UPROPERTY(EditAnywhere, Category = Landscape, meta = (LandscapeOverridable))
    TArray<FLandscapePerLODMaterialOverride> PerLODOverrideMaterials;
 
#if WITH_EDITORONLY_DATA
    UE_DEPRECATED(5.6, "PreEditPerLODOverrideMaterials has been deprecated. PerLODOverrideMaterial property changes handled in PostEditChange.")
    UPROPERTY(Transient)
    TArray<FLandscapePerLODMaterialOverride> PreEditPerLODOverrideMaterials_DEPRECATED;
 
    UPROPERTY(EditAnywhere, Category = Nanite, AdvancedDisplay, meta = (EditCondition = "bEnableNanite", LandscapeInherited))
    int32 NaniteLODIndex = 0;
 
    UPROPERTY(EditAnywhere, Category = Nanite, AdvancedDisplay, meta = (EditCondition = "bEnableNanite", LandscapeInherited))
    bool bNaniteSkirtEnabled = false;
 
    UPROPERTY(EditAnywhere, Category = Nanite, AdvancedDisplay, meta = (EditCondition = "bEnableNanite", LandscapeInherited))
    float NaniteSkirtDepth = 0.1f;
    
    UPROPERTY(EditAnywhere, Category = Nanite, AdvancedDisplay, meta = (EditCondition = "bEnableNanite", LandscapeInherited))
    int32 NanitePositionPrecision = 0;
 
    UPROPERTY(EditAnywhere, Category = Nanite, AdvancedDisplay, meta = (EditCondition = "bEnableNanite", LandscapeInherited))
    float NaniteMaxEdgeLengthFactor = 16.0f;
 
    LANDSCAPE_API static FOnLandscapeProxyFixupSharedDataDelegate OnLandscapeProxyFixupSharedDataDelegate;
#endif // WITH_EDITORONLY_DATA
 
    UPROPERTY(meta = (LandscapeInherited))
    bool bDisableRuntimeGrassMapGeneration = false;
 
public:
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    TMap<FName, TObjectPtr<ULandscapeLayerInfoObject>> TargetLayersForFixup;
 
    UE_DEPRECATED(5.7, "Use private SectionBase with GetSectionBase instead.")
    FIntPoint LandscapeSectionOffset;
#endif //WITH_EDITORONLY_DATA
 
    UPROPERTY(EditAnywhere, Category=LOD, meta = (LandscapeInherited))
    int32 MaxLODLevel;
 
#if WITH_EDITORONLY_DATA
    UE_DEPRECATED(all, "Unused property, replaced by LOD0DistributionSetting and LODDistributionSetting")
    UPROPERTY()
    float LODDistanceFactor_DEPRECATED;
 
    UE_DEPRECATED(all, "Unused property, replaced by LOD0DistributionSetting and LODDistributionSetting")
    UPROPERTY()
    TEnumAsByte<ELandscapeLODFalloff::Type> LODFalloff_DEPRECATED;
#endif // WITH_EDITORONLY_DATA
 
    UPROPERTY(EditAnywhere, Category = "LOD Distribution", meta = (EditCondition = "!bUseScalableLODSettings", DisplayName = "LOD 0 Screen Size", ClampMin = "0.1", ClampMax = "10.0", UIMin = "0.1", UIMax = "10.0", LandscapeInherited))
    float LOD0ScreenSize = 0.5f;
    
    UPROPERTY(EditAnywhere, Category = LOD, AdvancedDisplay, meta = (LandscapeInherited))
    uint32 LODGroupKey = 0;
 
    UPROPERTY(EditAnywhere, Category = "LOD Distribution", meta = (EditCondition = "!bUseScalableLODSettings", DisplayName = "LOD 0", ClampMin = "1.0", ClampMax = "10.0", UIMin = "1.0", UIMax = "10.0", LandscapeInherited))
    float LOD0DistributionSetting = 1.25f;
 
    UPROPERTY(EditAnywhere, Category = "LOD Distribution", meta = (EditCondition = "!bUseScalableLODSettings", DisplayName = "Other LODs", ClampMin = "1.0", ClampMax = "10.0", UIMin = "1.0", UIMax = "10.0", LandscapeInherited))
    float LODDistributionSetting = 3.0f;
 
    UPROPERTY(EditAnywhere, Category = "LOD Distribution", meta = (EditCondition = "bUseScalableLODSettings", DisplayName = "Scalable LOD 0 Screen Size", ClampMin = "0.1", ClampMax = "10.0", UIMin = "0.1", UIMax = "10.0", LandscapeInherited))
    FPerQualityLevelFloat ScalableLOD0ScreenSize = 0.5f;
    
    UPROPERTY(EditAnywhere, Category = "LOD Distribution", meta = (EditCondition = "bUseScalableLODSettings", DisplayName = "Scalable LOD 0", ClampMin = "1.0", ClampMax = "10.0", UIMin = "1.0", UIMax = "10.0", LandscapeInherited))
    FPerQualityLevelFloat ScalableLOD0DistributionSetting = 1.25f;
    
    UPROPERTY(EditAnywhere, Category = "LOD Distribution", meta = (EditCondition = "bUseScalableLODSettings", DisplayName = "Scalable Other LODs", ClampMin = "1.0", ClampMax = "10.0", UIMin = "1.0", UIMax = "10.0", LandscapeInherited))
    FPerQualityLevelFloat ScalableLODDistributionSetting = 3.0f;
 
    UPROPERTY(EditAnywhere, Category = "LOD Distribution", meta = (LandscapeInherited))
    bool bUseScalableLODSettings = false;
 
    UPROPERTY(EditAnywhere, Category = "LOD Distribution", meta = (DisplayName = "Blend Range", ClampMin = "0.01", ClampMax = "1.0", UIMin = "0.01", UIMax = "1.0", LandscapeInherited))
    float LODBlendRange = 0.1f;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY(EditAnywhere, Category=LOD, AdvancedDisplay, meta = (LandscapeOverridable))
    int32 ExportLOD;
#endif
 
    UPROPERTY(EditAnywhere, Category=Lighting, meta = (LandscapeOverridable))
    int32 StaticLightingLOD; 
 
    UPROPERTY(EditAnywhere, Category=Landscape, meta = (LandscapeOverridable))
    TObjectPtr<UPhysicalMaterial> DefaultPhysMaterial;
 
    UPROPERTY(EditAnywhere, Category=Landscape, meta = (LandscapeOverridable))
    float StreamingDistanceMultiplier;
 
    UPROPERTY(EditAnywhere, BlueprintSetter=EditorSetLandscapeMaterial, Category=Landscape, meta=(LandscapeOverridable))
    TObjectPtr<UMaterialInterface> LandscapeMaterial;
 
    UPROPERTY(EditAnywhere, Category=Landscape, AdvancedDisplay, meta = (LandscapeOverridable))
    TObjectPtr<UMaterialInterface> LandscapeHoleMaterial;
 
 
#if WITH_EDITORONLY_DATA
 
PRAGMA_DISABLE_DEPRECATION_WARNINGS
    UE_DEPRECATED(all, "LandscapeComponentMaterialOverride has been deprecated, use PerLODOverrideMaterials instead.")
    UPROPERTY()
    TArray<FLandscapeProxyMaterialOverride> LandscapeMaterialsOverride_DEPRECATED;
PRAGMA_ENABLE_DEPRECATION_WARNINGS
 
    UE_DEPRECATED(5.6, "PreEditLandscapeMaterial has been deprecated. LandscapeMaterial Property changes handled in PostEditChange.")
    UPROPERTY(Transient)
    TObjectPtr<UMaterialInterface> PreEditLandscapeMaterial_DEPRECATED;
 
    UE_DEPRECATED(5.6, "PreEditLandscapeHoleMaterial has been deprecated. LandscapeHoleMaterial Property changes handled in PostEditChange.")
    UPROPERTY(Transient)
    TObjectPtr<UMaterialInterface> PreEditLandscapeHoleMaterial_DEPRECATED;
 
    UE_DEPRECATED(5.6, "bIsPerformingInteractiveActionOnLandscapeMaterialOverride has been deprecated. PostEditChange checks interaction type.")
    UPROPERTY(Transient)
    bool bIsPerformingInteractiveActionOnLandscapeMaterialOverride_DEPRECATED = false;
#endif // WITH_EDITORONLY_DATA
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = VirtualTexture, meta = (DisplayName = "Draw in Virtual Textures", LandscapeOverridable))
    TArray<TObjectPtr<URuntimeVirtualTexture>> RuntimeVirtualTextures;
 
    UPROPERTY(VisibleAnywhere, Transient, Category = VirtualTexture)
    bool bSetCreateRuntimeVirtualTextureVolumes;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category = VirtualTexture, meta = (LandscapeOverridable))
    bool bVirtualTextureRenderWithQuad = false;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category = VirtualTexture, meta = (DisplayName = "High Quality PerPixel Height", EditCondition = "bVirtualTextureRenderWithQuad", LandscapeOverridable))
    bool bVirtualTextureRenderWithQuadHQ = true;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category = VirtualTexture, meta = (DisplayName = "Virtual Texture Num LODs", EditCondition = "!bVirtualTextureRenderWithQuad", UIMin = "0", UIMax = "7", LandscapeOverridable))
    int32 VirtualTextureNumLods = 6;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category = VirtualTexture, meta = (DisplayName = "Virtual Texture LOD Bias", EditCondition = "!bVirtualTextureRenderWithQuad", UIMin = "0", UIMax = "7", LandscapeOverridable))
    int32 VirtualTextureLodBias = 0;
 
    UPROPERTY(EditAnywhere, BlueprintSetter = SetVirtualTextureRenderPassType, Category = VirtualTexture, meta = (DisplayName = "Draw in Main Pass", LandscapeOverridable))
    ERuntimeVirtualTextureMainPassType VirtualTextureRenderPassType = ERuntimeVirtualTextureMainPassType::Always;
 
    UFUNCTION(BlueprintSetter)
    void SetVirtualTextureRenderPassType(ERuntimeVirtualTextureMainPassType InType);
 
    UPROPERTY(EditAnywhere, Category=Landscape, meta = (LandscapeOverridable))
    float NegativeZBoundsExtension;
 
    UPROPERTY(EditAnywhere, Category=Landscape, meta = (LandscapeOverridable))
    float PositiveZBoundsExtension;
 
    UPROPERTY()
    TArray<TObjectPtr<ULandscapeComponent>> LandscapeComponents;
 
    UPROPERTY()
    TArray<TObjectPtr<ULandscapeHeightfieldCollisionComponent>> CollisionComponents;
 
    UPROPERTY(transient, duplicatetransient)
    TArray<TObjectPtr<UHierarchicalInstancedStaticMeshComponent>> FoliageComponents;
 
    UE_DEPRECATED(all, "NaniteComponent has been deprecated, use NaniteComponents instead.")
    UPROPERTY()
    TObjectPtr<ULandscapeNaniteComponent> NaniteComponent_DEPRECATED;
 
    UPROPERTY(NonTransactional, TextExportTransient, NonPIEDuplicateTransient)
    TArray<TObjectPtr<ULandscapeNaniteComponent>> NaniteComponents;
 
    FCachedLandscapeFoliage FoliageCache;
    TArray<FAsyncTask<FAsyncGrassTask>* > AsyncFoliageTasks;
    uint32 FrameOffsetForTickInterval;
 
    // Only used outside of the editor (e.g. in cooked builds) - this value is no longer authoritative TODO [chris.tchou] remove
    // Cached grass max discard distance for all grass types in all landscape components with landscape grass configured
    UPROPERTY()
    float GrassTypesMaxDiscardDistance = 0.0f;
 
    // Non-serialized runtime cache of values derived from the assigned grass types.
    // Call ALandscapeProxy::UpdateGrassTypeSummary() to update.
    struct FGrassTypeSummary
    {
        // Used to track validity of these values, as it automatically invalidates if you add or remove a component.
        // If you do both add AND remove, then the add should also trigger UpdateGrassTypes() which will invalidate this cache.
        // Negative is the invalid state.
        int32 LandscapeComponentCount = -1;
 
        bool bHasAnyGrass = true;
        double MaxInstanceDiscardDistance = DBL_MAX;
    };
    FGrassTypeSummary GrassTypeSummary;
    inline bool IsGrassTypeSummaryValid() { return LandscapeComponents.Num() == GrassTypeSummary.LandscapeComponentCount; }
    inline void InvalidateGrassTypeSummary() { GrassTypeSummary.LandscapeComponentCount = -1; }
    void UpdateGrassTypeSummary();
 
    inline bool GetDisableRuntimeGrassMapGeneration() { return bDisableRuntimeGrassMapGeneration; }
    inline void SetDisableRuntimeGrassMapGenerationProxyOnly(bool bInDisableRuntimeGrassMapGeneration) { bDisableRuntimeGrassMapGeneration = bInDisableRuntimeGrassMapGeneration; }
 
    UPROPERTY(EditAnywhere, Category=Lighting, meta = (LandscapeOverridable))
    float StaticLightingResolution;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Lighting, meta = (LandscapeOverridable))
    uint8 CastShadow : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Lighting, AdvancedDisplay, meta = (EditCondition = "CastShadow", DisplayName = "Dynamic Shadow", LandscapeOverridable))
    uint8 bCastDynamicShadow : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Lighting, AdvancedDisplay, meta = (EditCondition = "CastShadow", DisplayName = "Static Shadow", LandscapeOverridable))
    uint8 bCastStaticShadow : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Lighting, AdvancedDisplay, meta=(EditCondition="CastShadow", LandscapeOverridable))
    EShadowCacheInvalidationBehavior ShadowCacheInvalidationBehavior;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Lighting, AdvancedDisplay, meta = (EditCondition = "CastShadow", DisplayName = "Contact Shadow", LandscapeOverridable))
    uint8 bCastContactShadow : 1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category = Lighting, meta = (EditCondition = "CastShadow", DisplayName = "Far Shadow", LandscapeOverridable))
    uint32 bCastFarShadow : 1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category = Lighting, meta = (EditCondition = "CastShadow", DisplayName = "Hidden Shadow", LandscapeOverridable))
    uint8 bCastHiddenShadow : 1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category = Lighting, meta = (EditCondition = "CastShadow", DisplayName = "Shadow Two Sided", LandscapeOverridable))
    uint32 bCastShadowAsTwoSided : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Lighting, AdvancedDisplay, meta = (EditCondition = "CastShadow", LandscapeOverridable))
    uint8 bAffectDistanceFieldLighting:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=Lighting, AdvancedDisplay, meta=(LandscapeOverridable), Interp)
    uint8 bAffectDynamicIndirectLighting:1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category=Lighting, meta=(EditCondition="bAffectDynamicIndirectLighting", DisplayName = "Affect Indirect Lighting While Hidden", LandscapeOverridable), Interp)
    uint8 bAffectIndirectLightingWhileHidden:1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category = Lighting, meta = (LandscapeOverridable))
    FLightingChannels LightingChannels;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, Category = Lighting, meta = (LandscapeInherited))
    uint32 bUseMaterialPositionOffsetInStaticLighting:1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, Category = Lighting, meta = (LandscapeOverridable))
    float NonNaniteVirtualShadowMapConstantDepthBias = 150.0f;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, Category = Lighting, meta = (LandscapeOverridable, UIMin = 0.0, ClampMin = 0.0))
    float NonNaniteVirtualShadowMapInvalidationHeightErrorThreshold = 250.0f;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, Category = Lighting, meta = (LandscapeOverridable, ClampMin = "0.0", ClampMax = "10.0", UIMin = "0.0", UIMax = "10.0"))
    float NonNaniteVirtualShadowMapInvalidationScreenSizeLimit = 0.2f;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, Category = Rendering, meta=(LandscapeOverridable), Interp)
    uint8 bHoldout : 1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category = Rendering, meta=(DisplayName = "Render CustomDepth Pass", LandscapeOverridable))
    uint32 bRenderCustomDepth:1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category = Rendering, meta = (editcondition = "bRenderCustomDepth", LandscapeOverridable))
    ERendererStencilMask CustomDepthStencilWriteMask;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category=Rendering,  meta=(UIMin = "0", UIMax = "255", editcondition = "bRenderCustomDepth", DisplayName = "CustomDepth Stencil Value", LandscapeOverridable))
    int32 CustomDepthStencilValue;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category=Rendering, meta = (DisplayName = "Desired Max Draw Distance", LandscapeOverridable))
    float LDMaxDrawDistance;
 
    UPROPERTY(EditAnywhere, Category=Lightmass, meta = (LandscapeInherited))
    FLightmassPrimitiveSettings LightmassSettings;
 
    // Landscape LOD to use for collision tests. Higher numbers use less memory and process faster, but are much less accurate
    UPROPERTY(EditAnywhere, Category=Collision, meta = (LandscapeOverridable))
    int32 CollisionMipLevel;
 
    // If set higher than the "Collision Mip Level", this specifies the Landscape LOD to use for "simple collision" tests, otherwise the "Collision Mip Level" is used for both simple and complex collision.
    UPROPERTY(EditAnywhere, Category=Collision, meta = (LandscapeOverridable))
    int32 SimpleCollisionMipLevel;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Collision, meta = (LandscapeOverridable))
    FBodyInstance BodyInstance;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Collision, meta = (LandscapeOverridable))
    uint32 bGenerateOverlapEvents : 1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, Category=Collision, meta = (LandscapeInherited))
    uint32 bBakeMaterialPositionOffsetIntoCollision:1;
 
#if WITH_EDITORONLY_DATA
    UE_DEPRECATED(all, "TargetLayers will be used instead")
    UPROPERTY()
    TArray<TObjectPtr<ULandscapeLayerInfoObject>> EditorCachedLayerInfos_DEPRECATED;
 
    UPROPERTY()
    FString ReimportHeightmapFilePath;
 
    UPROPERTY()
    FGuid ReimportDestinationLayerGuid;
 
PRAGMA_DISABLE_DEPRECATION_WARNINGS
    UE_DEPRECATED(all, "TargetLayers will be used instead")
    UPROPERTY()
    TArray<FLandscapeEditorLayerSettings> EditorLayerSettings_DEPRECATED;
PRAGMA_ENABLE_DEPRECATION_WARNINGS
    
    TMap<UTexture2D*, FLandscapeEditLayerReadback*> HeightmapsCPUReadback;
    TMap<UTexture2D*, FLandscapeEditLayerReadback*> WeightmapsCPUReadback;
 
    UPROPERTY(Transient, NonTransactional)
    TMap<TObjectPtr<UTexture2D>, TObjectPtr<ULandscapeWeightmapUsage>> WeightmapUsageMap;
 
    uint32 CurrentVersion = 1;
    uint32 WeightmapFixupVersion = 0;
    uint32 RegistrationCount = 0;
 
    bool bIsRegisteredWithLandscapeInfo : 1 = false;
 
    bool bNeedsWeightmapUsagesUpdate : 1 = false;
 
    bool bTemporarilyDisableWeightmapUsagesValidation : 1 = false;
#endif // WITH_EDITORONLY_DATA
 
    bool bIsLandscapeActorRegisteredWithLandscapeInfo : 1 = false;
 
    bool bIsRegisteredWithSubsystem : 1 = false;
 
    UPROPERTY(Transient, DuplicateTransient, NonTransactional, SkipSerialization)
    TObjectPtr<ULandscapeSubsystem> RegisteredToSubsystem;
 
    UPROPERTY(meta = (LandscapeInherited))
    int32 ComponentSizeQuads;    // Total number of quads in each component
 
    UPROPERTY(meta = (LandscapeInherited))
    int32 SubsectionSizeQuads;    // Number of quads for a subsection of a component. SubsectionSizeQuads+1 must be a power of two.
 
    UPROPERTY(meta = (LandscapeInherited))
    int32 NumSubsections;    // Number of subsections in X and Y axis
 
    UPROPERTY(EditAnywhere, Category=Navigation, meta = (LandscapeOverridable))
    uint32 bUsedForNavigation:1;
 
    UPROPERTY(EditAnywhere, Category = Navigation, meta = (LandscapeOverridable))
    uint32 bFillCollisionUnderLandscapeForNavmesh:1;
 
    UPROPERTY(EditAnywhere, Category = Navigation, AdvancedDisplay, meta = (LandscapeOverridable))
    ENavDataGatheringMode NavigationGeometryGatheringMode;
 
    UPROPERTY(EditAnywhere, Category = Landscape, meta = (LandscapeOverridable))
    bool bUseDynamicMaterialInstance;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY(EditAnywhere, Category=Landscape, meta = (LandscapeOverridable))
    int32 MaxPaintedLayersPerComponent; // 0 = disabled
#endif // WITH_EDITORONLY_DATA
 
    UPROPERTY(EditAnywhere, Category = HLOD, meta = (LandscapeOverridable))
    bool bUseLandscapeForCullingInvisibleHLODVertices;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY(EditAnywhere, Category = HLOD, meta = (DisplayName = "HLOD Texture Size Policy", LandscapeOverridable, EditCondition = "HLODMaterialOverride == nullptr"))
    ELandscapeHLODTextureSizePolicy HLODTextureSizePolicy;
 
    UPROPERTY(EditAnywhere, Category = HLOD, meta = (DisplayName = "HLOD Texture Size", LandscapeOverridable, EditCondition = "HLODMaterialOverride == nullptr && HLODTextureSizePolicy == ELandscapeHLODTextureSizePolicy::SpecificSize", ClampMin = "16", ClampMax = "8192"))
    int32 HLODTextureSize;
 
    UPROPERTY(EditAnywhere, Category = HLOD, meta = (DisplayName = "HLOD Material Override", LandscapeOverridable))
    TObjectPtr<UMaterialInterface> HLODMaterialOverride;
 
    UPROPERTY(EditAnywhere, Category = HLOD, meta = (DisplayName = "HLOD Mesh Source LOD Policy", LandscapeOverridable))
    ELandscapeHLODMeshSourceLODPolicy HLODMeshSourceLODPolicy;
 
    UPROPERTY(EditAnywhere, Category = HLOD, meta = (DisplayName = "HLOD Mesh Source LOD", LandscapeOverridable, EditCondition = "HLODMeshSourceLODPolicy == ELandscapeHLODMeshSourceLODPolicy::SpecificLOD", ClampMin = "0"))
    int32 HLODMeshSourceLOD;
#endif
 
    UE_DEPRECATED(5.7, "Non-edit layer landscapes are deprecated, all landscapes use the edit layer system now.")
    UPROPERTY()
    bool bHasLayersContent_DEPRECATED = false;
 
    UE_DEPRECATED(5.7, "Non-edit layer landscapes are deprecated, all landscapes use the edit layer system now.")
    TOptional<bool> HadLayersContentAtPostLoadTime;
 
    UE_DEPRECATED(5.6, "This has been replaced by the per-platform CVar landscape.HeightmapCompressionMode")
    UPROPERTY()
    bool bUseCompressedHeightmapStorage_DEPRECATED = false;
 
    UPROPERTY(EditAnywhere, Category = Landscape, AdvancedDisplay, meta = (LandscapeOverridable))
    bool bStripPhysicsWhenCookedClient = false;
 
    UPROPERTY(EditAnywhere, Category = Landscape, AdvancedDisplay, meta = (LandscapeOverridable))
    bool bStripPhysicsWhenCookedServer = false;
 
    UPROPERTY(EditAnywhere, Category = Landscape, AdvancedDisplay, meta = (LandscapeOverridable))
    bool bStripGrassWhenCookedClient = false;
 
    UPROPERTY(EditAnywhere, Category = Landscape, AdvancedDisplay, meta = (LandscapeOverridable))
    bool bStripGrassWhenCookedServer = false;
 
#if WITH_EDITOR
    LANDSCAPE_API static ULandscapeLayerInfoObject* VisibilityLayer;
 
    UE_DEPRECATED(5.6, "Use ULandscapeSubsystem::OnLandscapeProxyComponentDataChanged")
    FOnLandscapeProxyComponentDataChanged OnComponentDataChanged;
#endif // WITH_EDITOR
 
#if WITH_EDITORONLY_DATA
    TMap<FString, TObjectPtr<UMaterialInstanceConstant>> MaterialInstanceConstantMap;
#endif // WITH_EDITORONLY_DATA
 
    // Blueprint functions
 
    UFUNCTION(BlueprintCallable, Category = "Rendering", meta=(DeprecatedFunction, DeprecationMessage = "This value can't be changed anymore, you should edit the property LODDistributionSetting of the Landscape"))
    virtual void ChangeLODDistanceFactor(float InLODDistanceFactor);
 
    UFUNCTION(BlueprintCallable, Category = "Rendering", meta = (DeprecatedFunction, DeprecationMessage = "This value can't be changed anymore and has been ineffective for several versions now. Please stop using it"))
    virtual void ChangeComponentScreenSizeToUseSubSections(float InComponentScreenSizeToUseSubSections);
 
    /* Setter for LandscapeMaterial. Has no effect outside the editor. */
    UFUNCTION(BlueprintSetter)
    void EditorSetLandscapeMaterial(UMaterialInterface* NewLandscapeMaterial);
 
    // Editor-time blueprint functions
 
    UFUNCTION(BlueprintCallable, Category = "Landscape|Editor")
    LANDSCAPE_API void EditorApplySpline(USplineComponent* InSplineComponent, float StartWidth = 200, float EndWidth = 200, float StartSideFalloff = 200, float EndSideFalloff = 200, float StartRoll = 0, float EndRoll = 0, int32 NumSubdivisions = 20, bool bRaiseHeights = true, bool bLowerHeights = true, ULandscapeLayerInfoObject* PaintLayer = nullptr, FName EditLayerName = TEXT(""));
 
    UFUNCTION(BlueprintCallable, Category = "Landscape|Runtime|Material")
    LANDSCAPE_API void SetLandscapeMaterialTextureParameterValue(FName ParameterName, class UTexture* Value);
 
    UFUNCTION(BlueprintCallable, meta = (Keywords = "SetColorParameterValue"), Category = "Landscape|Runtime|Material")
    LANDSCAPE_API void SetLandscapeMaterialVectorParameterValue(FName ParameterName, FLinearColor Value);
 
    UFUNCTION(BlueprintCallable, meta = (Keywords = "SetFloatParameterValue"), Category = "Landscape|Runtime|Material")
    LANDSCAPE_API void SetLandscapeMaterialScalarParameterValue(FName ParameterName, float Value);
 
    // End blueprint functions
 
    //~ Begin AActor Interface
    virtual void PostRegisterAllComponents() override;
    virtual void UnregisterAllComponents(bool bForReregister = false) override;
    virtual bool IsLevelBoundsRelevant() const override { return true; }
 
    virtual void FinishDestroy() override;
 
#if WITH_EDITOR
    virtual void RerunConstructionScripts() override {}
    virtual void Destroyed() override;
    virtual void EditorApplyScale(const FVector& DeltaScale, const FVector* PivotLocation, bool bAltDown, bool bShiftDown, bool bCtrlDown) override;
    virtual void EditorApplyMirror(const FVector& MirrorScale, const FVector& PivotLocation) override;
    virtual void PostEditMove(bool bFinished) override;
    virtual void OnLoadedActorRemovedFromLevel() override;
    //~ End AActor Interface
 
    virtual uint32 GetDefaultGridSize(UWorld* InWorld) const override { return 1; }
    virtual FGuid GetGridGuid() const override { return LandscapeGuid; }
    virtual TUniquePtr<class FWorldPartitionActorDesc> CreateClassActorDesc() const override;
    virtual bool EditorCanAttachTo(const AActor* InParent, FText& OutReason) const override { return false; }
    virtual bool GetReferencedContentObjects(TArray<UObject*>& Objects) const override;
    virtual bool IsNaniteEnabled() const { return bEnableNanite; }
    virtual int32 GetNaniteLODIndex() const { return NaniteLODIndex; }
    virtual bool IsNaniteSkirtEnabled() const { return bNaniteSkirtEnabled; }
    virtual float GetNaniteSkirtDepth() const { return NaniteSkirtDepth;  }
    virtual int32 GetNanitePositionPrecision() const { return NanitePositionPrecision; }
    virtual float GetNaniteMaxEdgeLengthFactor() const { return NaniteMaxEdgeLengthFactor; }
    virtual UE::Landscape::EOutdatedDataFlags GetOutdatedDataFlags() const;
 
    void UpdateNaniteSharedPropertiesFromActor();
    void RemoveNaniteComponents();
    void ClearNaniteTransactional();
    static constexpr int32 NaniteComponentMaxSide = 8;
    static constexpr int32 NaniteMaxComponents = NaniteComponentMaxSide * NaniteComponentMaxSide;
    int32 NumNaniteRequiredComponents() const { return FMath::DivideAndRoundUp(LandscapeComponents.Num(), NaniteMaxComponents); }
#endif  //WITH_EDITOR
 
    bool AreNaniteComponentsValid(const FGuid& InProxyContentId) const;
    bool HasNaniteComponents() const { return !NaniteComponents.IsEmpty(); }
    LANDSCAPE_API TSet<FPrimitiveComponentId> GetNanitePrimitiveComponentIds() const;
    FGuid GetNaniteComponentContentId() const;
    bool AuditNaniteMaterials() const;
    void EnableNaniteComponents(bool bInNaniteActive);
 
    LANDSCAPE_API TOptional<float> GetHeightAtLocation(FVector Location, EHeightfieldSource HeightFieldSource = EHeightfieldSource::Complex) const;
    LANDSCAPE_API UPhysicalMaterial* GetPhysicalMaterialAtLocation(FVector Location, EHeightfieldSource HeightFieldSOurce = EHeightfieldSource::Complex) const;
 
    LANDSCAPE_API void GetHeightValues(int32& SizeX, int32& SizeY, TArray<float>& ArrayValue) const;
 
    /* Return the landscape guid, used to identify landscape proxies (and splines) that belong to the same landscape, even across world partitions.
     * Also used as the world partition grid guid.  This value may be modified when the landscape is instanced, to allow multiple instances of the same
     * landscape to exist simultaneously.  If you want the original (uninstanced) value, use GetOriginalLandscapeGuid().
     */
    virtual FGuid GetLandscapeGuid() const override { return LandscapeGuid; }
    void SetLandscapeGuid(const FGuid& Guid, bool bValidateGuid = true)
    {
        // we probably shouldn't be setting the landscape guid on instanced landscapes
        check(!bValidateGuid || (OriginalLandscapeGuid == LandscapeGuid) || !OriginalLandscapeGuid.IsValid());
        LandscapeGuid = Guid;
        OriginalLandscapeGuid = Guid;
    }
 
    LANDSCAPE_API uint32 ComputeLandscapeKey() const;
    LANDSCAPE_API static uint32 ComputeLandscapeKey(const UWorld* World, uint32 InLODGroupKey, FGuid InLandscapeGuid);
 
    /* Return the original landscape guid, before it was modified by instancing.
     * When not instanced, this value is equal to LandscapeGuid.
     */
    const FGuid& GetOriginalLandscapeGuid() const { return OriginalLandscapeGuid; }
 
    void SetLODGroupKeyInternal(uint32 InLODGroupKey);
 
    UFUNCTION(BlueprintCallable, Category = "Landscape|Runtime")
    virtual ALandscape* GetLandscapeActor() PURE_VIRTUAL(GetLandscapeActor, return nullptr;)
    virtual const ALandscape* GetLandscapeActor() const PURE_VIRTUAL(GetLandscapeActor, return nullptr;)
 
    const TArray<FLandscapePerLODMaterialOverride>& GetPerLODOverrideMaterials() const { return PerLODOverrideMaterials; }
    LANDSCAPE_API void SetPerLODOverrideMaterials(const TArray<FLandscapePerLODMaterialOverride>& InValue);
 
    static void SetGrassUpdateInterval(int32 Interval) { GrassUpdateInterval = Interval; }
 
    /* Determine whether we should update dynamic grass instances this update tick */
    FORCEINLINE bool ShouldTickGrass() const
    {
        // don't tick grass if there's no grass to tick
        if (!GrassTypeSummary.bHasAnyGrass)
        {
            return false;
        }
 
        const int32 UpdateInterval = GetGrassUpdateInterval();
        if (UpdateInterval > 1)
        {
            if ((GFrameNumber + FrameOffsetForTickInterval) % uint32(UpdateInterval))
            {
                return false;
            }
        }
 
        return true;
    }
    void ProcessAsyncGrassInstanceTasks(bool bWaitAsyncTasks, bool bForceSync, const TSet<UHierarchicalInstancedStaticMeshComponent*>& StillUsed);
 
    LANDSCAPE_API void FlushGrassComponents(const TSet<ULandscapeComponent*>* OnlyForComponents = nullptr, bool bFlushGrassMaps = true);
 
    LANDSCAPE_API void UpdateGrass(const TArray<FVector>& Cameras, int32& InOutNumComponentsCreated, bool bForceSync = false);
    LANDSCAPE_API void UpdateGrass(const TArray<FVector>& Cameras, bool bForceSync = false);
 
 
    // TODO [jonathan.bard] : Rename to "AddGrassExclusionBox" + no reason for any of this to be static
    LANDSCAPE_API static void AddExclusionBox(FWeakObjectPtr Owner, const FBox& BoxToRemove);
    LANDSCAPE_API static void RemoveExclusionBox(FWeakObjectPtr Owner);
 
    LANDSCAPE_API static void RemoveAllExclusionBoxes();
 
    static void RemoveInvalidExclusionBoxes();
 
    static void DebugDrawExclusionBoxes(const UWorld* World);
 
    /* Invalidate the precomputed grass and baked texture data for the specified components */
    LANDSCAPE_API static void InvalidateGeneratedComponentData(const TSet<ULandscapeComponent*>& Components, bool bInvalidateLightingCache = false);
    LANDSCAPE_API static void InvalidateGeneratedComponentData(const TArray<ULandscapeComponent*>& Components, bool bInvalidateLightingCache = false);
 
    /* Invalidate the precomputed grass and baked texture data on all components */
    LANDSCAPE_API void InvalidateGeneratedComponentData(bool bInvalidateLightingCache = false);
 
    LANDSCAPE_API void UpdateRenderingMethod();
 
#if WITH_EDITOR
    bool UpdatePhysicalMaterialTasks(bool bInShouldMarkDirty = false);
    void UpdatePhysicalMaterialTasksStatus(TSet<ULandscapeComponent*>* OutdatedComponents, int32* OutdatedComponentsCount) const;
 
    void OnFeatureLevelChanged(ERHIFeatureLevel::Type NewFeatureLevel);
 
    FDelegateHandle FeatureLevelChangedDelegateHandle;
 
    FGuid GetNaniteContentId() const;
#endif // WITH_EDITOR
 
    //~ Begin UObject Interface.
#if WITH_EDITOR
    virtual void BeginCacheForCookedPlatformData(const ITargetPlatform* TargetPlatform) override;
    virtual void OnCookEvent(UE::Cook::ECookEvent CookEvent, UE::Cook::FCookEventContext& CookContext) override;
#endif // WITH_EDITOR
 
    virtual void PreSave(FObjectPreSaveContext ObjectSaveContext) override;
    virtual void Serialize(FArchive& Ar) override;
    static void AddReferencedObjects(UObject* InThis, FReferenceCollector& Collector);
    virtual void PostLoad() override;
 
    LANDSCAPE_API ULandscapeInfo* CreateLandscapeInfo(bool bMapCheck = false, bool bUpdateAllAddCollisions = true);
    virtual LANDSCAPE_API ULandscapeInfo* GetLandscapeInfo() const override;
 
    virtual LANDSCAPE_API FTransform LandscapeActorToWorld() const override;
 
    LANDSCAPE_API FBox GetProxyBounds() const;
 
    UFUNCTION(BlueprintCallable, meta = (DisplayName = "Landscape Export Heightmap to RenderTarget", Keywords = "Push Landscape Heightmap to RenderTarget", UnsafeDuringActorConstruction = "true"), Category = Rendering)
    bool LandscapeExportHeightmapToRenderTarget(UTextureRenderTarget2D* InRenderTarget, bool InExportHeightIntoRGChannel = false, bool InExportLandscapeProxies = true);
 
    UE_DEPRECATED(5.7, "Use GetSectionBase instead.")
    LANDSCAPE_API FIntPoint GetSectionBaseOffset() const;
 
    LANDSCAPE_API FIntPoint GetSectionBase() const;
 
    // ILandscapeSplineInterface
    virtual ULandscapeSplinesComponent* GetSplinesComponent() const override { return SplineComponent; }
    LANDSCAPE_API virtual void UpdateSharedProperties(ULandscapeInfo* InLandscapeInfo) override;
    virtual bool IsSplineOwnerValid() const override { return true; }
 
    // Retrieve the screen size at which each LOD should be rendered
    LANDSCAPE_API TArray<float> GetLODScreenSizeArray() const;
 
#if WITH_EDITOR
    // Copy properties from parent Landscape actor
    LANDSCAPE_API void CopySharedProperties(ALandscapeProxy* InLandscape);
 
    LANDSCAPE_API TArray<FName> SynchronizeSharedProperties(ALandscapeProxy* InLandscape);
 
    // Returns true if the property is shared.
    LANDSCAPE_API bool IsSharedProperty(const FName& InPropertyName) const;
 
    // Returns true if the property is shared.
    LANDSCAPE_API bool IsSharedProperty(const FProperty* InProperty) const;
 
    // Returns true if the property is inherited.
    LANDSCAPE_API bool IsPropertyInherited(const FProperty* InProperty) const;
    
    // Returns true if the property is overridable
    LANDSCAPE_API bool IsPropertyOverridable(const FProperty* InProperty) const;
    
    // Returns true if the shared property is overridden by the object.
    virtual bool IsSharedPropertyOverridden(const FName& InPropertyName) const { return false; }
 
    // Modifies the override state of the property given as argument.
    virtual void SetSharedPropertyOverride(const FName& InPropertyName, const bool bIsOverriden) { }
 
    static FOnLandscapeProxyFixupSharedDataDelegate::RegistrationType& OnLandscapeProxyFixupSharedData() { return OnLandscapeProxyFixupSharedDataDelegate; }
#endif // WITH_EDITOR
 
    // Get Landscape Material assigned to this Landscape
    virtual UMaterialInterface* GetLandscapeMaterial(int8 InLODIndex = INDEX_NONE) const;
 
    // Get Hole Landscape Material assigned to this Landscape
    virtual UMaterialInterface* GetLandscapeHoleMaterial() const;
 
#if WITH_EDITOR
    /* Serialize all hashes/guids that record the current state of this proxy */
    void SerializeStateHashes(FArchive& Ar);
 
    void SetSplinesComponent(ULandscapeSplinesComponent* InSplineComponent) { check(!SplineComponent || (SplineComponent == InSplineComponent)); SplineComponent = InSplineComponent; }
 
    virtual bool SupportsForeignSplineMesh() const override { return true; }
 
    LANDSCAPE_API int32 GetOutdatedGrassMapCount() const;
    UE_DEPRECATED(5.6, "InSlowTask was unused, please use the parameterless function")
    void BuildGrassMaps(struct FScopedSlowTask* InSlowTask) { BuildGrassMaps(); }
    LANDSCAPE_API void BuildGrassMaps();
    UE_DEPRECATED(5.6, "InSlowTask was unused, please use the parameterless function")
    void BuildPhysicalMaterial(struct FScopedSlowTask* InSlowTask) { BuildPhysicalMaterial(); }
    LANDSCAPE_API bool BuildPhysicalMaterial();
    LANDSCAPE_API void InvalidatePhysicalMaterial();
    LANDSCAPE_API int32 GetOudatedPhysicalMaterialComponentsCount() const;
    LANDSCAPE_API virtual void CreateSplineComponent() override;
    LANDSCAPE_API virtual void CreateSplineComponent(const FVector& Scale3D) override;
 
    virtual bool CanEditChange(const FProperty* InProperty) const override;
    virtual void PostTransacted(const FTransactionObjectEvent& InTransactionEvent) override;
    virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
    virtual void PostEditImport() override;
    virtual void PostEditUndo() override;
    //~ End UObject Interface
 
    LANDSCAPE_API void InitializeProxyLayersWeightmapUsage();
    void ValidateProxyLayersWeightmapUsage() const;
    void UpdateProxyLayersWeightmapUsage();
    void RequestProxyLayersWeightmapUsageUpdate();
 
    LANDSCAPE_API static const TArray<FName> GetLayersFromMaterial(UMaterialInterface* Material);
    LANDSCAPE_API const TArray<FName> GetLayersFromMaterial() const;
 
    // Get all Layer names used by the materials assigned the proxy and components (Proxy Material, Component, Component LOD Material and Hole Material)
    LANDSCAPE_API TArray<FName> RetrieveTargetLayerNamesFromMaterials() const;
    
    // Query all the LandscapeLayerInfo Objects from the weight layers allocated on this proxy.
    TMap<FName, ULandscapeLayerInfoObject*> RetrieveTargetLayerInfosFromAllocations() const;
 
    UE_DEPRECATED(5.6, "This create function is deprecated. Please use new util UE::Landscape::CreateTargetLayerInfo instead.")
    LANDSCAPE_API static ULandscapeLayerInfoObject* CreateLayerInfo(const TCHAR* InLayerName, const FString& InFilePath, const ULandscapeLayerInfoObject* InTemplate = nullptr);
 
    UE_DEPRECATED(5.6, "This create function is deprecated. Please use new util UE::Landscape::CreateTargetLayerInfo instead.")
    LANDSCAPE_API static ULandscapeLayerInfoObject* CreateLayerInfo(const TCHAR* InLayerName, const ULevel* InLevel, const ULandscapeLayerInfoObject* InTemplate = nullptr);
 
    UE_DEPRECATED(5.6, "This create function is deprecated. Please use new util UE::Landscape::CreateTargetLayerInfo instead.")
    LANDSCAPE_API ULandscapeLayerInfoObject* CreateLayerInfo(const TCHAR* InLayerName, const ULandscapeLayerInfoObject* InTemplate = nullptr);
 
    void FixupWeightmaps();
 
    void RepairInvalidTextures();
 
    // Remove Invalid weightmaps
    LANDSCAPE_API void RemoveInvalidWeightmaps();
 
    // Changed Physical Material
    LANDSCAPE_API void ChangedPhysMaterial();
 
    // Converts shared properties overridden before explicit override, asking the user how to proceed.
    LANDSCAPE_API void UpgradeSharedProperties(ALandscape* InParentLandscape);
 
    // Displays the obsolete edit layers within the LandscapeComponents in a actionable MapCheck log
    // Asks users to copy obsolete layer data or delete for good.
    void DisplayObsoleteEditLayerMapCheck(ALandscape* InParentLandscape);
 
    // Assign only mismatching data and mark proxy package dirty
    LANDSCAPE_API void FixupSharedData(ALandscape* Landscape, bool bMapCheck = false);
 
    UE_DEPRECATED(5.7, "Use SetSectionBase instead.")
    LANDSCAPE_API void SetAbsoluteSectionBase(FIntPoint SectionOffset);
 
    LANDSCAPE_API void SetSectionBase(FIntPoint SectionOffset);
 
    LANDSCAPE_API void RecreateComponentsState();
 
    LANDSCAPE_API void RecreateComponentsRenderState(TFunctionRef<void(ULandscapeComponent*)> Fn);
 
    LANDSCAPE_API void RecreateCollisionComponents();
 
    LANDSCAPE_API void RemoveXYOffsets();
 
    void UpdateNaniteMaterials();
    
    LANDSCAPE_API void UpdateAllComponentMaterialInstances(bool bInInvalidateCombinationMaterials = false);
    LANDSCAPE_API void UpdateAllComponentMaterialInstances(FMaterialUpdateContext& InOutMaterialContext, TArray<class FComponentRecreateRenderStateContext>& InOutRecreateRenderStateContext, bool bInInvalidateCombinationMaterials = false);
 
    UE_DEPRECATED(5.6, "Use UE::Landscape::CreateLandscapeLayerThumbnailMIC")
    LANDSCAPE_API static ULandscapeMaterialInstanceConstant* GetLayerThumbnailMIC(UMaterialInterface* LandscapeMaterial, FName LayerName, UTexture2D* ThumbnailWeightmap, UTexture2D* ThumbnailHeightmap, ALandscapeProxy* Proxy);
 
    LANDSCAPE_API void Import(const FGuid& InGuid, int32 InMinX, int32 InMinY, int32 InMaxX, int32 InMaxY, int32 InNumSubsections, int32 InSubsectionSizeQuads, const TMap<FGuid, TArray<uint16>>& InImportHeightData,
        const TCHAR* const InHeightmapFileName, const TMap<FGuid, TArray<FLandscapeImportLayerInfo>>& InImportMaterialLayerInfos, ELandscapeImportAlphamapType InImportMaterialLayerType,
        const TArrayView<const struct FLandscapeLayer>& InImportLayers);
 
    struct FRawMeshExportParams
    {
        static constexpr int32 MaxUVCount = 6;
 
        enum class EUVMappingType : uint8
        {
            None, 
            //RelativeToBoundsUV, /** Only valid when ExportBounds is set : normalized UVs spanning the export bounds, i.e. (0,0) at the bottom left corner of ExportBounds -> (1,1) at the top right corner of ExportBounds. */
            // TODO [jonathan.bard] : RelativeToComponentsBoundsUV, /** Only valid when ComponentsToExport is set : normalized UVs spanning the ComponentToExport's bounds, i.e. (0,0) at the bottom left corner of those components' lower left component -> (1,1) at the top right corner of those components' upper right component */
            RelativeToProxyBoundsUV, 
            // TODO[jonathan.bard] : RelativeToLandscapeBoundsUV, /** Normalized UVs spanning the entire landscape bounds, i.e. (0,0) at the bottom left corner of the landscape's lower left landscape component -> (1,1) at the top right corner of the landscape's upper right component */
            HeightmapUV,            
            WeightmapUV,            
            TerrainCoordMapping_XY, 
            TerrainCoordMapping_XZ, 
            TerrainCoordMapping_YZ, 
            LightmapUV,             
            Num
        };
 
        struct FUVConfiguration
        {
            LANDSCAPE_API FUVConfiguration();
            LANDSCAPE_API int32 GetNumUVChannelsNeeded() const;
 
        public:
            // Index 0 = UVChannel 0, Index 1 = UVChannel 1... 
            TArray<EUVMappingType> ExportUVMappingTypes; 
        };
 
        enum class EExportCoordinatesType : uint8
        {
            Absolute,
            RelativeToProxy,
            // TODO [jonathan.bard] : RelativeToComponentsBounds,
            // TODO [jonathan.bard] : RelativeToProxyBounds,
            // TODO [jonathan.bard] : RelativeToLandscapeBounds,
        };
 
    public:
        FRawMeshExportParams() = default;
        LANDSCAPE_API const FUVConfiguration& GetUVConfiguration(int32 InComponentIndex) const;
        LANDSCAPE_API const FName& GetMaterialSlotName(int32 InComponentIndex) const;
        LANDSCAPE_API int32 GetNumUVChannelsNeeded() const;
 
    public:
        int32 ExportLOD = INDEX_NONE;
 
        FUVConfiguration UVConfiguration;
 
        EExportCoordinatesType ExportCoordinatesType = EExportCoordinatesType::Absolute;
 
        FName MaterialSlotName = TEXT("LandscapeMat");
 
        TOptional<FBoxSphereBounds> ExportBounds;
 
        TOptional<float> SkirtDepth;
 
        TOptional<TArrayView<ULandscapeComponent*>> ComponentsToExport;
 
        TOptional<TArrayView<FUVConfiguration>> ComponentsUVConfiguration;
 
        TOptional<TArrayView<FName>> ComponentsMaterialSlotName;
    };
 
    LANDSCAPE_API bool ExportToRawMesh(const FRawMeshExportParams& InExportParams, FMeshDescription& OutRawMesh) const;
 
    LANDSCAPE_API TSharedRef<UE::Landscape::Nanite::FAsyncBuildData> MakeAsyncNaniteBuildData(int32 InLODToExport, const TArray<ULandscapeComponent*>& ComponentsToExport) const;
 
    bool ExportToRawMeshDataCopy(const FRawMeshExportParams& InExportParams, FMeshDescription& OutRawMesh, const UE::Landscape::Nanite::FAsyncBuildData& AsyncData) const;
 
    LANDSCAPE_API void CheckGenerateMobilePlatformData(bool bIsCooking, const ITargetPlatform* TargetPlatform);
 
    LANDSCAPE_API bool IsNaniteMeshUpToDate() const;
 
    LANDSCAPE_API void UpdateNaniteRepresentation(const ITargetPlatform* InTargetPlatform);
 
    FGraphEventRef UpdateNaniteRepresentationAsync(const ITargetPlatform* InTargetPlatform);
 
    LANDSCAPE_API void InvalidateNaniteRepresentation(bool bInCheckContentId);
    
    LANDSCAPE_API void InvalidateOrUpdateNaniteRepresentation(bool bInCheckContentId, const ITargetPlatform* InTargetPlatform);
 
    LANDSCAPE_API FIntRect GetBoundingRect() const;
 
    LANDSCAPE_API UTexture2D* CreateLandscapeTexture(int32 InSizeX, int32 InSizeY, TextureGroup InLODGroup, ETextureSourceFormat InFormat, UObject* OptionalOverrideOuter = nullptr, bool bCompress = false, bool bMipChain = true) const;
 
    LANDSCAPE_API UTexture2DArray* CreateLandscapeTextureArray(int32 InSizeX, int32 InSizeY, int32 Slices, TextureGroup InLODGroup, ETextureSourceFormat InFormat, UObject* OptionalOverrideOuter = nullptr);
    
    LANDSCAPE_API UTexture2D* CreateLandscapeToolTexture(int32 InSizeX, int32 InSizeY, TextureGroup InLODGroup, ETextureSourceFormat InFormat) const;
 
    LANDSCAPE_API ULandscapeWeightmapUsage* CreateWeightmapUsage();
 
    LANDSCAPE_API void RemoveOverlappingComponent(ULandscapeComponent* Component);
 
    LANDSCAPE_API static TArray<FLinearColor> SampleRTData(UTextureRenderTarget2D* InRenderTarget, FLinearColor InRect);
 
    UFUNCTION(BlueprintCallable, meta = (DisplayName = "Landscape Import Heightmap from RenderTarget", Keywords = "Push RenderTarget to Landscape Heightmap", UnsafeDuringActorConstruction = "true"), Category = Rendering)
    bool LandscapeImportHeightmapFromRenderTarget(UTextureRenderTarget2D* InRenderTarget, bool InImportHeightFromRGChannel = false, int32 InEditLayerIndex = 0);
 
    UFUNCTION(BlueprintCallable, meta = (DisplayName = "Landscape Import Weightmap from RenderTarget", Keywords = "Push RenderTarget to Landscape Weightmap", UnsafeDuringActorConstruction = "true"), Category = Rendering)
    bool LandscapeImportWeightmapFromRenderTarget(UTextureRenderTarget2D* InRenderTarget, FName InLayerName, int32 InEditLayerIndex = 0);
 
    UE_DEPRECATED(5.7, "Deprecating placeholder function. Not needed after non-edit layer landscape deprecation. ")
    UFUNCTION()
    bool LandscapeExportWeightmapToRenderTarget(UTextureRenderTarget2D* InRenderTarget, FName InLayerName);
 
    DECLARE_EVENT(ALandscape, FLandscapeMaterialChangedDelegate);
    UE_DEPRECATED(5.6, "Use ULandscapeSubsystem::OnLandscapeProxyMaterialChanged")
    FLandscapeMaterialChangedDelegate& OnMaterialChangedDelegate() 
    { 
PRAGMA_DISABLE_DEPRECATION_WARNINGS
        return LandscapeMaterialChangedDelegate; 
PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    UE_DEPRECATED(5.7, "Non-edit layer landscapes are deprecated, all landscapes use the edit layer system now.")
    LANDSCAPE_API virtual bool HasLayersContent() const;
 
    UE_DEPRECATED(5.7, "Non-edit layer landscapes are deprecated, all landscapes use the edit layer system now.")
    LANDSCAPE_API bool CanHaveLayersContent() const;
 
    UE_DEPRECATED(5.7, "Non-edit layer landscapes are deprecated, all landscapes use the edit layer system now.")
    LANDSCAPE_API virtual void UpdateCachedHasLayersContent(bool InCheckComponentDataIntegrity = false);
 
    FAsyncWorkMonitor& GetAsyncWorkMonitor() { return AsyncWorkMonitor; }
 
    UFUNCTION(BlueprintCallable, Category = "Landscape")
    LANDSCAPE_API virtual void DeleteUnusedLayers();
    
    // TargetLayer API Start
    // ---------------------
    
    // Add a TargetLayer with a unique name and no layer object info
    LANDSCAPE_API FLandscapeTargetLayerSettings& AddTargetLayer();
 
    // Add a TargetLayer with the given name or a generated unique name if the given name is invalid
    LANDSCAPE_API FLandscapeTargetLayerSettings& AddTargetLayer(const FName& Name, const FLandscapeTargetLayerSettings& TargetLayerSettings, bool bPostEditChange = true);
 
    // Generate a unique TargetLayer name
    LANDSCAPE_API const FName GenerateUniqueTargetLayerName() const;
 
    // Update a existing Target Layer
    LANDSCAPE_API bool UpdateTargetLayer(const FName& Name, const FLandscapeTargetLayerSettings& TargetLayerSettings, bool bPostEditChange = true);
 
    // Remove Named TargetLayer,
    // Returns true if a layer has been removed.
    LANDSCAPE_API bool RemoveTargetLayer(const FName& Name, bool bPostEditChange = true);
 
    // Query if a TargetLayer exists by Name or by checking the ULandscapeLayerInfoObject in  TargetLayerSettings
    LANDSCAPE_API bool HasTargetLayer(const FName& Name) const;
    LANDSCAPE_API bool HasTargetLayer(const FLandscapeTargetLayerSettings& TargetLayerSettings) const;
    LANDSCAPE_API bool HasTargetLayer(const ULandscapeLayerInfoObject* LayerInfoObject) const;
 
    // All the Target layers 
    LANDSCAPE_API const TMap<FName, FLandscapeTargetLayerSettings>& GetTargetLayers() const;
    LANDSCAPE_API TSet<ULandscapeLayerInfoObject*> GetValidTargetLayerObjects() const;
 
    // TargetLayer API End
    // -------------------
protected:
    friend class ALandscape;
 
    LANDSCAPE_API bool AddLayer(const FGuid& InLayerGuid);
 
    LANDSCAPE_API void DeleteLayer(const FGuid& InLayerGuid);
 
    LANDSCAPE_API bool RemoveObsoleteEditLayers(bool bShowMapCheckWarning);
 
    UE_DEPRECATED(5.7, "Use RemoveObsoleteEditLayers based on ALandscape or use DeleteLayer to directly remove layers")
    LANDSCAPE_API bool RemoveObsoleteLayers(const TSet<FGuid>& InExistingLayers);
 
    // Returns a map of this Proxy's LandscapeComponents obsolete edit layers Guids to Debug Names
    TMap<FGuid, FName> GetObsoleteEditLayersInComponents();
 
    LANDSCAPE_API void InitializeLayerWithEmptyContent(const FGuid& InLayerGuid);
 
    virtual void FixupOverriddenSharedProperties() {}
 
    LANDSCAPE_API virtual TArray<FName> SynchronizeUnmarkedSharedProperties(ALandscapeProxy* InLandscape);
 
protected:
    UE_DEPRECATED(5.6, "Use ULandscapeSubsystem::OnLandscapeProxyComponentDataChanged")
    FLandscapeMaterialChangedDelegate LandscapeMaterialChangedDelegate;
 
    // Used to know if the deprecation of shared properties modified before the enforcement system introduction has been performed on load.
    bool bUpgradeSharedPropertiesPerformed = false;
#endif // WITH_EDITOR
private:
    
    UPROPERTY(Category = "Target Layers", VisibleAnywhere, meta = (NoResetToDefault, LandscapeInherited) )
    TMap<FName, FLandscapeTargetLayerSettings> TargetLayers;
    
    FORCEINLINE int32 GetGrassUpdateInterval() const 
    {
#if WITH_EDITOR
        // When editing landscape, force update interval to be every frame
        if (GLandscapeEditModeActive)
        {
            return 1;
        }
#endif
        return GrassUpdateInterval;
    }
    static int32 GrassUpdateInterval;
 
    FName GenerateUniqueLandscapeTextureName(UObject* InOuter, TextureGroup InLODGroup) const;
 
#if WITH_EDITOR
    void CreateNaniteComponents(int32 NumComponents);
 
    void SetSourceComponentsForNaniteComponents(bool bSetEmptyComponentsOnly = false) const;
 
    void OnLayerInfoObjectDataChanged(const FOnLandscapeLayerInfoDataChangedParams& InParams);
#endif
 
    void PostLoadFixupLandscapeGuidsIfInstanced();
 
#if WITH_EDITOR
    void InstallOrUpdateTextureUserDatas(const ITargetPlatform* TargetPlatform);
#endif // WITH_EDITOR
 
#if WITH_EDITORONLY_DATA
public:
    static const TArray<ALandscapeProxy*>& GetLandscapeProxies() { return LandscapeProxies; }
 
    inline bool HasEditLayersDataOnLoad() const
    {
        return bHasEditLayersOnLoad;
    }
 
private:
    static TArray<ALandscapeProxy*> LandscapeProxies;
    FAsyncWorkMonitor AsyncWorkMonitor;
#endif // WITH_EDITORONLY_DATA
 
    UPROPERTY()
    FIntPoint SectionBase = FIntPoint::ZeroValue;
 
    bool bHasEditLayersOnLoad = false;
 
#if WITH_EDITOR
    static constexpr TCHAR const* LandscapeInheritedTag = TEXT("LandscapeInherited");
    static constexpr TCHAR const* LandscapeOverridableTag = TEXT("LandscapeOverridable");
#endif // WITH_EDITOR
};
 
 
#if WITH_EDITOR
class FLandscapePhysicalMaterialBuilder
{
public:
    LANDSCAPE_API FLandscapePhysicalMaterialBuilder(UWorld* InWorld);
    UE_DEPRECATED(5.6, "Use the function with the EBuildFlags param")
    LANDSCAPE_API void Build();
    LANDSCAPE_API void Build(UE::Landscape::EBuildFlags InBuildFlags);
    UE_DEPRECATED(5.6, "Use the Build function with UE::Landscape::EBuildFlags::ForceRebuild")
    LANDSCAPE_API void Rebuild();
    LANDSCAPE_API int32 GetOudatedPhysicalMaterialComponentsCount();
private:
    UWorld* World;
    int32 OudatedPhysicalMaterialComponentsCount;
};
 
class FLandscapeProxyComponentDataChangedParams
{
public:
    LANDSCAPE_API FLandscapeProxyComponentDataChangedParams(const TSet<ULandscapeComponent*>& InComponents);
    LANDSCAPE_API void ForEachComponent(TFunctionRef<void(const ULandscapeComponent*)> Func) const;
    const TArray<ULandscapeComponent*>& GetComponents() const { return Components; }
 
private:
    TArray<ULandscapeComponent*> Components;
};
 
DEFINE_ACTORDESC_TYPE(ALandscapeProxy, FLandscapeActorDesc);
#endif