LandscapeEditLayer.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Landscape.h"
#include "LandscapeEditLayerRenderer.h"
#include "LandscapeEditTypes.h"
#include "Math/Interval.h"
 
#include "LandscapeEditLayer.generated.h"
 
enum class ELandscapeToolTargetType : uint8;
 
struct FOnLandscapeEditLayerDataChangedParams
{
    FOnLandscapeEditLayerDataChangedParams(const FPropertyChangedEvent& InPropertyChangedEvent = FPropertyChangedEvent(/*InProperty = */nullptr))
        : PropertyChangedEvent(InPropertyChangedEvent)
    {}
 
    FPropertyChangedEvent PropertyChangedEvent;
 
    bool bUserTriggered = false;
 
    bool bRequiresLandscapeUpdate = true;
 
    bool bHasValueChanged = true;
};
 
UCLASS(MinimalAPI, Abstract)
class ULandscapeEditLayerBase : public UObject
#if CPP && WITH_EDITOR
    , public UE::Landscape::EditLayers::IEditLayerRendererProvider
#endif // CPP && WITH_EDITOR
{
    GENERATED_BODY()
 
public:
    class UE_DEPRECATED(5.7, "Expose custom actions to the editor with IEditLayerCustomization and RegisterCustomEditLayerClassLayout") FEditLayerAction
    {
        FEditLayerAction() = delete;
 
    public:
        class UE_DEPRECATED(5.7, "Expose custom actions to the editor with IEditLayerCustomization and RegisterCustomEditLayerClassLayout") FExecuteParams
        {
            FExecuteParams() = delete;
 
        public:
            FExecuteParams(const ULandscapeEditLayerBase* InEditLayer, ALandscape* InLandscape)
                : EditLayer(InEditLayer)
                , Landscape(InLandscape)
            {
                check((InEditLayer != nullptr) && (InLandscape != nullptr));
            }
 
            UE_DEPRECATED(5.6, "This FLandscapeLayer constructor is deprecated. Use ULandscapeEditLayerBase constructor.")
            FExecuteParams(const FLandscapeLayer* InLayer, ALandscape* InLandscape)
                : Layer(InLayer)
                , Landscape(InLandscape)
            {
                check((InLayer != nullptr) && (InLandscape != nullptr));
            }
 
            UE_DEPRECATED(5.6, "Deprecated in preference of ULandscapeEditLayerBase*, use GetEditLayer instead. ")
            inline const FLandscapeLayer* GetLayer() const { return Layer; }
            inline const ULandscapeEditLayerBase* GetEditLayer() const { return EditLayer; }
            inline ALandscape* GetLandscape() const { return Landscape; }
 
        private:
            const ULandscapeEditLayerBase* EditLayer = nullptr;
            const FLandscapeLayer* Layer = nullptr;
            ALandscape* Landscape = nullptr;
        };
 
        struct UE_DEPRECATED(5.7, "Expose custom actions to the editor with IEditLayerCustomization and RegisterCustomEditLayerClassLayout") FExecuteResult
        {
            FExecuteResult() = default;
            FExecuteResult(bool bInSuccess, const FText& InReason = FText())
                : bSuccess(bInSuccess)
                , Reason(InReason)
            {}
 
            bool bSuccess = true;
            FText Reason;
        };
 
        DECLARE_DELEGATE_RetVal_OneParam(FExecuteResult, FExecuteDelegate, const FExecuteParams& /*InParams*/);
        DECLARE_DELEGATE_RetVal_TwoParams(bool, FCanExecuteDelegate, const FExecuteParams& /*InParams*/, FText& /*OutReason*/);
 
        FEditLayerAction(const FText& InLabel, const FExecuteDelegate& InExecuteDelegate, const FCanExecuteDelegate& InCanExecuteDelegate)
            : Label(InLabel)
            , ExecuteDelegate(InExecuteDelegate)
            , CanExecuteDelegate(InCanExecuteDelegate)
        {}
 
        inline const FText& GetLabel() const { return Label; }
        inline const FExecuteDelegate& GetExecuteDelegate() const { return ExecuteDelegate; }
        inline const FCanExecuteDelegate& GetCanExecuteDelegate() const { return CanExecuteDelegate; }
 
    private:
        FText Label;
        FExecuteDelegate ExecuteDelegate;
        FCanExecuteDelegate CanExecuteDelegate;
    };
 
public:
    virtual bool SupportsTargetType(ELandscapeToolTargetType InType) const
        PURE_VIRTUAL(ULandscapeEditLayerBase::SupportsTargetType, return true; );
 
    virtual bool NeedsPersistentTextures() const
        PURE_VIRTUAL(ULandscapeEditLayerBase::NeedsPersistentTextures, return false; );
 
    virtual bool SupportsEditingTools() const
        PURE_VIRTUAL(ULandscapeEditLayerBase::SupportsEditingTools, return true; );
 
    virtual bool SupportsMultiple() const
        PURE_VIRTUAL(ULandscapeEditLayerBase::SupportsMultiple, return true; );
 
    virtual bool SupportsBeingCollapsedAway() const
        PURE_VIRTUAL(ULandscapeEditLayerBase::SupportsBeingCollapsedAway, return true; );
 
    virtual bool SupportsCollapsingTo() const
        PURE_VIRTUAL(ULandscapeEditLayerBase::SupportsCollapsingTo, return true; );
 
    virtual bool SupportsBlueprintBrushes() const
        PURE_VIRTUAL(ULandscapeEditLayerBase::SupportsBlueprintBrushes(), return false; );
 
    virtual FString GetDefaultName() const
        PURE_VIRTUAL(ULandscapeEditLayerBase::GetDefaultName, return FString(); );
 
#if WITH_EDITOR
    LANDSCAPE_API virtual bool SupportsAlphaForTargetType(ELandscapeToolTargetType InType) const;
 
    LANDSCAPE_API virtual void SetAlphaForTargetType(ELandscapeToolTargetType InType, float InNewValue, bool bInModify, EPropertyChangeType::Type InChangeType);
 
    LANDSCAPE_API virtual float GetAlphaForTargetType(ELandscapeToolTargetType InType) const;
 
    LANDSCAPE_API virtual FFloatInterval GetAlphaRangeForTargetType(ELandscapeToolTargetType InType) const;
 
    LANDSCAPE_API virtual void SetGuid(const FGuid& InGuid, bool bInModify);
 
    LANDSCAPE_API virtual const FGuid& GetGuid() const;
 
    LANDSCAPE_API virtual void SetName(FName InName, bool bInModify);
 
    LANDSCAPE_API virtual FName GetName() const;
 
    LANDSCAPE_API virtual void SetVisible(bool bInVisible, bool bInModify);
    
    LANDSCAPE_API virtual bool IsVisible() const;
 
    LANDSCAPE_API virtual void SetLocked(bool bInLocked, bool bInModify);
 
    LANDSCAPE_API virtual bool IsLocked() const;
 
    UE_INTERNAL LANDSCAPE_API virtual ELandscapeBlendMode GetBlendMode() const;
 
    UE_INTERNAL LANDSCAPE_API virtual bool RemoveAndCopyWeightmapAllocationLayerBlend(TObjectPtr<ULandscapeLayerInfoObject> InKey, bool& bOutValue, bool bInModify);
 
    UE_INTERNAL LANDSCAPE_API virtual void AddOrUpdateWeightmapAllocationLayerBlend(TObjectPtr<ULandscapeLayerInfoObject> InKey, bool InValue, bool bInModify);
 
    UE_INTERNAL LANDSCAPE_API virtual const TMap<TObjectPtr<ULandscapeLayerInfoObject>, bool>& GetWeightmapLayerAllocationBlend() const;
 
    UE_INTERNAL LANDSCAPE_API virtual void SetWeightmapLayerAllocationBlend(const TMap<TObjectPtr<ULandscapeLayerInfoObject>, bool>& InWeightmapLayerAllocationBlend, bool bInModify);
 
#endif // WITH_EDITOR
 
    UE_DEPRECATED(5.7, "Register custom context menu actions using RegisterCustomEditLayerClassLayout from ILandscapeEditorModule")
PRAGMA_DISABLE_DEPRECATION_WARNINGS
    virtual TArray<FEditLayerAction> GetActions() const 
PRAGMA_ENABLE_DEPRECATION_WARNINGS
    { 
        return {}; 
    }
 
    virtual void GetRenderDependencies(TSet<UObject*>& OutDependencies) const 
    {}
 
    // Called by landscape after removing this layer from its list so that the layer can do
    // any cleanup that it might need to do.
    // TODO: Should this be protected and then we friend ALandscape?
    virtual void OnLayerRemoved() 
    {}
 
#if WITH_EDITOR
    //~ Begin IEditLayerRendererProvider implementation
    // By default this does nothing in a landscape edit layer, but subclasses can override it if 
    //  they would like to provide additional renderers.
    virtual TArray<UE::Landscape::EditLayers::FEditLayerRendererState> GetEditLayerRendererStates(const UE::Landscape::EditLayers::FMergeContext* InMergeContext) {  return {};  };
    //~ End IEditLayerRendererProvider implementation
 
 
    DECLARE_MULTICAST_DELEGATE_OneParam(FOnLayerDataChanged, const FOnLandscapeEditLayerDataChangedParams& /*InParams*/);
    FOnLayerDataChanged::RegistrationType& OnLayerDataChanged() const
    {
        return OnLayerDataChangedDelegate;
    }
 
    LANDSCAPE_API virtual ELandscapeToolTargetTypeFlags GetEnabledTargetTypeMask() const;
#endif // WITH_EDITOR
 
protected:
#if WITH_EDITOR
    // Begin UObject implementation
    LANDSCAPE_API virtual void PostLoad() override;
    LANDSCAPE_API virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
    LANDSCAPE_API virtual void PostEditUndo() override;
    LANDSCAPE_API virtual bool CanEditChange(const FProperty* InProperty) const override;
    // End UObject implementation
#endif // WITH_EDITOR
 
#if WITH_EDITORONLY_DATA
    // Setters for UPROPERTY (should be used for blueprint setters eventually) :  
    void SetGuidInternal(const FGuid& InGuid);
    void SetNameInternal(FName InName);
    void SetVisibleInternal(bool bInVisible);
    void SetLockedInternal(bool bInLocked);
    void SetHeightmapAlphaInternal(float InNewValue);
    void SetWeightmapAlphaInternal(float InNewValue);
    // Marked as UE_INTERNAL to prevent external usage before blend refactor with the introduction of blend groups and premultiplied alpha blending
    UE_INTERNAL void SetWeightmapLayerAllocationBlendInternal(const TMap<TObjectPtr<ULandscapeLayerInfoObject>, bool>& InWeightmapLayerAllocationBlend);
#endif // WITH_EDITORONLY_DATA
 
#if WITH_EDITOR
    float& GetAlphaForTargetTypeRef(ELandscapeToolTargetType InType);
    FProperty* GetAlphaPropertyForTargetType(ELandscapeToolTargetType InType) const;
    void BroadcastOnLayerDataChanged(FName InPropertyName, bool bInUserTriggered, bool bRequiresLandscapeUpdate, bool bInHasValueChanged, EPropertyChangeType::Type InChangeType);
#endif // WITH_EDITOR
protected:
#if WITH_EDITORONLY_DATA
    UPROPERTY(Setter = "SetGuidInternal", meta = (EditCondition = "!bLocked"))
    FGuid Guid = FGuid::NewGuid();
 
    UPROPERTY(Setter = "SetNameInternal", meta = (EditCondition = "!bLocked"))
    FName LayerName = NAME_None;
 
    UPROPERTY(Category = "Edit Layer", EditAnywhere, Setter = "SetVisibleInternal", meta = (EditCondition = "!bLocked"))
    bool bVisible = true;
 
    UPROPERTY(Category = "Edit Layer", EditAnywhere, Setter = "SetLockedInternal")
    bool bLocked = false;
 
    UPROPERTY(Category = "Edit Layer", EditAnywhere, Setter = "SetHeightmapAlphaInternal", meta = (UIMin = "-1.0", UIMax = "1.0", ClampMin = "-1.0", ClampMax = "1.0", EditCondition = "!bLocked"))
    float HeightmapAlpha = 1.0f;
 
    UPROPERTY(Category = "Edit Layer", EditAnywhere, Setter = "SetWeightmapAlphaInternal", meta = (UIMin = "0.0", UIMax = "1.0", ClampMin = "0.0", ClampMax = "1.0", EditCondition = "!bLocked"))
    float WeightmapAlpha = 1.0f;
 
    // TODO: This might be removed once more things are moved from FLandscapeLayer to ULandscapeLayer
    UPROPERTY()
    TWeakObjectPtr<ALandscape> OwningLandscape;
 
private:
    // TODO: This might be removed once the guid is stored here and subclasses have a way to request landscape updates.
    friend class ALandscape;
    void SetBackPointer(ALandscape* Landscape);
 
    mutable FOnLayerDataChanged OnLayerDataChangedDelegate;
 
    UPROPERTY(Setter = "SetWeightmapLayerAllocationBlendInternal", meta = (EditCondition = "!bLocked"))
    TMap<TObjectPtr<ULandscapeLayerInfoObject>, bool> WeightmapLayerAllocationBlend; // True -> Substractive, False -> Add
#endif //WITH_EDITORONLY_DATA
};
 
