LandscapeComponent.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/StaticArray.h"
#include "CoreMinimal.h"
#include "UObject/ObjectMacros.h"
#include "Misc/Guid.h"
#include "Engine/TextureStreamingTypes.h"
#include "Components/PrimitiveComponent.h"
#include "UObject/PerPlatformProperties.h"
#include "LandscapePhysicalMaterial.h"
#include "LandscapeInfo.h"
#include "LandscapeWeightmapUsage.h"
#include "Containers/ArrayView.h"
#include "Engine/StreamableRenderAsset.h"
#include "Engine/Texture2DArray.h"
 
#if UE_ENABLE_INCLUDE_ORDER_DEPRECATED_IN_5_6
#include "Serialization/BulkData.h"
#endif
 
#include "LandscapeComponent.generated.h"
 
class ALandscape;
class ALandscapeProxy;
class FLightingBuildOptions;
class FMaterialUpdateContext;
class FMeshMapBuildData;
class FPrimitiveSceneProxy;
class ITargetPlatform;
class ULandscapeComponent;
class ULandscapeGrassType;
class ULandscapeHeightfieldCollisionComponent;
class ULandscapeInfo;
class ULandscapeLayerInfoObject;
class ULightComponent;
class UMaterialInstanceConstant;
class UMaterialInterface;
class UTexture2D;
struct FConvexVolume;
struct FEngineShowFlags;
struct FLandscapeTextureDataInfo;
struct FStaticLightingPrimitiveInfo;
struct FLandscapeEditDataInterface;
struct FLandscapeMobileRenderData;
class ULandscapeHeightmapTextureEdgeFixup;
struct FLandscapeGroup;
enum class ELandscapeTextureUsage : uint8;
enum class ELandscapeTextureType : uint8;
 
//
// FLandscapeEditToolRenderData
//
USTRUCT()
struct FLandscapeEditToolRenderData
{
public:
    GENERATED_USTRUCT_BODY()
 
    enum SelectionType
    {
        ST_NONE = 0,
        ST_COMPONENT = 1,
        ST_REGION = 2,
        // = 4...
    };
 
    FLandscapeEditToolRenderData()
        : ToolMaterial(NULL),
        GizmoMaterial(NULL),
        SelectedType(ST_NONE),
        DebugChannelR(INDEX_NONE),
        DebugChannelG(INDEX_NONE),
        DebugChannelB(INDEX_NONE),
        DataTexture(NULL),
        LayerContributionTexture(NULL),
        DirtyTexture(NULL)
    {}
 
    // Material used to render the tool.
    UPROPERTY(NonTransactional)
    TObjectPtr<UMaterialInterface> ToolMaterial;
 
    // Material used to render the gizmo selection region...
    UPROPERTY(NonTransactional)
    TObjectPtr<UMaterialInterface> GizmoMaterial;
 
    // Component is selected
    UPROPERTY(NonTransactional)
    int32 SelectedType;
 
    UPROPERTY(NonTransactional)
    int32 DebugChannelR;
 
    UPROPERTY(NonTransactional)
    int32 DebugChannelG;
 
    UPROPERTY(NonTransactional)
    int32 DebugChannelB;
 
    UPROPERTY(NonTransactional)
    TObjectPtr<UTexture2D> DataTexture; // Data texture other than height/weight
 
    UPROPERTY(NonTransactional)
    TObjectPtr<UTexture2D> LayerContributionTexture; // Data texture used to represent layer contribution
 
    UPROPERTY(NonTransactional)
    TObjectPtr<UTexture2D> DirtyTexture; // Data texture used to represent layer blend dirtied area
 
#if WITH_EDITOR
    void UpdateDebugColorMaterial(const ULandscapeComponent* const Component);
    void UpdateSelectionMaterial(int32 InSelectedType, const ULandscapeComponent* const Component);
#endif
};
 
/* Used to uniquely reference a landscape vertex in a component. */
struct FLandscapeVertexRef
{
    FLandscapeVertexRef(int16 InX, int16 InY, int8 InSubX, int8 InSubY)
        : X(InX)
        , Y(InY)
        , SubX(InSubX)
        , SubY(InSubY)
    {}
 
    uint32 X : 8;
    uint32 Y : 8;
    uint32 SubX : 8;
    uint32 SubY : 8;
 
    static int32 GetVertexIndex(FLandscapeVertexRef Vert, int32 SubsectionCount, int32 SubsectionVerts)
    {
        return (Vert.SubY * SubsectionVerts + Vert.Y) * SubsectionVerts * SubsectionCount + Vert.SubX * SubsectionVerts + Vert.X;
    }
};
 
USTRUCT()
struct FWeightmapLayerAllocationInfo
{
    GENERATED_USTRUCT_BODY()
 
    UPROPERTY()
    TObjectPtr<ULandscapeLayerInfoObject> LayerInfo;
 
    UPROPERTY()
    uint8 WeightmapTextureIndex;
 
    UPROPERTY()
    uint8 WeightmapTextureChannel;
 
    FWeightmapLayerAllocationInfo()
        : LayerInfo(nullptr)
        , WeightmapTextureIndex(0)
        , WeightmapTextureChannel(0)
    {
    }
 
 
    FWeightmapLayerAllocationInfo(ULandscapeLayerInfoObject* InLayerInfo)
        :   LayerInfo(InLayerInfo)
        ,   WeightmapTextureIndex(255)  // Indicates an invalid allocation
        ,   WeightmapTextureChannel(255)
    {
    }
    
    bool operator == (const FWeightmapLayerAllocationInfo& RHS) const
    {
        return (LayerInfo == RHS.LayerInfo)
            && (WeightmapTextureIndex == RHS.WeightmapTextureIndex)
            && (WeightmapTextureChannel == RHS.WeightmapTextureChannel); 
    }
 
    FName GetLayerName() const;
 
    uint32 GetHash() const;
 
    void Free()
    {
        WeightmapTextureChannel = 255;
        WeightmapTextureIndex = 255;
    }
 
    bool IsAllocated() const { return (WeightmapTextureChannel != 255 && WeightmapTextureIndex != 255); }
};
 
inline uint32 GetTypeHash(const FWeightmapLayerAllocationInfo& InAllocInfo)
{
    return InAllocInfo.GetHash();
}
 
template<typename T>
struct IBuffer2DView
{
    // copy up to Count elements to Dest, in X then Y order (standard image order)
    virtual void CopyTo(T* Dest, int32 Count) const = 0;
 
    // copy up to Count elements to Dest, in X then Y order (standard image order)
    virtual bool CopyToAndCalcIsAllZero(T* Dest, int32 Count) const = 0;
 
    // return the total number of elements
    virtual int32 Num() const = 0;
};
 
struct FLandscapeComponentGrassData
{
#if WITH_EDITORONLY_DATA
    // Variables used to detect when grass data needs to be regenerated:
 
