Merge remote-tracking branch 'origin/master' into HDRP_GraphicTests

# Conflicts:
#	ImageTemplates/HDRenderPipeline/Scenes/1xxx_Materials/1101_Unlit.unity.png
#	ImageTemplates/HDRenderPipeline/Scenes/1xxx_Materials/1301_SubSurfaceScattering.unity.png
#	ImageTemplates/HDRenderPipeline/Scenes/1xxx_Materials/1302_SSS_MaxRadius.unity.png
#	ImageTemplates/HDRenderPipeline/Scenes/1xxx_Materials/1302_SSS_MaxRadius.unity.png.meta
#	ImageTemplates/HDRenderPipeline/Scenes/1xxx_Materials/1303_SSS_Pre-Post.unity.png
#	ImageTemplates/HDRenderPipeline/Scenes/1xxx_Materials/1303_SSS_Pre-Post.unity.png.meta
#	ImageTemplates/HDRenderPipeline/Scenes/2xxx_Lighting/2101_GI_Metapass.unity.png
#	ImageTemplates/HDRenderPipeline/Scenes/2xxx_Lighting/2102_GI_Emission.unity.png
#	ImageTemplates/HDRenderPipeline/Scenes/2xxx_Lighting/2103_BakeMixed.unity.png
#	ImageTemplates/HDRenderPipeline/Scenes/2xxx_Lighting/2401_Light_on_Tesselation.unity.png
#	ImageTemplates/HDRenderPipeline/Scenes/9xxx_Other/9002_Deferr...

CHANGELOG.md

 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
-### Added
- - Planar Reflection Probe support roughness (gaussian convolution of captured probe)
- - Screen Space Refraction projection model (Proxy raycasting, HiZ raymarching)
- - Screen Space Refraction settings as volume component
-
-### Changed
- - Depth and color pyramid are properly computed and sampled when the camera renders inside a viewport of a RTHandle.
- - Forced Planar Probe update modes to (Realtime, Every Update, Mirror Camera)
- - Removed Planar Probe mirror plane position and normal fields in inspector, always display mirror plane and normal gizmos
- - Screen Space Refraction proxy model uses the proxy of the first environment light (Reflection probe/Planar probe) or the sky
 
 ## [0.1.6] - 2018-xx-yy
 

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/BSDF.hlsl

 
 real F_Schlick(real f0, real f90, real u)
 {
-    real x  = 1.0 - u;
+    real x = 1.0 - u;
     real x2 = x * x;
     real x5 = x * x2 * x2;
     return (f90 - f0) * x5 + f0;                // sub mul mul mul sub mad
 
 real3 F_Schlick(real3 f0, real f90, real u)
 {
-    real x  = 1.0 - u;
+    real x = 1.0 - u;
     real x2 = x * x;
     real x5 = x * x2 * x2;
     return f0 * (1.0 - x5) + (f90 * x5);        // sub mul mul mul sub mul mad*3
 // Does not handle TIR.
 real F_Transm_Schlick(real f0, real f90, real u)
 {
-    real x  = 1.0 - u;
+    real x = 1.0 - u;
     real x2 = x * x;
     real x5 = x * x2 * x2;
     return (1.0 - f90 * x5) - f0 * (1.0 - x5);  // sub mul mul mul mad sub mad
 // Does not handle TIR.
 real3 F_Transm_Schlick(real3 f0, real f90, real u)
 {
-    real x  = 1.0 - u;
+    real x = 1.0 - u;
     real x2 = x * x;
     real x5 = x * x2 * x2;
     return (1.0 - f90 * x5) - f0 * (1.0 - x5);  // sub mul mul mul mad sub mad*3
 
 // Ref: https://seblagarde.wordpress.com/2013/04/29/memo-on-fresnel-equations/
 // Fresnel dieletric / dielectric
-real F_Fresnel(real ior, real u)
+real F_FresnelDieletric(real ior, real u)
+// Fresnel dieletric / conductor
+// Note: etak2 = etak * etak (optimization for Artist Friendly Metallic Fresnel below)
+// eta = eta_t / eta_i and etak = k_t / n_i
+real3 F_FresnelConductor(real3 eta, real3 etak2, real cosTheta)
+{
+    real cosTheta2 = cosTheta * cosTheta;
+    real sinTheta2 = 1.0 - cosTheta2;
+    real3 eta2 = eta * eta;
+
+    real3 t0 = eta2 - etak2 - sinTheta2;
+    real3 a2plusb2 = sqrt(t0 * t0 + 4.0 * eta2 * etak2);
+    real3 t1 = a2plusb2 + cosTheta2;
+    real3 a = sqrt(0.5 * (a2plusb2 + t0));
+    real3 t2 = 2.0 * a * cosTheta;
+    real3 Rs = (t1 - t2) / (t1 + t2);
+
+    real3 t3 = cosTheta2 * a2plusb2 + sinTheta2 * sinTheta2;
+    real3 t4 = t2 * sinTheta2;
+    real3 Rp = Rs * (t3 - t4) / (t3 + t4);
+
+    return 0.5 * (Rp + Rs);
+}
+
+// Conversion FO/IOR
+
+// ior is a value between 1.0 and 3.0. 1.0 is air interface
+real IorToFresnel0(real transmittedIor, real incidentIor = 1.0)
+{
+    return Sq((transmittedIor - incidentIor) / (transmittedIor + incidentIor));
+}
+
+// Assume air interface for top
+// Note: Don't handle the case fresnel0 == 1
+real Fresnel0ToIor(real fresnel0)
+{
+    real sqrtF0 = sqrt(fresnel0);
+    return (1.0 + sqrtF0) / (1.0 - sqrtF0);
+}
+
+// This function is a coarse approximation of computing fresnel0 for a different top than air (here clear coat of IOR 1.5) when we only have fresnel0 with air interface
+// This function is equivalent to IorToFresnel0(Fresnel0ToIor(fresnel0), 1.5)
+// mean
+// real sqrtF0 = sqrt(fresnel0);
+// return Sq(1.0 - 5.0 * sqrtF0) / Sq(5.0 - sqrtF0);
+// Optimization: Fit of the function (3 mad) for range [0.04 (should return 0), 1 (should return 1)]
+TEMPLATE_1_REAL(ConvertF0ForAirInterfaceToF0ForClearCoat15, fresnel0, return saturate(-0.0256868 + fresnel0 * (0.326846 + (0.978946 - 0.283835 * fresnel0) * fresnel0)))
+
+// Artist Friendly Metallic Fresnel Ref: http://jcgt.org/published/0003/04/03/paper.pdf
+
+real3 GetIorN(real3 f0, real3 edgeTint)
+{
+    real3 sqrtF0 = sqrt(f0);
+    return lerp((1.0 - f0) / (1.0 + f0), (1.0 + sqrtF0) / (1.0 - sqrt(f0)), edgeTint);
+}
+
+real3 getIorK2(real3 f0, real3 n)
+{
+    real3 nf0 = Sq(n + 1.0) * f0 - Sq(f0 - 1.0);
+    return nf0 / (1.0 - f0);
+}
+
 //-----------------------------------------------------------------------------
 // Specular BRDF
 //-----------------------------------------------------------------------------
     real a2 = Sq(roughness);
-    real s  = (NdotH * a2 - NdotH) * NdotH + 1.0;
+    real s = (NdotH * a2 - NdotH) * NdotH + 1.0;
     return a2 / (s * s);
 }
 
 real DV_SmithJointGGX(real NdotH, real NdotL, real NdotV, real roughness, real partLambdaV)
 {
     real a2 = Sq(roughness);
-    real s  = (NdotH * a2 - NdotH) * NdotH + 1.0;
+    real s = (NdotH * a2 - NdotH) * NdotH + 1.0;
 
     real lambdaV = NdotL * partLambdaV;
     real lambdaL = NdotV * sqrt((-NdotL * a2 + NdotL) * NdotL + a2);
 
 // Inline D_GGXAniso() * V_SmithJointGGXAniso() together for better code generation.
 real DV_SmithJointGGXAniso(real TdotH, real BdotH, real NdotH, real NdotV,
-                           real TdotL, real BdotL, real NdotL,
-                           real roughnessT, real roughnessB, real partLambdaV)
+    real TdotL, real BdotL, real NdotL,
+    real roughnessT, real roughnessB, real partLambdaV)
 {
     real a2 = roughnessT * roughnessB;
     real3 v = real3(roughnessB * TdotH, roughnessT * BdotH, a2 * NdotH);
 }
 
 real DV_SmithJointGGXAniso(real TdotH, real BdotH, real NdotH,
-                           real TdotV, real BdotV, real NdotV,
-                           real TdotL, real BdotL, real NdotL,
-                           real roughnessT, real roughnessB)
+    real TdotV, real BdotV, real NdotV,
+    real TdotL, real BdotL, real NdotL,
+    real roughnessT, real roughnessB)
-                                 roughnessT, roughnessB, partLambdaV);
+        roughnessT, roughnessB, partLambdaV);
 }
 
 //-----------------------------------------------------------------------------
     real fd90 = 0.5 + (perceptualRoughness + perceptualRoughness * LdotV);
     // Two schlick fresnel term
     real lightScatter = F_Schlick(1.0, fd90, NdotL);
-    real viewScatter  = F_Schlick(1.0, fd90, NdotV);
+    real viewScatter = F_Schlick(1.0, fd90, NdotV);
 
     // Normalize the BRDF for polar view angles of up to (Pi/4).
     // We use the worst case of (roughness = albedo = 1), and, for each view angle,
 // Ref: Diffuse Lighting for GGX + Smith Microsurfaces, p. 113.
 real3 DiffuseGGXNoPI(real3 albedo, real NdotV, real NdotL, real NdotH, real LdotV, real roughness)
 {
-    real facing    = 0.5 + 0.5 * LdotV;              // (LdotH)^2
-    real rough     = facing * (0.9 - 0.4 * facing) * (0.5 / NdotH + 1);
+    real facing = 0.5 + 0.5 * LdotV;              // (LdotH)^2
+    real rough = facing * (0.9 - 0.4 * facing) * (0.5 / NdotH + 1);
-    real smooth    = transmitL * transmitV * 1.05;   // Normalize F_t over the hemisphere
-    real single    = lerp(smooth, rough, roughness); // Rescaled by PI
-    real multiple  = roughness * (0.1159 * PI);      // Rescaled by PI
+    real smooth = transmitL * transmitV * 1.05;   // Normalize F_t over the hemisphere
+    real single = lerp(smooth, rough, roughness); // Rescaled by PI
+    real multiple = roughness * (0.1159 * PI);      // Rescaled by PI
 
     return single + albedo * multiple;
 }
     // Note that we could save 2 cycles by inlining the multiplication by INV_PI.
     return INV_PI * DiffuseGGXNoPI(albedo, NdotV, NdotL, NdotH, LdotV, roughness);
 }
-
-//-----------------------------------------------------------------------------
-// Conversion FO/IOR
-//-----------------------------------------------------------------------------
-
-// ior is a value between 1.0 and 3.0. 1.0 is air interface
-real IorToFresnel0(real transmittedIor, real incidentIor = 1.0)
-{
-    return Sq((transmittedIor - incidentIor) / (transmittedIor + incidentIor));
-}
-
-// Assume air interface for top
-// Note: Don't handle the case fresnel0 == 1
-real Fresnel0ToIor(real fresnel0)
-{
-    real sqrtF0 = sqrt(fresnel0);
-    return (1.0 + sqrtF0) / (1.0 - sqrtF0);
-}
-
-// This function is a coarse approximation of computing fresnel0 for a different top than air (here clear coat of IOR 1.5) when we only have fresnel0 with air interface
-// This function is equivalent to IorToFresnel0(Fresnel0ToIor(fresnel0), 1.5)
-// mean
-// real sqrtF0 = sqrt(fresnel0);
-// return Sq(1.0 - 5.0 * sqrtF0) / Sq(5.0 - sqrtF0);
-// Optimization: Fit of the function (3 mad) for range [0.04 (should return 0), 1 (should return 1)]
-TEMPLATE_1_REAL(ConvertF0ForAirInterfaceToF0ForClearCoat15, fresnel0, return saturate(-0.0256868 + fresnel0 * (0.326846 + (0.978946 - 0.283835 * fresnel0) * fresnel0)))
 
 //-----------------------------------------------------------------------------
 // Iridescence

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/GeometricTools.hlsl

 // Intersection functions
 //-----------------------------------------------------------------------------
 
-// This implementation does not attempt to explicitly handle NaNs.
-// Ref: https://tavianator.com/fast-branchless-raybounding-box-intersections-part-2-nans/
-    float3 rayDirInv = rcp(rayDirection); // Could be precomputed
+    // Could be precomputed. Clamp to avoid INF. clamp() is a single ALU on GCN.
+    // rcp(FLT_EPS) = 16,777,216, which is large enough for our purposes,
+    // yet doesn't cause a lot of numerical issues associated with FLT_MAX.
+    float3 rayDirInv = clamp(rcp(rayDirection), -rcp(FLT_EPS), rcp(FLT_EPS));
 
     // Perform ray-slab intersection (component-wise).
     float3 t0 = boxMin * rayDirInv - (rayOrigin * rayDirInv);

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/ImageBasedLighting.hlsl

                          out real    NdotL,
                          out real    weightOverPdf)
 {
+#if 0
+#else
+    real3 N = localToWorld[2];
+
+    L     = SampleHemisphereCosine(u.x, u.y, N);
+    NdotL = saturate(dot(N, L));
+#endif
 
     // Importance sampling weight for each sample
     // pdf = N.L / PI

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/Sampling/Sampling.hlsl

     return r * real2(cosPhi, sinPhi);
 }
 
+real3 SampleSphereUniform(real u1, real u2)
+{
+    real phi      = TWO_PI * u2;
+    real cosTheta = 1.0 - 2.0 * u1;
+
+    return SphericalToCartesian(phi, cosTheta);
+}
+
 // Performs cosine-weighted sampling of the hemisphere.
 // Ref: PBRT v3, p. 780.
 real3 SampleHemisphereCosine(real u1, real u2)
     return localL;
 }
 
-real3 SampleHemisphereUniform(real u1, real u2)
+// Cosine-weighted sampling without the tangent frame.
+// Ref: http://www.amietia.com/lambertnotangent.html
+real3 SampleHemisphereCosine(real u1, real u2, real3 normal)
-    real phi      = TWO_PI * u2;
-    real cosTheta = 1.0 - u1;
-
-    return SphericalToCartesian(phi, cosTheta);
+    real3 pointOnSphere = SampleSphereUniform(u1, u2);
+    return normalize(normal + pointOnSphere);
-real3 SampleSphereUniform(real u1, real u2)
+real3 SampleHemisphereUniform(real u1, real u2)
-    real cosTheta = 1.0 - 2.0 * u1;
+    real cosTheta = 1.0 - u1;
 
     return SphericalToCartesian(phi, cosTheta);
 }

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/SpaceFillingCurves.hlsl

     return x;
 }
 
-// "Insert" two 0 bits after each of the 10 low bits of x/
+// "Insert" two 0 bits after each of the 10 low bits of x.
 // Ref: https://fgiesen.wordpress.com/2009/12/13/decoding-morton-codes/
 uint Part1By2(uint x)
 {
     return x;
 }
 
-// Inverse of Part1By1 - "delete" all odd-indexed bits/
+// Inverse of Part1By1 - "delete" all odd-indexed bits.
 // Ref: https://fgiesen.wordpress.com/2009/12/13/decoding-morton-codes/
 uint Compact1By1(uint x)
 {
     return x;
 }
 
-// Inverse of Part1By2 - "delete" all bits not at positions divisible by 3/
+// Inverse of Part1By2 - "delete" all bits not at positions divisible by 3.
 // Ref: https://fgiesen.wordpress.com/2009/12/13/decoding-morton-codes/
 uint Compact1By2(uint x)
 {

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/VolumeRendering.hlsl

 // Samples the interval of homogeneous participating medium using the closed-form tracking approach
 // (proportionally to the transmittance).
 // Returns the offset from the start of the interval and the weight = (transmittance / pdf).
-// Ref: Production Volume Rendering, 3.6.1.
+// Ref: Monte Carlo Methods for Volumetric Light Transport Simulation, p. 5.
-    // pdf    = extinction * exp(-extinction * t) / (1 - exp(-intervalLength * extinction))
+    // pdf    = extinction * exp(extinction * (intervalLength - t)) / (exp(intervalLength * extinction - 1)
-    // weight = (1 - exp(-extinction * intervalLength)) / extinction;
+    // weight = (1 - exp(-extinction * intervalLength)) / extinction
+    real c = rcp(extinction);
-    weight = x * rcp(extinction);
-    offset = -log(1 - rndVal * x) * rcp(extinction);
+    weight = x * c;
+    offset = -log(1 - rndVal * x) * c;
 }
 
 // Implements equiangular light sampling.

ScriptableRenderPipeline/Core/CoreRP/Textures/DepthBits.cs.meta

 fileFormatVersion: 2
-guid: 32875dc85f620f54e817e767811b5c2e
+guid: d063f57ca4b7cd346a14a1be20de65b4
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

ScriptableRenderPipeline/Core/CoreRP/Utilities/CoreUtils.cs

         {
             string msg = "AR/VR devices are not supported, no rendering will occur";
             DisplayUnsupportedMessage(msg);
-        }        
+        }
 
         // Returns 'true' if "Animated Materials" are enabled for the view associated with the given camera.
         public static  bool AreAnimatedMaterialsEnabled(Camera camera)
                     }
                 }
             }
-            
+
             // TODO: how to handle reflection views? We don't know the parent window they are being rendered into,
             // so we don't know whether we can animate them...
             //
         #endif
 
             return animateMaterials;
+        }
+
+        public static bool IsSceneViewFogEnabled(Camera camera)
+        {
+            bool fogEnable = true;
+
+#if UNITY_EDITOR
+            fogEnable = Application.isPlaying;
+
+            if (camera.cameraType == CameraType.SceneView)
+            {
+                fogEnable = false;
+
+                // Determine whether the "Animated Materials" checkbox is checked for the current view.
+                foreach (UnityEditor.SceneView sv in Resources.FindObjectsOfTypeAll(typeof(UnityEditor.SceneView)))
+                {
+                    if (sv.camera == camera && sv.sceneViewState.showFog)
+                    {
+                        fogEnable = true;
+                        break;
+                    }
+                }
+            }
+#endif
+
+            return fogEnable;
         }
     }
 }

ScriptableRenderPipeline/Core/CoreRP/Volume/VolumeComponent.cs

                 parameter.OnDisable();
         }
 
+        // You can override this to do your own blending. Either loop through the `parameters` list
+        // or reference direct fields (you'll need to cast `state` to your custom type and don't
+        // forget to use `SetValue` on parameters, do not assign directly to the state object - and
+        // of course you'll need to check for the `overrideState` manually).
+        public virtual void Override(VolumeComponent state, float interpFactor)
+        {
+            int count = parameters.Count;
+
+            for (int i = 0; i < count; i++)
+            {
+                var stateParam = state.parameters[i];
+                var toParam = parameters[i];
+
+                // Keep track of the override state for debugging purpose
+                stateParam.overrideState = toParam.overrideState;
+
+                if (toParam.overrideState)
+                    stateParam.Interp(stateParam, toParam, interpFactor);
+            }
+        }
+
         public void SetAllOverridesTo(bool state)
         {
             SetAllOverridesTo(parameters, state);

ScriptableRenderPipeline/Core/CoreRP/Volume/VolumeManager.cs

                 if (!component.active)
                     continue;
 
-                var target = stack.GetComponent(component.GetType());
-                int count = component.parameters.Count;
-
-                for (int i = 0; i < count; i++)
-                {
-                    var fromParam = target.parameters[i];
-                    var toParam = component.parameters[i];
-
-                    // Keep track of the override state for debugging purpose
-                    fromParam.overrideState = toParam.overrideState;
-
-                    if (toParam.overrideState)
-                        fromParam.Interp(fromParam, toParam, interpFactor);
-                }
+                var state = stack.GetComponent(component.GetType());
+                component.Override(state, interpFactor);
             }
         }
 

ScriptableRenderPipeline/HDRenderPipeline/CHANGELOG.md

 The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+### Added
+
+
+### Changed
+
+
-### Changelog starting
+### New features and functionality
+- 
-Started Changelog
+### Bug fixes
+- Fix fog flags in scene view is now taken into account
+- Fix sky in preview windows that were disappearing after a load of a new level
+- Fix numerical issues in IntersectRayAABB().
+- Fix alpha blending of volumetric lighting with transparent objects.
+- Fix the near plane of the V-Buffer causing out-of-bounds look-ups in the clustered data structure.
+- Depth and color pyramid are properly computed and sampled when the camera renders inside a viewport of a RTHandle.
+
+### Changed, Removals and deprecations
+- EnableShadowMask in FrameSettings (But shadowMaskSupport still disable by default)
+- Forced Planar Probe update modes to (Realtime, Every Update, Mirror Camera)
+- Removed Planar Probe mirror plane position and normal fields in inspector, always display mirror plane and normal gizmos
+- Screen Space Refraction proxy model uses the proxy of the first environment light (Reflection probe/Planar probe) or the sky
+- Moved RTHandle static methods to RTHandles
+- Renamed RTHandle to RTHandleSystem.RTHandle
+ 
+### Improvements
+- Port Global Density Volumes to the Interpolation Volume System.
+- Optimize ImportanceSampleLambert() to not require the tangent frame.
+- Generalize SampleVBuffer() to handle different sampling and reconstruction methods.
+- Improve the quality of volumetric lighting reprojection.
+- Optimize Morton Order code in the Subsurface Scattering pass.
+- Planar Reflection Probe support roughness (gaussian convolution of captured probe)
+- Only store decal textures to atlas if decal is visible, debounce out of memory decal atlas warning.
+
+### Features
+- Screen Space Refraction projection model (Proxy raycasting, HiZ raymarching)
+- Screen Space Refraction settings as volume component
+- Added buffered frame history per camera

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Camera/HDCamera.cs

 
         HDAdditionalCameraData m_AdditionalCameraData;
 
+        BufferedRTHandleSystem m_HistoryRTSystem = new BufferedRTHandleSystem();
+
         public HDCamera(Camera cam)
         {
             camera = cam;
 
             // Unfortunately sometime (like in the HDCameraEditor) HDUtils.hdrpSettings can be null because of scripts that change the current pipeline...
             m_msaaSamples = HDUtils.hdrpSettings != null ? HDUtils.hdrpSettings.msaaSampleCount : MSAASamples.None;
-            RTHandle.SetReferenceSize(m_ActualWidth, m_ActualHeight, frameSettings.enableMSAA, m_msaaSamples);
+            RTHandles.SetReferenceSize(m_ActualWidth, m_ActualHeight, frameSettings.enableMSAA, m_msaaSamples);
+            m_HistoryRTSystem.SetReferenceSize(m_ActualWidth, m_ActualHeight, frameSettings.enableMSAA, m_msaaSamples);
+            m_HistoryRTSystem.Swap();
-            int maxWidth = RTHandle.maxWidth;
-            int maxHeight = RTHandle.maxHeight;
+            int maxWidth = RTHandles.maxWidth;
+            int maxHeight = RTHandles.maxHeight;
             m_CameraScaleBias.x = (float)m_ActualWidth / maxWidth;
             m_CameraScaleBias.y = (float)m_ActualHeight / maxHeight;
 
             return hdcam;
         }
 
+        public static void ClearAll()
+        {
+            foreach (var cam in s_Cameras)
+                cam.Value.ReleaseHistoryBuffer();
+
+            s_Cameras.Clear();
+            s_Cleanup.Clear();
+        }
+
         // Look for any camera that hasn't been used in the last frame and remove them for the pool.
         public static void CleanUnused()
         {
             {
-                if (kvp.Value.m_LastFrameActive != frameCheck)
+                if (kvp.Value.m_LastFrameActive < frameCheck)
+            {
+                var hdCam = s_Cameras[cam];
+                if (hdCam.m_HistoryRTSystem != null)
+                {
+                    hdCam.m_HistoryRTSystem.Dispose();
+                    hdCam.m_HistoryRTSystem = null;
+                }
+            }
 
             s_Cleanup.Clear();
         }
             cmd.SetGlobalMatrixArray(HDShaderIDs._InvViewMatrixStereo, invViewStereo);
             cmd.SetGlobalMatrixArray(HDShaderIDs._InvProjMatrixStereo, invProjStereo);
             cmd.SetGlobalMatrixArray(HDShaderIDs._InvViewProjMatrixStereo, invViewProjStereo);
+        }
+
+        public RTHandleSystem.RTHandle GetPreviousFrameRT(int id)
+        {
+            return m_HistoryRTSystem.GetFrameRT(id, 1);
+        }
+
+        public RTHandleSystem.RTHandle GetCurrentFrameRT(int id)
+        {
+            return m_HistoryRTSystem.GetFrameRT(id, 0);
+        }
+
+        // Allocate buffers frames and return current frame
+        public RTHandleSystem.RTHandle AllocHistoryFrameRT(int id, Func<string, int, RTHandleSystem, RTHandleSystem.RTHandle> allocator)
+        {
+            m_HistoryRTSystem.AllocBuffer(id, (rts, i) => allocator(camera.name, i, rts), 2);
+            return m_HistoryRTSystem.GetFrameRT(id, 0);
+        }
+
+        void ReleaseHistoryBuffer()
+        {
+            m_HistoryRTSystem.ReleaseAll();
         }
     }
 }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Debug/DebugDisplay.cs

         public static string k_PanelRendering = "Rendering";
 
         public static string k_PanelScreenSpaceTracing = "Screen Space Tracing";
+        public static string k_PanelDecals = "Decals";
 
         //static readonly string[] k_HiZIntersectionKind = { "None", "Depth", "Cell" };
 
         DebugUI.Widget[] m_DebugRenderingItems;
         DebugUI.Widget[] m_DebugScreenSpaceTracingItems;
-        
+        DebugUI.Widget[] m_DebugDecalsItems;
+
 
         public float debugOverlayRatio = 0.33f;
         public FullScreenDebugMode  fullScreenDebugMode = FullScreenDebugMode.None;
         public LightingDebugSettings lightingDebugSettings = new LightingDebugSettings();
         public MipMapDebugSettings mipMapDebugSettings = new MipMapDebugSettings();
         public ColorPickerDebugSettings colorPickerDebugSettings = new ColorPickerDebugSettings();
+        public DecalsDebugSettings decalsDebugSettings = new DecalsDebugSettings();
 
         public static GUIContent[] lightingFullScreenDebugStrings = null;
         public static int[] lightingFullScreenDebugValues = null;
 
         Lit.RefractionSSRayModel m_LastSSRayModel = Lit.RefractionSSRayModel.None;
         ScreenSpaceTracingDebug m_ScreenSpaceTracingDebugData;
-        public ScreenSpaceTracingDebug screenSpaceTracingDebugData 
+        public ScreenSpaceTracingDebug screenSpaceTracingDebugData
-            internal set 
+            internal set
-                m_ScreenSpaceTracingDebugData = value; 
+                m_ScreenSpaceTracingDebugData = value;
                 if (m_LastSSRayModel != m_ScreenSpaceTracingDebugData.tracingModel)
                 {
                     m_LastSSRayModel = m_ScreenSpaceTracingDebugData.tracingModel;
             return materialDebugSettings.IsDebugDisplayEnabled() || lightingDebugSettings.IsDebugDisplayEnabled() || mipMapDebugSettings.IsDebugDisplayEnabled() || IsDebugFullScreenEnabled();
         }
 
