LightComponent.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "UObject/ObjectMacros.h"
#include "Engine/EngineTypes.h"
#include "RenderCommandFence.h"
#include "EngineDefines.h"
#include "SceneTypes.h"
#include "RenderResource.h"
#include "Components/LightComponentBase.h"
#include "LightComponent.generated.h"
 
class FLightSceneProxy;
class FLightComponentMapBuildData;
class FStaticLightingBuildContext;
class FStaticShadowDepthMapData;
class ULevel;
class UMaterialInterface;
class UPrimitiveComponent;
class UTextureLightProfile;
enum class ELightUnits : uint8;
 
using FUpdateLightProxyCallback = TFunction<void(FLightSceneProxy*)>;
 
class FStaticShadowDepthMap : public FTexture
{
public:
 
    FStaticShadowDepthMap() : 
        Data(NULL)
    {}
 
    const FStaticShadowDepthMapData* Data;
 
    virtual void InitRHI(FRHICommandListBase& RHICmdList);
};
 
UCLASS(abstract, HideCategories=(Trigger,Activation,"Components|Activation",Physics), ShowCategories=(Mobility), MinimalAPI)
class ULightComponent : public ULightComponentBase
{
    GENERATED_UCLASS_BODY()
 
    
    UPROPERTY(EditAnywhere, BlueprintReadOnly, interp, Category = Light, meta = (UIMin = "1700.0", UIMax = "12000.0", ShouldShowInViewport = true, DisplayAfter ="bUseTemperature"))
    float Temperature;
    
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Performance)
    float MaxDrawDistance;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Performance, meta = (EditCondition = "MaxDrawDistance > 0.0"))
    float MaxDistanceFadeRange;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=Light, meta=(DisplayName = "Use Temperature", ShouldShowInViewport = true))
    uint32 bUseTemperature : 1;
 
    UPROPERTY()
    int32 ShadowMapChannel_DEPRECATED;
 
    UPROPERTY(NonPIEDuplicateTransient)
    int32 PreviewShadowMapChannel;
    
    UPROPERTY()
    float MinRoughness_DEPRECATED;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=Light, AdvancedDisplay, meta=(UIMin = "0", UIMax = "1"))
    float SpecularScale;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=Light, AdvancedDisplay, meta=(UIMin = "0", UIMax = "1"))
    float DiffuseScale;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=Light, AdvancedDisplay, meta=(UIMin = ".125", UIMax = "8"))
    float ShadowResolutionScale;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=Light, AdvancedDisplay, meta=(UIMin = "0", UIMax = "1"))
    float ShadowBias;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Light, AdvancedDisplay, meta = (UIMin = "0", UIMax = "1"))
    float ShadowSlopeBias;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=Light, AdvancedDisplay, meta=(UIMin = "0.0", UIMax = "1.0", DisplayName = "Shadow Filter Sharpen"))
    float ShadowSharpen;
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Light, AdvancedDisplay, meta = (UIMin = "0.0", UIMax = "0.1"))
    float ContactShadowLength;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Light, AdvancedDisplay, meta = (DisplayName = "Contact Shadow Length In World Space Units"))
    uint32 ContactShadowLengthInWS : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Light, AdvancedDisplay, meta = (ClampMin = 0.0, ClampMax = 1.0, UIMin = "0.0", UIMax = "1.0"))
    float ContactShadowCastingIntensity;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Light, AdvancedDisplay, meta = (ClampMin = 0.0, ClampMax = 1.0))
    float ContactShadowNonCastingIntensity;
 
    UPROPERTY()
    uint32 InverseSquaredFalloff_DEPRECATED:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=Light, AdvancedDisplay)
    uint32 CastTranslucentShadows:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=Light, AdvancedDisplay)
    uint32 bCastShadowsFromCinematicObjectsOnly:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Light, AdvancedDisplay)
    uint32 bForceCachedShadowsForMovablePrimitives : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Light, meta = (DisplayName = "Allow MegaLights"), AdvancedDisplay)
    uint32 bAllowMegaLights : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Light, meta = (DisplayName = "MegaLights Shadow Method"), AdvancedDisplay)
    TEnumAsByte<EMegaLightsShadowMethod::Type> MegaLightsShadowMethod;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Light, meta=(InlineEditConditionToggle), AdvancedDisplay)
    uint32 bOverrideRayEndBias : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Light, meta = (EditCondition = "bOverrideRayEndBias", ClampMin = "0", UIMax = "100"), AdvancedDisplay)
    float RayEndBias;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category=Light)
    FLightingChannels LightingChannels;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category=Light)
    FViewLightingChannels ViewLightingChannels;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=LightFunction)
    TObjectPtr<class UMaterialInterface> LightFunctionMaterial;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY(Transient)
    TObjectPtr<class UMaterialInterface> StashedLightFunctionMaterial;