    // Guid per material instance in the hierarchy between the assigned landscape material (instance) and the root UMaterial
    // used to detect changes to material instance parameters or the root material that could affect the grass maps
    UE_DEPRECATED(all, "GenerationHash is now used") 
    TArray<FGuid, TInlineAllocator<2>> MaterialStateIds_DEPRECATED;
    // cached component rotation when material world-position-offset is used,
    // as this will affect the direction of world-position-offset deformation (included in the HeightData below)
    UE_DEPRECATED(all, "GenerationHash is now used") 
    FQuat RotationForWPO_DEPRECATED;
 
    // Variable used to detect when grass data needs to be regenerated:
    uint32 GenerationHash = 0;
#endif
 
#if WITH_EDITORONLY_DATA
    // Height data for LODs 1+, keyed on LOD index
    TMap<int32, TArray<uint16>> HeightMipData;
#endif // WITH_EDITORONLY_DATA
    
    static constexpr int32 UnknownNumElements = -1;
    // Elements per contiguous array: for validation and also to indicate whether the grass data is valid (NumElements >= 0, meaning 0 elements is valid but the grass data is all zero and 
    //  therefore empty) or not known yet (== UnknownNumElements)
    int32 NumElements = UnknownNumElements;
    // Serialized in one block to prevent Slack waste
    TMap<TObjectPtr<ULandscapeGrassType>, int32> WeightOffsets;
    TArray<uint8> HeightWeightData;
 
    // Note: We need to explicitly disable warnings on these constructors/operators for clang to be happy with deprecated variables
    PRAGMA_DISABLE_DEPRECATION_WARNINGS
    FLandscapeComponentGrassData() = default;
    FLandscapeComponentGrassData(ULandscapeComponent* Component);
    ~FLandscapeComponentGrassData() = default;
    FLandscapeComponentGrassData(const FLandscapeComponentGrassData&) = default;
    FLandscapeComponentGrassData(FLandscapeComponentGrassData&&) = default;
    FLandscapeComponentGrassData& operator=(const FLandscapeComponentGrassData&) = default;
    FLandscapeComponentGrassData& operator=(FLandscapeComponentGrassData&&) = default;
    PRAGMA_ENABLE_DEPRECATION_WARNINGS
 
    // Returns whether grass data has been computed (or serialized) yet. Returns true even if the data is completely empty (e.g. all-zero weightmap data)
    bool HasValidData() const;
 
    // Returns whether the data is completely empty (e.g. all-zero weightmap data). Returns false if the data just wasn't computed yet :
    bool HasData() const;
 
    void InitializeFrom(const TArray<uint16>& HeightData, const TMap<ULandscapeGrassType*, TArray<uint8>>& WeightData);
    void InitializeFrom(IBuffer2DView<uint16>* HeightData, TMap<ULandscapeGrassType*, IBuffer2DView<uint8>*>& WeightData, bool bStripEmptyWeights);
 
    bool HasWeightData() const;
    TArrayView<uint8> GetWeightData(const ULandscapeGrassType* GrassType);
    bool Contains(ULandscapeGrassType* GrassType) const;
    TArrayView<uint16> GetHeightData();
 
    SIZE_T GetAllocatedSize() const;
 
    // Check whether we can discard any data not needed with current scalability settings
    void ConditionalDiscardDataOnLoad();
 
    friend FArchive& operator<<(FArchive& Ar, FLandscapeComponentGrassData& Data);
};
 
USTRUCT(NotBlueprintable, meta = (Deprecated = "5.1"))
struct UE_DEPRECATED(all, "FLandscapeComponentMaterialOverride is deprecated; please use FLandscapePerLODMaterialOverride instead") FLandscapeComponentMaterialOverride
{
    GENERATED_USTRUCT_BODY()
 
    UPROPERTY(EditAnywhere, Category = LandscapeComponent, meta=(UIMin=0, UIMax=8, ClampMin=0, ClampMax=8))
    FPerPlatformInt LODIndex;
 
    UPROPERTY(EditAnywhere, Category = LandscapeComponent)
    TObjectPtr<UMaterialInterface> Material = nullptr;
};
 
USTRUCT(NotBlueprintable)
struct FLandscapePerLODMaterialOverride
{
    GENERATED_USTRUCT_BODY()
 
    UPROPERTY(EditAnywhere, Category = Material, meta = (UIMin = 0, UIMax = 8, ClampMin = 0, ClampMax = 8))
    int32 LODIndex = 0;
 
    UPROPERTY(EditAnywhere, Category = Material)
    TObjectPtr<UMaterialInterface> Material = nullptr;
 
    bool operator == (const FLandscapePerLODMaterialOverride & InOther) const
    {
        return (LODIndex == InOther.LODIndex)
            && (Material == InOther.Material);
    }
};
 
USTRUCT(NotBlueprintable)
struct FWeightmapData
{
    GENERATED_USTRUCT_BODY()
 
    UPROPERTY()
    TArray<TObjectPtr<UTexture2D>> Textures;
    
    UPROPERTY()
    TArray<FWeightmapLayerAllocationInfo> LayerAllocations;
 
    UPROPERTY(Transient, NonTransactional)
    TArray<TObjectPtr<ULandscapeWeightmapUsage>> TextureUsages;
};
 
USTRUCT(NotBlueprintable)
struct FHeightmapData
{
    GENERATED_USTRUCT_BODY()
 
    UPROPERTY()
    TObjectPtr<UTexture2D> Texture = nullptr;
};
 
USTRUCT(NotBlueprintable)
struct FLandscapeLayerComponentData
{
    GENERATED_USTRUCT_BODY()
 
    FLandscapeLayerComponentData() = default;
 
#if WITH_EDITOR
    FLandscapeLayerComponentData(const FName& InDebugName)
        : DebugName(InDebugName)
    {}
 
#endif // WITH_EDITOR
 
#if WITH_EDITORONLY_DATA
    // Edit layers are referenced by Guid, this name is just there to provide some insights as to what edit layer name this layer data corresponded to in case of a missing edit layer guid
    UPROPERTY()
    FName DebugName; 
#endif // WITH_EDITORONLY_DATA
 
    UPROPERTY()
    FHeightmapData HeightmapData;
 
    UPROPERTY()
    FWeightmapData WeightmapData;
 
    bool IsInitialized() const { return HeightmapData.Texture != nullptr || WeightmapData.Textures.Num() > 0;  }
};
 
#if WITH_EDITOR
enum ELandscapeComponentUpdateFlag : uint32
{
    // Will call UpdateCollisionHeightData, UpdateCacheBounds, UpdateComponentToWorld on Component
    Component_Update_Heightmap_Collision = 1 << 0,
    // Will call UdateCollisionLayerData on Component
    Component_Update_Weightmap_Collision = 1 << 1,
    // Will call RecreateCollision on Component
    Component_Update_Recreate_Collision = 1 << 2,
    // Will update Component clients: Navigation data, Foliage, Grass, etc.
    Component_Update_Client = 1 << 3,
    // Will update Component clients while editing
    Component_Update_Client_Editing = 1 << 4,
    // Will compute component approximated bounds
    Component_Update_Approximated_Bounds = 1 << 5
};
 