+        public bool IsDebugDisplayRemovePostprocess()
+        {
+            // We want to keep post process when only the override more are enabled and none of the other
+            return materialDebugSettings.IsDebugDisplayEnabled() || lightingDebugSettings.IsDebugDisplayRemovePostprocess() || mipMapDebugSettings.IsDebugDisplayEnabled() || IsDebugFullScreenEnabled();
+        }
+
         public bool IsDebugMaterialDisplayEnabled()
         {
             return materialDebugSettings.IsDebugDisplayEnabled();
 
         bool IsScreenSpaceTracingRefractionDebugEnabled()
         {
-            return fullScreenDebugMode == FullScreenDebugMode.ScreenSpaceTracing 
+            return fullScreenDebugMode == FullScreenDebugMode.ScreenSpaceTracing
                 && lightingDebugSettings.debugLightingMode == DebugLightingMode.ScreenSpaceTracingRefraction;
         }
 
             var refractionContainer = new DebugUI.Container
             {
                 displayName = "Refraction",
-                children = 
+                children =
                 {
                     new DebugUI.BoolField { displayName = "Debug Enabled", getter = IsScreenSpaceTracingRefractionDebugEnabled, setter = SetScreenSpaceTracingRefractionDebugEnabled, onValueChanged = RefreshScreenSpaceTracingDebug },
                 }
             RegisterScreenSpaceTracingDebug();
         }
 
+        void RefreshDecalsDebug<T>(DebugUI.Field<T> field, T value)
+        {
+            UnregisterDebugItems(k_PanelDecals, m_DebugDecalsItems);
+            RegisterDecalsDebug();
+        }
+
         public void RegisterLightingDebug()
         {
             var list = new List<DebugUI.Widget>();
             panel.children.Add(m_DebugRenderingItems);
         }
 
+        public void RegisterDecalsDebug()
+        {
+            m_DebugDecalsItems = new DebugUI.Widget[]
+            {
+                new DebugUI.BoolField { displayName = "Display atlas", getter = () => decalsDebugSettings.m_DisplayAtlas, setter = value => decalsDebugSettings.m_DisplayAtlas = value},
+                new DebugUI.UIntField { displayName = "Mip Level", getter = () => decalsDebugSettings.m_MipLevel, setter = value => decalsDebugSettings.m_MipLevel = value, min = () => 0u, max = () => (uint)(RenderPipelineManager.currentPipeline as HDRenderPipeline).GetDecalAtlasMipCount() }
+            };
+
+            var panel = DebugManager.instance.GetPanel(k_PanelDecals, true);
+            panel.children.Add(m_DebugDecalsItems);
+        }
+
+            RegisterDecalsDebug();
             RegisterDisplayStatsDebug();
             RegisterMaterialDebug();
             RegisterLightingDebug();
 
         public void UnregisterDebug()
         {
+            UnregisterDebugItems(k_PanelDecals, m_DebugDecalsItems);
             UnregisterDebugItems(k_PanelDisplayStats, m_DebugDisplayStatsItems);
             UnregisterDebugItems(k_PanelMaterials, m_DebugMaterialItems);
             UnregisterDebugItems(k_PanelLighting, m_DebugLightingItems);

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Debug/LightingDebug.cs

     {
         public bool IsDebugDisplayEnabled()
         {
-            return debugLightingMode != DebugLightingMode.None || overrideSmoothness || overrideAlbedo || overrideNormal;
+            return debugLightingMode != DebugLightingMode.None || overrideSmoothness || overrideAlbedo || overrideNormal || overrideSpecularColor;
+        }
+
+        public bool IsDebugDisplayRemovePostprocess()
+        {
+            return debugLightingMode != DebugLightingMode.None;
         }
 
         public DebugLightingMode    debugLightingMode = DebugLightingMode.None;

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Decal/DecalSystem.cs

 
         private Texture2DAtlas m_Atlas = null;
         public bool m_AllocationSuccess = true;
+        public bool m_PrevAllocationSuccess = true;
 
         public Texture2DAtlas Atlas
         {
             {
                 if (m_NumResults == 0)
                     return;
-
+                // only add if anything in this decal set is visible.
+                AddToTextureList(ref instance.m_TextureList);
                 int instanceCount = 0;
                 int batchCount = 0;
                 Matrix4x4[] decalToWorldBatch = null;
                     textureList.Add(m_Mask);
                 }
             }
-
-           
-           
 
             public void RenderIntoDBuffer(CommandBuffer cmd)
             {
         // updates textures, texture atlas indices and blend value
         public void UpdateCachedMaterialData()
         {
-            //instance.m_AllocationSuccess = true;
-                pair.Value.InitializeMaterialValues();
-                pair.Value.AddToTextureList(ref m_TextureList);
+                pair.Value.InitializeMaterialValues();                
             }
         }
 
                     AddTexture(cmd, textureScaleBias);
                 }
 
-                if(!m_AllocationSuccess) // still failed to allocate, decal atlas size needs to increase
+                if(!m_AllocationSuccess && m_PrevAllocationSuccess) // still failed to allocate, decal atlas size needs to increase, debounce so that we don't spam the console with warnings
+            m_PrevAllocationSuccess = m_AllocationSuccess;
         }
 
         public void CreateDrawData()
             // set to null so that they get recreated
             m_DecalMesh = null;
             m_Atlas = null;
+        }
+
+        public void RenderDebugOverlay(HDCamera hdCamera, CommandBuffer cmd, DebugDisplaySettings debugDisplaySettings, ref float x, ref float y, float overlaySize, float width)
+        {
+            if(debugDisplaySettings.decalsDebugSettings.m_DisplayAtlas)
+            { 
+                using (new ProfilingSample(cmd, "Display Decal Atlas", CustomSamplerId.DisplayDebugDecalsAtlas.GetSampler()))
+                {
+                    HDUtils.BlitQuad(cmd, Atlas.AtlasTexture, new Vector4(1,1,0,0), new Vector4(width / hdCamera.actualWidth, overlaySize / hdCamera.actualHeight, x / hdCamera.actualWidth, y / hdCamera.actualHeight), (int)debugDisplaySettings.decalsDebugSettings.m_MipLevel, true);
+                    HDUtils.NextOverlayCoord(ref x, ref y, overlaySize, overlaySize, hdCamera.actualWidth);
+                }
+            }
         }
     }
 }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Material/StackLit/StackLitUI.cs

         protected static class Styles
         {
             public static string InputsText = "Inputs";
+            public static GUIContent doubleSidedNormalModeText = new GUIContent("Normal mode", "This will modify the normal base on the selected mode. Mirror: Mirror the normal with vertex normal plane, Flip: Flip the normal");
+
+            // Scalar scale factors for: metallic and the two lobe perceptual smoothness.
+            public static GUIContent metallicText = new GUIContent("Metallic", "Metallic scale factor");
+            public static GUIContent smoothnessAText = new GUIContent("Primary Lobe Smoothness", "Primary lobe smoothness scale factor");
+            public static GUIContent smoothnessBText = new GUIContent("Secondary Lobe Smoothness", "Secondary lobe smoothness scale factor");
+            public static GUIContent lobeMixText = new GUIContent("Lobe Mixing", "Lobe mixing factor");
+
+            public static GUIContent smoothnessARemappingText = new GUIContent("Primary Lobe Smoothness Remapping", "Primary lobe smoothness remapping");
+            public static GUIContent smoothnessBRemappingText = new GUIContent("Secondary Lobe Smoothness Remapping", "Secondary  lobe smoothness remapping");
+            public static GUIContent maskMapASText = new GUIContent("Primary mask map - M(R), AO(G), D(B), S1(A)", "Primary mask map");
+            public static GUIContent maskMapBSText = new GUIContent("Secondary mask Map - (R), (G), (B), S2(A)", "Secondary mask map");
+
+            public static GUIContent normalMapText = new GUIContent("Normal Map", "Normal Map (BC7/BC5/DXT5(nm))");
+
+            public static GUIContent UVBaseMappingText = new GUIContent("UV mapping usage", "");
+
+
+            // Emissive
+            public static string emissiveLabelText = "Emissive Inputs";
-			
+
+        public enum DoubleSidedNormalMode
+        {
+            Flip,
+            Mirror,
+            None
+        }
+
+        public enum UVBaseMapping
+        {
+            UV0,
+            UV1,
+            UV2,
+            UV3,
+            Planar,
+            Triplanar
+        }
+
+        protected MaterialProperty doubleSidedNormalMode = null;
+        protected const string kDoubleSidedNormalMode = "_DoubleSidedNormalMode";
+
+        // Example UV mapping mask, TODO: could have for multiple maps, and channel mask for scalars
+        protected MaterialProperty UVBase = null;
+        protected const string kUVBase = "_UVBase";
+        protected MaterialProperty UVMappingMask = null;
+        protected const string kUVMappingMask = "_UVMappingMask"; // hidden, see enum material property drawer in .shader
+
 
         protected MaterialProperty baseColor = null;
         protected const string kBaseColor = "_BaseColor";
+        protected const string kMetallic = "_Metallic";
+        protected MaterialProperty metallic = null;
+
+        // Primary lobe smoothness
+        protected MaterialProperty smoothnessA = null;
+        protected const string kSmoothnessA = "_SmoothnessA";
+        protected MaterialProperty smoothnessARemapMin = null;
+        protected const string kSmoothnessARemapMin = "_SmoothnessARemapMin";
+        protected MaterialProperty smoothnessARemapMax = null;
+        protected const string kSmoothnessARemapMax = "_SmoothnessARemapMax";
+        protected const string klobeMix = "_LobeMix";
+        protected MaterialProperty lobeMix = null;
+
+        // Secondary lobe smoothness
+        protected MaterialProperty smoothnessB = null;
+        protected const string kSmoothnessB = "_SmoothnessB";
+        protected MaterialProperty smoothnessBRemapMin = null;
+        protected const string kSmoothnessBRemapMin = "_SmoothnessBRemapMin";
+        protected MaterialProperty smoothnessBRemapMax = null;
+        protected const string kSmoothnessBRemapMax = "_SmoothnessBRemapMax";
+
+
+        // Two mask maps for the two smoothnesses
+        protected MaterialProperty maskMapA = null;
+        protected const string kMaskMapA = "_MaskMapA";
+        protected MaterialProperty maskMapB = null;
+        protected const string kMaskMapB = "_MaskMapB";
+
+        protected MaterialProperty normalScale = null;
+        protected const string kNormalScale = "_NormalScale";
+        protected MaterialProperty normalMap = null;
+        protected const string kNormalMap = "_NormalMap";
+
         protected MaterialProperty emissiveColor = null;
         protected const string kEmissiveColor = "_EmissiveColor";
         protected MaterialProperty emissiveColorMap = null;
         protected MaterialProperty albedoAffectEmissive = null;
         protected const string kAlbedoAffectEmissive = "_AlbedoAffectEmissive";
-		
+
+        protected override void FindBaseMaterialProperties(MaterialProperty[] props)
+        {
+            base.FindBaseMaterialProperties(props);
+
+            doubleSidedNormalMode = FindProperty(kDoubleSidedNormalMode, props);
+        }
+
+            UVBase = FindProperty(kUVBase, props);
+            UVMappingMask = FindProperty(kUVMappingMask, props);
+
+            metallic = FindProperty(kMetallic, props);
+
+            smoothnessA = FindProperty(kSmoothnessA, props);
+            smoothnessARemapMin = FindProperty(kSmoothnessARemapMin, props);
+            smoothnessARemapMax = FindProperty(kSmoothnessARemapMax, props);
+
+            smoothnessB = FindProperty(kSmoothnessB, props);
+            smoothnessBRemapMin = FindProperty(kSmoothnessBRemapMin, props);
+            smoothnessBRemapMax = FindProperty(kSmoothnessBRemapMax, props);
+
+            lobeMix = FindProperty(klobeMix, props);
+
+            maskMapA = FindProperty(kMaskMapA, props);
+            maskMapB = FindProperty(kMaskMapB, props);
+
+            normalMap = FindProperty(kNormalMap, props);
+            normalScale = FindProperty(kNormalScale, props);
+
             emissiveColor = FindProperty(kEmissiveColor, props);
             emissiveColorMap = FindProperty(kEmissiveColorMap, props);
             emissiveIntensity = FindProperty(kEmissiveIntensity, props);
+
+        protected override void BaseMaterialPropertiesGUI()
+        {
+            base.BaseMaterialPropertiesGUI();
+
+            EditorGUI.indentLevel++;
+
+            // This follow double sided option, see BaseUnlitUI.BaseMaterialPropertiesGUI()
+            // Don't put anything between base.BaseMaterialPropertiesGUI(); above and this:
+            if (doubleSidedEnable.floatValue > 0.0f)
+            {
+                EditorGUI.indentLevel++;
+                m_MaterialEditor.ShaderProperty(doubleSidedNormalMode, Styles.doubleSidedNormalModeText);
+                EditorGUI.indentLevel--;
+            }
+
+            //TODO: m_MaterialEditor.ShaderProperty(enableMotionVectorForVertexAnimation, StylesBaseUnlit.enableMotionVectorForVertexAnimationText);
+            //refs to this ?
+
+            EditorGUI.indentLevel--;
+
+        }
+
+            EditorGUI.indentLevel++;
+
+
+            m_MaterialEditor.ShaderProperty(metallic, Styles.metallicText);
+
+            // maskMaps and smoothness rescaling controls:
+            if(maskMapA.textureValue == null)
+            {
+                m_MaterialEditor.ShaderProperty(smoothnessA, Styles.smoothnessAText);
+            }
+            else
+            {
+                float remapMin = smoothnessARemapMin.floatValue;
+                float remapMax = smoothnessARemapMax.floatValue;
+                EditorGUI.BeginChangeCheck();
+                EditorGUILayout.MinMaxSlider(Styles.smoothnessARemappingText, ref remapMin, ref remapMax, 0.0f, 1.0f);
+                if (EditorGUI.EndChangeCheck())
+                {
+                    smoothnessARemapMin.floatValue = remapMin;
+                    smoothnessARemapMax.floatValue = remapMax;
+                }
+            }
+            if(maskMapB.textureValue == null)
+            {
+                m_MaterialEditor.ShaderProperty(smoothnessB, Styles.smoothnessBText);
+            }
+            else
+            {
+                float remapMin = smoothnessBRemapMin.floatValue;
+                float remapMax = smoothnessBRemapMax.floatValue;
+                EditorGUI.BeginChangeCheck();
+                EditorGUILayout.MinMaxSlider(Styles.smoothnessBRemappingText, ref remapMin, ref remapMax, 0.0f, 1.0f);
+                if (EditorGUI.EndChangeCheck())
+                {
+                    smoothnessBRemapMin.floatValue = remapMin;
+                    smoothnessBRemapMax.floatValue = remapMax;
+                }
+            }
+            m_MaterialEditor.ShaderProperty(lobeMix, Styles.lobeMixText);
+            m_MaterialEditor.TexturePropertySingleLine(Styles.maskMapASText, maskMapA);
+            m_MaterialEditor.TexturePropertySingleLine(Styles.maskMapBSText, maskMapB);
+
+
+            // Normal map: 
+            m_MaterialEditor.TexturePropertySingleLine(Styles.normalMapText, normalMap, normalScale);
+
+            // UV Mapping:
+            EditorGUILayout.Space();
+
+            EditorGUI.BeginChangeCheck(); // UV mapping selection
+            m_MaterialEditor.ShaderProperty(UVBase, Styles.UVBaseMappingText);
+
+            UVBaseMapping uvBaseMapping = (UVBaseMapping)UVBase.floatValue;
+
+            float X, Y, Z, W;
+            X = (uvBaseMapping == UVBaseMapping.UV0) ? 1.0f : 0.0f;
+            Y = (uvBaseMapping == UVBaseMapping.UV1) ? 1.0f : 0.0f;
+            Z = (uvBaseMapping == UVBaseMapping.UV2) ? 1.0f : 0.0f;
+            W = (uvBaseMapping == UVBaseMapping.UV3) ? 1.0f : 0.0f;
+
+            UVMappingMask.colorValue = new Color(X, Y, Z, W);
+
+
+            //TODO:
+            //if ((uvBaseMapping == UVBaseMapping.Planar) || (uvBaseMapping == UVBaseMapping.Triplanar))
+            //{
+            //    m_MaterialEditor.ShaderProperty(TexWorldScale, Styles.texWorldScaleText);
+            //}
+            if (EditorGUI.EndChangeCheck()) // ...UV mapping selection
+            {
+            }
-            m_MaterialEditor.TexturePropertySingleLine(Styles.emissiveText, emissiveColorMap, emissiveColor);
-            m_MaterialEditor.TextureScaleOffsetProperty(emissiveColorMap);
-            m_MaterialEditor.ShaderProperty(emissiveIntensity, Styles.emissiveIntensityText);
-            m_MaterialEditor.ShaderProperty(albedoAffectEmissive, Styles.albedoAffectEmissiveText);
+            EditorGUI.indentLevel--; // inputs
+            EditorGUILayout.Space();
+            // Surface type:
             var surfaceTypeValue = (SurfaceType)surfaceType.floatValue;
             if (surfaceTypeValue == SurfaceType.Transparent)
             {
 
                 --EditorGUI.indentLevel;
             }
+
+
+            // TODO: see DoEmissiveGUI( ) in LitUI.cs: custom uvmapping for emissive
+            EditorGUILayout.Space();
+            EditorGUILayout.LabelField(Styles.emissiveLabelText, EditorStyles.boldLabel);
+            EditorGUI.indentLevel++;
+            m_MaterialEditor.TexturePropertySingleLine(Styles.emissiveText, emissiveColorMap, emissiveColor);
+            m_MaterialEditor.ShaderProperty(emissiveIntensity, Styles.emissiveIntensityText);
+            m_MaterialEditor.ShaderProperty(albedoAffectEmissive, Styles.albedoAffectEmissiveText);
+            EditorGUI.indentLevel--;
         }
 
         protected override void MaterialPropertiesAdvanceGUI(Material material)
         // All Setup Keyword functions must be static. It allow to create script to automatically update the shaders with a script if code change
         static public void SetupMaterialKeywordsAndPass(Material material)
         {
+            //TODO see BaseLitUI.cs:SetupBaseLitKeywords (stencil etc)
+
+            bool doubleSidedEnable = material.GetFloat(kDoubleSidedEnable) > 0.0f;
+
+            if (doubleSidedEnable)
+            {
+                DoubleSidedNormalMode doubleSidedNormalMode = (DoubleSidedNormalMode)material.GetFloat(kDoubleSidedNormalMode);
+                switch (doubleSidedNormalMode)
+                {
+                    case DoubleSidedNormalMode.Mirror: // Mirror mode (in tangent space)
+                        material.SetVector("_DoubleSidedConstants", new Vector4(1.0f, 1.0f, -1.0f, 0.0f));
+                        break;
+
+                    case DoubleSidedNormalMode.Flip: // Flip mode (in tangent space)
+                        material.SetVector("_DoubleSidedConstants", new Vector4(-1.0f, -1.0f, -1.0f, 0.0f));
+                        break;
+
+                    case DoubleSidedNormalMode.None: // None mode (in tangent space)
+                        material.SetVector("_DoubleSidedConstants", new Vector4(1.0f, 1.0f, 1.0f, 0.0f));
+                        break;
+                }
+            }
+
+            //NOTE: For SSS in forward and split lighting, obviously we don't have a gbuffer pass, 
+            // so no stencil tagging there, but velocity? To check...
+            
+            //TODO: stencil state, displacement, wind, depthoffset, tesselation
+
+            SetupMainTexForAlphaTestGI("_BaseColorMap", "_BaseColor", material);
+
+            //TODO: disable DBUFFER
+
+
+            CoreUtils.SetKeyword(material, "_NORMALMAP_TANGENT_SPACE", true);
+            CoreUtils.SetKeyword(material, "_NORMALMAP", material.GetTexture(kNormalMap));
+            CoreUtils.SetKeyword(material, "_MASKMAPA", material.GetTexture(kMaskMapA));
+            CoreUtils.SetKeyword(material, "_MASKMAPB", material.GetTexture(kMaskMapB));
+
+            bool needUV2 = (UVBaseMapping)material.GetFloat(kUVBase) == UVBaseMapping.UV2;
+            bool needUV3 = (UVBaseMapping)material.GetFloat(kUVBase) == UVBaseMapping.UV3;
+
+            if (needUV3)
+            {
+                material.DisableKeyword("_REQUIRE_UV2");
+                material.EnableKeyword("_REQUIRE_UV3");
+            }
+            else if (needUV2)
+            {
+                material.EnableKeyword("_REQUIRE_UV2");
+                material.DisableKeyword("_REQUIRE_UV3");
+            }
+            else
+            {
+                material.DisableKeyword("_REQUIRE_UV2");
+                material.DisableKeyword("_REQUIRE_UV3");
+            }
 
             CoreUtils.SetKeyword(material, "_EMISSIVE_COLOR_MAP", material.GetTexture(kEmissiveColorMap));
         }

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

-using System.Collections;
+using System.Collections;
 using System.Collections.Generic;
 using UnityEngine;
 using UnityEditor;
             PropertyField(m_FogHeightAttenuation);
         }
     }
-}
+}

ScriptableRenderPipeline/HDRenderPipeline/HDRP/HDCustomSamplerId.cs

         GBuffer,
         DBufferRender,
         DBufferPrepareDrawData,
+        DisplayDebugDecalsAtlas,
         DisplayDebugViewMaterial,
         DebugViewMaterialGBuffer,
         BlitDebugViewMaterialDebug,
         TransparentDepthPostpass,
         ObjectsVelocity,
         CameraVelocity,
-        GaussianPyramidColor,
-        PyramidDepth,
+        ColorPyramid,
+        DepthPyramid,
         PostProcessing,
         RenderDebug,
         ClearBuffers,

ScriptableRenderPipeline/HDRenderPipeline/HDRP/HDRenderPipeline.cs

         RenderTargetIdentifier[] m_MRTCache2 = new RenderTargetIdentifier[2];
 
         // 'm_CameraColorBuffer' does not contain diffuse lighting of SSS materials until the SSS pass. It is stored within 'm_CameraSssDiffuseLightingBuffer'.
-        RTHandle m_CameraColorBuffer;
-        RTHandle m_CameraSssDiffuseLightingBuffer;
+        RTHandleSystem.RTHandle m_CameraColorBuffer;
+        RTHandleSystem.RTHandle m_CameraSssDiffuseLightingBuffer;
-        RTHandle m_CameraDepthStencilBuffer;
-        RTHandle m_CameraDepthBufferCopy;
-        RTHandle m_CameraStencilBufferCopy;
+        RTHandleSystem.RTHandle m_CameraDepthStencilBuffer;
+        RTHandleSystem.RTHandle m_CameraDepthBufferCopy;
+        RTHandleSystem.RTHandle m_CameraStencilBufferCopy;
-        RTHandle m_VelocityBuffer;
-        RTHandle m_DeferredShadowBuffer;
-        RTHandle m_AmbientOcclusionBuffer;
-        RTHandle m_DistortionBuffer;
+        RTHandleSystem.RTHandle m_VelocityBuffer;
+        RTHandleSystem.RTHandle m_DeferredShadowBuffer;
+        RTHandleSystem.RTHandle m_AmbientOcclusionBuffer;
+        RTHandleSystem.RTHandle m_DistortionBuffer;
 
         // The pass "SRPDefaultUnlit" is a fall back to legacy unlit rendering and is required to support unity 2d + unity UI that render in the scene.
         ShaderPassName[] m_ForwardAndForwardOnlyPassNames = { new ShaderPassName(), new ShaderPassName(), HDShaderPassNames.s_SRPDefaultUnlitName };
 
         public int GetCurrentShadowCount() { return m_LightLoop.GetCurrentShadowCount(); }
         public int GetShadowAtlasCount() { return m_LightLoop.GetShadowAtlasCount(); }
+        public int GetDecalAtlasMipCount()
+        {
+            int highestDim = Math.Max(renderPipelineSettings.decalSettings.atlasWidth, renderPipelineSettings.decalSettings.atlasHeight);
+            return (int)Math.Log(highestDim, 2);
+        }
+
         public int GetShadowSliceCount(uint atlasIndex) { return m_LightLoop.GetShadowSliceCount(atlasIndex); }
 
         readonly SkyManager m_SkyManager = new SkyManager();
         public DebugDisplaySettings debugDisplaySettings { get { return m_DebugDisplaySettings; } }
         static DebugDisplaySettings s_NeutralDebugDisplaySettings = new DebugDisplaySettings();
         DebugDisplaySettings m_CurrentDebugDisplaySettings;
-        RTHandle                        m_DebugColorPickerBuffer;
-        RTHandle                        m_DebugFullScreenTempBuffer;
+        RTHandleSystem.RTHandle         m_DebugColorPickerBuffer;
+        RTHandleSystem.RTHandle         m_DebugFullScreenTempBuffer;
         bool                            m_FullScreenDebugPushed;
         bool                            m_ValidAPI; // False by default mean we render normally, true mean we don't render anything
 
             // Initial state of the RTHandle system.
             // Tells the system that we will require MSAA or not so that we can avoid wasteful render texture allocation.
             // TODO: Might want to initialize to at least the window resolution to avoid un-necessary re-alloc in the player
-            RTHandle.Initialize(1, 1, m_Asset.renderPipelineSettings.supportMSAA, m_Asset.renderPipelineSettings.msaaSampleCount);
+            RTHandles.Initialize(1, 1, m_Asset.renderPipelineSettings.supportMSAA, m_Asset.renderPipelineSettings.msaaSampleCount);
 
             if(!m_Asset.renderPipelineSettings.supportForwardOnly)
                 m_GbufferManager.CreateBuffers();
 
-            m_BufferPyramid.CreateBuffers();
-
-            m_CameraColorBuffer = RTHandle.Alloc(Vector2.one, filterMode: FilterMode.Point, colorFormat: RenderTextureFormat.ARGBHalf, sRGB : false, enableRandomWrite: true, enableMSAA: true, name : "CameraColor");
-            m_CameraSssDiffuseLightingBuffer = RTHandle.Alloc(Vector2.one, filterMode: FilterMode.Point, colorFormat: RenderTextureFormat.RGB111110Float, sRGB: false, enableRandomWrite: true, enableMSAA: true, name: "CameraSSSDiffuseLighting");
+            m_CameraColorBuffer = RTHandles.Alloc(Vector2.one, filterMode: FilterMode.Point, colorFormat: RenderTextureFormat.ARGBHalf, sRGB : false, enableRandomWrite: true, enableMSAA: true, name : "CameraColor");
+            m_CameraSssDiffuseLightingBuffer = RTHandles.Alloc(Vector2.one, filterMode: FilterMode.Point, colorFormat: RenderTextureFormat.RGB111110Float, sRGB: false, enableRandomWrite: true, enableMSAA: true, name: "CameraSSSDiffuseLighting");
-            m_CameraDepthStencilBuffer = RTHandle.Alloc(Vector2.one, depthBufferBits: DepthBits.Depth24, colorFormat: RenderTextureFormat.Depth, filterMode: FilterMode.Point, bindTextureMS: true, enableMSAA: true, name: "CameraDepthStencil");
+            m_CameraDepthStencilBuffer = RTHandles.Alloc(Vector2.one, depthBufferBits: DepthBits.Depth24, colorFormat: RenderTextureFormat.Depth, filterMode: FilterMode.Point, bindTextureMS: true, enableMSAA: true, name: "CameraDepthStencil");
-                m_CameraDepthBufferCopy = RTHandle.Alloc(Vector2.one, depthBufferBits: DepthBits.Depth24, colorFormat: RenderTextureFormat.Depth, filterMode: FilterMode.Point, bindTextureMS: true, enableMSAA: true, name: "CameraDepthStencilCopy");
+                m_CameraDepthBufferCopy = RTHandles.Alloc(Vector2.one, depthBufferBits: DepthBits.Depth24, colorFormat: RenderTextureFormat.Depth, filterMode: FilterMode.Point, bindTextureMS: true, enableMSAA: true, name: "CameraDepthStencilCopy");
-            m_CameraStencilBufferCopy = RTHandle.Alloc(Vector2.one, depthBufferBits: DepthBits.None, colorFormat: RenderTextureFormat.R8, sRGB: false, filterMode: FilterMode.Point, enableMSAA: true, name: "CameraStencilCopy"); // DXGI_FORMAT_R8_UINT is not supported by Unity
+            m_CameraStencilBufferCopy = RTHandles.Alloc(Vector2.one, depthBufferBits: DepthBits.None, colorFormat: RenderTextureFormat.R8, sRGB: false, filterMode: FilterMode.Point, enableMSAA: true, name: "CameraStencilCopy"); // DXGI_FORMAT_R8_UINT is not supported by Unity
-                m_AmbientOcclusionBuffer = RTHandle.Alloc(Vector2.one, filterMode: FilterMode.Bilinear, colorFormat: RenderTextureFormat.R8, sRGB: false, enableRandomWrite: true, name: "AmbientOcclusion");
+                m_AmbientOcclusionBuffer = RTHandles.Alloc(Vector2.one, filterMode: FilterMode.Bilinear, colorFormat: RenderTextureFormat.R8, sRGB: false, enableRandomWrite: true, name: "AmbientOcclusion");
-                m_VelocityBuffer = RTHandle.Alloc(Vector2.one, filterMode: FilterMode.Point, colorFormat: Builtin.GetVelocityBufferFormat(), sRGB: Builtin.GetVelocityBufferSRGBFlag(), enableMSAA: true, name: "Velocity");
+                m_VelocityBuffer = RTHandles.Alloc(Vector2.one, filterMode: FilterMode.Point, colorFormat: Builtin.GetVelocityBufferFormat(), sRGB: Builtin.GetVelocityBufferSRGBFlag(), enableMSAA: true, name: "Velocity");
-            m_DistortionBuffer = RTHandle.Alloc(Vector2.one, filterMode: FilterMode.Point, colorFormat: Builtin.GetDistortionBufferFormat(), sRGB: Builtin.GetDistortionBufferSRGBFlag(), name: "Distortion");
+            m_DistortionBuffer = RTHandles.Alloc(Vector2.one, filterMode: FilterMode.Point, colorFormat: Builtin.GetDistortionBufferFormat(), sRGB: Builtin.GetDistortionBufferSRGBFlag(), name: "Distortion");
-            m_DeferredShadowBuffer = RTHandle.Alloc(Vector2.one, filterMode: FilterMode.Point, colorFormat: RenderTextureFormat.ARGB32, sRGB: false, enableRandomWrite: true, name: "DeferredShadow");
+            m_DeferredShadowBuffer = RTHandles.Alloc(Vector2.one, filterMode: FilterMode.Point, colorFormat: RenderTextureFormat.ARGB32, sRGB: false, enableRandomWrite: true, name: "DeferredShadow");
-                m_DebugColorPickerBuffer = RTHandle.Alloc(Vector2.one, filterMode: FilterMode.Point, colorFormat: RenderTextureFormat.ARGBHalf, sRGB: false, name: "DebugColorPicker");
-                m_DebugFullScreenTempBuffer = RTHandle.Alloc(Vector2.one, filterMode: FilterMode.Point, colorFormat: RenderTextureFormat.ARGBHalf, sRGB: false, name: "DebugFullScreen");
+                m_DebugColorPickerBuffer = RTHandles.Alloc(Vector2.one, filterMode: FilterMode.Point, colorFormat: RenderTextureFormat.ARGBHalf, sRGB: false, name: "DebugColorPicker");
+                m_DebugFullScreenTempBuffer = RTHandles.Alloc(Vector2.one, filterMode: FilterMode.Point, colorFormat: RenderTextureFormat.ARGBHalf, sRGB: false, name: "DebugFullScreen");
             }
         }
 
             m_DbufferManager.DestroyBuffers();
             m_BufferPyramid.DestroyBuffers();
 
-            RTHandle.Release(m_CameraColorBuffer);
-            RTHandle.Release(m_CameraSssDiffuseLightingBuffer);
+            RTHandles.Release(m_CameraColorBuffer);
+            RTHandles.Release(m_CameraSssDiffuseLightingBuffer);
-            RTHandle.Release(m_CameraDepthStencilBuffer);
-            RTHandle.Release(m_CameraDepthBufferCopy);
-            RTHandle.Release(m_CameraStencilBufferCopy);
+            RTHandles.Release(m_CameraDepthStencilBuffer);
+            RTHandles.Release(m_CameraDepthBufferCopy);
+            RTHandles.Release(m_CameraStencilBufferCopy);
-            RTHandle.Release(m_AmbientOcclusionBuffer);
-            RTHandle.Release(m_VelocityBuffer);
-            RTHandle.Release(m_DistortionBuffer);
-            RTHandle.Release(m_DeferredShadowBuffer);
+            RTHandles.Release(m_AmbientOcclusionBuffer);
+            RTHandles.Release(m_VelocityBuffer);
+            RTHandles.Release(m_DistortionBuffer);
+            RTHandles.Release(m_DeferredShadowBuffer);
-            RTHandle.Release(m_DebugColorPickerBuffer);
-            RTHandle.Release(m_DebugFullScreenTempBuffer);
-
+            RTHandles.Release(m_DebugColorPickerBuffer);
+            RTHandles.Release(m_DebugFullScreenTempBuffer);
+            
+
+            HDCamera.CleanUnused();
         }
 
 
 
                 m_VolumetricLightingSystem.PushGlobalParams(hdCamera, cmd);
 
-                var ssrefraction = VolumeManager.instance.stack.GetComponent<ScreenSpaceRefraction>()
+                var ssRefraction = VolumeManager.instance.stack.GetComponent<ScreenSpaceRefraction>()
-                ssrefraction.PushShaderParameters(cmd);
+                ssRefraction.PushShaderParameters(cmd);
+
+                var previousDepthPyramidRT = hdCamera.GetPreviousFrameRT((int)HDCameraFrameHistoryType.DepthPyramid);
+                if (previousDepthPyramidRT != null)
+                {
+                    cmd.SetGlobalTexture(HDShaderIDs._DepthPyramidTexture, previousDepthPyramidRT);
+                    cmd.SetGlobalVector(HDShaderIDs._DepthPyramidSize, new Vector4(
+                        previousDepthPyramidRT.referenceSize.x, 
+                        previousDepthPyramidRT.referenceSize.y, 
+                        1f / previousDepthPyramidRT.referenceSize.x, 
+                        1f / previousDepthPyramidRT.referenceSize.y
+                    ));
+                    cmd.SetGlobalVector(HDShaderIDs._DepthPyramidScale, new Vector4(
+                        previousDepthPyramidRT.referenceSize.x / (float)previousDepthPyramidRT.rt.width, 
+                        previousDepthPyramidRT.referenceSize.y / (float)previousDepthPyramidRT.rt.height, 
+                        Mathf.Log(Mathf.Min(previousDepthPyramidRT.rt.width, previousDepthPyramidRT.rt.height), 2), 
+                        0.0f
+                    ));
+                }
+                    
+                var previousColorPyramidRT = hdCamera.GetPreviousFrameRT((int)HDCameraFrameHistoryType.ColorPyramid);
+                if (previousColorPyramidRT != null)
+                {
+                    cmd.SetGlobalTexture(HDShaderIDs._ColorPyramidTexture, previousColorPyramidRT);
+                    cmd.SetGlobalVector(HDShaderIDs._ColorPyramidSize, new Vector4(
+                        previousColorPyramidRT.referenceSize.x, 
+                        previousColorPyramidRT.referenceSize.y, 
+                        1f / previousColorPyramidRT.referenceSize.x, 
+                        1f / previousColorPyramidRT.referenceSize.y
+                    ));
+                    cmd.SetGlobalVector(HDShaderIDs._ColorPyramidScale, new Vector4(
+                        previousColorPyramidRT.referenceSize.x / (float)previousColorPyramidRT.rt.width, 
+                        previousColorPyramidRT.referenceSize.y / (float)previousColorPyramidRT.rt.height, 
+                        Mathf.Log(Mathf.Min(previousColorPyramidRT.rt.width, previousColorPyramidRT.rt.height), 2), 
+                        0.0f
+                    ));
+                }
             }
         }
 
             return m_LightLoop.GetFeatureVariantsEnabled();
         }
 
-        RTHandle GetDepthTexture()
+        RTHandleSystem.RTHandle GetDepthTexture()
         {
             return NeedDepthBufferCopy() ? m_CameraDepthBufferCopy : m_CameraDepthStencilBuffer;
         }
                     var postProcessLayer = camera.GetComponent<PostProcessLayer>();
 
                     // Disable post process if we enable debug mode or if the post process layer is disabled
-                    if (m_CurrentDebugDisplaySettings.IsDebugDisplayEnabled() || !CoreUtils.IsPostProcessingActive(postProcessLayer))
+                    if (m_CurrentDebugDisplaySettings.IsDebugDisplayRemovePostprocess() || !CoreUtils.IsPostProcessingActive(postProcessLayer))
                     {
                         m_FrameSettings.enablePostprocess = false;
                     }
                             DecalSystem.instance.EndCull();
                             m_DbufferManager.vsibleDecalCount = DecalSystem.m_DecalsVisibleThisFrame;
                             DecalSystem.instance.UpdateCachedMaterialData();    // textures, alpha or fade distances could've changed
-                            DecalSystem.instance.UpdateTextureAtlas(cmd);       // as this is only used for transparent pass, would've been nice not to have to do this if no transparent renderers are visible
+                            DecalSystem.instance.UpdateTextureAtlas(cmd);       // as this is only used for transparent pass, would've been nice not to have to do this if no transparent renderers are visible, needs to happen after CreateDrawData
                         }
                     }
                     renderContext.SetupCameraProperties(camera, m_FrameSettings.enableStereo);
                     // TODO: Try to arrange code so we can trigger this call earlier and use async compute here to run sky convolution during other passes (once we move convolution shader to compute).
                     UpdateSkyEnvironment(hdCamera, cmd);
 
-                    RenderPyramidDepth(hdCamera, cmd, renderContext, FullScreenDebugMode.DepthPyramid);
+                    RenderDepthPyramid(hdCamera, cmd, renderContext, FullScreenDebugMode.DepthPyramid);
 
                     StopStereoRendering(renderContext, hdCamera.camera);
 
                             m_LightLoop.RenderShadows(renderContext, cmd, m_CullResults);
 
                             // Overwrite camera properties set during the shadow pass with the original camera properties.
-                            renderContext.SetupCameraProperties(camera, m_FrameSettings.enableStereo); 
+                            renderContext.SetupCameraProperties(camera, m_FrameSettings.enableStereo);
                             hdCamera.SetupGlobalParams(cmd, m_Time, m_LastTime);
                             if (m_FrameSettings.enableStereo) hdCamera.SetupGlobalStereoParams(cmd);
                         }
                         RenderForward(m_CullResults, hdCamera, renderContext, cmd, ForwardPass.PreRefraction);
                         RenderForwardError(m_CullResults, hdCamera, renderContext, cmd, ForwardPass.PreRefraction);
 
-                        RenderGaussianPyramidColor(hdCamera, cmd, renderContext, true);
+                        RenderColorPyramid(hdCamera, cmd, renderContext, true);
 
                         // Render all type of transparent forward (unlit, lit, complex (hair...)) to keep the sorting between transparent objects.
                         RenderForward(m_CullResults, hdCamera, renderContext, cmd, ForwardPass.Transparent);
                         RenderTransparentDepthPostpass(m_CullResults, hdCamera, renderContext, cmd, ForwardPass.Transparent);
 
-                        RenderGaussianPyramidColor(hdCamera, cmd, renderContext, false);
+                        RenderColorPyramid(hdCamera, cmd, renderContext, false);
 
                         AccumulateDistortion(m_CullResults, hdCamera, renderContext, cmd);
                         RenderDistortion(cmd, m_Asset.renderPipelineResources, hdCamera);
                     m_DebugScreenSpaceTracingData.GetData(m_DebugScreenSpaceTracingDataArray);
                     var data = m_DebugScreenSpaceTracingDataArray[0];
                     m_CurrentDebugDisplaySettings.screenSpaceTracingDebugData = data;
+
+                    // Assign -1 in tracing model to notifiy we took the data.
+                    // When debugging in forward, we want only the first time the pixel is drawn
+                    data.tracingModel = (Lit.RefractionSSRayModel)(-1);
+                    m_DebugScreenSpaceTracingDataArray[0] = data;
+                    m_DebugScreenSpaceTracingData.SetData(m_DebugScreenSpaceTracingDataArray);
                 }
             } // For each camera
         }
 
             using (new ProfilingSample(cmd, "ApplyDistortion", CustomSamplerId.ApplyDistortion.GetSampler()))
             {
-                Vector2 pyramidScale = m_BufferPyramid.GetPyramidToScreenScale(hdCamera);
+                var colorPyramidRT = hdCamera.GetPreviousFrameRT((int)HDCameraFrameHistoryType.ColorPyramid);
+                var pyramidScale = m_BufferPyramid.GetPyramidToScreenScale(hdCamera, colorPyramidRT);
 
                 // Need to account for the fact that the gaussian pyramid is actually rendered inside the camera viewport in a square texture so we mutiply by the PyramidToScreen scale
                 var size = new Vector4(hdCamera.screenSize.x, hdCamera.screenSize.y, pyramidScale.x / hdCamera.screenSize.x, pyramidScale.y / hdCamera.screenSize.y);
-                cmd.SetComputeTextureParam(m_applyDistortionCS, m_applyDistortionKernel, HDShaderIDs._ColorPyramidTexture, m_BufferPyramid.colorPyramid);
+                cmd.SetComputeTextureParam(m_applyDistortionCS, m_applyDistortionKernel, HDShaderIDs._ColorPyramidTexture, colorPyramidRT);
                 cmd.SetComputeTextureParam(m_applyDistortionCS, m_applyDistortionKernel, HDShaderIDs._CameraColorTexture, m_CameraColorBuffer);
                 cmd.SetComputeVectorParam(m_applyDistortionCS, HDShaderIDs._Size, size);
 
                 var camera = hdCamera.camera;
 
                 m_LightLoop.RenderForward(camera, cmd, pass == ForwardPass.Opaque);
+                var debugScreenSpaceTracing = m_CurrentDebugDisplaySettings.fullScreenDebugMode == FullScreenDebugMode.ScreenSpaceTracing;
 
                 if (pass == ForwardPass.Opaque)
                 {
                     var passNames = m_FrameSettings.enableForwardRenderingOnly
                         ? m_ForwardAndForwardOnlyPassNames
                         : m_ForwardOnlyPassNames;
+                    var debugSSTThisPass = debugScreenSpaceTracing && (m_CurrentDebugDisplaySettings.lightingDebugSettings.debugLightingMode == DebugLightingMode.ScreenSpaceTracingReflection);
+                    if (debugSSTThisPass)
+                    {
+                        cmd.SetGlobalBuffer(HDShaderIDs._DebugScreenSpaceTracingData, m_DebugScreenSpaceTracingData);
+                        cmd.SetRandomWriteTarget(7, m_DebugScreenSpaceTracingData);
+                    }
+                    if (debugSSTThisPass)
+                        cmd.ClearRandomWriteTargets();
-                    // Assign debug data
-                    if (m_CurrentDebugDisplaySettings.fullScreenDebugMode == FullScreenDebugMode.ScreenSpaceTracing
-                        && pass == ForwardPass.Transparent)
-                    {
-                        cmd.SetGlobalBuffer(HDShaderIDs._DebugScreenSpaceTracingData, m_DebugScreenSpaceTracingData);
-                        cmd.SetRandomWriteTarget(1, m_DebugScreenSpaceTracingData);
-                    }
-
-                    RenderTransparentRenderList(cullResults, camera, renderContext, cmd, m_AllTransparentPassNames, m_currentRendererConfigurationBakedLighting, pass == ForwardPass.PreRefraction ? HDRenderQueue.k_RenderQueue_PreRefraction : HDRenderQueue.k_RenderQueue_Transparent);
-                    if (m_CurrentDebugDisplaySettings.fullScreenDebugMode == FullScreenDebugMode.ScreenSpaceTracing
-                        && pass == ForwardPass.Transparent)
+                    var debugSSTThisPass = debugScreenSpaceTracing && (m_CurrentDebugDisplaySettings.lightingDebugSettings.debugLightingMode == DebugLightingMode.ScreenSpaceTracingRefraction);
+                    if (debugSSTThisPass)
-                        cmd.ClearRandomWriteTargets();
+                        cmd.SetGlobalBuffer(HDShaderIDs._DebugScreenSpaceTracingData, m_DebugScreenSpaceTracingData);
+                        cmd.SetRandomWriteTarget(7, m_DebugScreenSpaceTracingData);
+                    RenderTransparentRenderList(cullResults, camera, renderContext, cmd, m_AllTransparentPassNames, m_currentRendererConfigurationBakedLighting, pass == ForwardPass.PreRefraction ? HDRenderQueue.k_RenderQueue_PreRefraction : HDRenderQueue.k_RenderQueue_Transparent);
+                    if (debugSSTThisPass)
+                        cmd.ClearRandomWriteTargets();
                 }
             }
         }
             }
         }
 
