Merge pull request #1255 from EvgeniiG/master

Enable volumetrics by default (+ bugfixes)

ScriptableRenderPipeline/HDRenderPipeline/HDRP/HDRenderPipeline.cs

 
             m_SkyManager.RenderSky(hdCamera, m_LightLoop.GetCurrentSunLight(), m_CameraColorBuffer, m_CameraDepthStencilBuffer, m_CurrentDebugDisplaySettings, cmd);
 
-            if (visualEnv.fogType != FogType.None || m_VolumetricLightingSystem.preset != VolumetricLightingSystem.VolumetricLightingPreset.Off)
+            if (visualEnv.fogType != FogType.None)
                 m_SkyManager.RenderOpaqueAtmosphericScattering(cmd);
         }
 

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

-using System;
+using System;
 using System.Collections.Generic;
 using UnityEngine.Experimental.Rendering.HDPipeline.Internal;
 using UnityEngine.Rendering;
 
                 var stereoEnabled = m_FrameSettings.enableStereo;
 
+                Vector3 camPosWS = camera.transform.position;
+
+                var worldToView = WorldToCamera(camera);
+                var rightEyeWorldToView = Matrix4x4.identity;
+                if (stereoEnabled)
+                {
+                    worldToView = WorldToViewStereo(camera, Camera.StereoscopicEye.Left);
+                    rightEyeWorldToView = WorldToViewStereo(camera, Camera.StereoscopicEye.Right);
+                }
+
                 // Note: Light with null intensity/Color are culled by the C++, no need to test it here
                 if (cullResults.visibleLights.Count != 0 || cullResults.visibleReflectionProbes.Count != 0)
                 {
 
                     // 2. Go through all lights, convert them to GPU format.
                     // Simultaneously create data for culling (LightVolumeData and SFiniteLightBound)
-                    Vector3 camPosWS = camera.transform.position;
-
-                    var worldToView = WorldToCamera(camera);
-                    var rightEyeWorldToView = Matrix4x4.identity;
-                    if (stereoEnabled)
-                    {
-                        worldToView = WorldToViewStereo(camera, Camera.StereoscopicEye.Left);
-                        rightEyeWorldToView = WorldToViewStereo(camera, Camera.StereoscopicEye.Right);
-                    }
 
                     for (int sortIndex = 0; sortIndex < sortCount; ++sortIndex)
                     {
                         }
                     }
 
-                    // Inject density volumes into the clustered data structure for efficient look up.
-                    m_densityVolumeCount = densityVolumes.bounds != null ? densityVolumes.bounds.Count : 0;
-
-                    Matrix4x4 worldToViewCR = worldToView;
-
-                    if (ShaderConfig.s_CameraRelativeRendering != 0)
-                    {
-                        // The OBBs are camera-relative, the matrix is not. Fix it.
-                        worldToViewCR.SetColumn(3, new Vector4(0, 0, 0, 1));
-                    }
-
-                    for (int i = 0, n = m_densityVolumeCount; i < n; i++)
-                    {
-                        // Density volumes are not lights and therefore should not affect light classification.
-                        LightFeatureFlags featureFlags = 0;
-                        AddBoxVolumeDataAndBound(densityVolumes.bounds[i], LightCategory.DensityVolume, featureFlags, worldToViewCR);
-                    }
-
-                m_lightCount = m_lightList.lights.Count + m_lightList.envLights.Count + m_densityVolumeCount;
-                Debug.Assert(m_lightCount == m_lightList.bounds.Count);
-                Debug.Assert(m_lightCount == m_lightList.lightVolumes.Count);
 
                 int decalDatasCount = Math.Min(DecalSystem.m_DecalDatasCount, k_MaxDecalsOnScreen);
                 if (decalDatasCount > 0)
                     }
                     m_lightCount += decalDatasCount;
                 }