enum ELandscapeLayerUpdateMode : uint32
{ 
    // No Update
    Update_None = 0,
    // Update types
    Update_Heightmap_All = 1 << 0,
    Update_Heightmap_Editing = 1 << 1,
    Update_Heightmap_Editing_NoCollision = 1 << 2,
    Update_Weightmap_All = 1 << 3,
    Update_Weightmap_Editing = 1 << 4,
    Update_Weightmap_Editing_NoCollision = 1 << 5,
    // Combinations
    Update_All = Update_Weightmap_All | Update_Heightmap_All,
    Update_All_Editing = Update_Weightmap_Editing | Update_Heightmap_Editing,
    Update_All_Editing_NoCollision = Update_Weightmap_Editing_NoCollision | Update_Heightmap_Editing_NoCollision,
    Update_Heightmap_Types = Update_Heightmap_All | Update_Heightmap_Editing | Update_Heightmap_Editing_NoCollision,
    Update_Weightmap_Types = Update_Weightmap_All | Update_Weightmap_Editing | Update_Weightmap_Editing_NoCollision,
    // In cases where we couldn't update the clients right away this flag will be set in RegenerateLayersContent
    Update_Client_Deferred = 1 << 6,
    // Update landscape component clients while editing
    Update_Client_Editing = 1 << 7
};
 
static const uint32 DefaultSplineHash = 0xFFFFFFFF;
 
#endif
 
UENUM()
enum UE_DEPRECATED(5.7, "Use ELandscapeToolTargetTypeFlags instead.") ELandscapeClearMode : int
{
    Clear_Weightmap = 1 << 0 UMETA(DisplayName = "Paint"),
    Clear_Heightmap = 1 << 1 UMETA(DisplayName = "Sculpt"),
    Clear_All = Clear_Weightmap | Clear_Heightmap UMETA(DisplayName = "All")
};
 
UCLASS(MinimalAPI)
class ULandscapeLODStreamingProxy_DEPRECATED : public UStreamableRenderAsset
{
    GENERATED_UCLASS_BODY()
};
 
UCLASS(hidecategories=(Display, Attachment, Physics, Debug, Collision, Movement, Rendering, PrimitiveComponent, Object, Transform, Mobility, VirtualTexture), showcategories=("Rendering|Material"), MinimalAPI, Within=LandscapeProxy)
class ULandscapeComponent : public UPrimitiveComponent
{
    GENERATED_UCLASS_BODY()
    
    
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category=LandscapeComponent)
    int32 SectionBaseX;
 
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category=LandscapeComponent)
    int32 SectionBaseY;
 
    UPROPERTY()
    int32 ComponentSizeQuads;
 
    UPROPERTY()
    int32 SubsectionSizeQuads;
 
    UPROPERTY()
    int32 NumSubsections;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=LandscapeComponent)
    TObjectPtr<UMaterialInterface> OverrideMaterial;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=LandscapeComponent, AdvancedDisplay)
    TObjectPtr<UMaterialInterface> OverrideHoleMaterial;
 
#if WITH_EDITORONLY_DATA
    PRAGMA_DISABLE_DEPRECATION_WARNINGS
    UE_DEPRECATED(all, "OverrideMaterials has been deprecated, use PerLODOverrideMaterials instead.")
    UPROPERTY()
    TArray<FLandscapeComponentMaterialOverride> OverrideMaterials_DEPRECATED;
    PRAGMA_ENABLE_DEPRECATION_WARNINGS
 
    UE_DEPRECATED(all, "MaterialInstance has been deprecated, use MaterialInstances instead.")
    UPROPERTY()
    TObjectPtr<UMaterialInstanceConstant> MaterialInstance_DEPRECATED;
#endif // WITH_EDITORONLY_DATA
 
    UPROPERTY(TextExportTransient)
    TArray<TObjectPtr<UMaterialInstanceConstant>> MaterialInstances;
 
    UPROPERTY(Transient, TextExportTransient)
    TArray<TObjectPtr<UMaterialInstanceDynamic>> MaterialInstancesDynamic;
 
    UPROPERTY(TextExportTransient)
    TArray<int8> LODIndexToMaterialIndex;
 
    UE_DEPRECATED(5.7, "RetopologizeTool/XYOffset deprecated with the removal of non-edit layer landscapes")
    UPROPERTY()
    TObjectPtr<UTexture2D> XYOffsetmapTexture_DEPRECATED;
 
    UPROPERTY()
    FVector4 WeightmapScaleBias;
 
    UPROPERTY()
    float WeightmapSubsectionOffset;
 
    UPROPERTY()
    FVector4 HeightmapScaleBias;
 
    UPROPERTY()
    FBox CachedLocalBox;
 
    UPROPERTY()
    TArray<double> MipToMipMaxDeltas;
 
#if WITH_EDITORONLY_DATA
    UE_DEPRECATED(all, "CollisionComponent has been deprecated")
    UPROPERTY()
    TLazyObjectPtr<ULandscapeHeightfieldCollisionComponent> CollisionComponent_DEPRECATED;
#endif // !WITH_EDITORONLY_DATA
 
private:
    UPROPERTY()
    TObjectPtr<ULandscapeHeightfieldCollisionComponent> CollisionComponentRef;
 
    UPROPERTY(Transient)
    bool bUserTriggeredChangeRequested = false;
    
    UPROPERTY(Transient)
    bool bNaniteActive;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    FGuid LightingGuid;
 
    UPROPERTY()
    TMap<FGuid, FLandscapeLayerComponentData> LayersData;
 
    UPROPERTY(Transient)
    TMap<FGuid, FLandscapeLayerComponentData> ObsoleteEditLayerData;
 
    // Final layer data
    UPROPERTY(Transient)
    TArray<TObjectPtr<ULandscapeWeightmapUsage>> WeightmapTexturesUsage;
 
    UPROPERTY(Transient)
    uint32 LayerUpdateFlagPerMode;
 
    UPROPERTY(Transient)
    bool bPendingCollisionDataUpdate;
 
    UPROPERTY(Transient)
    bool bPendingLayerCollisionDataUpdate;
 
    bool bUndoChangedWeightmapAllocs = false;
 
    // Physical material has been invalidated and no new physical material task has been started since then
    bool bPendingPhysicalMaterialInvalidation = false;
 
    FIntRect LayerDirtyCollisionHeightData;
#endif // WITH_EDITORONLY_DATA
 
    UPROPERTY()
    TObjectPtr<UTexture2D> HeightmapTexture;
 
    UPROPERTY()
    TArray<FWeightmapLayerAllocationInfo> WeightmapLayerAllocations;
 
    UPROPERTY()
    TArray<TObjectPtr<UTexture2D>> WeightmapTextures;
 
    UPROPERTY(EditAnywhere, Category = LandscapeComponent)
    TArray<FLandscapePerLODMaterialOverride> PerLODOverrideMaterials;
 
