Switch to the volume system WIP

ScriptableRenderPipeline/HDRenderPipeline/HDRP/HDStringConstants.cs

         public static readonly int _Source4 = Shader.PropertyToID("_Source4");
         public static readonly int _Result1 = Shader.PropertyToID("_Result1");
 
+        public static readonly int _AtmosphericScatteringType  = Shader.PropertyToID("_AtmosphericScatteringType");
         public static readonly int _AmbientProbeCoeffs         = Shader.PropertyToID("_AmbientProbeCoeffs");
         public static readonly int _GlobalExtinction           = Shader.PropertyToID("_GlobalExtinction");
         public static readonly int _GlobalScattering           = Shader.PropertyToID("_GlobalScattering");

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

 {
     public Vector3 scattering; // [0, 1], prefer sRGB
     public float   extinction; // [0, 1], prefer sRGB
+    public float   asymmetry;  // [-1, 1], linear, global parameter
 
     public static DensityVolumeProperties GetNeutralProperties()
     {
         properties.extinction = 0;
+        properties.asymmetry  = 0;
 
         return properties;
     }
         DensityVolumeProperties globalVolumeProperties = (globalVolume != null) ? globalVolume.parameters.GetProperties()
                                                                                 : DensityVolumeProperties.GetNeutralProperties();
 
-        float asymmetry = globalVolume != null ? globalVolume.parameters.asymmetry : 0;
-        cmd.SetGlobalFloat( HDShaderIDs._GlobalAsymmetry,  asymmetry);
+        cmd.SetGlobalFloat( HDShaderIDs._GlobalAsymmetry,  globalVolumeProperties.asymmetry);
 
         VBuffer vBuffer = FindVBuffer(camera.GetViewID());
         Debug.Assert(vBuffer != null);
 
-        SetPreconvolvedAmbientLightProbe(cmd, asymmetry);
+        SetPreconvolvedAmbientLightProbe(cmd, globalVolumeProperties.asymmetry);
+
         cmd.SetGlobalVector( HDShaderIDs._VBufferResolution,          new Vector4(w, h, 1.0f / w, 1.0f / h));
         cmd.SetGlobalVector( HDShaderIDs._VBufferSliceCount,          new Vector4(d, 1.0f / d));
         cmd.SetGlobalVector( HDShaderIDs._VBufferDepthEncodingParams, ComputeLogarithmicDepthEncodingParams(m_VBufferNearPlane, m_VBufferFarPlane, k_LogScale));

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

-using System;
+using System;
 using System.Diagnostics;
 using UnityEngine.Rendering;
 
     public abstract class AtmosphericScattering : VolumeComponent
     {
-        static readonly int m_TypeParam = Shader.PropertyToID("_AtmosphericScatteringType");
         // Fog Color
         static readonly int m_ColorModeParam = Shader.PropertyToID("_FogColorMode");
         static readonly int m_FogColorDensityParam = Shader.PropertyToID("_FogColorDensity");
 
         public static void PushNeutralShaderParameters(CommandBuffer cmd)
         {
-            cmd.SetGlobalFloat(m_TypeParam, (float)FogType.None);
+            cmd.SetGlobalInt(HDShaderIDs._AtmosphericScatteringType, (int)FogType.None);
+
+            // In case volumetric lighting is enabled, we need to make sure that all rendering passes
+            // (not just the atmospheric scattering one) receive neutral parameters.
+            if (ShaderConfig.s_VolumetricLightingPreset != 0)
+            {
+                var properties = DensityVolumeProperties.GetNeutralProperties();
+
+                cmd.SetGlobalVector(HDShaderIDs._GlobalScattering, properties.scattering);
+                cmd.SetGlobalFloat( HDShaderIDs._GlobalExtinction, properties.extinction);
+                cmd.SetGlobalFloat( HDShaderIDs._GlobalAsymmetry,  properties.asymmetry);
+            }
+        // Not used by the volumetric fog.
-            if (frameSettings.enableAtmosphericScattering)
-                cmd.SetGlobalFloat(m_TypeParam, (float)type);
-            else
-                cmd.SetGlobalFloat(m_TypeParam, (float)FogType.None);
+            Debug.Assert(frameSettings.enableAtmosphericScattering);
+
+            cmd.SetGlobalInt(HDShaderIDs._AtmosphericScatteringType, (int)type);
 
             // Fog Color
             cmd.SetGlobalFloat(m_ColorModeParam, (float)colorMode.value);
     {
         None,
         Linear,
-        Exponential
+        Exponential,
+        Volumetric
     }
 
     [GenerateHLSL]

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

 #define FOGTYPE_NONE (0)
 #define FOGTYPE_LINEAR (1)
 #define FOGTYPE_EXPONENTIAL (2)
+#define FOGTYPE_VOLUMETRIC (3)
 
 //
 // UnityEngine.Experimental.Rendering.HDPipeline.FogColorMode:  static fields

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Sky/AtmosphericScattering/AtmosphericScattering.hlsl

 #endif
 
 CBUFFER_START(AtmosphericScattering)
-float   _AtmosphericScatteringType;
+int     _AtmosphericScatteringType;
 // Common
 float   _FogColorMode;
 float4  _FogColorDensity; // color in rgb, density in alpha
 	float3 fogColor = 0;
 	float  fogFactor = 0;
 
-#if (SHADEROPTIONS_VOLUMETRIC_LIGHTING_PRESET != 0)
-	float4 volFog = SampleVolumetricLighting(TEXTURE3D_PARAM(_VBufferLighting, s_linear_clamp_sampler),
-											 posInput.positionNDC,
-											 posInput.linearDepth,
-											 _VBufferResolution,
-											 _VBufferSliceCount.xy,
-											 _VBufferDepthEncodingParams,
-											 _VBufferDepthDecodingParams,
-											 true, true);
-
-	fogFactor = 1 - volFog.a;                              // Opacity from transmittance
-	fogColor  = volFog.rgb * min(rcp(fogFactor), FLT_MAX); // Un-premultiply, clamp to avoid (0 * INF = NaN)
-#else
-
-	if (_AtmosphericScatteringType == FOGTYPE_EXPONENTIAL)
+	switch (_AtmosphericScatteringType)
-		fogColor = GetFogColor(posInput);
-		float distance = length(GetWorldSpaceViewDir(posInput.positionWS));
-		float fogHeight = max(0.0, GetAbsolutePositionWS(posInput.positionWS).y - _ExpFogBaseHeight);
-		fogFactor = _FogDensity * TransmittanceHomogeneousMedium(_ExpFogHeightAttenuation, fogHeight) * (1.0f - TransmittanceHomogeneousMedium(1.0f / _ExpFogDistance, distance));
-	}
-	else if (_AtmosphericScatteringType == FOGTYPE_LINEAR)
-	{
-		fogColor = GetFogColor(posInput);
-		fogFactor = _FogDensity * saturate((posInput.linearDepth - _LinearFogStart) * _LinearFogOneOverRange) * saturate((_LinearFogHeightEnd - GetAbsolutePositionWS(posInput.positionWS).y) * _LinearFogHeightOneOverRange);
-	}
-	else // NONE
-	{
+		case FOGTYPE_LINEAR:
+		{
+			fogColor = GetFogColor(posInput);
+			fogFactor = _FogDensity * saturate((posInput.linearDepth - _LinearFogStart) * _LinearFogOneOverRange) * saturate((_LinearFogHeightEnd - GetAbsolutePositionWS(posInput.positionWS).y) * _LinearFogHeightOneOverRange);
+			break;
+		}
+		case FOGTYPE_EXPONENTIAL:
+		{
+			fogColor = GetFogColor(posInput);
+			float distance = length(GetWorldSpaceViewDir(posInput.positionWS));
+			float fogHeight = max(0.0, GetAbsolutePositionWS(posInput.positionWS).y - _ExpFogBaseHeight);
+			fogFactor = _FogDensity * TransmittanceHomogeneousMedium(_ExpFogHeightAttenuation, fogHeight) * (1.0f - TransmittanceHomogeneousMedium(1.0f / _ExpFogDistance, distance));
+			break;
+		}
+		case FOGTYPE_VOLUMETRIC:
+		{
+		#if (SHADEROPTIONS_VOLUMETRIC_LIGHTING_PRESET != 0)
+			float4 volFog = SampleVolumetricLighting(TEXTURE3D_PARAM(_VBufferLighting, s_linear_clamp_sampler),
+													 posInput.positionNDC,
+													 posInput.linearDepth,
+													 _VBufferResolution,
+													 _VBufferSliceCount.xy,
+													 _VBufferDepthEncodingParams,
+													 _VBufferDepthDecodingParams,
+													 true, true);
+
+			fogFactor = 1 - volFog.a;                              // Opacity from transmittance
+			fogColor  = volFog.rgb * min(rcp(fogFactor), FLT_MAX); // Un-premultiply, clamp to avoid (0 * INF = NaN)
+		#endif
+			break;
+		}
-#endif
 
 	return float4(fogColor, fogFactor);
 }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Sky/VisualEnvironment.cs

-using System;
+using System;
 using System.Collections;
 using System.Collections.Generic;
 using UnityEngine;
 
         public void PushFogShaderParameters(CommandBuffer cmd, FrameSettings frameSettings)
         {
+            if (!frameSettings.enableAtmosphericScattering)
+            {
+                AtmosphericScattering.PushNeutralShaderParameters(cmd);
+                return;
+            }
+
             switch (fogType.value)
             {
                 case FogType.None:
                 case FogType.Exponential:
                     {
                         var fogSettings = VolumeManager.instance.stack.GetComponent<ExponentialFog>();
+                        fogSettings.PushShaderParameters(cmd, frameSettings);
+                        break;
+                    }
+                case FogType.Volumetric:
+                    {
+                        var fogSettings = VolumeManager.instance.stack.GetComponent<VolumetricFog>();
                         fogSettings.PushShaderParameters(cmd, frameSettings);
                         break;
                     }

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

+using System;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Rendering;
+
+namespace UnityEngine.Experimental.Rendering.HDPipeline
+{
+    public class VolumetricFog : AtmosphericScattering
+    {
+        private readonly static int m_ExpFogParam = Shader.PropertyToID("_ExpFogParameters");
+
+        public ColorParameter        albedo       = new ColorParameter(new Color(0.5f, 0.5f, 0.5f));
+
+        // Note: mean free path is a non-linear function of density.
+        // You want to interpolate the ExtinctionCoefficient = 1 / MeanFreePath.
+        public ClampedFloatParameter meanFreePath = new ClampedFloatParameter(10.0f, 0, 1000000);
+
+        public ClampedFloatParameter asymmetry    = new ClampedFloatParameter(0.0f, -1, 1);
+
+        public override void PushShaderParameters(CommandBuffer cmd, FrameSettings frameSettings)
+        {
+            cmd.SetGlobalInt(HDShaderIDs._AtmosphericScatteringType, (int)FogType.Volumetric);
+
+            // cmd.SetGlobalVector(HDShaderIDs._GlobalScattering, properties.scattering);
+            // cmd.SetGlobalFloat( HDShaderIDs._GlobalExtinction, properties.extinction);
+            // cmd.SetGlobalFloat( HDShaderIDs._GlobalAsymmetry,  properties.asymmetry);
+        }
+    }
+
+}

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

+fileFormatVersion: 2
+guid: 29b00527f85bb3346a4d2cb710971587
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: