VirtualShadowMapClipmap.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
VirtualShadowMapClipmap.h
=============================================================================*/
 
#pragma once
 
#include "CoreMinimal.h"
#include "ConvexVolume.h"
#include "Templates/RefCounting.h"
#include "VirtualShadowMapProjection.h"
#include "VirtualShadowMapCacheManager.h"
 
struct FViewMatrices;
struct FVirtualShadowMapProjectionShaderData;
class FPrimitiveSceneInfo;
class FVirtualShadowMap;
class FVirtualShadowMapArray;
 
bool IsVirtualShadowMapDirectionalReceiverMaskEnabled();
 
class FVirtualShadowMapClipmapConfig
{
public:
    static FVirtualShadowMapClipmapConfig GetGlobal();
 
    int32 FirstLevel = 8;
    int32 LastLevel = 18;
    int32 FirstCoarseLevel = -1;
    int32 LastCoarseLevel = -1;
    uint32 ShadowTypeId = 0u;
    float ResolutionLodBias = 0.0f;
    float ResolutionLodBiasMoving = 0.0f;
    bool bForceInvalidate = false;
    bool bIsFirstPersonShadow = false;
    bool bCullDynamicTightly = false;
    bool bUseReceiverMask = false;
};
 
class FVirtualShadowMapClipmap : FRefCountedObject
{
public: 
    FVirtualShadowMapClipmap(
        FVirtualShadowMapArray& VirtualShadowMapArray,
        const FLightSceneInfo& InLightSceneInfo,
        const FViewMatrices& CameraViewMatrices,
        FIntPoint CameraViewRectSize,
        const FViewInfo* InDependentView,
        float LightMobilityFactor,
        const FVirtualShadowMapClipmapConfig& Config = FVirtualShadowMapClipmapConfig::GetGlobal()
    );
 
    FViewMatrices GetViewMatrices(int32 ClipmapIndex) const;
 
    FVector2f GetDynamicDepthCullRange(int32 ClipmapIndex) const
    {
        check(ClipmapIndex >= 0 && ClipmapIndex < LevelData.Num());
        return LevelData[ClipmapIndex].DynamicDepthCullRange;
    }
 
    int32 GetVirtualShadowMapId() const
    {
        return PerLightCacheEntry->GetVirtualShadowMapId();
    }
 
    int32 GetLevelCount() const
    {
        return LevelData.Num();
    }
 
    // Get absolute clipmap level from index (0..GetLevelCount())
    int32 GetClipmapLevel(int32 ClipmapIndex) const
    {
        return FirstLevel + ClipmapIndex;
    }
 
    FVector GetPreViewTranslation(int32 ClipmapIndex) const
    {
        return -LevelData[ClipmapIndex].WorldCenter;
    }
 
    FMatrix GetViewToClipMatrix(int32 ClipmapIndex) const
    {
        return LevelData[ClipmapIndex].ViewToClip;
    }
 
    FMatrix GetWorldToLightViewRotationMatrix() const
    {
        return WorldToLightViewRotationMatrix;
    }
 
    const FLightSceneInfo& GetLightSceneInfo() const
    {
        return LightSceneInfo;
    }
 
    const FVirtualShadowMapProjectionShaderData& GetProjectionShaderData(int32 ClipmapIndex) const;
 
    FVector GetWorldOrigin() const
    {
        return WorldOrigin;
    }
 
    static float GetLevelRadius(float AbsoluteLevel);
 
    // Returns the max radius the clipmap is guaranteed to cover (i.e. the radius of the last clipmap level)
    // Note that this is not a conservative radius of the level projection, which is snapped
    float GetMaxRadius() const;
    FSphere GetBoundingSphere() const { return BoundingSphere; }
    FConvexVolume GetViewFrustumBounds() const { return ViewFrustumBounds; }
 
    const FViewInfo* GetDependentView() const { return DependentView; }
 
    void OnPrimitiveRendered(const FPrimitiveSceneInfo* PrimitiveSceneInfo);
 
    void UpdateCachedFrameData();
 
    TSharedPtr<FVirtualShadowMapPerLightCacheEntry>& GetCacheEntry() { return PerLightCacheEntry; }
 
    bool IsFirstPersonShadow() const { return Config.bIsFirstPersonShadow; }
 
private:
    FVirtualShadowMapProjectionShaderData ComputeProjectionShaderData(int32 ClipmapIndex) const;
    void ComputeBoundingVolumes(const FVector CameraOrigin);
 
    FVirtualShadowMapClipmapConfig Config;
 
    const FLightSceneInfo& LightSceneInfo;
 
    const FViewInfo* DependentView;
 
    FVector WorldOrigin;
    FVector CameraToViewTarget;
 
    FVector LightDirection;
 
    FMatrix WorldToLightViewRotationMatrix;
 
    int32 FirstLevel;
    float ResolutionLodBias;
 
    struct FLevelData
    {
        FMatrix ViewToClip;
        FVector WorldCenter;
        //Offset from (0,0) to clipmap corner, in level radii
        FInt64Point CornerOffset;
        //Offset from LastLevel-snapped WorldCenter to clipmap corner, in level radii
        FIntPoint RelativeCornerOffset;
        double WPODistanceDisableThresholdSquared;
        FVector2f DynamicDepthCullRange;
    };
    TArray< FLevelData, TInlineAllocator<32> > LevelData;
 
    FSphere BoundingSphere;
    FConvexVolume ViewFrustumBounds;
 
    TSharedPtr<FVirtualShadowMapPerLightCacheEntry> PerLightCacheEntry;
 
    // Rendered primitives are marked during culling (through OnPrimitiveRendered being called).
    TBitArray<> RenderedPrimitives;
};