#if WITH_EDITORONLY_DATA
    uint32 LastLandscapeMaterialAllStateCRCWhenGrassTypesBuilt = 0;
#endif // WITH_EDITORONLY_DATA
 
    UPROPERTY()
    TArray<TObjectPtr<ULandscapeGrassType>> GrassTypes;
 
public:
    // Non-serialized runtime cache of values derived from the assigned grass types.
    // Call ALandscapeProxy::UpdateGrassTypeSummary() to update.
    struct FGrassTypeSummary
    {
        bool bInvalid = true;
        bool bHasAnyGrass = true;
        double MaxInstanceDiscardDistance = DBL_MAX;
    };
    FGrassTypeSummary GrassTypeSummary;
    inline bool IsGrassTypeSummaryValid() { return GrassTypeSummary.bInvalid; }
 
    LANDSCAPE_API void InvalidateGrassTypeSummary();
 
    UPROPERTY()
    FGuid MapBuildDataId;
 
    UPROPERTY(EditAnywhere, Category=LandscapeComponent)
    int32 CollisionMipLevel;
 
    UPROPERTY(EditAnywhere, Category=LandscapeComponent)
    int32 SimpleCollisionMipLevel;
 
    UPROPERTY(EditAnywhere, Category=LandscapeComponent)
    float NegativeZBoundsExtension;
 
    UPROPERTY(EditAnywhere, Category=LandscapeComponent)
    float PositiveZBoundsExtension;
 
    UPROPERTY(EditAnywhere, Category=LandscapeComponent, meta=(ClampMax = 4096))
    float StaticLightingResolution;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=LandscapeComponent)
    int32 ForcedLOD;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=LandscapeComponent)
    int32 LODBias;
 
    UPROPERTY(Transient, DuplicateTransient, NonTransactional)
    TObjectPtr<ULandscapeHeightmapTextureEdgeFixup> RegisteredEdgeFixup;
    FLandscapeGroup* RegisteredLandscapeGroup;
 
#if WITH_EDITORONLY_DATA
    UE_DEPRECATED(all, "IrrelevantLights is officially deprecated now")
    UPROPERTY()
    TArray<FGuid> IrrelevantLights_DEPRECATED;
 
    UPROPERTY(EditAnywhere, Category=LandscapeComponent)
    int32 LightingLODBias;
 
    // List of layers allowed to be painted on this component
    UPROPERTY(EditAnywhere, Category=LandscapeComponent)
    TArray<TObjectPtr<ULandscapeLayerInfoObject>> LayerAllowList;
 
    UPROPERTY(Transient, DuplicateTransient, NonTransactional)
    FLandscapeEditToolRenderData EditToolRenderData;
 
    UPROPERTY(NonPIEDuplicateTransient)
    FGuid MobileDataSourceHash;
 
    UPROPERTY(NonPIEDuplicateTransient)
    TMap<TObjectPtr<UMaterialInterface>, int8> MaterialPerLOD;
 
    uint32 WeightmapsHash;
 
    UPROPERTY()
    uint32 SplineHash;
 
    UPROPERTY()
    uint32 PhysicalMaterialHash;
 
    UPROPERTY(Transient)
    uint32 LastSavedPhysicalMaterialHash;
 
    UE_DEPRECATED(all, "MobileMaterialInterface has been deprecated and will be removed in a future version")
    UPROPERTY(NonPIEDuplicateTransient)
    TObjectPtr<UMaterialInterface> MobileMaterialInterface_DEPRECATED;
 
    UE_DEPRECATED(all, "MobileCombinationMaterialInstance has been deprecated and will be removed in a future version")
    UPROPERTY(NonPIEDuplicateTransient)
    TObjectPtr<UMaterialInstanceConstant> MobileCombinationMaterialInstance_DEPRECATED;
#endif // WITH_EDITORONLY_DATA
 
    UPROPERTY(NonPIEDuplicateTransient)
    TArray<TObjectPtr<UMaterialInterface>> MobileMaterialInterfaces;
 
    UPROPERTY(NonPIEDuplicateTransient)
    TArray<TObjectPtr<UTexture2D>> MobileWeightmapTextures;
 
    UPROPERTY(NonPIEDuplicateTransient)
    TObjectPtr<UTexture2DArray> MobileWeightmapTextureArray;
    
    UPROPERTY()
    TArray<FWeightmapLayerAllocationInfo> MobileWeightmapLayerAllocations;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY(NonPIEDuplicateTransient)
    TArray<TObjectPtr<UMaterialInstanceConstant>> MobileCombinationMaterialInstances;
#endif // WITH_EDITORONLY_DATA
 
public:
    TSharedRef<FLandscapeComponentGrassData, ESPMode::ThreadSafe> GrassData;
    
    // This wrapper is needed to filter out exclude boxes that are completely inside of another exclude box
    struct FExcludeBox
    {
        FBox Box;
 
        FExcludeBox() = default;
        FExcludeBox(const FBox& InBox) : Box(InBox) {}
 
        bool operator==(const FExcludeBox& Other) const
        {
            return Box.IsInsideOrOn(Other.Box);
        }
    };
    TArray<FExcludeBox> ActiveExcludedBoxes;
    uint32 ChangeTag;
 
#if WITH_EDITOR
    FLandscapePhysicalMaterialRenderTask PhysicalMaterialTask;
    uint32 CalculatePhysicalMaterialTaskHash() const;
 
    bool GetRenderPhysicalMaterials(TArray<UPhysicalMaterial*>& OutPhysicalMaterials) const;
#endif // WITH_EDITOR
 
    //~ Begin UObject Interface.    
    virtual void PostInitProperties() override; 
    virtual void Serialize(FArchive& Ar) override;
    virtual void GetResourceSizeEx(FResourceSizeEx& CumulativeResourceSize) override;
    virtual void BeginDestroy() override;
    virtual void PostLoad() override;
#if WITH_EDITORONLY_DATA
    static void DeclareConstructClasses(TArray<FTopLevelAssetPath>& OutConstructClasses, const UClass* SpecificSubclass);
#endif
 
    static void AddReferencedObjects(UObject* InThis, FReferenceCollector& Collector);
 
#if WITH_EDITOR
    virtual void BeginCacheForCookedPlatformData(const ITargetPlatform* TargetPlatform) override;
    virtual void PreEditUndo() override;
    virtual void PostEditUndo() override;
    virtual void PreEditChange(FProperty* PropertyThatWillChange) override;
    virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
    //~ End UObject Interface
 
    LANDSCAPE_API void UpdateEditToolRenderData();
 
    LANDSCAPE_API void FixupWeightmaps();
    LANDSCAPE_API void FixupWeightmaps(const FGuid& InEditLayerGuid);
 
    TArray<UTexture*> RepairInvalidTextures();
 
    // Update layer allow list to include the currently painted layers
    LANDSCAPE_API void UpdateLayerAllowListFromPaintedLayers();
    
    //~ Begin UPrimitiveComponent Interface.
    virtual bool GetLightMapResolution( int32& Width, int32& Height ) const override;
    virtual int32 GetStaticLightMapResolution() const override;
    virtual void GetLightAndShadowMapMemoryUsage( int32& LightMapMemoryUsage, int32& ShadowMapMemoryUsage ) const override;
    virtual void GetStaticLightingInfo(FStaticLightingPrimitiveInfo& OutPrimitiveInfo,const TArray<ULightComponent*>& InRelevantLights,const FLightingBuildOptions& Options) override;
    virtual void AddMapBuildDataGUIDs(TSet<FGuid>& InGUIDs) const override;
