Scalable volumetrics [skip ci]

TestProjects/HDRP_Tests/Assets/GraphicTests/Scenes/2x_Lighting/2008_Light_Volumetrics/2008_Light_Volumetrics_Volume.asset

@@ -104,6 +104,16 @@ MonoBehaviour:
     m_Value: 0.75
     min: 0
     max: 1
+  screenResolutionPercentage:
+    m_OverrideState: 1
+    m_Value: 25
+    min: 6.25
+    max: 100
+  volumeSliceCount:
+    m_OverrideState: 1
+    m_Value: 128
+    min: 1
+    max: 1024
 --- !u!114 &11400000
 MonoBehaviour:
   m_ObjectHideFlags: 0

TestProjects/HDRP_Tests/Assets/GraphicTests/Scenes/5x_SkyAndFog/5001_Fog_FogFallback/Volume_Base.asset

@@ -198,6 +198,16 @@ MonoBehaviour:
     m_Value: 0.75
     min: 0
     max: 1
+  screenResolutionPercentage:
+    m_OverrideState: 1
+    m_Value: 25
+    min: 6.25
+    max: 100
+  volumeSliceCount:
+    m_OverrideState: 1
+    m_Value: 128
+    min: 1
+    max: 1024
 --- !u!114 &3474294613101294443
 MonoBehaviour:
   m_ObjectHideFlags: 3

TestProjects/HDRP_Tests/Assets/GraphicTests/Scenes/5x_SkyAndFog/5002_Fog_DensityVolumes/Scene Settings Profile.asset

@@ -81,6 +81,16 @@ MonoBehaviour:
     m_Value: 0.75
     min: 0
     max: 1
+  screenResolutionPercentage:
+    m_OverrideState: 1
+    m_Value: 25
+    min: 6.25
+    max: 100
+  volumeSliceCount:
+    m_OverrideState: 1
+    m_Value: 128
+    min: 1
+    max: 1024
 --- !u!114 &11400000
 MonoBehaviour:
   m_ObjectHideFlags: 0

TestProjects/HDRP_Tests/Assets/GraphicTests/Scenes/5x_SkyAndFog/5003_Fog_DensityVolumesShadows/Scene Settings Profile.asset

@@ -254,3 +254,13 @@ MonoBehaviour:
     m_Value: 1
     min: 0
     max: 1
+  screenResolutionPercentage:
+    m_OverrideState: 1
+    m_Value: 25
+    min: 6.25
+    max: 100
+  volumeSliceCount:
+    m_OverrideState: 1
+    m_Value: 128
+    min: 1
+    max: 1024

TestProjects/HDRP_Tests/Assets/GraphicTests/Scenes/5x_SkyAndFog/5008_FogFiltering/Sky and Fog Settings Profile.asset

@@ -81,6 +81,16 @@ MonoBehaviour:
     m_Value: 0.75
     min: 0
     max: 1
+  screenResolutionPercentage:
+    m_OverrideState: 1
+    m_Value: 25
+    min: 6.25
+    max: 100
+  volumeSliceCount:
+    m_OverrideState: 1
+    m_Value: 128
+    min: 1
+    max: 1024
   filter:
     m_OverrideState: 1
     m_Value: 1

com.unity.render-pipelines.high-definition/CHANGELOG.md

@@ -110,6 +110,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 - Added alpha channel support in motion blur pass.
 - Added the HDRP Compositor Tool (in Preview).
 - Added a ray tracing mode option in the HDRP asset that allows to override and shader stripping.
+- Added support for arbitrary resolution scaling of Volumetric Lighting to the Fog volume component.
 
 ### Fixed
 - Fix when rescale probe all direction below zero (1219246)
@@ -662,6 +663,8 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 - Raytracing: Remove the LOD cross fade multi compile for ray tracing.
 - Cookie are now supported in lightmaper. All lights casting cookie and baked will now include cookie influence.
 - Avoid building the mip chain a second time for SSR for transparent objects.
+- Replaced "High Quality" Subsurface Scattering with a set of Quality Levels.
+- Replaced "High Quality" Volumetric Lighting with "Screen Resolution Percentage" and "Volume Slice Count" on the Fog volume component.
 
 ## [7.1.1] - 2019-09-05
 

