LightSceneInfo.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    LightSceneInfo.h: Light scene info definitions.
=============================================================================*/
 
#pragma once
 
#include "CoreTypes.h"
#include "Math/Color.h"
#include "Math/GenericOctree.h"
#include "Math/GenericOctreePublic.h"
#include "Math/UnrealMath.h"
#include "PrimitiveSceneProxy.h"
#include "SceneTypes.h"
#include "SceneView.h"
 
class FLightPrimitiveInteraction;
class FLightSceneInfo;
class FMobileMovableLocalLightShadowParameters;
class FPrimitiveSceneInfoCompact;
class FPrimitiveSceneProxy;
class FScene;
class FViewInfo;
class FVisibleLightInfo;
 
namespace ECastRayTracedShadow
{
    enum Type : int;
}
 
class FLightSceneInfoCompact
{
public:
    // XYZ: origin, W:sphere radius
    VectorRegister BoundingSphereVector;
    FLinearColor Color;
    // must not be 0
    FLightSceneInfo* LightSceneInfo;
    // e.g. LightType_Directional, LightType_Point or LightType_Spot
    uint32 LightType : LightType_NumBits;   
    uint32 bCastDynamicShadow : 1;
    uint32 bCastStaticShadow : 1;
    uint32 bStaticLighting : 1;
    uint32 bAffectReflection : 1;
    uint32 bAffectGlobalIllumination : 1;
    uint32 bIsMovable : 1;
    uint32 bAllowMegaLights : 1;
    TEnumAsByte<EMegaLightsShadowMethod::Type> MegaLightsShadowMethod;
    TEnumAsByte<ECastRayTracedShadow::Type> CastRaytracedShadow;
 
    void Init(FLightSceneInfo* InLightSceneInfo);
 
    FLightSceneInfoCompact():
        LightSceneInfo(NULL)
    {}
 
    FLightSceneInfoCompact(FLightSceneInfo* InLightSceneInfo)
    {
        Init(InLightSceneInfo);
    }
 
    bool AffectsPrimitive(const FBoxSphereBounds& PrimitiveBounds, const FPrimitiveSceneProxy* PrimitiveSceneProxy) const;
};
 
struct FSortedLightSceneInfo
{
    union
    {
        struct
        {
            // Note: the order of these members controls the light sort order!
            // Currently bHandledByMegaLights is the MSB and LightType is LSB
            uint32 LightType : LightType_NumBits;
            uint32 bIESProfile : 1;
            uint32 bLightFunction : 1;
            uint32 bUsesLightingChannels : 1;
            uint32 bShadowed : 1;
            uint32 bIsNotSimpleLight : 1;
            uint32 bClusteredDeferredNotSupported : 1;
            uint32 LightSceneId : LIGHT_ID_NUM_BITS;
            uint32 bHandledByMegaLights : 1;
        } Fields;
        uint32 Packed;
        static_assert(sizeof(Packed) >= sizeof(Fields), "SortKey Packed representation must include all bits in Fields");
    } SortKey;
 
    const FLightSceneInfo* LightSceneInfo;
    int32 SimpleLightIndex;
    bool bIsCompatibleWithLightFunctionAtlas;
 
    explicit FSortedLightSceneInfo(const FLightSceneInfo* InLightSceneInfo)
        : LightSceneInfo(InLightSceneInfo),
        SimpleLightIndex(-1),
        bIsCompatibleWithLightFunctionAtlas(false)
    {
        SortKey.Packed = 0;
        SortKey.Fields.bIsNotSimpleLight = 1;
    }
 
    explicit FSortedLightSceneInfo(int32 InSimpleLightIndex)
        : LightSceneInfo(nullptr),
        SimpleLightIndex(InSimpleLightIndex),
        bIsCompatibleWithLightFunctionAtlas(false)
    {
        SortKey.Packed = 0;
        SortKey.Fields.bIsNotSimpleLight = 0;
    }
};
 
struct FSortedLightSetSceneInfo
{
    // One past last simple light excluding those handled by Mega Lights
    int32 SimpleLightsEnd;
    int32 ClusteredSupportedEnd;
 
    int32 UnbatchedLightStart;
 
    // First light handled by Mega Lights
    int32 MegaLightsLightStart;
    // One past last simple light handled by Mega Lights
    int32 MegaLightsSimpleLightsEnd;
 
    bool bHasRectLights = false;
    bool bHasLightFunctions = false;
    bool bHasLightChannels = false;
    bool bHasFirstPersonSelfShadowLights = false;
 
    FSimpleLightArray SimpleLights;
    TArray<FSortedLightSceneInfo, SceneRenderingAllocator> SortedLights;
};
 
template <>
struct TUseBitwiseSwap<FSortedLightSceneInfo>
{
    enum { Value = false };
};
 
typedef TOctree2<FLightSceneInfoCompact,struct FLightOctreeSemantics> FSceneLightOctree;
 
struct FPersistentShadowStateKey
{
    int32 AtlasIndex = -1;
    int32 ProjectionId = -1;
    int32 SubjectPrimitiveComponentIndex = -1;
};
 
inline uint32 GetTypeHash(const FPersistentShadowStateKey& Key)
{
    return HashCombine(HashCombine((uint32)Key.AtlasIndex, (uint32)Key.ProjectionId), (uint32)Key.SubjectPrimitiveComponentIndex);
}
 
