LightSceneProxy.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "GameFramework/Actor.h"
#include "Math/Color.h"
#include "Math/MathFwd.h"
#include "Math/Vector.h"
#include "UObject/NameTypes.h"
 
class ULightComponent;
class FMaterialRenderProxy;
struct FViewMatrices;
struct FLightRenderParameters;
class FSceneView;
class FSceneViewFamily;
class FWholeSceneProjectedShadowInitializer;
class FPerObjectProjectedShadowInitializer;
class FShadowCascadeSettings;
class FRHICommandList;
class FLightSceneInfo;
class UTextureLightProfile;
class FTexture;
 
enum ELightShaderParameterFlags
{
    RectAsSpotLight=1,
};
 
// Hacky base class to avoid 8 bytes of padding after the vtable
class FLightSceneProxyFixLayout
{
public:
    virtual ~FLightSceneProxyFixLayout() = default;
};
 
class FLightSceneProxy : public FLightSceneProxyFixLayout
{
public:
 
    ENGINE_API FLightSceneProxy(const ULightComponent* InLightComponent);
    ENGINE_API virtual ~FLightSceneProxy();
 
    virtual bool AffectsBounds(const FBoxSphereBounds& Bounds) const
    {
        return true;
    }
 
    ENGINE_API void SetLightFunctionMaterial_GameThread(const ULightComponent* Component);
    ENGINE_API void SetTransmission_GameThread(const ULightComponent* Component);
 
    ENGINE_API virtual FSphere GetBoundingSphere() const;
 
    virtual float GetRadius() const { return FLT_MAX; }
    virtual float GetOuterConeAngle() const { return 0.0f; }
    virtual float GetSourceRadius() const { return 0.0f; }
    virtual bool IsInverseSquared() const { return true; }
    virtual bool IsRectLight() const { return false; }
    virtual bool  IsLocalLight() const { return false; }
    virtual bool HasSourceTexture() const { return false; }
    virtual float GetLightSourceAngle() const { return 0.0f; }
    virtual float GetShadowSourceAngleFactor() const { return 1.0f; }
    virtual float GetTraceDistance() const { return 0.0f; }
 
    // TODO: refactor this to move into the shadow scene renderer
    virtual float GetEffectiveScreenRadius(const FViewMatrices& ShadowViewMatrices, const FIntPoint& CameraViewRectSize) const { return 0.0f; }
 
    UE_DEPRECATED(5.1, "The GetEffectiveScreenRadius() that uses the screen-percentage scaled view rect (above) is used now.")
    virtual float GetEffectiveScreenRadius(const FViewMatrices& ShadowViewMatrices) const { return 0.0f; }
 
    virtual void GetLightShaderParameters(FLightRenderParameters& OutLightParameters, uint32 Flags=0) const {}
 
    virtual FVector2D GetDirectionalLightDistanceFadeParameters(ERHIFeatureLevel::Type InFeatureLevel, bool bPrecomputedLightingIsValid, int32 MaxNearCascades) const
    {
        return FVector2D(0, 0);
    }
 
    virtual int32 GetDirectionalLightForwardShadingPriority() const
    {
        return 0;
    }
 
    virtual bool GetLightShaftOcclusionParameters(float& OutOcclusionMaskDarkness, float& OutOcclusionDepthRange) const
    {
        OutOcclusionMaskDarkness = 0;
        OutOcclusionDepthRange = 1;
        return false;
    }
 
    virtual FVector GetLightPositionForLightShafts(FVector ViewOrigin) const
    {
        return GetPosition();
    }
 
    virtual bool GetWholeSceneProjectedShadowInitializer(const FSceneViewFamily& ViewFamily, TArray<FWholeSceneProjectedShadowInitializer, TInlineAllocator<6> >& OutInitializers) const
    {
        return false;
    }
 
    ENGINE_API virtual bool ShouldCreatePerObjectShadowsForDynamicObjects() const;
 
    ENGINE_API virtual bool UseCSMForDynamicObjects() const;
 
    float GetVSMTexelDitherScale() const
    {
        return VSMTexelDitherScale;
    }
 
    float GetVSMResolutionLodBias() const
    {
        return VSMResolutionLodBias;
    }
    
    virtual uint32 GetNumViewDependentWholeSceneShadows(const FSceneView& View, bool bPrecomputedLightingIsValid) const { return 0; }
 
    virtual bool GetViewDependentWholeSceneProjectedShadowInitializer(
        const FSceneView& View,
        int32 InCascadeIndex,
        bool bPrecomputedLightingIsValid,
        FWholeSceneProjectedShadowInitializer& OutInitializer) const
    {
        return false;
    }
 
    virtual bool GetPerObjectProjectedShadowInitializer(const FBoxSphereBounds& SubjectBounds, FPerObjectProjectedShadowInitializer& OutInitializer) const
    {
        return false;
    }
 
