Add framesettings support to volumetric

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Camera/HDCamera.cs

             s_Cleanup.Clear();
         }
 
-        // Look for any camera that hasn't been used in the last frame and remove them for the pool.
+        // Look for any camera that hasn't been used in the last frame and remove them from the pool.
         public static void CleanUnused()
         {
             int frameCheck = Time.frameCount - 1;

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/RenderLoopSettings/FrameSettingsUI.cs

             EditorGUILayout.PropertyField(p.enableSSAO, _.GetContent("Enable SSAO"));
             EditorGUILayout.PropertyField(p.enableSubsurfaceScattering, _.GetContent("Enable Subsurface Scattering"));
             EditorGUILayout.PropertyField(p.enableTransmission, _.GetContent("Enable Transmission"));
+            EditorGUILayout.PropertyField(p.enableVolumetric, _.GetContent("Enable Volumetric"));
             EditorGUILayout.PropertyField(p.enableShadow, _.GetContent("Enable Shadow"));
             EditorGUILayout.PropertyField(p.enableContactShadow, _.GetContent("Enable Contact Shadows"));
             EditorGUILayout.PropertyField(p.enableShadowMask, _.GetContent("Enable Shadow Masks"));

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/RenderLoopSettings/SerializedFrameSettings.cs

         public SerializedProperty enableSSAO;
         public SerializedProperty enableSubsurfaceScattering;
         public SerializedProperty enableTransmission;
+        public SerializedProperty enableVolumetric;
 
         public SerializedProperty diffuseGlobalDimmer;
         public SerializedProperty specularGlobalDimmer;
             enableSSAO = root.Find((FrameSettings d) => d.enableSSAO);
             enableSubsurfaceScattering = root.Find((FrameSettings d) => d.enableSubsurfaceScattering);
             enableTransmission = root.Find((FrameSettings d) => d.enableTransmission);
+            enableVolumetric = root.Find((FrameSettings d) => d.enableVolumetric);
             diffuseGlobalDimmer = root.Find((FrameSettings d) => d.diffuseGlobalDimmer);
             specularGlobalDimmer = root.Find((FrameSettings d) => d.specularGlobalDimmer);
             enableForwardRenderingOnly = root.Find((FrameSettings d) => d.enableForwardRenderingOnly);

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

 {
     public enum VolumetricLightingPreset
     {
-        Off,
         Normal,
         Ultra,
         Count
     RTHandleSystem.RTHandle m_DensityBufferHandle;
     RTHandleSystem.RTHandle m_LightingBufferHandle;
 
+    // Do we support volumetric or not?
+    bool m_supportVolumetric = false;
+
-        if (preset == VolumetricLightingPreset.Off) return;
+        m_supportVolumetric = asset.renderPipelineSettings.supportVolumetric;
+
+        if (!m_supportVolumetric)
+            return;
 
         m_VolumeVoxelizationCS = asset.renderPipelineResources.volumeVoxelizationCS;
         m_VolumetricLightingCS = asset.renderPipelineResources.volumetricLightingCS;
 
     public void InitializePerCameraData(HDCamera hdCamera)
     {
-        if (preset == VolumetricLightingPreset.Off) return;
+        // Note: Here we can't test framesettings as they are not initialize yet
+        // TODO: Here we allocate history even for camera that may not use volumetric
+        if (!m_supportVolumetric)
+            return;
 
         // Start with the same parameters for both frames. Then update them one by one every frame.
         var parameters          = ComputeVBufferParameters(hdCamera, true);
     // The results are undefined otherwise.
     public void UpdatePerCameraData(HDCamera hdCamera)
     {
-        if (preset == VolumetricLightingPreset.Off) return;
+        if (!hdCamera.frameSettings.enableVolumetric)
+            return;
 
         var parameters = ComputeVBufferParameters(hdCamera, false);
 
 
     void DestroyBuffers()
     {
-        RTHandles.Release(m_DensityBufferHandle);
-        RTHandles.Release(m_LightingBufferHandle);
+        if (m_DensityBufferHandle != null)
+            RTHandles.Release(m_DensityBufferHandle);
+        if (m_LightingBufferHandle != null)
+            RTHandles.Release(m_LightingBufferHandle);
 
         CoreUtils.SafeRelease(s_VisibleVolumeBoundsBuffer);
         CoreUtils.SafeRelease(s_VisibleVolumeDataBuffer);
 
     public void Cleanup()
     {
-        if (preset == VolumetricLightingPreset.Off) return;
-
+        // Note: No need to test for support volumetric here, we do saferelease and null assignation
         DestroyBuffers();
 
         m_VolumeVoxelizationCS = null;
                 return 8;
             case VolumetricLightingPreset.Ultra:
                 return 4;
-            case VolumetricLightingPreset.Off:
-                return 0;
             default:
                 Debug.Assert(false, "Encountered an unexpected VolumetricLightingPreset.");
                 return 0;
                 return 64;
             case VolumetricLightingPreset.Ultra:
                 return 128;
-            case VolumetricLightingPreset.Off:
-                return 0;
             default:
                 Debug.Assert(false, "Encountered an unexpected VolumetricLightingPreset.");
                 return 0;
 
     public void PushGlobalParams(HDCamera hdCamera, CommandBuffer cmd, uint frameIndex)
     {
-        if (preset == VolumetricLightingPreset.Off) return;
+        if (!hdCamera.frameSettings.enableVolumetric)
+            return;
 
         var visualEnvironment = VolumeManager.instance.stack.GetComponent<VisualEnvironment>();
 
     {
         DensityVolumeList densityVolumes = new DensityVolumeList();
 
-        if (preset == VolumetricLightingPreset.Off) return densityVolumes;
+        if (!hdCamera.frameSettings.enableVolumetric)
+            return densityVolumes;
 
         var visualEnvironment = VolumeManager.instance.stack.GetComponent<VisualEnvironment>();
         if (visualEnvironment.fogType != FogType.Volumetric) return densityVolumes;
 
     public void VolumeVoxelizationPass(HDCamera hdCamera, CommandBuffer cmd, uint frameIndex, DensityVolumeList densityVolumes)
     {
-        if (preset == VolumetricLightingPreset.Off) return;
+        if (!hdCamera.frameSettings.enableVolumetric)
+            return;
 
         var visualEnvironment = VolumeManager.instance.stack.GetComponent<VisualEnvironment>();
         if (visualEnvironment.fogType != FogType.Volumetric) return;
 
     public void VolumetricLightingPass(HDCamera hdCamera, CommandBuffer cmd, uint frameIndex)
     {
-        if (preset == VolumetricLightingPreset.Off) return;
+        if (!hdCamera.frameSettings.enableVolumetric)
+            return;
-        if (visualEnvironment.fogType != FogType.Volumetric) return;
+        if (visualEnvironment.fogType != FogType.Volumetric)
+            return;
 
         using (new ProfilingSample(cmd, "Volumetric Lighting"))
         {

ScriptableRenderPipeline/HDRenderPipeline/HDRP/RenderPipeline/FrameSettings.cs

             frameSettings.enableSSAO = this.enableSSAO;
             frameSettings.enableSubsurfaceScattering = this.enableSubsurfaceScattering;
             frameSettings.enableTransmission = this.enableTransmission;
+            frameSettings.enableVolumetric = this.enableVolumetric;
 
             frameSettings.diffuseGlobalDimmer = this.diffuseGlobalDimmer;
             frameSettings.specularGlobalDimmer = this.specularGlobalDimmer;
                         new DebugUI.BoolField { displayName = "Enable SSAO", getter = () => frameSettings.enableSSAO, setter = value => frameSettings.enableSSAO = value },
                         new DebugUI.BoolField { displayName = "Enable SubsurfaceScattering", getter = () => frameSettings.enableSubsurfaceScattering, setter = value => frameSettings.enableSubsurfaceScattering = value },
                         new DebugUI.BoolField { displayName = "Enable Transmission", getter = () => frameSettings.enableTransmission, setter = value => frameSettings.enableTransmission = value },
+                        new DebugUI.BoolField { displayName = "Enable volumetric", getter = () => frameSettings.enableVolumetric, setter = value => frameSettings.enableVolumetric = value },
                         new DebugUI.BoolField { displayName = "Enable Shadows", getter = () => frameSettings.enableShadow, setter = value => frameSettings.enableShadow = value },
                         new DebugUI.BoolField { displayName = "Enable Contact Shadows", getter = () => frameSettings.enableContactShadows, setter = value => frameSettings.enableContactShadows = value },
                         new DebugUI.BoolField { displayName = "Enable ShadowMask", getter = () => frameSettings.enableShadowMask, setter = value => frameSettings.enableShadowMask = value },

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Sky/AtmosphericScattering/AtmosphericScattering.cs

 
         public abstract void PushShaderParameters(HDCamera hdCamera, CommandBuffer cmd);
 
-        public static void PushNeutralShaderParameters(CommandBuffer cmd)
+        public static void PushNeutralShaderParameters(HDCamera hdCamera, CommandBuffer cmd)
-            if (ShaderConfig.s_VolumetricLightingPreset != 0)
+            if (hdCamera.frameSettings.enableVolumetric)
             {
                 var data = DensityVolumeData.GetNeutralValues();
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Sky/VisualEnvironment.cs

         {
             if (!hdCamera.frameSettings.enableAtmosphericScattering)
             {
-                AtmosphericScattering.PushNeutralShaderParameters(cmd);
+                AtmosphericScattering.PushNeutralShaderParameters(hdCamera, cmd);
                 return;
             }
 
                     {
-                        AtmosphericScattering.PushNeutralShaderParameters(cmd);
+                        AtmosphericScattering.PushNeutralShaderParameters(hdCamera, cmd);
                         break;
                     }
                 case FogType.Linear: