Add volumetric slider cutoff

Author: Antoine Lelièvre

Packages/com.unity.render-pipelines.high-definition/Documentation~/fog-volume-override-reference.md

@@ -6,18 +6,19 @@ This document explains how to fix some common visual artifacts that can appear w
 
 A slice artifact is the appearance of thin layers around the edge of the volumetric fog. To fix this issue, go to the Local Volumetric Fog component and adjust the following settings:
 
-- **Blend Distance**: Set this value above 0.
+- **Blend Distance**: Set this value above 0 to improve visual transitions at the volume’s border and reduce slice artifacts.
 - **Slice Distribution Uniformity**: Increase this value to make the edge of the fog more detailed as it gets closer to the camera.
-- **Volumetric Fog Distance**: Set this property between 20 and 100 to reduce the appearance of artifacts.
 
 ## Sharp edges 
 
 To remove the appearance of sharp areas or corners in a volumetric fog, open the [Global Fog](create-a-global-fog-effect.md) component and set the **Denoising Mode** property to one of the following modes: 
 - **None**.
-- **Reprojection**: This mode can cause edges to have a blurry artifact (ghosting).
-- **Gaussian**: Use this setting for blurry fog with no hard shapes.
+- **Reprojection**:  Disables denoising for fog with sharp edges or hard corners. This option maintains detail, but can introduce ghosting artifacts, and doubles the amount of memory volumetric fog uses.
+- **Gaussian**: Creates soft, blurry fog with undefined shapes. This mode smooths out noise but can blur out sharp features.
 - **Both**: Applies both Reprojection and Gaussian techniques. This setting significantly increases the volumetric fog's memory usage and GPU time.
 
+For more physically accurate blending between the fog and the environment, set **Falloff Mode** to **Exponential**.
+
 ## Light flickering
 
 To stop light from flickering in a fog volume, change the following properties: 
@@ -27,3 +28,35 @@ To stop light from flickering in a fog volume, change the following properties:
 - **Volumetric Fog Distance**: Set this value between the **Distance Fade Start** and **Distance Fade End** values set in the Local Volumetric Fog component. This makes the fog fade out at the same point as its maximum distance, which reduces light flickering in the distant areas of the fog volume.
 - **Radius**: Increase this value in the [Light](Light-Component.md) component. This lowers the intensity of the light source which makes flickering artifacts less visible.
 
+## Optimize fog performance
+
+How to optimize volumetric fog depends on the content of your scene and the quality you want. For more information about fog properties, refer to [Fog Volume Override reference](fog-volume-override-reference.md) and [Local Volumetric Fog Volume reference](local-volumetric-fog-volume-reference.md).
+
+To make sure all parameters are visible in the **Inspector** window, follow these steps in each Local Volumetric Fog Volume:
+
+1. Set **Quality** to **Custom**.
+2. Set **Fog Control Mode** to **Manual**.
+3. At the top of the **Fog** component, open the **More** (⋮) menu and enable **Advanced Properties**.
+
+Try adjusting the following properties:
+
+- Decrease the **Distance** parameter to reduce the number of fog slices HDRP renders. For long-distance fog, adjust the **Slice Distribution Uniformity** and **Slice Count** instead.
+- Decrease **Volume Slice Count** to reduce the number of fog slices along the camera's forward axis, to reduce GPU and memory usage. Or increase **Volume Slice Count** and reduce **Slice Distribution Uniformity** to focus more slices further from the camera.
+- Set the near and far clipping planes of the camera, to avoid fog rendering too close to the camera. This is particularly important in scenarios such as top-down views, where there may be a significant distance between the camera and the first visible fog or objects.
+- Set **Denoising Mode** to **Gaussian** instead of **Reprojection**, so the fog uses less memory.
+- Reduce the **Screen Resolution Percentage** value to a low value, to limit how much memory and computation fog uses, especially if you have highly diffuse fog.
+- Enable **Directional Lights Only**, especially if you have a large or outdoor scene where only sunlight should contribute to volumetric effects.
+
+### Skip lighting calculations in areas with low-density fog
+
+To skip lighting calculations for areas where the fog density is below a certain threshold, use the **Volumetric Lighting Density Cutoff** property.
+
+This property can improve performance if you use [Local Volumetric Fog Volumes](local-volumetric-fog-volume-reference.md). It doesn't affect scenes with constant or height-based fog because all areas have the same density.
+
+Follow these steps:
+
+1. To remove global fog from the scene, set a very high **Fog Attenuation Distance**.
+2. Add Local Volumetric Fog Volumes where you want fog to appear.
+3. Increase the **Volumetric Lighting Density Cutoff** gradually, until important fog features begin to disappear.
+
+**Note**: This property doesn't take into account changes applied by the **Anisotropy** property. The visibility of fog might not correspond directly to the **Volumetric Lighting Density Cutoff** value in scenes with a lot of anisotropic scattering.

