LandscapeEditLayerMergeRenderContext.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "LandscapeEditTypes.h"
#include "LandscapeEditLayerMergeContext.h"
#include "LandscapeEditLayerRendererState.h"
#include "LandscapeEditLayerTargetTypeState.h"
#include "LandscapeEditLayerTypes.h"
#include "LandscapeUtils.h"
#include "EngineDefines.h"
#include "StructUtils/InstancedStruct.h"
 
 
// ----------------------------------------------------------------------------------
// Forward declarations
 
class ALandscape;
class ULandscapeComponent;
class ULandscapeLayerInfoObject;
class ULandscapeScratchRenderTarget;
class ILandscapeEditLayerRenderer;
struct FLandscapeEditLayerMergeRenderBlackboardItem;
 
namespace UE::Landscape
{
    class FRDGBuilderRecorder;
} // namespace UE::Landscape
 
 
namespace UE::Landscape::EditLayers
{
    class FMergeRenderContext;
} //namespace UE::Landscape::EditLayers
 
 
// ----------------------------------------------------------------------------------
 
namespace UE::Landscape::EditLayers
{
 
#if WITH_EDITOR
 
// ----------------------------------------------------------------------------------
 
struct FMergeRenderParams
{
    FMergeRenderParams(TArray<ULandscapeComponent*> InComponentsToMerge, const TArrayView<FEditLayerRendererState>& InEditLayerRendererStates, const TSet<FName>& InWeightmapLayerNames = {}, bool bInRequestAllLayers = false);
 
    TArray<ULandscapeComponent*> ComponentsToMerge;
 
    TArray<FEditLayerRendererState> EditLayerRendererStates;
    
    TSet<FName> WeightmapLayerNames;
 
    bool bRequestAllLayers = false;
};
 
 
// ----------------------------------------------------------------------------------
 
struct FMergeRenderStep
{
    enum class EType
    {
        Invalid,
 
        BeginRenderCommandRecorder, // Initiates a render command recorder that will batch one or several RenderLayer_Recorded operations, runs on the game thread
        EndRenderCommandRecorder, // Ends the render command recorder initiated by the last BeginRenderCommandRecorder, runs on the game thread but this is where the render command executing the recorded operations from (several) RenderLayer_Recorded step(s) will be pushed (on the render thread, this is where the FRDBuilder is created and executed)
 
        BeginRenderLayerGroup, // Initiates a series of RenderLayer steps for renderers that can be rendered one after another without an intermediate BlendLayer. Triggers a call to BeginRenderLayerGroup() on the first renderer in the group 
        EndRenderLayerGroup, // Ends a series of RenderLayer steps for renderers that can be rendered one after another without an intermediate BlendLayer. Triggers a call to EndRenderLayerGroup() on the last renderer in the group 
 
        RenderLayer, // Performs the rendering of a target layer group on an edit layer on a given world region (i.e. in a batch), runs on the game thread. Use the command recorder to perform the render operations. In RenderMode_Recorded, these will be delayed until EndRenderCommandRecorder
        BlendLayer, // Performs the rendering of a target layer group on an edit layer on a given world region (i.e. in a batch), runs on the game thread. Use the command recorder to perform the render operations. In RenderMode_Recorded, these will be delayed until EndRenderCommandRecorder
 
        SignalBatchMergeGroupDone, // Final step when rendering a target layer group on a given world region (i.e. in a batch) : runs on the game thread and allows to retrieve the result of the merge and do something with it (e.g. resolve the final textures)
    };
 
    FMergeRenderStep(EType InType)
        : Type(InType)
    {}
 
 
    FMergeRenderStep(EType InType, const TBitArray<>& InTargetLayerGroupBitIndices, const TArrayView<ULandscapeComponent*>& InComponentsToRender)
        : Type(InType)
        , TargetLayerGroupBitIndices(InTargetLayerGroupBitIndices)
        , ComponentsToRender(InComponentsToRender)
    {}
 
    FMergeRenderStep(EType InType, ERenderFlags InRenderFlags, const FEditLayerRendererState& InRendererState, const TBitArray<>& InTargetLayerGroupBitIndices, const TArrayView<ULandscapeComponent*>& InComponentsToRender)
        : Type(InType)
        , RenderFlags(InRenderFlags)
        , RendererState(InRendererState)
        , TargetLayerGroupBitIndices(InTargetLayerGroupBitIndices)
        , ComponentsToRender(InComponentsToRender)
    {}
 
