LandscapeEditResourcesSubsystem.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Subsystems/EngineSubsystem.h"
#include "Engine/TextureRenderTarget2D.h"
#include "LandscapeEditTypes.h"
#include "RHIAccess.h"
#include "RHITransition.h"
 
#if WITH_EDITOR
#include "Materials/Material.h"
#include "LandscapeUtils.h"
#endif // WITH_EDITOR
 
#include "LandscapeEditResourcesSubsystem.generated.h"
 
struct FResourceSizeEx;
class UTextureRenderTarget2D;
class UTextureRenderTarget2DArray;
class FRDGBuilder;
class FRHICommandListImmediate;
 
namespace UE::Landscape 
{
class FRDGBuilderRecorder;
 
struct FScratchRenderTargetParams
{
    FScratchRenderTargetParams() = default;
    explicit FScratchRenderTargetParams(const FString& InDebugName, bool bInExactDimensions, bool bInUseUAV, bool bInTargetArraySlicesIndependently, const FIntPoint& InResolution, int32 InNumSlices, ETextureRenderTargetFormat InFormat, const FLinearColor& InClearColor, ERHIAccess InInitialState)
        : DebugName(InDebugName)
        , bExactDimensions(bInExactDimensions)
        , bUseUAV(bInUseUAV)
        , bTargetArraySlicesIndependently(bInTargetArraySlicesIndependently)
        , Resolution(InResolution)
        , NumSlices(InNumSlices)
        , Format(InFormat)
        , ClearColor(InClearColor)
        , InitialState(InInitialState)
    {}
 
    FString DebugName;
    bool bExactDimensions = false;
    bool bUseUAV = false;
    bool bTargetArraySlicesIndependently = false;
    FIntPoint Resolution = FIntPoint(ForceInit);
    int32 NumSlices = 0; 
    ETextureRenderTargetFormat Format = ETextureRenderTargetFormat::RTF_RGBA8;
    FLinearColor ClearColor = FLinearColor(ForceInitToZero);
    ERHIAccess InitialState = ERHIAccess::None;
};
 
struct FScratchRenderTargetScope : public FNoncopyable
{
    FScratchRenderTargetScope() = delete;
    FScratchRenderTargetScope(const FScratchRenderTargetParams& InParams);
    ~FScratchRenderTargetScope();
 
    ULandscapeEditResourcesSubsystem* EditResourcesSubsystem = nullptr;
    ULandscapeScratchRenderTarget* RenderTarget = nullptr;
};
 
} // namespace UE::Landscape
 
UCLASS(Transient)
class ULandscapeScratchRenderTarget : public UObject
{
    GENERATED_BODY()
 
    friend class ULandscapeEditResourcesSubsystem;
    friend class FTransitionBatcherScope;
 
public:
    ULandscapeScratchRenderTarget();
 
    LANDSCAPE_API const FString& GetDebugName() const;
    UTextureRenderTarget* GetRenderTarget() const { return RenderTarget; }
    LANDSCAPE_API UTextureRenderTarget2D* GetRenderTarget2D() const;
    LANDSCAPE_API UTextureRenderTarget2D* TryGetRenderTarget2D() const;
    LANDSCAPE_API UTextureRenderTarget2DArray* GetRenderTarget2DArray() const;
    LANDSCAPE_API UTextureRenderTarget2DArray* TryGetRenderTarget2DArray() const;
    LANDSCAPE_API FIntPoint GetResolution() const;
    LANDSCAPE_API FIntPoint GetEffectiveResolution() const;
    LANDSCAPE_API int32 GetNumSlices() const;
    LANDSCAPE_API int32 GetEffectiveNumSlices() const;
    bool IsTexture2D() const { return (TryGetRenderTarget2D() != nullptr); }
    bool IsTexture2DArray() const { return (TryGetRenderTarget2DArray() != nullptr); }
    LANDSCAPE_API ETextureRenderTargetFormat GetFormat() const;
    LANDSCAPE_API FLinearColor GetClearColor() const;
    ERHIAccess GetCurrentState() const { return CurrentState; }
    const UE::Landscape::FScratchRenderTargetParams& GetCurrentRenderTargetParams() { return CurrentRenderTargetParams; }
 
    class FTransitionInfo
    {
    public:
        FTransitionInfo() = default;
        FTransitionInfo(FTextureResource* InResource, ERHIAccess InStateBefore, ERHIAccess InStateAfter)
            : Resource(InResource)
            , StateBefore(InStateBefore)
            , StateAfter(InStateAfter)
        {}
 
        FRHITransitionInfo ToRHITransitionInfo() const;
 
    private:
        FTextureResource* Resource = nullptr;
        ERHIAccess StateBefore = ERHIAccess::None;
        ERHIAccess StateAfter = ERHIAccess::None;
    };
 
    class FTransitionBatcherScope : public FNoncopyable
    {
    public:
        FTransitionBatcherScope(UE::Landscape::FRDGBuilderRecorder& RDGBuilderRecorder);
        ~FTransitionBatcherScope();
 
        void TransitionTo(ULandscapeScratchRenderTarget* InScratchRenderTarget, ERHIAccess InStateAfter);
 
    private:
        UE::Landscape::FRDGBuilderRecorder& RDGBuilderRecorder;
        TArray<FTransitionInfo> PendingTransitions;
    };
 
    struct FCopyFromParams
    {
        FIntPoint CopySize = FIntPoint(0, 0);
        FIntPoint SourcePosition = FIntPoint(0, 0);
        FIntPoint DestPosition = FIntPoint(0, 0);
        uint8 SourceMip = 0;
        uint8 DestMip = 0;
        uint32 SourceSliceIndex = 0;
        uint32 DestSliceIndex = 0;
    };
 