Packages/com.unity.render-pipelines.high-definition/Documentation~/troubleshoot-fog.md

@@ -23,6 +23,7 @@ class FogEditor : VolumeComponentWithQualityEditor
 
         protected SerializedDataParameter m_EnableVolumetricFog;
         protected SerializedDataParameter m_Anisotropy;
+        protected SerializedDataParameter m_VolumetricLightingDensityCutoff;
         protected SerializedDataParameter m_MultipleScatteringIntensity;
         protected SerializedDataParameter m_DepthExtent;
         protected SerializedDataParameter m_GlobalLightProbeDimmer;
@@ -63,6 +64,7 @@ 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_VolumetricLightingDensityCutoff = Unpack(o.Find(x => x.volumetricLightingDensityCutoff));
             m_MultipleScatteringIntensity = Unpack(o.Find(x => x.multipleScatteringIntensity));
             m_GlobalLightProbeDimmer = Unpack(o.Find(x => x.globalLightProbeDimmer));
 
@@ -173,6 +175,15 @@ public override void OnInspectorGUI()
                         EndAdditionalPropertiesScope();
                     }
 
+                    PropertyField(m_VolumetricLightingDensityCutoff);
+                    if (m_VolumetricLightingDensityCutoff.value.floatValue > 0.0f)
+                    {
+                        using (new IndentLevelScope())
+                        {
+                            float currentMinExtinction = VolumeRenderingUtils.ExtinctionFromMeanFreePath(m_MeanFreePath.value.floatValue);
+                            EditorGUILayout.HelpBox($"The current minimum density for the fog is {currentMinExtinction:F3} (calculated from the Fog Distance).", MessageType.Info, wide: true);
+                        }
+                    }
                 }
             }
             PropertyField(m_MultipleScatteringIntensity);

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

@@ -157,6 +157,10 @@ public float resolutionDepthRatio
         [Tooltip("When enabled, HDRP only includes directional Lights when it evaluates volumetric fog.")]
         public BoolParameter directionalLightsOnly = new BoolParameter(false);
 
+        /// <summary>Indicates at which fog density the lighting should be ignored. Every voxel containing less fog density than this value will be ignored by the volumetric lighting.</summary>
+        [Tooltip("Improves performance by skipping the lighting evaluation in areas with low-density fog. When the value is above 0, HDRP skips calculating volumetric lighting in areas where the fog density is below this value.")]
+        public FloatParameter volumetricLightingDensityCutoff = new(0.0f);
+
         internal static bool IsFogEnabled(HDCamera hdCamera)
         {
             return hdCamera.frameSettings.IsEnabled(FrameSettingsField.AtmosphericScattering) && hdCamera.volumeStack.GetComponent<Fog>().enabled.value;
@@ -177,7 +181,7 @@ internal static bool IsVolumetricFogEnabled(HDCamera hdCamera)
         internal static bool IsVolumetricReprojectionEnabled(HDCamera hdCamera)
         {
             var fog = hdCamera.volumeStack.GetComponent<Fog>();
- 
+
             return (fog.denoisingMode.value & FogDenoisingMode.Reprojection) != 0;
         }
 

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

@@ -85,7 +85,7 @@ unsafe struct ShaderVariablesVolumetric
         public uint _VolumeCount;
         public uint _IsObliqueProjectionMatrix;
         public float _HalfVoxelArcLength;
-        public uint _Padding2;
+        public float _VolumetricLightingExtinctionCutoff;
     }
 
     /// <summary>Falloff mode for the local volumetric fog blend distance.</summary>
@@ -997,6 +997,7 @@ unsafe void UpdateShaderVariableslVolumetrics(ref ShaderVariablesVolumetric cb,
             // Compute the arc length of a single froxel at 1m from the camera.
             // This value can be used to quickly compute the arc length of a single froxel
             cb._HalfVoxelArcLength = Mathf.Deg2Rad * hdCamera.camera.fieldOfView / currParams.viewportSize.y / 2.0f;
+            cb._VolumetricLightingExtinctionCutoff = fog.volumetricLightingDensityCutoff.value;
 
             if (updateVoxelizationFields)
             {

Packages/com.unity.render-pipelines.high-definition/Runtime/Lighting/VolumetricLighting/HDRenderPipeline.VolumetricLighting.cs

@@ -62,7 +62,7 @@ CBUFFER_START(ShaderVariablesVolumetric)
     uint _VolumeCount;
     uint _IsObliqueProjectionMatrix;
     float _HalfVoxelArcLength;
-    uint _Padding2;
+    float _VolumetricLightingExtinctionCutoff;
 CBUFFER_END
 
 // Generated from UnityEngine.Rendering.HighDefinition.VolumetricMaterialDataCBuffer