UCLASS(MinimalAPI, Abstract)
class ULandscapeEditLayerPersistent : public ULandscapeEditLayerBase
    , public ILandscapeEditLayerRenderer
{
    GENERATED_BODY()
 
public:
    // Begin ULandscapeEditLayerBase implementation
    virtual bool NeedsPersistentTextures() const override { return true; };
    virtual bool SupportsCollapsingTo() const override { return true; } // If the layer has persistent textures, it can be collapsed to another layer (one that supports being collapsed away, that is)
    virtual bool SupportsBlueprintBrushes() const override { return false; }
    // End ULandscapeEditLayerBase implementation
 
#if WITH_EDITOR
    //~ Begin ILandscapeEditLayerRenderer implementation
    LANDSCAPE_API virtual void GetRendererStateInfo(const UE::Landscape::EditLayers::FMergeContext* InMergeContext,
        UE::Landscape::EditLayers::FEditLayerTargetTypeState& OutSupportedTargetTypeState, UE::Landscape::EditLayers::FEditLayerTargetTypeState& OutEnabledTargetTypeState, TArray<UE::Landscape::EditLayers::FTargetLayerGroup>& OutTargetLayerGroups) const override;
    virtual UE::Landscape::EditLayers::ERenderFlags GetRenderFlags(const UE::Landscape::EditLayers::FMergeContext* InMergeContext) const override;
    LANDSCAPE_API virtual TArray<UE::Landscape::EditLayers::FEditLayerRenderItem> GetRenderItems(const UE::Landscape::EditLayers::FMergeContext* InMergeContext) const override;
    LANDSCAPE_API virtual bool RenderLayer(UE::Landscape::EditLayers::FRenderParams& RenderParams, UE::Landscape::FRDGBuilderRecorder& RDGBuilderRecorder) override;
    LANDSCAPE_API virtual void BlendLayer(UE::Landscape::EditLayers::FRenderParams& RenderParams, UE::Landscape::FRDGBuilderRecorder& RDGBuilderRecorder) override;
    LANDSCAPE_API virtual FString GetEditLayerRendererDebugName() const override;
    //~ End ILandscapeEditLayerRenderer implementation
#endif // WITH_EDITOR
};
 
