SkyLightComponent.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 "RenderCommandFence.h"
#include "RenderResource.h"
#include "RenderingThread.h"
#include "Components/LightComponentBase.h"
#include "Math/SHMath.h"
#include "Misc/TransactionallySafeCriticalSection.h"
#include "RenderDeferredCleanup.h"
#include "SkyLightComponent.generated.h"
 
class FSkyLightSceneProxy;
class UTextureCube;
 
class FSkyTextureCubeResource : public FTexture, private FDeferredCleanupInterface
{
    // @todo - support compression
 
public:
 
    FSkyTextureCubeResource() :
        Size(0),
        NumMips(0),
        Format(PF_Unknown),
        TextureCubeRHI(NULL),
        NumRefs(0)
    {}
 
    virtual ~FSkyTextureCubeResource() { check(NumRefs == 0); }
 
    void SetupParameters(int32 InSize, int32 InNumMips, EPixelFormat InFormat)
    {
        Size = InSize;
        NumMips = InNumMips;
        Format = InFormat;
    }
 
    ENGINE_API virtual void InitRHI(FRHICommandListBase& RHICmdList) override;
 
    virtual void ReleaseRHI() override
    {
        TextureCubeRHI.SafeRelease();
        FTexture::ReleaseRHI();
    }
 
    virtual uint32 GetSizeX() const override
    {
        return Size;
    }
 
    // PVS-Studio notices that the implementation of GetSizeX is identical to this one
    // and warns us. In this case, it is intentional, so we disable the warning:
    virtual uint32 GetSizeY() const override //-V524
    {
        return Size;
    }
 
    // Reference counting.
    void AddRef()
    {
        check( IsInGameThread() );
        NumRefs++;
    }
 
    ENGINE_API void Release();
private:
 
    int32 Size;
    int32 NumMips;
    EPixelFormat Format;
    FTextureRHIRef TextureCubeRHI;
    int32 NumRefs;
};
 
UENUM()
enum ESkyLightSourceType : int
{
    SLS_CapturedScene,
    SLS_SpecifiedCubemap,
    SLS_MAX,
};
 
enum class ESkyLightCaptureStatus
{
    SLCS_Uninitialized,
    SLCS_CapturedButIncomplete,
    SLCS_CapturedAndComplete,
};
 
UCLASS(Blueprintable, ClassGroup=Lights, HideCategories=(Trigger,Activation,"Components|Activation",Physics), meta=(BlueprintSpawnableComponent), MinimalAPI)
class USkyLightComponent : public ULightComponentBase
{
    GENERATED_UCLASS_BODY()
 
    
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Light)
    bool bRealTimeCapture;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=Light)
    TEnumAsByte<enum ESkyLightSourceType> SourceType;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=Light)
    TObjectPtr<class UTextureCube> Cubemap;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=Light, meta=(UIMin = "0", UIMax = "360"))
    float SourceCubemapAngle;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Light)
    int32 CubemapResolution;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=Light)
    float SkyDistanceThreshold;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Light, AdvancedDisplay)
    bool bCaptureEmissiveOnly;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=Light, AdvancedDisplay, meta=(DisplayName = "Lower Hemisphere Is Solid Color"))
    bool bLowerHemisphereIsBlack;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=Light, AdvancedDisplay)
    FLinearColor LowerHemisphereColor;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=DistanceFieldAmbientOcclusion, meta=(UIMin = "200", UIMax = "1500"))
    float OcclusionMaxDistance;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=DistanceFieldAmbientOcclusion, meta=(UIMin = "0", UIMax = "1", DisplayName = "Occlusion Contrast"))
    float Contrast;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=DistanceFieldAmbientOcclusion, meta=(UIMin = ".6", UIMax = "1.6"))
    float OcclusionExponent;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=DistanceFieldAmbientOcclusion, meta=(UIMin = "0", UIMax = "1"))
    float MinOcclusion;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=DistanceFieldAmbientOcclusion)
    FColor OcclusionTint;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = AtmosphereAndCloud)
    uint32 bCloudAmbientOcclusion : 1;
    UPROPERTY(EditAnywhere, BlueprintReadOnly, interp, Category = AtmosphereAndCloud, meta = (UIMin = "0", UIMax = "1", ClampMin = "0", SliderExponent = 1.0))
    float CloudAmbientOcclusionStrength;
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = AtmosphereAndCloud, meta = (UIMin = "1", ClampMin = "1"))
    float CloudAmbientOcclusionExtent;
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = AtmosphereAndCloud, meta = (UIMin = "0.25", UIMax = "8", ClampMin = "0.25", SliderExponent = 1.0))
    float CloudAmbientOcclusionMapResolutionScale;
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = AtmosphereAndCloud, meta = (UIMin = "0.0", UIMax = "0.1", ClampMin = "0.0", ClampMax = "1.0", SliderExponent = 2.0))
    float CloudAmbientOcclusionApertureScale;
 
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=DistanceFieldAmbientOcclusion)
    TEnumAsByte<enum EOcclusionCombineMode> OcclusionCombineMode;
        
    ENGINE_API class FSkyLightSceneProxy* CreateSceneProxy() const;
 
    //~ Begin UObject Interface
    ENGINE_API virtual void PostInitProperties() override;
    ENGINE_API virtual void PostLoad() override;
