LandscapeEditLayerRenderer.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "LandscapeEditTypes.h"
#include "LandscapeUtils.h"
#include "LandscapeEditLayerRendererState.h"
#include "LandscapeEditLayerTargetTypeState.h"
#include "LandscapeEditLayerTypes.h"
 
#if UE_ENABLE_INCLUDE_ORDER_DEPRECATED_IN_5_6
#include "LandscapeEditLayerMergeRenderContext.h"
#include "LandscapeEditLayerMergeRenderBlackboardItem.h"
#endif // UE_ENABLE_INCLUDE_ORDER_DEPRECATED_IN_5_6
 
#include "LandscapeEditLayerRenderer.generated.h"
 
// ----------------------------------------------------------------------------------
// Forward declarations
 
class ULandscapeLayerInfoObject;
 
namespace UE::Landscape
{
    class FRDGBuilderRecorder;
} // namespace UE::Landscape
 
namespace UE::Landscape::EditLayers
{
    struct FComponentMergeRenderInfo;
    struct FRenderParams;
    class FMergeRenderContext;
    class FTargetLayerGroup;
} // namespace UE::Landscape::EditLayers
 
 
// ----------------------------------------------------------------------------------
 
namespace UE::Landscape::EditLayers
{
 
#if WITH_EDITOR
 
// ----------------------------------------------------------------------------------
 
// TODO [jonathan.bard] : use FOrientedBox2d instead?
struct FOOBox2D
{
    FOOBox2D() = default;
    FOOBox2D(const FTransform& InTransform, const FVector2D& InExtents)
        : Transform(InTransform)
        , Extents(InExtents)
    {}
 
    FTransform Transform;
    FVector2D Extents = FVector2D(ForceInit);
 
    FBox BuildAABB() const;
};
 
 
// ----------------------------------------------------------------------------------
 
class FInputWorldArea
{
public:
    enum class EType
    {
        LocalComponent, // Designates any landscape component (i.e. the input area corresponds to the component being requested), with an optional number of neighboring components around it
        SpecificComponent, // Designates a specific landscape component (based on its component key), with an optional number of neighboring components around it
        OOBox, // Designates a fixed world area (an object-oriented box)
        Infinite, // Designates the entire loaded landscape area
    };
 
    static FInputWorldArea CreateInfinite() { return FInputWorldArea(EType::Infinite); }
    static FInputWorldArea CreateLocalComponent(const FIntRect& InLocalArea = FIntRect()) { return FInputWorldArea(EType::LocalComponent, FIntPoint(ForceInit), InLocalArea); }
    static FInputWorldArea CreateSpecificComponent(const FIntPoint& InComponentKey, const FIntRect& InLocalArea = FIntRect()) { return FInputWorldArea(EType::SpecificComponent, InComponentKey, InLocalArea); }
    static FInputWorldArea CreateOOBox(const FOOBox2D& InOOBox) { return FInputWorldArea(EType::OOBox, FIntPoint(ForceInit), FIntRect(), InOOBox); }
 
    EType GetType() const { return Type; }
    FIntRect GetLocalComponentKeys(const FIntPoint& InComponentKey) const;
    FIntRect GetSpecificComponentKeys() const;
    const FOOBox2D& GetOOBox() const { check(Type == EType::OOBox); return OOBox2D; }
    const FOOBox2D* TryGetOOBox() const { return (Type == EType::OOBox) ? &OOBox2D : nullptr; }
 
    FBox ComputeWorldAreaAABB(const FTransform& InLandscapeTransform, const FBox& InLandscapeLocalBounds, const FTransform& InComponentTransform, const FBox& InComponentLocalBounds) const;
    FOOBox2D ComputeWorldAreaOOBB(const FTransform& InLandscapeTransform, const FBox& InLandscapeLocalBounds, const FTransform& InComponentTransform, const FBox& InComponentLocalBounds) const;
 
private: 
    FInputWorldArea(EType InType, const FIntPoint& InComponentKey = FIntPoint(ForceInit), const FIntRect& InLocalArea = FIntRect(), const FOOBox2D& InOOBox2D = FOOBox2D())
        : Type(InType)
        , SpecificComponentKey(InComponentKey)
        , LocalArea(InLocalArea)
        , OOBox2D(InOOBox2D)
    {}
 
private:
    EType Type = EType::LocalComponent;
    FIntPoint SpecificComponentKey = FIntPoint(ForceInit);
    FIntRect LocalArea; 
 
    FOOBox2D OOBox2D;
};
 
 
// ----------------------------------------------------------------------------------
 
class FOutputWorldArea
{
public:
    enum class EType
    {
        LocalComponent, // Designates any landscape component (i.e. the input area corresponds to the component being requested)
        SpecificComponent, // Designates a specific landscape component (based on its component key)
        OOBox, // Designates a fixed world area (an Object-oriented box)
    };
 
    static FOutputWorldArea CreateLocalComponent() { return FOutputWorldArea(EType::LocalComponent); }
    static FOutputWorldArea CreateSpecificComponent(const FIntPoint& InComponentKey) { return FOutputWorldArea(EType::SpecificComponent, InComponentKey); }
    static FOutputWorldArea CreateOOBox(const FOOBox2D& InOOBox) { return FOutputWorldArea(EType::OOBox, FIntPoint(ForceInit), InOOBox); }
 
    EType GetType() const { return Type; }
    const FIntPoint& GetSpecificComponentKey() const { check(Type == EType::SpecificComponent); return SpecificComponentKey; }
    const FOOBox2D& GetOOBox() const { check(Type == EType::OOBox); return OOBox2D; }
    const FOOBox2D* TryGetOOBox() const { return (Type == EType::OOBox) ? &OOBox2D : nullptr; }
 