com.unity.render-pipelines.high-definition/Editor/RenderPipeline/HDRenderPipelineUI.cs

@@ -865,13 +865,6 @@ static void Drawer_SectionLightingUnsorted(SerializedHDRenderPipelineAsset seria
             EditorGUILayout.PropertyField(serialized.renderPipelineSettings.supportSSAO, Styles.supportSSAOContent);
 
             EditorGUILayout.PropertyField(serialized.renderPipelineSettings.supportVolumetrics, Styles.supportVolumetricContent);
-            using (new EditorGUI.DisabledScope(serialized.renderPipelineSettings.supportVolumetrics.hasMultipleDifferentValues
-                || !serialized.renderPipelineSettings.supportVolumetrics.boolValue))
-            {
-                ++EditorGUI.indentLevel;
-                EditorGUILayout.PropertyField(serialized.renderPipelineSettings.increaseResolutionOfVolumetrics, Styles.volumetricResolutionContent);
-                --EditorGUI.indentLevel;
-            }
 
             EditorGUILayout.PropertyField(serialized.renderPipelineSettings.supportProbeVolume, Styles.supportProbeVolumeContent);
             using (new EditorGUI.DisabledScope(!serialized.renderPipelineSettings.supportProbeVolume.boolValue))

com.unity.render-pipelines.high-definition/Editor/RenderPipeline/Settings/SerializedRenderPipelineSettings.cs

@@ -26,7 +26,6 @@ class SerializedRenderPipelineSettings
         public SerializedScalableSetting sssSampleBudget;
         [FormerlySerializedAs("supportVolumetric")]
         public SerializedProperty supportVolumetrics;
-        public SerializedProperty increaseResolutionOfVolumetrics;
         public SerializedProperty supportLightLayers;
         public SerializedProperty lightLayerName0;
         public SerializedProperty lightLayerName1;
@@ -88,7 +87,6 @@ public SerializedRenderPipelineSettings(SerializedProperty root)
             supportSubsurfaceScattering     = root.Find((RenderPipelineSettings s) => s.supportSubsurfaceScattering);
             sssSampleBudget                 = new SerializedScalableSetting(root.Find((RenderPipelineSettings s) => s.sssSampleBudget));
             supportVolumetrics              = root.Find((RenderPipelineSettings s) => s.supportVolumetrics);
-            increaseResolutionOfVolumetrics = root.Find((RenderPipelineSettings s) => s.increaseResolutionOfVolumetrics);
             supportLightLayers              = root.Find((RenderPipelineSettings s) => s.supportLightLayers);
             lightLayerName0                 = root.Find((RenderPipelineSettings s) => s.lightLayerName0);
             lightLayerName1                 = root.Find((RenderPipelineSettings s) => s.lightLayerName1);

com.unity.render-pipelines.high-definition/Editor/Sky/AtmosphericScattering/FogEditor.cs

@@ -25,6 +25,8 @@ class FogEditor : VolumeComponentEditor
         protected SerializedDataParameter m_EnableVolumetricFog;
         protected SerializedDataParameter m_DepthExtent;
         protected SerializedDataParameter m_SliceDistributionUniformity;
+        protected SerializedDataParameter m_ScreenResolutionPercentage;
+        protected SerializedDataParameter m_VolumeSliceCount;
         protected SerializedDataParameter m_Filter;
 
         static GUIContent s_Enabled = new GUIContent("Enable", "Check this to enable fog in your scene.");
@@ -61,6 +63,8 @@ public override void OnEnable()
             m_EnableVolumetricFog = Unpack(o.Find(x => x.enableVolumetricFog));
             m_DepthExtent = Unpack(o.Find(x => x.depthExtent));
             m_SliceDistributionUniformity = Unpack(o.Find(x => x.sliceDistributionUniformity));
+            m_ScreenResolutionPercentage = Unpack(o.Find(x => x.screenResolutionPercentage));
+            m_VolumeSliceCount = Unpack(o.Find(x => x.volumeSliceCount));
             m_Filter = Unpack(o.Find(x => x.filter));
         }
 