#if WITH_EDITOR
    ENGINE_API virtual void PreEditChange(FProperty* PropertyAboutToChange) override;
    ENGINE_API virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
    ENGINE_API virtual bool CanEditChange(const FProperty* InProperty) const 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 FPrecomputedSkyLightInstanceData* ComponentInstanceData);
 
    static ENGINE_API void UpdateSkyCaptureContents(UWorld* WorldToUpdate);
    static ENGINE_API void UpdateSkyCaptureContentsArray(UWorld* WorldToUpdate, TArray<USkyLightComponent*>& ComponentArray, bool bBlendSources);
 
    ENGINE_API void CaptureEmissiveRadianceEnvironmentCubeMap(FSHVectorRGB3& OutIrradianceMap, TArray<FFloat16Color>& OutRadianceMap) const;
 
    UFUNCTION(BlueprintCallable, Category="Rendering|Components|SkyLight")
    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|SkyLight")
    ENGINE_API void SetLightColor(FLinearColor NewLightColor);
 
    UFUNCTION(BlueprintCallable, Category="SkyLight")
    ENGINE_API void SetCubemap(UTextureCube* NewCubemap);
 
    UFUNCTION(BlueprintCallable, Category = "Rendering|Components|SkyLight")
    ENGINE_API void SetSourceCubemapAngle(float NewValue);
 
    UFUNCTION(BlueprintCallable, Category="SkyLight")
    ENGINE_API void SetCubemapBlend(UTextureCube* SourceCubemap, UTextureCube* DestinationCubemap, float InBlendFraction);
 
    UFUNCTION(BlueprintCallable, Category="Rendering|Components|SkyLight")
    ENGINE_API void SetLowerHemisphereColor(const FLinearColor& InLowerHemisphereColor);
 
    UFUNCTION(BlueprintCallable, Category="Rendering|Components|SkyLight")
    ENGINE_API void SetOcclusionTint(const FColor& InTint);
 
    UFUNCTION(BlueprintCallable, Category="Rendering|Components|SkyLight")
    ENGINE_API void SetOcclusionContrast(float InOcclusionContrast);
 
    UFUNCTION(BlueprintCallable, Category="Rendering|Components|SkyLight")
    ENGINE_API void SetOcclusionExponent(float InOcclusionExponent);
 
    UFUNCTION(BlueprintCallable, Category="Rendering|Components|SkyLight")
    ENGINE_API void SetMinOcclusion(float InMinOcclusion);
 
    UFUNCTION(BlueprintCallable, Category="Rendering|Components|SkyLight")
    ENGINE_API void SetRealTimeCapture(bool bInRealTimeCapture);
 
protected:
    ENGINE_API virtual void OnVisibilityChanged() override;
 
