ShadowRendering.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    ShadowRendering.h: Shadow rendering definitions.
=============================================================================*/
 
#pragma once
 
#include "CoreMinimal.h"
#include "HAL/IConsoleManager.h"
#include "Templates/RefCounting.h"
#include "RHI.h"
#include "DataDrivenShaderPlatformInfo.h"
#include "LightSceneProxy.h"
#include "RenderResource.h"
#include "UniformBuffer.h"
#include "SceneInterface.h"
#include "ShaderParameters.h"
#include "Shader.h"
#include "HitProxies.h"
#include "ConvexVolume.h"
#include "RHIStaticStates.h"
#include "RendererInterface.h"
#include "SceneManagement.h"
#include "ScenePrivateBase.h"
#include "SceneCore.h"
#include "GlobalShader.h"
#include "SystemTextures.h"
#include "PostProcess/SceneRenderTargets.h"
#include "SceneRenderTargetParameters.h"
#include "ShaderParameterUtils.h"
#include "LightRendering.h"
#include "HairStrands/HairStrandsRendering.h"
#include "Substrate/Substrate.h"
#include "SimpleMeshDrawCommandPass.h"
#include "Engine/SubsurfaceProfile.h"
 
class FPrimitiveSceneInfo;
class FPrimitiveSceneProxy;
class FProjectedShadowInfo;
class FScene;
class FSceneRenderer;
class FViewInfo;
class FVirtualShadowMapArrayCacheManager;
class FVirtualShadowMapPerLightCacheEntry;
class FLightTileIntersectionParameters;
class FDistanceFieldCulledObjectBufferParameters;
 
namespace ShadowRendering
{
    // Use Shadow stencil mask is set to 0x07u instead of 0xFF so that that highest bit can be used for Substrate classification without clearing the stencil bit for pre-shadow/per-object static shadow mask
    constexpr uint32 ShadowStencilMask = 0x07u;
};
 
DECLARE_GPU_DRAWCALL_STAT_NAMED_EXTERN(ShadowDepths, TEXT("Shadow Depths"));
 
extern void DrawStencilingCone(const FMatrix& ConeToWorld, float ConeAngle, float SphereRadius, const FVector& PreViewTranslation);
 
class FShadowDepthBasePS;
 
void OverrideWithDefaultMaterialForShadowDepth(
    const FMaterialRenderProxy*& InOutMaterialRenderProxy, 
    const FMaterial*& InOutMaterialResource,
    ERHIFeatureLevel::Type InFeatureLevel
    );
 
enum EShadowDepthRenderMode
{
    ShadowDepthRenderMode_Normal,
 
    ShadowDepthRenderMode_EmissiveOnly,
 
    ShadowDepthRenderMode_GIBlockingVolumes,
};
 
enum class EShadowDepthType
{
    None = 0,
    VSM = 1 << 0,
    Directional = 1 << 1,
    Point = 1 << 2,
    OnePassPoint = 1 << 3
};
 
ENUM_CLASS_FLAGS(EShadowDepthType);
 
extern EMeshPass::Type GetShadowMeshPassType(EShadowDepthType ShadowDepthType);
 
extern bool UseCachedMeshDrawCommands(EShadowDepthType ShadowDepthType);
 
enum class EShadowMeshSelection : uint8
{
    SM = 1U << 0U,
    VSM = 1U << 1U, // declared if GPU-Scene instace culling is supported.
    All = SM | VSM,
};
 
ENUM_CLASS_FLAGS(EShadowMeshSelection)
 
 
class FShadowDepthPassMeshProcessor : public FSceneRenderingAllocatorObject<FShadowDepthPassMeshProcessor>, public FMeshPassProcessor
{
public:
 
    FShadowDepthPassMeshProcessor(
        const FScene* Scene, 
        const ERHIFeatureLevel::Type InFeatureLevel,
        const FSceneView* InViewIfDynamicMeshCommand,
        EShadowDepthType ShadowDepthType,
        FMeshPassDrawListContext* InDrawListContext);
 
    virtual void AddMeshBatch(const FMeshBatch& RESTRICT MeshBatch, uint64 BatchElementMask, const FPrimitiveSceneProxy* RESTRICT PrimitiveSceneProxy, int32 StaticMeshId = -1) override final;
    virtual void CollectPSOInitializers(const FSceneTexturesConfig& SceneTexturesConfig, const FMaterial& Material, const FPSOPrecacheVertexFactoryData& VertexFactoryData, const FPSOPrecacheParams& PreCacheParams, TArray<FPSOPrecacheData>& PSOInitializers) override final;
 
    FMeshPassProcessorRenderState PassDrawRenderState;
 
private:
    bool TryAddMeshBatch(const FMeshBatch& RESTRICT MeshBatch,
        uint64 BatchElementMask,
        const FPrimitiveSceneProxy* RESTRICT PrimitiveSceneProxy,
        int32 StaticMeshId,
        const FMaterialRenderProxy& MaterialRenderProxy,
        const FMaterial& Material);
 
    bool Process(
        const FMeshBatch& RESTRICT MeshBatch,
        uint64 BatchElementMask,
        int32 StaticMeshId,
        const FPrimitiveSceneProxy* RESTRICT PrimitiveSceneProxy,
        const FMaterialRenderProxy& RESTRICT MaterialRenderProxy,
        const FMaterial& RESTRICT MaterialResource,
        ERasterizerFillMode MeshFillMode,
        ERasterizerCullMode MeshCullMode);
 
    void CollectPSOInitializersForEachShadowDepthType(
        const FPSOPrecacheVertexFactoryData& VertexFactoryData,
        const FMaterial& RESTRICT MaterialResource,
        ERasterizerFillMode MeshFillMode,
        ERasterizerCullMode MeshCullMode,
        bool bCastShadowAsTwoSided,
        TArray<FPSOPrecacheData>& PSOInitializers);
 
    void CollectPSOInitializersForEachStreamSetup(
        const FPSOPrecacheVertexFactoryData& VertexFactoryData,
        const FMaterial& RESTRICT MaterialResource,
        EShadowDepthType InShadowDepthType,
        ERasterizerFillMode MeshFillMode,
        ERasterizerCullMode MeshCullMode,
        bool bRequired,
        TArray<FPSOPrecacheData>& PSOInitializers);
 
    void CollectPSOInitializersInternal(
        const FPSOPrecacheVertexFactoryData& VertexFactoryData,
        const FMaterial& RESTRICT MaterialResource,
        EShadowDepthType InShadowDepthType,
        ERasterizerFillMode MeshFillMode,
        ERasterizerCullMode MeshCullMode,
        bool bSupportsPositionAndNormalOnlyStream,
        bool bRequired,
        TArray<FPSOPrecacheData>& PSOInitializers);
 
    EShadowDepthType ShadowDepthType;
    EShadowMeshSelection MeshSelectionMask = EShadowMeshSelection::All;
};
 
enum EShadowDepthCacheMode
{
    SDCM_MovablePrimitivesOnly,
    SDCM_StaticPrimitivesOnly,
    SDCM_CSMScrolling,
    SDCM_Uncached
};
 
inline bool IsShadowCacheModeOcclusionQueryable(EShadowDepthCacheMode CacheMode)
{
    // SDCM_StaticPrimitivesOnly shadowmaps are emitted randomly as the cache needs to be updated,
    // And therefore not appropriate for occlusion queries which are latent and therefore need to be stable.
    // Only one the cache modes from ComputeWholeSceneShadowCacheModes should be queryable
    return CacheMode != SDCM_StaticPrimitivesOnly;
}
 
struct FTiledShadowRendering
{
    enum class ETileType : uint8
    {
        Tile16bits,
        Tile12bits
    };
    FRDGBufferRef       DrawIndirectParametersBuffer;
    FRDGBufferSRVRef    TileListDataBufferSRV;
    uint32              TileSize;
    ETileType           TileType = ETileType::Tile16bits;
};
 
class FShadowMapRenderTargets
{
public:
    TArray<IPooledRenderTarget*, SceneRenderingAllocator> ColorTargets;
    IPooledRenderTarget* DepthTarget;
 
    FShadowMapRenderTargets() :
        DepthTarget(nullptr)
    {}
 
    FIntPoint GetSize() const
    {
        if (DepthTarget)
        {
            return DepthTarget->GetDesc().Extent;
        }
        else 
        {
            check(ColorTargets.Num() > 0);
            return ColorTargets[0]->GetDesc().Extent;
        }
    }
 
    void CopyReferencesFromRenderTargets(const FShadowMapRenderTargetsRefCounted& SourceTargets)
    {
        int32 ColorTargetsCount = SourceTargets.ColorTargets.Num();
        ColorTargets.Empty(ColorTargetsCount);
        ColorTargets.AddDefaulted(ColorTargetsCount);
        for (int32 TargetIndex = 0; TargetIndex < ColorTargetsCount; TargetIndex++)
        {
            ColorTargets[TargetIndex] = SourceTargets.ColorTargets[TargetIndex].GetReference();
        }
 
        DepthTarget = SourceTargets.DepthTarget.GetReference();
    }
};
 
typedef TFunctionRef<void(FRHICommandList& RHICmdList, bool bFirst)> FBeginShadowRenderPassFunction;
using FPackedNaniteView = Nanite::FPackedView;
 
BEGIN_GLOBAL_SHADER_PARAMETER_STRUCT(FShadowDepthPassUniformParameters,)
    SHADER_PARAMETER_STRUCT(FSceneTextureUniformParameters, SceneTextures)
    SHADER_PARAMETER(FMatrix44f, ProjectionMatrix)
    SHADER_PARAMETER(FMatrix44f, ViewMatrix)
    SHADER_PARAMETER(FVector4f, ShadowParams)
    SHADER_PARAMETER(float, bClampToNearPlane)
    SHADER_PARAMETER_ARRAY(FMatrix44f, ShadowViewProjectionMatrices, [6])
    SHADER_PARAMETER_ARRAY(FMatrix44f, ShadowViewMatrices, [6])
    SHADER_PARAMETER(int, bRenderToVirtualShadowMap)
 
    SHADER_PARAMETER_RDG_TEXTURE(Texture2D<uint>, VirtualSmPageTable)
    SHADER_PARAMETER_RDG_BUFFER_SRV(StructuredBuffer< FPackedNaniteView >, PackedNaniteViews)
    SHADER_PARAMETER_RDG_BUFFER_SRV(StructuredBuffer< uint4 >, AllocatedPageRectBounds)
    SHADER_PARAMETER_RDG_BUFFER_SRV(StructuredBuffer< uint4 >, UncachedPageRectBounds)
    SHADER_PARAMETER_RDG_TEXTURE_UAV(RWTexture2DArray< uint >, OutDepthBufferArray)