-        void RenderGaussianPyramidColor(HDCamera hdCamera, CommandBuffer cmd, ScriptableRenderContext renderContext, bool isPreRefraction)
+        void RenderColorPyramid(HDCamera hdCamera, CommandBuffer cmd, ScriptableRenderContext renderContext, bool isPreRefraction)
         {
             if (isPreRefraction)
             {
                     return;
             }
 
-            using (new ProfilingSample(cmd, "Gaussian Pyramid Color", CustomSamplerId.GaussianPyramidColor.GetSampler()))
-                m_BufferPyramid.RenderColorPyramid(hdCamera, cmd, renderContext, m_CameraColorBuffer);
+            var cameraRT = hdCamera.GetCurrentFrameRT((int)HDCameraFrameHistoryType.ColorPyramid)
+                ?? hdCamera.AllocHistoryFrameRT((int)HDCameraFrameHistoryType.ColorPyramid, m_BufferPyramid.AllocColorRT);
-            Vector2 pyramidScale = m_BufferPyramid.GetPyramidToScreenScale(hdCamera);
-            PushFullScreenDebugTextureMip(cmd, m_BufferPyramid.colorPyramid, m_BufferPyramid.GetPyramidLodCount(hdCamera), new Vector4(pyramidScale.x, pyramidScale.y, 0.0f, 0.0f), hdCamera, isPreRefraction ? FullScreenDebugMode.PreRefractionColorPyramid : FullScreenDebugMode.FinalColorPyramid);
+            using (new ProfilingSample(cmd, "Color Pyramid", CustomSamplerId.ColorPyramid.GetSampler()))
+                m_BufferPyramid.RenderColorPyramid(hdCamera, cmd, renderContext, m_CameraColorBuffer, cameraRT);
+
+            Vector2 pyramidScale = m_BufferPyramid.GetPyramidToScreenScale(hdCamera, cameraRT);
+            PushFullScreenDebugTextureMip(cmd, cameraRT, m_BufferPyramid.GetPyramidLodCount(new Vector2Int(hdCamera.actualWidth, hdCamera.actualHeight)), new Vector4(pyramidScale.x, pyramidScale.y, 0.0f, 0.0f), hdCamera, isPreRefraction ? FullScreenDebugMode.PreRefractionColorPyramid : FullScreenDebugMode.FinalColorPyramid);
-        void RenderPyramidDepth(HDCamera hdCamera, CommandBuffer cmd, ScriptableRenderContext renderContext, FullScreenDebugMode debugMode)
+        void RenderDepthPyramid(HDCamera hdCamera, CommandBuffer cmd, ScriptableRenderContext renderContext, FullScreenDebugMode debugMode)
-            using (new ProfilingSample(cmd, "Pyramid Depth", CustomSamplerId.PyramidDepth.GetSampler()))
-                m_BufferPyramid.RenderDepthPyramid(hdCamera, cmd, renderContext, GetDepthTexture());
+            var cameraRT = hdCamera.GetCurrentFrameRT((int)HDCameraFrameHistoryType.DepthPyramid)
+                ?? hdCamera.AllocHistoryFrameRT((int)HDCameraFrameHistoryType.DepthPyramid, m_BufferPyramid.AllocDepthRT);
-            Vector2 pyramidScale = m_BufferPyramid.GetPyramidToScreenScale(hdCamera);
-            PushFullScreenDebugTextureMip(cmd, m_BufferPyramid.depthPyramid, m_BufferPyramid.GetPyramidLodCount(hdCamera), new Vector4(pyramidScale.x, pyramidScale.y, 0.0f, 0.0f), hdCamera, debugMode);
+            using (new ProfilingSample(cmd, "Depth Pyramid", CustomSamplerId.DepthPyramid.GetSampler()))
+                m_BufferPyramid.RenderDepthPyramid(hdCamera, cmd, renderContext, GetDepthTexture(), cameraRT);
+
+            Vector2 pyramidScale = m_BufferPyramid.GetPyramidToScreenScale(hdCamera, cameraRT);
+            PushFullScreenDebugTextureMip(cmd, cameraRT, m_BufferPyramid.GetPyramidLodCount(new Vector2Int(hdCamera.actualWidth, hdCamera.actualHeight)), new Vector4(pyramidScale.x, pyramidScale.y, 0.0f, 0.0f), hdCamera, debugMode);
         }
 
         void RenderPostProcess(HDCamera hdcamera, CommandBuffer cmd, PostProcessLayer layer)
             }
         }
 
-        public void PushColorPickerDebugTexture(CommandBuffer cmd, RTHandle textureID, HDCamera hdCamera)
+        public void PushColorPickerDebugTexture(CommandBuffer cmd, RTHandleSystem.RTHandle textureID, HDCamera hdCamera)
         {
             if (m_CurrentDebugDisplaySettings.colorPickerDebugSettings.colorPickerMode != ColorPickerDebugMode.None)
             {
             }
         }
 
-        public void PushFullScreenDebugTexture(CommandBuffer cmd, RTHandle textureID, HDCamera hdCamera, FullScreenDebugMode debugMode)
+        public void PushFullScreenDebugTexture(CommandBuffer cmd, RTHandleSystem.RTHandle textureID, HDCamera hdCamera, FullScreenDebugMode debugMode)
         {
             if (debugMode == m_CurrentDebugDisplaySettings.fullScreenDebugMode)
             {
         }
 
-        void PushFullScreenDebugTextureMip(CommandBuffer cmd, RTHandle texture, int lodCount, Vector4 scaleBias, HDCamera hdCamera, FullScreenDebugMode debugMode)
+        void PushFullScreenDebugTextureMip(CommandBuffer cmd, RTHandleSystem.RTHandle texture, int lodCount, Vector4 scaleBias, HDCamera hdCamera, FullScreenDebugMode debugMode)
         {
             if (debugMode == m_CurrentDebugDisplaySettings.fullScreenDebugMode)
             {
                     // (i.e. we have perform a flip, we need to flip the input texture)
                     m_DebugFullScreen.SetFloat(HDShaderIDs._RequireToFlipInputTexture, hdCamera.camera.cameraType != CameraType.SceneView ? 1.0f : 0.0f);
                     m_DebugFullScreen.SetBuffer(HDShaderIDs._DebugScreenSpaceTracingData, m_DebugScreenSpaceTracingData);
-                    m_DebugFullScreen.SetTexture(HDShaderIDs._DepthPyramidTexture, m_BufferPyramid.depthPyramid);
+                    m_DebugFullScreen.SetTexture(HDShaderIDs._DepthPyramidTexture, hdCamera.GetPreviousFrameRT((int)HDCameraFrameHistoryType.DepthPyramid));
                     HDUtils.DrawFullScreen(cmd, hdCamera, m_DebugFullScreen, (RenderTargetIdentifier)BuiltinRenderTextureType.CameraTarget);
 
                     PushColorPickerDebugTexture(cmd, (RenderTargetIdentifier)BuiltinRenderTextureType.CameraTarget, hdCamera);
                 }
 
                 m_LightLoop.RenderDebugOverlay(hdCamera, cmd, m_CurrentDebugDisplaySettings, ref x, ref y, overlaySize, hdCamera.actualWidth);
+
+                DecalSystem.instance.RenderDebugOverlay(hdCamera, cmd, m_CurrentDebugDisplaySettings, ref x, ref y, overlaySize, hdCamera.actualWidth);
 
                 if (m_CurrentDebugDisplaySettings.colorPickerDebugSettings.colorPickerMode != ColorPickerDebugMode.None)
                 {

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");
         public static readonly int _VBufferLightingFeedback    = Shader.PropertyToID("_VBufferLightingFeedback");
         public static readonly int _VBufferSampleOffset        = Shader.PropertyToID("_VBufferSampleOffset");
         public static readonly int _VolumeBounds               = Shader.PropertyToID("_VolumeBounds");
-        public static readonly int _VolumeProperties           = Shader.PropertyToID("_VolumeProperties");
+        public static readonly int _VolumeData                 = Shader.PropertyToID("_VolumeData");
         public static readonly int _NumVisibleDensityVolumes   = Shader.PropertyToID("_NumVisibleDensityVolumes");
     }
 }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/HDUtils.cs

             return Matrix4x4.Transpose(worldToViewMatrix.transpose * viewSpaceRasterTransform);
         }
 
