DecalRenderingShared.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "RendererInterface.h"
#include "DecalRenderingCommon.h"
 
class FDeferredDecalProxy;
class FMaterial;
class FMaterialRenderProxy;
class FScene;
class FViewInfo;
class FDecalVisibilityTaskData;
 
class FShader;
class FShaderMapPointerTable;
template<typename ShaderType, typename PointerTableType> class TShaderRefBase;
template<typename ShaderType> using TShaderRef = TShaderRefBase<ShaderType, FShaderMapPointerTable>;
 
struct FVisibleDecal
{
    FVisibleDecal(const FDeferredDecalProxy& InDecalProxy, float InConservativeRadius, float InFadeAlpha, EShaderPlatform ShaderPlatform, ERHIFeatureLevel::Type FeatureLevel);
 
    const FMaterialRenderProxy* MaterialProxy;
    uintptr_t Component;
    uint32 SortOrder;
    FDecalBlendDesc BlendDesc;
    float ConservativeRadius;
    float FadeAlpha;
    float InvFadeDuration;
    float InvFadeInDuration;
    float FadeStartDelayNormalized;
    float FadeInStartDelayNormalized;
    FLinearColor DecalColor;
    FTransform ComponentTrans;
    FBox BoxBounds;
};
 
using FVisibleDecalList = TArray<FVisibleDecal, SceneRenderingAllocator>;
using FRelevantDecalList = TArray<const FVisibleDecal*, SceneRenderingAllocator>;
 
class FDecalVisibilityViewPacket
{
public:
    FDecalVisibilityViewPacket(const FDecalVisibilityTaskData& InTaskData, const FScene& Scene, const FViewInfo& InView);
 
    ~FDecalVisibilityViewPacket()
    {
        check(bFinishCalled);
        check(AllTasksEvent.IsCompleted());
    }
 
    TConstArrayView<FVisibleDecal> FinishVisibleDecals();
    TConstArrayView<const FVisibleDecal*> FinishRelevantDecals(EDecalRenderStage Stage);
 
    void Finish()
    {
        bFinishCalled = true;
        AllTasksEvent.Trigger();
        AllTasksEvent.Wait();
    }
 
    bool HasStage(EDecalRenderStage Stage) const
    {
        return RelevantDecalsMap.Contains(Stage);
    }
 
private:
    const FDecalVisibilityTaskData& TaskData;
    const FViewInfo& View;
 
    struct FVisibleDecals
    {
        FVisibleDecalList List;
        UE::Tasks::FTask Task;
 
    } VisibleDecals;
 
    struct FRelevantDecals
    {
        FRelevantDecalList List;
        UE::Tasks::FTask Task;
    };
 
    TMap<EDecalRenderStage, FRelevantDecals> RelevantDecalsMap;
    UE::Tasks::FTaskEvent AllTasksEvent{ UE_SOURCE_LOCATION };
    bool bFinishCalled = false;
};
 
class FDecalVisibilityTaskData
{
public:
    static FDecalVisibilityTaskData* Launch(FRDGBuilder& GraphBuilder, const FScene& Scene, TConstArrayView<FViewInfo> Views);
 
    TConstArrayView<FVisibleDecal> FinishVisibleDecals(int32 ViewIndex)
    {
        return ViewPackets[ViewIndex].FinishVisibleDecals();
    }
 
    TConstArrayView<const FVisibleDecal*> FinishRelevantDecals(int32 ViewIndex, EDecalRenderStage Stage)
    {
        return ViewPackets[ViewIndex].FinishRelevantDecals(Stage);
    }
 
    bool HasStage(int32 ViewIndex, EDecalRenderStage Stage) const
    {
        return ViewPackets[ViewIndex].HasStage(Stage);
    }
 
    void Finish()
    {
        for (FDecalVisibilityViewPacket& ViewPacket : ViewPackets)
        {
            ViewPacket.Finish();
        }
    }
 
    bool IsDBufferEnabled() const
    {
        return bDBufferEnabled;
    }
 
    bool IsGBufferEnabled() const
    {
        return bGBufferEnabled;
    }
 
private:
    FDecalVisibilityTaskData(const FScene& Scene, TConstArrayView<FViewInfo> Views, bool bInDBufferEnabled, bool bInGBufferEnabled);
 
    const bool bDBufferEnabled;
    const bool bGBufferEnabled;
 
    TArray<FDecalVisibilityViewPacket, FRDGArrayAllocator> ViewPackets;
 
    friend class FDecalVisibilityViewPacket;
    RDG_FRIEND_ALLOCATOR_FRIEND(FDecalVisibilityTaskData);
};
 
namespace DecalRendering
{
    float GetDecalFadeScreenSizeMultiplier();
    float CalculateDecalFadeAlpha(float DecalFadeScreenSize, const FMatrix& ComponentToWorldMatrix, const FViewInfo& View, float FadeMultiplier);
    FMatrix ComputeComponentToClipMatrix(const FViewInfo& View, const FMatrix& DecalComponentToWorld);
    void SetVertexShaderOnly(FRHICommandList& RHICmdList, FGraphicsPipelineStateInitializer& GraphicsPSOInit, const FViewInfo& View, const FMatrix& FrustumComponentToClip);
    void SortDecalList(FRelevantDecalList& Decals);
    FVisibleDecalList BuildVisibleDecalList(TConstArrayView<FDeferredDecalProxy*> Decals, const FViewInfo& View);
    FRelevantDecalList BuildRelevantDecalList(TConstArrayView<FVisibleDecal> Decals, EDecalRenderStage DecalRenderStage);
    bool HasRelevantDecals(TConstArrayView<FVisibleDecal> Decals, EDecalRenderStage DecalRenderStage);
    bool GetShaders(ERHIFeatureLevel::Type FeatureLevel, const FMaterial& Material, EDecalRenderStage DecalRenderStage, TShaderRef<FShader>& OutVertexShader, TShaderRef<FShader>& OutPixelShader);
    bool SetupShaderState(ERHIFeatureLevel::Type FeatureLevel, const FMaterial& Material, EDecalRenderStage DecalRenderStage, FBoundShaderStateInput& OutBoundShaderState);
    void SetShader(FRHICommandList& RHICmdList, FGraphicsPipelineStateInitializer& GraphicsPSOInit, uint32 StencilRef, const FViewInfo& View, const FVisibleDecal& DecalData, EDecalRenderStage DecalRenderStage, const FMatrix& FrustumComponentToClip, const FScene* Scene = nullptr);
};