#endif
    virtual void GetUsedMaterials(TArray<UMaterialInterface*>& OutMaterials, bool bGetDebugMaterials = false) const override;
    virtual FPrimitiveSceneProxy* CreateSceneProxy() override;
    virtual ELightMapInteractionType GetStaticLightingType() const override;
    virtual void GetStreamingRenderAssetInfo(FStreamingTextureLevelContext& LevelContext, TArray<FStreamingRenderAssetPrimitiveInfo>& OutStreamingRenderAssets) const override;
    virtual bool IsPrecomputedLightingValid() const override;
    virtual void OnUpdateTransform(EUpdateTransformFlags UpdateTransformFlags, ETeleportType TeleportType) override;
 
    virtual TArray<URuntimeVirtualTexture*> const& GetRuntimeVirtualTextures() const override;
    virtual ERuntimeVirtualTextureMainPassType GetVirtualTextureRenderPassType() const override;
 
    // Returns the heightmap for this component. If InReturnEditingHeightmap is passed, returns the currently active edit layer's heightmap : 
    LANDSCAPE_API UTexture2D* GetHeightmap(bool InReturnEditingHeightmap = false) const;
    // Returns the heightmap for this component and the edit layer specified by InLayerGuid. If InLayerGuid is invalid, returns the final (base) heightmap : 
    LANDSCAPE_API UTexture2D* GetHeightmap(const FGuid& InLayerGuid) const;
    LANDSCAPE_API TArray<TObjectPtr<UTexture2D>>& GetWeightmapTextures(bool InReturnEditingWeightmap = false);
    LANDSCAPE_API const TArray<UTexture2D*>& GetWeightmapTextures(bool InReturnEditingWeightmap = false) const;
    LANDSCAPE_API TArray<TObjectPtr<UTexture2D>>& GetWeightmapTextures(const FGuid& InLayerGuid);
    LANDSCAPE_API const TArray<UTexture2D*>& GetWeightmapTextures(const FGuid& InLayerGuid) const;
    LANDSCAPE_API const TArray<UTexture2D*>& GetRenderedWeightmapTexturesForFeatureLevel(ERHIFeatureLevel::Type FeatureLevel) const;
 
    LANDSCAPE_API TArray<FWeightmapLayerAllocationInfo>& GetWeightmapLayerAllocations(bool InReturnEditingWeightmap = false);
    LANDSCAPE_API const TArray<FWeightmapLayerAllocationInfo>& GetWeightmapLayerAllocations(bool InReturnEditingWeightmap = false) const;
    LANDSCAPE_API TArray<FWeightmapLayerAllocationInfo>& GetWeightmapLayerAllocations(const FGuid& InLayerGuid);
    LANDSCAPE_API const TArray<FWeightmapLayerAllocationInfo>& GetWeightmapLayerAllocations(const FGuid& InLayerGuid) const;
 
    LANDSCAPE_API TArray<FWeightmapLayerAllocationInfo>& GetCurrentRuntimeWeightmapLayerAllocations();
    LANDSCAPE_API const TArray<FWeightmapLayerAllocationInfo>& GetCurrentRuntimeWeightmapLayerAllocations() const;
 
    const TArray<FLandscapePerLODMaterialOverride>& GetPerLODOverrideMaterials() const { return PerLODOverrideMaterials; }
    void SetPerLODOverrideMaterials(const TArray<FLandscapePerLODMaterialOverride>& InValue) { PerLODOverrideMaterials = InValue; }
 
    LANDSCAPE_API void SetHeightmap(UTexture2D* NewHeightmap);
    LANDSCAPE_API void SetWeightmapTextures(const TArray<UTexture2D*>& InNewWeightmapTextures, bool InApplyToEditingWeightmap = false);
    void SetWeightmapTexturesInternal(const TArray<UTexture2D*>& InNewWeightmapTextures, const FGuid& InEditLayerGuid);
 
#if WITH_EDITOR
    LANDSCAPE_API void SetWeightmapLayerAllocations(const TArray<FWeightmapLayerAllocationInfo>& InNewWeightmapLayerAllocations);
    LANDSCAPE_API uint32 ComputeLayerHash(bool InReturnEditingHash = true) const;
 
    LANDSCAPE_API void SetWeightmapTexturesUsage(const TArray<ULandscapeWeightmapUsage*>& InNewWeightmapTexturesUsage, bool InApplyToEditingWeightmap = false);
    void SetWeightmapTexturesUsageInternal(const TArray<ULandscapeWeightmapUsage*>& InNewWeightmapTexturesUsage, const FGuid& InEditLayerGuid);
 
    LANDSCAPE_API TArray<TObjectPtr<ULandscapeWeightmapUsage>>& GetWeightmapTexturesUsage(bool InReturnEditingWeightmap = false);
    LANDSCAPE_API const TArray<ULandscapeWeightmapUsage*>& GetWeightmapTexturesUsage(bool InReturnEditingWeightmap = false) const;
    LANDSCAPE_API TArray<TObjectPtr<ULandscapeWeightmapUsage>>& GetWeightmapTexturesUsage(const FGuid& InLayerGuid);
    LANDSCAPE_API const TArray<ULandscapeWeightmapUsage*>& GetWeightmapTexturesUsage(const FGuid& InLayerGuid) const;
    LANDSCAPE_API void InitializeLayersWeightmapUsage(const FGuid& InLayerGuid);
 
    LANDSCAPE_API bool HasLayersData() const;
    LANDSCAPE_API const FLandscapeLayerComponentData* GetLayerData(const FGuid& InLayerGuid) const;
    LANDSCAPE_API FLandscapeLayerComponentData* GetLayerData(const FGuid& InLayerGuid);
 
    void CopyComponentDataToEditLayer(const FGuid& InSourceEditLayerGuid, const FGuid& InDestEditLayerGuid, bool bInUseObsoleteLayerData, TSet<UTexture2D*>& OutProcessedHeightmaps, TSet<UTexture2D*>& OutProcessedWeightmaps);
 
    // Obsolete edit layer helpers
    const TMap<FGuid, FLandscapeLayerComponentData>& GetObsoleteEditLayersData() const;
    const FLandscapeLayerComponentData* GetObsoleteEditLayerData(const FGuid& InLayerGuid) const; 
    void RemoveObsoleteEditLayerData(const FGuid& InLayerGuid);
    void InitializeObsoleteEditLayerData(const TSet<FGuid>& InParentEditLayerGuids);
 
    LANDSCAPE_API void AddLayerData(const FGuid& InLayerGuid, const FLandscapeLayerComponentData& InData);
    LANDSCAPE_API void AddDefaultLayerData(const FGuid& InLayerGuid, const TArray<ULandscapeComponent*>& InComponentsUsingHeightmap, TMap<UTexture2D*, UTexture2D*>& InOutCreatedHeightmapTextures);
    LANDSCAPE_API void RemoveLayerData(const FGuid& InLayerGuid);
    LANDSCAPE_API void ForEachLayer(TFunctionRef<void(const FGuid&, struct FLandscapeLayerComponentData&)> Fn);
 
    FLandscapeLayerComponentData* GetEditingLayer();
    const FLandscapeLayerComponentData* GetEditingLayer() const;
 
    FGuid GetEditingLayerGUID() const;
 
    void SetPendingCollisionDataUpdate(bool bInPendingCollisionDataUpdate) { bPendingCollisionDataUpdate = bInPendingCollisionDataUpdate; }
    bool GetPendingCollisionDataUpdate() const { return bPendingCollisionDataUpdate; }
    void SetPendingLayerCollisionDataUpdate(bool bInPendingLayerCollisionDataUpdate) { bPendingLayerCollisionDataUpdate = bInPendingLayerCollisionDataUpdate; }
    bool GetPendingLayerCollisionDataUpdate() const { return bPendingLayerCollisionDataUpdate; }
 
    void SetUndoChangedWeightmapAllocs(bool bInVal) { bUndoChangedWeightmapAllocs = bInVal; }
    bool GetUndoChangedWeightmapAllocs() const { return bUndoChangedWeightmapAllocs; }