-        private static void SetViewportAndClear(CommandBuffer cmd, HDCamera camera, RTHandle buffer, ClearFlag clearFlag, Color clearColor)
+        private static void SetViewportAndClear(CommandBuffer cmd, HDCamera camera, RTHandleSystem.RTHandle buffer, ClearFlag clearFlag, Color clearColor)
         {
             // Clearing a partial viewport currently does not go through the hardware clear.
             // Instead it goes through a quad rendered with a specific shader.
 
         // This set of RenderTarget management methods is supposed to be used when rendering into a camera dependent render texture.
         // This will automatically set the viewport based on the camera size and the RTHandle scaling info.
-        public static void SetRenderTarget(CommandBuffer cmd, HDCamera camera, RTHandle buffer, ClearFlag clearFlag, Color clearColor, int miplevel = 0, CubemapFace cubemapFace = CubemapFace.Unknown, int depthSlice = 0)
+        public static void SetRenderTarget(CommandBuffer cmd, HDCamera camera, RTHandleSystem.RTHandle buffer, ClearFlag clearFlag, Color clearColor, int miplevel = 0, CubemapFace cubemapFace = CubemapFace.Unknown, int depthSlice = 0)
-        public static void SetRenderTarget(CommandBuffer cmd, HDCamera camera, RTHandle buffer, ClearFlag clearFlag = ClearFlag.None, int miplevel = 0, CubemapFace cubemapFace = CubemapFace.Unknown, int depthSlice = 0)
+        public static void SetRenderTarget(CommandBuffer cmd, HDCamera camera, RTHandleSystem.RTHandle buffer, ClearFlag clearFlag = ClearFlag.None, int miplevel = 0, CubemapFace cubemapFace = CubemapFace.Unknown, int depthSlice = 0)
-        public static void SetRenderTarget(CommandBuffer cmd, HDCamera camera, RTHandle colorBuffer, RTHandle depthBuffer, int miplevel = 0, CubemapFace cubemapFace = CubemapFace.Unknown, int depthSlice = 0)
+        public static void SetRenderTarget(CommandBuffer cmd, HDCamera camera, RTHandleSystem.RTHandle colorBuffer, RTHandleSystem.RTHandle depthBuffer, int miplevel = 0, CubemapFace cubemapFace = CubemapFace.Unknown, int depthSlice = 0)
-        public static void SetRenderTarget(CommandBuffer cmd, HDCamera camera, RTHandle colorBuffer, RTHandle depthBuffer, ClearFlag clearFlag, int miplevel = 0, CubemapFace cubemapFace = CubemapFace.Unknown, int depthSlice = 0)
+        public static void SetRenderTarget(CommandBuffer cmd, HDCamera camera, RTHandleSystem.RTHandle colorBuffer, RTHandleSystem.RTHandle depthBuffer, ClearFlag clearFlag, int miplevel = 0, CubemapFace cubemapFace = CubemapFace.Unknown, int depthSlice = 0)
-        public static void SetRenderTarget(CommandBuffer cmd, HDCamera camera, RTHandle colorBuffer, RTHandle depthBuffer, ClearFlag clearFlag, Color clearColor, int miplevel = 0, CubemapFace cubemapFace = CubemapFace.Unknown, int depthSlice = 0)
+        public static void SetRenderTarget(CommandBuffer cmd, HDCamera camera, RTHandleSystem.RTHandle colorBuffer, RTHandleSystem.RTHandle depthBuffer, ClearFlag clearFlag, Color clearColor, int miplevel = 0, CubemapFace cubemapFace = CubemapFace.Unknown, int depthSlice = 0)
-        public static void SetRenderTarget(CommandBuffer cmd, HDCamera camera, RenderTargetIdentifier[] colorBuffers, RTHandle depthBuffer)
+        public static void SetRenderTarget(CommandBuffer cmd, HDCamera camera, RenderTargetIdentifier[] colorBuffers, RTHandleSystem.RTHandle depthBuffer)
-        public static void SetRenderTarget(CommandBuffer cmd, HDCamera camera, RenderTargetIdentifier[] colorBuffers, RTHandle depthBuffer, ClearFlag clearFlag = ClearFlag.None)
+        public static void SetRenderTarget(CommandBuffer cmd, HDCamera camera, RenderTargetIdentifier[] colorBuffers, RTHandleSystem.RTHandle depthBuffer, ClearFlag clearFlag = ClearFlag.None)
-        public static void SetRenderTarget(CommandBuffer cmd, HDCamera camera, RenderTargetIdentifier[] colorBuffers, RTHandle depthBuffer, ClearFlag clearFlag, Color clearColor)
+        public static void SetRenderTarget(CommandBuffer cmd, HDCamera camera, RenderTargetIdentifier[] colorBuffers, RTHandleSystem.RTHandle depthBuffer, ClearFlag clearFlag, Color clearColor)
         {
             cmd.SetRenderTarget(colorBuffers, depthBuffer);
             SetViewport(cmd, camera, depthBuffer);
         // When we render using a camera whose viewport is smaller than the RTHandles reference size (and thus smaller than the RT actual size), we need to set it explicitly (otherwise, native code will set the viewport at the size of the RT)
         // For auto-scaled RTs (like for example a half-resolution RT), we need to scale this viewport accordingly.
         // For non scaled RTs we just do nothing, the native code will set the viewport at the size of the RT anyway.
-        public static void SetViewport(CommandBuffer cmd, HDCamera camera, RTHandle target)
+        public static void SetViewport(CommandBuffer cmd, HDCamera camera, RTHandleSystem.RTHandle target)
         {
             if (target.useScaling)
             {
             cmd.DrawProcedural(Matrix4x4.identity, GetBlitMaterial(), bilinear ? 2 : 3, MeshTopology.Quads, 4, 1, s_PropertyBlock);
         }
 
-        public static void BlitTexture(CommandBuffer cmd, RTHandle source, RTHandle destination, Vector4 scaleBias, float mipLevel, bool bilinear)
+        public static void BlitTexture(CommandBuffer cmd, RTHandleSystem.RTHandle source, RTHandleSystem.RTHandle destination, Vector4 scaleBias, float mipLevel, bool bilinear)
         {
             s_PropertyBlock.SetTexture(HDShaderIDs._BlitTexture, source);
             s_PropertyBlock.SetVector(HDShaderIDs._BlitScaleBias, scaleBias);
         // It means that we can end up rendering inside a partial viewport for one of these "camera space" rendering.
         // In this case, we need to make sure than when we blit from one such camera texture to another, we only blit the necessary portion corresponding to the camera viewport.
         // Here, both source and destination are camera-scaled.
-        public static void BlitCameraTexture(CommandBuffer cmd, HDCamera camera, RTHandle source, RTHandle destination, float mipLevel = 0.0f, bool bilinear = false)
+        public static void BlitCameraTexture(CommandBuffer cmd, HDCamera camera, RTHandleSystem.RTHandle source, RTHandleSystem.RTHandle destination, float mipLevel = 0.0f, bool bilinear = false)
         {
             // Will set the correct camera viewport as well.
             SetRenderTarget(cmd, camera, destination);
         // This case, both source and destination are camera-scaled but we want to override the scale/bias parameter.
-        public static void BlitCameraTexture(CommandBuffer cmd, HDCamera camera, RTHandle source, RTHandle destination, Vector4 scaleBias, float mipLevel = 0.0f, bool bilinear = false)
+        public static void BlitCameraTexture(CommandBuffer cmd, HDCamera camera, RTHandleSystem.RTHandle source, RTHandleSystem.RTHandle destination, Vector4 scaleBias, float mipLevel = 0.0f, bool bilinear = false)
         {
             // Will set the correct camera viewport as well.
             SetRenderTarget(cmd, camera, destination);
-        public static void BlitCameraTexture(CommandBuffer cmd, HDCamera camera, RTHandle source, RTHandle destination, Rect destViewport, float mipLevel = 0.0f, bool bilinear = false)
+        public static void BlitCameraTexture(CommandBuffer cmd, HDCamera camera, RTHandleSystem.RTHandle source, RTHandleSystem.RTHandle destination, Rect destViewport, float mipLevel = 0.0f, bool bilinear = false)
         {
             SetRenderTarget(cmd, camera, destination);
             cmd.SetViewport(destViewport);
         // This particular case is for blitting a camera-scaled texture into a non scaling texture. So we setup the full viewport (implicit in cmd.Blit) but have to scale the input UVs.
-        public static void BlitCameraTexture(CommandBuffer cmd, HDCamera camera, RTHandle source, RenderTargetIdentifier destination)
+        public static void BlitCameraTexture(CommandBuffer cmd, HDCamera camera, RTHandleSystem.RTHandle source, RenderTargetIdentifier destination)
-        public static void BlitCameraTexture(CommandBuffer cmd, HDCamera camera, RenderTargetIdentifier source, RTHandle destination)
+        public static void BlitCameraTexture(CommandBuffer cmd, HDCamera camera, RenderTargetIdentifier source, RTHandleSystem.RTHandle destination)
         {
             // Will set the correct camera viewport as well.
             SetRenderTarget(cmd, camera, destination);
         // These method should be used to render full screen triangles sampling auto-scaling RTs.
         // This will set the proper viewport and UV scale.
         public static void DrawFullScreen(  CommandBuffer commandBuffer, HDCamera camera, Material material,
-                                            RTHandle colorBuffer,
+                                            RTHandleSystem.RTHandle colorBuffer,
                                             MaterialPropertyBlock properties = null, int shaderPassId = 0)
         {
             HDUtils.SetRenderTarget(commandBuffer, camera, colorBuffer);
 
         public static void DrawFullScreen(  CommandBuffer commandBuffer, HDCamera camera, Material material,
-                                            RTHandle colorBuffer, RTHandle depthStencilBuffer,
+                                            RTHandleSystem.RTHandle colorBuffer, RTHandleSystem.RTHandle depthStencilBuffer,
                                             MaterialPropertyBlock properties = null, int shaderPassId = 0)
         {
             HDUtils.SetRenderTarget(commandBuffer, camera, colorBuffer, depthStencilBuffer);
 
         public static void DrawFullScreen(  CommandBuffer commandBuffer, HDCamera camera, Material material,
-                                            RenderTargetIdentifier[] colorBuffers, RTHandle depthStencilBuffer,
+                                            RenderTargetIdentifier[] colorBuffers, RTHandleSystem.RTHandle depthStencilBuffer,
                                             MaterialPropertyBlock properties = null, int shaderPassId = 0)
         {
             HDUtils.SetRenderTarget(commandBuffer, camera, colorBuffers, depthStencilBuffer);

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightDefinition.cs

         public float weight;
         public float multiplier;
 
-        public Vector3 sampleDirectionDiscardWS;
         // Sampling properties
         public int envIndex;
     };

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightDefinition.cs.hlsl

     float3 boxSideFadeNegative;
     float weight;
     float multiplier;
-    float3 sampleDirectionDiscardWS;
     int envIndex;
 };
 
 float GetMultiplier(EnvLightData value)
 {
 	return value.multiplier;
-}
-float3 GetSampleDirectionDiscardWS(EnvLightData value)
-{
-	return value.sampleDirectionDiscardWS;
 }
 int GetEnvIndex(EnvLightData value)
 {

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

             var capturePosition = Vector3.zero;
             var influenceToWorld = probe.influenceToWorld;
 
-            var sampleDirectionDiscardWS = Vector3.zero;
-
             // 31 bits index, 1 bit cache type
             var envIndex = -1;
             if (probe.planarReflectionProbe != null)
                 // We transform it to object space by translating the capturePosition
                 var vp = gpuProj * gpuView * Matrix4x4.Translate(capturePosition);
                 m_Env2DCaptureVP[fetchIndex] = vp;
-                sampleDirectionDiscardWS = captureRotation * Vector3.forward;
             }
             else if (probe.reflectionProbe != null)
             {
             envLightData.blendDistanceNegative = probe.blendDistanceNegative;
             envLightData.boxSideFadePositive = probe.boxSideFadePositive;
             envLightData.boxSideFadeNegative = probe.boxSideFadeNegative;
-            envLightData.sampleDirectionDiscardWS = sampleDirectionDiscardWS;
 
             envLightData.influenceRight = influenceToWorld.GetColumn(0).normalized;
             envLightData.influenceUp = influenceToWorld.GetColumn(1).normalized;
                     m_lightList.bounds.AddRange(m_lightList.rightEyeBounds);
                     m_lightList.lightVolumes.AddRange(m_lightList.rightEyeLightVolumes);
                 }
-                
+
                 UpdateDataBuffers();
 
                 return m_enableBakeShadowMask;
                 // XRTODO: If possible, we could generate a non-oblique stereo projection
                 // matrix.  It's ok if it's not the exact same matrix, as long as it encompasses
                 // the same FOV as the original projection matrix (which would mean padding each half
-                // of the frustum with the max half-angle). We don't need the light information in 
+                // of the frustum with the max half-angle). We don't need the light information in
                 // real projection space.  We just use screen space to figure out what is proximal
                 // to a cluster or tile.
                 // Once we generate this non-oblique projection matrix, it can be shared across both eyes (un-array)
             public bool outputSplitLighting;
         }
 
-        public void RenderDeferredDirectionalShadow(HDCamera hdCamera, RTHandle deferredShadowRT, RenderTargetIdentifier depthTexture, CommandBuffer cmd)
+        public void RenderDeferredDirectionalShadow(HDCamera hdCamera, RTHandleSystem.RTHandle deferredShadowRT, RenderTargetIdentifier depthTexture, CommandBuffer cmd)
         {
             if (m_CurrentSunLight == null || m_CurrentSunLight.GetComponent<AdditionalShadowData>() == null || m_CurrentSunLightShadowIndex < 0)
             {

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

     [AddComponentMenu("Rendering/Homogeneous Density Volume", 1100)]
     public class HomogeneousDensityVolume : MonoBehaviour
     {
-        public DensityVolumeParameters parameters = new DensityVolumeParameters();
+        public DensityVolumeParameters parameters;
+
+        public HomogeneousDensityVolume()
+        {
+            parameters.albedo       = new Color(0.5f, 0.5f, 0.5f);
+            parameters.meanFreePath = 10.0f;
+            parameters.asymmetry    = 0.0f;
+        }
 
         private void Awake()
         {
 
         void OnDrawGizmos()
         {
-            if (parameters.IsLocalVolume())
-            {
-                Gizmos.color  = parameters.albedo;
-                Gizmos.matrix = transform.localToWorldMatrix;
-                Gizmos.DrawWireCube(Vector3.zero, Vector3.one);
-            }
-        }
-
-        // Returns NULL if a global fog component does not exist, or is not enabled.
-        public static HomogeneousDensityVolume GetGlobalHomogeneousDensityVolume()
-        {
-            HomogeneousDensityVolume globalVolume = null;
-
-            HomogeneousDensityVolume[] volumes = FindObjectsOfType(typeof(HomogeneousDensityVolume)) as HomogeneousDensityVolume[];
-
-            foreach (HomogeneousDensityVolume volume in volumes)
-            {
-                if (volume.enabled && !volume.parameters.IsLocalVolume())
-                {
-                    globalVolume = volume;
-                    break;
-                }
-            }
-
-            return globalVolume;
+            Gizmos.color  = parameters.albedo;
+            Gizmos.matrix = transform.localToWorldMatrix;
+            Gizmos.DrawWireCube(Vector3.zero, Vector3.one);
         }
     }
 } // UnityEngine.Experimental.Rendering.HDPipeline

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/Volumetrics/VBuffer.hlsl

 // Interpolation in the log space is non-linear.
 // Therefore, given 'logEncodedDepth', we compute a new depth value
 // which allows us to perform HW interpolation which is linear in the view space.
-float ComputeLerpPositionForLogEncoding(float linearDepth, float logEncodedDepth,
+float ComputeLerpPositionForLogEncoding(float  linearDepth,
+                                        float  logEncodedDepth,
                                         float2 VBufferSliceCount,
                                         float4 VBufferDepthDecodingParams)
 {
     float numSlices    = VBufferSliceCount.x;
     float rcpNumSlices = VBufferSliceCount.y;
 
-    float s0 = floor(d * numSlices - 0.5);
-    float s1 = ceil(d * numSlices - 0.5);
+    float s  = d * numSlices - 0.5;
+    float s0 = floor(s);
+    float s1 = ceil(s);
     float d0 = saturate(s0 * rcpNumSlices + (0.5 * rcpNumSlices));
     float d1 = saturate(s1 * rcpNumSlices + (0.5 * rcpNumSlices));
     float z0 = DecodeLogarithmicDepthGeneralized(d0, VBufferDepthDecodingParams);
     return d0 + t * rcpNumSlices;
 }
 
-// Performs trilinear reconstruction of the V-Buffer.
-// If (clampToEdge == false), out-of-bounds loads return 0.
-float4 SampleVBuffer(TEXTURE3D_ARGS(VBufferLighting, trilinearSampler), bool clampToEdge,
-                     float2 positionNDC, float linearDepth,
+// if (correctLinearInterpolation), we use ComputeLerpPositionForLogEncoding() to correct weighting
+// of both slices at the cost of extra ALUs.
+//
+// if (quadraticFilterXY), we perform biquadratic (3x3) reconstruction for each slice to reduce
+// aliasing at the cost of extra ALUs and bandwidth.
+// Warning: you MUST pass a linear sampler in order for the quadratic filter to work.
+//
+// Note: for correct filtering, the data has to be stored in the perceptual space.
+// 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).
+// 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_ARGS(VBuffer, clampSampler),
+                     float2 positionNDC,
+                     float  linearDepth,
+                     float4 VBufferResolution,
-                     float4 VBufferDepthDecodingParams)
+                     float4 VBufferDepthDecodingParams,
+                     bool   correctLinearInterpolation,
+                     bool   quadraticFilterXY,
+                     bool   clampToBorder)
-    float numSlices    = VBufferSliceCount.x;
-    float rcpNumSlices = VBufferSliceCount.y;
-
+    float  w;
-    // Unity doesn't support samplers clamping to border, so we have to do it ourselves.
-    // TODO: add the proper sampler support.
-    bool isInBounds = Min3(uv.x, uv.y, d) > 0 && Max3(uv.x, uv.y, d) < 1;
-
-    UNITY_BRANCH if (clampToEdge || isInBounds)
+    if (correctLinearInterpolation)
-    #if 1
+        // Adjust the texture coordinate for HW linear filtering.
+        w = ComputeLerpPositionForLogEncoding(z, d, VBufferSliceCount, VBufferDepthDecodingParams);
+    }
+    else
+    {
-        float w = d;
-    #else
-        // Adjust the texture coordinate for HW trilinear sampling.
-        float w = ComputeLerpPositionForLogEncoding(z, d, VBufferSliceCount, VBufferDepthDecodingParams);
-    #endif
+        w = d;
+    }
-        return SAMPLE_TEXTURE3D_LOD(VBufferLighting, trilinearSampler, float3(uv, w), 0);
+    float fadeWeight = 1;
+
+    if (clampToBorder)
+    {
+        // Compute the distance to the edge, and remap it to the [0, 1] range.
+        // TODO: add support for the HW border clamp sampler.
+        float weightU = saturate((1 - 2 * abs(uv.x - 0.5)) * VBufferResolution.x);
+        float weightV = saturate((1 - 2 * abs(uv.y - 0.5)) * VBufferResolution.y);
+        float weightW = saturate((1 - 2 * abs(w    - 0.5)) * VBufferSliceCount.x);
+
+        fadeWeight = weightU * weightV * weightW;
-    else
+
+    float4 result = 0;
+
+    if (fadeWeight > 0)
-        return 0;
-    }
-}
+        if (quadraticFilterXY)
+        {
+            float2 xy = uv * VBufferResolution.xy;
+            float2 ic = floor(xy);
+            float2 fc = frac(xy);
-// Returns interpolated {volumetric radiance, transmittance}. The sampler clamps to edge.
-float4 SampleInScatteredRadianceAndTransmittance(TEXTURE3D_ARGS(VBufferLighting, trilinearSampler),
-                                                 float2 positionNDC, float linearDepth,
-                                                 float4 VBufferResolution,
-                                                 float2 VBufferSliceCount,
-                                                 float4 VBufferDepthEncodingParams,
-                                                 float4 VBufferDepthDecodingParams)
-{
-#ifdef RECONSTRUCTION_FILTER_TRILINEAR
-    float4 L = SampleVBuffer(TEXTURE3D_PARAM(VBufferLighting, trilinearSampler), true,
-                             positionNDC, linearDepth,
-                             VBufferSliceCount,
-                             VBufferDepthEncodingParams,
-                             VBufferDepthDecodingParams);
-#else // Perform biquadratic reconstruction in XY, linear in Z, using 4x trilinear taps.
-    float2 uv = positionNDC;
-    float2 xy = uv * VBufferResolution.xy;
-    float2 ic = floor(xy);
-    float2 fc = frac(xy);
+            float2 weights[2], offsets[2];
+            BiquadraticFilter(1 - fc, weights, offsets); // Inverse-translate the filter centered around 0.5
-    // The distance between slices is log-encoded.
-    float z = linearDepth;
-    float d = EncodeLogarithmicDepthGeneralized(z, VBufferDepthEncodingParams);
+            result = (weights[0].x * weights[0].y) * SAMPLE_TEXTURE3D_LOD(VBuffer, clampSampler, float3((ic + float2(offsets[0].x, offsets[0].y)) * VBufferResolution.zw, w), 0)  // Top left
+                   + (weights[1].x * weights[0].y) * SAMPLE_TEXTURE3D_LOD(VBuffer, clampSampler, float3((ic + float2(offsets[1].x, offsets[0].y)) * VBufferResolution.zw, w), 0)  // Top right
+                   + (weights[0].x * weights[1].y) * SAMPLE_TEXTURE3D_LOD(VBuffer, clampSampler, float3((ic + float2(offsets[0].x, offsets[1].y)) * VBufferResolution.zw, w), 0)  // Bottom left
+                   + (weights[1].x * weights[1].y) * SAMPLE_TEXTURE3D_LOD(VBuffer, clampSampler, float3((ic + float2(offsets[1].x, offsets[1].y)) * VBufferResolution.zw, w), 0); // Bottom right
+        }
+        else
+        {
+            result = SAMPLE_TEXTURE3D_LOD(VBuffer, clampSampler, float3(uv, w), 0);
+        }
-#if 0
-    // Ignore non-linearity (for performance reasons) at the cost of accuracy.
-    // The results are exact for a stationary camera, but can potentially cause some judder in motion.
-    float w = d;
-#else
-    // Adjust the texture coordinate for HW trilinear sampling.
-    float w = ComputeLerpPositionForLogEncoding(z, d, VBufferSliceCount, VBufferDepthDecodingParams);
-#endif
+        result *= fadeWeight;
+    }
-    float2 weights[2], offsets[2];
-    BiquadraticFilter(1 - fc, weights, offsets); // Inverse-translate the filter centered around 0.5
+    return result;
+}
-    float2 rcpRes = VBufferResolution.zw;
+float4 SampleVBuffer(TEXTURE3D_ARGS(VBuffer, clampSampler),
+                     float3   positionWS,
+                     float4x4 viewProjMatrix,
+                     float4   VBufferResolution,
+                     float2   VBufferSliceCount,
+                     float4   VBufferDepthEncodingParams,
+                     float4   VBufferDepthDecodingParams,
+                     bool     correctLinearInterpolation,
+                     bool     quadraticFilterXY,
+                     bool     clampToBorder)
+{
+    float2 positionNDC = ComputeNormalizedDeviceCoordinates(positionWS, viewProjMatrix);
+    float  linearDepth = mul(viewProjMatrix, float4(positionWS, 1)).w;
-    // TODO: reconstruction should be performed in the perceptual space (e.i., after tone mapping).
-    // But our VBuffer is linear. How to achieve that?
-    // See "A Fresh Look at Generalized Sampling", p. 51.
-    float4 L = (weights[0].x * weights[0].y) * SAMPLE_TEXTURE3D_LOD(VBufferLighting, trilinearSampler, float3((ic + float2(offsets[0].x, offsets[0].y)) * rcpRes, w), 0)  // Top left
-             + (weights[1].x * weights[0].y) * SAMPLE_TEXTURE3D_LOD(VBufferLighting, trilinearSampler, float3((ic + float2(offsets[1].x, offsets[0].y)) * rcpRes, w), 0)  // Top right
-             + (weights[0].x * weights[1].y) * SAMPLE_TEXTURE3D_LOD(VBufferLighting, trilinearSampler, float3((ic + float2(offsets[0].x, offsets[1].y)) * rcpRes, w), 0)  // Bottom left
-             + (weights[1].x * weights[1].y) * SAMPLE_TEXTURE3D_LOD(VBufferLighting, trilinearSampler, float3((ic + float2(offsets[1].x, offsets[1].y)) * rcpRes, w), 0); // Bottom right
-#endif
+    return SampleVBuffer(TEXTURE3D_PARAM(VBuffer, clampSampler),
+                         positionNDC,
+                         linearDepth,
+                         VBufferResolution,
+                         VBufferSliceCount,
+                         VBufferDepthEncodingParams,
+                         VBufferDepthDecodingParams,
+                         correctLinearInterpolation,
+                         quadraticFilterXY,
+                         clampToBorder);
+}
-    // TODO: add some animated noise to the reconstructed radiance.
-    return float4(L.rgb, Transmittance(L.a));
+// Returns interpolated {volumetric radiance, transmittance}.
+float4 SampleVolumetricLighting(TEXTURE3D_ARGS(VBufferLighting, clampSampler),
+                                float2 positionNDC,
+                                float  linearDepth,
+                                float4 VBufferResolution,
+                                float2 VBufferSliceCount,
+                                float4 VBufferDepthEncodingParams,
+                                float4 VBufferDepthDecodingParams,
+                                bool   correctLinearInterpolation,
+                                bool   quadraticFilterXY)
+{
+    // TODO: add some slowly animated noise to the reconstructed value.
+    return FastTonemapInvert(SampleVBuffer(TEXTURE3D_PARAM(VBufferLighting, clampSampler),
+                                           positionNDC,
+                                           linearDepth,
+                                           VBufferResolution,
+                                           VBufferSliceCount,
+                                           VBufferDepthEncodingParams,
+                                           VBufferDepthDecodingParams,
+                                           correctLinearInterpolation,
+                                           quadraticFilterXY,
+                                           false));
 }
 
 #endif // UNITY_VBUFFER_INCLUDED

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

 //--------------------------------------------------------------------------------------------------
 
 StructuredBuffer<OrientedBBox>            _VolumeBounds;
-StructuredBuffer<DensityVolumeProperties> _VolumeProperties;
+StructuredBuffer<DensityVolumeProperties> _VolumeData;
 
 RW_TEXTURE3D(float4, _VBufferDensity); // RGB = sqrt(scattering), A = sqrt(extinction)
 
                 if (overlapFraction > 0)
                 {
                     // There is an overlap. Sample the 3D texture, or load the constant value.
-                    voxelScattering += overlapFraction * _VolumeProperties[volumeIndex].scattering;
-                    voxelExtinction += overlapFraction * _VolumeProperties[volumeIndex].extinction;
+                    voxelScattering += overlapFraction * _VolumeData[volumeIndex].scattering;
+                    voxelExtinction += overlapFraction * _VolumeData[volumeIndex].extinction;
                 }
 
     #ifndef USE_CLUSTERED_LIGHTLIST

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

     #define VBUFFER_SLICE_COUNT 128
 #endif
 
-#define SUPPORT_ASYMMETRY       1 // Support asymmetric phase functions
 #define SUPPORT_PUNCTUAL_LIGHTS 1 // Punctual lights contribute to fog lighting
 
 #define GROUP_SIZE_1D 8
 //--------------------------------------------------------------------------------------------------
 
 #include "CoreRP/ShaderLibrary/Common.hlsl"
+#include "CoreRP/ShaderLibrary/Color.hlsl"
 #include "CoreRP/ShaderLibrary/Filtering.hlsl"
 #include "CoreRP/ShaderLibrary/VolumeRendering.hlsl"
 
 // Implementation
 //--------------------------------------------------------------------------------------------------
 
+// A ray with a single origin and two directions:
+// one pointing at the center of the voxel, and one jittered in screen space.
-    float3 strataDirWS;       // Normalized, tile-stratified
-    float3 centerDirWS;       // Normalized, tile-centered
-    float  strataDirInvViewZ; // 1 / ViewSpace(strataDirWS).z
-    float  twoDirRatioViewZ;  // ViewSpace(strataDirWS).z / ViewSpace(centerDirWS).z
+    float3 jitterDirWS;       // Normalized, voxel-jittered in the screen space
+    float3 centerDirWS;       // Normalized, voxel-centered in the screen space
+    float  jitterDirInvViewZ; // 1 / ViewSpace(jitterDirWS).z
+    float  twoDirRatioViewZ;  // ViewSpace(jitterDirWS).z / ViewSpace(centerDirWS).z
-// Returns a point along the stratified direction.
+float ConvertLinearDepthToJitterRayDist(DualRay ray, float z)
+{
+    return z * ray.jitterDirInvViewZ;
+}
+
+float ConvertJitterDistToCenterRayDist(DualRay ray, float t)
+{
+    return t * ray.twoDirRatioViewZ;
+}
+
+// Returns a point along the jittered direction.
-    return ray.originWS + t * ray.strataDirWS;
+    return ray.originWS + t * ray.jitterDirWS;
-// Returns a point along the centered direction. It has a special property:
-// ViewSpace(GetPointAtDistance(ray, t)).z = ViewSpace(GetCenterAtDistance(ray, t)).z,
-// e.i. both points computed from the same value of 't' reside on the same Z-plane in the view space.
-float3 GetCenterAtDistance(DualRay ray, float t)
+// Returns a point along the centered direction.
+float3 GetCenterAtDistance(DualRay ray, float s)
-    t *= ray.twoDirRatioViewZ; // Perform the Z-coordinate conversion
-    return ray.originWS + t * ray.centerDirWS;
+    return ray.originWS + s * ray.centerDirWS;
 }
 
 struct VoxelLighting
                                       color, attenuation);
 
             // Important:
-            // Ideally, all scattering calculations should use the stratified versions
+            // Ideally, all scattering calculations should use the jittered versions
             // of the sample position and the ray direction. However, correct reprojection
             // of asymmetrically scattered lighting (affected by an anisotropic phase
             // function) is not possible. We work around this issue by reprojecting
                     float3 coneAxisX = lenMul * light.right;
                     float3 coneAxisY = lenMul * light.up;
 
-                    sampleLight = IntersectRayCone(ray.originWS, ray.strataDirWS,
+                    sampleLight = IntersectRayCone(ray.originWS, ray.jitterDirWS,
                                                    light.positionWS, light.forward,
                                                    coneAxisX, coneAxisY,
                                                    t0, t1, tEntr, tExit);
 
                     float t, distSq, rcpPdf;
                     ImportanceSamplePunctualLight(rndVal, light.positionWS,
-                                                  ray.originWS, ray.strataDirWS,
+                                                  ray.originWS, ray.jitterDirWS,
                                                   tEntr, tExit, t, distSq, rcpPdf,
                                                   hackMinDistSq);
 
                     float3 L             = -lightToSample * distRcp;
 
                     float3 color; float attenuation;
-                    EvaluateLight_Punctual(context, posInput, light, unused, 0, L, lightToSample,
-                                           distances, color, attenuation);
+                    EvaluateLight_Punctual(context, posInput, light, unused,
+                                           0, L, lightToSample, distances, color, attenuation);
-                    // Ideally, all scattering calculations should use the stratified versions
+                    // Ideally, all scattering calculations should use the jittered versions
                     // of the sample position and the ray direction. However, correct reprojection
                     // of asymmetrically scattered lighting (affected by an anisotropic phase
                     // function) is not possible. We work around this issue by reprojecting
                 float3x3 rotMat = float3x3(light.right, light.up, light.forward);
 
                 float3 o = mul(rotMat, ray.originWS - light.positionWS);
-                float3 d = mul(rotMat, ray.strataDirWS);
+                float3 d = mul(rotMat, ray.jitterDirWS);
 
                 float  range  = light.size.x;
                 float3 boxPt0 = float3(-1, -1, 0);
                     float4 distances     = float4(1, 1, 1, distProj);
 
                     float3 color; float attenuation;
-                    EvaluateLight_Punctual(context, posInput, light, unused, 0, L, lightToSample,
-                                           distances, color, attenuation);
+                    EvaluateLight_Punctual(context, posInput, light, unused,
+                                           0, L, lightToSample, distances, color, attenuation);
-                    // Ideally, all scattering calculations should use the stratified versions
+                    // Ideally, all scattering calculations should use the jittered versions
                     // of the sample position and the ray direction. However, correct reprojection
                     // of asymmetrically scattered lighting (affected by an anisotropic phase
                     // function) is not possible. We work around this issue by reprojecting
 void FillVolumetricLightingBuffer(LightLoopContext context, uint featureFlags,
                                   PositionInputs posInput, DualRay ray)
 {
-    float n  = _VBufferDepthDecodingParams.x + _VBufferDepthDecodingParams.z;
-    float z0 = n;                          // Start integration from the near plane
-    float t0 = ray.strataDirInvViewZ * z0; // Convert view space Z to distance along the stratified ray
-    float de = rcp(VBUFFER_SLICE_COUNT);   // Log-encoded distance between slices
+    const float n  = _VBufferDepthDecodingParams.x + _VBufferDepthDecodingParams.z;
+    const float z0 = n;                        // Start integration from the near plane
+    const float de = rcp(VBUFFER_SLICE_COUNT); // Log-encoded distance between slices
+
+    float t0 = ConvertLinearDepthToJitterRayDist(ray, z0);
 
     // The contribution of the ambient probe does not depend on the position,
     // only on the direction and the length of the interval.
         uint3 voxelCoord = uint3(posInput.positionSS, slice);
 
         float e1 = slice * de + de; // (slice + 1) / sliceCount
-#if defined(SHADER_API_METAL)
-        // Warning: this compiles, but it's nonsense. Use DecodeLogarithmicDepthGeneralized().
-        float z1 = DecodeLogarithmicDepth(e1, _VBufferDepthDecodingParams);
-#else
-#endif
-        float t1 = ray.strataDirInvViewZ * z1; // Convert view space Z to distance along the stratified ray
+        float t1 = ConvertLinearDepthToJitterRayDist(ray, z1);
         float dt = t1 - t0;
 
     #ifdef USE_CLUSTERED_LIGHTLIST
         // Compute the -exact- position of the center of the voxel.
         // It's important since the accumulated value of the integral is stored at the center.
         // We will use it for participating media sampling, asymmetric scattering and reprojection.
-        float  tc       = t0 + 0.5 * dt;
-        float3 centerWS = GetCenterAtDistance(ray, tc);
+        float  s        = ConvertJitterDistToCenterRayDist(ray, t0 + 0.5 * dt);
+        float3 centerWS = GetCenterAtDistance(ray, s);
-        // Sample the participating medium at 'tc' (or 'centerWS').
+        // Sample the participating medium at the center of the voxel.
         // We consider it to be constant along the interval [t0, t1] (within the voxel).
         // TODO: piecewise linear.
         float3 scattering = LOAD_TEXTURE3D(_VBufferDensity, voxelCoord).rgb;
                                                        );
                                                    #endif
     #if ENABLE_REPROJECTION
+
-        float2 reprojPosNDC = ComputeNormalizedDeviceCoordinates(centerWS, _PrevViewProjMatrix);
-        float  reprojZ      = mul(_PrevViewProjMatrix, float4(centerWS, 1)).w;
-        float4 reprojValue  = SampleVBuffer(TEXTURE3D_PARAM(_VBufferLightingHistory, s_trilinear_clamp_sampler),
-                                            false, reprojPosNDC, reprojZ,
-                                            _VBufferSliceCount.xy,
-                                            _VBufferDepthEncodingParams,
-                                            _VBufferDepthDecodingParams);
+        float4 reprojValue = SampleVBuffer(TEXTURE3D_PARAM(_VBufferLightingHistory, s_linear_clamp_sampler),
+                                           centerWS,
+                                           _PrevViewProjMatrix,
+                                           _VBufferResolution,
+                                           _VBufferSliceCount.xy,
+                                           _VBufferDepthEncodingParams,
+                                           _VBufferDepthDecodingParams,
+                                           false, false, true);
 
         // Compute the exponential moving average over 'n' frames:
         // X = (1 - a) * ValueAtFrame[n] + a * AverageOverPreviousFrames.
         // TODO: doesn't seem to be worth it, removed for now.
 
         // Perform temporal blending.
-        // Both radiance values are obtained by integrating over line segments of different length.
-        // Blending only makes sense if the length of both intervals is the same.
-        // Therefore, the reprojected radiance needs to be rescaled by (frame_dt / reproj_dt).
+        // Both radiance values are obtained by integrating over line segments of different length,
+        // with potentially different participating media coverage.
+        // Blending only makes sense if the voxels are virtually identical.
+        // Therefore, we need to rescale the history to make it match the current configuration.
+        // In order to do that, we integrate transmittance over the length of the ray interval
+        // passing through the center of the voxel. The integral can be interpreted as the amount of
+        // isotropically in-scattered radiance from a directional light with unit intensity.
+        // We ignore jittering, as we want values from the same voxel to be reporojected without
+        // any rescaling.
+        float  ds              = ConvertJitterDistToCenterRayDist(ray, dt);
+        float  centerTransmInt = TransmittanceIntegralHomogeneousMedium(extinction, ds);
+
-        float  reprojRcpLen    = reprojSuccess ? rcp(reprojValue.a) : 0;
-        float  lengthScale     = dt * reprojRcpLen;
+        float  reprojScale     = reprojSuccess ? (centerTransmInt * rcp(reprojValue.a)) : 0;
-        float3 blendedRadiance = (1 - blendFactor) * lighting.radianceNoPhase + blendFactor * lengthScale * reprojRadiance;
+        float3 blendedRadiance = (1 - blendFactor) * lighting.radianceNoPhase + blendFactor * reprojScale * reprojRadiance;
 
         // Store the feedback for the voxel.
         // TODO: dynamic lights (which update their position, rotation, cookie or shadow at runtime)
 
-        _VBufferLightingFeedback[voxelCoord] = float4(blendedRadiance, dt);
+        _VBufferLightingFeedback[voxelCoord] = float4(blendedRadiance, centerTransmInt);
-    #if SUPPORT_ASYMMETRY
-    #endif
-
-    #if SUPPORT_ASYMMETRY
-    #else
-        float3 blendedRadiance = lighting.radianceNoPhase;
-    #endif
-
-
-    #if SUPPORT_ASYMMETRY
-        float phase = _CornetteShanksConstant;
-    #else
-        float phase = IsotropicPhaseFunction();
-    #endif
-
-        float4 integral = float4(totalRadiance, opticalDepth);
+        float phase         = _CornetteShanksConstant;
 
         // Integrate the contribution of the probe over the interval.
         // Integral{a, b}{Transmittance(0, t) * L_s(t) dt} = Transmittance(0, a) * Integral{a, b}{Transmittance(0, t - a) * L_s(t) dt}.
         opticalDepth += 0.5 * extinction * dt;
 
         // Store the voxel data.
-        _VBufferLightingIntegral[voxelCoord] = float4(totalRadiance, opticalDepth);
+        // Note: for correct filtering, the data has to be stored in the perceptual space.
+        // This means storing the tone mapped radiance and transmittance instead of optical depth.
+        // See "A Fresh Look at Generalized Sampling", p. 51.
+        _VBufferLightingIntegral[voxelCoord] = float4(FastTonemap(totalRadiance), Transmittance(opticalDepth));
-        z0 = z1;
         t0 = t1;
 
     #ifdef USE_CLUSTERED_LIGHTLIST
 
     float2 centerCoord = voxelCoord + float2(0.5, 0.5);
 #if ENABLE_REPROJECTION
-    float2 strataCoord = centerCoord + _VBufferSampleOffset.xy;
+    float2 jitterCoord = centerCoord + _VBufferSampleOffset.xy;
-    float2 strataCoord = centerCoord;
+    float2 jitterCoord = centerCoord;
-    // Compute the (tile-centered) ray direction s.t. its ViewSpace(rayDirWS).z = 1.
+    // Compute the (voxel-centered in the screen space) ray direction s.t. its ViewSpace(rayDirWS).z = 1.
-    // Compute the (tile-stratified) ray direction s.t. its ViewSpace(rayDirWS).z = 1.
-    float3 strataDirWS     = mul(-float3(strataCoord, 1), (float3x3)_VBufferCoordToViewDirWS);
-    float  strataDirLenSq  = dot(strataDirWS, strataDirWS);
-    float  strataDirLenRcp = rsqrt(strataDirLenSq);
-    float  strataDirLen    = strataDirLenSq * strataDirLenRcp;
+    // Compute the (voxel-jittered in the screen space) ray direction s.t. its ViewSpace(rayDirWS).z = 1.
+    float3 jitterDirWS     = mul(-float3(jitterCoord, 1), (float3x3)_VBufferCoordToViewDirWS);
+    float  jitterDirLenSq  = dot(jitterDirWS, jitterDirWS);
+    float  jitterDirLenRcp = rsqrt(jitterDirLenSq);
+    float  jitterDirLen    = jitterDirLenSq * jitterDirLenRcp;
-    ray.strataDirWS       = strataDirWS * strataDirLenRcp;  // Normalize
+    ray.jitterDirWS       = jitterDirWS * jitterDirLenRcp;  // Normalize
-    ray.strataDirInvViewZ = strataDirLen;                   // View space Z
-    ray.twoDirRatioViewZ  = centerDirLen * strataDirLenRcp; // View space Z ratio
+    ray.jitterDirInvViewZ = jitterDirLen;                   // View space Z
+    ray.twoDirRatioViewZ  = centerDirLen * jitterDirLenRcp; // View space Z ratio
 
     // TODO
     LightLoopContext context;

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

 namespace UnityEngine.Experimental.Rendering.HDPipeline
 {
 [GenerateHLSL]
-public struct DensityVolumeProperties
+public struct DensityVolumeData
-    public static DensityVolumeProperties GetNeutralProperties()
+    public static DensityVolumeData GetNeutralValues()
-        DensityVolumeProperties properties = new DensityVolumeProperties();
+        DensityVolumeData data;
-        properties.scattering = Vector3.zero;
-        properties.extinction = 0;
+        data.scattering = Vector3.zero;
+        data.extinction = 0;
-        return properties;
+        return data;
-[Serializable]
-public class DensityVolumeParameters
+public class VolumeRenderingUtils
-    public bool  isLocal;      // Enables voxelization
-    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;    // Only used if (isLocal == false)
-
-    public DensityVolumeParameters()
+    public static float MeanFreePathFromExtinction(float extinction)
-        isLocal      = true;
-        albedo       = new Color(0.5f, 0.5f, 0.5f);
-        meanFreePath = 10.0f;
-        asymmetry    = 0.0f;
+        return 1.0f / extinction;
-    public bool IsLocalVolume()
+    public static float ExtinctionFromMeanFreePath(float meanFreePath)
-        return isLocal;
+        return 1.0f / meanFreePath;
-    public Vector3 GetAbsorptionCoefficient()
+    public static Vector3 AbsorptionFromExtinctionAndScattering(float extinction, Vector3 scattering)
-        float   extinction = GetExtinctionCoefficient();
-        Vector3 scattering = GetScatteringCoefficient();
-
-        return Vector3.Max(new Vector3(extinction, extinction, extinction) - scattering, Vector3.zero);
+        return new Vector3(extinction, extinction, extinction) - scattering;
-    public Vector3 GetScatteringCoefficient()
+    public static Vector3 ScatteringFromExtinctionAndAlbedo(float extinction, Vector3 albedo)
-        float extinction = GetExtinctionCoefficient();
-
-        return new Vector3(albedo.r * extinction, albedo.g * extinction, albedo.b * extinction);
+        return extinction * albedo;
-    public float GetExtinctionCoefficient()
+    public static Vector3 AlbedoFromMeanFreePathAndScattering(float meanFreePath, Vector3 scattering)
-        return 1.0f / meanFreePath;
+        return meanFreePath * scattering;
+}
+
+[Serializable]
+public struct DensityVolumeParameters
+{
+    public Color albedo;       // Single scattering albedo [0, 1]. Alpha is ignored
+    public float meanFreePath; // In meters [1, inf]. Should be chromatic - this is an optimization!
+    public float asymmetry;    // Only used if (isLocal == false)
 
     public void Constrain()
     {
+        albedo.a = 1.0f;
-        meanFreePath = Mathf.Max(meanFreePath, 1.0f);
+        meanFreePath = Mathf.Clamp(meanFreePath, 1.0f, float.MaxValue);
-    public DensityVolumeProperties GetProperties()
+    public DensityVolumeData GetData()
-        DensityVolumeProperties properties = new DensityVolumeProperties();
+        DensityVolumeData data = new DensityVolumeData();
-        properties.scattering = GetScatteringCoefficient();
-        properties.extinction = GetExtinctionCoefficient();
+        data.extinction = VolumeRenderingUtils.ExtinctionFromMeanFreePath(meanFreePath);
+        data.scattering = VolumeRenderingUtils.ScatteringFromExtinctionAndAlbedo(data.extinction, (Vector3)(Vector4)albedo);
-        return properties;
+        return data;
-    public List<OrientedBBox>            bounds;
-    public List<DensityVolumeProperties> properties;
+    public List<OrientedBBox>      bounds;
+    public List<DensityVolumeData> density;
 }
 
 public class VolumetricLightingSystem
     ComputeShader m_VolumeVoxelizationCS = null;
     ComputeShader m_VolumetricLightingCS = null;
 
-    List<VBuffer>                 m_VBuffers                = null;
-    List<OrientedBBox>            m_VisibleVolumeBounds     = null;
-    List<DensityVolumeProperties> m_VisibleVolumeProperties = null;
-    public const int              k_MaxVisibleVolumeCount   = 512;
+    List<VBuffer>           m_VBuffers              = null;
+    List<OrientedBBox>      m_VisibleVolumeBounds   = null;
+    List<DensityVolumeData> m_VisibleVolumeData     = null;
+    public const int        k_MaxVisibleVolumeCount = 512;
-    static ComputeBuffer s_VisibleVolumePropertiesBuffer = null;
+    static ComputeBuffer s_VisibleVolumeDataBuffer = null;
 
     float       m_VBufferNearPlane = 0.5f;  // Distance in meters; dynamic modifications not handled by reprojection
     float       m_VBufferFarPlane  = 64.0f; // Distance in meters; dynamic modifications not handled by reprojection
     {
         if (preset == VolumetricLightingPreset.Off) return;
 
-        m_VolumeVoxelizationCS          = asset.renderPipelineResources.volumeVoxelizationCS;
-        m_VolumetricLightingCS          = asset.renderPipelineResources.volumetricLightingCS;
-        m_VBuffers                      = new List<VBuffer>();
-        m_VisibleVolumeBounds           = new List<OrientedBBox>();
-        m_VisibleVolumeProperties       = new List<DensityVolumeProperties>();
-        s_VisibleVolumeBoundsBuffer     = new ComputeBuffer(k_MaxVisibleVolumeCount, System.Runtime.InteropServices.Marshal.SizeOf(typeof(OrientedBBox)));
-        s_VisibleVolumePropertiesBuffer = new ComputeBuffer(k_MaxVisibleVolumeCount, System.Runtime.InteropServices.Marshal.SizeOf(typeof(DensityVolumeProperties)));
+        m_VolumeVoxelizationCS      = asset.renderPipelineResources.volumeVoxelizationCS;
+        m_VolumetricLightingCS      = asset.renderPipelineResources.volumetricLightingCS;
+        m_VBuffers                  = new List<VBuffer>();
+        m_VisibleVolumeBounds       = new List<OrientedBBox>();
+        m_VisibleVolumeData         = new List<DensityVolumeData>();
+        s_VisibleVolumeBoundsBuffer = new ComputeBuffer(k_MaxVisibleVolumeCount, System.Runtime.InteropServices.Marshal.SizeOf(typeof(OrientedBBox)));
+        s_VisibleVolumeDataBuffer   = new ComputeBuffer(k_MaxVisibleVolumeCount, System.Runtime.InteropServices.Marshal.SizeOf(typeof(DensityVolumeData)));
     }
 
     public void Cleanup()
             m_VBuffers[i].Destroy();
         }
 
-        m_VBuffers                = null;
-        m_VisibleVolumeBounds     = null;
-        m_VisibleVolumeProperties = null;
+        m_VBuffers            = null;
+        m_VisibleVolumeBounds = null;
+        m_VisibleVolumeData   = null;
-        CoreUtils.SafeRelease(s_VisibleVolumePropertiesBuffer);
+        CoreUtils.SafeRelease(s_VisibleVolumeDataBuffer);
     }
 
     public void ResizeVBuffer(HDCamera camera, int screenWidth, int screenHeight)
     {
         if (preset == VolumetricLightingPreset.Off) return;
 
-        HomogeneousDensityVolume globalVolume = HomogeneousDensityVolume.GetGlobalHomogeneousDensityVolume();
-
-        // TODO: may want to cache these results somewhere.
-        DensityVolumeProperties globalVolumeProperties = (globalVolume != null) ? globalVolume.parameters.GetProperties()
-                                                                                : DensityVolumeProperties.GetNeutralProperties();
-
-        float asymmetry = globalVolume != null ? globalVolume.parameters.asymmetry : 0;
-        cmd.SetGlobalVector(HDShaderIDs._GlobalScattering, globalVolumeProperties.scattering);
-        cmd.SetGlobalFloat( HDShaderIDs._GlobalExtinction, globalVolumeProperties.extinction);
-        cmd.SetGlobalFloat( HDShaderIDs._GlobalAsymmetry,  asymmetry);
+        // 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.
+        m_VBufferNearPlane = camera.camera.nearClipPlane;
 
         VBuffer vBuffer = FindVBuffer(camera.GetViewID());
         Debug.Assert(vBuffer != null);
 
-        SetPreconvolvedAmbientLightProbe(cmd, asymmetry);
+        // Get the interpolated asymmetry value.
+        var fog = VolumeManager.instance.stack.GetComponent<VolumetricFog>();
+
+        SetPreconvolvedAmbientLightProbe(cmd, fog.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));
 
         if (preset == VolumetricLightingPreset.Off) return densityVolumes;
 
+        var visualEnvironment = VolumeManager.instance.stack.GetComponent<VisualEnvironment>();
+
+        if (visualEnvironment.fogType != FogType.Volumetric) return densityVolumes;
+
         using (new ProfilingSample(cmd, "Prepare Visible Density Volume List"))
         {
             Vector3 camPosition = camera.camera.transform.position;
             }
 
             m_VisibleVolumeBounds.Clear();
-            m_VisibleVolumeProperties.Clear();
+            m_VisibleVolumeData.Clear();
 
             // Collect all visible finite volume data, and upload it to the GPU.
             HomogeneousDensityVolume[] volumes = Object.FindObjectsOfType(typeof(HomogeneousDensityVolume)) as HomogeneousDensityVolume[];
                 HomogeneousDensityVolume volume = volumes[i];
 
                 // Only test active finite volumes.
-                if (volume.enabled && volume.parameters.IsLocalVolume())
+                if (volume.enabled)
                 {
                     // TODO: cache these?
                     var obb = OrientedBBox.Create(volume.transform);
                     if (GeometryUtils.Overlap(obb, camera.frustum, 6, 8))
                     {
                         // TODO: cache these?
-                        var properties = volume.parameters.GetProperties();
+                        var data = volume.parameters.GetData();
-                        m_VisibleVolumeProperties.Add(properties);
+                        m_VisibleVolumeData.Add(data);
-            s_VisibleVolumePropertiesBuffer.SetData(m_VisibleVolumeProperties);
+            s_VisibleVolumeDataBuffer.SetData(m_VisibleVolumeData);
-            densityVolumes.properties = m_VisibleVolumeProperties;
+            densityVolumes.density = m_VisibleVolumeData;
 
             return densityVolumes;
         }
             float     vFoV       = camera.camera.fieldOfView * Mathf.Deg2Rad;
             Vector4   resolution = new Vector4(w, h, 1.0f / w, 1.0f / h);
             Matrix4x4 transform  = HDUtils.ComputePixelCoordToWorldSpaceViewDirectionMatrix(vFoV, resolution, camera.viewMatrix, false);
-                                   
-            cmd.SetComputeTextureParam(m_VolumeVoxelizationCS, kernel, HDShaderIDs._VBufferDensity,   vBuffer.GetDensityBuffer());
-            cmd.SetComputeBufferParam( m_VolumeVoxelizationCS, kernel, HDShaderIDs._VolumeBounds,     s_VisibleVolumeBoundsBuffer);
-            cmd.SetComputeBufferParam( m_VolumeVoxelizationCS, kernel, HDShaderIDs._VolumeProperties, s_VisibleVolumePropertiesBuffer);
+
+            cmd.SetComputeTextureParam(m_VolumeVoxelizationCS, kernel, HDShaderIDs._VBufferDensity, vBuffer.GetDensityBuffer());
+            cmd.SetComputeBufferParam( m_VolumeVoxelizationCS, kernel, HDShaderIDs._VolumeBounds,   s_VisibleVolumeBoundsBuffer);
+            cmd.SetComputeBufferParam( m_VolumeVoxelizationCS, kernel, HDShaderIDs._VolumeData,     s_VisibleVolumeDataBuffer);
 
             // TODO: set the constant buffer data only once.
             cmd.SetComputeMatrixParam( m_VolumeVoxelizationCS, HDShaderIDs._VBufferCoordToViewDirWS,  transform);
 
         using (new ProfilingSample(cmd, "Volumetric Lighting"))
         {
-            VBuffer vBuffer = FindVBuffer(camera.GetViewID());
-            Debug.Assert(vBuffer != null);
+            var visualEnvironment = VolumeManager.instance.stack.GetComponent<VisualEnvironment>();
-            HomogeneousDensityVolume globalVolume = HomogeneousDensityVolume.GetGlobalHomogeneousDensityVolume();
-            float asymmetry = globalVolume != null ? globalVolume.parameters.asymmetry : 0;
-
-            if (globalVolume == null)
+            if (visualEnvironment.fogType != FogType.Volumetric)
-                // CoreUtils.SetRenderTarget(cmd, vBuffer.GetLightingIntegralBuffer(), ClearFlag.Color, CoreUtils.clearColorAllBlack);
-                // CoreUtils.SetRenderTarget(cmd, vBuffer.GetLightingFeedbackBuffer(), ClearFlag.Color, CoreUtils.clearColorAllBlack);
+                // CoreUtils.SetRenderTarget(cmd, vBuffer.GetDensityBuffer(), ClearFlag.Color, CoreUtils.clearColorAllBlack);
+
+            VBuffer vBuffer = FindVBuffer(camera.GetViewID());
+            Debug.Assert(vBuffer != null);
 
             // Only available in the Play Mode because all the frame counters in the Edit Mode are broken.
             bool enableClustered    = settings.lightLoopSettings.enableTileAndCluster;
             int sampleIndex = rfc % 7;
             Vector4 offset = new Vector4(xySeq[sampleIndex].x, xySeq[sampleIndex].y, zSeq[sampleIndex], rfc);
 
+            // Get the interpolated asymmetry value.
+            var fog = VolumeManager.instance.stack.GetComponent<VolumetricFog>();
+
-            cmd.SetComputeFloatParam(  m_VolumetricLightingCS,         HDShaderIDs._CornetteShanksConstant,  CornetteShanksPhasePartConstant(asymmetry));
+            cmd.SetComputeFloatParam(  m_VolumetricLightingCS,         HDShaderIDs._CornetteShanksConstant,  CornetteShanksPhasePartConstant(fog.asymmetry));
             cmd.SetComputeTextureParam(m_VolumetricLightingCS, kernel, HDShaderIDs._VBufferDensity,          vBuffer.GetDensityBuffer());          // Read
             cmd.SetComputeTextureParam(m_VolumetricLightingCS, kernel, HDShaderIDs._VBufferLightingIntegral, vBuffer.GetLightingIntegralBuffer()); // Write
             if (enableReprojection)

ScriptableRenderPipeline/HDRenderPipeline/HDRP/MRTBufferManager.cs

     {
         protected int m_BufferCount;
         protected RenderTargetIdentifier[] m_RTIDs;
-        protected RTHandle[] m_RTs;
+        protected RTHandleSystem.RTHandle[] m_RTs;
         protected int[] m_TextureShaderIDs;
 
         public int bufferCount { get { return m_BufferCount; } }
             m_BufferCount = maxBufferCount;
             m_RTIDs = new RenderTargetIdentifier[maxBufferCount];
-            m_RTs = new RTHandle[maxBufferCount];
+            m_RTs = new RTHandleSystem.RTHandle[maxBufferCount];
             m_TextureShaderIDs = new int[maxBufferCount];
         }
 
             return m_RTIDs;
         }
 
-        public RTHandle GetBuffer(int index)
+        public RTHandleSystem.RTHandle GetBuffer(int index)
         {
             Debug.Assert(index < m_BufferCount);
             return m_RTs[index];
         {
             for (int i = 0; i < m_BufferCount; ++i)
             {
-                RTHandle.Release(m_RTs[i]);
+                RTHandles.Release(m_RTs[i]);
                 m_RTs[i] = null;
             }
         }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Decal/DBufferManager.cs

     {
         public int vsibleDecalCount { get; set; }
 
-        RTHandle m_HTile;
+        RTHandleSystem.RTHandle m_HTile;
 
         public DBufferManager()
             : base(Decal.GetMaterialDBufferCount())
 
             for (int dbufferIndex = 0; dbufferIndex < m_BufferCount; ++dbufferIndex)
             {
-                m_RTs[dbufferIndex] = RTHandle.Alloc(Vector2.one, colorFormat: rtFormat[dbufferIndex], sRGB: sRGBFlags[dbufferIndex], filterMode: FilterMode.Point, name: string.Format("DBuffer{0}", dbufferIndex));
+                m_RTs[dbufferIndex] = RTHandles.Alloc(Vector2.one, colorFormat: rtFormat[dbufferIndex], sRGB: sRGBFlags[dbufferIndex], filterMode: FilterMode.Point, name: string.Format("DBuffer{0}", dbufferIndex));
-            m_HTile = RTHandle.Alloc(size => new Vector2Int((size.x + 7) / 8, (size.y + 7) / 8), filterMode: FilterMode.Point, colorFormat: RenderTextureFormat.R8, sRGB: false, enableRandomWrite: true, name: "DBufferHTile"); // Enable UAV
+            m_HTile = RTHandles.Alloc(size => new Vector2Int((size.x + 7) / 8, (size.y + 7) / 8), filterMode: FilterMode.Point, colorFormat: RenderTextureFormat.R8, sRGB: false, enableRandomWrite: true, name: "DBufferHTile"); // Enable UAV
-            RTHandle.Release(m_HTile);
+            RTHandles.Release(m_HTile);
         }
 
         public void ClearTargets(CommandBuffer cmd, HDCamera camera)

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/GBufferManager.cs

 
             for (int gbufferIndex = 0; gbufferIndex < m_GBufferCount; ++gbufferIndex)
             {
-                m_RTs[gbufferIndex] = RTHandle.Alloc(Vector2.one, colorFormat: rtFormat[gbufferIndex], sRGB: sRGBFlags[gbufferIndex], filterMode: FilterMode.Point, name: string.Format("GBuffer{0}", gbufferIndex));
+                m_RTs[gbufferIndex] = RTHandles.Alloc(Vector2.one, colorFormat: rtFormat[gbufferIndex], sRGB: sRGBFlags[gbufferIndex], filterMode: FilterMode.Point, name: string.Format("GBuffer{0}", gbufferIndex));
                 m_RTIDs[gbufferIndex] = m_RTs[gbufferIndex].nameID;
                 m_TextureShaderIDs[gbufferIndex] = HDShaderIDs._GBufferTexture[gbufferIndex];
                 m_RTIDsNoShadowMask[gbufferIndex] = HDShaderIDs._GBufferTexture[gbufferIndex];
             {
-                m_RTs[m_GBufferCount] = RTHandle.Alloc(Vector2.one, colorFormat: Builtin.GetShadowMaskBufferFormat(), sRGB: Builtin.GetShadowMaskSRGBFlag(), filterMode: FilterMode.Point, name: "GBufferShadowMask");
+                m_RTs[m_GBufferCount] = RTHandles.Alloc(Vector2.one, colorFormat: Builtin.GetShadowMaskBufferFormat(), sRGB: Builtin.GetShadowMaskSRGBFlag(), filterMode: FilterMode.Point, name: "GBufferShadowMask");
                 m_RTIDs[m_GBufferCount] = new RenderTargetIdentifier(m_RTs[m_GBufferCount]);
                 m_TextureShaderIDs[m_GBufferCount] = HDShaderIDs._ShadowMaskTexture;
             }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/LTCAreaLight/LTCAreaLight.cs

             }
         }
 
-        bool m_isInit;
         int m_refCounting;
 
         // For area lighting - We pack all texture inside a texture array to reduce the number of resource required
 
         LTCAreaLight()
         {
-            m_isInit = false;
             m_refCounting = 0;
         }
 
 
         public void Build()
         {
-            m_refCounting++;
+            Debug.Assert(m_refCounting >= 0);
-            m_LtcData = new Texture2DArray(k_LtcLUTResolution, k_LtcLUTResolution, 3, TextureFormat.RGBAHalf, false /*mipmap*/, true /* linear */)
+            if (m_refCounting == 0)
-                hideFlags = HideFlags.HideAndDontSave,
-                wrapMode = TextureWrapMode.Clamp,
-                filterMode = FilterMode.Bilinear,
-                name = CoreUtils.GetTextureAutoName(k_LtcLUTResolution, k_LtcLUTResolution, TextureFormat.RGBAHalf, depth: 3, dim: TextureDimension.Tex2DArray, name: "LTC_LUT")
-            };
+                m_LtcData = new Texture2DArray(k_LtcLUTResolution, k_LtcLUTResolution, 3, TextureFormat.RGBAHalf, false /*mipmap*/, true /* linear */)
+                {
+                    hideFlags = HideFlags.HideAndDontSave,
+                    wrapMode = TextureWrapMode.Clamp,
+                    filterMode = FilterMode.Bilinear,
+                    name = CoreUtils.GetTextureAutoName(k_LtcLUTResolution, k_LtcLUTResolution, TextureFormat.RGBAHalf, depth: 3, dim: TextureDimension.Tex2DArray, name: "LTC_LUT")
+                };
-            LoadLUT(m_LtcData, 0, TextureFormat.RGBAHalf, s_LtcGGXMatrixData);
-            LoadLUT(m_LtcData, 1, TextureFormat.RGBAHalf, s_LtcDisneyDiffuseMatrixData);
-            // TODO: switch to RGBA64 when it becomes available.
-            LoadLUT(m_LtcData, 2, TextureFormat.RGBAHalf, s_LtcGGXMagnitudeData, s_LtcGGXFresnelData, s_LtcDisneyDiffuseMagnitudeData);
+                LoadLUT(m_LtcData, 0, TextureFormat.RGBAHalf, s_LtcGGXMatrixData);
+                LoadLUT(m_LtcData, 1, TextureFormat.RGBAHalf, s_LtcDisneyDiffuseMatrixData);
+                // TODO: switch to RGBA64 when it becomes available.
+                LoadLUT(m_LtcData, 2, TextureFormat.RGBAHalf, s_LtcGGXMagnitudeData, s_LtcGGXFresnelData, s_LtcDisneyDiffuseMagnitudeData);
-            m_LtcData.Apply();
+                m_LtcData.Apply();
+            }
-            m_isInit = true;
+            m_refCounting++;
         }
 
         public void Cleanup()
-            if (m_refCounting <= 0)
+            if (m_refCounting == 0)
-            m_isInit = false;
+            Debug.Assert(m_refCounting >= 0);
         }
 
         public void Bind()

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Lit/Lit.cs

 
         bool m_isInit;
 
-        // For image based lighting
-        Material      m_InitPreFGD;
-        RenderTexture m_PreIntegratedFGD;
-
-            m_InitPreFGD = CoreUtils.CreateEngineMaterial("Hidden/HDRenderPipeline/PreIntegratedFGD");
-
-            m_PreIntegratedFGD = new RenderTexture(128, 128, 0, RenderTextureFormat.ARGB2101010, RenderTextureReadWrite.Linear);
-            m_PreIntegratedFGD.hideFlags = HideFlags.HideAndDontSave;
-            m_PreIntegratedFGD.filterMode = FilterMode.Bilinear;
-            m_PreIntegratedFGD.wrapMode = TextureWrapMode.Clamp;
-            m_PreIntegratedFGD.hideFlags = HideFlags.DontSave;
-            m_PreIntegratedFGD.name = CoreUtils.GetRenderTargetAutoName(128, 128, RenderTextureFormat.ARGB2101010, "PreIntegratedFGD");
-            m_PreIntegratedFGD.Create();
-
+            PreIntegratedFGD.instance.Build();
             LTCAreaLight.instance.Build();
 
             m_isInit = false;
         {
-            CoreUtils.Destroy(m_InitPreFGD);
-            CoreUtils.Destroy(m_PreIntegratedFGD);
-
+            PreIntegratedFGD.instance.Cleanup();
             LTCAreaLight.instance.Cleanup();
 
             m_isInit = false;
             if (m_isInit)
                 return;
 
-            using (new ProfilingSample(cmd, "Init PreFGD"))
-            {
-                CoreUtils.DrawFullScreen(cmd, m_InitPreFGD, new RenderTargetIdentifier(m_PreIntegratedFGD));
-            }
+            PreIntegratedFGD.instance.RenderInit(cmd);
 
             m_isInit = true;
         }
-            Shader.SetGlobalTexture("_PreIntegratedFGD", m_PreIntegratedFGD);
+            PreIntegratedFGD.instance.Bind();
             LTCAreaLight.instance.Bind();
         }
     }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Lit/Lit.hlsl

 TEXTURE2D(_GBufferTexture3);
 
 #include "../LTCAreaLight/LTCAreaLight.hlsl"
-
-TEXTURE2D(_PreIntegratedFGD);
+#include "../PreIntegratedFGD/PreIntegratedFGD.hlsl"
 
 //-----------------------------------------------------------------------------
 // Definition
     bsdfData.absorptionCoefficient = TransmittanceColorAtDistanceToAbsorption(transmittanceColor, atDistance);
     bsdfData.transmittanceMask = transmittanceMask;
     bsdfData.thickness = max(thickness, 0.0001);
-}
-
-// For image based lighting, a part of the BSDF is pre-integrated.
-// This is done both for specular and diffuse (in case of DisneyDiffuse)
-void GetPreIntegratedFGD(float NdotV, float perceptualRoughness, float3 fresnel0, out float3 specularFGD, out float diffuseFGD, out float reflectivity)
-{
-    // Pre-integrate GGX FGD
-    // Integral{BSDF * <N,L> dw} =
-    // Integral{(F0 + (1 - F0) * (1 - <V,H>)^5) * (BSDF / F) * <N,L> dw} =
-    // (1 - F0) * Integral{(1 - <V,H>)^5 * (BSDF / F) * <N,L> dw} + F0 * Integral{(BSDF / F) * <N,L> dw}=
-    // (1 - F0) * x + F0 * y = lerp(x, y, F0)
-    // Pre integrate DisneyDiffuse FGD:
-    // z = DisneyDiffuse
-    float3 preFGD = SAMPLE_TEXTURE2D_LOD(_PreIntegratedFGD, s_linear_clamp_sampler, float2(NdotV, perceptualRoughness), 0).xyz;
-
-    specularFGD = lerp(preFGD.xxx, preFGD.yyy, fresnel0);
-
-#ifdef LIT_DIFFUSE_LAMBERT_BRDF
-    diffuseFGD = 1.0;
-#else
-    // Remap from the [0, 1] to the [0.5, 1.5] range.
-    diffuseFGD = preFGD.z + 0.5;
-#endif
-
-    reflectivity = preFGD.y;
 }
 
 // This function is use to help with debugging and must be implemented by any lit material
     // IBL
 
     // Handle IBL +  multiscattering
-    float reflectivity;
-    GetPreIntegratedFGD(NdotV, preLightData.iblPerceptualRoughness, bsdfData.fresnel0, preLightData.specularFGD, preLightData.diffuseFGD, reflectivity);
+    float specularReflectivity;
+    GetPreIntegratedFGDGGXAndDisneyDiffuse(NdotV, preLightData.iblPerceptualRoughness, bsdfData.fresnel0, preLightData.specularFGD, preLightData.diffuseFGD, specularReflectivity);
+#ifdef LIT_DIFFUSE_LAMBERT_BRDF
+    preLightData.diffuseFGD = 1.0;
+#endif
 
     iblR = reflect(-V, iblN);
     // This is a ad-hoc tweak to better match reference of anisotropic GGX.
     // We deem the intensity difference of a couple of percent for high values of roughness
     // to not be worth the cost of another precomputed table.
     // Note: this formulation bakes the BSDF non-symmetric!
-    preLightData.energyCompensation = 1.0 / reflectivity - 1.0;
+    preLightData.energyCompensation = 1.0 / specularReflectivity - 1.0;
 #else
     preLightData.energyCompensation = 0.0;
 #endif // LIT_USE_GGX_ENERGY_COMPENSATION
     // Formula is empirical.
     float roughness = PerceptualRoughnessToRoughness(preLightData.iblPerceptualRoughness);
     R = lerp(R, preLightData.iblR, saturate(smoothstep(0, 1, roughness * roughness)));
-
-    float3 sampleDirectionDiscardWS = lightData.sampleDirectionDiscardWS;
-    if (dot(sampleDirectionDiscardWS, R) < 0) // Use by planar reflection to early reject opposite plan reflection, neutral for reflection probe
-        return lighting;
 
     float3 F = preLightData.specularFGD;
     float iblMipLevel = PerceptualRoughnessToMipmapLevel(preLightData.iblPerceptualRoughness);

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/StackLit/StackLit.cs

-using UnityEngine;
+using UnityEngine.Rendering;
-//-----------------------------------------------------------------------------
-// structure definition
-//-----------------------------------------------------------------------------
+        [GenerateHLSL(PackingRules.Exact)]
+        public enum MaterialFeatureFlags
+        {
+            LitStandard             = 1 << 0
+        };
+
         //-----------------------------------------------------------------------------
         // SurfaceData
         //-----------------------------------------------------------------------------
         public struct SurfaceData
         {
+            [SurfaceDataAttributes("Material Features")]
+            public uint materialFeatures;
+
             // Standard
             [SurfaceDataAttributes("Base Color", false, true)]
             public Vector3 baseColor;
+
+            [SurfaceDataAttributes("Smoothness A")]
+            public float perceptualSmoothnessA;
+            [SurfaceDataAttributes("Smoothness B")]
+            public float perceptualSmoothnessB;
+
+            [SurfaceDataAttributes("Lobe Mixing")]
+            public float lobeMix;
+
+            [SurfaceDataAttributes("Metallic")]
+            public float metallic;
+
         };
 
         //-----------------------------------------------------------------------------
         [GenerateHLSL(PackingRules.Exact, false, true, 1400)]
         public struct BSDFData
         {
+            public uint materialFeatures;
+
-            
+            public Vector3 fresnel0;
+
+            public float perceptualRoughnessA;
+            public float perceptualRoughnessB;
+            public float lobeMix;
+            public float roughnessAT;
+            public float roughnessAB;
+            public float roughnessBT;
+            public float roughnessBB;
+            public float anisotropy;
+            //public fixed float test[2];
+
+
+        //-----------------------------------------------------------------------------
+        // Init precomputed textures
+        //-----------------------------------------------------------------------------
+
+        bool m_isInit;
+
+        public StackLit() {}
+
+        public override void Build(HDRenderPipelineAsset hdAsset)
+        {
+            PreIntegratedFGD.instance.Build();
+            //LTCAreaLight.instance.Build();
+
+            m_isInit = false;
+        }
+
+        public override void Cleanup()
+        {
+            PreIntegratedFGD.instance.Cleanup();
+            //LTCAreaLight.instance.Cleanup();
+
+            m_isInit = false;
+        }
+
+        public override void RenderInit(CommandBuffer cmd)
+        {
+            if (m_isInit)
+                return;
+
+            PreIntegratedFGD.instance.RenderInit(cmd);
+
+            m_isInit = true;
+        }
+
+        public override void Bind()
+        {
+            PreIntegratedFGD.instance.Bind();
+            //LTCAreaLight.instance.Bind();
+        }
+
     }
 }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/StackLit/StackLit.cs.hlsl

 #ifndef STACKLIT_CS_HLSL
 #define STACKLIT_CS_HLSL
 //