    // @param InCascadeIndex cascade index or INDEX_NONE for the distance field cascade
    // @param OutCascadeSettings can be 0
    virtual FSphere GetShadowSplitBounds(const FSceneView& View, int32 InCascadeIndex, bool bPrecomputedLightingIsValid, FShadowCascadeSettings* OutCascadeSettings) const { return FSphere(FVector::ZeroVector, 0); }
    virtual FSphere GetShadowSplitBoundsDepthRange(const FSceneView& View, FVector ViewOrigin, float SplitNear, float SplitFar, FShadowCascadeSettings* OutCascadeSettings) const { return FSphere(FVector::ZeroVector, 0); }
 
    ENGINE_API virtual bool GetScissorRect(FIntRect& ScissorRect, const FSceneView& View, const FIntRect& ViewRect) const;
 
    // @param OutScissorRect the scissor rect used if one is set
    // @return whether a scissor rect is set
    virtual bool SetScissorRect(FRHICommandList& RHICmdList, const FSceneView& View, const FIntRect& ViewRect, FIntRect* OutScissorRect = nullptr) const
    {
        return false;
    }
 
    virtual bool ShouldCreateRayTracedCascade(ERHIFeatureLevel::Type Type, bool bPrecomputedLightingIsValid, int32 MaxNearCascades) const { return false; }
 
    // Accessors.
    float GetUserShadowBias() const { return ShadowBias; }
    float GetUserShadowSlopeBias() const { return ShadowSlopeBias; }
 
    inline const ULightComponent* GetLightComponent() const { return LightComponent; }
    inline FSceneInterface* GetSceneInterface() const { return SceneInterface; }
    inline FLightSceneInfo* GetLightSceneInfo() const { return LightSceneInfo; }
    inline const FMatrix& GetWorldToLight() const { return WorldToLight; }
    inline const FMatrix& GetLightToWorld() const { return LightToWorld; }
    inline FVector GetDirection() const { return FVector(WorldToLight.M[0][0], WorldToLight.M[1][0], WorldToLight.M[2][0]); }
    inline FVector GetOrigin() const { return LightToWorld.GetOrigin(); }
    inline FVector4 GetPosition() const { return Position; }
    inline const FLinearColor& GetColor() const { return Color; }
    inline float GetIndirectLightingScale() const { return IndirectLightingScale; }
    inline float GetVolumetricScatteringIntensity() const { return VolumetricScatteringIntensity; }
    inline float GetRayEndBias() const { return RayEndBias; }
    inline float GetShadowResolutionScale() const { return ShadowResolutionScale; }
    inline FGuid GetLightGuid() const { return LightGuid; }
    inline float GetShadowSharpen() const { return ShadowSharpen; }
    inline float GetContactShadowLength() const { return ContactShadowLength; }
    inline bool IsContactShadowLengthInWS() const { return bContactShadowLengthInWS; }
    inline float GetContactShadowCastingIntensity() const { return ContactShadowCastingIntensity; }
    inline float GetContactShadowNonCastingIntensity() const { return ContactShadowNonCastingIntensity; }
    inline float GetSpecularScale() const { return SpecularScale; }
    inline float GetDiffuseScale() const { return DiffuseScale; }
    inline FVector GetLightFunctionScale() const { return LightFunctionScale; }
    inline float GetLightFunctionFadeDistance() const { return LightFunctionFadeDistance; }
    inline float GetLightFunctionDisabledBrightness() const { return LightFunctionDisabledBrightness; }
    inline UTextureLightProfile* GetIESTexture() const { return IESTexture; }
    ENGINE_API FTexture* GetIESTextureResource() const;
    inline const FMaterialRenderProxy* GetLightFunctionMaterial() const { return LightFunctionMaterial; }
    inline bool IsMovable() const { return bMovable; }
    inline bool HasStaticLighting() const { return bStaticLighting; }
    inline bool HasStaticShadowing() const { return bStaticShadowing; }
    inline bool CastsDynamicShadow() const { return bCastDynamicShadow; }
    inline bool CastsStaticShadow() const { return bCastStaticShadow; }
    inline bool AllowMegaLights() const { return bAllowMegaLights; }
    TEnumAsByte<EMegaLightsShadowMethod::Type> GetMegaLightsShadowMethod() const { return MegaLightsShadowMethod; }
    inline bool CastsTranslucentShadows() const { return bCastTranslucentShadows; }
    inline bool CastsVolumetricShadow() const { return bCastVolumetricShadow; }
    inline bool CastsHairStrandsDeepShadow() const { return bCastHairStrandsDeepShadow; }
    inline TEnumAsByte<ECastRayTracedShadow::Type> CastsRaytracedShadow() const { return CastRaytracedShadow; }
    inline bool AffectReflection() const { return bAffectReflection; }
    inline bool AffectGlobalIllumination() const { return bAffectGlobalIllumination; }
    inline bool CastsShadowsFromCinematicObjectsOnly() const { return bCastShadowsFromCinematicObjectsOnly; }
    inline bool CastsModulatedShadows() const { return bCastModulatedShadows; }
    inline const FLinearColor& GetModulatedShadowColor() const { return ModulatedShadowColor; }
    inline const float GetShadowAmount() const { return ShadowAmount; }
    inline bool AffectsTranslucentLighting() const { return bAffectTranslucentLighting; }
    inline bool Transmission() const { return bTransmission; }
    inline bool UseRayTracedDistanceFieldShadows() const { return bUseRayTracedDistanceFieldShadows; }
    inline bool UseVirtualShadowMaps() const { return bUseVirtualShadowMaps; }
    inline float GetRayStartOffsetDepthScale() const { return RayStartOffsetDepthScale; }
    inline uint8 GetLightType() const { return LightType; }
    inline uint8 GetLightingChannelMask() const { return LightingChannelMask; }
    inline uint8 GetViewLightingChannelMask() const { return ViewLightingChannelMask; }
    inline FName GetComponentFName() const { return ComponentName; }
 