    struct FCopyFromTextureParams : public FCopyFromParams
    {
        explicit FCopyFromTextureParams(UTexture* InSourceTexture)
            : SourceTexture(InSourceTexture)
        {}
 
        UTexture* SourceTexture = nullptr;
    };
 
    struct FCopyFromScratchRenderTargetParams : public FCopyFromParams
    {
        explicit FCopyFromScratchRenderTargetParams(ULandscapeScratchRenderTarget* InSourceScratchRenderTarget)
            : SourceScratchRenderTarget(InSourceScratchRenderTarget)
        {
            // No need to copy anything beyond the effective resolution in the case of a scratch render target : 
            CopySize = InSourceScratchRenderTarget->GetEffectiveResolution();
        }
 
        ULandscapeScratchRenderTarget* SourceScratchRenderTarget = nullptr;
    };
    
    LANDSCAPE_API void CopyFrom(const FCopyFromTextureParams& InCopyParams, UE::Landscape::FRDGBuilderRecorder& RDGBuilderRecorder);
 
    LANDSCAPE_API void CopyFrom(const FCopyFromScratchRenderTargetParams& InCopyParams, UE::Landscape::FRDGBuilderRecorder& RDGBuilderRecorder);
 
    LANDSCAPE_API void TransitionTo(ERHIAccess InStateAfter, UE::Landscape::FRDGBuilderRecorder& RDGBuilderRecorder);
 
    LANDSCAPE_API void Clear(UE::Landscape::FRDGBuilderRecorder& RDGBuilderRecorder);
 
    bool IsCompatibleWith(const UE::Landscape::FScratchRenderTargetParams& InParams) const;
 
    bool IsInUse() const { return bIsInUse; }
 
private:
    void OnRequested(const UE::Landscape::FScratchRenderTargetParams& InParams);
    void OnReleased();
 
private:
    UPROPERTY(NonTransactional)
    TObjectPtr<UTextureRenderTarget> RenderTarget;
 
    // BEGIN Un-mutable section
    // The following variables are un-mutable after RenderTarget is initialized : 
    
    // Format of the render target. Technically, we could infer it from RenderTarget->Format but since it's stored as a EPixelFormat, 
    //  end there's no easy conversion from EPixelFormat to ETextureRenderTargetFormat, we store a copy here instead: 
    ETextureRenderTargetFormat RenderTargetFormat = ETextureRenderTargetFormat::RTF_RGBA8;
    // END Un-mutable section
 
    // Current state of the scratch render target :
    bool bIsInUse = false;
    UE::Landscape::FScratchRenderTargetParams CurrentRenderTargetParams;
    ERHIAccess CurrentState = ERHIAccess::None;
};
 
UCLASS()
class ULandscapeEditResourcesSubsystem : public UEngineSubsystem
{
    GENERATED_BODY()
 
public:
    ULandscapeEditResourcesSubsystem();
 
    // UEngineSubsystem implementation
    virtual void Initialize(FSubsystemCollectionBase& Collection) override;
    virtual void Deinitialize() override;
 
    ULandscapeScratchRenderTarget* RequestScratchRenderTarget(const UE::Landscape::FScratchRenderTargetParams& InParams);
 
    void ReleaseScratchRenderTarget(ULandscapeScratchRenderTarget* InScratchRenderTarget);
 
#if WITH_EDITOR
    UMaterialInterface* GetLayerDebugColorMaterial() const { return LayerDebugColorMaterial; }
    UMaterialInterface* GetSelectionColorMaterial() const { return SelectionColorMaterial; }
    UMaterialInterface* GetSelectionRegionMaterial() const { return SelectionRegionMaterial; }
    UMaterialInterface* GetMaskRegionMaterial() const { return MaskRegionMaterial; }
    UMaterialInterface* GetColorMaskRegionMaterial() const { return ColorMaskRegionMaterial; }
    UTexture2D* GetLandscapeBlackTexture() const { return LandscapeBlackTexture; }
    UMaterialInterface* GetLandscapeLayerUsageMaterial() const { return LandscapeLayerUsageMaterial; }
    UMaterialInterface* GetLandscapeDirtyMaterial() const { return LandscapeDirtyMaterial; }
#endif // WITH_EDITOR
 
private:
    UPROPERTY(Transient, NonTransactional)
    TArray<TObjectPtr<ULandscapeScratchRenderTarget>> ScratchRenderTargets;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY(Transient, NonTransactional) 
    TObjectPtr<UMaterialInterface> LayerDebugColorMaterial;
 
    UPROPERTY(Transient, NonTransactional) 
    TObjectPtr<UMaterialInterface> SelectionColorMaterial;
 
    UPROPERTY(Transient, NonTransactional) 
    TObjectPtr<UMaterialInterface> SelectionRegionMaterial;
 
    UPROPERTY(Transient, NonTransactional) 
    TObjectPtr<UMaterialInterface> MaskRegionMaterial;
 
    UPROPERTY(Transient, NonTransactional) 
    TObjectPtr<UMaterialInterface> ColorMaskRegionMaterial;
 
    UPROPERTY(Transient, NonTransactional) 
    TObjectPtr<UTexture2D> LandscapeBlackTexture;
 
    UPROPERTY(Transient, NonTransactional) 
    TObjectPtr<UMaterialInterface> LandscapeLayerUsageMaterial;
 
    UPROPERTY(Transient, NonTransactional) 
    TObjectPtr<UMaterialInterface> LandscapeDirtyMaterial;
#endif // WITH_EDITORONLY_DATA
     
};