+// UnityEngine.Experimental.Rendering.HDPipeline.StackLit+MaterialFeatureFlags:  static fields
+//
+#define MATERIALFEATUREFLAGS_LIT_STANDARD (1)
+
+//
-#define DEBUGVIEW_STACKLIT_SURFACEDATA_BASE_COLOR (1300)
-#define DEBUGVIEW_STACKLIT_SURFACEDATA_NORMAL (1301)
-#define DEBUGVIEW_STACKLIT_SURFACEDATA_NORMAL_VIEW_SPACE (1302)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_MATERIAL_FEATURES (1300)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_BASE_COLOR (1301)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_NORMAL (1302)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_NORMAL_VIEW_SPACE (1303)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_SMOOTHNESS_A (1304)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_SMOOTHNESS_B (1305)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_LOBE_MIXING (1306)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_METALLIC (1307)
-#define DEBUGVIEW_STACKLIT_BSDFDATA_DIFFUSE_COLOR (1400)
-#define DEBUGVIEW_STACKLIT_BSDFDATA_NORMAL_WS (1401)
-#define DEBUGVIEW_STACKLIT_BSDFDATA_NORMAL_VIEW_SPACE (1402)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_MATERIAL_FEATURES (1400)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_DIFFUSE_COLOR (1401)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_FRESNEL0 (1402)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_NORMAL_WS (1403)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_NORMAL_VIEW_SPACE (1404)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_PERCEPTUAL_ROUGHNESS_A (1405)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_PERCEPTUAL_ROUGHNESS_B (1406)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_LOBE_MIXING (1407)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_ROUGHNESS_AT (1408)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_ROUGHNESS_AB (1409)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_ROUGHNESS_BT (1410)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_ROUGHNESS_BB (1411)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_ANISOTROPY (1412)
+    uint materialFeatures;
+    float perceptualSmoothnessA;
+    float perceptualSmoothnessB;
+    float lobeMix;
+    float metallic;
 };
 
 // Generated from UnityEngine.Experimental.Rendering.HDPipeline.StackLit+BSDFData
+    uint materialFeatures;
+    float3 fresnel0;
+    float perceptualRoughnessA;
+    float perceptualRoughnessB;
+    float lobeMix;
+    float roughnessAT;
+    float roughnessAB;
+    float roughnessBT;
+    float roughnessBB;
+    float anisotropy;
 };
 
 //
 {
     switch (paramId)
     {
+        case DEBUGVIEW_STACKLIT_SURFACEDATA_MATERIAL_FEATURES:
+            result = GetIndexColor(surfacedata.materialFeatures);
+            break;
         case DEBUGVIEW_STACKLIT_SURFACEDATA_BASE_COLOR:
             result = surfacedata.baseColor;
             needLinearToSRGB = true;
         case DEBUGVIEW_STACKLIT_SURFACEDATA_NORMAL_VIEW_SPACE:
             result = surfacedata.normalWS * 0.5 + 0.5;
             break;
+        case DEBUGVIEW_STACKLIT_SURFACEDATA_SMOOTHNESS_A:
+            result = surfacedata.perceptualSmoothnessA.xxx;
+            break;
+        case DEBUGVIEW_STACKLIT_SURFACEDATA_SMOOTHNESS_B:
+            result = surfacedata.perceptualSmoothnessB.xxx;
+            break;
+        case DEBUGVIEW_STACKLIT_SURFACEDATA_LOBE_MIXING:
+            result = surfacedata.lobeMix.xxx;
+            break;
+        case DEBUGVIEW_STACKLIT_SURFACEDATA_METALLIC:
+            result = surfacedata.metallic.xxx;
+            break;
     }
 }
 
 {
     switch (paramId)
     {
+        case DEBUGVIEW_STACKLIT_BSDFDATA_MATERIAL_FEATURES:
+            result = GetIndexColor(bsdfdata.materialFeatures);
+            break;
+        case DEBUGVIEW_STACKLIT_BSDFDATA_FRESNEL0:
+            result = bsdfdata.fresnel0;
+            break;
+            break;
+        case DEBUGVIEW_STACKLIT_BSDFDATA_PERCEPTUAL_ROUGHNESS_A:
+            result = bsdfdata.perceptualRoughnessA.xxx;
+            break;
+        case DEBUGVIEW_STACKLIT_BSDFDATA_PERCEPTUAL_ROUGHNESS_B:
+            result = bsdfdata.perceptualRoughnessB.xxx;
+            break;
+        case DEBUGVIEW_STACKLIT_BSDFDATA_LOBE_MIXING:
+            result = bsdfdata.lobeMix.xxx;
+            break;
+        case DEBUGVIEW_STACKLIT_BSDFDATA_ROUGHNESS_AT:
+            result = bsdfdata.roughnessAT.xxx;
+            break;
+        case DEBUGVIEW_STACKLIT_BSDFDATA_ROUGHNESS_AB:
+            result = bsdfdata.roughnessAB.xxx;
+            break;
+        case DEBUGVIEW_STACKLIT_BSDFDATA_ROUGHNESS_BT:
+            result = bsdfdata.roughnessBT.xxx;
+            break;
+        case DEBUGVIEW_STACKLIT_BSDFDATA_ROUGHNESS_BB:
+            result = bsdfdata.roughnessBB.xxx;
+            break;
+        case DEBUGVIEW_STACKLIT_BSDFDATA_ANISOTROPY:
+            result = bsdfdata.anisotropy.xxx;
             break;
     }
 }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/StackLit/StackLit.hlsl

 //
 // Also add options at the top of this file, see Lit.hlsl.
 
+//-----------------------------------------------------------------------------
+// Texture and constant buffer declaration
+//-----------------------------------------------------------------------------
+
+// Declare the BSDF specific FGD property and its fetching function
+#include "../PreIntegratedFGD/PreIntegratedFGD.hlsl"
+
+//-----------------------------------------------------------------------------
+// Definition
+//-----------------------------------------------------------------------------
+
+#define HAS_REFRACTION (defined(_REFRACTION_PLANE) || defined(_REFRACTION_SPHERE)) && (defined(_REFRACTION_SSRAY_PROXY) || defined(_REFRACTION_SSRAY_HIZ))
+#define DEFAULT_SPECULAR_VALUE 0.04
+
+//-----------------------------------------------------------------------------
+// Configuration
+//-----------------------------------------------------------------------------
+#define LIT_DIFFUSE_LAMBERT_BRDF // TODO Disney Diffuse
+#define LIT_USE_GGX_ENERGY_COMPENSATION
+
+
+//-----------------------------------------------------------------------------
+// Helper functions/variable specific to this material
+//-----------------------------------------------------------------------------
+
+// This method allows us to know at compile time what material features should be removed from the code by Tile (Indepenently of the value of material feature flag per pixel).
+// This is only useful for classification during lighting, so it's not needed in EncodeIntoGBuffer and ConvertSurfaceDataToBSDFData (where we always know exactly what the material feature is)
+bool HasFeatureFlag(uint featureFlags, uint flag)
+{
+    return ((featureFlags & flag) != 0);
+}
+
+float3 ComputeDiffuseColor(float3 baseColor, float metallic)
+{
+    return baseColor * (1.0 - metallic);
+}
+
+float3 ComputeFresnel0(float3 baseColor, float metallic, float dielectricF0)
+{
+    return lerp(dielectricF0.xxx, baseColor, metallic);
+}
+
+
+
 
 // This function is use to help with debugging and must be implemented by any lit material
 // Implementer must take into account what are the current override component and
     BSDFData bsdfData;
     ZERO_INITIALIZE(BSDFData, bsdfData);
 