    UE_DEPRECATED(5.6, "Use the other constructors")
    FMergeRenderStep(EType InType, const FEditLayerRendererState& InRendererState, const TBitArray<>& InTargetLayerGroupBitIndices, const TArrayView<ULandscapeComponent*>& InComponentsToRender)
        : FMergeRenderStep(InType, ERenderFlags::None, InRendererState, InTargetLayerGroupBitIndices, InComponentsToRender)
    {}
 
    EType Type = EType::Invalid;
    
    ERenderFlags RenderFlags = ERenderFlags::None;
 
PRAGMA_DISABLE_EXPERIMENTAL_WARNINGS
    FEditLayerRendererState RendererState = FEditLayerRendererState::GetDummyRendererState();
PRAGMA_ENABLE_EXPERIMENTAL_WARNINGS
 
    TBitArray<> TargetLayerGroupBitIndices;
 
    TArray<ULandscapeComponent*> ComponentsToRender;
 
    UE_DEPRECATED(5.6, "Renamed : use TargetLayerGroupBitIndices")
    TBitArray<> RenderGroupBitIndices;
};
 
 
// ----------------------------------------------------------------------------------
 
struct FMergeRenderBatch
{
    bool operator < (const FMergeRenderBatch& InOther) const;
 
    ALandscape* Landscape = nullptr;
 
    FIntRect LandscapeExtent;
 
    FIntRect SectionRect;
 
    // TODO [jonathan.bard] : rename EffectiveResolution and make private maybe?
    FIntPoint Resolution = FIntPoint(ForceInitToZero);
    
    FIntPoint MinComponentKey = FIntPoint(MAX_int32, MAX_int32);
    FIntPoint MaxComponentKey = FIntPoint(MIN_int32, MIN_int32);
    
    TArray<FMergeRenderStep> RenderSteps;
    
    TSet<ULandscapeComponent*> ComponentsToRender;
 
    TBitArray<> TargetLayerBitIndices;
 
    TMap<ULandscapeComponent*, TBitArray<>> ComponentToTargetLayerBitIndices;
 
    TArray<TSet<ULandscapeComponent*>> TargetLayersToComponents;
 
public:
    FIntPoint GetRenderTargetResolution(bool bInWithDuplicateBorders) const;
    
    int32 ComputeSubsectionRects(ULandscapeComponent* InComponent, TArray<FIntRect, TInlineAllocator<4>>& OutSubsectionRects, TArray<FIntRect, TInlineAllocator<4>>& OutSubsectionRectsWithDuplicateBorders) const;
 
    FIntRect ComputeSectionRect(ULandscapeComponent* InComponent, bool bInWithDuplicateBorders) const;
 
    TArray<FIntRect> ComputeAllComponentSectionRects(bool bInWithDuplicateBorders) const;
 
    void ComputeAllSubsectionRects(TArray<FIntRect>& OutSubsectionRects, TArray<FIntRect>& OutSubsectionRectsWithDuplicateBorders) const;
 
    uint32 ComputeComponentLinearIndex(const FIntPoint& InComponentKey) const;
};
 
 
// ----------------------------------------------------------------------------------
 
struct FComponentMergeRenderInfo
{
    ULandscapeComponent* Component = nullptr;
 
    FIntRect ComponentRegionInRenderArea;
 
    FIntPoint ComponentKeyInRenderArea = FIntPoint(ForceInitToZero);
 
    bool operator < (const FComponentMergeRenderInfo& InOther) const;
};
 
struct FRenderParams
{
    FRenderParams(FMergeRenderContext* InMergeRenderContext,
        const TArrayView<FName>& InTargetLayerGroupLayerNames,
        const TArrayView<ULandscapeLayerInfoObject*>& InTargetLayerGroupLayerInfos,
        const FEditLayerRendererState& InRendererState,
        const TArrayView<FComponentMergeRenderInfo>& InSortedComponentMergeRenderInfos,
        const FTransform& InRenderAreaWorldTransform,
        const FIntRect& InRenderAreaSectionRect,
        int32 InNumSuccessfulRenderLayerStepsUntilBlendLayerStep);
 
    FMergeRenderContext* MergeRenderContext = nullptr;
 
    TArray<FName> TargetLayerGroupLayerNames;
 
    TArray<ULandscapeLayerInfoObject*> TargetLayerGroupLayerInfos;
 
    FEditLayerRendererState RendererState;
 