#endif
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=LightFunction, meta=(AllowPreserveRatio = "true"))
    FVector LightFunctionScale;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=LightProfiles, meta=(DisplayName = "IES Texture"))
    TObjectPtr<class UTextureLightProfile> IESTexture;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=LightProfiles, meta=(DisplayName = "Use IES Intensity", EditCondition="IESTexture!=nullptr"))
    uint32 bUseIESBrightness : 1;
 
    UPROPERTY(BlueprintReadOnly, interp, Category=LightProfiles, meta=(UIMin = "0.0", UIMax = "10.0", DisplayName = "IES Intensity Scale"))
    float IESBrightnessScale;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=LightFunction, meta=(DisplayName = "Fade Distance"))
    float LightFunctionFadeDistance;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=LightFunction, meta=(UIMin = "0.0", UIMax = "1.0"))
    float DisabledBrightness;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=LightShafts, meta=(DisplayName = "Light Shaft Bloom"))
    uint32 bEnableLightShaftBloom:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=LightShafts, meta=(UIMin = "0", UIMax = "10"))
    float BloomScale;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=LightShafts, meta=(UIMin = "0", UIMax = "4"))
    float BloomThreshold;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=LightShafts, meta=(UIMin = "0", UIMax = "100", SliderExponent = 20.0))
    float BloomMaxBrightness;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=LightShafts)
    FColor BloomTint;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=DistanceFieldShadows, meta=(DisplayName = "Distance Field Shadows"))
    bool bUseRayTracedDistanceFieldShadows;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=DistanceFieldShadows, meta=(UIMin = "0", UIMax = ".1"), AdvancedDisplay)
    float RayStartOffsetDepthScale;
 
public:
    UFUNCTION(BlueprintCallable, Category="Rendering|Components|Light")
    ENGINE_API void SetIntensity(float NewIntensity);
 
    UFUNCTION(BlueprintCallable, Category="Rendering|Components|Light")
    ENGINE_API void SetIndirectLightingIntensity(float NewIntensity);
 
    UFUNCTION(BlueprintCallable, Category="Rendering|Components|Light")
    ENGINE_API void SetVolumetricScatteringIntensity(float NewIntensity);
 
    UFUNCTION(BlueprintCallable, Category="Rendering|Components|Light")
    ENGINE_API void SetLightColor(FLinearColor NewLightColor, bool bSRGB = true);
 
    UFUNCTION(Category="Rendering|Components|Light")
    ENGINE_API void SetLightFColor(FColor NewLightColor);
 
    UFUNCTION(BlueprintCallable, Category = "Rendering|Components|Light")
    ENGINE_API void SetTemperature(float NewTemperature);
 
    UFUNCTION(BlueprintCallable, Category = "Rendering|Components|Light")
    ENGINE_API void SetUseTemperature(bool bNewValue);
 
    UFUNCTION(BlueprintCallable, Category="Rendering|Components|Light")
    ENGINE_API void SetLightFunctionMaterial(UMaterialInterface* NewLightFunctionMaterial);
 
    UFUNCTION(BlueprintCallable, Category="Rendering|Components|Light")
    ENGINE_API void SetLightFunctionScale(FVector NewLightFunctionScale);
 
    UFUNCTION(BlueprintCallable, Category="Rendering|Components|Light")
    ENGINE_API void SetLightFunctionFadeDistance(float NewLightFunctionFadeDistance);
 
    UFUNCTION(BlueprintCallable, Category="Rendering|Components|Light")
    ENGINE_API void SetLightFunctionDisabledBrightness(float NewValue);
 
    UFUNCTION(BlueprintCallable, Category="Rendering|Components|Light")
    ENGINE_API void SetAffectTranslucentLighting(bool bNewValue);
 
    UFUNCTION(BlueprintCallable, Category = "Rendering|Components|Light")
    ENGINE_API void SetTransmission(bool bNewValue);
 
    UFUNCTION(BlueprintCallable, Category="Rendering|Components|Light")
    ENGINE_API void SetEnableLightShaftBloom(bool bNewValue);
 
    UFUNCTION(BlueprintCallable, Category="Rendering|Components|Light")
    ENGINE_API void SetBloomScale(float NewValue);
 
    UFUNCTION(BlueprintCallable, Category="Rendering|Components|Light")
    ENGINE_API void SetBloomThreshold(float NewValue);
 
    UFUNCTION(BlueprintCallable, Category="Rendering|Components|Light")
    ENGINE_API void SetBloomMaxBrightness(float NewValue);
 
    UFUNCTION(BlueprintCallable, Category="Rendering|Components|Light")
    ENGINE_API void SetBloomTint(FColor NewValue);
 
    UFUNCTION(BlueprintCallable, Category="Rendering|Components|Light", meta=(DisplayName = "Set IES Texture"))
    ENGINE_API void SetIESTexture(UTextureLightProfile* NewValue);
 
    UFUNCTION(BlueprintCallable, Category="Rendering|Components|Light", meta=(DisplayName = "Set Use IES Intensity"))
    ENGINE_API void SetUseIESBrightness(bool bNewValue);
 
    UFUNCTION(BlueprintCallable, Category="Rendering|Components|Light", meta=(DisplayName = "Set IES Intensity Scale"))
    ENGINE_API void SetIESBrightnessScale(float NewValue);
 
    UFUNCTION(BlueprintCallable, Category="Rendering|Components|Light")
    ENGINE_API void SetShadowBias(float NewValue);
    
    UFUNCTION(BlueprintCallable, Category = "Rendering|Components|Light")
    ENGINE_API void SetShadowSlopeBias(float NewValue);
 
    UFUNCTION(BlueprintCallable, Category = "Rendering|Components|Light")
    ENGINE_API void SetSpecularScale(float NewValue);
 
    UFUNCTION(BlueprintCallable, Category = "Rendering|Components|Light")
    ENGINE_API void SetDiffuseScale(float NewValue);
 
    UFUNCTION(BlueprintCallable, Category = "Rendering|Components|Light")
    ENGINE_API void SetForceCachedShadowsForMovablePrimitives(bool bNewValue);
 
    UFUNCTION(BlueprintCallable, Category = "Rendering|Components|Light")
    ENGINE_API void SetLightingChannels(bool bChannel0, bool bChannel1, bool bChannel2);
 
    UFUNCTION(BlueprintCallable, Category="Rendering|Components|Light")
    ENGINE_API void SetUseRayTracedDistanceFieldShadows(bool bNewValue);
 
    UFUNCTION(BlueprintCallable, Category = "Rendering|Components|Light")
    ENGINE_API void SetMaxDrawDistance(float NewValue);
 
    UFUNCTION(BlueprintCallable, Category = "Rendering|Components|Light")
    ENGINE_API void SetMaxDistanceFadeRange(float NewValue);
 