END_GLOBAL_SHADER_PARAMETER_STRUCT()
 
BEGIN_GLOBAL_SHADER_PARAMETER_STRUCT(FMobileShadowDepthPassUniformParameters, RENDERER_API)
    SHADER_PARAMETER_STRUCT(FMobileSceneTextureUniformParameters, SceneTextures)
    SHADER_PARAMETER(FMatrix44f, ProjectionMatrix)
    SHADER_PARAMETER(FMatrix44f, ViewMatrix)
    SHADER_PARAMETER(FVector4f, ShadowParams)
    SHADER_PARAMETER(float, bClampToNearPlane)
    SHADER_PARAMETER_ARRAY(FMatrix44f, ShadowViewProjectionMatrices, [6])
END_GLOBAL_SHADER_PARAMETER_STRUCT()
 
class FProjectedShadowInfo : public FRefCountedObject
{
public:
    typedef TArray<const FPrimitiveSceneInfo*,SceneRenderingAllocator> PrimitiveArrayType;
 
    FViewInfo* ShadowDepthView;
 
    FShadowMapRenderTargets RenderTargets;
 
    EShadowDepthCacheMode CacheMode;
 
    FViewInfo* DependentView;
 
    int32 ShadowId;
 
    FVector PreShadowTranslation;
 
    FMatrix TranslatedWorldToView;
 
    FMatrix ViewToClipInner;
    
    FMatrix ViewToClipOuter;
    
    FMatrix44f TranslatedWorldToClipInnerMatrix;
    FMatrix44f TranslatedWorldToClipOuterMatrix;
 
    FMatrix44f InvReceiverInnerMatrix;
 
    float InvMaxSubjectDepth;
 
    float MaxSubjectZ;
    float MinSubjectZ;
 
    FConvexVolume CasterOuterFrustum;
 
    FConvexVolume ReceiverInnerFrustum;
 
    float MinPreSubjectZ;
 
    FSphere ShadowBounds;
 
    FShadowCascadeSettings CascadeSettings;
 
    uint32 X;
    uint32 Y;
 
    uint32 ResolutionX;
    uint32 ResolutionY;
 
    uint32 BorderSize;
 
    FIntRect ScissorRectOptim;
 
    void ComputeScissorRectOptim();
 
    float MaxScreenPercent;
 
    TArray<float, TInlineAllocator<2> > FadeAlphas;
 
    uint32 bAllocated : 1;
 
    uint32 bRendered : 1;
 
    uint32 bAllocatedInPreshadowCache : 1;
 
    uint32 bDepthsCached : 1;
 
    // redundant to LightSceneInfo->Proxy->GetLightType() == LightType_Directional, could be made ELightComponentType LightType
    uint32 bDirectionalLight : 1;
 
    uint32 bOnePassPointLightShadow : 1;
 
    uint32 bVSM : 1;
 
    uint32 bWholeSceneShadow : 1;
 
    uint32 bTranslucentShadow : 1;
 
    uint32 bRayTracedDistanceField : 1;
 
    uint32 bCapsuleShadow : 1;
 
    uint32 bPreShadow : 1;
 
    uint32 bSelfShadowOnly : 1;
 
    uint32 bPerObjectOpaqueShadow : 1;
 
    uint32 bTransmission : 1;
 
    uint32 bHairStrandsDeepShadow : 1;
 
    uint32 bNaniteGeometry : 1;
 
    uint32 bContainsNaniteSubjects : 1;
    uint32 bShouldRenderVSM : 1;
 
    uint32 bVolumetricShadow : 1;
 
    EShadowMeshSelection MeshSelectionMask = EShadowMeshSelection::All;
 
    TSharedPtr<FVirtualShadowMapPerLightCacheEntry> VirtualShadowMapPerLightCacheEntry;
    TSharedPtr<FVirtualShadowMapClipmap> VirtualShadowMapClipmap;
 
    TArray<FMatrix> OnePassShadowViewProjectionMatrices;
 
    TArray<FMatrix> OnePassShadowViewMatrices;
    
    FMatrix OnePassShadowFaceProjectionMatrix;
 
    float PerObjectShadowFadeStart;
    float InvPerObjectShadowFadeLength;
 
    float CSMScrollingZOffset;
 
    FVector4f OverlappedUVOnCachedShadowMap;
    FVector4f OverlappedUVOnCurrentShadowMap;
 
    TArray<FPlane, TInlineAllocator<4>> CSMScrollingExtraCullingPlanes;
 
    int32 ProjectionIndex = 0;
 
    int32 SubjectPrimitiveComponentIndex = -1;
 
    int32 ExplicitNaniteInstanceChunkStartOffset = INDEX_NONE;
    int32 ExplicitNaniteInstanceChunkEndOffset = INDEX_NONE;
    int32 ExplicitNaniteInstanceLastChunkSize = 0;
 
    TArray<int32, TInlineAllocator<6> > ViewIds;
    
public:
 
    // default constructor
    FProjectedShadowInfo();
 
    ~FProjectedShadowInfo();
 
    bool SetupPerObjectProjection(
        FLightSceneInfo* InLightSceneInfo,
        const FPrimitiveSceneInfo* InParentSceneInfo,
        const FPerObjectProjectedShadowInitializer& Initializer,
        bool bInPreShadow,
        uint32 InResolutionX,
        uint32 MaxShadowResolutionY,
        uint32 InBorderSize,
        float InMaxScreenPercent,
        bool bInTranslucentShadow
        );
 
    void SetupWholeSceneProjection(
        FLightSceneInfo* InLightSceneInfo,
        FViewInfo* InDependentView,
        const FWholeSceneProjectedShadowInitializer& Initializer,
        uint32 InResolutionX,
        uint32 InResolutionY,
        uint32 InSnapResolutionX,
        uint32 InSnapResolutionY,
        uint32 InBorderSize
        );
 
    void SetupClipmapProjection(
        FLightSceneInfo* InLightSceneInfo,
        FViewInfo* InDependentView,
        const TSharedPtr<FVirtualShadowMapClipmap> &VirtualShadowMapClipmap,
        float InMaxNonFarCascadeDistance
        );
 
    FViewMatrices GetShadowDepthRenderingViewMatrices(int32 CubeFaceIndex = -1, bool bUseForVSMCubeFaceWorkaround = false) const;
 
    float GetShaderDepthBias() const { return ShaderDepthBias; }
    float GetShaderSlopeDepthBias() const { return ShaderSlopeDepthBias; }
    float GetShaderMaxSlopeDepthBias() const { return ShaderMaxSlopeDepthBias; }
    float GetShaderReceiverDepthBias() const;
 
    void SetStateForView(FRHICommandList& RHICmdList, bool bRequiresBorderClamp = false) const;
 
    FIntRect GetInnerViewRect() const
    {
        return {
            int32(X + BorderSize),
            int32(Y + BorderSize),
            int32(X + BorderSize + ResolutionX),
            int32(Y + BorderSize + ResolutionY),
            };
    }
 
    FIntRect GetOuterViewRect() const   
    {
        return {
            int32(X),
            int32(Y),
            int32(X + 2 * BorderSize + ResolutionX),
            int32(Y + 2 * BorderSize + ResolutionY),
        };
    }
 
    void SetStateForDepth(FMeshPassProcessorRenderState& DrawRenderState) const;
 
    void ClearDepth(FRHICommandList& RHICmdList) const;
 
    void RenderTranslucencyDepths(FRDGBuilder& GraphBuilder, class FSceneRenderer* SceneRenderer, const FRenderTargetBindingSlots& RenderTargets, FInstanceCullingManager& InstanceCullingManager);
 
    static bool SupportsShadowStencilCulling(FStaticShaderPlatform ShaderPlatform);
 
    bool UseShadowStencilCulling(const FViewInfo& View) const;
 
    static FRHIBlendState* GetBlendStateForProjection(
        int32 ShadowMapChannel,
        bool bIsWholeSceneDirectionalShadow,
        bool bUseFadePlane,
        bool bProjectingForForwardShading,
        bool bMobileModulatedProjections);
 
    FRHIBlendState* GetBlendStateForProjection(bool bProjectingForForwardShading, bool bMobileModulatedProjections) const;
 
    void RenderProjection(
        FRDGBuilder& GraphBuilder,
        const FShadowProjectionPassParameters& CommonPassParameters,
        int32 ViewIndex,
        const FViewInfo* View,
        const FLightSceneProxy* LightSceneProxy,
        const FSceneRenderer* SceneRender,
        bool bProjectingForForwardShading,
        bool bSubPixelShadow) const;
 
    void RenderProjectionInternal(
        FRHICommandList& RHICmdList,
        int32 ViewIndex,
        const FViewInfo* View,
        const FLightSceneProxy* LightSceneProxy,
        const FSceneRenderer* SceneRender,
        bool bProjectingForForwardShading,
        bool bMobileModulatedProjections,
        const FInstanceCullingDrawParams& InstanceCullingDrawParams, 
        FRHIUniformBuffer* HairStrandsUniformBuffer) const;
 
    void RenderMobileModulatedShadowProjection(
        FRHICommandList& RHICmdList,
        int32 ViewIndex,
        const FViewInfo* View,
        const FLightSceneProxy* LightSceneProxy,
        const FSceneRenderer* SceneRender) const;
 
    void RenderDepth(
        FRDGBuilder& GraphBuilder,
        const FSceneRenderer* SceneRenderer,
        FRDGTextureRef ShadowDepthTexture,
        bool bDoParallelDispatch,
        bool bDoCrossGPUCopy);
 