    TArray<FComponentMergeRenderInfo> SortedComponentMergeRenderInfos;
 
    // TODO [jonathan.bard] Verify that scale is correct
    FTransform RenderAreaWorldTransform;
 
    FIntRect RenderAreaSectionRect;
 
    int32 NumSuccessfulRenderLayerStepsUntilBlendLayerStep = 0;
 
    UE_DEPRECATED(5.6, "Renamed : use TargetLayerGroupLayerNames")
    TArray<FName> RenderGroupTargetLayerNames;
    UE_DEPRECATED(5.6, "Renamed : use TargetLayerGroupLayerInfos")
    TArray<ULandscapeLayerInfoObject*> RenderGroupTargetLayerInfos;
};
 
 
// ----------------------------------------------------------------------------------
 
class FMergeRenderContext : public FMergeContext
{
public:
    friend class ::ALandscape;
 
    FMergeRenderContext(const FMergeContext& InMergeContext);
    virtual ~FMergeRenderContext();
    FMergeRenderContext(const FMergeRenderContext& Other) = default;
    FMergeRenderContext(FMergeRenderContext&& Other) = default;
    FMergeRenderContext& operator=(const FMergeRenderContext& Other) = default;
    FMergeRenderContext& operator=(FMergeRenderContext&& Other) = default;
 
    bool IsValid() const;
 
    LANDSCAPE_API void CycleBlendRenderTargets(UE::Landscape::FRDGBuilderRecorder& RDGBuilderRecorder);
 
    LANDSCAPE_API ULandscapeScratchRenderTarget* GetBlendRenderTargetWrite() const;
    LANDSCAPE_API ULandscapeScratchRenderTarget* GetBlendRenderTargetRead() const;
    LANDSCAPE_API ULandscapeScratchRenderTarget* GetBlendRenderTargetReadPrevious() const;
    LANDSCAPE_API ULandscapeScratchRenderTarget* GetComponentIdRenderTarget() const;
    
    struct FOnRenderBatchTargetGroupDoneParams
    {
        FOnRenderBatchTargetGroupDoneParams(FMergeRenderContext* InMergeRenderContext, 
            const TArrayView<FName>& InTargetLayerGroupLayerNames,
            const TArrayView<ULandscapeLayerInfoObject*>& InTargetLayerGroupLayerInfos,
            const TArrayView<FComponentMergeRenderInfo>& InSortedComponentMergeRenderInfos)
            : MergeRenderContext(InMergeRenderContext)
            , TargetLayerGroupLayerNames(InTargetLayerGroupLayerNames)
            , TargetLayerGroupLayerInfos(InTargetLayerGroupLayerInfos)
            , SortedComponentMergeRenderInfos(InSortedComponentMergeRenderInfos)
        {}
 
        FMergeRenderContext* MergeRenderContext = nullptr;
 
        TArray<FName> TargetLayerGroupLayerNames;
 
        TArray<ULandscapeLayerInfoObject*> TargetLayerGroupLayerInfos;
 
        const TArray<FComponentMergeRenderInfo> SortedComponentMergeRenderInfos;
 
        UE_DEPRECATED(5.6, "Renamed : use TargetLayerGroupLayerNames")
        TArray<FName> RenderGroupTargetLayerNames;
        UE_DEPRECATED(5.6, "Renamed : use TargetLayerGroupLayerInfos")
        TArray<ULandscapeLayerInfoObject*> RenderGroupTargetLayerInfos;
        UE_DEPRECATED(5.6, "Removed : use MergeRenderContext->GetCurrentRenderBatch()")
        const FMergeRenderBatch* RenderBatch = nullptr;
    };
    void Render(TFunction<void(const FOnRenderBatchTargetGroupDoneParams& /*InParams*/, UE::Landscape::FRDGBuilderRecorder& /*RDGBuilderRecorder*/)> OnRenderBatchTargetGroupDone);
 
    inline FIntPoint GetMaxNeededResolution() const { return MaxNeededResolution; }
    inline const TArray<FMergeRenderBatch>& GetRenderBatches() const { return RenderBatches; }
    LANDSCAPE_API const FMergeRenderBatch* GetCurrentRenderBatch() const;
    LANDSCAPE_API const int32 GetCurrentRenderBatchIdx() const;
 
