// Copyright Epic Games, Inc. All Rights Reserved. /*============================================================================= VolumetricFog.cpp =============================================================================*/ #include "VolumetricFog.h" #include "RendererPrivate.h" #include "ScenePrivate.h" #include "SceneUtils.h" #include "GlobalDistanceField.h" #include "GlobalDistanceFieldParameters.h" #include "DistanceFieldAmbientOcclusion.h" #include "DistanceFieldLightingShared.h" #include "VolumetricFogShared.h" #include "VolumeRendering.h" #include "ScreenRendering.h" #include "VolumeLighting.h" #include "PipelineStateCache.h" #include "ShaderParameterStruct.h" #include "Math/Halton.h" #include "VolumetricCloudRendering.h" #include "Lumen/LumenTranslucencyVolumeLighting.h" #include "GenerateConservativeDepthBuffer.h" #include "VirtualShadowMaps/VirtualShadowMapClipmap.h" #include "ProfilingDebugging/CpuProfilerTrace.h" int32 GVolumetricFog = 1; FAutoConsoleVariableRef CVarVolumetricFog( TEXT("r.VolumetricFog"), GVolumetricFog, TEXT("Whether to allow the volumetric fog feature."), ECVF_Scalability | ECVF_RenderThreadSafe ); int32 GVolumetricFogInjectShadowedLightsSeparately = 1; FAutoConsoleVariableRef CVarVolumetricFogInjectShadowedLightsSeparately( TEXT("r.VolumetricFog.InjectShadowedLightsSeparately"), GVolumetricFogInjectShadowedLightsSeparately, TEXT("Whether to allow the volumetric fog feature."), ECVF_Scalability | ECVF_RenderThreadSafe ); float GVolumetricFogDepthDistributionScale = 32.0f; FAutoConsoleVariableRef CVarVolumetricFogDepthDistributionScale( TEXT("r.VolumetricFog.DepthDistributionScale"), GVolumetricFogDepthDistributionScale, TEXT("Scales the slice depth distribution."), ECVF_Scalability | ECVF_RenderThreadSafe ); int32 GVolumetricFogGridPixelSize = 16; FAutoConsoleVariableRef CVarVolumetricFogGridPixelSize( TEXT("r.VolumetricFog.GridPixelSize"), GVolumetricFogGridPixelSize, TEXT("XY Size of a cell in the voxel grid, in pixels."), ECVF_Scalability | ECVF_RenderThreadSafe ); int32 GVolumetricFogGridSizeZ = 64; FAutoConsoleVariableRef CVarVolumetricFogGridSizeZ( TEXT("r.VolumetricFog.GridSizeZ"), GVolumetricFogGridSizeZ, TEXT("How many Volumetric Fog cells to use in z."), ECVF_Scalability | ECVF_RenderThreadSafe ); int32 GVolumetricFogTemporalReprojection = 1; FAutoConsoleVariableRef CVarVolumetricFogTemporalReprojection( TEXT("r.VolumetricFog.TemporalReprojection"), GVolumetricFogTemporalReprojection, TEXT("Whether to use temporal reprojection on volumetric fog."), ECVF_Scalability | ECVF_RenderThreadSafe ); int32 GVolumetricFogJitter = 1; FAutoConsoleVariableRef CVarVolumetricFogJitter( TEXT("r.VolumetricFog.Jitter"), GVolumetricFogJitter, TEXT("Whether to apply jitter to each frame's volumetric fog computation, achieving temporal super sampling."), ECVF_Scalability | ECVF_RenderThreadSafe ); float GVolumetricFogHistoryWeight = .9f; FAutoConsoleVariableRef CVarVolumetricFogHistoryWeight( TEXT("r.VolumetricFog.HistoryWeight"), GVolumetricFogHistoryWeight, TEXT("How much the history value should be weighted each frame. This is a tradeoff between visible jittering and responsiveness."), ECVF_Scalability | ECVF_RenderThreadSafe ); int32 GVolumetricFogHistoryMissSupersampleCount = 4; FAutoConsoleVariableRef CVarVolumetricFogHistoryMissSupersampleCount( TEXT("r.VolumetricFog.HistoryMissSupersampleCount"), GVolumetricFogHistoryMissSupersampleCount, TEXT("Number of lighting samples to compute for voxels whose history value is not available.\n") TEXT("This reduces noise when panning or on camera cuts, but introduces a variable cost to volumetric fog computation. Valid range [1, 16]."), ECVF_Scalability | ECVF_RenderThreadSafe ); float GInverseSquaredLightDistanceBiasScale = 1.0f; FAutoConsoleVariableRef CVarInverseSquaredLightDistanceBiasScale( TEXT("r.VolumetricFog.InverseSquaredLightDistanceBiasScale"), GInverseSquaredLightDistanceBiasScale, TEXT("Scales the amount added to the inverse squared falloff denominator. This effectively removes the spike from inverse squared falloff that causes extreme aliasing."), ECVF_Scalability | ECVF_RenderThreadSafe ); int32 GVolumetricFogEmissive = 1; FAutoConsoleVariableRef CVarVolumetricFogEmissive( TEXT("r.VolumetricFog.Emissive"), GVolumetricFogEmissive, TEXT("Whether to allow the volumetric fog emissive component."), ECVF_Scalability | ECVF_RenderThreadSafe ); int32 GVolumetricFogConservativeDepth = 0; FAutoConsoleVariableRef CVarVolumetricFogConservativeDepth( TEXT("r.VolumetricFog.ConservativeDepth"), GVolumetricFogConservativeDepth, TEXT("[Experimental] Whether to allow the volumetric to use conservative depth to accelerate computations."), ECVF_Scalability | ECVF_RenderThreadSafe ); int GVolumetricFogLightFunction = 1; FAutoConsoleVariableRef CVarVolumetricFogLightFunction( TEXT("r.VolumetricFog.LightFunction"), GVolumetricFogLightFunction, TEXT("Whether light functions are generated to be sampled when rendering volumetric fog."), ECVF_Scalability | ECVF_RenderThreadSafe ); float GLightScatteringSampleJitterMultiplier = 0; FAutoConsoleVariableRef CVarLightScatteringSampleJitterMultiplier( TEXT("r.VolumetricFog.LightScatteringSampleJitterMultiplier"), GLightScatteringSampleJitterMultiplier, TEXT("Multiplier for random offset value used to jitter each world sample position when generating the 3D fog volume. Enable/disable with r.VolumetricFog.Jitter"), ECVF_RenderThreadSafe | ECVF_Scalability ); static int32 GetVolumetricFogGridPixelSize() { return FMath::Max(1, GVolumetricFogGridPixelSize); } static int32 GetVolumetricFogGridSizeZ() { return FMath::Max(1, GVolumetricFogGridSizeZ); } IMPLEMENT_GLOBAL_SHADER_PARAMETER_STRUCT(FVolumetricFogGlobalData, "VolumetricFog"); DECLARE_GPU_STAT(VolumetricFog); FVolumetricFogGlobalData::FVolumetricFogGlobalData() {} FVector3f VolumetricFogTemporalRandom(uint32 FrameNumber) { // Center of the voxel FVector3f RandomOffsetValue(.5f, .5f, .5f); if (GVolumetricFogJitter && GVolumetricFogTemporalReprojection) { RandomOffsetValue = FVector3f(Halton(FrameNumber & 1023, 2), Halton(FrameNumber & 1023, 3), Halton(FrameNumber & 1023, 5)); } return RandomOffsetValue; } void SetupVolumetricFogIntegrationParameters( FVolumetricFogIntegrationParameters& Out, FViewInfo& View, const FVolumetricFogIntegrationParameterData& IntegrationData) { Out.VolumetricFog = View.VolumetricFogResources.VolumetricFogGlobalData; FMatrix44f UnjitteredInvTranslatedViewProjectionMatrix = FMatrix44f(View.ViewMatrices.ComputeInvProjectionNoAAMatrix() * View.ViewMatrices.GetTranslatedViewMatrix().GetTransposed()); Out.UnjitteredClipToTranslatedWorld = UnjitteredInvTranslatedViewProjectionMatrix; FMatrix TranslatedWorldToWorld = FTranslationMatrix(-View.ViewMatrices.GetPreViewTranslation()); FMatrix44f UnjitteredTranslatedViewProjectionMatrix = FMatrix44f(TranslatedWorldToWorld * View.PrevViewInfo.ViewMatrices.GetViewMatrix() * View.PrevViewInfo.ViewMatrices.ComputeProjectionNoAAMatrix()); Out.UnjitteredPrevTranslatedWorldToClip = UnjitteredTranslatedViewProjectionMatrix; int32 OffsetCount = IntegrationData.FrameJitterOffsetValues.Num(); for (int32 i = 0; i < OffsetCount; ++i) { Out.FrameJitterOffsets[i] = IntegrationData.FrameJitterOffsetValues.GetData()[i]; } extern float GVolumetricFogHistoryWeight; Out.HistoryWeight = IntegrationData.bTemporalHistoryIsValid ? GVolumetricFogHistoryWeight : 0.0f; extern int32 GVolumetricFogHistoryMissSupersampleCount; Out.HistoryMissSuperSampleCount = FMath::Clamp(GVolumetricFogHistoryMissSupersampleCount, 1, 16); } static const uint32 VolumetricFogGridInjectionGroupSize = 4; namespace { class FPermutationUseEmissive : SHADER_PERMUTATION_BOOL("USE_EMISSIVE"); } class FVolumetricFogMaterialSetupCS : public FGlobalShader { DECLARE_GLOBAL_SHADER(FVolumetricFogMaterialSetupCS); SHADER_USE_PARAMETER_STRUCT(FVolumetricFogMaterialSetupCS, FGlobalShader); using FPermutationDomain = TShaderPermutationDomain; BEGIN_SHADER_PARAMETER_STRUCT(FParameters, ) SHADER_PARAMETER(FLinearColor, GlobalAlbedo) SHADER_PARAMETER(FLinearColor, GlobalEmissive) SHADER_PARAMETER(float, GlobalExtinctionScale) SHADER_PARAMETER_RDG_UNIFORM_BUFFER(FFogUniformParameters, Fog) SHADER_PARAMETER_STRUCT_REF(FViewUniformShaderParameters, View) SHADER_PARAMETER_STRUCT_INCLUDE(FVolumetricFogIntegrationParameters, VolumetricFogParameters) SHADER_PARAMETER_RDG_TEXTURE_UAV(RWTexture3D, RWVBufferA) SHADER_PARAMETER_RDG_TEXTURE_UAV(RWTexture3D, RWVBufferB) END_SHADER_PARAMETER_STRUCT() public: static bool ShouldCompilePermutation(const FGlobalShaderPermutationParameters& Parameters) { return DoesPlatformSupportVolumetricFog(Parameters.Platform); } static void ModifyCompilationEnvironment(const FGlobalShaderPermutationParameters& Parameters, FShaderCompilerEnvironment& OutEnvironment) { FGlobalShader::ModifyCompilationEnvironment(Parameters, OutEnvironment); OutEnvironment.SetDefine(TEXT("THREADGROUP_SIZE"), VolumetricFogGridInjectionGroupSize); } }; IMPLEMENT_GLOBAL_SHADER(FVolumetricFogMaterialSetupCS, "/Engine/Private/VolumetricFog.usf", "MaterialSetupCS", SF_Compute); /** Vertex shader used to write to a range of slices of a 3d volume texture. */ class FWriteToBoundingSphereVS : public FGlobalShader { DECLARE_GLOBAL_SHADER(FWriteToBoundingSphereVS); SHADER_USE_PARAMETER_STRUCT(FWriteToBoundingSphereVS, FGlobalShader); BEGIN_SHADER_PARAMETER_STRUCT(FParameters, ) SHADER_PARAMETER_STRUCT_INCLUDE(FVolumetricFogIntegrationParameters, VolumetricFogParameters) SHADER_PARAMETER(FMatrix44f, ViewToVolumeClip) SHADER_PARAMETER(FVector4f, ViewSpaceBoundingSphere) SHADER_PARAMETER(int32, MinZ) END_SHADER_PARAMETER_STRUCT() static bool ShouldCompilePermutation(const FGlobalShaderPermutationParameters& Parameters) { return DoesPlatformSupportVolumetricFog(Parameters.Platform); } static void ModifyCompilationEnvironment(const FGlobalShaderPermutationParameters& Parameters, FShaderCompilerEnvironment& OutEnvironment) { FGlobalShader::ModifyCompilationEnvironment(Parameters, OutEnvironment); OutEnvironment.CompilerFlags.Add(CFLAG_VertexToGeometryShader); } }; IMPLEMENT_GLOBAL_SHADER(FWriteToBoundingSphereVS, "/Engine/Private/VolumetricFog.usf", "WriteToBoundingSphereVS", SF_Vertex); /** Shader that adds direct lighting contribution from the given light to the current volume lighting cascade. */ class FInjectShadowedLocalLightPS : public FGlobalShader { DECLARE_GLOBAL_SHADER(FInjectShadowedLocalLightPS); SHADER_USE_PARAMETER_STRUCT(FInjectShadowedLocalLightPS, FGlobalShader); BEGIN_SHADER_PARAMETER_STRUCT(FParameters, ) SHADER_PARAMETER_STRUCT_REF(FViewUniformShaderParameters, ViewUniformBuffer) SHADER_PARAMETER_RDG_UNIFORM_BUFFER(FDeferredLightUniformStruct, DeferredLight) SHADER_PARAMETER_STRUCT_INCLUDE(FVolumeShadowingShaderParameters, VolumeShadowingShaderParameters) SHADER_PARAMETER_STRUCT_INCLUDE(FVirtualShadowMapSamplingParameters, VirtualShadowMapSamplingParameters) SHADER_PARAMETER_RDG_TEXTURE(Texture2D, ConservativeDepthTexture) SHADER_PARAMETER_RDG_TEXTURE(Texture2D, WhiteDummyTexture) SHADER_PARAMETER_RDG_TEXTURE(Texture2D, LightFunctionAtlasTexture) SHADER_PARAMETER_SAMPLER(SamplerState, LightFunctionAtlasSampler) SHADER_PARAMETER_STRUCT_INCLUDE(FVolumetricFogIntegrationParameters, VolumetricFogParameters) SHADER_PARAMETER(FMatrix44f, LocalLightFunctionMatrix) SHADER_PARAMETER(FVector4f, LightFunctionAtlasTileMinMaxUvBound) SHADER_PARAMETER(float, PhaseG) SHADER_PARAMETER(float, InverseSquaredLightDistanceBiasScale) SHADER_PARAMETER(uint32, UseConservativeDepthTexture) SHADER_PARAMETER(int32, VirtualShadowMapId) RENDER_TARGET_BINDING_SLOTS() END_SHADER_PARAMETER_STRUCT() class FDynamicallyShadowed : SHADER_PERMUTATION_BOOL("DYNAMICALLY_SHADOWED"); class FTemporalReprojection : SHADER_PERMUTATION_BOOL("USE_TEMPORAL_REPROJECTION"); class FLightFunction : SHADER_PERMUTATION_BOOL("USE_LIGHT_FUNCTION"); class FEnableShadows : SHADER_PERMUTATION_BOOL("ENABLE_SHADOW_COMPUTATION"); class FVirtualShadowMap : SHADER_PERMUTATION_BOOL("VIRTUAL_SHADOW_MAP"); using FPermutationDomain = TShaderPermutationDomain< FDynamicallyShadowed, FTemporalReprojection, FLightFunction, FEnableShadows, FVirtualShadowMap >; static void ModifyCompilationEnvironment(const FGlobalShaderPermutationParameters& Parameters, FShaderCompilerEnvironment& OutEnvironment) { FGlobalShader::ModifyCompilationEnvironment(Parameters, OutEnvironment); FVirtualShadowMapArray::SetShaderDefines(OutEnvironment); } static bool ShouldCompilePermutation(const FGlobalShaderPermutationParameters& Parameters) { return DoesPlatformSupportVolumetricFog(Parameters.Platform); } }; IMPLEMENT_GLOBAL_SHADER(FInjectShadowedLocalLightPS, "/Engine/Private/VolumetricFog.usf", "InjectShadowedLocalLightPS", SF_Pixel); const FProjectedShadowInfo* GetShadowForInjectionIntoVolumetricFog(const FVisibleLightInfo& VisibleLightInfo) { for (int32 ShadowIndex = 0; ShadowIndex < VisibleLightInfo.ShadowsToProject.Num(); ShadowIndex++) { FProjectedShadowInfo* ProjectedShadowInfo = VisibleLightInfo.ShadowsToProject[ShadowIndex]; if (ProjectedShadowInfo->bAllocated && ProjectedShadowInfo->bWholeSceneShadow && !ProjectedShadowInfo->bRayTracedDistanceField) { return ProjectedShadowInfo; } } return nullptr; } bool LightNeedsSeparateInjectionIntoVolumetricFogForOpaqueShadow(const FViewInfo& View, const FLightSceneInfo* LightSceneInfo, const FVisibleLightInfo& VisibleLightInfo) { const FLightSceneProxy* LightProxy = LightSceneInfo->Proxy; if (GVolumetricFogInjectShadowedLightsSeparately && (LightProxy->GetLightType() == LightType_Point || LightProxy->GetLightType() == LightType_Spot || LightProxy->GetLightType() == LightType_Rect) && !LightProxy->HasStaticLighting() && LightProxy->CastsDynamicShadow() && LightProxy->CastsVolumetricShadow()) { const FStaticShadowDepthMap* StaticShadowDepthMap = LightProxy->GetStaticShadowDepthMap(); const bool bStaticallyShadowed = LightSceneInfo->IsPrecomputedLightingValid() && StaticShadowDepthMap && StaticShadowDepthMap->Data && StaticShadowDepthMap->TextureRHI; const bool bHasVirtualShadowMap = VisibleLightInfo.GetVirtualShadowMapId( &View ) != INDEX_NONE; return GetShadowForInjectionIntoVolumetricFog(VisibleLightInfo) != NULL || bStaticallyShadowed || bHasVirtualShadowMap; } return false; } bool LightNeedsSeparateInjectionIntoVolumetricFogForLightFunction(const FLightSceneInfo* LightSceneInfo) { // No directional light type because it is handled in a specific way in RenderLightFunctionForVolumetricFog. // TODO: add support for rect lights. return GVolumetricFogLightFunction > 0 && (LightSceneInfo->Proxy->GetLightType() == LightType_Point || LightSceneInfo->Proxy->GetLightType() == LightType_Spot); } FIntPoint CalculateVolumetricFogBoundsForLight(const FSphere& LightBounds, const FViewInfo& View, FIntVector VolumetricFogGridSize, FVector GridZParams) { FIntPoint VolumeZBounds; FVector ViewSpaceLightBoundsOrigin = View.ViewMatrices.GetViewMatrix().TransformPosition(LightBounds.Center); int32 FurthestSliceIndexUnclamped = ComputeZSliceFromDepth(ViewSpaceLightBoundsOrigin.Z + LightBounds.W, GridZParams); int32 ClosestSliceIndexUnclamped = ComputeZSliceFromDepth(ViewSpaceLightBoundsOrigin.Z - LightBounds.W, GridZParams); VolumeZBounds.X = FMath::Clamp(ClosestSliceIndexUnclamped, 0, VolumetricFogGridSize.Z - 1); VolumeZBounds.Y = FMath::Clamp(FurthestSliceIndexUnclamped, 0, VolumetricFogGridSize.Z - 1); return VolumeZBounds; } static bool OverrideDirectionalLightInScatteringUsingHeightFog(const FViewInfo& View, const FExponentialHeightFogSceneInfo& FogInfo) { return FogInfo.bOverrideLightColorsWithFogInscatteringColors && View.bUseDirectionalInscattering && !View.FogInscatteringColorCubemap; } static bool OverrideSkyLightInScatteringUsingHeightFog(const FViewInfo& View, const FExponentialHeightFogSceneInfo& FogInfo) { return FogInfo.bOverrideLightColorsWithFogInscatteringColors; } /** */ class FCircleRasterizeVertexBuffer : public FVertexBuffer { public: virtual void InitRHI() override { const int32 NumTriangles = NumVertices - 2; const uint32 Size = NumVertices * sizeof(FScreenVertex); FRHIResourceCreateInfo CreateInfo(TEXT("FCircleRasterizeVertexBuffer")); VertexBufferRHI = RHICreateBuffer(Size, BUF_Static | BUF_VertexBuffer, 0, ERHIAccess::VertexOrIndexBuffer, CreateInfo); FScreenVertex* DestVertex = (FScreenVertex*)RHILockBuffer(VertexBufferRHI, 0, Size, RLM_WriteOnly); const int32 NumRings = NumVertices; const float RadiansPerRingSegment = PI / (float)NumRings; // Boost the effective radius so that the edges of the circle approximation lie on the circle, instead of the vertices const float RadiusScale = 1.0f / FMath::Cos(RadiansPerRingSegment); for (int32 VertexIndex = 0; VertexIndex < NumVertices; VertexIndex++) { float Angle = VertexIndex / (float)(NumVertices - 1) * 2 * PI; // WriteToBoundingSphereVS only uses UV DestVertex[VertexIndex].Position = FVector2f::ZeroVector; DestVertex[VertexIndex].UV = FVector2f(RadiusScale * FMath::Cos(Angle) * .5f + .5f, RadiusScale * FMath::Sin(Angle) * .5f + .5f); } RHIUnlockBuffer(VertexBufferRHI); } static int32 NumVertices; }; int32 FCircleRasterizeVertexBuffer::NumVertices = 8; TGlobalResource GCircleRasterizeVertexBuffer; /** */ class FCircleRasterizeIndexBuffer : public FIndexBuffer { public: virtual void InitRHI() override { const int32 NumTriangles = FCircleRasterizeVertexBuffer::NumVertices - 2; TResourceArray Indices; Indices.Empty(NumTriangles * 3); for (int32 TriangleIndex = 0; TriangleIndex < NumTriangles; TriangleIndex++) { int32 LeadingVertexIndex = TriangleIndex + 2; Indices.Add(0); Indices.Add(LeadingVertexIndex - 1); Indices.Add(LeadingVertexIndex); } const uint32 Size = Indices.GetResourceDataSize(); const uint32 Stride = sizeof(uint16); // Create index buffer. Fill buffer with initial data upon creation FRHIResourceCreateInfo CreateInfo(TEXT("FCircleRasterizeIndexBuffer"), &Indices); IndexBufferRHI = RHICreateIndexBuffer(Stride, Size, BUF_Static, CreateInfo); } }; TGlobalResource GCircleRasterizeIndexBuffer; void FDeferredShadingSceneRenderer::RenderLocalLightsForVolumetricFog( FRDGBuilder& GraphBuilder, FViewInfo& View, bool bUseTemporalReprojection, const FVolumetricFogIntegrationParameterData& IntegrationData, const FExponentialHeightFogSceneInfo& FogInfo, FIntVector VolumetricFogGridSize, FVector GridZParams, const FRDGTextureDesc& VolumeDesc, FRDGTexture*& OutLocalShadowedLightScattering, FRDGTextureRef ConservativeDepthTexture) { // Gather lights that need to be rendered with shadow from opaque or light functions. TArray LightsToInject; for (auto LightIt = Scene->Lights.CreateConstIterator(); LightIt; ++LightIt) { const FLightSceneInfoCompact& LightSceneInfoCompact = *LightIt; const FLightSceneInfo* LightSceneInfo = LightSceneInfoCompact.LightSceneInfo; bool bIsShadowed = LightNeedsSeparateInjectionIntoVolumetricFogForOpaqueShadow(View, LightSceneInfo, VisibleLightInfos[LightSceneInfo->Id]); bool bUsesLightFunction = ViewFamily.EngineShowFlags.LightFunctions && CheckForLightFunction(LightSceneInfo) && LightNeedsSeparateInjectionIntoVolumetricFogForLightFunction(LightSceneInfo); if (LightSceneInfo->ShouldRenderLightViewIndependent() && LightSceneInfo->ShouldRenderLight(View) && (bIsShadowed || bUsesLightFunction) && LightSceneInfo->Proxy->GetVolumetricScatteringIntensity() > 0) { const FSphere LightBounds = LightSceneInfo->Proxy->GetBoundingSphere(); if ((View.ViewMatrices.GetViewOrigin() - LightBounds.Center).SizeSquared() < (FogInfo.VolumetricFogDistance + LightBounds.W) * (FogInfo.VolumetricFogDistance + LightBounds.W)) { LightsToInject.Add(LightSceneInfo); } } } // Now voxelise all the light we have just gathered. if (LightsToInject.Num() > 0) { TMap& LocalLightFunctionData = View.VolumetricFogResources.LocalLightFunctionData; bool bClearExecuted = false; for (int32 LightIndex = 0; LightIndex < LightsToInject.Num(); LightIndex++) { const FLightSceneInfo* LightSceneInfo = LightsToInject[LightIndex]; const FVisibleLightInfo& VisibleLightInfo = VisibleLightInfos[LightSceneInfo->Id]; const FSphere LightBounds = LightSceneInfo->Proxy->GetBoundingSphere(); const FIntPoint VolumeZBounds = CalculateVolumetricFogBoundsForLight(LightBounds, View, VolumetricFogGridSize, GridZParams); if (VolumeZBounds.X < VolumeZBounds.Y) { bool bIsShadowed = LightNeedsSeparateInjectionIntoVolumetricFogForOpaqueShadow(View, LightSceneInfo, VisibleLightInfo); bool bUsesLightFunction = ViewFamily.EngineShowFlags.LightFunctions && CheckForLightFunction(LightSceneInfo) && LightNeedsSeparateInjectionIntoVolumetricFogForLightFunction(LightSceneInfo); int32 VirtualShadowMapId = VisibleLightInfo.GetVirtualShadowMapId(&View); const bool bUseVSM = bIsShadowed && VirtualShadowMapArray.IsAllocated() && VirtualShadowMapId != INDEX_NONE; FInjectShadowedLocalLightPS::FParameters* PassParameters = GraphBuilder.AllocParameters(); // Light function parameters PassParameters->LightFunctionAtlasTexture = View.VolumetricFogResources.TransientLightFunctionTextureAtlas ? View.VolumetricFogResources.TransientLightFunctionTextureAtlas->GetTransientLightFunctionAtlasTexture() : GSystemTextures.GetWhiteDummy(GraphBuilder);; PassParameters->LocalLightFunctionMatrix = FMatrix44f::Identity; PassParameters->LightFunctionAtlasTileMinMaxUvBound = FVector4f(ForceInitToZero); if (bUsesLightFunction) { FVolumetricFogLocalLightFunctionInfo* LightFunctionData = LocalLightFunctionData.Find(LightSceneInfo); if (!ensure(LightFunctionData != nullptr)) { // The light function data is missing but the light requires it. Skip this light for now. continue; } PassParameters->LocalLightFunctionMatrix = LightFunctionData->LightFunctionTranslatedWorldToLightMatrix; PassParameters->LightFunctionAtlasTexture = LightFunctionData->AtlasTile.Texture; PassParameters->LightFunctionAtlasTileMinMaxUvBound = LightFunctionData->AtlasTile.MinMaxUvBound; } // We need to delay the real texture creation replacing the dummy on first use after all the culling logic, // otherwise it will be reported as not written by any pass (in this case we need to keep the default dummy). const bool bHasTextureBeenCreated = bClearExecuted == true; OutLocalShadowedLightScattering = bHasTextureBeenCreated ? OutLocalShadowedLightScattering : GraphBuilder.CreateTexture(VolumeDesc, TEXT("VolumetricFog.LocalShadowedLightScattering")); PassParameters->RenderTargets[0] = FRenderTargetBinding(OutLocalShadowedLightScattering, bClearExecuted ? ERenderTargetLoadAction::ELoad : ERenderTargetLoadAction::EClear); bClearExecuted = true; PassParameters->VirtualShadowMapSamplingParameters = VirtualShadowMapArray.GetSamplingParameters(GraphBuilder); PassParameters->ConservativeDepthTexture = ConservativeDepthTexture; PassParameters->LightFunctionAtlasSampler = TStaticSamplerState::GetRHI(); // We also bind the default light function texture because when we are out of atlas tile, we fallback to use a white light function so we need the RHI to be created PassParameters->WhiteDummyTexture = View.VolumetricFogResources.TransientLightFunctionTextureAtlas ? View.VolumetricFogResources.TransientLightFunctionTextureAtlas->GetDefaultLightFunctionTexture() : GSystemTextures.GetWhiteDummy(GraphBuilder); SetupVolumetricFogIntegrationParameters(PassParameters->VolumetricFogParameters, View, IntegrationData); PassParameters->ViewUniformBuffer = View.ViewUniformBuffer; PassParameters->PhaseG = FogInfo.VolumetricFogScatteringDistribution; PassParameters->InverseSquaredLightDistanceBiasScale = GInverseSquaredLightDistanceBiasScale; PassParameters->UseConservativeDepthTexture = GVolumetricFogConservativeDepth > 0 ? 1 : 0; PassParameters->VirtualShadowMapId = VirtualShadowMapId; FDeferredLightUniformStruct* DeferredLightStruct = GraphBuilder.AllocParameters(); *DeferredLightStruct = GetDeferredLightParameters(View, *LightSceneInfo); PassParameters->DeferredLight = GraphBuilder.CreateUniformBuffer(DeferredLightStruct); const FProjectedShadowInfo* ProjectedShadowInfo = GetShadowForInjectionIntoVolumetricFog(VisibleLightInfo); const bool bDynamicallyShadowed = ProjectedShadowInfo != NULL; GetVolumeShadowingShaderParameters(GraphBuilder, View, LightSceneInfo, ProjectedShadowInfo, PassParameters->VolumeShadowingShaderParameters); FInjectShadowedLocalLightPS::FPermutationDomain PermutationVector; PermutationVector.Set< FInjectShadowedLocalLightPS::FDynamicallyShadowed >(bDynamicallyShadowed); PermutationVector.Set< FInjectShadowedLocalLightPS::FTemporalReprojection >(bUseTemporalReprojection); PermutationVector.Set< FInjectShadowedLocalLightPS::FLightFunction >(bUsesLightFunction); PermutationVector.Set< FInjectShadowedLocalLightPS::FEnableShadows >(bIsShadowed); PermutationVector.Set< FInjectShadowedLocalLightPS::FVirtualShadowMap >(bUseVSM); auto VertexShader = View.ShaderMap->GetShader< FWriteToBoundingSphereVS >(); TOptionalShaderMapRef GeometryShader(View.ShaderMap); auto PixelShader = View.ShaderMap->GetShader< FInjectShadowedLocalLightPS >(PermutationVector); ClearUnusedGraphResources(PixelShader, PassParameters); // We execute one pass per light: this is because RDG resources needs to be gathrered before and reference in the PassParameters. // Not many lights cast shadow so that is acceptable (LightRendering is doing the same things). // If light shadow maps woud be in a common resources (atlas, texture array, bindless) we could have a single pass for all the lights. // NOTE: light functions are already in an atlas so they are not a problem. GraphBuilder.AddPass( RDG_EVENT_NAME("ShadowedLights"), PassParameters, ERDGPassFlags::Raster, [PassParameters, &View, this, VertexShader, GeometryShader, PixelShader, VolumeZBounds, LightBounds](FRHICommandList& RHICmdList) { FGraphicsPipelineStateInitializer GraphicsPSOInit; RHICmdList.ApplyCachedRenderTargets(GraphicsPSOInit); GraphicsPSOInit.RasterizerState = TStaticRasterizerState::GetRHI(); GraphicsPSOInit.DepthStencilState = TStaticDepthStencilState::GetRHI(); // Accumulate the contribution of multiple lights GraphicsPSOInit.BlendState = TStaticBlendState::GetRHI(); GraphicsPSOInit.BoundShaderState.VertexDeclarationRHI = GScreenVertexDeclaration.VertexDeclarationRHI; GraphicsPSOInit.BoundShaderState.VertexShaderRHI = VertexShader.GetVertexShader(); GraphicsPSOInit.BoundShaderState.SetGeometryShader(GeometryShader.GetGeometryShader()); GraphicsPSOInit.BoundShaderState.PixelShaderRHI = PixelShader.GetPixelShader(); GraphicsPSOInit.PrimitiveType = PT_TriangleList; SetGraphicsPipelineState(RHICmdList, GraphicsPSOInit, 0); SetShaderParameters(RHICmdList, PixelShader, PixelShader.GetPixelShader(), *PassParameters); FWriteToBoundingSphereVS::FParameters VSPassParameters; VSPassParameters.MinZ = VolumeZBounds.X; VSPassParameters.ViewSpaceBoundingSphere = FVector4f(FVector4f(View.ViewMatrices.GetViewMatrix().TransformPosition(LightBounds.Center)), LightBounds.W); // LWC_TODO: precision loss VSPassParameters.ViewToVolumeClip = FMatrix44f(View.ViewMatrices.ComputeProjectionNoAAMatrix()); // LWC_TODO: Precision loss? VSPassParameters.VolumetricFogParameters = PassParameters->VolumetricFogParameters; SetShaderParameters(RHICmdList, VertexShader, VertexShader.GetVertexShader(), VSPassParameters); if (GeometryShader.IsValid()) { GeometryShader->SetParameters(RHICmdList, VolumeZBounds.X); } RHICmdList.SetStreamSource(0, GCircleRasterizeVertexBuffer.VertexBufferRHI, 0); const int32 NumInstances = VolumeZBounds.Y - VolumeZBounds.X; const int32 NumTriangles = FCircleRasterizeVertexBuffer::NumVertices - 2; RHICmdList.DrawIndexedPrimitive(GCircleRasterizeIndexBuffer.IndexBufferRHI, 0, 0, FCircleRasterizeVertexBuffer::NumVertices, 0, NumTriangles, NumInstances); }); } } } } IMPLEMENT_GLOBAL_SHADER_PARAMETER_STRUCT(FLumenTranslucencyLightingUniforms, "LumenGIVolumeStruct"); class FVolumetricFogLightScatteringCS : public FGlobalShader { DECLARE_GLOBAL_SHADER(FVolumetricFogLightScatteringCS); SHADER_USE_PARAMETER_STRUCT(FVolumetricFogLightScatteringCS, FGlobalShader); class FTemporalReprojection : SHADER_PERMUTATION_BOOL("USE_TEMPORAL_REPROJECTION"); class FDistanceFieldSkyOcclusion : SHADER_PERMUTATION_BOOL("DISTANCE_FIELD_SKY_OCCLUSION"); class FSuperSampleCount : SHADER_PERMUTATION_SPARSE_INT("HISTORY_MISS_SUPER_SAMPLE_COUNT", 1, 4, 8, 16); class FLumenGI : SHADER_PERMUTATION_BOOL("LUMEN_GI"); class FVirtualShadowMap : SHADER_PERMUTATION_BOOL("VIRTUAL_SHADOW_MAP"); class FCloudTransmittance : SHADER_PERMUTATION_BOOL("USE_CLOUD_TRANSMITTANCE"); using FPermutationDomain = TShaderPermutationDomain< FSuperSampleCount, FTemporalReprojection, FDistanceFieldSkyOcclusion, FLumenGI, FVirtualShadowMap, FCloudTransmittance>; BEGIN_SHADER_PARAMETER_STRUCT(FParameters, ) SHADER_PARAMETER_STRUCT_REF(FViewUniformShaderParameters, View) SHADER_PARAMETER_RDG_UNIFORM_BUFFER(FForwardLightData, Forward) SHADER_PARAMETER_RDG_UNIFORM_BUFFER(FFogUniformParameters, Fog) SHADER_PARAMETER_STRUCT_INCLUDE(FVolumetricFogIntegrationParameters, VolumetricFogParameters) SHADER_PARAMETER_RDG_TEXTURE(Texture2D, VBufferA) SHADER_PARAMETER_RDG_TEXTURE(Texture2D, VBufferB) SHADER_PARAMETER_RDG_TEXTURE(Texture2D, LocalShadowedLightScattering) SHADER_PARAMETER_RDG_TEXTURE(Texture2D, LightFunctionTexture) SHADER_PARAMETER_SAMPLER(SamplerState, LightFunctionSampler) SHADER_PARAMETER_RDG_TEXTURE(Texture2D, CloudShadowmapTexture) SHADER_PARAMETER_SAMPLER(SamplerState, CloudShadowmapSampler) SHADER_PARAMETER_RDG_TEXTURE(Texture2D, ConservativeDepthTexture) SHADER_PARAMETER_RDG_TEXTURE(Texture2D, PrevConservativeDepthTexture) SHADER_PARAMETER_RDG_TEXTURE(Texture3D, LightScatteringHistory) SHADER_PARAMETER_SAMPLER(SamplerState, LightScatteringHistorySampler) SHADER_PARAMETER_RDG_UNIFORM_BUFFER(FLumenTranslucencyLightingUniforms, LumenGIVolumeStruct) SHADER_PARAMETER_STRUCT_INCLUDE(FVirtualShadowMapSamplingParameters, VirtualShadowMapSamplingParameters) SHADER_PARAMETER_STRUCT_INCLUDE(FAOParameters, AOParameters) SHADER_PARAMETER_STRUCT_INCLUDE(FGlobalDistanceFieldParameters2, GlobalDistanceFieldParameters) SHADER_PARAMETER_RDG_TEXTURE_UAV(RWTexture2D, RWLightScattering) SHADER_PARAMETER_ARRAY(FVector4f, SkySH, [3]) SHADER_PARAMETER(FMatrix44f, DirectionalLightFunctionTranslatedWorldToShadow) SHADER_PARAMETER(FMatrix44f, CloudShadowmapTranslatedWorldToLightClipMatrix) SHADER_PARAMETER(FVector2f, PrevConservativeDepthTextureSize) SHADER_PARAMETER(FVector2f, UseHeightFogColors) SHADER_PARAMETER(FVector2f, LightScatteringHistoryPreExposureAndInv) SHADER_PARAMETER(float, StaticLightingScatteringIntensity) SHADER_PARAMETER(float, SkyLightVolumetricScatteringIntensity) SHADER_PARAMETER(float, SkyLightUseStaticShadowing) SHADER_PARAMETER(float, PhaseG) SHADER_PARAMETER(float, InverseSquaredLightDistanceBiasScale) SHADER_PARAMETER(float, LightScatteringSampleJitterMultiplier) SHADER_PARAMETER(float, CloudShadowmapFarDepthKm) SHADER_PARAMETER(float, CloudShadowmapStrength) SHADER_PARAMETER(float, UseDirectionalLightShadowing) SHADER_PARAMETER(uint32, UseConservativeDepthTexture) SHADER_PARAMETER(uint32, UseEmissive) END_SHADER_PARAMETER_STRUCT() static bool ShouldCompilePermutation(const FGlobalShaderPermutationParameters& Parameters) { return DoesPlatformSupportVolumetricFog(Parameters.Platform); } static FIntVector GetGroupSize() { return FIntVector(4, 4, 4); } static int32 GetSuperSampleCount(int32 InSampleCount) { if (InSampleCount <= 1) { return 1; } else if (InSampleCount <= 4) { return 4; } else if (InSampleCount <= 8) { return 8; } return 16; } static void ModifyCompilationEnvironment(const FGlobalShaderPermutationParameters& Parameters, FShaderCompilerEnvironment& OutEnvironment) { FGlobalShader::ModifyCompilationEnvironment(Parameters, OutEnvironment); OutEnvironment.SetDefine(TEXT("THREADGROUP_SIZE_X"), GetGroupSize().X); OutEnvironment.SetDefine(TEXT("THREADGROUP_SIZE_Y"), GetGroupSize().Y); OutEnvironment.SetDefine(TEXT("THREADGROUP_SIZE_Z"), GetGroupSize().Z); FForwardLightingParameters::ModifyCompilationEnvironment(Parameters.Platform, OutEnvironment); FVirtualShadowMapArray::SetShaderDefines(OutEnvironment); } }; IMPLEMENT_GLOBAL_SHADER(FVolumetricFogLightScatteringCS, "/Engine/Private/VolumetricFog.usf", "LightScatteringCS", SF_Compute); uint32 VolumetricFogIntegrationGroupSize = 8; class FVolumetricFogFinalIntegrationCS : public FGlobalShader { DECLARE_GLOBAL_SHADER(FVolumetricFogFinalIntegrationCS); SHADER_USE_PARAMETER_STRUCT(FVolumetricFogFinalIntegrationCS, FGlobalShader); BEGIN_SHADER_PARAMETER_STRUCT(FParameters, ) SHADER_PARAMETER_STRUCT_REF(FViewUniformShaderParameters, ViewUniformBuffer) SHADER_PARAMETER_RDG_TEXTURE(Texture3D, LightScattering) SHADER_PARAMETER_RDG_TEXTURE_UAV(RWTexture3D, RWIntegratedLightScattering) SHADER_PARAMETER(float, VolumetricFogNearFadeInDistanceInv) SHADER_PARAMETER_STRUCT_INCLUDE(FVolumetricFogIntegrationParameters, VolumetricFogParameters) END_SHADER_PARAMETER_STRUCT() static bool ShouldCompilePermutation(const FGlobalShaderPermutationParameters& Parameters) { return DoesPlatformSupportVolumetricFog(Parameters.Platform); } static void ModifyCompilationEnvironment(const FGlobalShaderPermutationParameters& Parameters, FShaderCompilerEnvironment& OutEnvironment) { FGlobalShader::ModifyCompilationEnvironment(Parameters, OutEnvironment); OutEnvironment.SetDefine(TEXT("THREADGROUP_SIZE"), VolumetricFogIntegrationGroupSize); } }; IMPLEMENT_GLOBAL_SHADER(FVolumetricFogFinalIntegrationCS, "/Engine/Private/VolumetricFog.usf", "FinalIntegrationCS", SF_Compute); bool ShouldRenderVolumetricFog(const FScene* Scene, const FSceneViewFamily& ViewFamily) { return ShouldRenderFog(ViewFamily) && Scene && Scene->GetFeatureLevel() >= ERHIFeatureLevel::SM5 && DoesPlatformSupportVolumetricFog(Scene->GetShaderPlatform()) && GVolumetricFog && ViewFamily.EngineShowFlags.VolumetricFog && Scene->ExponentialFogs.Num() > 0 && Scene->ExponentialFogs[0].bEnableVolumetricFog && Scene->ExponentialFogs[0].VolumetricFogDistance > 0; } FVector GetVolumetricFogGridZParams(float VolumetricFogStartDistance, float NearPlane, float FarPlane, int32 GridSizeZ) { // S = distribution scale // B, O are solved for given the z distances of the first+last slice, and the # of slices. // // slice = log2(z*B + O) * S // Don't spend lots of resolution right in front of the near plane NearPlane = FMath::Max(NearPlane, double(VolumetricFogStartDistance)); double NearOffset = .095 * 100.0; // Space out the slices so they aren't all clustered at the near plane double S = GVolumetricFogDepthDistributionScale; double N = NearPlane + NearOffset; double F = FarPlane; double O = (F - N * FMath::Exp2((GridSizeZ - 1) / S)) / (F - N); double B = (1 - O) / N; double O2 = (FMath::Exp2((GridSizeZ - 1) / S) - F / N) / (-F / N + 1); float FloatN = (float)N; float FloatF = (float)F; float FloatB = (float)B; float FloatO = (float)O; float FloatS = (float)S; float NSlice = FMath::Log2(FloatN*FloatB + FloatO) * FloatS; float NearPlaneSlice = FMath::Log2(NearPlane*FloatB + FloatO) * FloatS; float FSlice = FMath::Log2(FloatF*FloatB + FloatO) * FloatS; // y = log2(z*B + O) * S // f(N) = 0 = log2(N*B + O) * S // 1 = N*B + O // O = 1 - N*B // B = (1 - O) / N // f(F) = GLightGridSizeZ - 1 = log2(F*B + O) * S // exp2((GLightGridSizeZ - 1) / S) = F*B + O // exp2((GLightGridSizeZ - 1) / S) = F * (1 - O) / N + O // exp2((GLightGridSizeZ - 1) / S) = F / N - F / N * O + O // exp2((GLightGridSizeZ - 1) / S) = F / N + (-F / N + 1) * O // O = (exp2((GLightGridSizeZ - 1) / S) - F / N) / (-F / N + 1) return FVector(B, O, S); } FIntVector GetVolumetricFogGridSize(FIntPoint ViewRectSize, int32& OutVolumetricFogGridPixelSize) { extern int32 GLightGridSizeZ; FIntPoint VolumetricFogGridSizeXY; int32 VolumetricFogGridPixelSize = GetVolumetricFogGridPixelSize(); VolumetricFogGridSizeXY = FIntPoint::DivideAndRoundUp(ViewRectSize, VolumetricFogGridPixelSize); if(VolumetricFogGridSizeXY.X > GMaxVolumeTextureDimensions || VolumetricFogGridSizeXY.Y > GMaxVolumeTextureDimensions) //clamp to max volume texture dimensions. only happens for extreme resolutions (~8x2k) { float PixelSizeX = (float)ViewRectSize.X / GMaxVolumeTextureDimensions; float PixelSizeY = (float)ViewRectSize.Y / GMaxVolumeTextureDimensions; VolumetricFogGridPixelSize = FMath::Max(FMath::CeilToInt(PixelSizeX), FMath::CeilToInt(PixelSizeY)); VolumetricFogGridSizeXY = FIntPoint::DivideAndRoundUp(ViewRectSize, VolumetricFogGridPixelSize); } OutVolumetricFogGridPixelSize = VolumetricFogGridPixelSize; return FIntVector(VolumetricFogGridSizeXY.X, VolumetricFogGridSizeXY.Y, GetVolumetricFogGridSizeZ()); } void SetupVolumetricFogGlobalData(const FViewInfo& View, FVolumetricFogGlobalData& Parameters) { const FScene* Scene = (FScene*)View.Family->Scene; const FExponentialHeightFogSceneInfo& FogInfo = Scene->ExponentialFogs[0]; int32 VolumetricFogGridPixelSize; const FIntVector VolumetricFogGridSize = GetVolumetricFogGridSize(View.ViewRect.Size(), VolumetricFogGridPixelSize); Parameters.GridSizeInt = VolumetricFogGridSize; Parameters.GridSize = FVector3f(VolumetricFogGridSize); FVector ZParams = GetVolumetricFogGridZParams(FogInfo.VolumetricFogStartDistance, View.NearClippingDistance, FogInfo.VolumetricFogDistance, VolumetricFogGridSize.Z); Parameters.GridZParams = (FVector3f)ZParams; Parameters.SVPosToVolumeUV = FVector2f::UnitVector / (FVector2f(VolumetricFogGridSize.X, VolumetricFogGridSize.Y) * VolumetricFogGridPixelSize); Parameters.FogGridToPixelXY = FIntPoint(VolumetricFogGridPixelSize, VolumetricFogGridPixelSize); Parameters.MaxDistance = FogInfo.VolumetricFogDistance; Parameters.HeightFogInscatteringColor = View.ExponentialFogColor; Parameters.HeightFogDirectionalLightInscatteringColor = FVector3f::ZeroVector; if (OverrideDirectionalLightInScatteringUsingHeightFog(View, FogInfo)) { Parameters.HeightFogDirectionalLightInscatteringColor = FVector3f(View.DirectionalInscatteringColor); } } void FViewInfo::SetupVolumetricFogUniformBufferParameters(FViewUniformShaderParameters& ViewUniformShaderParameters) const { const FScene* Scene = (const FScene*)Family->Scene; if (ShouldRenderVolumetricFog(Scene, *Family)) { const FExponentialHeightFogSceneInfo& FogInfo = Scene->ExponentialFogs[0]; int32 VolumetricFogGridPixelSize; const FIntVector VolumetricFogGridSize = GetVolumetricFogGridSize(ViewRect.Size(), VolumetricFogGridPixelSize); ViewUniformShaderParameters.VolumetricFogInvGridSize = FVector3f(1.0f / VolumetricFogGridSize.X, 1.0f / VolumetricFogGridSize.Y, 1.0f / VolumetricFogGridSize.Z); const FVector ZParams = GetVolumetricFogGridZParams(FogInfo.VolumetricFogStartDistance, NearClippingDistance, FogInfo.VolumetricFogDistance, VolumetricFogGridSize.Z); ViewUniformShaderParameters.VolumetricFogGridZParams = (FVector3f)ZParams; ViewUniformShaderParameters.VolumetricFogSVPosToVolumeUV = FVector2f::UnitVector / (FVector2f(VolumetricFogGridSize.X, VolumetricFogGridSize.Y) * VolumetricFogGridPixelSize); ViewUniformShaderParameters.VolumetricFogMaxDistance = FogInfo.VolumetricFogDistance; } else { ViewUniformShaderParameters.VolumetricFogInvGridSize = FVector3f::ZeroVector; ViewUniformShaderParameters.VolumetricFogGridZParams = FVector3f::ZeroVector; ViewUniformShaderParameters.VolumetricFogSVPosToVolumeUV = FVector2f::ZeroVector; ViewUniformShaderParameters.VolumetricFogMaxDistance = 0; } } bool FDeferredShadingSceneRenderer::ShouldRenderVolumetricFog() const { return ::ShouldRenderVolumetricFog(Scene, ViewFamily); } void FDeferredShadingSceneRenderer::SetupVolumetricFog() { if (ShouldRenderVolumetricFog()) { const FExponentialHeightFogSceneInfo& FogInfo = Scene->ExponentialFogs[0]; for (int32 ViewIndex = 0; ViewIndex < Views.Num(); ViewIndex++) { FViewInfo& View = Views[ViewIndex]; int32 VolumetricFogGridPixelSize; const FIntVector VolumetricFogGridSize = GetVolumetricFogGridSize(View.ViewRect.Size(), VolumetricFogGridPixelSize); FVolumetricFogGlobalData GlobalData; SetupVolumetricFogGlobalData(View, GlobalData); View.VolumetricFogResources.VolumetricFogGlobalData = TUniformBufferRef::CreateUniformBufferImmediate(GlobalData, UniformBuffer_SingleFrame); } } else { for (int32 ViewIndex = 0; ViewIndex < Views.Num(); ViewIndex++) { FViewInfo& View = Views[ViewIndex]; if (View.ViewState) { View.ViewState->LightScatteringHistory = NULL; View.ViewState->LightScatteringHistoryPreExposure = 1.0f; } } } } void FDeferredShadingSceneRenderer::ComputeVolumetricFog(FRDGBuilder& GraphBuilder, const FSceneTextures& SceneTextures) { if (!ShouldRenderVolumetricFog()) { return; } const FExponentialHeightFogSceneInfo& FogInfo = Scene->ExponentialFogs[0]; TRACE_CPUPROFILER_EVENT_SCOPE(FDeferredShadingSceneRenderer::ComputeVolumetricFog); QUICK_SCOPE_CYCLE_COUNTER(STAT_VolumetricFog); RDG_CSV_STAT_EXCLUSIVE_SCOPE(GraphBuilder, VolumetricFog); RDG_GPU_STAT_SCOPE(GraphBuilder, VolumetricFog); for (int32 ViewIndex = 0; ViewIndex < Views.Num(); ViewIndex++) { FViewInfo& View = Views[ViewIndex]; RDG_GPU_MASK_SCOPE(GraphBuilder, View.GPUMask); int32 VolumetricFogGridPixelSize; const FIntVector VolumetricFogGridSize = GetVolumetricFogGridSize(View.ViewRect.Size(), VolumetricFogGridPixelSize); const FVector GridZParams = GetVolumetricFogGridZParams(FogInfo.VolumetricFogStartDistance, View.NearClippingDistance, FogInfo.VolumetricFogDistance, VolumetricFogGridSize.Z); FVolumetricFogIntegrationParameterData IntegrationData; IntegrationData.FrameJitterOffsetValues.Empty(16); IntegrationData.FrameJitterOffsetValues.AddZeroed(16); IntegrationData.FrameJitterOffsetValues[0] = VolumetricFogTemporalRandom(View.Family->FrameNumber); for (int32 FrameOffsetIndex = 1; FrameOffsetIndex < GVolumetricFogHistoryMissSupersampleCount; FrameOffsetIndex++) { IntegrationData.FrameJitterOffsetValues[FrameOffsetIndex] = VolumetricFogTemporalRandom(View.Family->FrameNumber - FrameOffsetIndex); } const bool bUseTemporalReprojection = GVolumetricFogTemporalReprojection && View.ViewState; IntegrationData.bTemporalHistoryIsValid = bUseTemporalReprojection && !View.bCameraCut && !View.bPrevTransformsReset && ViewFamily.bRealtimeUpdate && View.ViewState->LightScatteringHistory; FMatrix44f DirectionalLightFunctionTranslatedWorldToShadow; RDG_EVENT_SCOPE(GraphBuilder, "VolumetricFog"); #if WITH_MGPU static const FName NameForTemporalEffect("ComputeVolumetricFog"); GraphBuilder.SetNameForTemporalEffect(FName(NameForTemporalEffect, View.ViewState ? View.ViewState->UniqueID : 0)); #endif FRDGTextureRef ConservativeDepthTexture; // To use a depth target format, and depth tests, we will have to render depth from a PS depth output. Keeping it simple for now with all the tests happening in shader. if (GVolumetricFogConservativeDepth > 0) { FIntPoint ConservativeDepthTextureSize = FIntPoint(VolumetricFogGridSize.X, VolumetricFogGridSize.Y); ConservativeDepthTexture = GraphBuilder.CreateTexture(FRDGTextureDesc::Create2D(ConservativeDepthTextureSize, PF_R16F, FClearValueBinding::Black, TexCreate_RenderTargetable | TexCreate_ShaderResource | TexCreate_UAV), TEXT("VolumetricFog.ConservativeDepthTexture")); AddGenerateConservativeDepthBufferPass(View, GraphBuilder, ConservativeDepthTexture, GetVolumetricFogGridPixelSize()); } else { ConservativeDepthTexture = GraphBuilder.RegisterExternalTexture(GSystemTextures.BlackDummy); } FRDGTexture* LightFunctionTexture = GraphBuilder.RegisterExternalTexture(GSystemTextures.WhiteDummy); FRDGTexture* BlackDummyTexture = GraphBuilder.RegisterExternalTexture(GSystemTextures.BlackDummy); FRDGTexture* VolumetricBlackDummyTexture = GraphBuilder.RegisterExternalTexture(GSystemTextures.VolumetricBlackDummy); const bool bUseEmissive = GVolumetricFogEmissive > 0; // The potential light function for the main directional light is kept separate to be applied during the main VolumetricFogLightScattering pass (as an optimisation). FRDGTexture* DirectionalLightFunctionTexture = GraphBuilder.RegisterExternalTexture(GSystemTextures.WhiteDummy); bool bUseDirectionalLightShadowing = false; // Recover the information about the light use as the forward directional light for cloud shadowing int AtmosphericDirectionalLightIndex = -1; FLightSceneProxy* AtmosphereLightProxy = nullptr; if(View.ForwardLightingResources.SelectedForwardDirectionalLightProxy) { FLightSceneProxy* AtmosphereLight0Proxy = Scene->AtmosphereLights[0] ? Scene->AtmosphereLights[0]->Proxy : nullptr; FLightSceneProxy* AtmosphereLight1Proxy = Scene->AtmosphereLights[1] ? Scene->AtmosphereLights[1]->Proxy : nullptr; FVolumetricCloudRenderSceneInfo* CloudInfo = Scene->GetVolumetricCloudSceneInfo(); const bool VolumetricCloudShadowMap0Valid = View.VolumetricCloudShadowExtractedRenderTarget[0] != nullptr; const bool VolumetricCloudShadowMap1Valid = View.VolumetricCloudShadowExtractedRenderTarget[1] != nullptr; const bool bLight0CloudPerPixelTransmittance = CloudInfo && VolumetricCloudShadowMap0Valid && View.ForwardLightingResources.SelectedForwardDirectionalLightProxy == AtmosphereLight0Proxy && AtmosphereLight0Proxy && AtmosphereLight0Proxy->GetCloudShadowOnSurfaceStrength() > 0.0f; const bool bLight1CloudPerPixelTransmittance = CloudInfo && VolumetricCloudShadowMap1Valid && View.ForwardLightingResources.SelectedForwardDirectionalLightProxy == AtmosphereLight1Proxy && AtmosphereLight1Proxy && AtmosphereLight1Proxy->GetCloudShadowOnSurfaceStrength() > 0.0f; if (bLight0CloudPerPixelTransmittance) { AtmosphereLightProxy = AtmosphereLight0Proxy; AtmosphericDirectionalLightIndex = 0; } else if (bLight1CloudPerPixelTransmittance) { AtmosphereLightProxy = AtmosphereLight1Proxy; AtmosphericDirectionalLightIndex = 1; } } RenderLightFunctionForVolumetricFog( GraphBuilder, View, SceneTextures, VolumetricFogGridSize, FogInfo.VolumetricFogDistance, DirectionalLightFunctionTranslatedWorldToShadow, DirectionalLightFunctionTexture, bUseDirectionalLightShadowing); View.VolumetricFogResources.IntegratedLightScatteringTexture = nullptr; TRDGUniformBufferRef FogUniformBuffer = CreateFogUniformBuffer(GraphBuilder, View); FRDGTextureDesc VolumeDesc(FRDGTextureDesc::Create3D( VolumetricFogGridSize, PF_FloatRGBA, FClearValueBinding::Black, TexCreate_ShaderResource | TexCreate_RenderTargetable | TexCreate_UAV | TexCreate_ReduceMemoryWithTilingMode | TexCreate_3DTiling)); FRDGTextureDesc VolumeDescFastVRAM = VolumeDesc; VolumeDescFastVRAM.Flags |= GFastVRamConfig.VolumetricFog; IntegrationData.VBufferA = GraphBuilder.CreateTexture(VolumeDescFastVRAM, TEXT("VolumetricFog.VBufferA")); IntegrationData.VBufferA_UAV = GraphBuilder.CreateUAV(FRDGTextureUAVDesc(IntegrationData.VBufferA)); IntegrationData.VBufferB = nullptr; IntegrationData.VBufferB_UAV = nullptr; if (bUseEmissive) { IntegrationData.VBufferB = GraphBuilder.CreateTexture(VolumeDescFastVRAM, TEXT("VolumetricFog.VBufferB")); IntegrationData.VBufferB_UAV = GraphBuilder.CreateUAV(FRDGTextureUAVDesc(IntegrationData.VBufferB)); } FRDGTexture* LocalShadowedLightScattering = GraphBuilder.RegisterExternalTexture(GSystemTextures.VolumetricBlackDummy); RenderLocalLightsForVolumetricFog(GraphBuilder, View, bUseTemporalReprojection, IntegrationData, FogInfo, VolumetricFogGridSize, GridZParams, VolumeDescFastVRAM, LocalShadowedLightScattering, ConservativeDepthTexture); { FVolumetricFogMaterialSetupCS::FParameters* PassParameters = GraphBuilder.AllocParameters(); PassParameters->GlobalAlbedo = FogInfo.VolumetricFogAlbedo; PassParameters->GlobalEmissive = FogInfo.VolumetricFogEmissive; PassParameters->GlobalExtinctionScale = FogInfo.VolumetricFogExtinctionScale; PassParameters->RWVBufferA = IntegrationData.VBufferA_UAV; PassParameters->RWVBufferB = IntegrationData.VBufferB_UAV; // FVolumetricFogMaterialSetupCS uses a permutation to not reference that UAV when bUseEmissive is false. PassParameters->Fog = FogUniformBuffer; PassParameters->View = View.ViewUniformBuffer; SetupVolumetricFogIntegrationParameters(PassParameters->VolumetricFogParameters, View, IntegrationData); FVolumetricFogMaterialSetupCS::FPermutationDomain PermutationVector; PermutationVector.Set< FPermutationUseEmissive >(bUseEmissive); auto ComputeShader = View.ShaderMap->GetShader< FVolumetricFogMaterialSetupCS >(PermutationVector); ClearUnusedGraphResources(ComputeShader, PassParameters); GraphBuilder.AddPass( RDG_EVENT_NAME("InitializeVolumeAttributes"), PassParameters, ERDGPassFlags::Compute, [PassParameters, &View, VolumetricFogGridSize, IntegrationData, ComputeShader](FRHICommandList& RHICmdList) { const FIntVector NumGroups = FIntVector::DivideAndRoundUp(VolumetricFogGridSize, VolumetricFogGridInjectionGroupSize); SetComputePipelineState(RHICmdList, ComputeShader.GetComputeShader()); SetShaderParameters(RHICmdList, ComputeShader, ComputeShader.GetComputeShader(), *PassParameters); DispatchComputeShader(RHICmdList, ComputeShader.GetShader(), NumGroups.X, NumGroups.Y, NumGroups.Z); UnsetShaderUAVs(RHICmdList, ComputeShader, ComputeShader.GetComputeShader()); }); VoxelizeFogVolumePrimitives( GraphBuilder, View, IntegrationData, VolumetricFogGridSize, GridZParams, FogInfo.VolumetricFogDistance, bUseEmissive); } IntegrationData.LightScattering = GraphBuilder.CreateTexture(VolumeDesc, TEXT("VolumetricFog.LightScattering"), ERDGTextureFlags::MultiFrame); IntegrationData.LightScatteringUAV = GraphBuilder.CreateUAV(FRDGTextureUAVDesc(IntegrationData.LightScattering)); { FVolumetricFogLightScatteringCS::FParameters* PassParameters = GraphBuilder.AllocParameters(); PassParameters->View = View.ViewUniformBuffer; PassParameters->Forward = View.ForwardLightingResources.ForwardLightUniformBuffer; PassParameters->Fog = FogUniformBuffer; SetupVolumetricFogIntegrationParameters(PassParameters->VolumetricFogParameters, View, IntegrationData); PassParameters->VBufferA = IntegrationData.VBufferA; PassParameters->VBufferB = IntegrationData.VBufferB ? IntegrationData.VBufferB : VolumetricBlackDummyTexture; PassParameters->LocalShadowedLightScattering = LocalShadowedLightScattering; PassParameters->ConservativeDepthTexture = ConservativeDepthTexture; PassParameters->UseConservativeDepthTexture = GVolumetricFogConservativeDepth > 0 ? 1 : 0; PassParameters->UseEmissive = bUseEmissive ? 1 : 0; if (GVolumetricFogConservativeDepth > 0 && bUseTemporalReprojection && View.ViewState->PrevLightScatteringConservativeDepthTexture.IsValid()) { PassParameters->PrevConservativeDepthTexture = GraphBuilder.RegisterExternalTexture(View.ViewState->PrevLightScatteringConservativeDepthTexture); FIntVector TextureSize = View.ViewState->PrevLightScatteringConservativeDepthTexture->GetDesc().GetSize(); PassParameters->PrevConservativeDepthTextureSize = FVector2f(TextureSize.X, TextureSize.Y); } else { PassParameters->PrevConservativeDepthTexture = BlackDummyTexture; PassParameters->PrevConservativeDepthTextureSize = FVector2f::UnitVector; } PassParameters->DirectionalLightFunctionTranslatedWorldToShadow = DirectionalLightFunctionTranslatedWorldToShadow; PassParameters->LightFunctionTexture = DirectionalLightFunctionTexture; PassParameters->LightFunctionSampler = TStaticSamplerState::GetRHI(); auto* LumenUniforms = GraphBuilder.AllocParameters(); LumenUniforms->Parameters = GetLumenTranslucencyLightingParameters(GraphBuilder, View.LumenTranslucencyGIVolume, View.LumenFrontLayerTranslucency); PassParameters->LumenGIVolumeStruct = GraphBuilder.CreateUniformBuffer(LumenUniforms); PassParameters->RWLightScattering = IntegrationData.LightScatteringUAV; PassParameters->VirtualShadowMapSamplingParameters = VirtualShadowMapArray.GetSamplingParameters(GraphBuilder); FDistanceFieldAOParameters AOParameterData(Scene->DefaultMaxDistanceFieldOcclusionDistance); if (Scene->SkyLight // Skylights with static lighting had their diffuse contribution baked into lightmaps && !Scene->SkyLight->bHasStaticLighting && View.Family->EngineShowFlags.SkyLighting) { AOParameterData = FDistanceFieldAOParameters(Scene->SkyLight->OcclusionMaxDistance, Scene->SkyLight->Contrast); } PassParameters->AOParameters = DistanceField::SetupAOShaderParameters(AOParameterData); PassParameters->GlobalDistanceFieldParameters = SetupGlobalDistanceFieldParameters(View.GlobalDistanceFieldInfo.ParameterData); FVolumetricCloudRenderSceneInfo* CloudInfo = Scene->GetVolumetricCloudSceneInfo(); FRDGTexture* LightScatteringHistoryRDGTexture = VolumetricBlackDummyTexture; float LightScatteringHistoryPreExposure = 1.0f; if (bUseTemporalReprojection && View.ViewState->LightScatteringHistory.IsValid()) { LightScatteringHistoryRDGTexture = GraphBuilder.RegisterExternalTexture(View.ViewState->LightScatteringHistory); LightScatteringHistoryPreExposure = View.ViewState->LightScatteringHistoryPreExposure; } PassParameters->LightScatteringHistory = LightScatteringHistoryRDGTexture; PassParameters->LightScatteringHistorySampler = TStaticSamplerState::GetRHI(); PassParameters->LightScatteringHistoryPreExposureAndInv = FVector2f(LightScatteringHistoryPreExposure, LightScatteringHistoryPreExposure > 0.0f ? 1.0f / LightScatteringHistoryPreExposure : 1.0f); FSkyLightSceneProxy* SkyLight = Scene->SkyLight; if (SkyLight // Skylights with static lighting had their diffuse contribution baked into lightmaps && !SkyLight->bHasStaticLighting && View.Family->EngineShowFlags.SkyLighting) { PassParameters->SkyLightUseStaticShadowing = SkyLight->bWantsStaticShadowing && SkyLight->bCastShadows ? 1.0f : 0.0f; PassParameters->SkyLightVolumetricScatteringIntensity = SkyLight->VolumetricScatteringIntensity; const FSHVectorRGB3& SkyIrradiance = SkyLight->IrradianceEnvironmentMap; PassParameters->SkySH[0] = (FVector4f&)SkyIrradiance.R.V; PassParameters->SkySH[1] = (FVector4f&)SkyIrradiance.G.V; PassParameters->SkySH[2] = (FVector4f&)SkyIrradiance.B.V; } else { PassParameters->SkyLightUseStaticShadowing = 0.0f; PassParameters->SkyLightVolumetricScatteringIntensity = 0.0f; PassParameters->SkySH[0] = FVector4f(0, 0, 0, 0); PassParameters->SkySH[1] = FVector4f(0, 0, 0, 0); PassParameters->SkySH[2] = FVector4f(0, 0, 0, 0); } float StaticLightingScatteringIntensityValue = 0; if (View.Family->EngineShowFlags.GlobalIllumination && View.Family->EngineShowFlags.VolumetricLightmap) { StaticLightingScatteringIntensityValue = FogInfo.VolumetricFogStaticLightingScatteringIntensity; } PassParameters->StaticLightingScatteringIntensity = StaticLightingScatteringIntensityValue; PassParameters->PhaseG = FogInfo.VolumetricFogScatteringDistribution; PassParameters->InverseSquaredLightDistanceBiasScale = GInverseSquaredLightDistanceBiasScale; PassParameters->UseDirectionalLightShadowing = bUseDirectionalLightShadowing ? 1.0f : 0.0f; PassParameters->LightScatteringSampleJitterMultiplier = GVolumetricFogJitter ? GLightScatteringSampleJitterMultiplier : 0; PassParameters->UseHeightFogColors = FVector2f( OverrideDirectionalLightInScatteringUsingHeightFog(View, FogInfo) ? 1.0f : 0.0f, OverrideSkyLightInScatteringUsingHeightFog(View, FogInfo) ? 1.0f : 0.0f); FMatrix44f CloudWorldToLightClipShadowMatrix = FMatrix44f::Identity; float CloudShadowmap_FarDepthKm = 0.0f; float CloudShadowmap_Strength = 0.0f; FRDGTexture* CloudShadowmap_RDGTexture = BlackDummyTexture; if (CloudInfo && AtmosphericDirectionalLightIndex >= 0 && AtmosphereLightProxy) { CloudShadowmap_RDGTexture = GraphBuilder.RegisterExternalTexture(View.VolumetricCloudShadowExtractedRenderTarget[AtmosphericDirectionalLightIndex]); CloudWorldToLightClipShadowMatrix = CloudInfo->GetVolumetricCloudCommonShaderParameters().CloudShadowmapTranslatedWorldToLightClipMatrix[AtmosphericDirectionalLightIndex]; CloudShadowmap_FarDepthKm = CloudInfo->GetVolumetricCloudCommonShaderParameters().CloudShadowmapFarDepthKm[AtmosphericDirectionalLightIndex].X; CloudShadowmap_Strength = AtmosphereLightProxy->GetCloudShadowOnSurfaceStrength(); } PassParameters->CloudShadowmapTexture = CloudShadowmap_RDGTexture; PassParameters->CloudShadowmapSampler = TStaticSamplerState::GetRHI(); PassParameters->CloudShadowmapFarDepthKm = CloudShadowmap_FarDepthKm; PassParameters->CloudShadowmapStrength = CloudShadowmap_Strength; PassParameters->CloudShadowmapTranslatedWorldToLightClipMatrix = CloudWorldToLightClipShadowMatrix; const bool bUseLumenGI = View.LumenTranslucencyGIVolume.Texture0 != nullptr; const bool bUseGlobalDistanceField = UseGlobalDistanceField() && Scene->DistanceFieldSceneData.NumObjectsInBuffer > 0; const bool bUseDistanceFieldSkyOcclusion = ViewFamily.EngineShowFlags.AmbientOcclusion && !bUseLumenGI && Scene->SkyLight && Scene->SkyLight->bCastShadows && Scene->SkyLight->bCastVolumetricShadow && ShouldRenderDistanceFieldAO() && SupportsDistanceFieldAO(View.GetFeatureLevel(), View.GetShaderPlatform()) && bUseGlobalDistanceField && Views.Num() == 1 && View.IsPerspectiveProjection(); const int32 SuperSampleCount = FVolumetricFogLightScatteringCS::GetSuperSampleCount(GVolumetricFogHistoryMissSupersampleCount); FVolumetricFogLightScatteringCS::FPermutationDomain PermutationVector; PermutationVector.Set< FVolumetricFogLightScatteringCS::FTemporalReprojection >(bUseTemporalReprojection); PermutationVector.Set< FVolumetricFogLightScatteringCS::FDistanceFieldSkyOcclusion >(bUseDistanceFieldSkyOcclusion); PermutationVector.Set< FVolumetricFogLightScatteringCS::FSuperSampleCount >(SuperSampleCount); PermutationVector.Set< FVolumetricFogLightScatteringCS::FLumenGI >(bUseLumenGI); PermutationVector.Set< FVolumetricFogLightScatteringCS::FVirtualShadowMap >(VirtualShadowMapArray.IsAllocated() ); PermutationVector.Set< FVolumetricFogLightScatteringCS::FCloudTransmittance >(AtmosphericDirectionalLightIndex >= 0); auto ComputeShader = View.ShaderMap->GetShader< FVolumetricFogLightScatteringCS >(PermutationVector); ClearUnusedGraphResources(ComputeShader, PassParameters); GraphBuilder.AddPass( RDG_EVENT_NAME("LightScattering %dx%dx%d SS:%d %s %s %s", VolumetricFogGridSize.X, VolumetricFogGridSize.Y, VolumetricFogGridSize.Z, SuperSampleCount, bUseDistanceFieldSkyOcclusion ? TEXT("DFAO") : TEXT(""), PassParameters->LightFunctionTexture ? TEXT("LF") : TEXT(""), bUseLumenGI ? TEXT("Lumen") : TEXT("")), PassParameters, ERDGPassFlags::Compute, [PassParameters, ComputeShader, &View, this, VolumetricFogGridSize](FRHICommandList& RHICmdList) { const FIntVector NumGroups = FComputeShaderUtils::GetGroupCount(VolumetricFogGridSize, FVolumetricFogLightScatteringCS::GetGroupSize()); SetComputePipelineState(RHICmdList, ComputeShader.GetComputeShader()); SetShaderParameters(RHICmdList, ComputeShader, ComputeShader.GetComputeShader(), *PassParameters); DispatchComputeShader(RHICmdList, ComputeShader.GetShader(), NumGroups.X, NumGroups.Y, NumGroups.Z); UnsetShaderUAVs(RHICmdList, ComputeShader, ComputeShader.GetComputeShader()); }); } FRDGTexture* IntegratedLightScattering = GraphBuilder.CreateTexture(VolumeDesc, TEXT("VolumetricFog.IntegratedLightScattering")); FRDGTextureUAV* IntegratedLightScatteringUAV = GraphBuilder.CreateUAV(FRDGTextureUAVDesc(IntegratedLightScattering)); { FVolumetricFogFinalIntegrationCS::FParameters* PassParameters = GraphBuilder.AllocParameters(); PassParameters->LightScattering = IntegrationData.LightScattering; PassParameters->RWIntegratedLightScattering = IntegratedLightScatteringUAV; PassParameters->VolumetricFogNearFadeInDistanceInv = View.VolumetricFogNearFadeInDistanceInv; PassParameters->ViewUniformBuffer = View.ViewUniformBuffer; SetupVolumetricFogIntegrationParameters(PassParameters->VolumetricFogParameters, View, IntegrationData); GraphBuilder.AddPass( RDG_EVENT_NAME("FinalIntegration"), PassParameters, ERDGPassFlags::Compute, [PassParameters, &View, VolumetricFogGridSize, IntegrationData, this](FRHICommandList& RHICmdList) { const FIntVector NumGroups = FIntVector::DivideAndRoundUp(VolumetricFogGridSize, VolumetricFogIntegrationGroupSize); auto ComputeShader = View.ShaderMap->GetShader< FVolumetricFogFinalIntegrationCS >(); SetComputePipelineState(RHICmdList, ComputeShader.GetComputeShader()); SetShaderParameters(RHICmdList, ComputeShader, ComputeShader.GetComputeShader(), *PassParameters); DispatchComputeShader(RHICmdList, ComputeShader.GetShader(), NumGroups.X, NumGroups.Y, 1); UnsetShaderUAVs(RHICmdList, ComputeShader, ComputeShader.GetComputeShader()); }); } View.VolumetricFogResources.IntegratedLightScatteringTexture = IntegratedLightScattering; if (bUseTemporalReprojection) { GraphBuilder.QueueTextureExtraction(IntegrationData.LightScattering, &View.ViewState->LightScatteringHistory); View.ViewState->LightScatteringHistoryPreExposure = View.CachedViewUniformShaderParameters->PreExposure; } else if (View.ViewState) { View.ViewState->LightScatteringHistory = nullptr; View.ViewState->LightScatteringHistoryPreExposure = 1.0f; } if (bUseTemporalReprojection && GVolumetricFogConservativeDepth > 0) { GraphBuilder.QueueTextureExtraction(ConservativeDepthTexture, &View.ViewState->PrevLightScatteringConservativeDepthTexture); } else if (View.ViewState) { View.ViewState->PrevLightScatteringConservativeDepthTexture = NULL; } } }