    void ResetRayTracedDistanceFieldShadow(const FViewInfo* View)
    {
        DistanceFieldShadowViewGPUData& SDFShadowViewGPUData = CachedDistanceFieldShadowViewGPUData.FindOrAdd(View);
        SDFShadowViewGPUData.RayTracedShadowsTexture = nullptr;
    }
 
    FScreenPassTexture RenderRayTracedDistanceFieldProjection(
        FRDGBuilder& GraphBuilder,
        bool bAsyncCompute,
        const FMinimalSceneTextures& SceneTextures,
        const FViewInfo& View,
        const FIntRect& ScissorRect);
 
    void RenderRayTracedDistanceFieldProjection(
        FRDGBuilder& GraphBuilder,
        const FMinimalSceneTextures& SceneTextures,
        FRDGTextureRef ScreenShadowMaskTexture,
        const FViewInfo& View,
        FIntRect ScissorRect,
        bool bProjectingForForwardShading,
        bool bForceRGBModulation = false,
        FTiledShadowRendering* TiledShadowRendering = nullptr);
 
    void RenderOnePassPointLightProjection(
        FRDGBuilder& GraphBuilder,
        const FShadowProjectionPassParameters& CommonPassParameters,
        int32 ViewIndex,
        const FViewInfo& View,
        const FLightSceneProxy* LightSceneProxy,
        bool bProjectingForForwardShading,
        bool bSubPixelShadow) const;
 
    void RenderFrustumWireframe(FPrimitiveDrawInterface* PDI) const;
 
    bool AddSubjectPrimitive(FPrimitiveSceneInfo* PrimitiveSceneInfo, TArrayView<FViewInfo> ViewArray, bool bRecordShadowSubjectForMobileShading, bool bInvertViewShadowRelevance = false);
 
    uint64 AddSubjectPrimitive_AnyThread(
        const FPrimitiveSceneInfoCompact& PrimitiveSceneInfoCompact,
        TArrayView<FViewInfo> ViewArray,
        ERHIFeatureLevel::Type FeatureLevel,
        struct FAddSubjectPrimitiveStats& OutStats,
        struct FAddSubjectPrimitiveOverflowedIndices& OverflowBuffer) const;
 
    void PresizeSubjectPrimitiveArrays(struct FAddSubjectPrimitiveStats const& Stats);
 
    void FinalizeAddSubjectPrimitive(
        FDynamicShadowsTaskData& TaskData,
        struct FAddSubjectPrimitiveOp const& Op,
        TArrayView<FViewInfo> ViewArray,
        struct FFinalizeAddSubjectPrimitiveContext& Context);
 
    bool HasSubjectPrims() const;
 
    void AddReceiverPrimitive(FPrimitiveSceneInfo* PrimitiveSceneInfo);
 
    enum class EGatherDynamicMeshElementsPass : uint8
    {
        // Processes all operations in a single pass.
        All,
 
        // Parallel pass runs first and processes elements in parallel with other shadows.
        Parallel,
 
        // Serial pass runs second and processes elements serially other shadows.
        Serial,
    };
 
    bool GatherDynamicMeshElements(FMeshElementCollector& MeshCollector, FSceneRenderer& Renderer, class FVisibleLightInfo& VisibleLightInfo, TArray<const FSceneView*>& ReusedViewsArray, EGatherDynamicMeshElementsPass Pass);
 
    void SetupMeshDrawCommandsForShadowDepth(FSceneRenderer& Renderer, FInstanceCullingManager& InstanceCullingManager);
 
    void SetupMeshDrawCommandsForProjectionStenciling(FSceneRenderer& Renderer, FInstanceCullingManager& InstanceCullingManager);
 
    bool SubjectsVisible(const FViewInfo& View) const;
 
    void ClearTransientArrays();
    
    friend uint32 GetTypeHash(const FProjectedShadowInfo* ProjectedShadowInfo)
    {
        return PointerHash(ProjectedShadowInfo);
    }
 
    FMatrix GetScreenToShadowMatrix(const FSceneView& View) const
    {
        return GetScreenToShadowMatrix(View, X, Y, ResolutionX, ResolutionY);
    }
 
    FVector4f GetClipToShadowBufferUvScaleBias() const;
 
    FMatrix GetScreenToShadowMatrix(const FSceneView& View, uint32 TileOffsetX, uint32 TileOffsetY, uint32 TileResolutionX, uint32 TileResolutionY) const;
 
    FMatrix GetWorldToShadowMatrix(FVector4f& ShadowmapMinMax, const FIntPoint* ShadowBufferResolutionOverride = nullptr) const;
 
    FIntPoint GetShadowBufferResolution() const
    {
        if (HasVirtualShadowMap())
        {
            return FIntPoint(FVirtualShadowMap::VirtualMaxResolutionXY, FVirtualShadowMap::VirtualMaxResolutionXY);
        }
        return RenderTargets.GetSize();
    }
 
    void UpdateShaderDepthBias();
 
    float ComputeTransitionSize() const;
 
    bool IsWholeSceneDirectionalShadow() const;
    bool IsWholeScenePointLightShadow() const;
 
    bool ShouldClampToNearPlane() const
    {
        return IsWholeSceneDirectionalShadow() || (bPreShadow && bDirectionalLight);
    }
 
    // 0 if Setup...() wasn't called yet
    FLightSceneInfo& GetLightSceneInfo() const { return *LightSceneInfo; }
    const FLightSceneInfoCompact& GetLightSceneInfoCompact() const { return LightSceneInfoCompact; }
    const FPrimitiveSceneInfo* GetParentSceneInfo() const { return ParentSceneInfo; }
 
    void SetupShadowDepthView(FSceneRenderer* SceneRenderer);
 
    EShadowDepthType GetShadowDepthType() const 
    {
        EShadowDepthType ShadowDepthType = bVSM ? EShadowDepthType::VSM : EShadowDepthType::None;
 
        if (bDirectionalLight)
        {
            ShadowDepthType |= EShadowDepthType::Directional;
        }
        else if (bOnePassPointLightShadow)
        {
            ShadowDepthType |= EShadowDepthType::OnePassPoint;
        }
        else
        {
            ShadowDepthType |= EShadowDepthType::Point;
        }
 
        return ShadowDepthType;
    }
 
    EMeshPass::Type GetTargetMeshPassType() const
    {
        return ::GetShadowMeshPassType(GetShadowDepthType());
    }
 
    bool HasVirtualShadowMap() const { return VirtualShadowMapPerLightCacheEntry.IsValid(); }
 
    FParallelMeshDrawCommandPass& GetShadowDepthPass() { return ShadowDepthPass; }
 
    float GetMaxNonFarCascadeDistance() const { return MaxNonFarCascadeDistance; }
 
    void BuildRenderingCommands(
        FRDGBuilder& GraphBuilder,
        FGPUScene& GPUScene,
        FInstanceCullingDrawParams& InstanceCullingDrawParams)
    {
        ShadowDepthView->DynamicPrimitiveCollector.Commit();
        return ShadowDepthPass.BuildRenderingCommands(GraphBuilder, GPUScene, InstanceCullingDrawParams);
    }
 
    bool ShouldUseCSMScissorOptim() const;
 
    const TArray<FMeshBatchAndRelevance, SceneRenderingAllocator>& GetDynamicSubjectHeterogeneousVolumeMeshElements() const { return DynamicSubjectHeterogeneousVolumeMeshElements; }
 
private:
    // 0 if Setup...() wasn't called yet
    FLightSceneInfo* LightSceneInfo;
    FLightSceneInfoCompact LightSceneInfoCompact;
 
    const FPrimitiveSceneInfo* ParentSceneInfo;
 
    PrimitiveArrayType DynamicSubjectPrimitives;
    PrimitiveArrayType ReceiverPrimitives;
    PrimitiveArrayType SubjectTranslucentPrimitives;
    PrimitiveArrayType SubjectHeterogeneousVolumePrimitives;
 
    TArray<FMeshBatchAndRelevance,SceneRenderingAllocator> DynamicSubjectMeshElements;
    TArray<FMeshBatchAndRelevance,SceneRenderingAllocator> DynamicSubjectTranslucentMeshElements;
    TArray<FMeshBatchAndRelevance, SceneRenderingAllocator> DynamicSubjectHeterogeneousVolumeMeshElements;
 
    TArray<const FStaticMeshBatch*, SceneRenderingAllocator> SubjectMeshCommandBuildRequests;
    TArray<EMeshDrawCommandCullingPayloadFlags, SceneRenderingAllocator> SubjectMeshCommandBuildFlags;
 
    int32 NumDynamicSubjectMeshElements;
 
    int32 NumSubjectMeshCommandBuildRequestElements;
 
    FMeshCommandOneFrameArray ShadowDepthPassVisibleCommands;
    FParallelMeshDrawCommandPass ShadowDepthPass;
 
    TArray<FSimpleMeshDrawCommandPass *, TInlineAllocator<8>> ProjectionStencilingPasses;
 
    FDynamicMeshDrawCommandStorage DynamicMeshDrawCommandStorage;
    FGraphicsMinimalPipelineStateSet GraphicsMinimalPipelineStateSet;
    bool NeedsShaderInitialisation;
    // If >= 0.0f then this records the cascade distance to the farthest non-'far' shadow cascade. Only used for clipmaps at the moment.
    float MaxNonFarCascadeDistance = -1.0f;
 
    float ShaderDepthBias;
    float ShaderSlopeDepthBias;
    float ShaderMaxSlopeDepthBias;
 
    struct DistanceFieldShadowViewGPUData 
    {
        FRDGTextureRef RayTracedShadowsTexture = nullptr;
 
        FLightTileIntersectionParameters*           SDFLightTileIntersectionParameters = nullptr;
        FDistanceFieldCulledObjectBufferParameters* SDFCulledObjectBufferParameters = nullptr;
        FLightTileIntersectionParameters*           HeightFieldLightTileIntersectionParameters = nullptr;
        FDistanceFieldCulledObjectBufferParameters* HeightFieldCulledObjectBufferParameters = nullptr;
    };
    TMap<const FViewInfo*, DistanceFieldShadowViewGPUData> CachedDistanceFieldShadowViewGPUData;
 