    LANDSCAPE_API FTransform ComputeVisualLogTransform(const FTransform& InTransform) const;
    LANDSCAPE_API void IncrementVisualLogOffset();
    LANDSCAPE_API void ResetVisualLogOffset();
 
#if ENABLE_VISUAL_LOG
    LANDSCAPE_API static int32 GetVisualLogAlpha();
    LANDSCAPE_API bool IsVisualLogEnabled() const;
#endif // ENABLE_VISUAL_LOG
 
    void RenderComponentIds(UE::Landscape::FRDGBuilderRecorder& RDGBuilderRecorder);
 
    void RenderExpandedRenderTarget(UE::Landscape::FRDGBuilderRecorder& RDGBuilderRecorder);
 
    LANDSCAPE_API void GenericBlendLayer(const FBlendParams& InBlendParams, FRenderParams& RenderParams, UE::Landscape::FRDGBuilderRecorder& RDGBuilderRecorder);
 
    const TBitArray<>& GetFinalTargetLayerBitIndices() const 
    { 
        return FinalTargetLayerBitIndices; 
    }
 
    template <typename T, typename = std::enable_if_t<std::is_base_of_v<FLandscapeEditLayerMergeRenderBlackboardItem, std::decay_t<T>>>>
    bool HasBlackboardItem() const;
 
    template <typename T, typename... TArgs, typename = std::enable_if_t<std::is_base_of_v<FLandscapeEditLayerMergeRenderBlackboardItem, std::decay_t<T>>>>
    T& AddBlackboardItem(TArgs&&... InArgs);
 
    template <typename T, typename = std::enable_if_t<std::is_base_of_v<FLandscapeEditLayerMergeRenderBlackboardItem, std::decay_t<T>>>>
    T* TryGetBlackboardItem();
 
    template <typename T, typename = std::enable_if_t<std::is_base_of_v<FLandscapeEditLayerMergeRenderBlackboardItem, std::decay_t<T>>>>
    T& GetBlackboardItem();
 
    template <typename T, typename... TArgs, typename = std::enable_if_t<std::is_base_of_v<FLandscapeEditLayerMergeRenderBlackboardItem, std::decay_t<T>>>>
    T& GetOrCreateBlackboardItem(TArgs&&... InArgs);
 
    template <typename T, typename = std::enable_if_t<std::is_base_of_v<FLandscapeEditLayerMergeRenderBlackboardItem, std::decay_t<T>>>>
    TArray<T*> GetBlackboardItems();
 
    const TArray<TInstancedStruct<FLandscapeEditLayerMergeRenderBlackboardItem>>& GetAllBlackboardItems() const { return BlackboardItems; }
 
private:
    void AllocateResources();
    void FreeResources();
    void AllocateBatchResources(const FMergeRenderBatch& InRenderBatch);
    void FreeBatchResources(const FMergeRenderBatch& InRenderBatch);
 
private:
    // Blending is pretty much what we only do during the merge. It requires 3 render targets : 1 that we write to and therefore use as RTV (Write) and 2 that we read from and therefore use 
    //  as SRV (one that contains the layer to merge, the other the accumulated result so far) : Previous(SRV) + Current(SRV) --> Write(RTV)
    static constexpr int32 NumBlendRenderTargets = 3; 
 
    TStaticArray<ULandscapeScratchRenderTarget*, NumBlendRenderTargets> BlendRenderTargets;
    int32 CurrentBlendRenderTargetWriteIndex = -1; 
 
    TBitArray<> FinalTargetLayerBitIndices;
 
    ULandscapeScratchRenderTarget* ComponentIdRenderTarget = nullptr;
 
    FIntPoint MaxNeededResolution = FIntPoint(ForceInit);
 
    int32 MaxNeededNumSlices = 0;
 
    FIntPoint MaxNumComponents = FIntPoint(ForceInit);
 
    TArray<FMergeRenderBatch> RenderBatches;
 
    int32 CurrentRenderBatchIndex = INDEX_NONE;
 
    FVector CurrentVisualLogOffset = FVector(ForceInitToZero);
 
    double MaxLocalHeight = DBL_MIN;
 
    TMap<ULandscapeComponent*, TBitArray<>> ComponentToTargetLayerBitIndices;
 
    TArray<TSet<ULandscapeComponent*>> TargetLayersToComponents;
 
    TArray<TInstancedStruct<FLandscapeEditLayerMergeRenderBlackboardItem>> BlackboardItems;
};
 
#endif // WITH_EDITOR
 
} //namespace UE::Landscape::EditLayers
 
#include "LandscapeEditLayerMergeRenderContext.inl"