    FBox ComputeWorldAreaAABB(const FTransform& InComponentTransform, const FBox& InComponentLocalBounds) const;
    FOOBox2D ComputeWorldAreaOOBB(const FTransform& InComponentTransform, const FBox& InComponentLocalBounds) const;
 
private:
    FOutputWorldArea(EType InType, const FIntPoint& InComponentKey = FIntPoint(ForceInit), const FOOBox2D& InOOBox = FOOBox2D())
        : Type(InType)
        , SpecificComponentKey(InComponentKey)
        , OOBox2D(InOOBox)
    {}
 
private:
    EType Type = EType::LocalComponent;
    FIntPoint SpecificComponentKey = FIntPoint(ForceInit);
    FOOBox2D OOBox2D;
};
 
 
// ----------------------------------------------------------------------------------
 
class FEditLayerRenderItem
{
public:
    FEditLayerRenderItem() = delete;
    FEditLayerRenderItem(const FEditLayerTargetTypeState& InTargetTypeState, const FInputWorldArea& InInputWorldArea, const FOutputWorldArea& InOutputWorldArea, bool bInModifyExistingWeightmapsOnly)
        : TargetTypeState(InTargetTypeState)
        , InputWorldArea(InInputWorldArea)
        , OutputWorldArea(InOutputWorldArea)
        , bModifyExistingWeightmapsOnly(bInModifyExistingWeightmapsOnly)
    {}
 
    const FEditLayerTargetTypeState& GetTargetTypeState() const { return TargetTypeState; }
 
    const FInputWorldArea& GetInputWorldArea() const { return InputWorldArea; }
    void SetInputWorldArea(const FInputWorldArea& InInputWorldArea) { InputWorldArea = InInputWorldArea; }
 
    const FOutputWorldArea& GetOutputWorldArea() const { return OutputWorldArea; }
    void SetOutputWorldArea(const FOutputWorldArea& InOutputWorldArea) { OutputWorldArea = InOutputWorldArea; }
 
    bool GetModifyExistingWeightmapsOnly() const { return bModifyExistingWeightmapsOnly; }
 
private:
    
    FEditLayerTargetTypeState TargetTypeState;
 
    FInputWorldArea InputWorldArea;
 
    FOutputWorldArea OutputWorldArea;
 
    bool bModifyExistingWeightmapsOnly = false;
};
 
 
// ----------------------------------------------------------------------------------
 
class IEditLayerRendererProvider
{
public:
    virtual ~IEditLayerRendererProvider() {}
 
    virtual TArray<FEditLayerRendererState> GetEditLayerRendererStates(const FMergeContext* InMergeContext) PURE_VIRTUAL(IEditLayerRendererProvider::GetEditLayerRendererStates, return {}; );
};
 
#endif // WITH_EDITOR
 
} // namespace UE::Landscape::EditLayers
 
 
// ----------------------------------------------------------------------------------
 
UINTERFACE()
class ULandscapeEditLayerRenderer :
    public UInterface
{
    GENERATED_BODY()
 
};
 
class ILandscapeEditLayerRenderer
{
    GENERATED_BODY()
 
#if WITH_EDITOR
public:
    using FRenderParams UE_DEPRECATED(5.6, "Use UE::Landscape::EditLayers::FRenderParams") = UE::Landscape::EditLayers::FRenderParams;
 
    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
        PURE_VIRTUAL(ILandscapeEditLayerRenderer::GetRendererStateInfo, );
 
    virtual FString GetEditLayerRendererDebugName() const 
        PURE_VIRTUAL(ILandscapeEditLayerRenderer::GetEditLayerRendererDebugName, return TEXT(""); );
 
    virtual TArray<UE::Landscape::EditLayers::FEditLayerRenderItem> GetRenderItems(const UE::Landscape::EditLayers::FMergeContext* InMergeContext) const
        PURE_VIRTUAL(ILandscapeEditLayerRenderer::GetRenderItems, return { }; );
 
    virtual UE::Landscape::EditLayers::ERenderFlags GetRenderFlags(const UE::Landscape::EditLayers::FMergeContext* InMergeContext) const
        PURE_VIRTUAL(ILandscapeEditLayerRenderer::GetRenderFlags, return UE::Landscape::EditLayers::ERenderFlags::None; );
 
    virtual bool RenderLayer(UE::Landscape::EditLayers::FRenderParams& RenderParams, UE::Landscape::FRDGBuilderRecorder& RDGBuilderRecorder)
        PURE_VIRTUAL(ILandscapeEditLayerRenderer::RenderLayer, return false; );
 
    virtual void BlendLayer(UE::Landscape::EditLayers::FRenderParams& RenderParams, UE::Landscape::FRDGBuilderRecorder& RDGBuilderRecorder) {}
 
    virtual bool CanGroupRenderLayerWith(TScriptInterface<ILandscapeEditLayerRenderer> InOtherRenderer) const { return false; }
 
    virtual void BeginRenderLayerGroup(UE::Landscape::EditLayers::FRenderParams& RenderParams, UE::Landscape::FRDGBuilderRecorder& RDGBuilderRecorder) {}
 
    virtual void EndRenderLayerGroup(UE::Landscape::EditLayers::FRenderParams& RenderParams, UE::Landscape::FRDGBuilderRecorder& RDGBuilderRecorder) {}
 
#endif // WITH_EDITOR
};