-    // NEWLITTODO: will be much more involved obviously, and use metallic, etc.
-    bsdfData.diffuseColor = surfaceData.baseColor;
+    // IMPORTANT: In our forward only case, all enable flags are statically know at compile time, so the compiler can do compile time optimization
+    bsdfData.materialFeatures = surfaceData.materialFeatures;
+
+    // Two lobe base material
+    bsdfData.perceptualRoughnessA = PerceptualSmoothnessToPerceptualRoughness(surfaceData.perceptualSmoothnessA);
+    bsdfData.perceptualRoughnessB = PerceptualSmoothnessToPerceptualRoughness(surfaceData.perceptualSmoothnessB);
+    bsdfData.lobeMix = surfaceData.lobeMix;
+
+    // There is no metallic with SSS and specular color mode
+    //todo: float metallic = HasFeatureFlag(surfaceData.materialFeatures, MATERIALFEATUREFLAGS_LIT_SPECULAR_COLOR | MATERIALFEATUREFLAGS_LIT_SUBSURFACE_SCATTERING | MATERIALFEATUREFLAGS_LIT_TRANSMISSION) ? 0.0 : surfaceData.metallic;
+    float metallic = surfaceData.metallic;
+
+    bsdfData.diffuseColor = ComputeDiffuseColor(surfaceData.baseColor, metallic);
+    bsdfData.fresnel0 = ComputeFresnel0(surfaceData.baseColor, surfaceData.metallic, DEFAULT_SPECULAR_VALUE);
+
+    // roughnessT and roughnessB are clamped, and are meant to be used with punctual and directional lights.
+    // perceptualRoughness is not clamped, and is meant to be used for IBL.
+    // TODO: add ui inputs, +tangent map, tangentws to use anisotropy; for now bsdfData.anisotropy = 0,
+    // so only bsdfData.roughnessT is used.
+    ConvertAnisotropyToClampRoughness(bsdfData.perceptualRoughnessA, bsdfData.anisotropy, bsdfData.roughnessAT, bsdfData.roughnessAB);
+    ConvertAnisotropyToClampRoughness(bsdfData.perceptualRoughnessB, bsdfData.anisotropy, bsdfData.roughnessBT, bsdfData.roughnessBB);
 
     ApplyDebugToBSDFData(bsdfData);
     return bsdfData;
     // Overide debug value output to be more readable
     switch (paramId)
     {
-        case DEBUGVIEW_LIT_SURFACEDATA_NORMAL_VIEW_SPACE:
+        case DEBUGVIEW_STACKLIT_SURFACEDATA_NORMAL_VIEW_SPACE:
             // Convert to view space
             result = TransformWorldToViewDir(surfaceData.normalWS) * 0.5 + 0.5;
             break;
     // Overide debug value output to be more readable
     switch (paramId)
     {
-        case DEBUGVIEW_LIT_BSDFDATA_NORMAL_VIEW_SPACE:
+        case DEBUGVIEW_STACKLIT_BSDFDATA_NORMAL_VIEW_SPACE:
             // Convert to view space
             result = TransformWorldToViewDir(bsdfData.normalWS) * 0.5 + 0.5;
             break;
 struct PreLightData
 {
     float NdotV;                     // Could be negative due to normal mapping, use ClampNdotV()
-    //NEWLITTODO
+
+    // IBL: we calculate and prefetch the pre-integrated split sum data for
+    // both lobes
+    float3 iblR[2];                  // Dominant specular direction, used for IBL in EvaluateBSDF_Env()
+    float  iblPerceptualRoughness[2];
+
+    float3 specularFGD[2];           // Store preconvoled BRDF for both specular and diffuse
+    float  diffuseFGD[2];
+
+    // GGX
+    float partLambdaV[2]; // One for each lobe
+    float energyCompensation;
 };
 
 PreLightData GetPreLightData(float3 V, PositionInputs posInput, inout BSDFData bsdfData)
 
     float3 N = bsdfData.normalWS;
     preLightData.NdotV = dot(N, V);
+    preLightData.iblPerceptualRoughness[0] = bsdfData.perceptualRoughnessA;
+    preLightData.iblPerceptualRoughness[1] = bsdfData.perceptualRoughnessB;
-    //float NdotV = ClampNdotV(preLightData.NdotV);
+    float NdotV = ClampNdotV(preLightData.NdotV);
+
+    float3 iblN[2], iblR[2];
+    // We will need two hacked N for the stretch anisotropic hack later.
+    // (Could use a UNITY_UNROLL loop, but not much code to dupe)
+
+    preLightData.partLambdaV[0] = GetSmithJointGGXPartLambdaV(NdotV, bsdfData.roughnessAT);
+    preLightData.partLambdaV[1] = GetSmithJointGGXPartLambdaV(NdotV, bsdfData.roughnessBT);
+    iblN[0] = iblN[1] = N;
+
+    // IBL
+    // Handle IBL pre calculated data + GGX multiscattering energy loss compensation term
+
+    float specularReflectivity[2];
+
+    GetPreIntegratedFGDGGXAndDisneyDiffuse(NdotV, preLightData.iblPerceptualRoughness[0], bsdfData.fresnel0, preLightData.specularFGD[0], preLightData.diffuseFGD[0], specularReflectivity[0]);
+    GetPreIntegratedFGDGGXAndDisneyDiffuse(NdotV, preLightData.iblPerceptualRoughness[1], bsdfData.fresnel0, preLightData.specularFGD[1], preLightData.diffuseFGD[1], specularReflectivity[1]);
+
+#ifdef LIT_DIFFUSE_LAMBERT_BRDF
+    preLightData.diffuseFGD[0] = preLightData.diffuseFGD[1] = 1.0;
+#endif
+
+    iblR[0] = reflect(-V, iblN[0]);
+    iblR[1] = reflect(-V, iblN[1]);
+    // This is a ad-hoc tweak to better match reference of anisotropic GGX.
+    // TODO: We need a better hack.
+    float fact = saturate(1.2 - abs(bsdfData.anisotropy));
+    preLightData.iblPerceptualRoughness[0] *= fact;
+    preLightData.iblPerceptualRoughness[1] *= fact;
+    // Corretion of reflected direction for better handling of rough material
+    preLightData.iblR[0] = GetSpecularDominantDir(N, iblR[0], preLightData.iblPerceptualRoughness[0], NdotV);
+    preLightData.iblR[1] = GetSpecularDominantDir(N, iblR[1], preLightData.iblPerceptualRoughness[1], NdotV);
+
+#ifdef LIT_USE_GGX_ENERGY_COMPENSATION
+    // Ref: Practical multiple scattering compensation for microfacet models.
+    // We only apply the formulation for metals.
+    // For dielectrics, the change of reflectance is negligible.
+    // We deem the intensity difference of a couple of percent for high values of roughness
+    // to not be worth the cost of another precomputed table.
+    // Note: this formulation bakes the BSDF non-symmetric!
+    // Note: that this also assumes all specular comes from GGX BSDFs.
+    // (That's the FGD we use above to get integral[BSDF/F (N.w) dw] )
+    // In our case, since this compensation term is already an average
+    // applied to a sum (akin to a "split sum" approximation) we will
+    // just lerp our two "specularReflectivities"
+    preLightData.energyCompensation = 1.0 / lerp(specularReflectivity[0], specularReflectivity[1], bsdfData.lobeMix) - 1.0;
+#else
+    preLightData.energyCompensation = 0.0;
+#endif // LIT_USE_GGX_ENERGY_COMPENSATION
 
     return preLightData;
 }
 // BSDF share between directional light, punctual light and area light (reference)
 //-----------------------------------------------------------------------------
 
-// NEWLITTODO
 
 // This function apply BSDF. Assumes that NdotL is positive.
 void BSDF(  float3 V, float3 L, float NdotL, float3 positionWS, PreLightData preLightData, BSDFData bsdfData,
+    float3 N = bsdfData.normalWS;
+
+    // Optimized math. Ref: PBR Diffuse Lighting for GGX + Smith Microsurfaces (slide 114).
+    float LdotV    = dot(L, V);
+    float invLenLV = rsqrt(max(2.0 * LdotV + 2.0, FLT_EPS));            // invLenLV = rcp(length(L + V)), clamp to avoid rsqrt(0) = NaN
+    float NdotH    = saturate((NdotL + preLightData.NdotV) * invLenLV); // Do not clamp NdotV here
+    float LdotH    = saturate(invLenLV * LdotV + invLenLV);
+    float NdotV    = ClampNdotV(preLightData.NdotV);
+
+    // TODO: Proper Fresnel
+    float3 F = F_Schlick(bsdfData.fresnel0, LdotH);
+
+    // TODO: with iridescence, will be per light sample.
+
+    float DV[2];
+
+    DV[0] = DV_SmithJointGGX(NdotH, NdotL, NdotV, bsdfData.roughnessAT, preLightData.partLambdaV[0]);
+    DV[1] = DV_SmithJointGGX(NdotH, NdotL, NdotV, bsdfData.roughnessBT, preLightData.partLambdaV[1]);
+
+    specularLighting = F * lerp(DV[0], DV[1], bsdfData.lobeMix);
+
+    // TODO: config option + diffuse GGX
-    specularLighting = float3(0.0, 0.0, 0.0);
+
+    // TODO: coat
 }
 
 //-----------------------------------------------------------------------------
     IndirectLighting lighting;
     ZERO_INITIALIZE(IndirectLighting, lighting);
 
-    //NEWLITTODO
+    // TODO: refraction
+
+#if !HAS_REFRACTION
+    if (GPUImageBasedLightingType == GPUIMAGEBASEDLIGHTINGTYPE_REFRACTION)
+        return lighting;
+#endif
+
+    float3 envLighting;
+    float3 positionWS = posInput.positionWS;
+    float weight;
+    float tempWeight[2];
+
+#ifdef LIT_DISPLAY_REFERENCE_IBL
+
+    envLighting = IntegrateSpecularGGXIBLRef(lightLoopContext, V, preLightData, lightData, bsdfData);
+
+    // TODO: Do refraction reference (is it even possible ?)
+    // TODO: handle clear coat
+
+    // TODO: Handle two lobes in reference
+
+
+//    #ifdef LIT_DIFFUSE_LAMBERT_BRDF
+//    envLighting += IntegrateLambertIBLRef(lightData, V, bsdfData);
+//    #else
+//    envLighting += IntegrateDisneyDiffuseIBLRef(lightLoopContext, V, preLightData, lightData, bsdfData);
+//    #endif
+
+#else
+
+    float3 R[2];
+    R[0] = preLightData.iblR[0];
+    R[1] = preLightData.iblR[1];
+
+    // TODO: Refraction
+
+    // We will sample 2 times (one for each lobe) the environment.
+    // Steps are:
+
+    // -Calculate influence weights from intersection with the proxies.
+    // Since the weights are influence blending weights, we can correctly
+    // use our lobe weight and mix them.
+    // -Fudge the sampling direction  to dampen boundary artefacts.
+    // -Do early discard for planar reflections.
+    // -Fetch 2 samples of preintegrated environment lighting
+    // (see preLD, first part of the split-sum approx.)
+    // -Use the 2 BSDF preintegration terms we pre-fetched in preLightData
+    // (second part of the split-sum approx.,
+    //  and common to all Env. Lights. using the same BSDF and
+    //  we only have GGX thus only one FGD map for now)
+    // -Multiply the two split sum terms together for each lobe
+    // and linearly combine the results.
+
+    // Note: using influenceShapeType and projectionShapeType instead of (lightData|proxyData).shapeType allow to make compiler optimization in case the type is know (like for sky)
+    tempWeight[0] = tempWeight[1] = 1.0;
+    EvaluateLight_EnvIntersection(positionWS, bsdfData.normalWS, lightData, influenceShapeType, R[0], tempWeight[0]);
+    EvaluateLight_EnvIntersection(positionWS, bsdfData.normalWS, lightData, influenceShapeType, R[1], tempWeight[1]);
+    weight = lerp(tempWeight[0], tempWeight[1], bsdfData.lobeMix);
+
+    // TODO: reflections + coating
+
+    // When we are rough, we tend to see outward shifting of the reflection when at the boundary of the projection volume
+    // Also it appear like more sharp. To avoid these artifact and at the same time get better match to reference we lerp to original unmodified reflection.
+    // Formula is empirical.
+    float roughness = PerceptualRoughnessToRoughness(preLightData.iblPerceptualRoughness[0]);
+    R[0] = lerp(R[0], preLightData.iblR[0], saturate(smoothstep(0, 1, roughness * roughness)));
+    roughness = PerceptualRoughnessToRoughness(preLightData.iblPerceptualRoughness[1]);
+    R[1] = lerp(R[1], preLightData.iblR[1], saturate(smoothstep(0, 1, roughness * roughness)));
+
+    float3 F[2];
+    F[0] = preLightData.specularFGD[0];
+    F[1] = preLightData.specularFGD[1];
+
+    float4 preLD[2];
+
+    float iblMipLevel = PerceptualRoughnessToMipmapLevel(preLightData.iblPerceptualRoughness[0]);
+    preLD[0] = SampleEnv(lightLoopContext, lightData.envIndex, R[0], iblMipLevel);
+
+    iblMipLevel = PerceptualRoughnessToMipmapLevel(preLightData.iblPerceptualRoughness[1]);
+    preLD[1] = SampleEnv(lightLoopContext, lightData.envIndex, R[1], iblMipLevel);
+
+    // Used by planar reflection to discard pixel:
+    weight *= lerp(preLD[0].a, preLD[1].a, bsdfData.lobeMix);
+
+    if (GPUImageBasedLightingType == GPUIMAGEBASEDLIGHTINGTYPE_REFLECTION)
+    {
+        envLighting = lerp(F[0] * preLD[0].rgb, F[1] * preLD[1].rgb, bsdfData.lobeMix);
+        // TODO: Clear Coat component if needed
+    }
+    else
+    {
+        // TODO: Refractions
+
+        // No clear coat support with refraction
+
+        // specular transmisted lighting is the remaining of the reflection (let's use this approx)
+        // With refraction, we don't care about the clear coat value, only about the Fresnel, thus why we use 'envLighting ='
+        //envLighting = (1.0 - F) * preLD.rgb * preLightData.transparentTransmittance;
+    }
+
+#endif // LIT_DISPLAY_REFERENCE_IBL
+
+    UpdateLightingHierarchyWeights(hierarchyWeight, weight);
+    envLighting *= weight * lightData.multiplier;
+
+    if (GPUImageBasedLightingType == GPUIMAGEBASEDLIGHTINGTYPE_REFLECTION)
+        lighting.specularReflected = envLighting;
+    //TODO refraction:
+    //else
+    //    lighting.specularTransmitted = envLighting * preLightData.transparentTransmittance;
 
     return lighting;
 }
                         PreLightData preLightData, BSDFData bsdfData, BakeLightingData bakeLightingData, AggregateLighting lighting,
                         out float3 diffuseLighting, out float3 specularLighting)
 {
-    // Apply the albedo to the direct diffuse lighting and that's about it.
+    // TODO: AO, SO, SSS, Refraction
+
-    specularLighting = lighting.direct.specular; // should be 0 for now.
+
+    specularLighting = lighting.direct.specular + lighting.indirect.specularReflected;
+    // Apply the fudge factor (boost) to compensate for multiple scattering not accounted for in BSDF.
+    // This assumes all spec comes from a GGX BSDF.
+    // Note: The multiply with fresnel0 is to apply it only for metallic
+    specularLighting *= 1.0 + bsdfData.fresnel0 * preLightData.energyCompensation;
 
 #ifdef DEBUG_DISPLAY
 
         switch (_DebugLightingMode)
         {
         case DEBUGLIGHTINGMODE_LUX_METER:
-            //diffuseLighting = lighting.direct.diffuse + bakeLightingData.bakeDiffuseLighting;
+            diffuseLighting = lighting.direct.diffuse + bakeLightingData.bakeDiffuseLighting;
-            //diffuseLighting = indirectAmbientOcclusion;
+            //diffuseLighting = aoFactor.indirectAmbientOcclusion;
-            //diffuseLighting = specularOcclusion;
+            //diffuseLighting = aoFactor.indirectSpecularOcclusion;
             break;
 
         case DEBUGLIGHTINGMODE_SCREEN_SPACE_TRACING_REFRACTION:

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/StackLit/StackLit.shader

         _BaseColor("BaseColor", Color) = (1,1,1,1)
         _BaseColorMap("BaseColorMap", 2D) = "white" {}
 
+        _Metallic("Metallic", Range(0.0, 1.0)) = 0
+
+
+        _SmoothnessA("SmoothnessA", Range(0.0, 1.0)) = 1.0
+        _SmoothnessARemapMin("SmoothnessARemapMin", Float) = 0.0
+        _SmoothnessARemapMax("SmoothnessARemapMax", Float) = 1.0
+        _SmoothnessB("SmoothnessB", Range(0.0, 1.0)) = 1.0
+        _SmoothnessBRemapMin("SmoothnessBRemapMin", Float) = 0.0
+        _SmoothnessBRemapMax("SmoothnessBRemapMax", Float) = 1.0
+        _LobeMix("lobeMix", Range(0.0, 1.0)) = 0
+        _MaskMapA("MaskMapA", 2D) = "white" {}
+        _MaskMapB("MaskMapB", 2D) = "white" {}
+
+        _NormalMap("NormalMap", 2D) = "bump" {}     // Tangent space normal map
+        _NormalScale("_NormalScale", Range(0.0, 2.0)) = 1
+
+        [Enum(UV0, 0, UV1, 1, UV2, 2, UV3, 3, Planar, 4, Triplanar, 5)] _UVBase("UV Set for base", Float) = 0
+        [HideInInspector] _UVMappingMask("_UVMappingMask", Color) = (1, 0, 0, 0)
+
+
         _EmissiveColor("EmissiveColor", Color) = (1, 1, 1)
         _EmissiveColorMap("EmissiveColorMap", 2D) = "white" {}
         _EmissiveIntensity("EmissiveIntensity", Float) = 0
 
     #pragma shader_feature _ALPHATEST_ON
     #pragma shader_feature _DOUBLESIDED_ON
-    
-    
+
+    #pragma shader_feature _NORMALMAP_TANGENT_SPACE
+    #pragma shader_feature _ _REQUIRE_UV2 _REQUIRE_UV3 
+    // ...TODO: for surface gradient framework eg see litdata.hlsl, 
+    // but we need it right away for toggle with LayerTexCoord mapping so we might need them 
+    // from the Frag input right away. See also ShaderPass/StackLitSharePass.hlsl.
+
+    #pragma shader_feature _NORMALMAP
+    #pragma shader_feature _MASKMAPA
+    #pragma shader_feature _MASKMAPB
     #pragma shader_feature _EMISSIVE_COLOR_MAP
 
     // Keyword for transparent

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/StackLit/StackLitData.hlsl

 //-------------------------------------------------------------------------------------
 // Fill SurfaceData/Builtin data function
 //-------------------------------------------------------------------------------------
+#include "CoreRP/ShaderLibrary/Sampling/SampleUVMapping.hlsl"
+//-----------------------------------------------------------------------------
+// Texture Mapping (think of LayerTexCoord as simply TexCoordMappings, 
+// ie no more layers here - cf Lit materials)
+//-----------------------------------------------------------------------------
+
+//
+// For easier copying of code for now use a LayerTexCoord wrapping struct.
+// We don't have details yet.
+//
+// NEWLITTODO: Eventually, we could quickly share GetBuiltinData of LitBuiltinData.hlsl 
+// in our GetSurfaceAndBuiltinData( ) here, since we will use the LayerTexCoord identifier,
+// and an identical ComputeLayerTexCoord( ) prototype
+//
+struct LayerTexCoord
+{
+    UVMapping base;
+    UVMapping details;
+
+    // Store information that will be share by all UVMapping
+    float3 vertexNormalWS; // TODO: store also object normal map for object triplanar
+};
+
+// Want to use only one sampler for normalmap/bentnormalmap either we use OS or TS. And either we have normal map or bent normal or both.
+// 
+// Note (compared to Lit shader): 
+//
+// We don't have a layered material with which we are sharing code here like the LayeredLit shader, but we can also save a couple of 
+// samplers later if we use bentnormals.
+//
+// _IDX suffix is meaningless here, could use the name SAMPLER_NORMALMAP_ID instead of SAMPLER_NORMALMAP_IDX and replace all 
+// indirect #ifdef _NORMALMAP_TANGENT_SPACE_IDX #ifdef and _NORMALMAP_IDX tests with the more direct 
+// shader_feature keywords _NORMALMAP_TANGENT_SPACE and _NORMALMAP.
+//
+// (Originally in the LayeredLit shader, shader_feature keywords like _NORMALMAP become _NORMALMAP0 but since files are shared,
+// LitDataIndividualLayer will use a generic _NORMALMAP_IDX defined before its inclusion by the client LitData or LayeredLitData.
+// That way, LitDataIndividualLayer supports multiple inclusions)
+//
+// 
+#ifdef _NORMALMAP_TANGENT_SPACE
+    #if defined(_NORMALMAP)
+    #define SAMPLER_NORMALMAP_ID sampler_NormalMap
+    // TODO:
+    //#elif defined(_BENTNORMALMAP)
+    //#define SAMPLER_NORMALMAP_ID sampler_BentNormalMap
+    #endif
+#else
+    // TODO:
+    //#error STACKLIT_USES_ONLY_TANGENT_SPACE_FOR_NOW
+    //#if defined(_NORMALMAP)
+    //#define SAMPLER_NORMALMAP_ID sampler_NormalMapOS
+    //#elif defined(_BENTNORMALMAP)
+    //#define SAMPLER_NORMALMAP_ID sampler_BentNormalMapOS
+    //#endif
+#endif
+
+void ComputeLayerTexCoord( // Uv related parameters
+                                    float2 texCoord0, float2 texCoord1, float2 texCoord2, float2 texCoord3, float4 uvMappingMask, 
+                                    // scale and bias for base 
+                                    float2 texScale, float2 texBias, 
+                                    // mapping type and output
+                                    int mappingType, inout LayerTexCoord layerTexCoord)
+{
+
+    //TODO: Planar, Triplanar, detail map, surface_gradient.
+
+    // Handle uv0, uv1, uv2, uv3 based on _UVMappingMask weight (exclusif 0..1)
+    float2 uvBase = uvMappingMask.x * texCoord0 +
+                    uvMappingMask.y * texCoord1 +
+                    uvMappingMask.z * texCoord2 +
+                    uvMappingMask.w * texCoord3;
+    
+    // Copy data in uvmapping fields: used by generic sampling code (see especially SampleUVMappingNormalInternal.hlsl)
+    layerTexCoord.base.mappingType = mappingType;
+    layerTexCoord.base.normalWS = layerTexCoord.vertexNormalWS;
+
+    // Apply tiling options
+    layerTexCoord.base.uv = uvBase * texScale + texBias;
+}
+
+
+
+float3 GetNormalTS(FragInputs input, LayerTexCoord layerTexCoord, float3 detailNormalTS, float detailMask)
+{
+    // TODO: different spaces (eg #ifdef _NORMALMAP_TANGENT_SPACE #elif object space, SURFACE_GRADIENT, etc.)
+    // and use detail map
+
+    float3 normalTS;
+
+    // Note we don't use the _NORMALMAP_IDX mechanism of the Lit shader, since we don't have "layers", we can 
+    // directly use the shader_feature keyword:
+#ifdef _NORMALMAP
+        normalTS = SAMPLE_UVMAPPING_NORMALMAP(_NormalMap, SAMPLER_NORMALMAP_ID, layerTexCoord.base, _NormalScale);
+#else
+    normalTS = float3(0.0, 0.0, 1.0);
+#endif
+
+    return normalTS;
+}
+
+// This maybe call directly by tessellation (domain) shader, thus all part regarding surface gradient must be done
+// in function with FragInputs input as parameters
+// layerTexCoord must have been initialize to 0 outside of this function
+void GetLayerTexCoord(float2 texCoord0, float2 texCoord1, float2 texCoord2, float2 texCoord3,
+                      float3 positionWS, float3 vertexNormalWS, inout LayerTexCoord layerTexCoord)
+{
+    layerTexCoord.vertexNormalWS = vertexNormalWS;
+    // TODO: 
+    //layerTexCoord.triplanarWeights = ComputeTriplanarWeights(vertexNormalWS);
+
+    int mappingType = UV_MAPPING_UVSET;
+
+    //TODO: _MAPPING_PLANAR, _MAPPING_TRIPLANAR
+
+    // Be sure that the compiler is aware that we don't use UV1 to UV3 for main layer so it can optimize code
+    ComputeLayerTexCoord(   texCoord0, texCoord1, texCoord2, texCoord3, _UVMappingMask, /* TODO _UVDetailsMappingMask, */
+                            _BaseColorMap_ST.xy, _BaseColorMap_ST.zw, /* TODO _DetailMap_ST.xy, _DetailMap_ST.zw, 1.0, _LinkDetailsWithBase,
+                            /* TODO positionWS, _TexWorldScale, */
+                            mappingType, layerTexCoord);
+}
+
+// This is call only in this file
+// layerTexCoord must have been initialize to 0 outside of this function
+void GetLayerTexCoord(FragInputs input, inout LayerTexCoord layerTexCoord)
+{
+// TODO: SURFACE_GRADIENT
+//#ifdef SURFACE_GRADIENT
+    //GenerateLayerTexCoordBasisTB(input, layerTexCoord);
+//#endif
+
+    GetLayerTexCoord(   input.texCoord0, input.texCoord1, input.texCoord2, input.texCoord3,
+                        input.positionWS, input.worldToTangent[2].xyz, layerTexCoord);
+}
+
+//-----------------------------------------------------------------------------
+// ...Texture Mapping
+//-----------------------------------------------------------------------------
+
+//
+// cf with 
+//    LitData.hlsl:GetSurfaceAndBuiltinData()
+//    LitDataIndividualLayer.hlsl:GetSurfaceData( )
+//    LitBuiltinData.hlsl:GetBuiltinData() 
+//
+// Here we can combine them
+//
-    
-    // NEWLITTODO: 
-    // For now, just use the interpolated vertex normal. This has been normalized in the initial fragment interpolators unpacking.
-    // Eventually, we want to share all the LitData LayerTexCoord (and surface gradient frame + uv, planar, triplanar, etc.) logic, also
-    // spread in LitDataIndividualLayer and LitDataMeshModification.
-    surfaceData.normalWS = input.worldToTangent[2].xyz;
-    
-    float2 baseColorMapUv = TRANSFORM_TEX(input.texCoord0, _BaseColorMap);
-    surfaceData.baseColor = SAMPLE_TEXTURE2D(_BaseColorMap, sampler_BaseColorMap, baseColorMapUv).rgb * _BaseColor.rgb;
-    float alpha = SAMPLE_TEXTURE2D(_BaseColorMap, sampler_BaseColorMap, baseColorMapUv).a * _BaseColor.a;
+
+
+    LayerTexCoord layerTexCoord;
+    ZERO_INITIALIZE(LayerTexCoord, layerTexCoord);
+    GetLayerTexCoord(input, layerTexCoord);
+
+    // -------------------------------------------------------------
+    // Surface Data:
+    // -------------------------------------------------------------
+    // We perform the conversion to world of the normalTS outside of the GetSurfaceData
+    // so it allow us to correctly deal with detail normal map and optimize the code for the layered shaders
+    float3 normalTS;
+    // TODO: Those are only needed once we handle specular occlusion and optionnally bent normal maps.
+    // Also, for the builtinData part, use bentnormal to sample diffuse GI
+    //float3 bentNormalTS;
+    //float3 bentNormalWS;
+
+    //float alpha = SAMPLE_TEXTURE2D(_BaseColorMap, sampler_BaseColorMap, baseColorMapUv).a * _BaseColor.a;
+    float alpha = SAMPLE_UVMAPPING_TEXTURE2D(_BaseColorMap, sampler_BaseColorMap, layerTexCoord.base).a * _BaseColor.a;
 #ifdef _ALPHATEST_ON
     //NEWLITTODO: Once we include those passes in the main StackLit.shader, add handling of CUTOFF_TRANSPARENT_DEPTH_PREPASS and _POSTPASS
     // and the related properties (in the .shader) and uniforms (in the StackLitProperties file) _AlphaCutoffPrepass, _AlphaCutoffPostpass
+    // TODO detail map:
+    float3 detailNormalTS = float3(0.0, 0.0, 0.0);
+    float detailMask = 0.0;
+
+
+    //TODO remove the following and use fetching macros that use uvmapping :
+    //float2 baseColorMapUv = TRANSFORM_TEX(input.texCoord0, _BaseColorMap);
+    //surfaceData.baseColor = SAMPLE_TEXTURE2D(_BaseColorMap, sampler_BaseColorMap, baseColorMapUv).rgb * _BaseColor.rgb;
+    surfaceData.baseColor = SAMPLE_UVMAPPING_TEXTURE2D(_BaseColorMap, sampler_BaseColorMap, layerTexCoord.base).rgb * _BaseColor.rgb;
+
+
+    //surfaceData.normalWS = float3(0.0, 0.0, 0.0);
+
+    normalTS = GetNormalTS(input, layerTexCoord, detailNormalTS, detailMask);
+    //TODO: bentNormalTS
+
+#if defined(_MASKMAPA)
+    surfaceData.perceptualSmoothnessA = SAMPLE_UVMAPPING_TEXTURE2D(_MaskMapA, sampler_MaskMapA, layerTexCoord.base).a;
+    surfaceData.perceptualSmoothnessA = lerp(_SmoothnessARemapMin, _SmoothnessARemapMax, surfaceData.perceptualSmoothnessA);
+#else
+    surfaceData.perceptualSmoothnessA = _SmoothnessA;
+#endif
+
+#if defined(_MASKMAPB)
+    surfaceData.perceptualSmoothnessB = SAMPLE_UVMAPPING_TEXTURE2D(_MaskMapB, sampler_MaskMapB, layerTexCoord.base).a;
+    surfaceData.perceptualSmoothnessB = lerp(_SmoothnessBRemapMin, _SmoothnessBRemapMax, surfaceData.perceptualSmoothnessB);
+#else
+    surfaceData.perceptualSmoothnessB = _SmoothnessB;
+#endif
+    // TODOSTACKLIT: lobe weighting
+    surfaceData.lobeMix = _LobeMix;
+
+    // MaskMapA is RGBA: Metallic, Ambient Occlusion (Optional), detail Mask (Optional), Smoothness
+    // TODO: Ambient occlusion, detail mask.
+#ifdef _MASKMAPA
+    surfaceData.metallic = SAMPLE_UVMAPPING_TEXTURE2D(_MaskMapA, sampler_MaskMapA, layerTexCoord.base).r;
+#else
+    surfaceData.metallic = 1.0;
+#endif
+    surfaceData.metallic *= _Metallic;
+
+    // These static material feature allow compile time optimization
+    // TODO: As we add features, or-set the flags eg MATERIALFEATUREFLAGS_LIT_* with #ifdef 
+    // on corresponding _MATERIAL_FEATURE_* shader_feature kerwords (set by UI) so the compiler 
+    // knows the value of surfaceData.materialFeatures.
+    surfaceData.materialFeatures = MATERIALFEATUREFLAGS_LIT_STANDARD;
+
+    // -------------------------------------------------------------
+    // Surface Data Part 2 (outsite GetSurfaceData( ) in Lit shader):
+    // -------------------------------------------------------------
+
+    GetNormalWS(input, V, normalTS, surfaceData.normalWS); // MaterialUtilities.hlsl
+
+
+    // TODO: decal etc.
+
-        surfaceData.color = GetTextureDataDebug(_DebugMipMapMode, baseColorMapUv, _BaseColorMap, _BaseColorMap_TexelSize, _BaseColorMap_MipInfo, surfaceData.color);
+        surfaceData.baseColor = GetTextureDataDebug(_DebugMipMapMode, layerTexCoord.base.uv, _BaseColorMap, _BaseColorMap_TexelSize, _BaseColorMap_MipInfo, surfaceData.baseColor);
+        surfaceData.metallic = 0;
-    // Builtin Data
+    // -------------------------------------------------------------
+    // Builtin Data:
+    // -------------------------------------------------------------
+
     // NEWLITTODO: for all BuiltinData, might need to just refactor and use a comon function like that 
     // contained in LitBuiltinData.hlsl
 
 
     // Emissive Intensity is only use here, but is part of BuiltinData to enforce UI parameters as we want the users to fill one color and one intensity
-    builtinData.emissiveIntensity = _EmissiveIntensity;
+    builtinData.emissiveIntensity = _EmissiveIntensity; // We still store intensity here so we can reuse it with debug code
-
 
 #ifdef _EMISSIVE_COLOR_MAP
     builtinData.emissiveColor *= SAMPLE_TEXTURE2D(_EmissiveColorMap, sampler_EmissiveColorMap, TRANSFORM_TEX(input.texCoord0, _EmissiveColorMap)).rgb;

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/StackLit/StackLitProperties.hlsl

 TEXTURE2D(_BaseColorMap);
 SAMPLER(sampler_BaseColorMap);
 
+TEXTURE2D(_MaskMapA);
+SAMPLER(sampler_MaskMapA);
+
+TEXTURE2D(_MaskMapB);
+SAMPLER(sampler_MaskMapB);
+
+TEXTURE2D(_NormalMap);
+SAMPLER(sampler_NormalMap);
+
 
 CBUFFER_START(UnityPerMaterial)
 
 float4 _BaseColorMap_MipInfo;
+
+float _Metallic;
+float _SmoothnessA;
+float _SmoothnessARemapMin;
+float _SmoothnessARemapMax;
+float _SmoothnessB;
+float _SmoothnessBRemapMin;
+float _SmoothnessBRemapMax;
+float _LobeMix;
+
+float _NormalScale;
+
+float4 _UVMappingMask;
+
 
 float3 _EmissiveColor;
 float4 _EmissiveColorMap_ST;

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/SubsurfaceScattering/SubsurfaceScattering.compute

 void SubsurfaceScattering(uint2 groupId       : SV_GroupID,
                           uint  groupThreadId : SV_GroupThreadID)
 {
+    groupThreadId &= GROUP_SIZE_2D - 1; // Help the compiler
+
     // Note: any factor of 64 is a suitable wave size for our algorithm.
     uint waveIndex = WaveReadFirstLane(groupThreadId / 64);
     uint laneIndex = groupThreadId % 64;

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/SubsurfaceScattering/SubsurfaceScatteringManager.cs

 
         public int sssBufferCount { get { return k_MaxSSSBuffer; } }
 
-        RTHandle[] m_ColorMRTs = new RTHandle[k_MaxSSSBuffer];
+        RTHandleSystem.RTHandle[] m_ColorMRTs = new RTHandleSystem.RTHandle[k_MaxSSSBuffer];
         bool[] m_ExternalBuffer = new bool[k_MaxSSSBuffer];
 
         // Disney SSS Model
 
-        RTHandle m_HTile;
+        RTHandleSystem.RTHandle m_HTile;
         // End Disney SSS Model
 
         // Jimenez SSS Model
 
         // Jimenez need an extra buffer and Disney need one for some platform
-        RTHandle m_CameraFilteringBuffer;
+        RTHandleSystem.RTHandle m_CameraFilteringBuffer;
 
         // This is use to be able to read stencil value in compute shader
         Material m_CopyStencilForSplitLighting;
             {
                 // In case of full forward we must allocate the render target for forward SSS (or reuse one already existing)
                 // TODO: Provide a way to reuse a render target
-                m_ColorMRTs[0] = RTHandle.Alloc(Vector2.one, filterMode: FilterMode.Point, colorFormat: RenderTextureFormat.ARGB32, sRGB: true, name: "SSSBuffer");
+                m_ColorMRTs[0] = RTHandles.Alloc(Vector2.one, filterMode: FilterMode.Point, colorFormat: RenderTextureFormat.ARGB32, sRGB: true, name: "SSSBuffer");
                 m_ExternalBuffer[0] = false;
             }
             else
             if (ShaderConfig.k_UseDisneySSS == 0 || NeedTemporarySubsurfaceBuffer())
             {
                 // Caution: must be same format as m_CameraSssDiffuseLightingBuffer
-                m_CameraFilteringBuffer = RTHandle.Alloc(Vector2.one, filterMode: FilterMode.Point, colorFormat: RenderTextureFormat.RGB111110Float, sRGB: false, enableRandomWrite: true, enableMSAA: true, name: "SSSCameraFiltering"); // Enable UAV
+                m_CameraFilteringBuffer = RTHandles.Alloc(Vector2.one, filterMode: FilterMode.Point, colorFormat: RenderTextureFormat.RGB111110Float, sRGB: false, enableRandomWrite: true, enableMSAA: true, name: "SSSCameraFiltering"); // Enable UAV
-            m_HTile = RTHandle.Alloc(size => new Vector2Int((size.x + 7) / 8, (size.y + 7) / 8), filterMode: FilterMode.Point, colorFormat: RenderTextureFormat.R8, sRGB: false, enableRandomWrite: true, name: "SSSHtile"); // Enable UAV
+            m_HTile = RTHandles.Alloc(size => new Vector2Int((size.x + 7) / 8, (size.y + 7) / 8), filterMode: FilterMode.Point, colorFormat: RenderTextureFormat.R8, sRGB: false, enableRandomWrite: true, name: "SSSHtile"); // Enable UAV
-        public RTHandle GetSSSBuffer(int index)
+        public RTHandleSystem.RTHandle GetSSSBuffer(int index)
         {
             Debug.Assert(index < sssBufferCount);
             return m_ColorMRTs[index];
             {
                 if (!m_ExternalBuffer[i])
                 {
-                    RTHandle.Release(m_ColorMRTs[i]);
+                    RTHandles.Release(m_ColorMRTs[i]);
-            RTHandle.Release(m_CameraFilteringBuffer);
-            RTHandle.Release(m_HTile);
+            RTHandles.Release(m_CameraFilteringBuffer);
+            RTHandles.Release(m_HTile);
         }
 
         public void PushGlobalParams(CommandBuffer cmd, DiffusionProfileSettings sssParameters, FrameSettings frameSettings)
 
         // Combines specular lighting and diffuse lighting with subsurface scattering.
         public void SubsurfaceScatteringPass(HDCamera hdCamera, CommandBuffer cmd, DiffusionProfileSettings sssParameters, FrameSettings frameSettings,
-                                            RTHandle colorBufferRT, RTHandle diffuseBufferRT, RTHandle depthStencilBufferRT, RTHandle depthTextureRT)
+                                            RTHandleSystem.RTHandle colorBufferRT, RTHandleSystem.RTHandle diffuseBufferRT, RTHandleSystem.RTHandle depthStencilBufferRT, RTHandleSystem.RTHandle depthTextureRT)
         {
             if (sssParameters == null || !frameSettings.enableSubsurfaceScattering)
                 return;

ScriptableRenderPipeline/HDRenderPipeline/HDRP/RenderPipeline/FrameSettings.cs

         public bool enableMSAA = false;
         public MSAASamples msaaSampleCount { get; private set; }
 
-        public bool enableShadowMask = false;
+        public bool enableShadowMask = true;
 
         public LightLoopSettings lightLoopSettings = new LightLoopSettings();
 
             aggregate.enableObjectMotionVectors = camera.cameraType != CameraType.Reflection && srcFrameSettings.enableObjectMotionVectors && renderPipelineSettings.supportMotionVectors;
             aggregate.enableDBuffer = srcFrameSettings.enableDBuffer && renderPipelineSettings.supportDBuffer;
             aggregate.enableAtmosphericScattering = srcFrameSettings.enableAtmosphericScattering;
+            // We must take care of the scene view fog flags in the editor
+            if (!CoreUtils.IsSceneViewFogEnabled(camera))
+                aggregate.enableAtmosphericScattering = false;
             aggregate.enableRoughRefraction = srcFrameSettings.enableRoughRefraction;
             aggregate.enableTransparentPostpass = srcFrameSettings.enableTransparentPostpass;
             aggregate.enableDistortion = camera.cameraType != CameraType.Reflection && srcFrameSettings.enableDistortion;

ScriptableRenderPipeline/HDRenderPipeline/HDRP/RenderPipelineResources/BufferPyramid.cs

-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using UnityEngine.Rendering;
 
 namespace UnityEngine.Experimental.Rendering.HDPipeline
-        RTHandle m_ColorPyramidBuffer;
-        List<RTHandle> m_ColorPyramidMips = new List<RTHandle>();
-
-        RTHandle m_DepthPyramidBuffer;
-        List<RTHandle> m_DepthPyramidMips = new List<RTHandle>();
-
-        public RTHandle colorPyramid { get { return m_ColorPyramidBuffer; } }
-        public RTHandle depthPyramid { get { return m_DepthPyramidBuffer; } }
+        List<RTHandleSystem.RTHandle> m_ColorPyramidMips = new List<RTHandleSystem.RTHandle>();
+        List<RTHandleSystem.RTHandle> m_DepthPyramidMips = new List<RTHandleSystem.RTHandle>();
 
         BufferPyramidProcessor m_Processor;
 
             return scale;
         }
 
-        public void CreateBuffers()
-        {
-            m_ColorPyramidBuffer = RTHandle.Alloc(size => CalculatePyramidSize(size), filterMode: FilterMode.Trilinear, colorFormat: RenderTextureFormat.ARGBHalf, sRGB: false, useMipMap: true, autoGenerateMips: false, enableRandomWrite: true, name: "ColorPyramid");
-            m_DepthPyramidBuffer = RTHandle.Alloc(size => CalculatePyramidSize(size), filterMode: FilterMode.Trilinear, colorFormat: RenderTextureFormat.RGFloat, sRGB: false, useMipMap: true, autoGenerateMips: false, enableRandomWrite: true, name: "DepthPyramid"); // Need randomReadWrite because we downsample the first mip with a compute shader.
-        }
-
-            RTHandle.Release(m_ColorPyramidBuffer);
-            RTHandle.Release(m_DepthPyramidBuffer);
-
-            {
-                RTHandle.Release(rth);
-            }
+                RTHandles.Release(rth);
-            {
-                RTHandle.Release(rth);
-            }
+                RTHandles.Release(rth);
-        public int GetPyramidLodCount(HDCamera camera)
+        public int GetPyramidLodCount(Vector2Int size)
-            var minSize = Mathf.Min(camera.actualWidth, camera.actualHeight);
-            return Mathf.FloorToInt(Mathf.Log(minSize, 2f));
+            var minSize = Mathf.Min(size.x, size.y);
+            return Mathf.Max(0, Mathf.FloorToInt(Mathf.Log(minSize, 2f)));
         }
 
         Vector2Int CalculatePyramidMipSize(Vector2Int baseMipSize, int mipIndex)
             return new Vector2Int((int)(pyramidSize * GetXRscale()), pyramidSize);
         }
 
-        void UpdatePyramidMips(HDCamera camera, RenderTextureFormat format, List<RTHandle> mipList, int lodCount)
+        void UpdatePyramidMips(HDCamera camera, RenderTextureFormat format, List<RTHandleSystem.RTHandle> mipList, int lodCount)
         {
             int currentLodCount = mipList.Count;
             if (lodCount > currentLodCount)
                     int mipIndexCopy = i + 1; // Don't remove this copy! It's important for the value to be correctly captured by the lambda.
-                    RTHandle newMip = RTHandle.Alloc(size => CalculatePyramidMipSize(CalculatePyramidSize(size), mipIndexCopy), colorFormat: format, sRGB: false, enableRandomWrite: true, useMipMap: false, filterMode: FilterMode.Bilinear, name: string.Format("PyramidMip{0}", i));
+                    var newMip = RTHandles.Alloc(size => CalculatePyramidMipSize(CalculatePyramidSize(size), mipIndexCopy), colorFormat: format, sRGB: false, enableRandomWrite: true, useMipMap: false, filterMode: FilterMode.Bilinear, name: string.Format("PyramidMip{0}", i));
-        public Vector2 GetPyramidToScreenScale(HDCamera camera)
+        public Vector2 GetPyramidToScreenScale(HDCamera camera, RTHandleSystem.RTHandle rth)
-            return new Vector2((float)camera.actualWidth / m_DepthPyramidBuffer.rt.width, (float)camera.actualHeight / m_DepthPyramidBuffer.rt.height);
+            return new Vector2((float)camera.actualWidth / rth.rt.width, (float)camera.actualHeight / rth.rt.height);
         }
 
         public void RenderDepthPyramid(
-            RTHandle depthTexture)
+            RTHandleSystem.RTHandle sourceDepthTexture,
+            RTHandleSystem.RTHandle targetDepthTexture)
-            int lodCount = GetPyramidLodCount(hdCamera);
-            UpdatePyramidMips(hdCamera, m_DepthPyramidBuffer.rt.format, m_DepthPyramidMips, lodCount);
+            int lodCount = Mathf.Min(
+                GetPyramidLodCount(targetDepthTexture.referenceSize),
+                GetPyramidLodCount(new Vector2Int(hdCamera.actualWidth, hdCamera.actualHeight))
+            );
+            if (lodCount == 0)
+            {
+                Debug.LogWarning("The target for the pyramid buffer has an invalid size. Skipping DepthPyramid calculation.");
+                return;
+            }
-            Vector2 scale = GetPyramidToScreenScale(hdCamera);
+            UpdatePyramidMips(hdCamera, targetDepthTexture.rt.format, m_DepthPyramidMips, lodCount);
+
+            Vector2 scale = GetPyramidToScreenScale(hdCamera, targetDepthTexture);
             cmd.SetGlobalVector(HDShaderIDs._DepthPyramidSize, new Vector4(hdCamera.actualWidth, hdCamera.actualHeight, 1f / hdCamera.actualWidth, 1f / hdCamera.actualHeight));
             cmd.SetGlobalVector(HDShaderIDs._DepthPyramidScale, new Vector4(scale.x, scale.y, lodCount, 0.0f));
 
-                depthTexture,
-                m_DepthPyramidBuffer,
+                sourceDepthTexture,
+                targetDepthTexture,
-            cmd.SetGlobalTexture(HDShaderIDs._DepthPyramidTexture, m_DepthPyramidBuffer);
+            cmd.SetGlobalTexture(HDShaderIDs._DepthPyramidTexture, targetDepthTexture);
         }
 
         public void RenderColorPyramid(
-            RTHandle colorTexture)
+            RTHandleSystem.RTHandle sourceColorTexture,
+            RTHandleSystem.RTHandle targetColorTexture)
-            int lodCount = GetPyramidLodCount(hdCamera);
-            UpdatePyramidMips(hdCamera, m_ColorPyramidBuffer.rt.format, m_ColorPyramidMips, lodCount);
+            int lodCount = Mathf.Min(
+                GetPyramidLodCount(targetColorTexture.referenceSize),
+                GetPyramidLodCount(new Vector2Int(hdCamera.actualWidth, hdCamera.actualHeight))
+            );
+            if (lodCount == 0)
+            {
+                Debug.LogWarning("The target for the pyramid buffer has an invalid size. Skipping ColorPyramid calculation.");
+                return;
+            }
-            Vector2 scale = GetPyramidToScreenScale(hdCamera);
+            UpdatePyramidMips(hdCamera, targetColorTexture.rt.format, m_ColorPyramidMips, lodCount);
+
+            Vector2 scale = GetPyramidToScreenScale(hdCamera, targetColorTexture);
             cmd.SetGlobalVector(HDShaderIDs._ColorPyramidSize, new Vector4(hdCamera.actualWidth, hdCamera.actualHeight, 1f / hdCamera.actualWidth, 1f / hdCamera.actualHeight));
             cmd.SetGlobalVector(HDShaderIDs._ColorPyramidScale, new Vector4(scale.x, scale.y, lodCount, 0.0f));
 
-                colorTexture,
-                m_ColorPyramidBuffer,
+                sourceColorTexture,
+                targetColorTexture,
-            cmd.SetGlobalTexture(HDShaderIDs._ColorPyramidTexture, m_ColorPyramidBuffer);
+            cmd.SetGlobalTexture(HDShaderIDs._ColorPyramidTexture, targetColorTexture);
+        }
+
+        public RTHandleSystem.RTHandle AllocColorRT(string id, int frameIndex, RTHandleSystem rtHandleSystem)
+        {
+            return rtHandleSystem.Alloc(
+                size => CalculatePyramidSize(size), 
+                filterMode: FilterMode.Trilinear, 
+                colorFormat: RenderTextureFormat.ARGBHalf, 
+                sRGB: false, 
+                useMipMap: true, 
+                autoGenerateMips: false, 
+                enableRandomWrite: true, 
+                name: string.Format("ColorPyramid-{0}-{1}", id, frameIndex)
+            );
+        }
+
+        public RTHandleSystem.RTHandle AllocDepthRT(string id, int frameIndex, RTHandleSystem rtHandleSystem)
+        {
+            return rtHandleSystem.Alloc(
+                size => CalculatePyramidSize(size), 
+                filterMode: FilterMode.Trilinear, 
+                colorFormat: RenderTextureFormat.RGFloat, 
+                sRGB: false, 
+                useMipMap: true, 
+                autoGenerateMips: false, 
+                enableRandomWrite: true, // Need randomReadWrite because we downsample the first mip with a compute shader.
+                name: string.Format("DepthPyramid-{0}-{1}", id, frameIndex)
+            );
         }
     }
 }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/RenderPipelineResources/BufferPyramidProcessor.cs

         public void RenderDepthPyramid(
             int width, int height,
             CommandBuffer cmd,
-            RTHandle sourceTexture,
-            RTHandle targetTexture,
-            List<RTHandle> mips,
+            RTHandleSystem.RTHandle sourceTexture,
+            RTHandleSystem.RTHandle targetTexture,
+            List<RTHandleSystem.RTHandle> mips,
             int lodCount,
             Vector2 scale
         )
-            RTHandle src = targetTexture;
+            var src = targetTexture;
-                RTHandle dest = mips[i];
+                var dest = mips[i];
 
                 var srcMip = new RectInt(0, 0, width >> i, height >> i);
                 var dstMip = new RectInt(0, 0, srcMip.width >> 1, srcMip.height >> 1);
         public void RenderColorPyramid(
             HDCamera hdCamera,
             CommandBuffer cmd,
-            RTHandle sourceTexture,
-            RTHandle targetTexture,
-            List<RTHandle> mips,
+            RTHandleSystem.RTHandle sourceTexture,
+            RTHandleSystem.RTHandle targetTexture,
+            List<RTHandleSystem.RTHandle> mips,
             int lodCount,
             Vector2 scale
         )

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 data = DensityVolumeData.GetNeutralValues();
+
+                cmd.SetGlobalVector(HDShaderIDs._GlobalScattering, data.scattering);
+                cmd.SetGlobalFloat( HDShaderIDs._GlobalExtinction, data.extinction);
+                cmd.SetGlobalFloat( HDShaderIDs._GlobalAsymmetry,  0.0f);
+            }
+        // 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 = SampleInScatteredRadianceAndTransmittance(TEXTURE3D_PARAM(_VBufferLighting, s_trilinear_clamp_sampler),
-															  posInput.positionNDC, posInput.linearDepth,
-															  _VBufferResolution,
-															  _VBufferSliceCount.xy,
-															  _VBufferDepthEncodingParams,
-															  _VBufferDepthDecodingParams);
-	fogColor = volFog.rgb;
-	fogFactor = 1 - volFog.a;
-#else
+	switch (_AtmosphericScatteringType)
+	{
+		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);
-	if (_AtmosphericScatteringType == 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));
-	}
-	else if (_AtmosphericScatteringType == FOGTYPE_LINEAR)
-	{
-		fogColor = GetFogColor(posInput);
-		fogFactor = _FogDensity * saturate((posInput.linearDepth - _LinearFogStart) * _LinearFogOneOverRange) * saturate((_LinearFogHeightEnd - GetAbsolutePositionWS(posInput.positionWS).y) * _LinearFogHeightOneOverRange);
-	}
-	else // NONE
-	{
+			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/OpaqueAtmosphericScattering.shader

             // #pragma enable_d3d11_debug_symbols
 
             #include "CoreRP/ShaderLibrary/Common.hlsl"
+            #include "CoreRP/ShaderLibrary/Color.hlsl"
             #include "../ShaderVariables.hlsl"
             #include "AtmosphericScattering/AtmosphericScattering.hlsl"
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Sky/SkyManager.cs

 
     public class BuiltinSkyParameters
     {
-        public Matrix4x4        pixelCoordToViewDirMatrix;
-        public Matrix4x4        invViewProjMatrix;
-        public Vector3          cameraPosWS;
-        public Vector4          screenSize;
-        public CommandBuffer    commandBuffer;
-        public Light            sunLight;
-        public RTHandle         colorBuffer;
-        public RTHandle         depthBuffer;
-        public HDCamera         hdCamera;
+        public Matrix4x4                pixelCoordToViewDirMatrix;
+        public Matrix4x4                invViewProjMatrix;
+        public Vector3                  cameraPosWS;
+        public Vector4                  screenSize;
+        public CommandBuffer            commandBuffer;
+        public Light                    sunLight;
+        public RTHandleSystem.RTHandle  colorBuffer;
+        public RTHandleSystem.RTHandle  depthBuffer;
+        public HDCamera                 hdCamera;
 
         public DebugDisplaySettings debugSettings;
 
 #if UNITY_EDITOR
             if (camera.camera.cameraType == CameraType.Preview)
             {
-                m_VisualSky.skySettings = m_DefaultPreviewSky;
+                m_VisualSky.skySettings = GetDefaultPreviewSkyInstance();
             }
 #endif
 
             cmd.SetGlobalFloat(HDShaderIDs._SkyTextureMipCount, mipCount);
         }
 
+#if UNITY_EDITOR
+        ProceduralSky GetDefaultPreviewSkyInstance()
+        {
+            if (m_DefaultPreviewSky == null)
+            {
+                m_DefaultPreviewSky = ScriptableObject.CreateInstance<ProceduralSky>();
+            }
+
+            return m_DefaultPreviewSky;
+        }
+#endif
+
         public void Build(HDRenderPipelineAsset hdAsset, IBLFilterGGX iblFilterGGX)
         {
             m_BakingSkyRenderingContext = new SkyRenderingContext(iblFilterGGX, (int)hdAsset.renderPipelineSettings.lightLoopSettings.skyReflectionSize, false);
 
             m_LightingOverrideVolumeStack = VolumeManager.instance.CreateStack();
             m_LightingOverrideLayerMask = hdAsset.renderPipelineSettings.lightLoopSettings.skyLightingOverrideLayerMask;
-
-#if UNITY_EDITOR
-            m_DefaultPreviewSky = ScriptableObject.CreateInstance<ProceduralSky>();
-#endif
+
+#if UNITY_EDITOR
+            CoreUtils.Destroy(m_DefaultPreviewSky);
+#endif
             CoreUtils.Destroy(m_StandardSkyboxMaterial);
             CoreUtils.Destroy(m_BlitCubemapMaterial);
             CoreUtils.Destroy(m_OpaqueAtmScatteringMaterial);
             }
         }
 
-        public void RenderSky(HDCamera camera, Light sunLight, RTHandle colorBuffer, RTHandle depthBuffer, DebugDisplaySettings debugSettings, CommandBuffer cmd)
+        public void RenderSky(HDCamera camera, Light sunLight, RTHandleSystem.RTHandle colorBuffer, RTHandleSystem.RTHandle depthBuffer, DebugDisplaySettings debugSettings, CommandBuffer cmd)
         {
             m_SkyRenderingContext.RenderSky(m_VisualSky, camera, sunLight, colorBuffer, depthBuffer, debugSettings, cmd);
         }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Sky/SkyRenderingContext.cs

     internal class SkyRenderingContext
     {
         IBLFilterGGX            m_IBLFilterGGX;
-        RTHandle                m_SkyboxCubemapRT;
-        RTHandle                m_SkyboxGGXCubemapRT;
-        RTHandle                m_SkyboxMarginalRowCdfRT;
-        RTHandle                m_SkyboxConditionalCdfRT;
+        RTHandleSystem.RTHandle m_SkyboxCubemapRT;
+        RTHandleSystem.RTHandle m_SkyboxGGXCubemapRT;
+        RTHandleSystem.RTHandle m_SkyboxMarginalRowCdfRT;
+        RTHandleSystem.RTHandle m_SkyboxConditionalCdfRT;
         Vector4                 m_CubemapScreenSize;
         Matrix4x4[]             m_facePixelCoordToViewDirMatrices   = new Matrix4x4[6];
         Matrix4x4[]             m_faceCameraInvViewProjectionMatrix = new Matrix4x4[6];
             // Cleanup first if needed
             if (updateNeeded)
             {
-                RTHandle.Release(m_SkyboxCubemapRT);
-                RTHandle.Release(m_SkyboxGGXCubemapRT);
+                RTHandles.Release(m_SkyboxCubemapRT);
+                RTHandles.Release(m_SkyboxGGXCubemapRT);
 
                 m_SkyboxCubemapRT = null;
                 m_SkyboxGGXCubemapRT = null;
             {
-                RTHandle.Release(m_SkyboxConditionalCdfRT);
-                RTHandle.Release(m_SkyboxMarginalRowCdfRT);
+                RTHandles.Release(m_SkyboxConditionalCdfRT);
+                RTHandles.Release(m_SkyboxMarginalRowCdfRT);
 
                 m_SkyboxConditionalCdfRT = null;
                 m_SkyboxMarginalRowCdfRT = null;
             if (m_SkyboxCubemapRT == null)
             {
-                m_SkyboxCubemapRT = RTHandle.Alloc(resolution, resolution, colorFormat: RenderTextureFormat.ARGBHalf, sRGB: false, dimension: TextureDimension.Cube, useMipMap: true, autoGenerateMips: false, filterMode: FilterMode.Trilinear, name: "SkyboxCubemap");
+                m_SkyboxCubemapRT = RTHandles.Alloc(resolution, resolution, colorFormat: RenderTextureFormat.ARGBHalf, sRGB: false, dimension: TextureDimension.Cube, useMipMap: true, autoGenerateMips: false, filterMode: FilterMode.Trilinear, name: "SkyboxCubemap");
-                m_SkyboxGGXCubemapRT = RTHandle.Alloc(resolution, resolution, colorFormat: RenderTextureFormat.ARGBHalf, sRGB: false, dimension: TextureDimension.Cube, useMipMap: true, autoGenerateMips: false, filterMode: FilterMode.Trilinear, name: "SkyboxGGXCubemap");
+                m_SkyboxGGXCubemapRT = RTHandles.Alloc(resolution, resolution, colorFormat: RenderTextureFormat.ARGBHalf, sRGB: false, dimension: TextureDimension.Cube, useMipMap: true, autoGenerateMips: false, filterMode: FilterMode.Trilinear, name: "SkyboxGGXCubemap");
             }
 
             if (m_SupportsMIS && (m_SkyboxConditionalCdfRT == null))
                 int height = (int)LightSamplingParameters.TextureHeight;
 
                 // + 1 because we store the value of the integral of the cubemap at the end of the texture.
-                m_SkyboxMarginalRowCdfRT = RTHandle.Alloc(height + 1, 1, colorFormat: RenderTextureFormat.RFloat, sRGB: false, useMipMap: false, enableRandomWrite: true, filterMode: FilterMode.Point, name: "SkyboxMarginalRowCdf");
+                m_SkyboxMarginalRowCdfRT = RTHandles.Alloc(height + 1, 1, colorFormat: RenderTextureFormat.RFloat, sRGB: false, useMipMap: false, enableRandomWrite: true, filterMode: FilterMode.Point, name: "SkyboxMarginalRowCdf");
-                m_SkyboxMarginalRowCdfRT = RTHandle.Alloc(width, height, colorFormat: RenderTextureFormat.RFloat, sRGB: false, useMipMap: false, enableRandomWrite: true, filterMode: FilterMode.Point, name: "SkyboxMarginalRowCdf");
+                m_SkyboxMarginalRowCdfRT = RTHandles.Alloc(width, height, colorFormat: RenderTextureFormat.RFloat, sRGB: false, useMipMap: false, enableRandomWrite: true, filterMode: FilterMode.Point, name: "SkyboxMarginalRowCdf");
             }
 
             m_CubemapScreenSize = new Vector4((float)resolution, (float)resolution, 1.0f / (float)resolution, 1.0f / (float)resolution);
         }
         public void Cleanup()
         {
-            RTHandle.Release(m_SkyboxCubemapRT);
-            RTHandle.Release(m_SkyboxGGXCubemapRT);
-            RTHandle.Release(m_SkyboxMarginalRowCdfRT);
-            RTHandle.Release(m_SkyboxConditionalCdfRT);
+            RTHandles.Release(m_SkyboxCubemapRT);
+            RTHandles.Release(m_SkyboxGGXCubemapRT);
+            RTHandles.Release(m_SkyboxMarginalRowCdfRT);
+            RTHandles.Release(m_SkyboxConditionalCdfRT);
         }
 
         void RenderSkyToCubemap(SkyUpdateContext skyContext)
             return result;
         }
 