    inline bool IsSelected() const { return bSelected; }
    inline void SetSelected(bool bNewSelected) { bSelected = bNewSelected; }
 
#if ACTOR_HAS_LABELS
    inline const FString& GetOwnerNameOrLabel() const { return OwnerNameOrLabel; }
#else 
    inline FString GetOwnerNameOrLabel() const { return ComponentName.ToString(); }
#endif 
 
    inline FName GetLevelName() const { return LevelName; }
    inline TStatId GetStatId() const
    {
        return StatId;
    }
    inline int32 GetShadowMapChannel() const { return ShadowMapChannel; }
    inline int32 GetPreviewShadowMapChannel() const { return PreviewShadowMapChannel; }
 
    inline const class FStaticShadowDepthMap* GetStaticShadowDepthMap() const { return StaticShadowDepthMap; }
 
    inline bool GetForceCachedShadowsForMovablePrimitives() const { return bForceCachedShadowsForMovablePrimitives; }
 
    inline uint32 GetSamplesPerPixel() const { return SamplesPerPixel; }
    inline float GetDeepShadowLayerDistribution() const { return DeepShadowLayerDistribution; }
    ENGINE_API virtual void ApplyWorldOffset(FVector InOffset);
 
    virtual float GetMaxDrawDistance() const { return 0.0f; }
    virtual float GetFadeRange() const { return 0.0f; }
 
    // Atmosphere / Fog related functions.
 
    inline bool IsUsedAsAtmosphereSunLight() const { return bUsedAsAtmosphereSunLight; }
    inline uint8 GetAtmosphereSunLightIndex() const { return AtmosphereSunLightIndex; }
    inline FLinearColor GetAtmosphereSunDiskColorScale() const { return AtmosphereSunDiskColorScale; }
    virtual void SetAtmosphereRelatedProperties(FLinearColor TransmittanceTowardSunIn, FLinearColor SunDiscOuterSpaceLuminanceIn) {}
    virtual FLinearColor GetOuterSpaceLuminance() const { return FLinearColor::White; }
    virtual FLinearColor GetOuterSpaceIlluminance() const { return GetColor(); }
    virtual FLinearColor GetAtmosphereTransmittanceTowardSun() const { return FLinearColor::White; }
    virtual FLinearColor GetSunIlluminanceOnGroundPostTransmittance() const { return GetColor(); }
    virtual FLinearColor GetSunIlluminanceAccountingForSkyAtmospherePerPixelTransmittance() const { return GetColor(); }
    virtual bool GetPerPixelTransmittanceEnabled() const { return false; }
    static float GetSunOnEarthHalfApexAngleRadian()
    {
        const float SunOnEarthApexAngleDegree = 0.545f; // Apex angle == angular diameter
        return 0.5f * SunOnEarthApexAngleDegree * UE_PI / 180.0f;
    }
    virtual float GetSunLightHalfApexAngleRadian() const { return GetSunOnEarthHalfApexAngleRadian(); }
 
    virtual bool GetCastShadowsOnClouds() const { return false; }
    virtual bool GetCastShadowsOnAtmosphere() const { return false; }
    virtual bool GetCastCloudShadows() const { return false; }
    virtual float GetCloudShadowExtent() const { return 1.0f; }
    virtual float GetCloudShadowMapResolutionScale() const { return 1.0f; }
    virtual float GetCloudShadowRaySampleCountScale() const { return 1.0f; }
    virtual float GetCloudShadowStrength() const { return 1.0f; }
    virtual float GetCloudShadowOnAtmosphereStrength() const { return 1.0f; }
    virtual float GetCloudShadowOnSurfaceStrength() const { return 1.0f; }
    virtual float GetCloudShadowDepthBias() const { return 0.0f; }
    virtual FLinearColor GetCloudScatteredLuminanceScale() const { return FLinearColor::White; }
    virtual bool GetUsePerPixelAtmosphereTransmittance() const { return false; }
 
