LandscapeEditLayerMergeContext.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "LandscapeEditTypes.h"
 
 
// ----------------------------------------------------------------------------------
// Forward declarations
 
class ALandscape;
class ULandscapeInfo;
class ULandscapeLayerInfoObject;
 
namespace UE::Landscape::EditLayers
{
    class FTargetLayerGroup;
} // namespace UE::Landscape::EditLayers
 
// ----------------------------------------------------------------------------------
 
namespace UE::Landscape::EditLayers
{
 
#if WITH_EDITOR
 
class FMergeContext
{
public:
    friend ALandscape;
 
    using FTargetLayerGroupsPerBlendingMethod = TStaticArray<TArray<FTargetLayerGroup>, static_cast<uint8>(ELandscapeTargetLayerBlendMethod::Count)>;
 
    FMergeContext(ALandscape* InLandscape, bool bInIsHeightmapMerge, bool bInSkipProceduralRenderers);
    virtual ~FMergeContext() = default;
    FMergeContext(const FMergeContext& Other) = default;
    FMergeContext(FMergeContext&& Other) = default;
    FMergeContext& operator=(const FMergeContext& Other) = default;
    FMergeContext& operator=(FMergeContext&& Other) = default;
 
    inline ALandscape* GetLandscape() const { return Landscape; }
 
    inline ULandscapeInfo* GetLandscapeInfo() const { return LandscapeInfo; }
    
    inline const TArray<FName>& GetAllTargetLayerNames() const { return AllTargetLayerNames; }
 
    TArray<FName> GetValidTargetLayerNames() const;
 
    inline const TArray<ULandscapeLayerInfoObject*>& GetAllWeightmapLayerInfos() const { return AllWeightmapLayerInfos; }
 
    inline bool IsHeightmapMerge() const { return bIsHeightmapMerge; }
 
    inline bool ShouldSkipProceduralRenderers() const { return bSkipProceduralRenderers; }
 
    LANDSCAPE_API int32 IsValidTargetLayerName(const FName& InName) const;
 
    LANDSCAPE_API int32 IsValidTargetLayerNameChecked(const FName& InName) const;
 
    LANDSCAPE_API int32 IsTargetLayerIndexValid(int32 InIndex) const;
 
    LANDSCAPE_API int32 GetTargetLayerIndexForName(const FName& InName) const;
 
    LANDSCAPE_API int32 GetTargetLayerIndexForNameChecked(const FName& InName) const;
 
    LANDSCAPE_API FName GetTargetLayerNameForIndex(int32 InIndex) const;
 
    LANDSCAPE_API FName GetTargetLayerNameForIndexChecked(int32 InIndex) const;
 
    LANDSCAPE_API int32 GetTargetLayerIndexForLayerInfo(ULandscapeLayerInfoObject* InLayerInfo) const;
 
    LANDSCAPE_API int32 GetTargetLayerIndexForLayerInfoChecked(ULandscapeLayerInfoObject* InLayerInfo) const;
 
    LANDSCAPE_API ULandscapeLayerInfoObject* GetTargetLayerInfoForName(const FName& InName) const;
 
    LANDSCAPE_API ULandscapeLayerInfoObject* GetTargetLayerInfoForNameChecked(const FName& InName) const;
 
    LANDSCAPE_API ULandscapeLayerInfoObject* GetTargetLayerInfoForIndex(int32 InIndex) const;
 
    LANDSCAPE_API TBitArray<> ConvertTargetLayerNamesToBitIndices(TConstArrayView<FName> InTargetLayerNames) const;
 
    LANDSCAPE_API TBitArray<> ConvertTargetLayerNamesToBitIndicesChecked(TConstArrayView<FName> InTargetLayerNames) const;
 
    LANDSCAPE_API TArray<FName> ConvertTargetLayerBitIndicesToNames(const TBitArray<>& InTargetLayerBitIndices) const;
 
    LANDSCAPE_API TArray<ULandscapeLayerInfoObject*> ConvertTargetLayerBitIndicesToLayerInfos(const TBitArray<>& InTargetLayerBitIndices) const;
 
    LANDSCAPE_API void ForEachTargetLayer(const TBitArray<>& InTargetLayerBitIndices, TFunctionRef<bool(int32 /*InTargetLayerIndex*/, const FName& /*InTargetLayerName*/, ULandscapeLayerInfoObject* /*InWeightmapLayerInfo*/)> Fn) const;
 
    LANDSCAPE_API void ForEachValidTargetLayer(TFunctionRef<bool(int32 /*InTargetLayerIndex*/, const FName& /*InTargetLayerName*/, ULandscapeLayerInfoObject* /*InWeightmapLayerInfo*/)> Fn) const;
 
    inline int32 GetVisibilityTargetLayerIndex() const { return VisibilityTargetLayerIndex; }
 
    inline const TBitArray<>& GetVisibilityTargetLayerMask() const { return VisibilityTargetLayerMask; }
 
    inline const TBitArray<>& GetNegatedVisibilityTargetLayerMask() const { return NegatedVisibilityTargetLayerMask; }
 
    inline const TBitArray<>& GetValidTargetLayerBitIndices() const { return ValidTargetLayerBitIndices; }
 
    LANDSCAPE_API TBitArray<> BuildTargetLayerBitIndices(bool bInBitValue) const;
 
    const FTargetLayerGroupsPerBlendingMethod& GetTargetLayerGroupsPerBlendingMethod() const { return TargetLayerGroupsPerBlendingMethod; }
 
    LANDSCAPE_API TArray<FTargetLayerGroup> BuildGenericBlendTargetLayerGroups(const TBitArray<>& InTargetLayerBitIndices) const;
 
private:
    void FinalizeTargetLayerGroupsPerBlendingMethod();
    TArray<FTargetLayerGroup> GatherTargetLayerGroupsForBlendMethod(ELandscapeTargetLayerBlendMethod InBlendMethod) const;
 
protected:
    // COMMENT [jonathan.bard] : purposefully don't use ELandscapeToolTargetType here as ELandscapeToolTargetType::Weightmap and ELandscapeToolTargetType::Visibility have to be processed together (because of weightmap packing, 
    //  which means a visibility weightmap could be another channel of a texture which contains weightmap up to 3 other weightmaps, so we have to resolve the 4 channels altogether). 
    //  Note: this could change when SUPPORTS_LANDSCAPE_EDITORONLY_UBER_MATERIAL is done...
    bool bIsHeightmapMerge = false;
 
    bool bSkipProceduralRenderers = false;
 
    ALandscape* Landscape = nullptr;
 
    ULandscapeInfo* LandscapeInfo = nullptr;
 
    TArray<FName> AllTargetLayerNames;
 
    TBitArray<> VisibilityTargetLayerMask;
 
    TBitArray<> NegatedVisibilityTargetLayerMask;
 
    TArray<ULandscapeLayerInfoObject*> AllWeightmapLayerInfos;
 
    TBitArray<> ValidTargetLayerBitIndices;
 
    FTargetLayerGroupsPerBlendingMethod TargetLayerGroupsPerBlendingMethod;
 
    // Index of the visibility layer in AllTargetLayerNames (always valid for weightmap merges)
    int32 VisibilityTargetLayerIndex = INDEX_NONE;
};
 
#endif // WITH_EDITOR
 
} // namespace UE::Landscape::EditLayers