Add more phase functions

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/VolumeRendering.hlsl

     return INV_FOUR_PI * (1 - g * g);
 }
 
-real HenyeyGreensteinPhasePartVarying(real asymmetry, real LdotD)
+real HenyeyGreensteinPhasePartVarying(real asymmetry, real cosTheta)
-    return pow(abs(1 + g * g - 2 * g * LdotD), -1.5);
+    return pow(abs(1 + g * g - 2 * g * cosTheta), -1.5);
-real HenyeyGreensteinPhaseFunction(real asymmetry, real LdotD)
+real HenyeyGreensteinPhaseFunction(real asymmetry, real cosTheta)
-           HenyeyGreensteinPhasePartVarying(asymmetry, LdotD);
+           HenyeyGreensteinPhasePartVarying(asymmetry, cosTheta);
+}
+
+real CornetteShanksPhasePartConstant(real asymmetry)
+{
+    real g = asymmetry;
+
+    return INV_FOUR_PI * 1.5 * (1 - g * g) / (2 + g * g);
+}
+
+real CornetteShanksPhasePartVarying(real asymmetry, real cosTheta)
+{
+    real g = asymmetry;
+
+    return (1 + cosTheta * cosTheta) * pow(abs(1 + g * g - 2 * g * cosTheta), -1.5);
+}
+
+// A better approximation of the Mie phase function.
+// Ref: Henyey–Greenstein and Mie phase functions in Monte Carlo radiative transfer computations
+real CornetteShanksPhaseFunction(real asymmetry, real cosTheta)
+{
+    return CornetteShanksPhasePartConstant(asymmetry) *
+           CornetteShanksPhasePartVarying(asymmetry, cosTheta);
 }
 
 // Samples the interval of homogeneous participating medium using the closed-form tracking approach

ScriptableRenderPipeline/HDRenderPipeline/HDRP/HDStringConstants.cs

 
         public static readonly int _GlobalFog_Extinction       = Shader.PropertyToID("_GlobalFog_Extinction");
         public static readonly int _GlobalFog_Scattering       = Shader.PropertyToID("_GlobalFog_Scattering");
+        public static readonly int _GlobalFog_Asymmetry        = Shader.PropertyToID("_GlobalFog_Asymmetry");
         public static readonly int _VBufferResolution          = Shader.PropertyToID("_VBufferResolution");
         public static readonly int _VBufferScaleAndSliceCount  = Shader.PropertyToID("_VBufferScaleAndSliceCount");
         public static readonly int _VBufferDepthEncodingParams = Shader.PropertyToID("_VBufferDepthEncodingParams");

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

 // Implementation
 //--------------------------------------------------------------------------------------------------
 
