Fix fog scattering in HDRP

Fix fog scattering in HDRP that didn't account for opaque objects' color.


https://media.github.cds.internal.unity3d.com/user/745/files/639309be-e188-4586-896a-cdcb481e45a6

Author: alelievr

Packages/com.unity.render-pipelines.core/Editor/PostProcessing/LensFlareComponentSRPEditor.cs

@@ -22,17 +22,18 @@ class LensFlareComponentSRPEditor : Editor
         SerializedProperty m_AttenuationByLightShape;
         SerializedProperty m_RadialScreenAttenuationCurve;
         SerializedProperty m_UseOcclusion;
-        SerializedProperty m_BackgroundCloudOcclusion;
+        SerializedProperty m_fogOcclusion;
         SerializedProperty m_WaterOcclusion;
         SerializedProperty m_OcclusionRadius;
         SerializedProperty m_SamplesCount;
         SerializedProperty m_OcclusionOffset;
         SerializedProperty m_AllowOffScreen;
-        SerializedProperty m_VolumetricCloudOcclusion;
         SerializedProperty m_OcclusionRemapTextureCurve;
         SerializedProperty m_OcclusionRemapCurve;
         SerializedProperty m_LightOverride;
 
+        Light m_AttachedLight;
+
         void MakeTextureDirtyCallback()
         {
             LensFlareComponentSRP comp = target as LensFlareComponentSRP;
@@ -41,6 +42,10 @@ void MakeTextureDirtyCallback()
 
         void OnEnable()
         {
+            if (targets.Length == 1)
+                m_AttachedLight = (target as Component)?.GetComponent<Light>();
+            else
+                m_AttachedLight = null;
             PropertyFetcher<LensFlareComponentSRP> entryPoint = new PropertyFetcher<LensFlareComponentSRP>(serializedObject);
             m_LensFlareData = entryPoint.Find("m_LensFlareData");
             m_Intensity = entryPoint.Find(x => x.intensity);
@@ -52,13 +57,12 @@ void OnEnable()
             m_AttenuationByLightShape = entryPoint.Find(x => x.attenuationByLightShape);
             m_RadialScreenAttenuationCurve = entryPoint.Find(x => x.radialScreenAttenuationCurve);
             m_UseOcclusion = entryPoint.Find(x => x.useOcclusion);
-            m_BackgroundCloudOcclusion = entryPoint.Find(x => x.useBackgroundCloudOcclusion);
+            m_fogOcclusion = entryPoint.Find(x => x.useFogOpacityOcclusion);
             m_WaterOcclusion = entryPoint.Find(x => x.useWaterOcclusion);
             m_OcclusionRadius = entryPoint.Find(x => x.occlusionRadius);
             m_SamplesCount = entryPoint.Find(x => x.sampleCount);
             m_OcclusionOffset = entryPoint.Find(x => x.occlusionOffset);
             m_AllowOffScreen = entryPoint.Find(x => x.allowOffScreen);
-            m_VolumetricCloudOcclusion = entryPoint.Find(x => x.volumetricCloudOcclusion);
             m_OcclusionRemapTextureCurve = entryPoint.Find(x => x.occlusionRemapCurve);
             m_OcclusionRemapCurve = m_OcclusionRemapTextureCurve.FindPropertyRelative("m_Curve");
             m_LightOverride = entryPoint.Find(x => x.lightOverride);
@@ -156,12 +160,16 @@ public override void OnInspectorGUI()
             if (m_UseOcclusion.boolValue)
             {
                 ++EditorGUI.indentLevel;
-                if (RenderPipelineManager.currentPipeline is ICloudBackground)
-                    EditorGUILayout.PropertyField(m_BackgroundCloudOcclusion, Styles.backgroundCloudOcclusion);
-                if (RenderPipelineManager.currentPipeline is IVolumetricCloud volumetricCloud && volumetricCloud.IsVolumetricCloudUsable())
-                    EditorGUILayout.PropertyField(m_VolumetricCloudOcclusion, Styles.volumetricCloudOcclusion);
-                if (RenderPipelineManager.currentPipeline is IWaterRendering waterRendering && waterRendering.IsWaterRenderingUsable())
-                    EditorGUILayout.PropertyField(m_WaterOcclusion, Styles.waterOcclusion);
+                EditorGUI.BeginDisabledGroup(m_AttachedLight != null && m_AttachedLight.type != LightType.Directional);
+                {
+                    if (RenderPipelineManager.currentPipeline is ICloudBackground)
+                        EditorGUILayout.PropertyField(m_fogOcclusion, Styles.fogAndCloudOpacityOcclusion);
+                    if (RenderPipelineManager.currentPipeline is IWaterRendering waterRendering &&
+                        waterRendering.IsWaterRenderingUsable())
+                        EditorGUILayout.PropertyField(m_WaterOcclusion, Styles.waterOcclusion);
+                }
+                EditorGUI.EndDisabledGroup();
+
                 EditorGUILayout.PropertyField(m_OcclusionRadius, Styles.occlusionRadius);
                 EditorGUILayout.PropertyField(m_SamplesCount, Styles.sampleCount);
                 EditorGUILayout.PropertyField(m_OcclusionOffset, Styles.occlusionOffset);
@@ -199,7 +207,7 @@ static class Styles
             static public readonly GUIContent attenuationByLightShape = EditorGUIUtility.TrTextContent("Attenuation By Light Shape", "When enabled, if the component is attached to a light, automatically reduces the effect of the lens flare based on the type and shape of the light.");
             static public readonly GUIContent radialScreenAttenuationCurve = EditorGUIUtility.TrTextContent("Screen Attenuation Curve", "Specifies the curve that modifies the intensity of the lens flare based on its distance from the edge of the screen.");
             static public readonly GUIContent enableOcclusion = EditorGUIUtility.TrTextContent("Enable", "When enabled, the renderer uses the depth buffer to occlude (partially or completely) the lens flare. Partial occlusion also occurs when the lens flare is partially offscreen.");
-            static public readonly GUIContent backgroundCloudOcclusion = EditorGUIUtility.TrTextContent("Background Clouds", "When enabled, the occlusion is attenuated by the Background Clouds used on the Visual Environnement (Cloud layer).");
+            static public readonly GUIContent fogAndCloudOpacityOcclusion = EditorGUIUtility.TrTextContent("Fog And Cloud Opacity", "When enabled, the occlusion is attenuated by the Background Clouds, Volumetric Clouds and the Fog.");
             static public readonly GUIContent occlusionRadius = EditorGUIUtility.TrTextContent("Occlusion Radius", "Sets the radius, in meters, around the light used to compute the occlusion of the lens flare. If this area is half occluded by geometry (or half off-screen), the intensity of the lens flare is cut by half.");
             static public readonly GUIContent sampleCount = EditorGUIUtility.TrTextContent("Sample Count", "Sets the number of random samples used inside the Occlusion Radius area. A higher sample count gives a smoother attenuation when occluded.");
             static public readonly GUIContent occlusionOffset = EditorGUIUtility.TrTextContent("Occlusion Offset", "Sets the offset of the occlusion area in meters between the GameObject this asset is attached to, and the Camera. A positive value moves the occlusion area closer to the Camera.");

Packages/com.unity.render-pipelines.core/Runtime/PostProcessing/LensFlareCommonSRP.cs

@@ -557,28 +557,22 @@ static public bool IsCloudLayerOpacityNeeded(Camera cam)
                     (comp.useOcclusion && comp.sampleCount == 0))
                     continue;
 
-                if (comp.useBackgroundCloudOcclusion)
+                if (comp.useFogOpacityOcclusion)
                     return true;
             }
 
             return false;
         }
 