@@ -117,6 +121,8 @@ public override void OnInspectorGUI()
                     {
                         PropertyField(m_DepthExtent);
                         PropertyField(m_SliceDistributionUniformity);
+                        PropertyField(m_ScreenResolutionPercentage);
+                        PropertyField(m_VolumeSliceCount);
                         PropertyField(m_Filter);
                     }
 

com.unity.render-pipelines.high-definition/Runtime/Lighting/AtmosphericScattering/AtmosphericScattering.hlsl

@@ -14,6 +14,8 @@
 #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Debug/DebugDisplay.hlsl"
 #endif
 
+TEXTURE3D(_VBufferLighting);
+
 float3 ExpLerp(float3 A, float3 B, float t, float x, float y)
 {
     // Remap t: (exp(10 k t) - 1) / (exp(10 k) - 1) = exp(x t) y - y.
@@ -276,14 +278,14 @@ void EvaluateAtmosphericScattering(PositionInputs posInput, float3 V, out float3
         if (_EnableVolumetricFog != 0)
         {
             float4 value = SampleVBuffer(TEXTURE3D_ARGS(_VBufferLighting, s_linear_clamp_sampler),
-                posInput.positionNDC,
-                fogFragDist,
-                _VBufferViewportSize,
-                _VBufferSharedUvScaleAndLimit.xy,
-                _VBufferSharedUvScaleAndLimit.zw,
-                _VBufferDistanceEncodingParams,
-                _VBufferDistanceDecodingParams,
-                true, false);
+                                         posInput.positionNDC,
+                                         fogFragDist,   
+                                         _VBufferViewportSize,
+                                         _VBufferLightingViewportScale.xyz,
+                                         _VBufferLightingViewportLimit.xyz,
+                                         _VBufferDistanceEncodingParams,
+                                         _VBufferDistanceDecodingParams,
+                                         true, false);
 
             // TODO: add some slowly animated noise (dither?) to the reconstructed value.
             // TODO: re-enable tone mapping after implementing pre-exposure.

com.unity.render-pipelines.high-definition/Runtime/Lighting/AtmosphericScattering/Fog.cs

@@ -60,6 +60,13 @@ public class Fog : VolumeComponent
         /// <summary>Controls the distribution of slices along the Camera's focal axis. 0 is exponential distribution and 1 is linear distribution.</summary>
         [Tooltip("Controls the distribution of slices along the Camera's focal axis. 0 is exponential distribution and 1 is linear distribution.")]
         public ClampedFloatParameter sliceDistributionUniformity = new ClampedFloatParameter(0.75f, 0, 1);
+        /// <summary>Resolution of the volumetric buffer (3D texture) along the X and Y axes relative to the resolution of the frame buffer.</summary>
+        [Tooltip("Resolution of the volumetric buffer (3D texture) along the X and Y axes relative to the resolution of the frame buffer. " +
+        "Setting it to 12.5% (1/8) means the number of voxels per slice is 1/8^2 = 1/64 = 1.5625% of the resolution of the frame buffer.")]
+        public ClampedFloatParameter screenResolutionPercentage = new ClampedFloatParameter((1.0f/8.0f) * 100, (1.0f/16.0f) * 100, 100);
+        /// <summary>Number of slices of the volumetric buffer (3D texture) along the camera's focal axis.</summary>
+        [Tooltip("Number of slices of the volumetric buffer (3D texture) along the camera's focal axis.")]
+        public ClampedIntParameter volumeSliceCount = new ClampedIntParameter(64, 1, 1024);
 
         /// <summary>Applies a blur to smoothen the volumetric lighting output.</summary>
         [Tooltip("Applies a blur to smoothen the volumetric lighting output.")]

com.unity.render-pipelines.high-definition/Runtime/Lighting/AtmosphericScattering/ShaderVariablesAtmosphericScattering.hlsl

@@ -1,4 +1,3 @@
-TEXTURE3D(_VBufferLighting);
 TEXTURECUBE_ARRAY(_SkyTexture);
 
 #define _MipFogNear                     _MipFogParameters.x

com.unity.render-pipelines.high-definition/Runtime/Lighting/VolumetricLighting/VBuffer.hlsl

@@ -9,15 +9,15 @@
 // This means storing tone mapped radiance and transmittance instead of optical depth.
 // See "A Fresh Look at Generalized Sampling", p. 51.
 //
-// if (clampToBorder), samples outside of the buffer return 0 (we perform a smooth fade).
+// if (clampToBorder), samples outside of the buffer return 0 (border color).
 // Otherwise, the sampler simply clamps the texture coordinate to the edge of the texture.
 // Warning: clamping to border may not work as expected with the quadratic filter due to its extent.
 float4 SampleVBuffer(TEXTURE3D_PARAM(VBuffer, clampSampler),
                      float2 positionNDC,
                      float  linearDistance,
                      float4 VBufferViewportSize,
-                     float2 VBufferUvScale,
-                     float2 VBufferUvLimit,
+                     float3 VBufferViewportScale,
+                     float3 VBufferViewportLimit,
                      float4 VBufferDistanceEncodingParams,
                      float4 VBufferDistanceDecodingParams,
                      bool   quadraticFilterXY,
@@ -27,17 +27,19 @@ float4 SampleVBuffer(TEXTURE3D_PARAM(VBuffer, clampSampler),
     float2 uv = positionNDC;
     float  w  = EncodeLogarithmicDepthGeneralized(linearDistance, VBufferDistanceEncodingParams);
 
-    bool coordIsInsideFrustum = true;
+    bool coordIsInsideFrustum;
 
     if (clampToBorder)
     {
-        // Coordinates are always clamped to edge. We just introduce a clipping operation.
+        // Coordinates are always clamped to the edge. We just introduce a clipping operation.
         float3 positionCS = float3(uv, w) * 2 - 1;
 
         coordIsInsideFrustum = Max3(abs(positionCS.x), abs(positionCS.y), abs(positionCS.z)) < 1;
     }
-
-    float4 result = 0;
+    else
+    {
+        coordIsInsideFrustum = true; // No clipping, only clamping
+    }
 
     #if defined(UNITY_STEREO_INSTANCING_ENABLED)
         // With XR single-pass, one 3D buffer is used to store all views (split along w)
@@ -51,6 +53,8 @@ float4 SampleVBuffer(TEXTURE3D_PARAM(VBuffer, clampSampler),
         w = clamp(w, lowerSliceRange + limitSliceRange, upperSliceRange - limitSliceRange);
     #endif
 
+    float4 result = 0;
+
     if (coordIsInsideFrustum)
     {
         if (quadraticFilterXY)
@@ -62,21 +66,30 @@ float4 SampleVBuffer(TEXTURE3D_PARAM(VBuffer, clampSampler),
             float2 weights[2], offsets[2];
             BiquadraticFilter(1 - fc, weights, offsets); // Inverse-translate the filter centered around 0.5
 
-            const float2 ssToUv = VBufferViewportSize.zw * VBufferUvScale;
+            // Don't want to pass another shader parameter...
+            const float2 rcpBufDim = VBufferViewportScale.xy * VBufferViewportSize.zw; // (vp_dim / buf_dim) * (1 / vp_dim)
+
+            // And these are the texture coordinates.
+            // TODO: will the compiler eliminate redundant computations?
+            float2 texUv0 = (ic + float2(offsets[0].x, offsets[0].y)) * rcpBufDim; // Top left
+            float2 texUv1 = (ic + float2(offsets[1].x, offsets[0].y)) * rcpBufDim; // Top right
+            float2 texUv2 = (ic + float2(offsets[0].x, offsets[1].y)) * rcpBufDim; // Bottom left
+            float2 texUv3 = (ic + float2(offsets[1].x, offsets[1].y)) * rcpBufDim; // Bottom right
+            float  texW   = w * VBufferViewportScale.z;
 
-            // The sampler clamps to edge. This takes care of 4 frustum faces out of 6.
-            // Due to the RTHandle scaling system, we must take care of the other 2 manually.
+            // The sampler clamps to the edge (so UVWs < 0 are OK).
             // TODO: perform per-sample (4, in this case) bilateral filtering, rather than per-pixel. This should reduce leaking.
-            result = (weights[0].x * weights[0].y) * SAMPLE_TEXTURE3D_LOD(VBuffer, clampSampler, float3(min((ic + float2(offsets[0].x, offsets[0].y)) * ssToUv, VBufferUvLimit), w), 0)  // Top left
-                   + (weights[1].x * weights[0].y) * SAMPLE_TEXTURE3D_LOD(VBuffer, clampSampler, float3(min((ic + float2(offsets[1].x, offsets[0].y)) * ssToUv, VBufferUvLimit), w), 0)  // Top right
-                   + (weights[0].x * weights[1].y) * SAMPLE_TEXTURE3D_LOD(VBuffer, clampSampler, float3(min((ic + float2(offsets[0].x, offsets[1].y)) * ssToUv, VBufferUvLimit), w), 0)  // Bottom left
-                   + (weights[1].x * weights[1].y) * SAMPLE_TEXTURE3D_LOD(VBuffer, clampSampler, float3(min((ic + float2(offsets[1].x, offsets[1].y)) * ssToUv, VBufferUvLimit), w), 0); // Bottom right
+            result = (weights[0].x * weights[0].y) * SAMPLE_TEXTURE3D_LOD(VBuffer, clampSampler, min(float3(texUv0, texW), VBufferViewportLimit), 0)
+                   + (weights[1].x * weights[0].y) * SAMPLE_TEXTURE3D_LOD(VBuffer, clampSampler, min(float3(texUv1, texW), VBufferViewportLimit), 0)
+                   + (weights[0].x * weights[1].y) * SAMPLE_TEXTURE3D_LOD(VBuffer, clampSampler, min(float3(texUv2, texW), VBufferViewportLimit), 0)
+                   + (weights[1].x * weights[1].y) * SAMPLE_TEXTURE3D_LOD(VBuffer, clampSampler, min(float3(texUv3, texW), VBufferViewportLimit), 0);
         }
         else
         {
-            // The sampler clamps to edge. This takes care of 4 frustum faces out of 6.
-            // Due to the RTHandle scaling system, we must take care of the other 2 manually.
-            result = SAMPLE_TEXTURE3D_LOD(VBuffer, clampSampler, float3(min(uv * VBufferUvScale, VBufferUvLimit), w), 0);
+            // And these are the texture coordinates.
+            float3 texUVW = float3(uv, w) * VBufferViewportScale;
+            // The sampler clamps to the edge (so UVWs < 0 are OK).
+            result = SAMPLE_TEXTURE3D_LOD(VBuffer, clampSampler, min(texUVW, VBufferViewportLimit), 0);
         }
     }
 
@@ -88,22 +101,22 @@ float4 SampleVBuffer(TEXTURE3D_PARAM(VBuffer, clampSampler),
                      float3   cameraPositionWS,
                      float4x4 viewProjMatrix,
                      float4   VBufferViewportSize,
-                     float2   VBufferUvScale,
-                     float2   VBufferUvLimit,
+                     float3   VBufferViewportScale,
+                     float3   VBufferViewportLimit,
                      float4   VBufferDistanceEncodingParams,
                      float4   VBufferDistanceDecodingParams,
                      bool     quadraticFilterXY,
                      bool     clampToBorder)
 {
-    float2 positionNDC = ComputeNormalizedDeviceCoordinates(positionWS, viewProjMatrix);
+    float2 positionNDC    = ComputeNormalizedDeviceCoordinates(positionWS, viewProjMatrix);
     float  linearDistance = distance(positionWS, cameraPositionWS);
 
     return SampleVBuffer(TEXTURE3D_ARGS(VBuffer, clampSampler),
                          positionNDC,
                          linearDistance,
                          VBufferViewportSize,
-                         VBufferUvScale,
-                         VBufferUvLimit,
+                         VBufferViewportScale,
+                         VBufferViewportLimit,
                          VBufferDistanceEncodingParams,
                          VBufferDistanceDecodingParams,
                          quadraticFilterXY,

com.unity.render-pipelines.high-definition/Runtime/Lighting/VolumetricLighting/VolumeVoxelization.compute

@@ -5,24 +5,18 @@
 // #pragma enable_d3d11_debug_symbols
 #pragma only_renderers d3d11 playstation xboxone vulkan metal switch
 
-#pragma kernel VolumeVoxelizationBruteforceMQ VolumeVoxelization=VolumeVoxelizationBruteforceMQ LIGHTLOOP_DISABLE_TILE_AND_CLUSTER VL_PRESET_MQ
-#pragma kernel VolumeVoxelizationTiledMQ      VolumeVoxelization=VolumeVoxelizationTiledMQ      VL_PRESET_MQ
-#pragma kernel VolumeVoxelizationBruteforceHQ VolumeVoxelization=VolumeVoxelizationBruteforceHQ LIGHTLOOP_DISABLE_TILE_AND_CLUSTER VL_PRESET_HQ
-#pragma kernel VolumeVoxelizationTiledHQ      VolumeVoxelization=VolumeVoxelizationTiledHQ      VL_PRESET_HQ
+#pragma kernel VolumeVoxelizationBruteforceOptimal VolumeVoxelization=VolumeVoxelizationBruteforceOptimal LIGHTLOOP_DISABLE_TILE_AND_CLUSTER VL_PRESET_OPTIMAL
+#pragma kernel VolumeVoxelizationTiledOptimal      VolumeVoxelization=VolumeVoxelizationTiledOptimal                                         VL_PRESET_OPTIMAL
+#pragma kernel VolumeVoxelizationBruteforce        VolumeVoxelization=VolumeVoxelizationBruteforce        LIGHTLOOP_DISABLE_TILE_AND_CLUSTER
+#pragma kernel VolumeVoxelizationTiled             VolumeVoxelization=VolumeVoxelizationTiled
 
 #ifndef LIGHTLOOP_DISABLE_TILE_AND_CLUSTER
     #define USE_BIG_TILE_LIGHTLIST
 #endif
 
-#ifdef VL_PRESET_MQ
-    // E.g. for 1080p: (1920/8)x(1080/8)x(64)  =  2,073,600 voxels
-    // Same texel count as in a 1080p frame buffer.
-    #define VBUFFER_TILE_SIZE 8
-#endif
-#ifdef VL_PRESET_HQ
-    // E.g. for 1080p: (1920/4)x(1080/4)x(128) = 16,588,800 voxels
-    // Double the texel count of a 4K frame buffer!
-    #define VBUFFER_TILE_SIZE 4
+#ifdef VL_PRESET_OPTIMAL
+    // E.g. for 1080p: (1920/8)x(1080/8)x(64) = 2,073,600 voxels
+    #define VBUFFER_VOXEL_SIZE 8
 #endif
 
 #define GROUP_SIZE_1D     8
@@ -316,15 +310,21 @@ void VolumeVoxelization(uint3 dispatchThreadId : SV_DispatchThreadID,
                         uint2 groupId          : SV_GroupID,
                         uint2 groupThreadId    : SV_GroupThreadID)
 {
-    // Perform compile-time checks.
-    if (!IsPower2(VBUFFER_TILE_SIZE) || !IsPower2(TILE_SIZE_BIG_TILE)) return;
-
     UNITY_XR_ASSIGN_VIEW_INDEX(dispatchThreadId.z);
 
     uint2 groupOffset = groupId * GROUP_SIZE_1D;
     uint2 voxelCoord  = groupOffset + groupThreadId;
-    uint2 tileCoord   = groupOffset * VBUFFER_TILE_SIZE / TILE_SIZE_BIG_TILE;
-    uint  tileIndex   = tileCoord.x + _NumTileBigTileX * tileCoord.y;
+#ifdef VL_PRESET_OPTIMAL
+    // The entire thread group is within the same light tile.
+    uint2 tileCoord = groupOffset * VBUFFER_VOXEL_SIZE / TILE_SIZE_BIG_TILE;
+#else
+    // No compile-time optimizations, no scalarization.
+    // If _VBufferVoxelSize is not a power of 2 or > TILE_SIZE_BIG_TILE, a voxel may straddle
+    // a tile boundary. This means different voxel subsamples may belong to different tiles.
+    // We accept this error, and simply use the coordinates of the center of the voxel.
+    uint2 tileCoord = (uint2)((voxelCoord + 0.5) * _VBufferVoxelSize / TILE_SIZE_BIG_TILE);
+#endif
+    uint  tileIndex = tileCoord.x + _NumTileBigTileX * tileCoord.y;
 
     // Reminder: our voxels are sphere-capped right frustums (truncated right pyramids).
     // The curvature of the front and back faces is quite gentle, so we can use