+#define HG 0
+
 struct Ray
 {
     float3 originWS;
 // Computes the light integral (in-scattered radiance) within the voxel.
 // Multiplication by the scattering coefficient and the phase function is performed outside.
 float3 EvaluateVoxelLighting(LightLoopContext context, uint featureFlags, PositionInputs posInput,
-                             Ray ray, float t0, float t1, float dt, float rndVal, float extinction
+                             Ray ray, float t0, float t1, float dt, float rndVal, float extinction, float asymmetry
                          #ifdef LIGHTLOOP_TILE_PASS
                            , uint clusterIndices[2], float clusterDepths[2])
                          #else
             EvaluateLight_Directional(context, posInput, light, unused, 0, L,
                                       color, attenuation);
 
+            float cosTheta = dot(L, ray.directionWS);
+        #if HG
+            float phase    = HenyeyGreensteinPhasePartVarying(asymmetry, cosTheta);
+        #else
+            float phase    = CornetteShanksPhasePartVarying(asymmetry, cosTheta);
+        #endif
+
-            float intensity = attenuation * weight;
+            float intensity = attenuation * (phase * weight);
 
             // Compute the amount of in-scattered radiance.
             voxelRadiance += intensity * color;
                         EvaluateLight_Punctual(context, posInput, light, unused, 0, L, lightToSample,
                                                distances, color, attenuation);
 
-                        float intensity = attenuation * rcpPdf;
+                        float cosTheta = dot(L, ray.directionWS);
+                    #if HG
+                        float phase    = HenyeyGreensteinPhasePartVarying(asymmetry, cosTheta);
+                    #else
+                        float phase    = CornetteShanksPhasePartVarying(asymmetry, cosTheta);
+                    #endif
+
+                        float intensity = attenuation * (phase * rcpPdf);
 
                         // Compute transmittance from 't0' to 't'.
                         intensity *= TransmittanceHomogeneousMedium(extinction, t - t0);
                         EvaluateLight_Punctual(context, posInput, light, unused, 0, L, lightToSample,
                                                distances, color, attenuation);
 
+                        float cosTheta = dot(L, ray.directionWS);
+                    #if HG
+                        float phase    = HenyeyGreensteinPhasePartVarying(asymmetry, cosTheta);
+                    #else
+                        float phase    = CornetteShanksPhasePartVarying(asymmetry, cosTheta);
+                    #endif
+
-                        float intensity = attenuation * weight;
+                        float intensity = attenuation * (phase * weight);
 
                         // Compute transmittance from 't0' to 'tEntr'.
                         intensity *= TransmittanceHomogeneousMedium(extinction, tEntr - t0);
         // TODO: piecewise linear.
         float3 scattering = _GlobalFog_Scattering;
         float  extinction = _GlobalFog_Extinction;
+        float  asymmetry  = _GlobalFog_Asymmetry;
         
         // TODO: define a function ComputeGlobalFogCoefficients(float3 centerWS),
         // which allows procedural definition of extinction and scattering.
     #endif
 
         float3 voxelRadiance = EvaluateVoxelLighting(context, featureFlags, posInput,
-                                                     ray, t0, t1, dt, rndVal, extinction
+                                                     ray, t0, t1, dt, rndVal, extinction, asymmetry
                                                 #ifdef LIGHTLOOP_TILE_PASS
                                                    , clusterIndices, clusterDepths);
                                                 #else
         // Compute the transmittance from the camera to 't0'.
         float transmittance = Transmittance(opticalDepth);
 
+    #if HG
+        float phase = HenyeyGreensteinPhasePartConstant(asymmetry);
+    #else
+        float phase = CornetteShanksPhasePartConstant(asymmetry);
+    #endif
+
-        totalRadiance += (transmittance * IsotropicPhaseFunction()) * scattering * blendedRadiance;
+        totalRadiance += (transmittance * phase) * scattering * blendedRadiance;
 
         // Compute the optical depth up to the center of the interval.
         opticalDepth += 0.5 * extinction * dt;

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

 
 namespace UnityEngine.Experimental.Rendering.HDPipeline
 {
-
 [GenerateHLSL]
 public struct VolumeProperties
 {
     public Bounds bounds;       // Position and dimensions in meters
     public Color  albedo;       // Single scattering albedo [0, 1]
     public float  meanFreePath; // In meters [1, inf]. Should be chromatic - this is an optimization!
+    public float  asymmetry;    // Single global parameter for all volumes. TODO: UX
 
     public VolumeParameters()
     {
+        asymmetry    = 0.0f;
     }
 
     public bool IsVolumeUnbounded()
         albedo.b = Mathf.Clamp01(albedo.b);
 
         meanFreePath = Mathf.Max(meanFreePath, 1.0f);
+
+        asymmetry = Mathf.Clamp(asymmetry, -1.0f, 1.0f);
     }
 
     public VolumeProperties GetProperties()
 
         cmd.SetGlobalVector(HDShaderIDs._GlobalFog_Scattering, globalFogProperties.scattering);
         cmd.SetGlobalFloat( HDShaderIDs._GlobalFog_Extinction, globalFogProperties.extinction);
+        cmd.SetGlobalFloat( HDShaderIDs._GlobalFog_Asymmetry,  globalFogComponent != null ? globalFogComponent.volumeParameters.asymmetry : 0);
 
         int w = 0, h = 0, d = 0;
         Vector2 scale = ComputeVBufferResolutionAndScale(preset, (int)camera.screenSize.x, (int)camera.screenSize.y, ref w, ref h, ref d);

ScriptableRenderPipeline/HDRenderPipeline/HDRP/ShaderVariables.hlsl

     float4 unity_ShadowColor;
     float2 _TaaFrameRotation; // {x = sin(_TaaFrameIndex * PI/2), y = cos(_TaaFrameIndex * PI/2), z = unused}
     uint   _TaaFrameIndex;    // [0, 7]
-    uint   _Align128;         // Pad for 128-bit alignment
-    // Volumetric lighting. Should be a struct in 'UnityPerFrame'.
-    // Unfortunately, structures inside constant buffers are not supported by Unity.
+    // Volumetric lighting.
+    float  _GlobalFog_Asymmetry;
     float3 _GlobalFog_Scattering;
     float  _GlobalFog_Extinction;
     float4 _VBufferResolution;          // { w, h, 1/w, 1/h }