    void CopyCachedShadowMap(
        FRDGBuilder& GraphBuilder,
        const FViewInfo& View,
        const FSceneRenderer* SceneRenderer,
        const FRenderTargetBindingSlots& RenderTargets,
        const FMeshPassProcessorRenderState& DrawRenderState);
 
    float GetLODDistanceFactor() const;
 
    void ModifyViewForShadow(FViewInfo* FoundView) const;
 
    friend class FVirtualShadowMapArray;
    void BeginRenderView(FRDGBuilder& GraphBuilder, FScene* Scene);
 
    FViewInfo* FindViewForShadow(FSceneRenderer* SceneRenderer) const;
 
    void AddCachedMeshDrawCommandsForPass(
        const FMeshDrawCommandPrimitiveIdInfo &PrimitiveIdInfo,
        const FPrimitiveSceneInfo* InPrimitiveSceneInfo,
        const FStaticMeshBatchRelevance& RESTRICT StaticMeshRelevance,
        const FStaticMeshBatch& StaticMesh,
        EMeshDrawCommandCullingPayloadFlags CullingPayloadFlags,
        const FScene* Scene,
        EMeshPass::Type PassType,
        FMeshCommandOneFrameArray& VisibleMeshCommands,
        TArray<const FStaticMeshBatch*, SceneRenderingAllocator>& MeshCommandBuildRequests,
        TArray<EMeshDrawCommandCullingPayloadFlags, SceneRenderingAllocator> MeshCommandBuildFlags,
        int32& NumMeshCommandBuildRequestElements);
 
    void AddCachedMeshDrawCommands_AnyThread(
        const FScene* Scene,
        const FStaticMeshBatchRelevance& RESTRICT StaticMeshRelevance,
        int32 StaticMeshIdx,
        int32& NumAcceptedStaticMeshes,
        struct FAddSubjectPrimitiveResult& OutResult,
        struct FAddSubjectPrimitiveStats& OutStats,
        struct FAddSubjectPrimitiveOverflowedIndices& OverflowBuffer) const;
 
 
    /*
     * Helper to calculate the LOD such that we do not repeat this in threaded & non threaded versions
     * NOTE: Reads and modifies the CurrentView.PrimitivesLODMask for the given primitive. 
     * Storing it is an optimization for the case where a primitive is not visible in the main view but in several shadow views (e.g., cascades).
     * This also creates a potential data race if we ever process multiple shadows infos for the same view and primitive in parallel (e.g., cascades).
     */
    FORCEINLINE_DEBUGGABLE FLODMask CalcAndUpdateLODToRender(FViewInfo& CurrentView, const FBoxSphereBounds& Bounds, const FPrimitiveSceneInfo* PrimitiveSceneInfo, int32 ForcedLOD) const;
 
    FORCEINLINE bool ShouldDrawStaticMesh(const FStaticMeshBatchRelevance& StaticMeshRelevance, const FLODMask &ShadowLODToRender, bool& bOutDrawingStaticMeshes) const;
 
    bool ShouldDrawStaticMeshes(FViewInfo& InCurrentView, FPrimitiveSceneInfo* InPrimitiveSceneInfo);
 
    bool ShouldDrawStaticMeshes_AnyThread(
        FViewInfo& InCurrentView,
        const FPrimitiveSceneInfoCompact& PrimitiveSceneInfoCompact,
        bool bMayBeFading,
        struct FAddSubjectPrimitiveResult& OutResult,
        struct FAddSubjectPrimitiveStats& OutStats,
        struct FAddSubjectPrimitiveOverflowedIndices& OverflowBuffer) const;
 
    void GetShadowTypeNameForDrawEvent(FString& TypeName) const;
 
    int32 UpdateShadowCastingObjectBuffers() const;
 
    bool GatherDynamicMeshElementsArray(
        FMeshElementCollector& Collector,
        const PrimitiveArrayType& PrimitiveArray, 
        const TArray<const FSceneView*>& Views,
        const FSceneViewFamily& ViewFamily,
        TArray<FMeshBatchAndRelevance,SceneRenderingAllocator>& OutDynamicMeshElements,
        int32& OutNumDynamicSubjectMeshElements,
        EGatherDynamicMeshElementsPass Pass);
 
    bool GatherDynamicHeterogeneousVolumeMeshElementsArray(
        FSceneRenderer& Renderer,
        FMeshElementCollector& Collector,
        const PrimitiveArrayType& PrimitiveArray,
        const TArray<const FSceneView*>& Views,
        const FSceneViewFamily& ViewFamily,
        TArray<FMeshBatchAndRelevance, SceneRenderingAllocator>& OutDynamicMeshElements,
        int32& OutNumDynamicSubjectMeshElements,
        EGatherDynamicMeshElementsPass Pass);
 
    void SetupFrustumForProjection(const FViewInfo* View, TArray<FVector4f, TInlineAllocator<8>>& OutFrustumVertices, bool& bOutCameraInsideShadowFrustum, FPlane* OutPlanes) const;
 
    void SetupProjectionStencilMask(
        FRHICommandList& RHICmdList,
        const FViewInfo* View, 
        int32 ViewIndex,
        const class FSceneRenderer* SceneRender,
        const TArray<FVector4f, TInlineAllocator<8>>& FrustumVertices,
        bool bMobileModulatedProjections,
        bool bCameraInsideShadowFrustum,
        const FInstanceCullingDrawParams& InstanceCullingDrawParams) const;
 
    void SetupProjectionStencilMaskForHair(FRHICommandList& RHICmdList, const FViewInfo* View) const;
 
    FORCEINLINE bool TestPrimitiveFarCascadeConditions(bool bPrimitiveCastsFarShadow, const FBoxSphereBounds& Bounds) const;
 
    friend class FShadowDepthVS;
    friend class FShadowDepthBasePS;
    friend class FShadowVolumeBoundProjectionVS;
    friend class FShadowProjectionPS;
};
 
enum class EShadowProjectionVertexShaderFlags
{
    None,
    DrawingFrustum  = 0x01
};
ENUM_CLASS_FLAGS(EShadowProjectionVertexShaderFlags)
 
 
class FShadowVolumeBoundProjectionVS : public FGlobalShader
{
    DECLARE_SHADER_TYPE(FShadowVolumeBoundProjectionVS,Global);
public:
 
    FShadowVolumeBoundProjectionVS() {}
    FShadowVolumeBoundProjectionVS(const ShaderMetaType::CompiledShaderInitializerType& Initializer)
        : FGlobalShader(Initializer) 
    {
        const FShaderParameterMap& ParameterMap = Initializer.ParameterMap;
 
        StencilingGeometryParameters.Bind(ParameterMap);
        InvReceiverInnerMatrix.Bind(ParameterMap, TEXT("InvReceiverInnerMatrix"));
        PreShadowToPreViewTranslation.Bind(ParameterMap, TEXT("PreShadowToPreViewTranslation"));
    }
 
    void SetParameters(FRHIBatchedShaderParameters& BatchedParameters, const FSceneView& View,  const FProjectedShadowInfo* ShadowInfo, EShadowProjectionVertexShaderFlags Flags);
 
private:
    LAYOUT_FIELD(FStencilingGeometryShaderParameters, StencilingGeometryParameters);
    LAYOUT_FIELD(FShaderParameter, InvReceiverInnerMatrix);
    LAYOUT_FIELD(FShaderParameter, PreShadowToPreViewTranslation);
};
 
class FShadowProjectionNoTransformVS : public FGlobalShader
{
    DECLARE_SHADER_TYPE(FShadowProjectionNoTransformVS,Global);
public:
    FShadowProjectionNoTransformVS() {}
    FShadowProjectionNoTransformVS(const ShaderMetaType::CompiledShaderInitializerType& Initializer)
        : FGlobalShader(Initializer) 
    {
    }
 
    void SetParameters(FRHIBatchedShaderParameters& BatchedParameters, const FSceneView& View, const FProjectedShadowInfo* ShadowInfo, EShadowProjectionVertexShaderFlags Flags) {}
};
 
class FShadowProjectionPixelShaderInterface : public FGlobalShader
{
    DECLARE_TYPE_LAYOUT(FShadowProjectionPixelShaderInterface, NonVirtual);
public:
 
    FShadowProjectionPixelShaderInterface() 
        :   FGlobalShader()
    {}
 
    FShadowProjectionPixelShaderInterface(const ShaderMetaType::CompiledShaderInitializerType& Initializer)
        :   FGlobalShader(Initializer)
    {}
};
 
class FShadowProjectionShaderParameters
{
    DECLARE_TYPE_LAYOUT(FShadowProjectionShaderParameters, NonVirtual);
public:
    void Bind(const FShader::CompiledShaderInitializerType& Initializer)
    {
        const FShaderParameterMap& ParameterMap = Initializer.ParameterMap;
        ScreenToShadowMatrix.Bind(ParameterMap,TEXT("ScreenToShadowMatrix"));
        SoftTransitionScale.Bind(ParameterMap,TEXT("SoftTransitionScale"));
        ShadowBufferSize.Bind(ParameterMap,TEXT("ShadowBufferSize"));
        ShadowDepthTexture.Bind(ParameterMap,TEXT("ShadowDepthTexture"));
        ShadowDepthTextureSampler.Bind(ParameterMap,TEXT("ShadowDepthTextureSampler"));
        ProjectionDepthBias.Bind(ParameterMap,TEXT("ProjectionDepthBiasParameters"));
        FadePlaneOffset.Bind(ParameterMap,TEXT("FadePlaneOffset"));
        InvFadePlaneLength.Bind(ParameterMap,TEXT("InvFadePlaneLength"));
        ShadowTileOffsetAndSizeParam.Bind(ParameterMap, TEXT("ShadowTileOffsetAndSize"));
        LightPositionOrDirection.Bind(ParameterMap, TEXT("LightPositionOrDirection"));
        PerObjectShadowFadeStart.Bind(ParameterMap, TEXT("PerObjectShadowFadeStart"));
        InvPerObjectShadowFadeLength.Bind(ParameterMap, TEXT("InvPerObjectShadowFadeLength"));
        ShadowNearAndFarDepth.Bind(ParameterMap, TEXT("ShadowNearAndFarDepth"));
        bCascadeUseFadePlane.Bind(ParameterMap, TEXT("bCascadeUseFadePlane"));
    }
 