UCLASS(MinimalAPI, meta = (ShortToolTip = "Standard edit layer"))
class ULandscapeEditLayer : public ULandscapeEditLayerPersistent
{
    GENERATED_BODY()
 
public:
    // Begin ULandscapeEditLayerBase implementation
    virtual bool SupportsTargetType(ELandscapeToolTargetType InType) const override;
    virtual bool SupportsEditingTools() const override { return true; }
    virtual bool SupportsMultiple() const override { return true; }
    virtual bool SupportsBeingCollapsedAway() const override { return true; } 
    virtual bool SupportsBlueprintBrushes() const override { return true; }
    virtual FString GetDefaultName() const { return TEXT("Layer"); }
    // End ULandscapeEditLayerBase implementation
 
protected:
 
};
 
UCLASS(MinimalAPI, Abstract)
class ULandscapeEditLayerProcedural : public ULandscapeEditLayerBase
{
    GENERATED_BODY()
 
public:
    // Begin ULandscapeEditLayerBase implementation
    virtual bool SupportsEditingTools() const override { return false; } // procedural layers cannot be edited through standard editing tools
    virtual bool SupportsCollapsingTo() const override { return false; } // for now, don't support collapsing to a layer underneath for a procedural layer (this may become unneeded if we make the collapse happen on the GPU)
    virtual bool SupportsBeingCollapsedAway() const override { return false; } // this is a procedural and therefore cannot be collapsed 
    virtual bool SupportsBlueprintBrushes() const override { return false; }
    // End ULandscapeEditLayerBase implementation
};
 