-        public void RenderSky(SkyUpdateContext skyContext, HDCamera hdCamera, Light sunLight, RTHandle colorBuffer, RTHandle depthBuffer, DebugDisplaySettings debugSettings, CommandBuffer cmd)
+        public void RenderSky(SkyUpdateContext skyContext, HDCamera hdCamera, Light sunLight, RTHandleSystem.RTHandle colorBuffer, RTHandleSystem.RTHandle depthBuffer, DebugDisplaySettings debugSettings, CommandBuffer cmd)
         {
             if (skyContext.IsValid() && hdCamera.clearColorMode == HDAdditionalCameraData.ClearColorMode.Sky)
             {

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/Texture2DAtlas.cs

 
     public class Texture2DAtlas
     {
-        private RTHandle m_AtlasTexture = null;
+        private RTHandleSystem.RTHandle m_AtlasTexture = null;
         private int m_Width;
         private int m_Height;
         private RenderTextureFormat m_Format;
-        public RTHandle AtlasTexture
+        public RTHandleSystem.RTHandle AtlasTexture
         {
             get
             {
             m_Width = width;
             m_Height = height;
             m_Format = format;
-            m_AtlasTexture = RTHandle.Alloc(m_Width,
+            m_AtlasTexture = RTHandles.Alloc(m_Width,
                 m_Height,
                 1,
                 DepthBits.None,
         public void Release()
         {
             ResetAllocator();
-            RTHandle.Release(m_AtlasTexture);
+            RTHandles.Release(m_AtlasTexture);
         }
 
         public void ResetAllocator()

ScriptableRenderPipeline/Core/CoreRP/Textures/BufferedRTHandleSystem.cs

+using System;
+using System.Collections.Generic;
+using UnityEngine.Assertions;
+using UnityEngine.Rendering;
+
+namespace UnityEngine.Experimental.Rendering
+{
+    public class BufferedRTHandleSystem : IDisposable
+    {
+        Dictionary<int, RTHandleSystem.RTHandle[]> m_RTHandles = new Dictionary<int, RTHandleSystem.RTHandle[]>();
+
+        RTHandleSystem m_RTHandleSystem = new RTHandleSystem();
+        bool m_DisposedValue = false;
+
+        public RTHandleSystem.RTHandle GetFrameRT(int id, int index)
+        {
+            if (!m_RTHandles.ContainsKey(id))
+                return null;
+
+            Assert.IsTrue(index >= 0 && index < m_RTHandles[id].Length);
+
+            return m_RTHandles[id][index];
+        }
+
+        public void AllocBuffer(
+            int id, 
+            Func<RTHandleSystem, int, RTHandleSystem.RTHandle> allocator,
+            int bufferSize
+        )
+        {
+            var buffer = new RTHandleSystem.RTHandle[bufferSize];
+            m_RTHandles.Add(id, buffer);
+
+            // First is autoresized
+            buffer[0] = allocator(m_RTHandleSystem, 0);
+
+            // Other are resized on demand
+            for (int i = 1, c = buffer.Length; i < c; ++i)
+            {
+                buffer[i] = allocator(m_RTHandleSystem, i);
+                m_RTHandleSystem.SwitchResizeMode(buffer[i], RTHandleSystem.ResizeMode.OnDemand);
+            }
+        }
+
+        public void SetReferenceSize(int width, int height, bool msaa, MSAASamples msaaSamples)
+        {
+            m_RTHandleSystem.SetReferenceSize(width, height, msaa, msaaSamples);
+        }
+
+        public void Swap()
+        {
+            foreach (var item in m_RTHandles)
+            {
+                var nextFirst = item.Value[item.Value.Length - 1];
+                for (int i = 0, c = item.Value.Length - 1; i < c; ++i)
+                    item.Value[i + 1] = item.Value[i];
+                item.Value[0] = nextFirst;
+
+                // First is autoresize, other are on demand
+                m_RTHandleSystem.SwitchResizeMode(item.Value[0], RTHandleSystem.ResizeMode.Auto);
+                m_RTHandleSystem.SwitchResizeMode(item.Value[1], RTHandleSystem.ResizeMode.OnDemand);
+            }
+        }
+
+        void Dispose(bool disposing)
+        {
+            if (!m_DisposedValue)
+            {
+                if (disposing)
+                {
+                    m_RTHandleSystem.Dispose();
+                    m_RTHandleSystem = null;
+                }
+
+                m_DisposedValue = true;
+            }
+        }
+
+        public void Dispose()
+        {
+            Dispose(true);
+        }
+
+        public void ReleaseAll()
+        {
+            foreach (var item in m_RTHandles)
+            {
+                for (int i = 0, c = item.Value.Length; i < c; ++i)
+                {
+                    m_RTHandleSystem.Release(item.Value[i]);
+                }
+            }
+            m_RTHandles.Clear();
+        }
+    }
+}

ScriptableRenderPipeline/Core/CoreRP/Textures/BufferedRTHandleSystem.cs.meta

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

ScriptableRenderPipeline/Core/CoreRP/Textures/DepthBits.cs

+using System.Collections.Generic;
+using UnityEngine.Rendering;
+
+namespace UnityEngine.Experimental.Rendering
+{
+    public enum DepthBits
+    {
+        None = 0,
+        Depth8 = 8,
+        Depth16 = 16,
+        Depth24 = 24
+    }
+}

ScriptableRenderPipeline/Core/CoreRP/Textures/MSAASamples.cs

+using System.Collections.Generic;
+using UnityEngine.Rendering;
+
+namespace UnityEngine.Experimental.Rendering
+{
+    public enum MSAASamples
+    {
+        None = 1,
+        MSAA2x = 2,
+        MSAA4x = 4,
+        MSAA8x = 8
+    }
+}

ScriptableRenderPipeline/Core/CoreRP/Textures/MSAASamples.cs.meta

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

ScriptableRenderPipeline/Core/CoreRP/Textures/RTCategory.cs

+using System.Collections.Generic;
+using UnityEngine.Rendering;
+
+namespace UnityEngine.Experimental.Rendering
+{
+    enum RTCategory
+    {
+        Regular = 0,
+        MSAA = 1,
+        Count
+    }
+}

ScriptableRenderPipeline/Core/CoreRP/Textures/RTCategory.cs.meta

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

ScriptableRenderPipeline/Core/CoreRP/Textures/RTHandleSystem.RTHandle.cs

+using System.Collections.Generic;
+using UnityEngine.Rendering;
+
+namespace UnityEngine.Experimental.Rendering
+{
+    public partial class RTHandleSystem
+    {
+        public class RTHandle
+        {
+            internal RTHandleSystem             m_Owner;
+            internal RenderTexture[]            m_RTs = new RenderTexture[2];
+            internal RenderTargetIdentifier[]   m_NameIDs = new RenderTargetIdentifier[2];
+            internal bool                       m_EnableMSAA = false;
+            internal bool                       m_EnableRandomWrite = false;
+            internal string                     m_Name;
+
+            internal Vector2 scaleFactor        = Vector2.one;
+            internal ScaleFunc scaleFunc;
+
+            public bool                         useScaling { get; internal set; }
+            public Vector2Int                   referenceSize {get; internal set; }
+
+            public RenderTexture rt
+            {
+                get
+                {
+                    if(!useScaling)
+                    {
+                        return m_EnableMSAA ? m_RTs[(int)RTCategory.MSAA] : m_RTs[(int)RTCategory.Regular];
+                    }
+                    else
+                    {
+                        var category = (m_EnableMSAA && m_Owner.m_ScaledRTCurrentCategory == RTCategory.MSAA) ? RTCategory.MSAA : RTCategory.Regular;
+                        CreateIfNeeded(category);
+                        return m_RTs[(int)category];
+                    }
+                }
+            }
+
+            public RenderTargetIdentifier nameID
+            {
+                get
+                {
+                    if (!useScaling)
+                    {
+                        return m_EnableMSAA ? m_NameIDs[(int)RTCategory.MSAA] : m_RTs[(int)RTCategory.Regular];
+                    }
+                    else
+                    {
+                        var category = (m_EnableMSAA && m_Owner.m_ScaledRTCurrentCategory == RTCategory.MSAA) ? RTCategory.MSAA : RTCategory.Regular;
+                        CreateIfNeeded(category);
+                        return m_NameIDs[(int)category];
+                    }
+                }
+            }
+
+            // Keep constructor private
+            internal RTHandle(RTHandleSystem owner)
+            {
+                m_Owner = owner;
+            }
+
+            public static implicit operator RenderTexture(RTHandle handle)
+            {
+                return handle.rt;
+            }
+
+            public static implicit operator RenderTargetIdentifier(RTHandle handle)
+            {
+                return handle.nameID;
+            }
+
+            internal void SetRenderTexture(RenderTexture rt, RTCategory category)
+            {
+                m_RTs[(int)category] = rt;
+                m_NameIDs[(int)category] = new RenderTargetIdentifier(rt);
+            }
+
+            void CreateIfNeeded(RTCategory category)
+            {
+                // If a RT was first created for MSAA then the regular one might be null, in this case we create it.
+                // That's why we never test the MSAA version: It should always be there if RT was declared correctly.
+                if(category == RTCategory.Regular && m_RTs[(int)RTCategory.Regular] == null)
+                {
+                    var refRT = m_RTs[(int)RTCategory.MSAA];
+                    Debug.Assert(refRT != null);
+                    referenceSize = new Vector2Int(m_Owner.maxWidthRegular, m_Owner.maxHeightRegular);
+                    var scaledSize = GetScaledSize(referenceSize);
+
+                    var newRT = new RenderTexture(scaledSize.x, scaledSize.y, refRT.depth, refRT.format, refRT.sRGB ? RenderTextureReadWrite.sRGB : RenderTextureReadWrite.Linear)
+                    {
+                        hideFlags = HideFlags.HideAndDontSave,
+                        volumeDepth = refRT.volumeDepth,
+                        filterMode = refRT.filterMode,
+                        wrapMode = refRT.wrapMode,
+                        dimension = refRT.dimension,
+                        enableRandomWrite = m_EnableRandomWrite, // We cannot take the info from the msaa rt since we force it to 1
+                        useMipMap = refRT.useMipMap,
+                        autoGenerateMips = refRT.autoGenerateMips,
+                        anisoLevel = refRT.anisoLevel,
+                        mipMapBias = refRT.mipMapBias,
+                        antiAliasing = 1, // No MSAA for the regular version of the texture.
+                        bindTextureMS = false, // Somehow, this can be true even if antiAliasing == 1. Leads to Unity-internal binding errors.
+                        useDynamicScale = refRT.useDynamicScale,
+                        vrUsage = refRT.vrUsage,
+                        memorylessMode = refRT.memorylessMode,
+                        name = CoreUtils.GetRenderTargetAutoName(refRT.width, refRT.height, refRT.format, m_Name, mips : refRT.useMipMap)
+                    };
+                    newRT.Create();
+
+                    m_RTs[(int)RTCategory.Regular] = newRT;
+                    m_NameIDs[(int)RTCategory.Regular] = new RenderTargetIdentifier(newRT);
+                }
+            }
+
+            public void Release()
+            {
+                m_Owner.m_AutoSizedRTs.Remove(this);
+                for (int i = 0; i < (int)RTCategory.Count; ++i)
+                {
+                    CoreUtils.Destroy(m_RTs[i]);
+                    m_NameIDs[i] = BuiltinRenderTextureType.None;
+                    m_RTs[i] = null;
+                }
+            }
+
+            public Vector2Int GetScaledSize(Vector2Int refSize)
+            {
+                if (scaleFunc != null)
+                {
+                    return scaleFunc(refSize);
+                }
+                else
+                {
+                    return new Vector2Int(
+                        x: Mathf.RoundToInt(scaleFactor.x * refSize.x),
+                        y: Mathf.RoundToInt(scaleFactor.y * refSize.y)
+                    );
+                }
+            }
+        }
+    }
+}

ScriptableRenderPipeline/Core/CoreRP/Textures/RTHandleSystem.RTHandle.cs.meta

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

ScriptableRenderPipeline/Core/CoreRP/Textures/RTHandleSystem.cs

+using System;
+using System.Collections.Generic;
+using UnityEngine.Assertions;
+using UnityEngine.Rendering;
+
+namespace UnityEngine.Experimental.Rendering
+{
+    public delegate Vector2Int ScaleFunc(Vector2Int size);
+
+    public partial class RTHandleSystem : IDisposable
+    {
+        public enum ResizeMode
+        {
+            Auto,
+            OnDemand
+        }
+
+        internal enum RTCategory
+        {
+            Regular = 0,
+            MSAA = 1,
+            Count
+        }
+
+        // Parameters for auto-scaled Render Textures
+        bool                m_ScaledRTSupportsMSAA = false;
+        MSAASamples         m_ScaledRTCurrentMSAASamples = MSAASamples.None;
+        HashSet<RTHandle>   m_AutoSizedRTs;
+        RTHandle[]          m_AutoSizedRTsArray; // For fast iteration
+        HashSet<RTHandle>   m_ResizeOnDemandRTs;
+        RTCategory          m_ScaledRTCurrentCategory = RTCategory.Regular;
+
+        int[] m_MaxWidths = new int[(int)RTCategory.Count];
+        int[] m_MaxHeights = new int[(int)RTCategory.Count];
+
+        int maxWidthRegular { get { return GetMaxWidth(RTCategory.Regular); } }
+        int maxHeightRegular { get { return GetMaxHeight(RTCategory.Regular); } }
+
+        int maxWidthMSAA { get { return GetMaxWidth(RTCategory.MSAA); } }
+        int maxHeightMSAA { get { return GetMaxHeight(RTCategory.MSAA); } }
+
+        public int maxWidth { get { return GetMaxWidth(m_ScaledRTCurrentCategory); } }
+        public int maxHeight { get { return GetMaxHeight(m_ScaledRTCurrentCategory); } }
+
+        public RTHandleSystem()
+        {
+            m_AutoSizedRTs = new HashSet<RTHandle>();
+            m_ResizeOnDemandRTs = new HashSet<RTHandle>();
+            for (int i = 0; i < (int)RTCategory.Count; ++i)
+            {
+                m_MaxWidths[i] = 1;
+                m_MaxHeights[i] = 1;
+            }
+        }
+
+        public void Dispose()
+        {
+            Dispose(true);
+        }
+
+        // Call this once to set the initial size and allow msaa targets or not.
+        public void Initialize(int width, int height, bool scaledRTsupportsMSAA, MSAASamples scaledRTMSAASamples)
+        {
+            Debug.Assert(m_AutoSizedRTs.Count == 0, "RTHandle.Initialize should only be called once before allocating any Render Texture.");
+
+            for (int i = 0; i < (int)RTCategory.Count; ++i)
+            {
+                m_MaxWidths[i] = width;
+                m_MaxHeights[i] = height;
+            }
+
+            m_ScaledRTSupportsMSAA = scaledRTsupportsMSAA;
+            m_ScaledRTCurrentMSAASamples = scaledRTMSAASamples;
+        }
+
+        public void Release(RTHandle rth)
+        {
+            if(rth != null)
+            {
+                Assert.AreEqual(this, rth.m_Owner);
+                rth.Release();
+            }
+        }
+
+        public void SetReferenceSize(int width, int height, bool msaa, MSAASamples msaaSamples)
+        {
+            // Technically, the enum could be passed as argument directly but let's not pollute public API with unnecessary complexity for now.
+            RTCategory category = msaa ? RTCategory.MSAA : RTCategory.Regular;
+
+            width = Mathf.Max(width, 1);
+            height = Mathf.Max(height, 1);
+
+            bool msaaSamplesChanged = msaa && (msaaSamples != m_ScaledRTCurrentMSAASamples);
+            if (width > GetMaxWidth(category) || height > GetMaxHeight(category) || msaaSamplesChanged)
+                Resize(width, height, category, msaaSamples);
+        }
+
+        public void ResetReferenceSize(int width, int height, bool msaa, MSAASamples msaaSamples)
+        {
+            // Technically, the enum could be passed as argument directly but let's not pollute public API with unnecessary complexity for now.
+            RTCategory category = msaa ? RTCategory.MSAA : RTCategory.Regular;
+
+            width = Mathf.Max(width, 1);
+            height = Mathf.Max(height, 1);
+
+            bool msaaSamplesChanged = msaa && (msaaSamples != m_ScaledRTCurrentMSAASamples);
+            if (width != GetMaxWidth(category) || height != GetMaxHeight(category) || msaaSamplesChanged)
+                Resize(width, height, category, msaaSamples);
+        }
+
+        public void SwitchResizeMode(RTHandle rth, ResizeMode mode)
+        {
+            switch (mode)
+            {
+                case ResizeMode.OnDemand:
+                    m_AutoSizedRTs.Remove(rth);
+                    m_ResizeOnDemandRTs.Add(rth);
+                    break;
+                case ResizeMode.Auto:
+                    // Resize now so it is consistent with other auto resize RTHs
+                    if (m_ResizeOnDemandRTs.Contains(rth))
+                        DemandResize(rth);
+                    m_ResizeOnDemandRTs.Remove(rth);
+                    m_AutoSizedRTs.Add(rth);
+                    break;
+            }
+        }
+
+        public void DemandResize(RTHandle rth)
+        {
+            Assert.IsTrue(m_ResizeOnDemandRTs.Contains(rth), string.Format("The RTHandle {0} is not an resize on demand handle in this RTHandleSystem. Please call SwitchToResizeOnDemand(rth, true) before resizing on demand.", rth));
+            
+            for (int i = 0, c = (int)RTCategory.Count; i < c; ++i)
+            {
+                if (rth.m_RTs[i] == null)
+                    continue;
+
+                var rt = rth.m_RTs[i];
+                rth.referenceSize = new Vector2Int(m_MaxWidths[i], m_MaxHeights[i]);
+                var scaledSize = rth.GetScaledSize(rth.referenceSize);
+                scaledSize = Vector2Int.Max(Vector2Int.one, scaledSize);
+
+                var enableMSAA = i == (int)RTCategory.MSAA;
+                var sizeChanged = rt.width != scaledSize.x || rt.height != scaledSize.y;
+                var msaaSampleChanged = enableMSAA && rt.antiAliasing != (int)m_ScaledRTCurrentMSAASamples;
+
+                if (sizeChanged || msaaSampleChanged)
+                {
+                    rt.Release();
+
+                    if (enableMSAA)
+                        rt.antiAliasing = (int)m_ScaledRTCurrentMSAASamples;
+
+                    rt.width = scaledSize.x;
+                    rt.height = scaledSize.y;
+
+                    rt.name = CoreUtils.GetRenderTargetAutoName(
+                        rt.width, 
+                        rt.height, 
+                        rt.format, 
+                        rth.m_Name, 
+                        mips: rt.useMipMap, 
+                        enableMSAA : enableMSAA, 
+                        msaaSamples: m_ScaledRTCurrentMSAASamples
+                    );
+                    rt.Create();
+                }
+            }
+        }
+
+        int GetMaxWidth(RTCategory category) { return m_MaxWidths[(int)category]; }
+        int GetMaxHeight(RTCategory category) { return m_MaxHeights[(int)category]; }
+
+        void Dispose(bool disposing)
+        {
+            if (disposing)
+            {
+                Array.Resize(ref m_AutoSizedRTsArray, m_AutoSizedRTs.Count);
+                m_AutoSizedRTs.CopyTo(m_AutoSizedRTsArray);
+                for (int i = 0, c = m_AutoSizedRTsArray.Length; i < c; ++i)
+                {
+                    var rt = m_AutoSizedRTsArray[i];
+                    Release(rt);
+                }
+                m_AutoSizedRTs.Clear();
+
+                Array.Resize(ref m_AutoSizedRTsArray, m_ResizeOnDemandRTs.Count);
+                m_ResizeOnDemandRTs.CopyTo(m_AutoSizedRTsArray);
+                for (int i = 0, c = m_AutoSizedRTsArray.Length; i < c; ++i)
+                {
+                    var rt = m_AutoSizedRTsArray[i];
+                    Release(rt);
+                }
+                m_ResizeOnDemandRTs.Clear();
+                m_AutoSizedRTsArray = null;
+            }
+        }
+
+        void Resize(int width, int height, RTCategory category, MSAASamples msaaSamples)
+        {
+            m_MaxWidths[(int)category] = width;
+            m_MaxHeights[(int)category] = height;
+            m_ScaledRTCurrentMSAASamples = msaaSamples;
+
+            var maxSize = new Vector2Int(width, height);
+            m_ScaledRTCurrentCategory = category;
+
+            Array.Resize(ref m_AutoSizedRTsArray, m_AutoSizedRTs.Count);
+            m_AutoSizedRTs.CopyTo(m_AutoSizedRTsArray);
+            for (int i = 0, c = m_AutoSizedRTsArray.Length; i < c; ++i)
+            {
+                var rth = m_AutoSizedRTsArray[i];
+                rth.referenceSize = maxSize;
+                
+                var rt = rth.m_RTs[(int)category];
+
+                // This can happen if you create a RTH for MSAA. By default we only create the MSAA version of the target.
+                // Missing version will be created when needed in the getter.
+                if (rt != null)
+                {
+                    rt.Release();
+
+                    var scaledSize = rth.GetScaledSize(maxSize);
+
+                    rt.width = Mathf.Max(scaledSize.x, 1);
+                    rt.height = Mathf.Max(scaledSize.y, 1);
+
+                    if (category == RTCategory.MSAA)
+                        rt.antiAliasing = (int)m_ScaledRTCurrentMSAASamples;
+
+                    rt.name = CoreUtils.GetRenderTargetAutoName(rt.width, rt.height, rt.format, rth.m_Name, mips: rt.useMipMap, enableMSAA : category == RTCategory.MSAA, msaaSamples: m_ScaledRTCurrentMSAASamples);
+                    rt.Create();
+                }
+            }
+        }
+
+
+        // This method wraps around regular RenderTexture creation.
+        // There is no specific logic applied to RenderTextures created this way.
+        public RTHandle Alloc(
+                int width,
+                int height,
+                int slices = 1,
+                DepthBits depthBufferBits = DepthBits.None,
+                RenderTextureFormat colorFormat = RenderTextureFormat.Default,
+                FilterMode filterMode = FilterMode.Point,
+                TextureWrapMode wrapMode = TextureWrapMode.Repeat,
+                TextureDimension dimension = TextureDimension.Tex2D,
+                bool sRGB = true,
+                bool enableRandomWrite = false,
+                bool useMipMap = false,
+                bool autoGenerateMips = true,
+                int anisoLevel = 1,
+                float mipMapBias = 0f,
+                MSAASamples msaaSamples = MSAASamples.None,
+                bool bindTextureMS = false,
+                bool useDynamicScale = false,
+                VRTextureUsage vrUsage = VRTextureUsage.None,
+                RenderTextureMemoryless memoryless = RenderTextureMemoryless.None,
+                string name = ""
+            )
+        {
+            bool enableMSAA = msaaSamples != MSAASamples.None;
+            if (!enableMSAA && bindTextureMS == true)
+            {
+                Debug.LogWarning("RTHandle allocated without MSAA but with bindMS set to true, forcing bindMS to false.");
+                bindTextureMS = false;
+            }
+
+            var rt = new RenderTexture(width, height, (int)depthBufferBits, colorFormat, sRGB ? RenderTextureReadWrite.sRGB : RenderTextureReadWrite.Linear)
+            {
+                hideFlags = HideFlags.HideAndDontSave,
+                volumeDepth = slices,
+                filterMode = filterMode,
+                wrapMode = wrapMode,
+                dimension = dimension,
+                enableRandomWrite = enableRandomWrite,
+                useMipMap = useMipMap,
+                autoGenerateMips = autoGenerateMips,
+                anisoLevel = anisoLevel,
+                mipMapBias = mipMapBias,
+                antiAliasing = (int)msaaSamples,
+                bindTextureMS = bindTextureMS,
+                useDynamicScale = useDynamicScale,
+                vrUsage = vrUsage,
+                memorylessMode = memoryless,
+                name = CoreUtils.GetRenderTargetAutoName(width, height, colorFormat, name, mips: useMipMap, enableMSAA: enableMSAA, msaaSamples: msaaSamples)
+            };
+            rt.Create();
+
+            RTCategory category = enableMSAA ? RTCategory.MSAA : RTCategory.Regular;
+            var newRT = new RTHandle(this);
+            newRT.SetRenderTexture(rt, category);
+            newRT.useScaling = false;
+            newRT.m_EnableRandomWrite = enableRandomWrite;
+            newRT.m_EnableMSAA = enableMSAA;
+            newRT.m_Name = name;
+
+            newRT.referenceSize = new Vector2Int(width, height);
+            
+            return newRT;
+        }
+
+
+        // Next two methods are used to allocate RenderTexture that depend on the frame settings (resolution and msaa for now)
+        // RenderTextures allocated this way are meant to be defined by a scale of camera resolution (full/half/quarter resolution for example).
+        // The idea is that internally the system will scale up the size of all render texture so that it amortizes with time and not reallocate when a smaller size is required (which is what happens with TemporaryRTs).
+        // Since MSAA cannot be changed on the fly for a given RenderTexture, a separate instance will be created if the user requires it. This instance will be the one used after the next call of SetReferenceSize if MSAA is required.
+        public RTHandle Alloc(
+                Vector2 scaleFactor,
+                DepthBits depthBufferBits = DepthBits.None,
+                RenderTextureFormat colorFormat = RenderTextureFormat.Default,
+                FilterMode filterMode = FilterMode.Point,
+                TextureWrapMode wrapMode = TextureWrapMode.Repeat,
+                TextureDimension dimension = TextureDimension.Tex2D,
+                bool sRGB = true,
+                bool enableRandomWrite = false,
+                bool useMipMap = false,
+                bool autoGenerateMips = true,
+                int anisoLevel = 1,
+                float mipMapBias = 0f,
+                bool enableMSAA = false,
+                bool bindTextureMS = false,
+                bool useDynamicScale = false,
+                VRTextureUsage vrUsage = VRTextureUsage.None,
+                RenderTextureMemoryless memoryless = RenderTextureMemoryless.None,
+                string name = ""
+            )
+        {
+            bool allocForMSAA = m_ScaledRTSupportsMSAA ? enableMSAA : false;
+            RTCategory category = allocForMSAA ? RTCategory.MSAA : RTCategory.Regular;
+
+            int width = Mathf.Max(Mathf.RoundToInt(scaleFactor.x * GetMaxWidth(category)), 1);
+            int height = Mathf.Max(Mathf.RoundToInt(scaleFactor.y * GetMaxHeight(category)), 1);
+
+            var rth = AllocAutoSizedRenderTexture(width,
+                height,
+                1,
+                depthBufferBits,
+                colorFormat,
+                filterMode,
+                wrapMode,
+                dimension,
+                sRGB,
+                enableRandomWrite,
+                useMipMap,
+                autoGenerateMips,
+                anisoLevel,
+                mipMapBias,
+                enableMSAA,
+                bindTextureMS,
+                useDynamicScale,
+                vrUsage,
+                memoryless,
+                name
+            );
+
+            rth.referenceSize = new Vector2Int(width, height);
+
+            rth.scaleFactor = scaleFactor;
+            return rth;
+        }
+
+        //
+        // You can provide your own scaling function for advanced scaling schemes (e.g. scaling to
+        // the next POT). The function takes a Vec2 as parameter that holds max width & height
+        // values for the current manager context and returns a Vec2 of the final size in pixels.
+        //
+        // var rth = Alloc(
+        //     size => new Vector2Int(size.x / 2, size.y),
+        //     [...]
+        // );
+        //
+        public RTHandle Alloc(
+                ScaleFunc scaleFunc,
+                DepthBits depthBufferBits = DepthBits.None,
+                RenderTextureFormat colorFormat = RenderTextureFormat.Default,
+                FilterMode filterMode = FilterMode.Point,
+                TextureWrapMode wrapMode = TextureWrapMode.Repeat,
+                TextureDimension dimension = TextureDimension.Tex2D,
+                bool sRGB = true,
+                bool enableRandomWrite = false,
+                bool useMipMap = false,
+                bool autoGenerateMips = true,
+                int anisoLevel = 1,
+                float mipMapBias = 0f,
+                bool enableMSAA = false,
+                bool bindTextureMS = false,
+                bool useDynamicScale = false,
+                VRTextureUsage vrUsage = VRTextureUsage.None,
+                RenderTextureMemoryless memoryless = RenderTextureMemoryless.None,
+                string name = ""
+            )
+        {
+            bool allocForMSAA = m_ScaledRTSupportsMSAA ? enableMSAA : false;
+            RTCategory category = allocForMSAA ? RTCategory.MSAA : RTCategory.Regular;
+
+            var scaleFactor = scaleFunc(new Vector2Int(GetMaxWidth(category), GetMaxHeight(category)));
+            int width = Mathf.Max(scaleFactor.x, 1);
+            int height = Mathf.Max(scaleFactor.y, 1);
+
+            var rth = AllocAutoSizedRenderTexture(width,
+                height,
+                1,
+                depthBufferBits,
+                colorFormat,
+                filterMode,
+                wrapMode,
+                dimension,
+                sRGB,
+                enableRandomWrite,
+                useMipMap,
+                autoGenerateMips,
+                anisoLevel,
+                mipMapBias,
+                enableMSAA,
+                bindTextureMS,
+                useDynamicScale,
+                vrUsage,
+                memoryless,
+                name
+            );
+
+            rth.referenceSize = new Vector2Int(width, height);
+
+            rth.scaleFunc = scaleFunc;
+            return rth;
+        }
+
+        // Internal function
+        RTHandle AllocAutoSizedRenderTexture(
+                int width,
+                int height,
+                int slices,
+                DepthBits depthBufferBits,
+                RenderTextureFormat colorFormat,
+                FilterMode filterMode,
+                TextureWrapMode wrapMode,
+                TextureDimension dimension,
+                bool sRGB,
+                bool enableRandomWrite,
+                bool useMipMap,
+                bool autoGenerateMips,
+                int anisoLevel,
+                float mipMapBias,
+                bool enableMSAA,
+                bool bindTextureMS,
+                bool useDynamicScale,
+                VRTextureUsage vrUsage,
+                RenderTextureMemoryless memoryless,
+                string name
+            )
+        {
+            // Here user made a mistake in setting up msaa/bindMS, hence the warning
+            if (!enableMSAA && bindTextureMS == true)
+            {
+                Debug.LogWarning("RTHandle allocated without MSAA but with bindMS set to true, forcing bindMS to false.");
+                bindTextureMS = false;
+            }
+
+            bool allocForMSAA = m_ScaledRTSupportsMSAA ? enableMSAA : false;
+            // Here we purposefully disable MSAA so we just force the bindMS param to false.
+            if (!allocForMSAA)
+            {
+                bindTextureMS = false;
+            }
+
+            // MSAA Does not support random read/write.
+            bool UAV = enableRandomWrite;
+            if (allocForMSAA && (UAV == true))
+            {
+                Debug.LogWarning("RTHandle that is MSAA-enabled cannot allocate MSAA RT with 'enableRandomWrite = true'.");
+                UAV = false;
+            }
+
+            int msaaSamples = allocForMSAA ? (int)m_ScaledRTCurrentMSAASamples : 1;
+            RTCategory category = allocForMSAA ? RTCategory.MSAA : RTCategory.Regular;
+
+            var rt = new RenderTexture(width, height, (int)depthBufferBits, colorFormat, sRGB ? RenderTextureReadWrite.sRGB : RenderTextureReadWrite.Linear)
+            {
+                hideFlags = HideFlags.HideAndDontSave,
+                volumeDepth = slices,
+                filterMode = filterMode,
+                wrapMode = wrapMode,
+                dimension = dimension,
+                enableRandomWrite = UAV,
+                useMipMap = useMipMap,
+                autoGenerateMips = autoGenerateMips,
+                anisoLevel = anisoLevel,
+                mipMapBias = mipMapBias,
+                antiAliasing = msaaSamples,
+                bindTextureMS = bindTextureMS,
+                useDynamicScale = useDynamicScale,
+                vrUsage = vrUsage,
+                memorylessMode = memoryless,
+                name = CoreUtils.GetRenderTargetAutoName(width, height, colorFormat, name, mips : useMipMap, enableMSAA: allocForMSAA, msaaSamples : m_ScaledRTCurrentMSAASamples)
+            };
+            rt.Create();
+
+            var rth = new RTHandle(this);
+            rth.SetRenderTexture(rt, category);
+            rth.m_EnableMSAA = enableMSAA;
+            rth.m_EnableRandomWrite = enableRandomWrite;
+            rth.useScaling = true;
+            rth.m_Name = name;
+            m_AutoSizedRTs.Add(rth);
+            return rth;
+        }
+
+        public string DumpRTInfo()
+        {
+            string result = "";
+            Array.Resize(ref m_AutoSizedRTsArray, m_AutoSizedRTs.Count);
+            m_AutoSizedRTs.CopyTo(m_AutoSizedRTsArray);
+            for (int i = 0, c = m_AutoSizedRTsArray.Length; i < c; ++i)
+            {
+                var rt = m_AutoSizedRTsArray[i].rt;
+                result = string.Format("{0}\nRT ({1})\t Format: {2} W: {3} H {4}\n", result, i, rt.format, rt.width, rt.height );
+            }
+
+            return result;
+        }
+    }
+}

ScriptableRenderPipeline/Core/CoreRP/Textures/RTHandleSystem.cs.meta

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

ScriptableRenderPipeline/Core/CoreRP/Textures/RTHandles.cs

+using System.Collections.Generic;
+using UnityEngine.Rendering;
+
+namespace UnityEngine.Experimental.Rendering
+{
+    public static class RTHandles
+    {
+        static RTHandleSystem s_DefaultInstance = new RTHandleSystem();
+
+        public static int maxWidth { get { return s_DefaultInstance.maxWidth; } }
+        public static int maxHeight { get { return s_DefaultInstance.maxHeight; } }
+
+        public static RTHandleSystem.RTHandle Alloc(
+            int width, 
+            int height, 
+            int slices = 1, 
+            DepthBits depthBufferBits = DepthBits.None, 
+            RenderTextureFormat colorFormat = RenderTextureFormat.Default, 
+            FilterMode filterMode = FilterMode.Point, 
+            TextureWrapMode wrapMode = TextureWrapMode.Repeat, 
+            TextureDimension dimension = TextureDimension.Tex2D, 
+            bool sRGB = true, 
+            bool enableRandomWrite = false, 
+            bool useMipMap = false, 
+            bool autoGenerateMips = true, 
+            int anisoLevel = 1, 
+            float mipMapBias = 0, 
+            MSAASamples msaaSamples = MSAASamples.None, 
+            bool bindTextureMS = false, 
+            bool useDynamicScale = false, 
+            VRTextureUsage vrUsage = VRTextureUsage.None, 
+            RenderTextureMemoryless memoryless = RenderTextureMemoryless.None, 
+            string name = ""
+        )
+        {
+            return s_DefaultInstance.Alloc(
+                width,
+                height,
+                slices,
+                depthBufferBits,
+                colorFormat,
+                filterMode,
+                wrapMode,
+                dimension,
+                sRGB,
+                enableRandomWrite,
+                useMipMap,
+                autoGenerateMips,
+                anisoLevel,
+                mipMapBias,
+                msaaSamples,
+                bindTextureMS,
+                useDynamicScale,
+                vrUsage,
+                memoryless,
+                name
+            );
+        }
+
+        public static RTHandleSystem.RTHandle Alloc(
+            Vector2 scaleFactor, 
+            DepthBits depthBufferBits = DepthBits.None, 
+            RenderTextureFormat colorFormat = RenderTextureFormat.Default, 
+            FilterMode filterMode = FilterMode.Point, 
+            TextureWrapMode wrapMode = TextureWrapMode.Repeat, 
+            TextureDimension dimension = TextureDimension.Tex2D, 
+            bool sRGB = true, 
+            bool enableRandomWrite = false, 
+            bool useMipMap = false, 
+            bool autoGenerateMips = true, 
+            int anisoLevel = 1, 
+            float mipMapBias = 0, 
+            bool enableMSAA = false, 
+            bool bindTextureMS = false, 
+            bool useDynamicScale = false, 
+            VRTextureUsage vrUsage = VRTextureUsage.None, 
+            RenderTextureMemoryless memoryless = RenderTextureMemoryless.None, 
+            string name = ""
+        )
+        {
+            return s_DefaultInstance.Alloc(
+                scaleFactor,
+                depthBufferBits,
+                colorFormat,
+                filterMode,
+                wrapMode,
+                dimension,
+                sRGB,
+                enableRandomWrite,
+                useMipMap,
+                autoGenerateMips,
+                anisoLevel,
+                mipMapBias,
+                enableMSAA,
+                bindTextureMS,
+                useDynamicScale,
+                vrUsage,
+                memoryless,
+                name
+            );
+        }
+
+        public static RTHandleSystem.RTHandle Alloc(
+            ScaleFunc scaleFunc, 
+            DepthBits depthBufferBits = DepthBits.None, 
+            RenderTextureFormat colorFormat = RenderTextureFormat.Default, 
+            FilterMode filterMode = FilterMode.Point, 
+            TextureWrapMode wrapMode = TextureWrapMode.Repeat, 
+            TextureDimension dimension = TextureDimension.Tex2D, 
+            bool sRGB = true, 
+            bool enableRandomWrite = false, 
+            bool useMipMap = false,
+            bool autoGenerateMips = true, 
+            int anisoLevel = 1, 
+            float mipMapBias = 0, 
+            bool enableMSAA = false, 
+            bool bindTextureMS = false, 
+            bool useDynamicScale = false, 
+            VRTextureUsage vrUsage = VRTextureUsage.None, 
+            RenderTextureMemoryless memoryless = RenderTextureMemoryless.None, 
+            string name = ""
+        )
+        {
+            return s_DefaultInstance.Alloc(
+                scaleFunc,
+                depthBufferBits,
+                colorFormat,
+                filterMode,
+                wrapMode,
+                dimension,
+                sRGB,
+                enableRandomWrite,
+                useMipMap,
+                autoGenerateMips,
+                anisoLevel,
+                mipMapBias,
+                enableMSAA,
+                bindTextureMS,
+                useDynamicScale,
+                vrUsage,
+                memoryless,
+                name
+            );
+        }
+
+        public static void Initialize(
+            int width, 
+            int height, 
+            bool scaledRTsupportsMSAA, 
+            MSAASamples scaledRTMSAASamples
+        )
+        {
+            s_DefaultInstance.Initialize(
+                width,
+                height,
+                scaledRTsupportsMSAA,
+                scaledRTMSAASamples
+            );
+        }
+
+        public static void Release(RTHandleSystem.RTHandle rth)
+        {
+            s_DefaultInstance.Release(rth);
+        }
+
+        public static void ResetReferenceSize(
+            int width, 
+            int height, 
+            bool msaa, 
+            MSAASamples msaaSamples
+        )
+        {
+            s_DefaultInstance.ResetReferenceSize(
+                width,
+                height,
+                msaa,
+                msaaSamples
+            );
+        }
+
+        public static void SetReferenceSize(
+            int width, 
+            int height, 
+            bool msaa, 
+            MSAASamples msaaSamples
+        )
+        {
+            s_DefaultInstance.SetReferenceSize(
+                width,
+                height,
+                msaa,
+                msaaSamples
+            );
+        }
+    }
+}

ScriptableRenderPipeline/Core/CoreRP/Textures/RTHandles.cs.meta

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

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Camera/HDCameraFrameHistoryType.cs

+using UnityEngine.Serialization;
+
+namespace UnityEngine.Experimental.Rendering.HDPipeline
+{
+    public enum HDCameraFrameHistoryType
+    {
+        DepthPyramid,
+        ColorPyramid
+    }
+}

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Camera/HDCameraFrameHistoryType.cs.meta

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

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Debug/DecalsDebug.cs

+using System;
+
+namespace UnityEngine.Experimental.Rendering.HDPipeline
+{
+    [Serializable]
+    public class DecalsDebugSettings
+    {
+        public bool m_DisplayAtlas = false;
+        public UInt32 m_MipLevel = 0;
+    }
+}

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Debug/DecalsDebug.cs.meta

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

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

+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEditor;
+using UnityEngine.Experimental.Rendering.HDPipeline;
+using UnityEditor.Experimental.Rendering;
+
+namespace UnityEditor.Experimental.Rendering.HDPipeline
+{
+    [VolumeComponentEditor(typeof(VolumetricFog))]
+    public class VolumetricFogEditor : AtmosphericScatteringEditor
+    {
+        private SerializedDataParameter m_Albedo;
+        private SerializedDataParameter m_MeanFreePath;
+        private SerializedDataParameter m_Asymmetry;
+
+        public override void OnEnable()
+        {
+            base.OnEnable();
+            var o = new PropertyFetcher<VolumetricFog>(serializedObject);
+
+            m_Albedo       = Unpack(o.Find(x => x.albedo));
+            m_MeanFreePath = Unpack(o.Find(x => x.meanFreePath));
+            m_Asymmetry    = Unpack(o.Find(x => x.asymmetry));
+        }
+
+        public override void OnInspectorGUI()
+        {
+            PropertyField(m_Albedo);
+            PropertyField(m_MeanFreePath);
+            PropertyField(m_Asymmetry);
+        }
+    }
+}

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Sky/AtmosphericScattering/VolumetricFogEditor.cs.meta

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

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/PreIntegratedFGD.meta

+fileFormatVersion: 2
+guid: d67850515da2e0844bf387a58fa11fac
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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
+    {
+        public ColorParameter        albedo       = new ColorParameter(new Color(0.5f, 0.5f, 0.5f));
+        public MinFloatParameter     meanFreePath = new MinFloatParameter(float.MaxValue, 1.0f);
+        public ClampedFloatParameter asymmetry    = new ClampedFloatParameter(0.0f, -1.0f, 1.0f);
+
+        // Override the volume blending function.
+        public override void Override(VolumeComponent state, float interpFactor)
+        {
+            VolumetricFog other = state as VolumetricFog;
+
+            float   thisExtinction  = VolumeRenderingUtils.ExtinctionFromMeanFreePath(meanFreePath);
+            Vector3 thisScattering  = VolumeRenderingUtils.ScatteringFromExtinctionAndAlbedo(thisExtinction, (Vector3)(Vector4)albedo.value);
+
+            float   otherExtinction = VolumeRenderingUtils.ExtinctionFromMeanFreePath(other.meanFreePath);
+            Vector3 otherScattering = VolumeRenderingUtils.ScatteringFromExtinctionAndAlbedo(otherExtinction, (Vector3)(Vector4)other.albedo.value);
+
+            float   blendExtinction =   Mathf.Lerp(otherExtinction, thisExtinction, interpFactor);
+            Vector3 blendScattering = Vector3.Lerp(otherScattering, thisScattering, interpFactor);
+            float   blendAsymmetry  =   Mathf.Lerp(other.asymmetry, asymmetry,      interpFactor);
+
+            float   blendMeanFreePath = VolumeRenderingUtils.MeanFreePathFromExtinction(blendExtinction);
+            Color   blendAlbedo       = (Color)(Vector4)VolumeRenderingUtils.AlbedoFromMeanFreePathAndScattering(blendMeanFreePath, blendScattering);
+                    blendAlbedo.a     = 1.0f;
+
+            if (meanFreePath.overrideState)
+            {
+                other.meanFreePath.value = blendMeanFreePath;
+            }
+
+            if (albedo.overrideState)
+            {
+                other.albedo.value = blendAlbedo;
+            }
+
+            if (asymmetry.overrideState)
+            {
+                other.asymmetry.value = blendAsymmetry;
+            }
+        }
+
+        public override void PushShaderParameters(CommandBuffer cmd, FrameSettings frameSettings)
+        {
+            DensityVolumeParameters param;
+
+            param.albedo       = albedo;
+            param.meanFreePath = meanFreePath;
+            param.asymmetry    = asymmetry;
+
+            DensityVolumeData data = param.GetData();
+
+            cmd.SetGlobalInt(HDShaderIDs._AtmosphericScatteringType, (int)FogType.Volumetric);
+
+            cmd.SetGlobalVector(HDShaderIDs._GlobalScattering, data.scattering);
+            cmd.SetGlobalFloat( HDShaderIDs._GlobalExtinction, data.extinction);
+            cmd.SetGlobalFloat( HDShaderIDs._GlobalAsymmetry,  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: 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/PreIntegratedFGD/PreIntegratedFGD.cs

+using System;
+using UnityEngine.Rendering;
+
+namespace UnityEngine.Experimental.Rendering.HDPipeline
+{
+    // Currently PreIntegratedFGD only have GGX, if we add another case convert it to a textureArray (like LTCArea)
+    public partial class PreIntegratedFGD
+    {
+        static PreIntegratedFGD s_Instance;
+
+        public static PreIntegratedFGD instance
+        {
+            get
+            {
+                if (s_Instance == null)
+                    s_Instance = new PreIntegratedFGD();
+
+                return s_Instance;
+            }
+        }
+
+        bool m_isInit;
+        int m_refCounting;
+
+        // For image based lighting
+        Material m_InitPreFGD;
+        RenderTexture m_PreIntegratedFGD;
+
+        PreIntegratedFGD()
+        {
+            m_isInit = false;
+            m_refCounting = 0;
+        }
+
+        public void Build()
+        {
+            Debug.Assert(m_refCounting >= 0);
+
+            if (m_refCounting == 0)
+            {
+                m_InitPreFGD = CoreUtils.CreateEngineMaterial("Hidden/HDRenderPipeline/PreIntegratedFGD");
+
+                m_PreIntegratedFGD = new RenderTexture(128, 128, 0, RenderTextureFormat.ARGB2101010, RenderTextureReadWrite.Linear);
+                m_PreIntegratedFGD.hideFlags = HideFlags.HideAndDontSave;
+                m_PreIntegratedFGD.filterMode = FilterMode.Bilinear;
+                m_PreIntegratedFGD.wrapMode = TextureWrapMode.Clamp;
+                m_PreIntegratedFGD.hideFlags = HideFlags.DontSave;
+                m_PreIntegratedFGD.name = CoreUtils.GetRenderTargetAutoName(128, 128, RenderTextureFormat.ARGB2101010, "PreIntegratedFGD");
+                m_PreIntegratedFGD.Create();
+
+                m_isInit = false;
+            }
+
+            m_refCounting++;
+        }
+
+        public void RenderInit(CommandBuffer cmd)
+        {
+            if (m_isInit)
+                return;
+
+            using (new ProfilingSample(cmd, "Init PreFGD"))
+            {
+                CoreUtils.DrawFullScreen(cmd, m_InitPreFGD, new RenderTargetIdentifier(m_PreIntegratedFGD));
+            }
+
+            m_isInit = true;
+        }
+
+        public void Cleanup()
+        {
+            m_refCounting--;
+
+            if (m_refCounting == 0)
+            {
+                CoreUtils.Destroy(m_InitPreFGD);
+                CoreUtils.Destroy(m_PreIntegratedFGD);
+
+                m_isInit = false;
+            }
+
+            Debug.Assert(m_refCounting >= 0);
+        }
+
+        public void Bind()
+        {
+            Shader.SetGlobalTexture("_PreIntegratedFGD", m_PreIntegratedFGD);
+        }
+    }
+}

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/PreIntegratedFGD/PreIntegratedFGD.cs.meta

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

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/PreIntegratedFGD/PreIntegratedFGD.hlsl

+TEXTURE2D(_PreIntegratedFGD);
+
+// For image based lighting, a part of the BSDF is pre-integrated.
+// This is done both for specular GGX height-correlated and DisneyDiffuse
+// reflectivity is  Integral{(BSDF_GGX / F) - use for multiscattering
+void GetPreIntegratedFGDGGXAndDisneyDiffuse(float NdotV, float perceptualRoughness, float3 fresnel0, out float3 GGXSpecularFGD, out float disneyDiffuseFGD, out float reflectivity)
+{
+    float3 preFGD = SAMPLE_TEXTURE2D_LOD(_PreIntegratedFGD, s_linear_clamp_sampler, float2(NdotV, perceptualRoughness), 0).xyz;
+
+    // Pre-integrate GGX FGD
+    // Integral{BSDF * <N,L> dw} =
+    // Integral{(F0 + (1 - F0) * (1 - <V,H>)^5) * (BSDF / F) * <N,L> dw} =
+    // (1 - F0) * Integral{(1 - <V,H>)^5 * (BSDF / F) * <N,L> dw} + F0 * Integral{(BSDF / F) * <N,L> dw}=
+    // (1 - F0) * x + F0 * y = lerp(x, y, F0)
+    GGXSpecularFGD = lerp(preFGD.xxx, preFGD.yyy, fresnel0);
+
+    // Pre integrate DisneyDiffuse FGD:
+    // z = DisneyDiffuse
+    // Remap from the [0, 1] to the [0.5, 1.5] range.
+    disneyDiffuseFGD = preFGD.z + 0.5;
+
+    reflectivity = preFGD.y;
+}

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/PreIntegratedFGD/PreIntegratedFGD.hlsl.meta

+fileFormatVersion: 2
+guid: 4ca702b62d480a040a08b750920b6b55
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/PreIntegratedFGD/Resources.meta

+fileFormatVersion: 2
+guid: ce581725fe970e14abbd599942a16779
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

ScriptableRenderPipeline/Core/CoreRP/Textures/RTHandle.cs

-using System.Collections.Generic;
-using UnityEngine.Rendering;
-
-namespace UnityEngine.Experimental.Rendering
-{
-    public delegate Vector2Int ScaleFunc(Vector2Int size);
-
-    public enum DepthBits
-    {
-        None = 0,
-        Depth8 = 8,
-        Depth16 = 16,
-        Depth24 = 24
-    }
-
-    public enum MSAASamples
-    {
-        None = 1,
-        MSAA2x = 2,
-        MSAA4x = 4,
-        MSAA8x = 8
-    }
-
-    public class RTHandle
-    {
-        enum RTCategory
-        {
-            Regular = 0,
-            MSAA = 1,
-            Count
-        }
-
-        // Static management.
-        public static int s_MaxWidth { get { return s_MaxWidths[(int)RTCategory.Regular]; } }
-        public static int s_MaxHeight { get { return s_MaxHeights[(int)RTCategory.Regular]; } }
-
-        public static int s_MaxWidthMSAAA { get { return s_MaxWidths[(int)RTCategory.MSAA]; } }
-        public static int s_MaxHeightMSAA { get { return s_MaxHeights[(int)RTCategory.MSAA]; } }
-
-        private static int GetMaxWidth(RTCategory category) { return s_MaxWidths[(int)category]; }
-        private static int GetMaxHeight(RTCategory category) { return s_MaxHeights[(int)category]; }
-
-
-        // Parameters for auto-scaled Render Textures
-        static bool             s_ScaledRTSupportsMSAA = false;
-        static MSAASamples      s_ScaledRTCurrentMSAASamples = MSAASamples.None;
-        static List<RTHandle>   s_AutoSizedRTs;
-        static RTCategory       s_ScaledRTCurrentCategory = RTCategory.Regular;
-
-        static int[] s_MaxWidths = new int[(int)RTCategory.Count];
-        static int[] s_MaxHeights = new int[(int)RTCategory.Count];
-
-        public static int maxWidth { get { return GetMaxWidth(s_ScaledRTCurrentCategory); } }
-        public static int maxHeight { get { return GetMaxHeight(s_ScaledRTCurrentCategory); } }
-
-        static RTHandle()
-        {
-            s_AutoSizedRTs = new List<RTHandle>();
-            for (int i = 0; i < (int)RTCategory.Count; ++i)
-            {
-                s_MaxWidths[i] = 1;
-                s_MaxHeights[i] = 1;
-            }
-        }
-
-        // Call this once to set the initial size and allow msaa targets or not.
-        public static void Initialize(int width, int height, bool scaledRTsupportsMSAA, MSAASamples scaledRTMSAASamples)
-        {
-            Debug.Assert(s_AutoSizedRTs.Count == 0, "RTHandle.Initialize should only be called once before allocating any Render Texture.");
-
-            for (int i = 0; i < (int)RTCategory.Count; ++i)
-            {
-                s_MaxWidths[i] = width;
-                s_MaxHeights[i] = height;
-            }
-
-            s_ScaledRTSupportsMSAA = scaledRTsupportsMSAA;
-            s_ScaledRTCurrentMSAASamples = scaledRTMSAASamples;
-        }
-
-        public static void Release(RTHandle rth)
-        {
-            if(rth != null)
-                rth.Release();
-        }
-
-        public static void SetReferenceSize(int width, int height, bool msaa, MSAASamples msaaSamples)
-        {
-            // Technically, the enum could be passed as argument directly but let's not pollute public API with unnecessary complexity for now.
-            RTCategory category = msaa ? RTCategory.MSAA : RTCategory.Regular;
-
-            width = Mathf.Max(width, 1);
-            height = Mathf.Max(height, 1);
-
-            bool msaaSamplesChanged = msaa && (msaaSamples != s_ScaledRTCurrentMSAASamples);
-            if (width > GetMaxWidth(category) || height > GetMaxHeight(category) || msaaSamplesChanged)
-                Resize(width, height, category, msaaSamples);
-        }
-
-        public static void ResetReferenceSize(int width, int height, bool msaa, MSAASamples msaaSamples)
-        {
-            // Technically, the enum could be passed as argument directly but let's not pollute public API with unnecessary complexity for now.
-            RTCategory category = msaa ? RTCategory.MSAA : RTCategory.Regular;
-
-            width = Mathf.Max(width, 1);
-            height = Mathf.Max(height, 1);
-
-            bool msaaSamplesChanged = msaa && (msaaSamples != s_ScaledRTCurrentMSAASamples);
-            if (width != GetMaxWidth(category) || height != GetMaxHeight(category) || msaaSamplesChanged)
-                Resize(width, height, category, msaaSamples);
-        }
-
-        static void Resize(int width, int height, RTCategory category, MSAASamples msaaSamples)
-        {
-            s_MaxWidths[(int)category] = width;
-            s_MaxHeights[(int)category] = height;
-            s_ScaledRTCurrentMSAASamples = msaaSamples;
-
-            var maxSize = new Vector2Int(width, height);
-            s_ScaledRTCurrentCategory = category;
-
-            foreach (var rth in s_AutoSizedRTs)
-            {
-                var rt = rth.m_RTs[(int)category];
-
-                // This can happen if you create a RTH for MSAA. By default we only create the MSAA version of the target.
-                // Missing version will be created when needed in the getter.
-                if (rt != null)
-                {
-                    rt.Release();
-
-                    Vector2Int scaledSize = rth.GetScaledSize(maxSize);
-
-                    rt.width = Mathf.Max(scaledSize.x, 1);
-                    rt.height = Mathf.Max(scaledSize.y, 1);
-
-                    if (category == RTCategory.MSAA)
-                        rt.antiAliasing = (int)s_ScaledRTCurrentMSAASamples;
-
-                    rt.name = CoreUtils.GetRenderTargetAutoName(rt.width, rt.height, rt.format, rth.m_Name, mips: rt.useMipMap, enableMSAA : category == RTCategory.MSAA, msaaSamples: s_ScaledRTCurrentMSAASamples);
-                    rt.Create();
-                }
-            }
-        }
-
-
-        // This method wraps around regular RenderTexture creation.
-        // There is no specific logic applied to RenderTextures created this way.
-        public static RTHandle Alloc(
-                int width,
-                int height,
-                int slices = 1,
-                DepthBits depthBufferBits = DepthBits.None,
-                RenderTextureFormat colorFormat = RenderTextureFormat.Default,
-                FilterMode filterMode = FilterMode.Point,
-                TextureWrapMode wrapMode = TextureWrapMode.Repeat,
-                TextureDimension dimension = TextureDimension.Tex2D,
-                bool sRGB = true,
-                bool enableRandomWrite = false,
-                bool useMipMap = false,
-                bool autoGenerateMips = true,
-                int anisoLevel = 1,
-                float mipMapBias = 0f,
-                MSAASamples msaaSamples = MSAASamples.None,
-                bool bindTextureMS = false,
-                bool useDynamicScale = false,
-                VRTextureUsage vrUsage = VRTextureUsage.None,
-                RenderTextureMemoryless memoryless = RenderTextureMemoryless.None,
-                string name = ""
-            )
-        {
-            bool enableMSAA = msaaSamples != MSAASamples.None;
-            if (!enableMSAA && bindTextureMS == true)
-            {
-                Debug.LogWarning("RTHandle allocated without MSAA but with bindMS set to true, forcing bindMS to false.");
-                bindTextureMS = false;
-            }
-
-            var rt = new RenderTexture(width, height, (int)depthBufferBits, colorFormat, sRGB ? RenderTextureReadWrite.sRGB : RenderTextureReadWrite.Linear)
-            {
-                hideFlags = HideFlags.HideAndDontSave,
-                volumeDepth = slices,
-                filterMode = filterMode,
-                wrapMode = wrapMode,
-                dimension = dimension,
-                enableRandomWrite = enableRandomWrite,
-                useMipMap = useMipMap,
-                autoGenerateMips = autoGenerateMips,
-                anisoLevel = anisoLevel,
-                mipMapBias = mipMapBias,
-                antiAliasing = (int)msaaSamples,
-                bindTextureMS = bindTextureMS,
-                useDynamicScale = useDynamicScale,
-                vrUsage = vrUsage,
-                memorylessMode = memoryless,
-                name = CoreUtils.GetRenderTargetAutoName(width, height, colorFormat, name, mips: useMipMap, enableMSAA: enableMSAA, msaaSamples: msaaSamples)
-            };
-            rt.Create();
-
-            RTCategory category = enableMSAA ? RTCategory.MSAA : RTCategory.Regular;
-            var newRT = new RTHandle();
-            newRT.SetRenderTexture(rt, category);
-            newRT.useScaling = false;
-            newRT.m_EnableRandomWrite = enableRandomWrite;
-            newRT.m_EnableMSAA = enableMSAA;
-            newRT.m_Name = name;
-            return newRT;
-        }
-
-
-        // Next two methods are used to allocate RenderTexture that depend on the frame settings (resolution and msaa for now)
-        // RenderTextures allocated this way are meant to be defined by a scale of camera resolution (full/half/quarter resolution for example).
-        // The idea is that internally the system will scale up the size of all render texture so that it amortizes with time and not reallocate when a smaller size is required (which is what happens with TemporaryRTs).
-        // Since MSAA cannot be changed on the fly for a given RenderTexture, a separate instance will be created if the user requires it. This instance will be the one used after the next call of SetReferenceSize if MSAA is required.
-        public static RTHandle Alloc(
-                Vector2 scaleFactor,
-                DepthBits depthBufferBits = DepthBits.None,
-                RenderTextureFormat colorFormat = RenderTextureFormat.Default,
-                FilterMode filterMode = FilterMode.Point,
-                TextureWrapMode wrapMode = TextureWrapMode.Repeat,
-                TextureDimension dimension = TextureDimension.Tex2D,
-                bool sRGB = true,
-                bool enableRandomWrite = false,
-                bool useMipMap = false,
-                bool autoGenerateMips = true,
-                int anisoLevel = 1,
-                float mipMapBias = 0f,
-                bool enableMSAA = false,
-                bool bindTextureMS = false,
-                bool useDynamicScale = false,
-                VRTextureUsage vrUsage = VRTextureUsage.None,
-                RenderTextureMemoryless memoryless = RenderTextureMemoryless.None,
-                string name = ""
-            )
-        {
-            bool allocForMSAA = s_ScaledRTSupportsMSAA ? enableMSAA : false;
-            RTCategory category = allocForMSAA ? RTCategory.MSAA : RTCategory.Regular;
-
-            int width = Mathf.Max(Mathf.RoundToInt(scaleFactor.x * GetMaxWidth(category)), 1);
-            int height = Mathf.Max(Mathf.RoundToInt(scaleFactor.y * GetMaxHeight(category)), 1);
-
-            var rth = AllocAutoSizedRenderTexture(width,
-                height,
-                1,
-                depthBufferBits,
-                colorFormat,
-                filterMode,
-                wrapMode,
-                dimension,
-                sRGB,
-                enableRandomWrite,
-                useMipMap,
-                autoGenerateMips,
-                anisoLevel,
-                mipMapBias,
-                enableMSAA,
-                bindTextureMS,
-                useDynamicScale,
-                vrUsage,
-                memoryless,
-                name
-            );
-
-            rth.scaleFactor = scaleFactor;
-            return rth;
-        }
-
-        //
-        // You can provide your own scaling function for advanced scaling schemes (e.g. scaling to
-        // the next POT). The function takes a Vec2 as parameter that holds max width & height
-        // values for the current manager context and returns a Vec2 of the final size in pixels.
-        //
-        // var rth = Alloc(
-        //     size => new Vector2Int(size.x / 2, size.y),
-        //     [...]
-        // );
-        //
-        public static RTHandle Alloc(
-                ScaleFunc scaleFunc,
-                DepthBits depthBufferBits = DepthBits.None,
-                RenderTextureFormat colorFormat = RenderTextureFormat.Default,
-                FilterMode filterMode = FilterMode.Point,
-                TextureWrapMode wrapMode = TextureWrapMode.Repeat,
-                TextureDimension dimension = TextureDimension.Tex2D,
-                bool sRGB = true,
-                bool enableRandomWrite = false,
-                bool useMipMap = false,
-                bool autoGenerateMips = true,
-                int anisoLevel = 1,
-                float mipMapBias = 0f,
-                bool enableMSAA = false,
-                bool bindTextureMS = false,
-                bool useDynamicScale = false,
-                VRTextureUsage vrUsage = VRTextureUsage.None,
-                RenderTextureMemoryless memoryless = RenderTextureMemoryless.None,
-                string name = ""
-            )
-        {
-            bool allocForMSAA = s_ScaledRTSupportsMSAA ? enableMSAA : false;
-            RTCategory category = allocForMSAA ? RTCategory.MSAA : RTCategory.Regular;
-
-            var scaleFactor = scaleFunc(new Vector2Int(GetMaxWidth(category), GetMaxHeight(category)));
-            int width = Mathf.Max(scaleFactor.x, 1);
-            int height = Mathf.Max(scaleFactor.y, 1);
-
-            var rth = AllocAutoSizedRenderTexture(width,
-                height,
-                1,
-                depthBufferBits,
-                colorFormat,
-                filterMode,
-                wrapMode,
-                dimension,
-                sRGB,
-                enableRandomWrite,
-                useMipMap,
-                autoGenerateMips,
-                anisoLevel,
-                mipMapBias,
-                enableMSAA,
-                bindTextureMS,
-                useDynamicScale,
-                vrUsage,
-                memoryless,
-                name
-            );
-
-            rth.scaleFunc = scaleFunc;
-            return rth;
-        }
-
-        // Internal function
-        static RTHandle AllocAutoSizedRenderTexture(
-                int width,
-                int height,
-                int slices,
-                DepthBits depthBufferBits,
-                RenderTextureFormat colorFormat,
-                FilterMode filterMode,
-                TextureWrapMode wrapMode,
-                TextureDimension dimension,
-                bool sRGB,
-                bool enableRandomWrite,
-                bool useMipMap,
-                bool autoGenerateMips,
-                int anisoLevel,
-                float mipMapBias,
-                bool enableMSAA,
-                bool bindTextureMS,
-                bool useDynamicScale,
-                VRTextureUsage vrUsage,
-                RenderTextureMemoryless memoryless,
-                string name
-            )
-        {
-            // Here user made a mistake in setting up msaa/bindMS, hence the warning
-            if (!enableMSAA && bindTextureMS == true)
-            {
-                Debug.LogWarning("RTHandle allocated without MSAA but with bindMS set to true, forcing bindMS to false.");
-                bindTextureMS = false;
-            }
-
-            bool allocForMSAA = s_ScaledRTSupportsMSAA ? enableMSAA : false;
-            // Here we purposefully disable MSAA so we just force the bindMS param to false.
-            if (!allocForMSAA)
-            {
-                bindTextureMS = false;
-            }
-
-            // MSAA Does not support random read/write.
-            bool UAV = enableRandomWrite;
-            if (allocForMSAA && (UAV == true))
-            {
-                Debug.LogWarning("RTHandle that is MSAA-enabled cannot allocate MSAA RT with 'enableRandomWrite = true'.");
-                UAV = false;
-            }
-
-            int msaaSamples = allocForMSAA ? (int)s_ScaledRTCurrentMSAASamples : 1;
-            RTCategory category = allocForMSAA ? RTCategory.MSAA : RTCategory.Regular;
-
-            var rt = new RenderTexture(width, height, (int)depthBufferBits, colorFormat, sRGB ? RenderTextureReadWrite.sRGB : RenderTextureReadWrite.Linear)
-            {
-                hideFlags = HideFlags.HideAndDontSave,
-                volumeDepth = slices,
-                filterMode = filterMode,
-                wrapMode = wrapMode,
-                dimension = dimension,
-                enableRandomWrite = UAV,
-                useMipMap = useMipMap,
-                autoGenerateMips = autoGenerateMips,
-                anisoLevel = anisoLevel,
-                mipMapBias = mipMapBias,
-                antiAliasing = msaaSamples,
-                bindTextureMS = bindTextureMS,
-                useDynamicScale = useDynamicScale,
-                vrUsage = vrUsage,
-                memorylessMode = memoryless,
-                name = CoreUtils.GetRenderTargetAutoName(width, height, colorFormat, name, mips : useMipMap, enableMSAA: allocForMSAA, msaaSamples : s_ScaledRTCurrentMSAASamples)
-            };
-            rt.Create();
-
-            RTHandle rth = new RTHandle();
-            rth.SetRenderTexture(rt, category);
-            rth.m_EnableMSAA = enableMSAA;
-            rth.m_EnableRandomWrite = enableRandomWrite;
-            rth.useScaling = true;
-            rth.m_Name = name;
-            s_AutoSizedRTs.Add(rth);
-            return rth;
-        }
-
-        public static implicit operator RenderTexture(RTHandle handle)
-        {
-            return handle.rt;
-        }
-
-        public static implicit operator RenderTargetIdentifier(RTHandle handle)
-        {
-            return handle.nameID;
-        }
-
-        public static string DumpRTInfo()
-        {
-            string result = "";
-            for (int i = 0; i < s_AutoSizedRTs.Count; ++i)
-            {
-                RenderTexture rt = s_AutoSizedRTs[i].rt;
-                result = string.Format("{0}\nRT ({1})\t Format: {2} W: {3} H {4}\n", result, i, rt.format, rt.width, rt.height );
-            }
-
-            return result;
-        }
-
-        // Instance data
-        RenderTexture[]             m_RTs = new RenderTexture[2];
-        RenderTargetIdentifier[]    m_NameIDs = new RenderTargetIdentifier[2];
-        bool                        m_EnableMSAA = false;
-        bool                        m_EnableRandomWrite = false;
-        string                      m_Name;
-
-        Vector2 scaleFactor = Vector2.one;
-        ScaleFunc scaleFunc;
-
-        public bool useScaling { get; private set; }
-
-        public RenderTexture rt
-        {
-            get
-            {
-                if(!useScaling)
-                {
-                    return m_EnableMSAA ? m_RTs[(int)RTCategory.MSAA] : m_RTs[(int)RTCategory.Regular];
-                }
-                else
-                {
-                    RTCategory category = (m_EnableMSAA && s_ScaledRTCurrentCategory == RTCategory.MSAA) ? RTCategory.MSAA : RTCategory.Regular;
-                    CreateIfNeeded(category);
-                    return m_RTs[(int)category];
-                }
-            }
-        }
-
-        public RenderTargetIdentifier nameID
-        {
-            get
-            {
-                if (!useScaling)
-                {
-                    return m_EnableMSAA ? m_NameIDs[(int)RTCategory.MSAA] : m_RTs[(int)RTCategory.Regular];
-                }
-                else
-                {
-                    RTCategory category = (m_EnableMSAA && s_ScaledRTCurrentCategory == RTCategory.MSAA) ? RTCategory.MSAA : RTCategory.Regular;
-                    CreateIfNeeded(category);
-                    return m_NameIDs[(int)category];
-                }
-            }
-        }
-
-        // Keep constructor private
-        RTHandle()
-        {
-        }
-
-        void SetRenderTexture(RenderTexture rt, RTCategory category)
-        {
-            m_RTs[(int)category] = rt;
-            m_NameIDs[(int)category] = new RenderTargetIdentifier(rt);
-        }
-
-        void CreateIfNeeded(RTCategory category)
-        {
-            // If a RT was first created for MSAA then the regular one might be null, in this case we create it.
-            // That's why we never test the MSAA version: It should always be there if RT was declared correctly.
-            if(category == RTCategory.Regular && m_RTs[(int)RTCategory.Regular] == null)
-            {
-                RenderTexture refRT = m_RTs[(int)RTCategory.MSAA];
-                Debug.Assert(refRT != null);
-                Vector2Int scaledSize = GetScaledSize(new Vector2Int(s_MaxWidth, s_MaxHeight));
-
-                RenderTexture newRT = new RenderTexture(scaledSize.x, scaledSize.y, refRT.depth, refRT.format, refRT.sRGB ? RenderTextureReadWrite.sRGB : RenderTextureReadWrite.Linear)
-                {
-                    hideFlags = HideFlags.HideAndDontSave,
-                    volumeDepth = refRT.volumeDepth,
-                    filterMode = refRT.filterMode,
-                    wrapMode = refRT.wrapMode,
-                    dimension = refRT.dimension,
-                    enableRandomWrite = m_EnableRandomWrite, // We cannot take the info from the msaa rt since we force it to 1
-                    useMipMap = refRT.useMipMap,
-                    autoGenerateMips = refRT.autoGenerateMips,
-                    anisoLevel = refRT.anisoLevel,
-                    mipMapBias = refRT.mipMapBias,
-                    antiAliasing = 1, // No MSAA for the regular version of the texture.
-                    bindTextureMS = false, // Somehow, this can be true even if antiAliasing == 1. Leads to Unity-internal binding errors.
-                    useDynamicScale = refRT.useDynamicScale,
-                    vrUsage = refRT.vrUsage,
-                    memorylessMode = refRT.memorylessMode,
-                    name = CoreUtils.GetRenderTargetAutoName(refRT.width, refRT.height, refRT.format, m_Name, mips : refRT.useMipMap)
-                };
-                newRT.Create();
-
-                m_RTs[(int)RTCategory.Regular] = newRT;
-                m_NameIDs[(int)RTCategory.Regular] = new RenderTargetIdentifier(newRT);
-            }
-        }
-
-        public void Release()
-        {
-
-            s_AutoSizedRTs.Remove(this);
-            for (int i = 0; i < (int)RTCategory.Count; ++i)
-            {
-                CoreUtils.Destroy(m_RTs[i]);
-                m_NameIDs[i] = BuiltinRenderTextureType.None;
-                m_RTs[i] = null;
-            }
-        }
-
-        public Vector2Int GetScaledSize(Vector2Int refSize)
-        {
-            if (scaleFunc != null)
-            {
-                return scaleFunc(refSize);
-            }
-            else
-            {
-                return new Vector2Int(
-                    x: Mathf.RoundToInt(scaleFactor.x * refSize.x),
-                    y: Mathf.RoundToInt(scaleFactor.y * refSize.y)
-                );
-            }
-        }
-    }
-}

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Lit/Resources.meta

-fileFormatVersion: 2
-guid: 0c490c1afeb26224c910524c2a5f08c6
-folderAsset: yes
-timeCreated: 1479130495
-licenseType: Pro
-DefaultImporter:
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Lit/PatchStandardShaderToNewNamingConvention.cginc.meta

-fileFormatVersion: 2
-guid: a9b4e2b7ef9a45f49834b052e7722acb
-timeCreated: 1480085057
-licenseType: Pro
-ShaderImporter:
-  defaultTextures: []
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Lit/PatchStandardShaderToNewNamingConvention.cginc

-// NOTE: For performing a project upgrade where you temporarily support both old and new renderpipelines
-//       in the same sahder
-//
-// The basic approach is:
-// Upgrade all your shaders to the new naming convention, using a SubShader that also contains the legacy // renderloop code.
-//
-// 1. Copy HDRenderPipeline Lit.shader into your project
-// 2. Add a SubShader and copy old Standard shader passes into it.
-// 2. Set LOD on subshader to make Unity pick at runtime to use new renderloop shaders or
-// legacy standard shaders based on if SRL is enabled or not.
-// In the legacy standard shader section add
-// #include "PatchStandardShaderToNewNamingConvention.cginc"
-
-// List of name remaps
-#define _MainTex _BaseColorMap
-#define _MainTex_ST _BaseColorMap_ST
-#define _BumpMap _NormalMap
-#define _ParallaxMap _HeightMap
-#define _Parallax _HeightScale
-#define _Glossiness _Smoothness