    void Set(FRHIBatchedShaderParameters& BatchedParameters, const FSceneView& View, const FProjectedShadowInfo* ShadowInfo, bool bModulatedShadows, bool bUseFadePlane, bool SubPixelShadow)
    {
        const FVector PreViewTranslation = View.ViewMatrices.GetPreViewTranslation();
        const FIntPoint ShadowBufferResolution = ShadowInfo->GetShadowBufferResolution();
 
        if (ShadowTileOffsetAndSizeParam.IsBound())
        {
            FVector2D InverseShadowBufferResolution(1.0f / ShadowBufferResolution.X, 1.0f / ShadowBufferResolution.Y);
            FVector4f ShadowTileOffsetAndSize(
                (ShadowInfo->BorderSize + ShadowInfo->X) * InverseShadowBufferResolution.X,
                (ShadowInfo->BorderSize + ShadowInfo->Y) * InverseShadowBufferResolution.Y,
                ShadowInfo->ResolutionX * InverseShadowBufferResolution.X,
                ShadowInfo->ResolutionY * InverseShadowBufferResolution.Y);
            SetShaderValue(BatchedParameters, ShadowTileOffsetAndSizeParam, ShadowTileOffsetAndSize);
        }
 
        // Set the transform from screen coordinates to shadow depth texture coordinates.
        if (bModulatedShadows)
        {
            // UE-29083 : work around precision issues with ScreenToShadowMatrix on low end devices.
            const FMatrix44f ScreenToShadow = FMatrix44f(ShadowInfo->GetScreenToShadowMatrix(View, 0, 0, ShadowBufferResolution.X, ShadowBufferResolution.Y));  // LWC_TODO: Precision loss
            SetShaderValue(BatchedParameters, ScreenToShadowMatrix, ScreenToShadow);
        }
        else
        {
            const FMatrix44f ScreenToShadow = FMatrix44f(ShadowInfo->GetScreenToShadowMatrix(View));        // LWC_TODO: Precision loss
            SetShaderValue(BatchedParameters, ScreenToShadowMatrix, ScreenToShadow);
        }
 
        if (SoftTransitionScale.IsBound())
        {
            const float TransitionSize = ShadowInfo->ComputeTransitionSize();
 
            SetShaderValue(BatchedParameters, SoftTransitionScale, FVector3f(0, 0, 1.0f / TransitionSize));
        }
 
        if (ShadowBufferSize.IsBound())
        {
            FVector2D ShadowBufferSizeValue(ShadowBufferResolution.X, ShadowBufferResolution.Y);
 
            SetShaderValue(BatchedParameters, ShadowBufferSize,
                FVector4f(ShadowBufferSizeValue.X, ShadowBufferSizeValue.Y, 1.0f / ShadowBufferSizeValue.X, 1.0f / ShadowBufferSizeValue.Y));
        }
 
        FRHITexture* ShadowDepthTextureValue;
 
        // Translucency shadow projection has no depth target
        if (ShadowInfo->RenderTargets.DepthTarget)
        {
            ShadowDepthTextureValue = ShadowInfo->RenderTargets.DepthTarget->GetRHI();
        }
        else
        {
            ShadowDepthTextureValue = GSystemTextures.BlackDummy->GetRHI();
        }
            
        FRHISamplerState* DepthSamplerState = TStaticSamplerState<SF_Point,AM_Clamp,AM_Clamp,AM_Clamp>::GetRHI();
 
        SetTextureParameter(BatchedParameters, ShadowDepthTexture, ShadowDepthTextureSampler, DepthSamplerState, ShadowDepthTextureValue);
 
        if (ShadowDepthTextureSampler.IsBound())
        {
            SetSamplerParameter(BatchedParameters, ShadowDepthTextureSampler, DepthSamplerState);
        }
 
        SetShaderValue(BatchedParameters, ProjectionDepthBias, FVector4f(ShadowInfo->GetShaderDepthBias(), ShadowInfo->GetShaderSlopeDepthBias(), ShadowInfo->GetShaderReceiverDepthBias(), ShadowInfo->MaxSubjectZ - ShadowInfo->MinSubjectZ));
        SetShaderValue(BatchedParameters, FadePlaneOffset, ShadowInfo->CascadeSettings.FadePlaneOffset);
 
        if(InvFadePlaneLength.IsBound() && bUseFadePlane)
        {
            check(ShadowInfo->CascadeSettings.FadePlaneLength > 0);
            SetShaderValue(BatchedParameters, InvFadePlaneLength, 1.0f / ShadowInfo->CascadeSettings.FadePlaneLength);
        }
 
        if (LightPositionOrDirection.IsBound())
        {
            const FVector LightDirection = ShadowInfo->GetLightSceneInfo().Proxy->GetDirection();
            const FVector LightPosition = ShadowInfo->GetLightSceneInfo().Proxy->GetPosition() + PreViewTranslation;
            const bool bIsDirectional = ShadowInfo->GetLightSceneInfo().Proxy->GetLightType() == LightType_Directional;
            SetShaderValue(BatchedParameters, LightPositionOrDirection, bIsDirectional ? FVector4f((FVector3f)LightDirection,0) : FVector4f((FVector3f)LightPosition,1));
        }
 
        if (SubPixelShadow)
        {
            float DeviceZNear = 1;
            float DeviceZFar = 0;
            const bool bIsCascadedShadow = ShadowInfo->bDirectionalLight && !(ShadowInfo->bPerObjectOpaqueShadow || ShadowInfo->bPreShadow);
            if (bIsCascadedShadow)
            {
                FVector4 Near = View.ViewMatrices.GetProjectionMatrix().TransformFVector4(FVector4(0, 0, ShadowInfo->CascadeSettings.SplitNear));
                FVector4 Far = View.ViewMatrices.GetProjectionMatrix().TransformFVector4(FVector4(0, 0, ShadowInfo->CascadeSettings.SplitFar));
                // LWC_TODO: precision loss?
                DeviceZNear = (float)(Near.Z / Near.W);
                DeviceZFar = (float)(Far.Z / Far.W);
            }
 
            FVector2f SliceNearAndFarDepth;
            SliceNearAndFarDepth.X = DeviceZNear;
            SliceNearAndFarDepth.Y = DeviceZFar;
            SetShaderValue(BatchedParameters, ShadowNearAndFarDepth, SliceNearAndFarDepth);
            SetShaderValue(BatchedParameters, bCascadeUseFadePlane, bUseFadePlane ? 1 : 0);
        }
 
        SetShaderValue(BatchedParameters, PerObjectShadowFadeStart, ShadowInfo->PerObjectShadowFadeStart);
        SetShaderValue(BatchedParameters, InvPerObjectShadowFadeLength, ShadowInfo->InvPerObjectShadowFadeLength);
    }
 
private:
    LAYOUT_FIELD(FShaderParameter, ScreenToShadowMatrix);
    LAYOUT_FIELD(FShaderParameter, SoftTransitionScale);
    LAYOUT_FIELD(FShaderParameter, ShadowBufferSize);
    LAYOUT_FIELD(FShaderResourceParameter, ShadowDepthTexture);
    LAYOUT_FIELD(FShaderResourceParameter, ShadowDepthTextureSampler);
    LAYOUT_FIELD(FShaderParameter, ProjectionDepthBias);
    LAYOUT_FIELD(FShaderParameter, FadePlaneOffset);
    LAYOUT_FIELD(FShaderParameter, InvFadePlaneLength);
    LAYOUT_FIELD(FShaderParameter, ShadowTileOffsetAndSizeParam);
    LAYOUT_FIELD(FShaderParameter, LightPositionOrDirection);
    LAYOUT_FIELD(FShaderParameter, PerObjectShadowFadeStart);
    LAYOUT_FIELD(FShaderParameter, InvPerObjectShadowFadeLength);
    LAYOUT_FIELD(FShaderParameter, ShadowNearAndFarDepth);
    LAYOUT_FIELD(FShaderParameter, bCascadeUseFadePlane);
};
 
template<uint32 Quality, bool bUseFadePlane = false, bool bModulatedShadows = false, bool bUseTransmission = false, bool SubPixelShadow = false>
class TShadowProjectionPS : public FShadowProjectionPixelShaderInterface
{
    DECLARE_SHADER_TYPE(TShadowProjectionPS,Global);
public:
 
    TShadowProjectionPS()
        : FShadowProjectionPixelShaderInterface()
    { 
    }
 
    TShadowProjectionPS(const ShaderMetaType::CompiledShaderInitializerType& Initializer):
        FShadowProjectionPixelShaderInterface(Initializer)
    {
        ProjectionParameters.Bind(Initializer);
        ShadowFadeFraction.Bind(Initializer.ParameterMap,TEXT("ShadowFadeFraction"));
        ShadowSharpen.Bind(Initializer.ParameterMap,TEXT("ShadowSharpen"));
        LightPosition.Bind(Initializer.ParameterMap, TEXT("LightPositionAndInvRadius"));
 
    }
 
    static bool ShouldCompilePermutation(const FGlobalShaderPermutationParameters& Parameters)
    {
        return IsFeatureLevelSupported(Parameters.Platform, ERHIFeatureLevel::SM5)
            || (bUseTransmission == 0 && SubPixelShadow == 0); // Mobile uses only those
    }
 
    static void ModifyCompilationEnvironment(const FGlobalShaderPermutationParameters& Parameters, FShaderCompilerEnvironment& OutEnvironment)
    {
        FShadowProjectionPixelShaderInterface::ModifyCompilationEnvironment(Parameters,OutEnvironment);
        OutEnvironment.SetDefine(TEXT("SHADOW_QUALITY"), Quality);
        OutEnvironment.SetDefine(TEXT("SUBPIXEL_SHADOW"), (uint32)(SubPixelShadow ? 1 : 0));
        OutEnvironment.SetDefine(TEXT("USE_FADE_PLANE"), (uint32)(bUseFadePlane ? 1 : 0));
        OutEnvironment.SetDefine(TEXT("USE_TRANSMISSION"), (uint32)(bUseTransmission ? 1 : 0));
 
        const bool bMobileForceDepthRead = MobileUsesFullDepthPrepass(Parameters.Platform);
        OutEnvironment.SetDefine(TEXT("FORCE_DEPTH_TEXTURE_READS"), (uint32)(bMobileForceDepthRead ? 1 : 0));
    }
 