UCLASS(MinimalAPI, meta = (ShortToolTip = "Special edit layer for landscape splines"))
class ULandscapeEditLayerSplines : public ULandscapeEditLayerPersistent
{
    GENERATED_BODY()
 
public:
    // Begin ULandscapeEditLayerBase implementation
    virtual bool SupportsEditingTools() const override { return false; } // procedural layers cannot be edited through standard editing tools
    virtual bool SupportsTargetType(ELandscapeToolTargetType InType) const override;
    virtual bool NeedsPersistentTextures() const override { return true; }; // it's a layer computed on the CPU and outputting to persistent textures
    virtual bool SupportsMultiple() const override { return false; } // only one layer of this type is allowed
    virtual bool SupportsBeingCollapsedAway() const override { return false; } // this is a procedural and therefore cannot be collapsed 
    virtual FString GetDefaultName() const override { return TEXT("Splines"); }
#if WITH_EDITOR
    virtual ELandscapeBlendMode GetBlendMode() const override { return ELandscapeBlendMode::LSBM_AlphaBlend; };
    bool SupportsAlphaForTargetType(ELandscapeToolTargetType InType) const override { return false; };
    virtual float GetAlphaForTargetType(ELandscapeToolTargetType InType) const override { return 1.0f; };
    virtual void SetAlphaForTargetType(ELandscapeToolTargetType InType, float InNewValue, bool bInModify, EPropertyChangeType::Type InChangeType) override { /* do nothing */ };
    // End ULandscapeEditLayerBase implementation
#endif // WITH_EDITOR
protected:
 
};