public:
    FLightSceneProxy* SceneProxy;
 
    ENGINE_API void PushSelectionToProxy();
 
    FStaticShadowDepthMap StaticShadowDepthMap;
 
    FRenderCommandFence DestroyFence;
 
    uint32 bAddedToSceneVisible:1;
 
    ENGINE_API bool AffectsPrimitive(const UPrimitiveComponent* Primitive) const;
 
    ENGINE_API virtual bool AffectsBounds(const FBoxSphereBounds& InBounds) const;
 
    virtual FBox GetBoundingBox() const { return FBox(FVector(-HALF_WORLD_MAX,-HALF_WORLD_MAX,-HALF_WORLD_MAX),FVector(HALF_WORLD_MAX,HALF_WORLD_MAX,HALF_WORLD_MAX)); }
 
    virtual FSphere GetBoundingSphere() const
    {
        // Directional lights will have a radius of WORLD_MAX
        return FSphere(FVector::ZeroVector, WORLD_MAX);
    }
 
#if WITH_EDITOR
    virtual FBox GetStreamingBounds() const override
    {
        return GetBoundingBox();
    }
#endif // WITH_EDITOR
 
    virtual FVector4 GetLightPosition() const PURE_VIRTUAL(ULightComponent::GetPosition,return FVector4(););
 
    virtual ELightComponentType GetLightType() const PURE_VIRTUAL(ULightComponent::GetLightType,return LightType_MAX;);
 
    virtual FLightmassLightSettings GetLightmassSettings() const PURE_VIRTUAL(ULightComponent::GetLightmassSettings,return FLightmassLightSettings(););
 
    virtual float GetUniformPenumbraSize() const PURE_VIRTUAL(ULightComponent::GetUniformPenumbraSize,return 0;);
 
    ENGINE_API virtual ELightUnits GetLightUnits() const;
 
    ENGINE_API bool IsShadowCast(UPrimitiveComponent* Primitive) const;
 
    /* Whether to consider light as a sunlight for atmospheric scattering. */  
    virtual bool IsUsedAsAtmosphereSunLight() const
    {
        return false;
    }
    virtual uint8 GetAtmosphereSunLightIndex() const
    {
        return 0;
    }
    virtual FLinearColor GetAtmosphereSunDiskColorScale() const
    {
        return FLinearColor::White;
    }
 
    ENGINE_API virtual float ComputeLightBrightness() const;
#if WITH_EDITOR
    ENGINE_API virtual void SetLightBrightness(float InBrightness);
#endif
 
    //~ Begin UObject Interface.
    ENGINE_API virtual void Serialize(FArchive& Ar) override;
    ENGINE_API virtual void PostLoad() override;