    void SetParameters(
        FRHIBatchedShaderParameters& BatchedParameters,
        int32 ViewIndex,
        const FSceneView& View,
        const FProjectedShadowInfo* ShadowInfo,
        bool bUseLightFunctionAtlas)
    {
        const FVector PreViewTranslation = View.ViewMatrices.GetPreViewTranslation();
        const bool bUseFadePlaneEnable = ShadowInfo->CascadeSettings.FadePlaneLength > 0;
 
        ProjectionParameters.Set(BatchedParameters, View, ShadowInfo, bModulatedShadows, bUseFadePlaneEnable, SubPixelShadow);
        const FLightSceneProxy& LightProxy = *(ShadowInfo->GetLightSceneInfo().Proxy);
 
        SetShaderValue(BatchedParameters, ShadowFadeFraction, ShadowInfo->FadeAlphas[ViewIndex] );
        SetShaderValue(BatchedParameters, ShadowSharpen, LightProxy.GetShadowSharpen() * 7.0f + 1.0f );
        SetShaderValue(BatchedParameters, LightPosition, FVector4f(FVector3f((FVector)LightProxy.GetPosition() + PreViewTranslation), 1.0f / LightProxy.GetRadius()));
 
        auto DeferredLightParameter = GetUniformBufferParameter<FDeferredLightUniformStruct>();
 
        if (DeferredLightParameter.IsBound())
        {
            SetDeferredLightParameters(BatchedParameters, DeferredLightParameter, &ShadowInfo->GetLightSceneInfo(), View, bUseLightFunctionAtlas);
        }
 
 
        FScene* Scene = nullptr;
 
        if (View.Family->Scene)
        {
            Scene = View.Family->Scene->GetRenderScene();
        }
    }
 
protected:
    LAYOUT_FIELD(FShadowProjectionShaderParameters, ProjectionParameters);
    LAYOUT_FIELD(FShaderParameter, ShadowFadeFraction);
    LAYOUT_FIELD(FShaderParameter, ShadowSharpen);
    LAYOUT_FIELD(FShaderParameter, LightPosition);
};
 
template<uint32 Quality>
class TModulatedShadowProjection : public TShadowProjectionPS<Quality, false, true>
{
    DECLARE_SHADER_TYPE(TModulatedShadowProjection, Global);
public:
 
    static void ModifyCompilationEnvironment(const FGlobalShaderPermutationParameters& Parameters, FShaderCompilerEnvironment& OutEnvironment)
    {
        TShadowProjectionPS<Quality, false, true>::ModifyCompilationEnvironment(Parameters, OutEnvironment);
        OutEnvironment.SetDefine(TEXT("MODULATED_SHADOWS"), 1);
        const bool bMobileForceDepthRead = MobileUsesFullDepthPrepass(Parameters.Platform);
        OutEnvironment.SetDefine(TEXT("IS_MOBILE_DEPTHREAD_SUBPASS"), bMobileForceDepthRead ? 0u : 1u);
    }
 
    static bool ShouldCompilePermutation(const FGlobalShaderPermutationParameters& Parameters)
    {
        return IsMobilePlatform(Parameters.Platform);
    }
 
    TModulatedShadowProjection() {}
 
    TModulatedShadowProjection(const ShaderMetaType::CompiledShaderInitializerType& Initializer);
 
    void SetParameters(
        FRHIBatchedShaderParameters& BatchedParameters,
        int32 ViewIndex,
        const FSceneView& View,
        const FProjectedShadowInfo* ShadowInfo,
        bool bUseLightFunctionAtlas)
    {
        TShadowProjectionPS<Quality, false, true>::SetParameters(BatchedParameters, ViewIndex, View, ShadowInfo, bUseLightFunctionAtlas);
        SetShaderValue(BatchedParameters, ModulatedShadowColorParameter, ShadowInfo->GetLightSceneInfo().Proxy->GetModulatedShadowColor());
    }
 
protected:
    LAYOUT_FIELD(FShaderParameter, ModulatedShadowColorParameter);
    LAYOUT_FIELD(FShaderUniformBufferParameter, MobileBasePassUniformBuffer);
};
 
BEGIN_GLOBAL_SHADER_PARAMETER_STRUCT(FTranslucentSelfShadowUniformParameters, )
    SHADER_PARAMETER(FMatrix44f, WorldToShadowMatrix)
    SHADER_PARAMETER(FVector4f, ShadowUVMinMax)
    SHADER_PARAMETER(FVector4f, DirectionalLightDirection)
    SHADER_PARAMETER(FVector4f, DirectionalLightColor)
    SHADER_PARAMETER_TEXTURE(Texture2D, Transmission0)
    SHADER_PARAMETER_TEXTURE(Texture2D, Transmission1)
    SHADER_PARAMETER_SAMPLER(SamplerState, Transmission0Sampler)
    SHADER_PARAMETER_SAMPLER(SamplerState, Transmission1Sampler)
END_GLOBAL_SHADER_PARAMETER_STRUCT()
 
extern void SetupTranslucentSelfShadowUniformParameters(const FProjectedShadowInfo* ShadowInfo, FTranslucentSelfShadowUniformParameters& OutParameters);
 
class FEmptyTranslucentSelfShadowUniformBuffer : public TUniformBuffer< FTranslucentSelfShadowUniformParameters >
{
    typedef TUniformBuffer< FTranslucentSelfShadowUniformParameters > Super;
public:
    virtual void InitRHI(FRHICommandListBase& RHICmdList) override;
};
 
extern TGlobalResource< FEmptyTranslucentSelfShadowUniformBuffer > GEmptyTranslucentSelfShadowUniformBuffer;
 
template<uint32 Quality> 
class TShadowProjectionFromTranslucencyPS : public TShadowProjectionPS<Quality>
{
    DECLARE_SHADER_TYPE(TShadowProjectionFromTranslucencyPS,Global);
public:
 
    static void ModifyCompilationEnvironment(const FGlobalShaderPermutationParameters& Parameters, FShaderCompilerEnvironment& OutEnvironment)
    {
        TShadowProjectionPS<Quality>::ModifyCompilationEnvironment(Parameters, OutEnvironment);
        OutEnvironment.SetDefine(TEXT("APPLY_TRANSLUCENCY_SHADOWS"), 1);
    }
 
    static bool ShouldCompilePermutation(const FGlobalShaderPermutationParameters& Parameters)
    {
        return IsFeatureLevelSupported(Parameters.Platform, ERHIFeatureLevel::SM5) && TShadowProjectionPS<Quality>::ShouldCompilePermutation(Parameters);
    }
 
    TShadowProjectionFromTranslucencyPS() {}
 
    TShadowProjectionFromTranslucencyPS(const ShaderMetaType::CompiledShaderInitializerType& Initializer):
        TShadowProjectionPS<Quality>(Initializer)
    {
    }
 
    void SetParameters(
        FRHIBatchedShaderParameters& BatchedParameters,
        int32 ViewIndex,
        const FSceneView& View,
        const FProjectedShadowInfo* ShadowInfo,
        bool bUseLightFunctionAtlas)
    {
        TShadowProjectionPS<Quality>::SetParameters(BatchedParameters, ViewIndex, View, ShadowInfo, bUseLightFunctionAtlas);
 
        FTranslucentSelfShadowUniformParameters TranslucentSelfShadowUniformParameters;
        SetupTranslucentSelfShadowUniformParameters(ShadowInfo, TranslucentSelfShadowUniformParameters);
        SetUniformBufferParameterImmediate(BatchedParameters, this->template GetUniformBufferParameter<FTranslucentSelfShadowUniformParameters>(), TranslucentSelfShadowUniformParameters);
    }
};
 
 
BEGIN_SHADER_PARAMETER_STRUCT(FOnePassPointShadowProjection, )
    SHADER_PARAMETER_RDG_TEXTURE(TextureCube, ShadowDepthCubeTexture)
    SHADER_PARAMETER_RDG_TEXTURE(TextureCube, ShadowDepthCubeTexture2)
    SHADER_PARAMETER_SAMPLER(SamplerComparisonState, ShadowDepthCubeTextureSampler)
    SHADER_PARAMETER_ARRAY(FMatrix44f, ShadowViewProjectionMatrices, [6])
    SHADER_PARAMETER(float, InvShadowmapResolution)
END_SHADER_PARAMETER_STRUCT()
 
extern void GetOnePassPointShadowProjectionParameters(FRDGBuilder& GraphBuilder, const FProjectedShadowInfo* ShadowInfo, FOnePassPointShadowProjection& OutParameters);
 
 
class FOnePassPointShadowProjectionShaderParameters
{
    DECLARE_TYPE_LAYOUT(FOnePassPointShadowProjectionShaderParameters, NonVirtual);
public:
 
    void Bind(const FShaderParameterMap& ParameterMap)
    {
        ShadowDepthTexture.Bind(ParameterMap,TEXT("ShadowDepthCubeTexture"));
        ShadowDepthTexture2.Bind(ParameterMap, TEXT("ShadowDepthCubeTexture2"));
        ShadowDepthCubeComparisonSampler.Bind(ParameterMap,TEXT("ShadowDepthCubeTextureSampler"));
        ShadowViewProjectionMatrices.Bind(ParameterMap, TEXT("ShadowViewProjectionMatrices"));
        InvShadowmapResolution.Bind(ParameterMap, TEXT("InvShadowmapResolution"));
        LightPositionOrDirection.Bind(ParameterMap, TEXT("LightPositionOrDirection"));
    }
 