#endif // WITH_EDITOR
 
    virtual bool IsShown(const FEngineShowFlags& ShowFlags) const override;
 
#if WITH_EDITOR
    virtual int32 GetNumMaterials() const override;
    virtual UMaterialInterface* GetMaterial(int32 ElementIndex) const override;
    virtual void SetMaterial(int32 ElementIndex, UMaterialInterface* Material) override;
    virtual void PreFeatureLevelChange(ERHIFeatureLevel::Type PendingFeatureLevel) override;
#endif
    //~ End UPrimitiveComponent Interface.
 
    //~ Begin USceneComponent Interface.
#if WITH_EDITOR
    virtual bool GetMaterialPropertyPath(int32 ElementIndex, UObject*& OutOwner, FString& OutPropertyPath, FProperty*& OutProperty) override;
#endif // WITH_EDITOR
    virtual void DestroyComponent(bool bPromoteChildren = false) override;
    virtual FBoxSphereBounds CalcBounds(const FTransform& LocalToWorld) const override;
    //~ End USceneComponent Interface.
 
    //~ Begin UActorComponent Interface.
    virtual void OnRegister() override;
    virtual void OnUnregister() override;
#if WITH_EDITOR
    virtual void InvalidateLightingCacheDetailed(bool bInvalidateBuildEnqueuedLighting, bool bTranslationOnly) override;
#endif
    virtual void PropagateLightingScenarioChange() override;
    virtual bool IsHLODRelevant() const override;
    //~ End UActorComponent Interface.
 
    LANDSCAPE_API ULandscapeInfo* GetLandscapeInfo() const;
 
    UFUNCTION(BlueprintCallable, Category = "Landscape|Grass", meta=(DisplayName = "GetGrassTypes", Tooltip = "Returns the grass types used by the landscape material on this component"))
    const TArray<ULandscapeGrassType*>& GetGrassTypesBP() const { return ObjectPtrDecay(GrassTypes); }
 
    const TArray<TObjectPtr<ULandscapeGrassType>>& GetGrassTypes() const { return GrassTypes; }
 
    void SetGrassTypes(const TArray<TObjectPtr<ULandscapeGrassType>>& InGrassTypes)
    {
        GrassTypes = InGrassTypes;
        InvalidateGrassTypeSummary();
    }
    
    bool MaterialHasGrass() const { return !GetGrassTypes().IsEmpty(); }
 
    double GetGrassTypesMaxDiscardDistance() const { return GrassTypeSummary.MaxInstanceDiscardDistance; }
    void SetGrassTypesMaxDiscardDistance(const float InGrassTypesMaxDiscardDistance) { GrassTypeSummary.MaxInstanceDiscardDistance = InGrassTypesMaxDiscardDistance; GrassTypeSummary.bInvalid = false; }
 
    LANDSCAPE_API bool UpdateGrassTypes(bool bForceUpdate = false);
 
    ULandscapeHeightmapTextureEdgeFixup* InstallOrUpdateTextureUserDatas(bool bUseEdgeFixup, bool bUseCompression = false, bool bUpdateSnapshotNow = true, int32 HeightmapCompressionMipThreshold = 32);
 
#if WITH_EDITOR
    bool DeleteLayerIfAllZero(const FGuid& InEditLayerGuid, const uint8* const TexDataPtr, int32 TexSize, int32 LayerIdx, bool bShouldDirtyPackage);
 
    LANDSCAPE_API void DeleteLayer(ULandscapeLayerInfoObject* LayerInfo, FLandscapeEditDataInterface& LandscapeEdit);
    
    void DeleteLayerInternal(ULandscapeLayerInfoObject* LayerInfo, FLandscapeEditDataInterface& LandscapeEdit, const FGuid& InEditLayerGuid);
 
    void DeleteLayerAllocation(const FGuid& InEditLayerGuid, int32 InLayerAllocationIdx, bool bInShouldDirtyPackage);
 
    LANDSCAPE_API void FillLayer(ULandscapeLayerInfoObject* LayerInfo, FLandscapeEditDataInterface& LandscapeEdit);
 
    LANDSCAPE_API void ReplaceLayer(ULandscapeLayerInfoObject* FromLayerInfo, ULandscapeLayerInfoObject* ToLayerInfo, FLandscapeEditDataInterface& LandscapeEdit);
    void ReplaceLayerInternal(ULandscapeLayerInfoObject* FromLayerInfo, ULandscapeLayerInfoObject* ToLayerInfo, FLandscapeEditDataInterface& LandscapeEdit, const FGuid& InEditLayerGUID);
 
#endif // WITH_EDITOR
 
    void RemoveGrassMap();
 
    /* Could a grassmap currently be generated, disregarding whether our textures are streamed in? */
    LANDSCAPE_API bool CanRenderGrassMap() const;
 
#if WITH_EDITOR
    LANDSCAPE_API uint32 ComputeGrassMapGenerationHash() const;
 
    /* Returns true if the component HAS grass data, but it is not up to date */
    bool IsGrassMapOutdated() const;
 
    TArray<uint16> RenderWPOHeightmap(int32 LOD);
 
    /* Serialize all hashes/guids that record the current state of this component */
    void SerializeStateHashes(FArchive& Ar);
 
    // Generates mobile platform data for this component
    void GenerateMobileWeightmapLayerAllocations();
    void GenerateMobilePlatformPixelData(bool bIsCooking, const ITargetPlatform* TargetPlatform);
 
    void CheckGenerateMobilePlatformData(bool bIsCooking, const ITargetPlatform* TargetPlatform);
 
    virtual TSubclassOf<class UHLODBuilder> GetCustomHLODBuilderClass() const override;
