Add a Volumetric Dimmer slider to lights to control the intensity of the scattered volumetric lighting

ScriptableRenderPipeline/HDRenderPipeline/CHANGELOG.md

 - Configure the volumetric lighting code path to be on by default
 - Trigger a build exception when trying to build an unsupported platform
 - Introduce the VolumetricLightingController component, which can (and should) be placed on the camera, and allows one to control the near and the far plane of the V-Buffer (volumetric "froxel" buffer) along with the depth distribution (from logarithmic to linear)
+- Add a Volumetric Dimmer slider to lights to control the intensity of the scattered volumetric lighting
 
 ### Changed, Removals and deprecations
 - Remove Resource folder of PreIntegratedFGD and add the resource to RenderPipeline Asset

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Lighting/HDLightEditor.Styles.cs

-using System;
+using System;
 using System.Linq;
 using UnityEngine;
 
             public readonly GUIContent affectDiffuse = new GUIContent("Affect Diffuse", "This will disable diffuse lighting for this light. Doesn't save performance, diffuse lighting is still computed.");
             public readonly GUIContent affectSpecular = new GUIContent("Affect Specular", "This will disable specular lighting for this light. Doesn't save performance, specular lighting is still computed.");
             public readonly GUIContent lightDimmer = new GUIContent("Dimmer", "Aim to be used with script, timeline or animation. It allows dimming one or multiple lights of heterogeneous intensity easily (without needing to know the intensity of each light).");
+            public readonly GUIContent volumetricDimmer = new GUIContent("Volumetric Dimmer", "Allows to reduce the intensity of the scattered volumetric lighting.");
             public readonly GUIContent fadeDistance = new GUIContent("Fade Distance", "The distance at which the light will smoothly fade before being culled to minimize popping.");
             public readonly GUIContent spotInnerPercent = new GUIContent("Inner Percent", "Controls size of the angular attenuation in percent of the base angle of the Spot light's cone.");
             public readonly GUIContent spotLightShape = new GUIContent("Shape", "The shape use for the spotlight. Has an impact on the cookie transformation and light angular attenuation.");

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Lighting/HDLightEditor.cs

             public SerializedProperty shapeRadius;
             public SerializedProperty maxSmoothness;
             public SerializedProperty applyRangeAttenuation;
+            public SerializedProperty volumetricDimmer;
 
             // Editor stuff
             public SerializedProperty useOldInspector;
                 enableSpotReflector = o.Find(x => x.enableSpotReflector),
                 spotInnerPercent = o.Find(x => x.m_InnerSpotPercent),
                 lightDimmer = o.Find(x => x.lightDimmer),
+                volumetricDimmer = o.Find(x => x.volumetricDimmer),
-                spotLightShape = o.Find(x => x.spotLightShape),              
+                spotLightShape = o.Find(x => x.spotLightShape),
                 shapeWidth = o.Find(x => x.shapeWidth),
                 shapeHeight = o.Find(x => x.shapeHeight),
                 aspectRatio = o.Find(x => x.aspectRatio),
                 EditorGUILayout.PropertyField(m_AdditionalLightData.affectSpecular, s_Styles.affectSpecular);
                 EditorGUILayout.PropertyField(m_AdditionalLightData.fadeDistance, s_Styles.fadeDistance);
                 EditorGUILayout.PropertyField(m_AdditionalLightData.lightDimmer, s_Styles.lightDimmer);
+                EditorGUILayout.PropertyField(m_AdditionalLightData.volumetricDimmer, s_Styles.volumetricDimmer);
                 EditorGUILayout.PropertyField(m_AdditionalLightData.applyRangeAttenuation, s_Styles.applyRangeAttenuation);
                 EditorGUI.indentLevel--;
             }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/Light/HDAdditionalLightData.cs

         [Range(0.0f, 1.0f)]
         public float lightDimmer = 1.0f;
 
+        [Range(0.0f, 1.0f)]
+        public float volumetricDimmer = 1.0f;
+
         // Not used for directional lights.
         public float fadeDistance = 10000.0f;
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightDefinition.cs

         public int dynamicShadowCasterOnly; // Use with ShadowMask feature // TODO: make it a bool
 
         public Vector4 shadowMaskSelector; // Use with ShadowMask feature
+
+        public float volumetricDimmer; // TODO: improve the cache locality
     };
 
     [GenerateHLSL]
         public Vector2 size;        // Used by area (X = length or width, Y = height) and box projector lights (X = range (depth))
         public GPULightType lightType;
         public float minRoughness;  // This is use to give a small "area" to punctual light, as if we have a light with a radius.
+
+        public float volumetricDimmer; // TODO: improve the cache locality
     };
 
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightDefinition.cs.hlsl

     float unused0;
     int dynamicShadowCasterOnly;
     float4 shadowMaskSelector;
+    float volumetricDimmer;
 };
 
 // Generated from UnityEngine.Experimental.Rendering.HDPipeline.LightData
     float2 size;
     int lightType;
     float minRoughness;
+    float volumetricDimmer;
 };
 
 // Generated from UnityEngine.Experimental.Rendering.HDPipeline.EnvLightData
 {
 	return value.shadowMaskSelector;
 }
+float GetVolumetricDimmer(DirectionalLightData value)
+{
+	return value.volumetricDimmer;
+}
 
 //
 // Accessors for UnityEngine.Experimental.Rendering.HDPipeline.LightData
 float GetMinRoughness(LightData value)
 {
 	return value.minRoughness;
+}
+float GetVolumetricDimmer(LightData value)
+{
+	return value.volumetricDimmer;
 }
 
 //

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightLoop/LightLoop.cs

             lightData.diffuseScale = additionalLightData.affectDiffuse ? lightScale * m_FrameSettings.diffuseGlobalDimmer : 0.0f;
             lightData.specularScale = additionalLightData.affectSpecular ? lightScale * m_FrameSettings.specularGlobalDimmer : 0.0f;
 
+            lightData.volumetricDimmer = additionalLightData.volumetricDimmer;
+
             if (lightData.diffuseScale <= 0.0f && lightData.specularScale <= 0.0f)
                 return false;
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/Volumetrics/VolumetricLighting.compute

             float phase    = CornetteShanksPhasePartVarying(anisotropy, cosTheta);
 
             // Note: the 'weight' accounts for transmittance from 't0' to 't'.
-            float intensity = attenuation * weight;
+            float intensity = light.volumetricDimmer * attenuation * weight;
 
             // Compute the amount of in-scattered radiance.
             lighting.radianceNoPhase  += intensity * color;
                     float  cosTheta = dot(centerL, ray.centerDirWS) * rsqrt(dot(centerL, centerL));
                     float  phase    = CornetteShanksPhasePartVarying(anisotropy, cosTheta);
 
-                    float intensity = attenuation * rcpPdf;
+                    float intensity = light.volumetricDimmer * attenuation * rcpPdf;
 
                     // Compute transmittance from 't0' to 't'.
                     intensity *= TransmittanceHomogeneousMedium(extinction, t - t0);
                     float  phase    = CornetteShanksPhasePartVarying(anisotropy, cosTheta);
 
                     // Note: the 'weight' accounts for transmittance from 'tEntr' to 't'.
-                    float intensity = attenuation * weight;
+                    float intensity = light.volumetricDimmer * attenuation * weight;
 
                     // Compute transmittance from 't0' to 'tEntr'.
                     intensity *= TransmittanceHomogeneousMedium(extinction, tEntr - t0);