    inline void Set(FRHIBatchedShaderParameters& BatchedParameters, const FSceneView& View, const FProjectedShadowInfo* ShadowInfo) const
    {
        const FVector PreViewTranslation = View.ViewMatrices.GetPreViewTranslation();
 
        FRHITexture* ShadowDepthTextureValue = GBlackTextureDepthCube->TextureRHI;
        
        if (ShadowInfo)
        {
            if (FRHITexture* Texture = ShadowInfo->RenderTargets.DepthTarget->GetRHI())
            {
                ShadowDepthTextureValue = Texture;
            }
        }
 
        SetTextureParameter(BatchedParameters, ShadowDepthTexture, ShadowDepthTextureValue);
        SetTextureParameter(BatchedParameters, ShadowDepthTexture2, ShadowDepthTextureValue);
 
        if (LightPositionOrDirection.IsBound())
        {
            const FVector LightPosition = ShadowInfo ? FVector(ShadowInfo->GetLightSceneInfo().Proxy->GetPosition()) : FVector::ZeroVector;
            SetShaderValue(BatchedParameters, LightPositionOrDirection, FVector4f(FVector3f(LightPosition + PreViewTranslation), 1));
        }
        
        if (ShadowDepthCubeComparisonSampler.IsBound())
        {
            // Use a comparison sampler to do hardware PCF
            SetSamplerParameter(BatchedParameters, ShadowDepthCubeComparisonSampler, TStaticSamplerState<SF_Bilinear, AM_Clamp, AM_Clamp, AM_Clamp, 0, 0, 0, SCF_Less>::GetRHI());
        }
 
        const int32 NumShaderMatrices = FMath::DivideAndRoundUp<int32>(ShadowViewProjectionMatrices.GetNumBytes(), sizeof(FMatrix44f));
 
        if (ShadowInfo)
        {
            const int32 NumUsableMatrices = FMath::Min<int32>(NumShaderMatrices, ShadowInfo->OnePassShadowViewProjectionMatrices.Num());
            TArray<FMatrix44f, SceneRenderingAllocator> TypeCastedMatrices;
            TypeCastedMatrices.AddUninitialized(NumUsableMatrices);
            for (int32 i = 0; i < NumUsableMatrices; i++)
            {
                TypeCastedMatrices[i] = FMatrix44f(ShadowInfo->OnePassShadowViewProjectionMatrices[i]);     // LWC_TODO: Precision loss?
            }
            if (NumUsableMatrices < NumShaderMatrices)
            {
                TypeCastedMatrices.AddZeroed(NumShaderMatrices - NumUsableMatrices);
            }
            SetShaderValueArray<FMatrix44f>(
                BatchedParameters,
                ShadowViewProjectionMatrices,
                TypeCastedMatrices.GetData(),
                NumShaderMatrices
                );
 
            SetShaderValue(BatchedParameters,InvShadowmapResolution,1.0f / ShadowInfo->ResolutionX);
        }
        else
        {
            TArray<FMatrix44f, SceneRenderingAllocator> ZeroMatrices;
            ZeroMatrices.AddZeroed(NumShaderMatrices);
 
            SetShaderValueArray<FMatrix44f>(
                BatchedParameters,
                ShadowViewProjectionMatrices,
                ZeroMatrices.GetData(),
                NumShaderMatrices
                );
 
            SetShaderValue(BatchedParameters,InvShadowmapResolution,0);
        }
    }
 
    /*friend FArchive& operator<<(FArchive& Ar,FOnePassPointShadowProjectionShaderParameters& P)
    {
        Ar << P.ShadowDepthTexture;
        Ar << P.ShadowDepthTexture2;
        Ar << P.ShadowDepthCubeComparisonSampler;
        Ar << P.ShadowViewProjectionMatrices;
        Ar << P.InvShadowmapResolution;
        Ar << P.LightPositionOrDirection;
        return Ar;
    }*/
 
private:
    LAYOUT_FIELD(FShaderResourceParameter, ShadowDepthTexture);
    LAYOUT_FIELD(FShaderResourceParameter, ShadowDepthTexture2);
    LAYOUT_FIELD(FShaderResourceParameter, ShadowDepthCubeComparisonSampler);
    LAYOUT_FIELD(FShaderParameter, ShadowViewProjectionMatrices);
    LAYOUT_FIELD(FShaderParameter, InvShadowmapResolution);
    LAYOUT_FIELD(FShaderParameter, LightPositionOrDirection);
};
 
// Quality = 0 / 1
template <uint32 Quality, bool bUseTransmission, bool bUseSubPixel>
class TOnePassPointShadowProjectionPS : public FGlobalShader
{
    DECLARE_SHADER_TYPE(TOnePassPointShadowProjectionPS,Global);
public:
 
    TOnePassPointShadowProjectionPS() {}
 
    TOnePassPointShadowProjectionPS(const ShaderMetaType::CompiledShaderInitializerType& Initializer):
        FGlobalShader(Initializer)
    {
        HairStrandsParameters.Bind(Initializer.ParameterMap, FHairStrandsViewUniformParameters::FTypeInfo::GetStructMetadata()->GetShaderVariableName());
        SubstrateGlobalParameters.Bind(Initializer.ParameterMap, FSubstrateGlobalUniformParameters::FTypeInfo::GetStructMetadata()->GetShaderVariableName());
        OnePassShadowParameters.Bind(Initializer.ParameterMap);
        ShadowDepthTextureSampler.Bind(Initializer.ParameterMap,TEXT("ShadowDepthTextureSampler"));
        LightPosition.Bind(Initializer.ParameterMap,TEXT("LightPositionAndInvRadius"));
        ShadowFadeFraction.Bind(Initializer.ParameterMap,TEXT("ShadowFadeFraction"));
        ShadowSharpen.Bind(Initializer.ParameterMap,TEXT("ShadowSharpen"));
        PointLightDepthBias.Bind(Initializer.ParameterMap,TEXT("PointLightDepthBias"));
        PointLightProjParameters.Bind(Initializer.ParameterMap, TEXT("PointLightProjParameters"));
    }
 
    static void ModifyCompilationEnvironment(const FGlobalShaderPermutationParameters& Parameters, FShaderCompilerEnvironment& OutEnvironment)
    {
        FGlobalShader::ModifyCompilationEnvironment(Parameters,OutEnvironment);
        OutEnvironment.SetDefine(TEXT("SHADOW_QUALITY"), Quality);
        if (IsMobilePlatform(Parameters.Platform))
        {
            OutEnvironment.SetDefine(TEXT("USE_TRANSMISSION"), 0);
        }
        else
        {
            OutEnvironment.SetDefine(TEXT("USE_TRANSMISSION"), (uint32)(bUseTransmission ? 1 : 0));
        }
        OutEnvironment.SetDefine(TEXT("SUBPIXEL_SHADOW"), (uint32)(bUseSubPixel ? 1 : 0));
    }
 
    static bool ShouldCompilePermutation(const FGlobalShaderPermutationParameters& Parameters)
    {
        if (IsMobilePlatform(Parameters.Platform))
        {
            return !bUseTransmission;
        }
 
        return true;
    }
 
    void SetParameters(
        FRHIBatchedShaderParameters& BatchedParameters,
        int32 ViewIndex,
        const FViewInfo& View,
        const FProjectedShadowInfo* ShadowInfo,
        FRHIUniformBuffer* HairStrandsUniformBuffer)
    {
        const FVector PreViewTranslation = View.ViewMatrices.GetPreViewTranslation();
 
        OnePassShadowParameters.Set(BatchedParameters, View, ShadowInfo);
 
        const FLightSceneProxy& LightProxy = *(ShadowInfo->GetLightSceneInfo().Proxy);
 
        SetShaderValue(BatchedParameters, LightPosition, FVector4f(FVector3f(FVector(LightProxy.GetPosition()) + PreViewTranslation), 1.0f / LightProxy.GetRadius()));
 
        SetShaderValue(BatchedParameters, ShadowFadeFraction, ShadowInfo->FadeAlphas[ViewIndex]);
        SetShaderValue(BatchedParameters, ShadowSharpen, LightProxy.GetShadowSharpen() * 7.0f + 1.0f);
 
        FVector2d ProjectionParams = FVector2d(ShadowInfo->OnePassShadowFaceProjectionMatrix.M[2][2], ShadowInfo->OnePassShadowFaceProjectionMatrix.M[3][2]);
        FVector2f InverseProjParams = FVector2f(1.0 / ProjectionParams.Y, ProjectionParams.X / ProjectionParams.Y);
        SetShaderValue(BatchedParameters, PointLightDepthBias, FVector3f(ShadowInfo->GetShaderDepthBias(), ShadowInfo->GetShaderSlopeDepthBias(), ShadowInfo->GetShaderMaxSlopeDepthBias()));
        SetShaderValue(BatchedParameters, PointLightProjParameters, InverseProjParams);
 
        if (HairStrandsParameters.IsBound())
        {
            SetUniformBufferParameter(BatchedParameters, HairStrandsParameters, HairStrandsUniformBuffer);
        }
 
        if (SubstrateGlobalParameters.IsBound())
        {
            TRDGUniformBufferRef<FSubstrateGlobalUniformParameters> SubstrateUniformBuffer = Substrate::BindSubstrateGlobalUniformParameters(View);
            SetUniformBufferParameter(BatchedParameters, SubstrateGlobalParameters, SubstrateUniformBuffer->GetRHIRef());
        }
 
        FScene* Scene = nullptr;
 
        if (View.Family->Scene)
        {
            Scene = View.Family->Scene->GetRenderScene();
        }
 
        SetSamplerParameter(BatchedParameters, ShadowDepthTextureSampler, TStaticSamplerState<SF_Point, AM_Clamp, AM_Clamp, AM_Clamp>::GetRHI());
 
        auto DeferredLightParameter = GetUniformBufferParameter<FDeferredLightUniformStruct>();
 
        if (DeferredLightParameter.IsBound())
        {
            SetDeferredLightParameters(BatchedParameters, DeferredLightParameter, &ShadowInfo->GetLightSceneInfo(), View, LightFunctionAtlas::IsEnabled(View, LightFunctionAtlas::ELightFunctionAtlasSystem::DeferredLighting));
        }
    }
 
private:
    LAYOUT_FIELD(FOnePassPointShadowProjectionShaderParameters, OnePassShadowParameters);
    LAYOUT_FIELD(FShaderResourceParameter, ShadowDepthTextureSampler);
    LAYOUT_FIELD(FShaderParameter, LightPosition);
    LAYOUT_FIELD(FShaderParameter, ShadowFadeFraction);
    LAYOUT_FIELD(FShaderParameter, ShadowSharpen);
    LAYOUT_FIELD(FShaderParameter, PointLightDepthBias);
    LAYOUT_FIELD(FShaderParameter, PointLightProjParameters);
    LAYOUT_FIELD(FShaderUniformBufferParameter, HairStrandsParameters);
    LAYOUT_FIELD(FShaderUniformBufferParameter, SubstrateGlobalParameters);
};
 