public:
 
    ENGINE_API void SetCaptureIsDirty();
    ENGINE_API void SetBlendDestinationCaptureIsDirty();
    ENGINE_API void SanitizeCubemapSize();
 
    ENGINE_API bool IsOcclusionSupported() const;
 
    ENGINE_API void SetRealTimeCaptureEnabled(bool bNewRealTimeCaptureEnabled);
    ENGINE_API bool IsRealTimeCaptureEnabled() const;
 
    UFUNCTION(BlueprintCallable, Category="Rendering|Components|SkyLight")
    ENGINE_API void RecaptureSky();
 
    ENGINE_API virtual void Serialize(FArchive& Ar) override;
 
    const FTexture* GetProcessedSkyTexture() const { return ProcessedSkyTexture; }
    FSHVectorRGB3 GetIrradianceEnvironmentMap() { return IrradianceEnvironmentMap; }
protected:
 
#if WITH_EDITOR
    int32 PreEditCubemapResolution = 128;
#endif
 
    bool bSavedConstructionScriptValuesValid;
 
    bool bHasEverCaptured;
 
#if WITH_EDITOR
    // In an attempt to get valid lighting data as soon as possible in a level, we will always trigger a skylight capture at creation.
    // And then, a soon as the world is finally loaded, the final capture will be taken.
    ESkyLightCaptureStatus CaptureStatus;
    float SecondsSinceLastCapture;
#endif
 
    TRefCountPtr<FSkyTextureCubeResource> ProcessedSkyTexture;
    FSHVectorRGB3 IrradianceEnvironmentMap;
    float AverageBrightness=0.0f;
 
    float BlendFraction;
 
    UPROPERTY(transient)
    TObjectPtr<class UTextureCube> BlendDestinationCubemap;
    TRefCountPtr<FSkyTextureCubeResource> BlendDestinationProcessedSkyTexture;
    FSHVectorRGB3 BlendDestinationIrradianceEnvironmentMap;
    float BlendDestinationAverageBrightness;
 
    FLinearColor SpecifiedCubemapColorScale;
 
    FRenderCommandFence IrradianceMapFence;
 
    FRenderCommandFence ReleaseResourcesFence;
 
    FSkyLightSceneProxy* SceneProxy;
 
    static ENGINE_API TArray<USkyLightComponent*> SkyCapturesToUpdate;
    static ENGINE_API TArray<USkyLightComponent*> SkyCapturesToUpdateBlendDestinations;
    static ENGINE_API FTransactionallySafeCriticalSection SkyCapturesToUpdateLock;
 
    //~ Begin UActorComponent Interface
    ENGINE_API virtual void CreateRenderState_Concurrent(FRegisterComponentContext* Context) override;
    ENGINE_API virtual void DestroyRenderState_Concurrent() override;
    ENGINE_API virtual void SendRenderTransform_Concurrent() override;
    //~ Begin UActorComponent Interface
 
    ENGINE_API void UpdateLimitedRenderingStateFast();
    ENGINE_API void UpdateOcclusionRenderingStateFast();
 
    friend class FSkyLightSceneProxy;
};
 
 
USTRUCT()
struct FPrecomputedSkyLightInstanceData : public FSceneComponentInstanceData
{
    GENERATED_BODY()
public:
    FPrecomputedSkyLightInstanceData() = default;
    FPrecomputedSkyLightInstanceData(const USkyLightComponent* SourceComponent)
        : FSceneComponentInstanceData(SourceComponent)
    {}
    virtual ~FPrecomputedSkyLightInstanceData() = default;
 
    virtual bool ContainsData() const override
    {
        return true;
    }
 
    virtual void ApplyToComponent(UActorComponent* Component, const ECacheApplyPhase CacheApplyPhase) override
    {
        Super::ApplyToComponent(Component, CacheApplyPhase);
        CastChecked<USkyLightComponent>(Component)->ApplyComponentInstanceData(this);
    }
 
    UPROPERTY()
    FGuid OriginalLightGuid;
 
    UPROPERTY()
    FGuid LightGuid;
 
    UPROPERTY()
    float AverageBrightness = 1.0f;
 
    // This has to be refcounted to keep it alive during the handoff without doing a deep copy
    TRefCountPtr<FSkyTextureCubeResource> ProcessedSkyTexture;
 
    FSHVectorRGB3 IrradianceEnvironmentMap;
};