#endif
 
    int32 GetCurrentRuntimeMaterialInstanceCount() const;
    class UMaterialInterface* GetCurrentRuntimeMaterialInterface(int32 InIndex) const;
 
    LANDSCAPE_API int32 GetMaterialInstanceCount(bool InDynamic = true) const;
    LANDSCAPE_API class UMaterialInstance* GetMaterialInstance(int32 InIndex, bool InDynamic = true) const;
 
    UFUNCTION(BlueprintCallable, Category = "Landscape|Runtime|Material")
    class UMaterialInstanceDynamic* GetMaterialInstanceDynamic(int32 InIndex) const;
 
    UFUNCTION(BlueprintCallable, Category = "Landscape|Editor")
    LANDSCAPE_API float EditorGetPaintLayerWeightAtLocation(const FVector& InLocation, ULandscapeLayerInfoObject* PaintLayer);
 
    UFUNCTION(BlueprintCallable, Category = "Landscape|Editor")
    LANDSCAPE_API float EditorGetPaintLayerWeightByNameAtLocation(const FVector& InLocation, const FName InPaintLayerName);
        
    LANDSCAPE_API ALandscape* GetLandscapeActor() const;
 
    ULevel* GetLevel() const;
 
#if WITH_EDITOR
    LANDSCAPE_API void GetGeneratedTexturesAndMaterialInstances(TArray<UObject*>& OutTexturesAndMaterials) const;
    LANDSCAPE_API TArray<UTexture*> GetGeneratedTextures() const;
    LANDSCAPE_API TArray<UMaterialInstance*> GetGeneratedMaterialInstances() const;
#endif // WITH_EDITOR
 
    LANDSCAPE_API ALandscapeProxy* GetLandscapeProxy() const;
 
    FIntPoint GetSectionBase() const
    {
        return FIntPoint(SectionBaseX, SectionBaseY);
    }
 
    FIntPoint GetComponentKey() const
    {
        return GetSectionBase() / ComponentSizeQuads;
    }
 
    void SetSectionBase(FIntPoint InSectionBase)
    {
        SectionBaseX = InSectionBase.X;
        SectionBaseY = InSectionBase.Y;
    }
 
    int32 GetNumRelevantMips() const;
 
    const FGuid& GetLightingGuid() const
    {
#if WITH_EDITORONLY_DATA
        return LightingGuid;
#else
        static const FGuid NullGuid( 0, 0, 0, 0 );
        return NullGuid;
#endif // WITH_EDITORONLY_DATA
    }
 
    void SetLightingGuid()
    {
#if WITH_EDITORONLY_DATA
        LightingGuid = FGuid::NewGuid();
#endif // WITH_EDITORONLY_DATA
    }
 
    FGuid GetMapBuildDataId() const
    {
        return MapBuildDataId;
    }
 
    LANDSCAPE_API const FMeshMapBuildData* GetMeshMapBuildData() const;
 
    LANDSCAPE_API void Init(int32 InBaseX, int32 InBaseY, int32 InComponentSizeQuads, int32 InNumSubsections, int32 InSubsectionSizeQuads);
 
    LANDSCAPE_API UMaterialInterface* GetLandscapeMaterial(int8 InLODIndex = INDEX_NONE) const;
 
    LANDSCAPE_API UMaterialInterface* GetLandscapeHoleMaterial() const;
 
    FBox ComputeApproximateBounds();
 