// Reversed Z
struct FShadowProjectionMatrix : FMatrix
{
    FShadowProjectionMatrix(FVector::FReal MinZ, FVector::FReal MaxZ, const FVector4& WAxis) :
        FMatrix(
            FPlane(1,   0,  0,                                                  WAxis.X),
            FPlane(0,   1,  0,                                                  WAxis.Y),
            FPlane(0,   0,      -(WAxis.Z * MinZ + WAxis.W) / (MaxZ - MinZ),    WAxis.Z),
            FPlane(0,   0, MaxZ *(WAxis.Z * MinZ + WAxis.W) / (MaxZ - MinZ),    WAxis.W)
            )
    {}
 
    // Off center projection
    FShadowProjectionMatrix( const FVector2D& Min, const FVector2D& Max, const FVector4& WAxis )
        : FMatrix(
            FPlane( 2.0f / (Max.X - Min.X),             0.0f,                               0.0f, WAxis.X),
            FPlane( 0.0f,                               2.0f / (Max.Y - Min.Y),             0.0f, WAxis.Y),
            FPlane( -(Max.X + Min.X) / (Max.X - Min.X), -(Max.Y + Min.Y) / (Max.Y - Min.Y), 0.0f, WAxis.Z),
            FPlane( 0.0f,                               0.0f,                               1.0f, WAxis.W)
            )
    {}
 
    // Change near and far plane
    FShadowProjectionMatrix( const FMatrix& InMatrix, float MinZ, float MaxZ )
        : FMatrix( InMatrix )
    {
        M[2][2] = -( M[2][3] * MinZ + M[3][3] ) / ( MaxZ - MinZ );
        M[3][2] = MaxZ * -M[2][2];
    }
};
 
 
template<uint32 Quality, bool bUseFadePlane>
class TDirectionalPercentageCloserShadowProjectionPS : public TShadowProjectionPS<Quality, bUseFadePlane>
{
    DECLARE_SHADER_TYPE(TDirectionalPercentageCloserShadowProjectionPS, Global);
public:
 
    TDirectionalPercentageCloserShadowProjectionPS() {}
    TDirectionalPercentageCloserShadowProjectionPS(const ShaderMetaType::CompiledShaderInitializerType& Initializer) :
        TShadowProjectionPS<Quality, bUseFadePlane>(Initializer)
    {
        PCSSParameters.Bind(Initializer.ParameterMap, TEXT("PCSSParameters"));
    }
 
    static void ModifyCompilationEnvironment(const FGlobalShaderPermutationParameters& Parameters, FShaderCompilerEnvironment& OutEnvironment)
    {
        TShadowProjectionPS<Quality, bUseFadePlane>::ModifyCompilationEnvironment(Parameters, OutEnvironment);
        OutEnvironment.SetDefine(TEXT("USE_PCSS"), 1);
    }
 
    static bool ShouldCompilePermutation(const FGlobalShaderPermutationParameters& Parameters)
    {
        return TShadowProjectionPS<Quality, bUseFadePlane>::ShouldCompilePermutation(Parameters)
            && FDataDrivenShaderPlatformInfo::GetSupportsPercentageCloserShadows(Parameters.Platform);
    }
 
    void SetParameters(
        FRHIBatchedShaderParameters& BatchedParameters,
        int32 ViewIndex,
        const FSceneView& View,
        const FProjectedShadowInfo* ShadowInfo,
        bool bUseLightFunctionAtlas)
    {
        TShadowProjectionPS<Quality, bUseFadePlane>::SetParameters(BatchedParameters, ViewIndex, View, ShadowInfo, bUseLightFunctionAtlas);
 
        // GetLightSourceAngle returns the full angle.
        float TanLightSourceAngle = FMath::Tan(0.5 * FMath::DegreesToRadians(ShadowInfo->GetLightSceneInfo().Proxy->GetLightSourceAngle()));
 
        static IConsoleVariable* CVarMaxSoftShadowKernelSize = IConsoleManager::Get().FindConsoleVariable(TEXT("r.Shadow.MaxSoftKernelSize"));
        check(CVarMaxSoftShadowKernelSize);
        int32 MaxKernelSize = CVarMaxSoftShadowKernelSize->GetInt();
 
        float SW = 2.0 * ShadowInfo->ShadowBounds.W;
        float SZ = ShadowInfo->MaxSubjectZ - ShadowInfo->MinSubjectZ;
 
        FVector4f PCSSParameterValues = FVector4f(TanLightSourceAngle * SZ / SW, MaxKernelSize / float(ShadowInfo->ResolutionX), 0, 0);
        SetShaderValue(BatchedParameters, PCSSParameters, PCSSParameterValues);
    }
 
protected:
    LAYOUT_FIELD(FShaderParameter, PCSSParameters);
};
 
 
template<uint32 Quality, bool bUseFadePlane>
class TSpotPercentageCloserShadowProjectionPS : public TShadowProjectionPS<Quality, bUseFadePlane>
{
    DECLARE_SHADER_TYPE(TSpotPercentageCloserShadowProjectionPS, Global);
public:
 
    TSpotPercentageCloserShadowProjectionPS() {}
    TSpotPercentageCloserShadowProjectionPS(const ShaderMetaType::CompiledShaderInitializerType& Initializer) :
        TShadowProjectionPS<Quality, bUseFadePlane>(Initializer)
    {
        PCSSParameters.Bind(Initializer.ParameterMap, TEXT("PCSSParameters"));
    }
 
    static bool ShouldCompilePermutation(const FGlobalShaderPermutationParameters& Parameters)
    {
        return IsFeatureLevelSupported(Parameters.Platform, ERHIFeatureLevel::SM5)
            && FDataDrivenShaderPlatformInfo::GetSupportsPercentageCloserShadows(Parameters.Platform);
    }
 
    static void ModifyCompilationEnvironment(const FGlobalShaderPermutationParameters& Parameters, FShaderCompilerEnvironment& OutEnvironment)
    {
        TShadowProjectionPS<Quality, bUseFadePlane>::ModifyCompilationEnvironment(Parameters, OutEnvironment);
        OutEnvironment.SetDefine(TEXT("USE_PCSS"), 1);
        OutEnvironment.SetDefine(TEXT("SPOT_LIGHT_PCSS"), 1);
    }
 
    void SetParameters(
        FRHIBatchedShaderParameters& BatchedParameters,
        int32 ViewIndex,
        const FSceneView& View,
        const FProjectedShadowInfo* ShadowInfo,
        bool bUseLightFunctionAtlas)
    {
        check(ShadowInfo->GetLightSceneInfo().Proxy->GetLightType() == LightType_Spot);
 
        TShadowProjectionPS<Quality, bUseFadePlane>::SetParameters(BatchedParameters, ViewIndex, View, ShadowInfo, bUseLightFunctionAtlas);
 
        static IConsoleVariable* CVarMaxSoftShadowKernelSize = IConsoleManager::Get().FindConsoleVariable(TEXT("r.Shadow.MaxSoftKernelSize"));
        check(CVarMaxSoftShadowKernelSize);
        int32 MaxKernelSize = CVarMaxSoftShadowKernelSize->GetInt();
 
        FVector4f PCSSParameterValues = FVector4f(0, MaxKernelSize / float(ShadowInfo->ResolutionX), 0, 0);
        SetShaderValue(BatchedParameters, PCSSParameters, PCSSParameterValues);
    }
 
protected:
    LAYOUT_FIELD(FShaderParameter, PCSSParameters);
};
 
 
// Sort by descending resolution
struct FCompareFProjectedShadowInfoByResolution
{
    FORCEINLINE bool operator() (const FProjectedShadowInfo& A, const FProjectedShadowInfo& B) const
    {
        return (B.ResolutionX * B.ResolutionY < A.ResolutionX * A.ResolutionY);
    }
};
 
// Sort by shadow type (CSMs first, then other types).
// Then sort CSMs by descending split index, and other shadows by resolution.
// Used to render shadow cascades in far to near order, whilst preserving the
// descending resolution sort behavior for other shadow types.
// Note: the ordering must match the requirements of blend modes set in SetBlendStateForProjection (blend modes that overwrite must come first)
struct FCompareFProjectedShadowInfoBySplitIndex
{
    FORCEINLINE bool operator()( const FProjectedShadowInfo& A, const FProjectedShadowInfo& B ) const
    {
        if (A.IsWholeSceneDirectionalShadow())
        {
            if (B.IsWholeSceneDirectionalShadow())
            {
                if (A.bRayTracedDistanceField != B.bRayTracedDistanceField)
                {
                    // RTDF shadows need to be rendered after all CSM, because they overlap in depth range with Far Cascades, which will use an overwrite blend mode for the fade plane.
                    if (!A.bRayTracedDistanceField && B.bRayTracedDistanceField)
                    {
                        return true;
                    }
 
                    if (A.bRayTracedDistanceField && !B.bRayTracedDistanceField)
                    {
                        return false;
                    }
                }
 
                // Both A and B are CSMs
                // Compare Split Indexes, to order them far to near.
                return (B.CascadeSettings.ShadowSplitIndex < A.CascadeSettings.ShadowSplitIndex);
            }
 
            // A is a CSM, B is per-object shadow etc.
            // B should be rendered after A.
            return true;
        }
        else
        {
            if (B.IsWholeSceneDirectionalShadow())
            {
                // B should be rendered before A.
                return false;
            }
            
            // Neither shadow is a CSM
            // Sort by descending resolution.
            return FCompareFProjectedShadowInfoByResolution()(A, B);
        }
    }
};