-        static void SetOcclusionPermutation(Rendering.CommandBuffer cmd,
-            bool useBackgroundCloudOcclusion, bool volumetricCloudOcclusion, bool waterOcclusion,
-            int _FlareCloudOpacity, int _FlareSunOcclusionTex,
-            Texture cloudOpacityTexture, Texture sunOcclusionTexture, Texture waterGBuffer3Thickness)
+        static void SetOcclusionPermutation(CommandBuffer cmd,
+            bool useFogOpacityOcclusion, bool waterOcclusion, int _FlareSunOcclusionTex,
+            Texture sunOcclusionTexture, Texture waterGBuffer3Thickness)
         {
             uint occlusionPermutation = (uint)(LensFlareOcclusionPermutation.Depth);
-            if (useBackgroundCloudOcclusion && cloudOpacityTexture != null)
-            {
-                occlusionPermutation |= (uint)(LensFlareOcclusionPermutation.CloudLayer);
-                cmd.SetGlobalTexture(_FlareCloudOpacity, cloudOpacityTexture);
-            }
 
-            if (volumetricCloudOcclusion && sunOcclusionTexture != null)
+            if (useFogOpacityOcclusion && sunOcclusionTexture != null)
             {
-                occlusionPermutation |= (uint)(LensFlareOcclusionPermutation.VolumetricCloud);
+                occlusionPermutation |= (uint)(LensFlareOcclusionPermutation.FogOpacity);
                 cmd.SetGlobalTexture(_FlareSunOcclusionTex, sunOcclusionTexture);
             }
 
@@ -947,10 +941,8 @@ static public void ComputeOcclusion(Material lensFlareShader, Camera cam, XRPass
 
                 cmd.SetGlobalVector(_FlareData1, new Vector4(occlusionRadius, comp.sampleCount, screenPosZ.z, actualHeight / actualWidth));
 
-                SetOcclusionPermutation(cmd,
-                    comp.useBackgroundCloudOcclusion && hasCloudLayer, comp.volumetricCloudOcclusion, comp.useWaterOcclusion,
-                    _FlareCloudOpacity, _FlareSunOcclusionTex,
-                    cloudOpacityTexture, sunOcclusionTexture, waterGBuffer3Thickness);
+                SetOcclusionPermutation(cmd, comp.useFogOpacityOcclusion, comp.useWaterOcclusion,
+                    _FlareSunOcclusionTex, sunOcclusionTexture, waterGBuffer3Thickness);
                 cmd.EnableShaderKeyword("FLARE_COMPUTE_OCCLUSION");
 
                 Vector2 screenPos = new Vector2(2.0f * viewportPos.x - 1.0f, -(2.0f * viewportPos.y - 1.0f));
@@ -1716,7 +1708,7 @@ static public void DoLensFlareDataDrivenCommon(Material lensFlareShader, Camera
 
                 if(!SystemInfo.graphicsUVStartsAtTop && isDirLight) // Y-flip for OpenGL & directional light
                     screenPos.y = -screenPos.y;
-                
+
                 Vector2 radPos = new Vector2(Mathf.Abs(screenPos.x), Mathf.Abs(screenPos.y));
                 float radius = Mathf.Max(radPos.x, radPos.y); // l1 norm (instead of l2 norm)
                 float radialsScaleRadius = comp.radialScreenAttenuationCurve.length > 0 ? comp.radialScreenAttenuationCurve.Evaluate(radius) : 1.0f;
@@ -1955,15 +1947,15 @@ static public void DoLensFlareScreenSpaceCommon(
             RTHandle result,
             bool debugView)
         {
-            
-            //Multiplying parameters value here for easier maintenance since they are the same numbers between SRPs 
+
+            //Multiplying parameters value here for easier maintenance since they are the same numbers between SRPs
             parameters2.x = Mathf.Pow(parameters2.x, 0.25f);        // Vignette effect
             parameters3.z = parameters3.z / 20f;                    // chromaticAbberationIntensity
-            parameters4.y = parameters4.y * 10f;                    // Streak Length                  
+            parameters4.y = parameters4.y * 10f;                    // Streak Length
             parameters4.z = parameters4.z / 90f;                    // Streak Orientation
             parameters5.y = 1.0f / parameters5.y;                   // WarpedFlareScale X
             parameters5.z = 1.0f / parameters5.z;                   // WarpedFlareScale Y
-            
+
             cmd.SetViewport(new Rect() { width = actualWidth, height = actualHeight });
             if (debugView)
             {

Packages/com.unity.render-pipelines.core/Runtime/PostProcessing/LensFlareComponentSRP.cs

@@ -4,6 +4,7 @@
 
 using System;
 using System.Dynamic;
+using UnityEngine.Serialization;
 
 namespace UnityEngine.Rendering
 {
@@ -17,6 +18,16 @@ public sealed class LensFlareComponentSRP : MonoBehaviour
         [SerializeField]
         private LensFlareDataSRP m_LensFlareData = null;
 
+        enum Version
+        {
+            Initial,
+        }
+
+        #pragma warning disable 414
+        [SerializeField]
+        Version version = Version.Initial;
+        #pragma warning restore 414
+
         /// <summary>
         /// Lens flare asset used on this component
         /// </summary>
@@ -71,8 +82,14 @@ public LensFlareDataSRP lensFlareData
         public bool useOcclusion = false;
         /// <summary>
         /// Enable Occlusion using Background Cloud (for instance: CloudLayer)
+        /// Please use useFogOpacityOcclusion instead.
         /// </summary>
+        [Obsolete("Replaced by useFogOpacityOcclusion.")]
         public bool useBackgroundCloudOcclusion = false;
+
+        /// <summary>Enable Occlusion using fog opacity from volumetric clouds, cloud layers and fog.</summary>
+        [FormerlySerializedAs("volumetricCloudOcclusion")]
+        public bool useFogOpacityOcclusion = false;
         /// <summary>
         /// Enable Occlusion with Water
         /// </summary>
@@ -103,7 +120,9 @@ public LensFlareDataSRP lensFlareData
         public bool allowOffScreen = false;
         /// <summary>
         /// If volumetricCloudOcclusion is true then use the volumetric cloud (on HDRP only) for the occlusion
+        /// Please use useFogOpacityOcclusion instead.
         /// </summary>
+        [Obsolete("Please use useFogOpacityOcclusion instead.")]
         public bool volumetricCloudOcclusion = false;
 
         /// Our default celestial body will have an angular radius of 3.3 degrees. This is an arbitrary number, but must be kept constant

Packages/com.unity.render-pipelines.core/Runtime/PostProcessing/LensFlareDataSRP.cs.hlsl

@@ -4,6 +4,13 @@
 
 #ifndef LENSFLAREDATASRP_CS_HLSL
 #define LENSFLAREDATASRP_CS_HLSL
+//
+// UnityEngine.Rendering.SRPLensFlareColorType:  static fields
+//
+#define SRPLENSFLARECOLORTYPE_CONSTANT (0)
+#define SRPLENSFLARECOLORTYPE_RADIAL_GRADIENT (1)
+#define SRPLENSFLARECOLORTYPE_ANGULAR_GRADIENT (2)
+
 //
 // UnityEngine.Rendering.SRPLensFlareType:  static fields
 //

Packages/com.unity.render-pipelines.core/Runtime/PostProcessing/LensFlareOcclusionPermutation.cs

@@ -4,8 +4,7 @@ namespace UnityEngine.Rendering
     internal enum LensFlareOcclusionPermutation
     {
         Depth = (1 << 0),
-        CloudLayer = (1 << 1),
-        VolumetricCloud = (1 << 2),
+        FogOpacity = (1 << 2),
         Water = (1 << 3)
     }
 }

Packages/com.unity.render-pipelines.core/Runtime/PostProcessing/LensFlareOcclusionPermutation.cs.hlsl

@@ -8,8 +8,7 @@
 // UnityEngine.Rendering.LensFlareOcclusionPermutation:  static fields
 //
 #define LENSFLAREOCCLUSIONPERMUTATION_DEPTH (1)
-#define LENSFLAREOCCLUSIONPERMUTATION_CLOUD_LAYER (2)
-#define LENSFLAREOCCLUSIONPERMUTATION_VOLUMETRIC_CLOUD (4)
+#define LENSFLAREOCCLUSIONPERMUTATION_FOG_OPACITY (4)
 #define LENSFLAREOCCLUSIONPERMUTATION_WATER (8)
 
 

Packages/com.unity.render-pipelines.core/Runtime/PostProcessing/Shaders/LensFlareCommon.hlsl

@@ -48,9 +48,6 @@ SAMPLER(sampler_StencilTexture);
 TEXTURE2D_X(_DepthWithWaterTexture);
 SAMPLER(sampler_DepthWithWaterTexture);
 
-TEXTURE2D_X(_FlareCloudOpacity);
-SAMPLER(sampler_FlareCloudOpacity);
-
 TEXTURE2D_X(_FlareSunOcclusionTex);
 SAMPLER(sampler_FlareSunOcclusionTex);
 
@@ -204,7 +201,7 @@ float GetOcclusion(float ratio)
         {
             float depth0 = GetLinearDepthValue(pos);
 
-#if UNITY_REVERSED_Z 
+#if UNITY_REVERSED_Z
             if (depth0 > _ScreenPosZ)
 #else
             if (depth0 < _ScreenPosZ)
@@ -213,24 +210,14 @@ float GetOcclusion(float ratio)
                 float occlusionValue = 1.0f;
 
 #ifdef HDRP_FLARE
-                if ((_FlareOcclusionPermutation & LENSFLAREOCCLUSIONPERMUTATION_CLOUD_LAYER) != 0)
-                {
-                    float cloudOpacity;
-                    if (_ViewId >= 0)
-                        cloudOpacity = LOAD_TEXTURE2D_ARRAY(_FlareCloudOpacity, uint2(pos * _ScreenParams.xy), _ViewId).x;
-                    else
-                        cloudOpacity = LOAD_TEXTURE2D_X(_FlareCloudOpacity, uint2(pos * _ScreenParams.xy)).x;
-                    occlusionValue *= saturate(cloudOpacity);
-                }
-
-                if ((_FlareOcclusionPermutation & LENSFLAREOCCLUSIONPERMUTATION_VOLUMETRIC_CLOUD) != 0)
+                if ((_FlareOcclusionPermutation & LENSFLAREOCCLUSIONPERMUTATION_FOG_OPACITY) != 0)
                 {
-                    float volumetricCloudOcclusion;
+                    float fogOcclusion;
                     if (_ViewId >= 0)
-                        volumetricCloudOcclusion = SAMPLE_TEXTURE2D_ARRAY_LOD(_FlareSunOcclusionTex, sampler_FlareSunOcclusionTex, pos, _ViewId, 0).w;
+                        fogOcclusion = SAMPLE_TEXTURE2D_ARRAY_LOD(_FlareSunOcclusionTex, sampler_FlareSunOcclusionTex, pos * _RTHandleScale.xy, _ViewId, 0).x;
                     else
-                        volumetricCloudOcclusion = SAMPLE_TEXTURE2D_X_LOD(_FlareSunOcclusionTex, sampler_FlareSunOcclusionTex, pos, 0).w;
-                    occlusionValue *= saturate(volumetricCloudOcclusion);
+                        fogOcclusion = SAMPLE_TEXTURE2D_X_LOD(_FlareSunOcclusionTex, sampler_FlareSunOcclusionTex, pos * _RTHandleScale.xy, 0).x;
+                    occlusionValue *= saturate(fogOcclusion);
                 }
 
                 if ((_FlareOcclusionPermutation & LENSFLAREOCCLUSIONPERMUTATION_WATER) != 0)

Packages/com.unity.render-pipelines.high-definition/Editor/Sky/AtmosphericScattering/FogEditor.cs

@@ -23,6 +23,7 @@ class FogEditor : VolumeComponentWithQualityEditor
 
         protected SerializedDataParameter m_EnableVolumetricFog;
         protected SerializedDataParameter m_Anisotropy;
+        protected SerializedDataParameter m_MultipleScatteringIntensity;
         protected SerializedDataParameter m_DepthExtent;
         protected SerializedDataParameter m_GlobalLightProbeDimmer;
         protected SerializedDataParameter m_SliceDistributionUniformity;
@@ -63,7 +64,9 @@ public override void OnEnable()
             m_BaseHeight = Unpack(o.Find(x => x.baseHeight));
             m_MaximumHeight = Unpack(o.Find(x => x.maximumHeight));
             m_Anisotropy = Unpack(o.Find(x => x.anisotropy));
+            m_MultipleScatteringIntensity = Unpack(o.Find(x => x.multipleScatteringIntensity));
             m_GlobalLightProbeDimmer = Unpack(o.Find(x => x.globalLightProbeDimmer));
+            
             m_EnableVolumetricFog = Unpack(o.Find(x => x.enableVolumetricFog));
             m_DepthExtent = Unpack(o.Find(x => x.depthExtent));
             m_SliceDistributionUniformity = Unpack(o.Find(x => x.sliceDistributionUniformity));
@@ -165,6 +168,8 @@ public override void OnInspectorGUI()
                         }
                         EndAdditionalPropertiesScope();
                     }
+
+                    PropertyField(m_MultipleScatteringIntensity);
                 }
             }
         }

Packages/com.unity.render-pipelines.high-definition/Runtime/Lighting/AtmosphericScattering/Fog.cs

@@ -75,6 +75,11 @@ public class Fog : VolumeComponentWithQuality
         [Tooltip("Controls the distribution of slices along the Camera's focal axis. 0 is exponential distribution and 1 is linear distribution.")]
         public ClampedFloatParameter sliceDistributionUniformity = new ClampedFloatParameter(0.75f, 0, 1);
 
+        /// <summary>Controls how much the multiple-scattering will affect the scene. Directly controls the amount of blur depending on the fog density.</summary>
+        [AdditionalProperty]
+        [Tooltip("Use this value to simulate multiple scattering when combining the fog with the scene color.")]
+        public ClampedFloatParameter multipleScatteringIntensity = new ClampedFloatParameter(0.0f, 0.0f, 2.0f);
+
         // Limit parameters for the fog quality
         internal const float minFogScreenResolutionPercentage = (1.0f / 16.0f) * 100;
         internal const float optimalFogScreenResolutionPercentage = (1.0f / 8.0f) * 100;
@@ -176,6 +181,13 @@ internal static bool IsPBRFogEnabled(HDCamera hdCamera)
             return (visualEnv.skyType.value == (int)SkyType.PhysicallyBased) && pbrSky.atmosphericScattering.value && fs;
         }
 
+        internal static bool IsMultipleScatteringEnabled(HDCamera hdCamera, out float intensity)
+        {
+            var fog = hdCamera.volumeStack.GetComponent<Fog>();
+            intensity = fog.multipleScatteringIntensity.value;
+            return intensity > 0.0f;
+        }
+
         static float ScaleHeightFromLayerDepth(float d)
         {
             // Exp[-d / H] = 0.001