inline bool operator==(const FPersistentShadowStateKey& A, const FPersistentShadowStateKey& B)
{
    return A.AtlasIndex == B.AtlasIndex && A.ProjectionId == B.ProjectionId && A.SubjectPrimitiveComponentIndex == B.SubjectPrimitiveComponentIndex;
}
 
class FPersistentShadowState
{
public:
    FViewMatrices                       ViewMatrices;
 
    FIntRect                            HZBTestViewRect;
    TRefCountPtr<IPooledRenderTarget>   HZB;                // Direct HZB. nullptr for Atlas rendering.
};
 
class FLightSceneInfo
{
    friend class FLightPrimitiveInteraction;
 
    bool bRecordInteractionShadowPrimitives;
    TArray<FLightPrimitiveInteraction*> InteractionShadowPrimitives;
 
    FLightPrimitiveInteraction* DynamicInteractionOftenMovingPrimitiveList;
 
    FLightPrimitiveInteraction* DynamicInteractionStaticPrimitiveList;
 
public:
    using FPersistentId = int32;
 
    FLightSceneProxy* Proxy;
 
    ELightComponentType Type;
 
    FPersistentId Id;
    FORCEINLINE FPersistentId GetPersistentIndex() const { return Id; }
 
    FOctreeElementId2 OctreeId;
 
    TMap<FPersistentShadowStateKey, FPersistentShadowState> PrevPersistentShadows;
    TMap<FPersistentShadowStateKey, FPersistentShadowState> PersistentShadows;
 
protected:
 
    int32 DynamicShadowMapChannel;
 
    uint32 bPrecomputedLightingIsValid : 1;
 
public:
 
    uint32 bVisible : 1;
 
    uint32 bEnableLightShaftBloom : 1;
 
    float BloomScale;
 
    float BloomThreshold;
 
    float BloomMaxBrightness;
 
    FColor BloomTint;
 
    int32 NumUnbuiltInteractions;
 
    bool bCreatePerObjectShadowsForDynamicObjects;
 
    FScene* Scene;
 
    FLightSceneInfo(FLightSceneProxy* InProxy, bool InbVisible);
 
    void AddToScene();
 
    bool ShouldCreateLightPrimitiveInteraction(const FLightSceneInfoCompact& LightSceneInfoCompact, const FPrimitiveSceneInfoCompact& PrimitiveSceneInfoCompact);
 
    void CreateLightPrimitiveInteraction(const FLightSceneInfoCompact& LightSceneInfoCompact, const FPrimitiveSceneInfoCompact& PrimitiveSceneInfoCompact);
 
    void RemoveFromScene();
 
    void Detach();
 
    FBoxCenterAndExtent GetBoundingBox() const;
 
    bool ShouldRenderLight(const FViewInfo& View, bool bOffscreen = false) const;
 
    bool ShouldRenderLightViewIndependent() const;
 
    bool ShouldRenderViewIndependentWholeSceneShadows() const;
 
    bool IsPrecomputedLightingValid() const;
 
    void SetDynamicShadowMapChannel(int32 NewChannel);
 
    int32 GetDynamicShadowMapChannel() const;
 
    const TArray<FLightPrimitiveInteraction*>* GetInteractionShadowPrimitives() const;
 
    FLightPrimitiveInteraction* GetDynamicInteractionOftenMovingPrimitiveList() const;
 
    FLightPrimitiveInteraction* GetDynamicInteractionStaticPrimitiveList() const;
 
    friend uint32 GetTypeHash(const FLightSceneInfo* LightSceneInfo)
    {
        return (uint32)LightSceneInfo->Id;
    }
 
    bool SetupMobileMovableLocalLightShadowParameters(const FViewInfo& View, TConstArrayView<FVisibleLightInfo> VisibleLightInfos, FMobileMovableLocalLightShadowParameters& MobileMovableLocalLightShadowParameters) const;
 
    bool ShouldRecordShadowSubjectsForMobile() const;
 
    // Extra data such as shadow channel masks, light type and flags packed into a uint32.
    // Unpacked in shader using helper functions defined in LightData.ush
    uint32 PackExtraData(bool bAllowStaticLighting, bool bLightFunction, bool bMegaLight, bool bClusteredDeferredSupported) const;
};
 
struct FLightOctreeSemantics
{
    enum { MaxElementsPerLeaf = 16 };
    enum { MinInclusiveElementsPerNode = 7 };
    enum { MaxNodeDepth = 12 };
 
    typedef TInlineAllocator<MaxElementsPerLeaf, TAlignedHeapAllocator<alignof(FLightSceneInfoCompact)>> ElementAllocator;
 
    FORCEINLINE static FBoxCenterAndExtent GetBoundingBox(const FLightSceneInfoCompact& Element)
    {
        return Element.LightSceneInfo->GetBoundingBox();
    }
 
    FORCEINLINE static bool AreElementsEqual(const FLightSceneInfoCompact& A,const FLightSceneInfoCompact& B)
    {
        return A.LightSceneInfo == B.LightSceneInfo;
    }
    
    FORCEINLINE static void SetElementId(const FLightSceneInfoCompact& Element,FOctreeElementId2 Id)
    {
        Element.LightSceneInfo->OctreeId = Id;
    }
 
    FORCEINLINE static void ApplyOffset(FLightSceneInfoCompact& Element, FVector Offset)
    {
        VectorRegister OffsetReg = VectorLoadFloat3_W0(&Offset);
        Element.BoundingSphereVector = VectorAdd(Element.BoundingSphereVector, OffsetReg);
    }
};