#if WITH_EDITOR
    ENGINE_API virtual void PreSave(FObjectPreSaveContext ObjectSaveContext) override;
    ENGINE_API virtual bool CanEditChange(const FProperty* InProperty) const override;
    ENGINE_API virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
    ENGINE_API virtual void UpdateLightSpriteTexture() override;
    ENGINE_API virtual void CheckForErrors() override;
#endif // WITH_EDITOR
    ENGINE_API virtual void BeginDestroy() override;
    ENGINE_API virtual bool IsReadyForFinishDestroy() override;
    //~ End UObject Interface.
 
    ENGINE_API virtual TStructOnScope<FActorComponentInstanceData> GetComponentInstanceData() const override;
    ENGINE_API void ApplyComponentInstanceData(struct FPrecomputedLightInstanceData* ComponentInstanceData);
    ENGINE_API virtual void PropagateLightingScenarioChange() override;
    ENGINE_API virtual bool IsPrecomputedLightingValid() const override;
 
    ENGINE_API virtual int32 GetNumMaterials() const;
 
    ENGINE_API virtual UMaterialInterface* GetMaterial(int32 ElementIndex) const;
 
    ENGINE_API virtual void SetMaterial(int32 ElementIndex, UMaterialInterface* InMaterial);
 
    ENGINE_API void ClearLightFunctionMaterial();
 
    virtual class FLightSceneProxy* CreateSceneProxy() const
    {
        return NULL;
    }
 
protected:
    //~ Begin UActorComponent Interface
    ENGINE_API virtual void OnRegister() override;
    ENGINE_API virtual void CreateRenderState_Concurrent(FRegisterComponentContext* Context) override;
    ENGINE_API virtual void SendRenderTransform_Concurrent() override;
    ENGINE_API virtual void DestroyRenderState_Concurrent() override;
    //~ Begin UActorComponent Interface
 
    //~ Begin USceneComponent Interface
#if WITH_EDITOR
    ENGINE_API virtual bool GetMaterialPropertyPath(int32 ElementIndex, UObject*& OutOwner, FString& OutPropertyPath, FProperty*& OutProperty) override;
#endif // WITH_EDITOR
    //~ End USceneComponent Interface
 
    void UpdateProxy(FUpdateLightProxyCallback&& Func);
 
private:
 
    bool CanTraceDistanceFieldShadows() const;
 
public:
    ENGINE_API virtual void InvalidateLightingCacheDetailed(bool bInvalidateBuildEnqueuedLighting, bool bTranslationOnly) override;
 
    ENGINE_API FVector GetDirection() const;
 
    ENGINE_API void UpdateColorAndBrightness();
 
    ENGINE_API const FLightComponentMapBuildData* GetLightComponentMapBuildData() const;
 
    ENGINE_API void InitializeStaticShadowDepthMap();
 
    ENGINE_API FLinearColor GetColoredLightBrightness() const;
 
    ENGINE_API FLinearColor GetColorTemperature() const;
 
#if WITH_EDITOR 
    static ENGINE_API void ReassignStationaryLightChannels(UWorld* TargetWorld, bool bAssignForLightingBuild, FStaticLightingBuildContext* LightingContext);
#endif
 
    DECLARE_MULTICAST_DELEGATE_OneParam(FOnUpdateColorAndBrightness, ULightComponent&);
 
    static ENGINE_API FOnUpdateColorAndBrightness UpdateColorAndBrightnessEvent;
};
 
 
USTRUCT()
struct FPrecomputedLightInstanceData : public FSceneComponentInstanceData
{
    GENERATED_BODY()
 
    FPrecomputedLightInstanceData() = default;
    FPrecomputedLightInstanceData(const ULightComponent* SourceComponent)
        : FSceneComponentInstanceData(SourceComponent)
        , Transform(SourceComponent->GetComponentTransform())
        , OriginalLightGuid(SourceComponent->OriginalLightGuid)     
        , LightGuid(SourceComponent->LightGuid)
        , PreviewShadowMapChannel(SourceComponent->PreviewShadowMapChannel)
    {}
    virtual ~FPrecomputedLightInstanceData() = default;
 
    virtual bool ContainsData() const override
    {
        return true;
    }
 
    virtual void ApplyToComponent(UActorComponent* Component, const ECacheApplyPhase CacheApplyPhase) override
    {
        Super::ApplyToComponent(Component, CacheApplyPhase);
        CastChecked<ULightComponent>(Component)->ApplyComponentInstanceData(this);
    }
 
    UPROPERTY()
    FTransform Transform;
 
    UPROPERTY()
    FGuid OriginalLightGuid;
 
    UPROPERTY()
    FGuid LightGuid;
 
    UPROPERTY()
    int32 PreviewShadowMapChannel = 0;
};