#if WITH_EDITOR
    LANDSCAPE_API bool UpdateCachedBounds(bool bInApproximateBounds = false);
 
    LANDSCAPE_API void UpdateMaterialInstances();
    LANDSCAPE_API void UpdateMaterialInstances(FMaterialUpdateContext& InOutMaterialContext, TArray<class FComponentRecreateRenderStateContext>& InOutRecreateRenderStateContext);
 
    // Internal implementation of UpdateMaterialInstances, not safe to call directly
    void UpdateMaterialInstances_Internal(FMaterialUpdateContext& Context);
 
    UMaterialInstanceConstant* GetCombinationMaterial(FMaterialUpdateContext* InMaterialUpdateContext, const TArray<FWeightmapLayerAllocationInfo>& Allocations, int8 InLODIndex, bool bMobile = false) const;
    void GenerateHeightmapMips(TArray<FColor*>& HeightmapTextureMipData, int32 ComponentX1=0, int32 ComponentY1=0, int32 ComponentX2=MAX_int32, int32 ComponentY2=MAX_int32, FLandscapeTextureDataInfo* TextureDataInfo=nullptr);
 
    LANDSCAPE_API static void CreateEmptyTextureMips(UTexture2D* Texture, ELandscapeTextureUsage TextureUsage, ELandscapeTextureType TextureType, bool bClear = false);
 
    template<typename DataType>
 
    static void GenerateMipsTempl(int32 InNumSubsections, int32 InSubsectionSizeQuads, UTexture2D* WeightmapTexture, DataType* BaseMipData);
 
    static void GenerateWeightmapMips(int32 InNumSubsections, int32 InSubsectionSizeQuads, UTexture2D* WeightmapTexture, FColor* BaseMipData);
 
    template<typename DataType>
 
    static void UpdateMipsTempl(int32 InNumSubsections, int32 InSubsectionSizeQuads, UTexture2D* WeightmapTexture, TArray<DataType*>& WeightmapTextureMipData, int32 ComponentX1=0, int32 ComponentY1=0, int32 ComponentX2=MAX_int32, int32 ComponentY2=MAX_int32, FLandscapeTextureDataInfo* TextureDataInfo=nullptr);
 
    LANDSCAPE_API static void UpdateWeightmapMips(int32 InNumSubsections, int32 InSubsectionSizeQuads, UTexture2D* WeightmapTexture, TArray<FColor*>& WeightmapTextureMipData, int32 ComponentX1=0, int32 ComponentY1=0, int32 ComponentX2=MAX_int32, int32 ComponentY2=MAX_int32, FLandscapeTextureDataInfo* TextureDataInfo=nullptr);
 
    static void UpdateDataMips(int32 InNumSubsections, int32 InSubsectionSizeQuads, UTexture2D* Texture, TArray<uint8*>& TextureMipData, int32 ComponentX1=0, int32 ComponentY1=0, int32 ComponentX2=MAX_int32, int32 ComponentY2=MAX_int32, FLandscapeTextureDataInfo* TextureDataInfo=nullptr);
 
    void UpdateCollisionHeightData(const FColor* HeightmapTextureMipData, const FColor* SimpleCollisionHeightmapTextureData, int32 ComponentX1=0, int32 ComponentY1=0, int32 ComponentX2=MAX_int32, int32 ComponentY2=MAX_int32, bool bUpdateBounds=false, bool bInUpdateHeightfieldRegion=true);
 
    void DestroyCollisionData();
 
    LANDSCAPE_API void UpdateCollisionData(bool bInUpdateHeightfieldRegion = true);
 
    void UpdateDirtyCollisionHeightData(FIntRect Region);
 
    void ClearDirtyCollisionHeightData();
 
    void UpdateCollisionLayerData(const FColor* const* WeightmapTextureMipData, const FColor* const* const SimpleCollisionWeightmapTextureMipData, int32 ComponentX1=0, int32 ComponentY1=0, int32 ComponentX2=MAX_int32, int32 ComponentY2=MAX_int32);
 
    LANDSCAPE_API void UpdateCollisionLayerData();
 
    void InvalidatePhysicalMaterial();
    bool CanUpdatePhysicalMaterial();
    void UpdatePhysicalMaterialTasks();
    void FinalizePhysicalMaterial(bool bInImmediatePhysicsRebuild);
    void UpdateCollisionPhysicalMaterialData(TArray<UPhysicalMaterial*> const& InPhysicalMaterials, TArray<uint8> const& InMaterialIds);
 
    LANDSCAPE_API TArray<UTexture*> ReallocateWeightmaps(FLandscapeEditDataInterface* DataInterface, const FGuid& InEditLayerGuid, bool bInSaveToTransactionBuffer, bool bInForceReallocate, ALandscapeProxy* InTargetProxy, TSet<ULandscapeComponent*>* InRestrictSharingToComponents);
 
    LANDSCAPE_API bool IsLandscapeHoleMaterialValid() const;
 
    LANDSCAPE_API bool ComponentHasVisibilityPainted() const;
 
    LANDSCAPE_API ULandscapeLayerInfoObject* GetVisibilityLayer() const;
 
    static FString GetLayerAllocationKey(const TArray<FWeightmapLayerAllocationInfo>& Allocations, UMaterialInterface* LandscapeMaterial, bool bMobile = false);
 
    bool ValidateCombinationMaterial(UMaterialInstanceConstant* InCombinationMaterial) const;
 
    void GetLayerDebugColorKey(int32& R, int32& G, int32& B) const;
 
    void RemoveInvalidWeightmaps();
    void RemoveInvalidWeightmaps(const FGuid& InEditLayerGuid);
 
    LANDSCAPE_API void InitHeightmapData(TArray<FColor>& Heights, bool bUpdateCollision);
 
    LANDSCAPE_API void InitWeightmapData(TArray<ULandscapeLayerInfoObject*>& LayerInfos, TArray<TArray<uint8> >& Weights);
 
    LANDSCAPE_API float GetLayerWeightAtLocation( const FVector& InLocation, ULandscapeLayerInfoObject* LayerInfo, TArray<uint8>* LayerCache = NULL, bool bUseEditingWeightmap = false);
 
    LANDSCAPE_API void GetComponentExtent(int32& MinX, int32& MinY, int32& MaxX, int32& MaxY) const;
 
    LANDSCAPE_API FIntRect GetComponentExtent() const;
 
    LANDSCAPE_API void ClearUpdateFlagsForModes(uint32 InModeMask);
    LANDSCAPE_API void RequestWeightmapUpdate(bool bUpdateAll = false, bool bUpdateCollision = true, bool bInUserTriggered = false);
    LANDSCAPE_API void RequestHeightmapUpdate(bool bUpdateAll = false, bool bUpdateCollision = true, bool bInUserTriggered = false);
    LANDSCAPE_API void RequestEditingClientUpdate(bool bInUserTriggered = false);
    LANDSCAPE_API void RequestDeferredClientUpdate();
    uint32 GetLayerUpdateFlagPerMode() const { return LayerUpdateFlagPerMode; }
    LANDSCAPE_API uint32 ComputeWeightmapsHash();
 
    void GetUsedPaintLayers(const FGuid& InLayerGuid, TArray<ULandscapeLayerInfoObject*>& OutUsedLayerInfos) const;
 
    void GetLandscapeComponentNeighborsToRender(TSet<ULandscapeComponent*>& NeighborComponents) const;
    void GetLandscapeComponentWeightmapsToRender(TSet<ULandscapeComponent*>& WeightmapComponents) const;
    void GetLandscapeComponentNeighbors3x3(TStaticArray<ULandscapeComponent*, 9>& OutNeighborComponents) const;
#endif
 
    void UpdateNavigationRelevance();
 
    void UpdateRejectNavmeshUnderneath();
 
    LANDSCAPE_API void UpdatedSharedPropertiesFromActor();
 
    friend class FLandscapeComponentSceneProxy;
    friend struct FLandscapeComponentDataInterface;
 
    LANDSCAPE_API void SetLOD(bool bForced, int32 InLODValue);
 
    UFUNCTION(BlueprintCallable, Category = "LandscapeComponent")
    LANDSCAPE_API void SetForcedLOD(int32 InForcedLOD);
 
    UFUNCTION(BlueprintCallable, Category = "LandscapeComponent")
    LANDSCAPE_API void SetLODBias(int32 InLODBias);
 
    void SetNaniteActive(bool bValue);
 
    inline bool IsNaniteActive() const
    {
        return bNaniteActive;
    }
 
    ULandscapeHeightfieldCollisionComponent* GetCollisionComponent() const { return CollisionComponentRef.Get(); }
    void SetCollisionComponent(ULandscapeHeightfieldCollisionComponent* InCollisionComponent) { CollisionComponentRef = InCollisionComponent; }
 
    void SetUserTriggeredChangeRequested(bool bInUserTriggeredChangeRequested)
    {
        bUserTriggeredChangeRequested = bInUserTriggeredChangeRequested;
    }
 
    bool GetUserTriggeredChangeRequested() const
    {
        return bUserTriggeredChangeRequested;
    }
 
protected:
 
#if WITH_EDITOR
    void RecreateCollisionComponent(bool bUseSimpleCollision);
    void UpdateCollisionHeightBuffer(int32 InComponentX1, int32 InComponentY1, int32 InComponentX2, int32 InComponentY2, int32 InCollisionMipLevel, int32 InHeightmapSizeU, int32 InHeightmapSizeV,
        const FColor* const InHeightmapTextureMipData, uint16* CollisionHeightData, uint16* GrassHeightData);
    void UpdateDominantLayerBuffer(int32 InComponentX1, int32 InComponentY1, int32 InComponentX2, int32 InComponentY2, int32 InCollisionMipLevel, int32 InWeightmapSizeU, int32 InVisibilityLayerIdx, const TArray<uint8*>& InCollisionDataPtrs, const TArray<ULandscapeLayerInfoObject*>& InLayerInfos, uint8* DominantLayerData);
#endif
 
    virtual bool SupportsStaticLighting() const override
    {
        return true;
    }
 
#if WITH_EDITOR
public:
    static uint32 UndoRedoModifiedComponentCount;
    static TMap<ULandscapeComponent*, uint32> UndoRedoModifiedComponents;
#endif // WITH_EDITOR
};