+
+                // Inject density volumes into the clustered data structure for efficient look up.
+                m_densityVolumeCount = densityVolumes.bounds != null ? densityVolumes.bounds.Count : 0;
+
+                Matrix4x4 worldToViewCR = worldToView;
+
+                if (ShaderConfig.s_CameraRelativeRendering != 0)
+                {
+                    // The OBBs are camera-relative, the matrix is not. Fix it.
+                    worldToViewCR.SetColumn(3, new Vector4(0, 0, 0, 1));
+                }
+
+                for (int i = 0, n = m_densityVolumeCount; i < n; i++)
+                {
+                    // Density volumes are not lights and therefore should not affect light classification.
+                    LightFeatureFlags featureFlags = 0;
+                    AddBoxVolumeDataAndBound(densityVolumes.bounds[i], LightCategory.DensityVolume, featureFlags, worldToViewCR);
+                }
+
+                m_lightCount = m_lightList.lights.Count + m_lightList.envLights.Count + m_densityVolumeCount + decalDatasCount;
+                Debug.Assert(m_lightCount == m_lightList.bounds.Count);
+                Debug.Assert(m_lightCount == m_lightList.lightVolumes.Count);
 
                 if (stereoEnabled)
                 {

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

         // Store the feedback for the voxel.
         // TODO: dynamic lights (which update their position, rotation, cookie or shadow at runtime)
         // do not support reprojection and should neither read nor write to the history buffer.
-        // to the history buffer. This will cause them to alias, but it is the only way
-        // to prevent ghosting.
+        // This will cause them to alias, but it is the only way to prevent ghosting.
 
         _VBufferLightingFeedback[voxelCoord] = float4(blendedRadiance, centerTransmInt);
 

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

     public void ResizeVBuffer(HDCamera camera, int screenWidth, int screenHeight)
     {
         if (preset == VolumetricLightingPreset.Off) return;
+        var visualEnvironment = VolumeManager.instance.stack.GetComponent<VisualEnvironment>();
+        if (visualEnvironment == null || visualEnvironment.fogType != FogType.Volumetric) return;
 
         long viewID = camera.GetViewID();
 
     public void PushGlobalParams(HDCamera camera, CommandBuffer cmd)
     {
         if (preset == VolumetricLightingPreset.Off) return;
+        var visualEnvironment = VolumeManager.instance.stack.GetComponent<VisualEnvironment>();
+        if (visualEnvironment == null || visualEnvironment.fogType != FogType.Volumetric) return;
 
         // Modify the near plane.
         // Warning: it can screw up the reprojection. However, we have to do it in order for clustered lighting to work correctly.
         DensityVolumeList densityVolumes = new DensityVolumeList();
 
         if (preset == VolumetricLightingPreset.Off) return densityVolumes;
-
-
-        if (visualEnvironment.fogType != FogType.Volumetric) return densityVolumes;
+        if (visualEnvironment == null || visualEnvironment.fogType != FogType.Volumetric) return densityVolumes;
 
         using (new ProfilingSample(cmd, "Prepare Visible Density Volume List"))
         {
     public void VolumeVoxelizationPass(DensityVolumeList densityVolumes, HDCamera camera, CommandBuffer cmd, FrameSettings settings)
     {
         if (preset == VolumetricLightingPreset.Off) return;
+        var visualEnvironment = VolumeManager.instance.stack.GetComponent<VisualEnvironment>();
+        if (visualEnvironment == null || visualEnvironment.fogType != FogType.Volumetric) return;
 
         using (new ProfilingSample(cmd, "Volume Voxelization"))
         {
             {
                 // Clear the render target instead of running the shader.
+                // Note: the clear must take the global fog into account!
-                // Use the workaround by running the full shader with 0 density.
+                // Use the workaround by running the full shader with 0 density
             }
 
             VBuffer vBuffer = FindVBuffer(camera.GetViewID());
     public void VolumetricLightingPass(HDCamera camera, CommandBuffer cmd, FrameSettings settings)
     {
         if (preset == VolumetricLightingPreset.Off) return;
+        var visualEnvironment = VolumeManager.instance.stack.GetComponent<VisualEnvironment>();
+        if (visualEnvironment == null || visualEnvironment.fogType != FogType.Volumetric) return;
-            var visualEnvironment = VolumeManager.instance.stack.GetComponent<VisualEnvironment>();
-
-            if (visualEnvironment.fogType != FogType.Volumetric)
-            {
-                // Clear the render target instead of running the shader.
-                // CoreUtils.SetRenderTarget(cmd, vBuffer.GetDensityBuffer(), ClearFlag.Color, CoreUtils.clearColorAllBlack);
-                // return;
-
-                // Clearing 3D textures does not seem to work!
-                // Use the workaround by running the full shader with 0 density.
-            }
-
             VBuffer vBuffer = FindVBuffer(camera.GetViewID());
             Debug.Assert(vBuffer != null);
 
 
             int rfc = Time.renderedFrameCount;
             int sampleIndex = rfc % 7;
+
+            // TODO: should we somehow reorder offsets in Z based on the offset in XY? S.t. the samples more evenly cover the domain.
+            // Currently, we assume that they are completely uncorrelated, but maybe we should correlate them somehow.
             Vector4 offset = new Vector4(xySeq[sampleIndex].x, xySeq[sampleIndex].y, zSeq[sampleIndex], rfc);
 
             // Get the interpolated asymmetry value.

ScriptableRenderPipeline/HDRenderPipeline/HDRP/ShaderConfig.cs

     {
         CameraRelativeRendering = 1, // Rendering sets the origin of the world to the position of the primary (scene view) camera
         UseDisneySSS = 1,            // Allow to chose between Burley Normalized Diffusion (Multi + Fix direction single scattering) or Jimenez diffusion approximation (Multiscattering only - More blurry) for Subsurface scattering
-        VolumetricLightingPreset = 0 // 0 = disabled, 1 = normal, 2 = ultra
+        VolumetricLightingPreset = 1 // 0 = disabled, 1 = normal, 2 = ultra
     };
 
     // Note: #define can't be use in include file in C# so we chose this way to configure both C# and hlsl

ScriptableRenderPipeline/HDRenderPipeline/HDRP/ShaderConfig.cs.hlsl

 //
 #define SHADEROPTIONS_CAMERA_RELATIVE_RENDERING (1)
 #define SHADEROPTIONS_USE_DISNEY_SSS (1)
-#define SHADEROPTIONS_VOLUMETRIC_LIGHTING_PRESET (0)
+#define SHADEROPTIONS_VOLUMETRIC_LIGHTING_PRESET (1)
 
 
 #endif

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

     public class VolumetricFog : AtmosphericScattering
     {
         public ColorParameter        albedo       = new ColorParameter(new Color(0.5f, 0.5f, 0.5f));
-        public MinFloatParameter     meanFreePath = new MinFloatParameter(float.MaxValue, 1.0f);
+        public MinFloatParameter     meanFreePath = new MinFloatParameter(1000000.0f, 1.0f);
         public ClampedFloatParameter asymmetry    = new ClampedFloatParameter(0.0f, -1.0f, 1.0f);
 
         // Override the volume blending function.