    inline void  SetLightFunctionAtlasIndices(uint8 LightIndex) { LightFunctionAtlasLightIndex = LightIndex; }
    inline bool  HasValidLightFunctionAtlasSlot() const { return LightFunctionAtlasLightIndex != 0; }
    inline uint8 GetLightFunctionAtlasLightIndex() const { return LightFunctionAtlasLightIndex; }
 
protected:
 
    friend class FScene;
    friend class FLightSceneInfo;
 
    const ULightComponent* LightComponent;
 
    FSceneInterface* SceneInterface;
 
    class FLightSceneInfo* LightSceneInfo;
 
    FVector4 Position;
 
    FLinearColor Color;
 
    FMatrix WorldToLight;
 
    FMatrix LightToWorld;
 
    float IndirectLightingScale;
 
    float VolumetricScatteringIntensity;
 
    float RayEndBias;
 
    float ShadowResolutionScale;
 
    float ShadowBias;
 
    float ShadowSlopeBias;
 
    float ShadowSharpen;
 
    float ContactShadowLength;
 
    float ContactShadowCastingIntensity;
 
    float ContactShadowNonCastingIntensity;
 
    float SpecularScale;
 
    float DiffuseScale;
 
    FGuid LightGuid;
 
    int32 ShadowMapChannel;
 
    int32 PreviewShadowMapChannel;
 
    float RayStartOffsetDepthScale;
 
    const class FStaticShadowDepthMap* StaticShadowDepthMap;
 
    FVector LightFunctionScale;
    float LightFunctionFadeDistance;
    float LightFunctionDisabledBrightness;
    const FMaterialRenderProxy* LightFunctionMaterial;
 
    UTextureLightProfile* IESTexture;
 
    uint8 bContactShadowLengthInWS : 1;
 
    /* True if the light's Mobility is set to Movable. */
    const uint8 bMovable : 1;
 
    const uint8 bStaticLighting : 1;
 
    uint8 bStaticShadowing : 1;
 
    uint8 bCastDynamicShadow : 1;
 
    const uint8 bCastStaticShadow : 1;
 
    const uint8 bCastTranslucentShadows : 1;
 
    uint8 bTransmission : 1;
 
    const uint8 bCastVolumetricShadow : 1;
    const uint8 bCastHairStrandsDeepShadow : 1;
    const uint8 bCastShadowsFromCinematicObjectsOnly : 1;
 
    const uint8 bForceCachedShadowsForMovablePrimitives : 1;
 
    const TEnumAsByte<ECastRayTracedShadow::Type> CastRaytracedShadow;
 
    const uint8 bAffectReflection : 1;
 
    const uint8 bAffectGlobalIllumination : 1;
 
    const uint8 bAffectTranslucentLighting : 1;
 
    const uint8 bUsedAsAtmosphereSunLight : 1;
 
    const uint8 bUseRayTracedDistanceFieldShadows : 1;
 
    uint8 bUseVirtualShadowMaps : 1;
 
    uint8 bCastModulatedShadows : 1;
 
    uint8 bUseWholeSceneCSMForMovableObjects : 1;
 
    uint8 bSelected : 1;
 
    const uint8 bAllowMegaLights : 1;
 
    const TEnumAsByte<EMegaLightsShadowMethod::Type> MegaLightsShadowMethod;
 
    uint8 LightFunctionAtlasLightIndex;
 
    const uint8 AtmosphereSunLightIndex;
 
    FLinearColor AtmosphereSunDiskColorScale;
 
    const uint8 LightType;
 
    uint8 LightingChannelMask;
    uint8 ViewLightingChannelMask;
 
    TStatId StatId;
 
    FName ComponentName;
 
    FName LevelName;
 
    float VSMTexelDitherScale;
    float VSMResolutionLodBias;
 
    float FarShadowDistance;
 
    uint32 FarShadowCascadeCount;
 
    FLinearColor ModulatedShadowColor;
 
    float ShadowAmount;
 
    uint32 SamplesPerPixel;
 
    float DeepShadowLayerDistribution;
 
    uint32 IESAtlasId;
 
    ENGINE_API void SetTransform(const FMatrix& InLightToWorld, const FVector4& InPosition);
 
    ENGINE_API void SetColor(const FLinearColor& InColor);
 
private:
#if ACTOR_HAS_LABELS
    // May store the label or name of the actor containing the component or if there is no actor the name of the component itself
    FString OwnerNameOrLabel;
#endif
};