Merge pull request #641 from Unity-Technologies/Support-forward-SSS

Add support for forward sss

ImageTemplates/LightweightPipeline/Scenes/007_LitShaderMaps.unity.png.meta

     sprites: []
     outline: []
     physicsShape: []
+    bones: []
+    spriteID: 
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
   spritePackingTag: 
   userData: 
   assetBundleName: 

ScriptableRenderPipeline/Core/Resources/BlitCubeTextureFace.shader

 Shader "Hidden/SRP/BlitCubeTextureFace"
 {
-    SubShader 
+    SubShader
-        Pass 
+        Pass
         {
 
             ZTest Always
             HLSLPROGRAM
-            #include "../ShaderLibrary/Common.hlsl"
+            #include "ShaderLibrary/Common.hlsl"
 
             #pragma vertex vert
             #pragma fragment frag

ScriptableRenderPipeline/Core/Resources/EncodeBC6H.compute

-#include "../ShaderLibrary/Common.hlsl"
-#include "../ShaderLibrary/BC6H.hlsl"
-#include "../ShaderLibrary/Sampling.hlsl"
+#include "ShaderLibrary/Common.hlsl"
+#include "ShaderLibrary/BC6H.hlsl"
+#include "ShaderLibrary/Sampling.hlsl"
 
 TextureCube<float4> _Source;
 RWTexture2DArray<uint4> _Target;
     EncodeMode11(block, blockMSLE, texels);
 
     _Target[dispatchThreadId] = block;
-}
+}

ScriptableRenderPipeline/Core/Resources/GPUCopy.compute

 // Autogenerated file. Do not edit by hand
 
-#include "../ShaderLibrary/Common.hlsl"
+#include "ShaderLibrary/Common.hlsl"
 
 SamplerState sampler_LinearClamp;
 

ScriptableRenderPipeline/Core/ShaderLibrary/CommonLighting.hlsl

     return area;
 }
 
+// Ref: Steve McAuley - Energy-Conserving Wrapped Diffuse
+float ComputeWrappedDiffuseLighting(float NdotL, float w)
+{
+    return saturate((NdotL + w) / ((1 + w) * (1 + w)));
+}
+
 //-----------------------------------------------------------------------------
 // Helper functions
 //-----------------------------------------------------------------------------

ScriptableRenderPipeline/Core/ShaderLibrary/CommonMaterial.hlsl

     return float3(oneMinusT, oneMinusT, oneMinusT) + b * t;
 }
 
-// ----------------------------------------------------------------------------
-// SSS/Transmittance
-// ----------------------------------------------------------------------------
-
-// Computes the fraction of light passing through the object.
-// Evaluate Int{0, inf}{2 * Pi * r * R(sqrt(r^2 + d^2))}, where R is the diffusion profile.
-// Note: 'volumeAlbedo' should be premultiplied by 0.25.
-// Ref: Approximate Reflectance Profiles for Efficient Subsurface Scattering by Pixar (BSSRDF only).
-float3 ComputeTransmittanceDisney(float3 S, float3 volumeAlbedo, float thickness, float radiusScale)
-{
-    // Thickness and SSS radius are decoupled for artists.
-    // In theory, we should modify the thickness by the inverse of the radius scale of the profile.
-    // thickness /= radiusScale;
-
-#if 0
-    float3 expOneThird = exp(((-1.0 / 3.0) * thickness) * S);
-#else
-    // Help the compiler.
-    float  k = (-1.0 / 3.0) * LOG2_E;
-    float3 p = (k * thickness) * S;
-    float3 expOneThird = exp2(p);
-#endif
-
-    // Premultiply & optimize: T = (1/4 * A) * (e^(-t * S) + 3 * e^(-1/3 * t * S))
-    return volumeAlbedo * (expOneThird * expOneThird * expOneThird + 3 * expOneThird);
-}
-
-// Evaluates transmittance for a linear combination of two normalized 2D Gaussians.
-// Ref: Real-Time Realistic Skin Translucency (2010), equation 9 (modified).
-// Note: 'volumeAlbedo' should be premultiplied by 0.25, correspondingly 'lerpWeight' by 4,
-// and 'halfRcpVariance1' should be prescaled by (0.1 * SssConstants.SSS_BASIC_DISTANCE_SCALE)^2.
-float3 ComputeTransmittanceJimenez(float3 halfRcpVariance1, float lerpWeight1,
-                                   float3 halfRcpVariance2, float lerpWeight2,
-                                   float3 volumeAlbedo, float thickness, float radiusScale)
-{
-    // Thickness and SSS radius are decoupled for artists.
-    // In theory, we should modify the thickness by the inverse of the radius scale of the profile.
-    // thickness /= radiusScale;
-
-    float t2 = thickness * thickness;
-
-    // T = A * lerp(exp(-t2 * halfRcpVariance1), exp(-t2 * halfRcpVariance2), lerpWeight2)
-    return volumeAlbedo * (exp(-t2 * halfRcpVariance1) * lerpWeight1 + exp(-t2 * halfRcpVariance2) * lerpWeight2);
-}
-
-// Ref: Steve McAuley - Energy-Conserving Wrapped Diffuse
-float ComputeWrappedDiffuseLighting(float NdotL, float w)
-{
-    return saturate((NdotL + w) / ((1 + w) * (1 + w)));
-}
-
-// In order to support subsurface scattering, we need to know which pixels have an SSS material.
-// It can be accomplished by reading the stencil buffer.
-// A faster solution (which avoids an extra texture fetch) is to simply make sure that
-// all pixels which belong to an SSS material are not black (those that don't always are).
-// We choose the blue color channel since it's perceptually the least noticeable.
-float3 TagLightingForSSS(float3 subsurfaceLighting)
-{
-    subsurfaceLighting.b = max(subsurfaceLighting.b, HALF_MIN);
-    return subsurfaceLighting;
-}
-
-// See TagLightingForSSS() for details.
-bool TestLightingForSSS(float3 subsurfaceLighting)
-{
-    return subsurfaceLighting.b > 0;
-}
-
 
 #endif // UNITY_COMMON_MATERIAL_INCLUDED

ScriptableRenderPipeline/Core/ShaderLibrary/Packing.hlsl

 #ifndef UNITY_PACKING_INCLUDED
 #define UNITY_PACKING_INCLUDED
 
-#include "Common.hlsl"
-
 //-----------------------------------------------------------------------------
 // Normal packing
 //-----------------------------------------------------------------------------

ScriptableRenderPipeline/HDRenderPipeline/HDCustomSamplerId.cs

         PushGlobalParameters,
         CopySetDepthBuffer,
         CopyDepthStencilbuffer,
-        CopyStencilBuffer,
+        HTileForSSS,
         Forward,
         RenderSSAO,
         RenderShadows,
         InitGBuffersAndClearDepthStencil,
         ClearSSSDiffuseTarget,
         ClearSSSFilteringTarget,
-        ClearStencilTexture,
+        ClearAndCopyStencilTexture,
         ClearHTile,
         ClearHDRTarget,
         ClearGBuffer,

ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipeline.cs

-using System.Collections.Generic;
+using System.Collections.Generic;
 using UnityEngine.Rendering;
 using System;
 using System.Diagnostics;
         readonly List<RenderPipelineMaterial> m_MaterialList = new List<RenderPipelineMaterial>();
 
         readonly GBufferManager m_GbufferManager = new GBufferManager();
+        readonly SubsurfaceScatteringManager m_SSSBufferManager = new SubsurfaceScatteringManager();
-        Material m_CopyStencilForRegularLighting;
+        Material m_CopyStencilForNoLighting;
         GPUCopy m_GPUCopy;
 
         IBLFilterGGX m_IBLFilterGGX = null;
             m_applyDistortionKernel = m_applyDistortionCS.FindKernel("KMain");
 
             m_CopyStencilForSplitLighting   = CoreUtils.CreateEngineMaterial("Hidden/HDRenderPipeline/CopyStencilBuffer");
-            m_CopyStencilForSplitLighting.EnableKeyword("EXPORT_HTILE");
-            m_CopyStencilForRegularLighting = CoreUtils.CreateEngineMaterial("Hidden/HDRenderPipeline/CopyStencilBuffer");
-            m_CopyStencilForRegularLighting.DisableKeyword("EXPORT_HTILE");
-            m_CopyStencilForRegularLighting.SetInt(HDShaderIDs._StencilRef, (int)StencilLightingUsage.RegularLighting);
+            m_CopyStencilForNoLighting = CoreUtils.CreateEngineMaterial("Hidden/HDRenderPipeline/CopyStencilBuffer");
+            m_CopyStencilForNoLighting.SetInt(HDShaderIDs._StencilRef, (int)StencilLightingUsage.NoLighting);
             m_CameraMotionVectorsMaterial   = CoreUtils.CreateEngineMaterial("Hidden/HDRenderPipeline/CameraMotionVectors");
 
             InitializeDebugMaterials();
             return NeedDepthBufferCopy() ? m_CameraDepthBufferCopy : m_CameraDepthStencilBuffer;
         }
 
-        RenderTargetIdentifier GetStencilTexture()
-        {
-            return NeedStencilBufferCopy() ? m_CameraStencilBufferCopyRT : m_CameraDepthStencilBufferRT;
-        }
-
         RenderTargetIdentifier GetHTile()
         {
             // Currently, Unity does not offer a way to access the GCN HTile.
             }
         }
 
-        void PrepareAndBindStencilTexture(CommandBuffer cmd)
-        {
-            if (NeedStencilBufferCopy())
-            {
-                using (new ProfilingSample(cmd, "Copy StencilBuffer", GetSampler(CustomSamplerId.CopyStencilBuffer)))
-                {
-                    cmd.SetRandomWriteTarget(1, GetHTile());
-                    // Our method of exporting the stencil requires one pass per unique stencil value.
-                    CoreUtils.DrawFullScreen(cmd, m_CopyStencilForSplitLighting,   m_CameraStencilBufferCopyRT, m_CameraDepthStencilBufferRT);
-                    CoreUtils.DrawFullScreen(cmd, m_CopyStencilForRegularLighting, m_CameraStencilBufferCopyRT, m_CameraDepthStencilBufferRT);
-                    cmd.ClearRandomWriteTargets();
-                }
-            }
-
-            cmd.SetGlobalTexture(HDShaderIDs._HTile, GetHTile());
-            cmd.SetGlobalTexture(HDShaderIDs._StencilTexture, GetStencilTexture());
-        }
-
         public void UpdateCommonSettings()
         {
             var commonSettings = commonSettingsToUse;
                 {
                     CoreUtils.SetRenderTarget(cmd, m_CameraColorBufferRT, m_CameraDepthStencilBufferRT, ClearFlag.Color | ClearFlag.Depth);
                     RenderOpaqueRenderList(m_CullResults, camera, renderContext, cmd, HDShaderPassNames.s_ForwardName);
-                        RenderTransparentRenderList(m_CullResults, camera, renderContext, cmd, HDShaderPassNames.s_ForwardName, false);
+                    RenderTransparentRenderList(m_CullResults, camera, renderContext, cmd, HDShaderPassNames.s_ForwardName, false);
                 }
 
                 renderContext.ExecuteCommandBuffer(cmd);
 
             RenderPyramidDepth(camera, cmd, renderContext, FullScreenDebugMode.DepthPyramid);
 
-            // Required for the SSS and the shader feature classification pass.
-            PrepareAndBindStencilTexture(cmd);
-
             if (m_CurrentDebugDisplaySettings.IsDebugMaterialDisplayEnabled())
             {
                 RenderDebugViewMaterial(m_CullResults, hdCamera, renderContext, cmd);
                     CommandBufferPool.Release(cmd);
                     cmd = CommandBufferPool.Get("");
 
-                    buildGPULightListsCompleteFence = m_LightLoop.BuildGPULightListsAsyncBegin(camera, renderContext, m_CameraDepthStencilBufferRT, GetStencilTexture(), startFence);
+                    buildGPULightListsCompleteFence = m_LightLoop.BuildGPULightListsAsyncBegin(camera, renderContext, m_CameraDepthStencilBufferRT, m_CameraStencilBufferCopyRT, startFence);
                 }
 
                 using (new ProfilingSample(cmd, "Render shadows", GetSampler(CustomSamplerId.RenderShadows)))
                     PushFullScreenDebugTexture(cmd, m_DeferredShadowBuffer, hdCamera.camera, renderContext, FullScreenDebugMode.DeferredShadows);
                 }
 
+  	            // TODO: Move this code inside LightLoop
+                if (m_LightLoop.GetFeatureVariantsEnabled())
+                {
+                    // For material classification we use compute shader and so can't read into the stencil, so prepare it.
+                    using (new ProfilingSample(cmd, "Clear and copy stencil texture", GetSampler(CustomSamplerId.ClearAndCopyStencilTexture)))
+                    {
+                        CoreUtils.SetRenderTarget(cmd, m_CameraStencilBufferCopyRT, ClearFlag.Color, CoreUtils.clearColorAllBlack);
+
+                        cmd.SetRandomWriteTarget(1, GetHTile());
+                        // In the material classification shader we will simply test is we are no lighting
+                        // Use ShaderPassID 1 => "Pass 1 - Write 1 if value different from stencilRef to output"
+                        CoreUtils.DrawFullScreen(cmd, m_CopyStencilForNoLighting, m_CameraStencilBufferCopyRT, m_CameraDepthStencilBufferRT, null, 1);
+                        cmd.ClearRandomWriteTargets();
+                    }
+                }
+
                 if (enableAsyncCompute)
                 {
                     m_LightLoop.BuildGPULightListAsyncEnd(camera, cmd, buildGPULightListsCompleteFence);
                     using (new ProfilingSample(cmd, "Build Light list", GetSampler(CustomSamplerId.BuildLightList)))
                     {
-                        m_LightLoop.BuildGPULightLists(camera, cmd, m_CameraDepthStencilBufferRT, GetStencilTexture());
+                        m_LightLoop.BuildGPULightLists(camera, cmd, m_CameraDepthStencilBufferRT, m_CameraStencilBufferCopyRT);
                     }
                 }
 
 
                 RenderDeferredLighting(hdCamera, cmd);
 
-                // We compute subsurface scattering here. Therefore, no objects rendered afterwards will exhibit SSS.
-                // Currently, there is no efficient way to switch between SRT and MRT for the forward pass;
-                // therefore, forward-rendered objects do not output split lighting required for the SSS pass.
-                SubsurfaceScatteringPass(hdCamera, cmd, sssSettings);
-
+
+                // SSS pass here handle both SSS material from deferred and forward
+                SubsurfaceScatteringPass(hdCamera, cmd, sssSettings);
 
                 RenderSky(hdCamera, cmd);
 
         // Combines specular lighting and diffuse lighting with subsurface scattering.
         void SubsurfaceScatteringPass(HDCamera hdCamera, CommandBuffer cmd, SubsurfaceScatteringSettings sssParameters)
         {
-            // Currently, forward-rendered objects do not output split lighting required for the SSS pass.
-            if (!m_CurrentDebugDisplaySettings.renderingDebugSettings.enableSSSAndTransmission || hdCamera.useForwardOnly)
+            if (!m_CurrentDebugDisplaySettings.renderingDebugSettings.enableSSSAndTransmission)
                 return;
 
             using (new ProfilingSample(cmd, "Subsurface Scattering", GetSampler(CustomSamplerId.SubsurfaceScattering)))
+                    using (new ProfilingSample(cmd, "HTile for SSS", GetSampler(CustomSamplerId.HTileForSSS)))
+                    {
+                        CoreUtils.SetRenderTarget(cmd, m_HTileRT, ClearFlag.Color, CoreUtils.clearColorAllBlack);
+
+                        cmd.SetRandomWriteTarget(1, GetHTile());
+                        // Generate HTile for the split lighting stencil usage. Don't write into stencil texture (shaderPassId = 2)
+                        // Use ShaderPassID 1 => "Pass 2 - Export HTILE for stencilRef to output"
+                        CoreUtils.DrawFullScreen(cmd, m_CopyStencilForSplitLighting, m_CameraStencilBufferCopyRT, m_CameraDepthStencilBufferRT, null, 2);
+                        cmd.ClearRandomWriteTargets();
+                    }
+
                     // TODO: Remove this once fix, see comment inside the function
                     hdCamera.SetupComputeShader(m_SubsurfaceScatteringCS, cmd);
 
                         cmd.SetComputeFloatParam(m_SubsurfaceScatteringCS, HDShaderIDs._TexturingModeFlags, *(float*)&texturingModeFlags);
                     }
 
-                    cmd.SetComputeVectorArrayParam(m_SubsurfaceScatteringCS, HDShaderIDs._FilterKernels, sssParameters.filterKernels);
+                    cmd.SetComputeVectorArrayParam(m_SubsurfaceScatteringCS, HDShaderIDs._WorldScales,        sssParameters.worldScales);
+                    cmd.SetComputeVectorArrayParam(m_SubsurfaceScatteringCS, HDShaderIDs._FilterKernels,      sssParameters.filterKernels);
+                    cmd.SetComputeVectorArrayParam(m_SubsurfaceScatteringCS, HDShaderIDs._ShapeParams,        sssParameters.shapeParams);
-                    cmd.SetComputeTextureParam(m_SubsurfaceScatteringCS, m_SubsurfaceScatteringKernel, HDShaderIDs._GBufferTexture0,  m_GbufferManager.GetGBuffers()[0]);
-                    cmd.SetComputeTextureParam(m_SubsurfaceScatteringCS, m_SubsurfaceScatteringKernel, HDShaderIDs._GBufferTexture1,  m_GbufferManager.GetGBuffers()[1]);
-                    cmd.SetComputeTextureParam(m_SubsurfaceScatteringCS, m_SubsurfaceScatteringKernel, HDShaderIDs._GBufferTexture2,  m_GbufferManager.GetGBuffers()[2]);
-                    cmd.SetComputeTextureParam(m_SubsurfaceScatteringCS, m_SubsurfaceScatteringKernel, HDShaderIDs._GBufferTexture3,  m_GbufferManager.GetGBuffers()[3]);
+
+                    for (int i = 0; i < m_SSSBufferManager.sssBufferCount; ++i)
+                    {
+                        cmd.SetComputeTextureParam(m_SubsurfaceScatteringCS, m_SubsurfaceScatteringKernel, HDShaderIDs._SSSBufferTexture[i], m_SSSBufferManager.GetSSSBuffers(i));
+                    }
 
                     if (NeedTemporarySubsurfaceBuffer())
                     {
                 }
                 else
                 {
+                    for (int i = 0; i < m_SSSBufferManager.sssBufferCount; ++i)
+                    {
+                        cmd.SetGlobalTexture(HDShaderIDs._SSSBufferTexture[i], m_SSSBufferManager.GetSSSBuffers(i));
+                    }
+
                     cmd.SetGlobalTexture(HDShaderIDs._IrradianceSource, m_CameraSssDiffuseLightingBufferRT);  // Cannot set a RT on a material
                     m_SssVerticalFilterPass.SetVectorArray(HDShaderIDs._FilterKernelsBasic,       sssParameters.filterKernelsBasic);
                     m_SssVerticalFilterPass.SetVectorArray(HDShaderIDs._HalfRcpWeightedVariances, sssParameters.halfRcpWeightedVariances);
 
             using (new ProfilingSample(cmd, profileName, GetSampler(CustomSamplerId.ForwardPassName)))
             {
-                CoreUtils.SetRenderTarget(cmd, m_CameraColorBufferRT, m_CameraDepthStencilBufferRT);
-
                 var camera = hdCamera.camera;
 
                 m_LightLoop.RenderForward(camera, cmd, pass == ForwardPass.Opaque);
+                    // In case of forward SSS we will bind all the required target. It is up to the shader to write into it or not.
+                    if (m_CurrentDebugDisplaySettings.renderingDebugSettings.enableSSSAndTransmission)
+                    {
+                        RenderTargetIdentifier[] m_MRTWithSSS = new RenderTargetIdentifier[2 + m_SSSBufferManager.sssBufferCount];
+                        m_MRTWithSSS[0] = m_CameraColorBufferRT; // Store the specular color
+                        m_MRTWithSSS[1] = m_CameraSssDiffuseLightingBufferRT;
+                        for (int i = 0; i < m_SSSBufferManager.sssBufferCount; ++i)
+                        {
+                            m_MRTWithSSS[i + 2] = m_SSSBufferManager.GetSSSBuffers(i);
+                        }
+
+                        CoreUtils.SetRenderTarget(cmd, m_MRTWithSSS, m_CameraDepthStencilBufferRT);
+                    }
+                    else
+                    {
+                        CoreUtils.SetRenderTarget(cmd, m_CameraColorBufferRT, m_CameraDepthStencilBufferRT);
+                    }
+
                     if (m_CurrentDebugDisplaySettings.IsDebugDisplayEnabled())
                     {
                         m_ForwardAndForwardOnlyPassNames[0] = m_ForwardOnlyPassNames[0] = HDShaderPassNames.s_ForwardOnlyDebugDisplayName;
                 }
                 else
                 {
+                    CoreUtils.SetRenderTarget(cmd, m_CameraColorBufferRT, m_CameraDepthStencilBufferRT);
+
                     var passNames = m_CurrentDebugDisplaySettings.IsDebugDisplayEnabled() ? m_AllTransparentDebugDisplayPassNames : m_AllTransparentPassNames;
                     RenderTransparentRenderList(cullResults, camera, renderContext, cmd, passNames, pass == ForwardPass.PreRefraction, m_currentRendererConfigurationBakedLighting);
                 }
                     // End
 
                     if (!camera.useForwardOnly)
+                    {
+                        m_SSSBufferManager.InitGBuffers(w, h, m_GbufferManager, cmd);
+                    }
+                    else
+                    {
+                        // We need to allocate target for SSS
+                        m_SSSBufferManager.InitGBuffers(w, h, cmd);
+                    }
 
                     CoreUtils.SetRenderTarget(cmd, m_CameraColorBufferRT, m_CameraDepthStencilBufferRT, ClearFlag.Depth);
                 }
                     }
                 }
                 // <<< Old SSS Model
-
-                if (NeedStencilBufferCopy())
-                {
-                    using (new ProfilingSample(cmd, "Clear stencil texture", GetSampler(CustomSamplerId.ClearStencilTexture)))
-                    {
-                        CoreUtils.SetRenderTarget(cmd, m_CameraStencilBufferCopyRT, ClearFlag.Color, CoreUtils.clearColorAllBlack);
-                    }
-                }
-
-                if (NeedHTileCopy())
-                {
-                    using (new ProfilingSample(cmd, "Clear HTile", GetSampler(CustomSamplerId.ClearHTile)))
-                    {
-                        CoreUtils.SetRenderTarget(cmd, m_HTileRT, ClearFlag.Color, CoreUtils.clearColorAllBlack);
-                    }
-                }
 
                 // TODO: As we are in development and have not all the setup pass we still clear the color in emissive buffer and gbuffer, but this will be removed later.
 

ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipelineAsset.asset

     pointCookieSize: 512
     reflectionCubemapSize: 128
     reflectionCacheCompressed: 0
-  sssSettings: {fileID: 11400000, guid: 873499ce7a6f749408981f512a9683f7, type: 2}
+  sssSettings: {fileID: 11400000, guid: c4d57f106d34d0046a33b3e66da29a72, type: 2}
   tileSettings:
     enableTileAndCluster: 1
     enableComputeLightEvaluation: 1

ScriptableRenderPipeline/HDRenderPipeline/HDStringConstants.cs

         public static readonly int g_BaseFeatureFlags = Shader.PropertyToID("g_BaseFeatureFlags");
         public static readonly int g_TileFeatureFlags = Shader.PropertyToID("g_TileFeatureFlags");
 
-        public static readonly int _GBufferTexture0 = Shader.PropertyToID("_GBufferTexture0");
-        public static readonly int _GBufferTexture1 = Shader.PropertyToID("_GBufferTexture1");
-        public static readonly int _GBufferTexture2 = Shader.PropertyToID("_GBufferTexture2");
-        public static readonly int _GBufferTexture3 = Shader.PropertyToID("_GBufferTexture3");
-
         public static readonly int g_DispatchIndirectBuffer = Shader.PropertyToID("g_DispatchIndirectBuffer");
         public static readonly int g_TileList = Shader.PropertyToID("g_TileList");
         public static readonly int g_NumTiles = Shader.PropertyToID("g_NumTiles");
             Shader.PropertyToID("_GBufferTexture5"),
             Shader.PropertyToID("_GBufferTexture6"),
             Shader.PropertyToID("_GBufferTexture7")
+        };
+
+        public static readonly int[] _SSSBufferTexture =
+        {
+            Shader.PropertyToID("_SSSBufferTexture0"),
+            Shader.PropertyToID("_SSSBufferTexture1"),
+            Shader.PropertyToID("_SSSBufferTexture2"),
+            Shader.PropertyToID("_SSSBufferTexture3"),
         };
 
         public static readonly int _VelocityTexture = Shader.PropertyToID("_VelocityTexture");

ScriptableRenderPipeline/HDRenderPipeline/Lighting/LightLoop/LightLoop.cs

-using UnityEngine.Rendering;
+using UnityEngine.Rendering;
 using System.Collections.Generic;
 using System;
 
         static ComputeBuffer s_GlobalLightListAtomic = null;
         // clustered light list specific buffers and data end
 
+        bool m_isForwardRenderingOnly;
         bool m_isFptlEnabled;
         bool m_isFptlEnabledForForwardOpaque;
 
 
         public bool GetFeatureVariantsEnabled()
         {
-            return m_isFptlEnabled && m_LightLoopSettings.enableComputeLightEvaluation && (m_LightLoopSettings.enableComputeLightVariants || m_LightLoopSettings.enableComputeMaterialVariants);
+            return !m_isForwardRenderingOnly && m_isFptlEnabled && m_LightLoopSettings.enableComputeLightEvaluation &&
+                    (m_LightLoopSettings.enableComputeLightVariants || m_LightLoopSettings.enableComputeMaterialVariants);
         }
 
         LightLoopSettings m_LightLoopSettings = null;
         }
 
         public void Build(  RenderPipelineResources renderPipelineResources,
-                            LightLoopSettings tileSettings,
+                            LightLoopSettings lightLoopSettings,
-            m_LightLoopSettings = tileSettings;
+            m_LightLoopSettings = lightLoopSettings;
 
             m_lightList = new LightList();
             m_lightList.Allocate();
             // In HD, MSAA is only supported for forward only rendering, no MSAA in deferred mode (for code complexity reasons)
 
             // If Deferred, enable Fptl. If we are forward renderer only and not using Fptl for forward opaque, disable Fptl
-            m_isFptlEnabled = !useForwardRenderingOnly || m_LightLoopSettings.enableFptlForForwardOpaque; // TODO: Disable if MSAA
+            m_isForwardRenderingOnly = useForwardRenderingOnly;
+            m_isFptlEnabled = !m_isForwardRenderingOnly || m_LightLoopSettings.enableFptlForForwardOpaque; // TODO: Disable if MSAA
             m_isFptlEnabledForForwardOpaque = m_LightLoopSettings.enableFptlForForwardOpaque; // TODO: Disable if MSAA
 
             if (GetFeatureVariantsEnabled())
             }
 
             // Cluster
-                VoxelLightListGeneration(cmd, camera, projscr, invProjscr, cameraDepthBufferRT);
+            VoxelLightListGeneration(cmd, camera, projscr, invProjscr, cameraDepthBufferRT);
 
             if (enableFeatureVariants)
             {
                     }
                 }
             }
- 
+
             using (new ProfilingSample(cmd, "Display Shadows", HDRenderPipeline.GetSampler(CustomSamplerId.TPDisplayShadows)))
             {
                 if (lightingDebug.shadowDebugMode == ShadowMapDebugMode.VisualizeShadowMap)

ScriptableRenderPipeline/HDRenderPipeline/Lighting/LightLoop/materialflags.compute

 		int idx = i * NR_THREADS + threadID;
 		uint2 uCrd = min( uint2(viTilLL.x + (idx & 0xf), viTilLL.y + (idx >> 4)), uint2(iWidth - 1, iHeight - 1));
 
-		if (UnpackByte(LOAD_TEXTURE2D(_StencilTexture, uCrd).r) != STENCILLIGHTINGUSAGE_NO_LIGHTING) // This test is we are the sky/background or not
+        // StencilTexture here contain the result of testing if we are not equal to stencil usage NoLighting. i.e (stencil value != NoLighting). The 1.0 mean true.
+        // This test if we are the sky/background or a forward opaque (which tag the stencil as NoLighting)
+		if (LOAD_TEXTURE2D(_StencilTexture, uCrd).r == 1.0)
 		{
 			PositionInputs posInput = GetPositionInput(uCrd, invScreenSize);
             materialFeatureFlags |= MATERIAL_FEATURE_FLAGS_FROM_GBUFFER(posInput.positionSS);

ScriptableRenderPipeline/HDRenderPipeline/Material/LayeredLit/LayeredLit.shader

     // This shader support vertex modification
     #define HAVE_VERTEX_MODIFICATION
 
+    // If we use subsurface scattering, enable output split lighting (for forward pass)
+    #if defined(_MATID_SSS) && !defined(_SURFACE_TYPE_TRANSPARENT)
+    #define OUTPUT_SPLIT_LIGHTING
+    #endif
+
     //-------------------------------------------------------------------------------------
     // Include
     //-------------------------------------------------------------------------------------
             Name "Forward" // Name is not used
             Tags{ "LightMode" = "Forward" } // This will be only for transparent object based on the RenderQueue index
 
+            Stencil
+            {
+                Ref[_StencilRef]
+                Comp Always
+                Pass Replace
+            }
+
             Blend[_SrcBlend][_DstBlend]
             ZWrite[_ZWrite]
             Cull[_CullMode]
         {
             Name "ForwardDebugDisplay" // Name is not used
             Tags{ "LightMode" = "ForwardDebugDisplay" } // This will be only for transparent object based on the RenderQueue index
+
+            Stencil
+            {
+                Ref[_StencilRef]
+                Comp Always
+                Pass Replace
+            }
 
             Blend[_SrcBlend][_DstBlend]
             ZWrite[_ZWrite]

ScriptableRenderPipeline/HDRenderPipeline/Material/LayeredLit/LayeredLitTessellation.shader

     #define HAVE_VERTEX_MODIFICATION
     #define HAVE_TESSELLATION_MODIFICATION
 
+    // If we use subsurface scattering, enable output split lighting (for forward pass)
+    #if defined(_MATID_SSS) && !defined(_SURFACE_TYPE_TRANSPARENT)
+    #define OUTPUT_SPLIT_LIGHTING
+    #endif
+
     //-------------------------------------------------------------------------------------
     // Include
     //-------------------------------------------------------------------------------------
             Name "Forward" // Name is not used
             Tags{ "LightMode" = "Forward" } // This will be only for transparent object based on the RenderQueue index
 
+            Stencil
+            {
+                Ref[_StencilRef]
+                Comp Always
+                Pass Replace
+            }
+
             Blend[_SrcBlend][_DstBlend]
             ZWrite[_ZWrite]
             Cull[_CullMode]
         {
             Name "ForwardDebugDisplay" // Name is not used
             Tags{ "LightMode" = "ForwardDebugDisplay" } // This will be only for transparent object based on the RenderQueue index
+
+            Stencil
+            {
+                Ref[_StencilRef]
+                Comp Always
+                Pass Replace
+            }
 
             Blend[_SrcBlend][_DstBlend]
             ZWrite[_ZWrite]

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Lit.hlsl

 
 // SurfaceData is define in Lit.cs which generate Lit.cs.hlsl
 #include "Lit.cs.hlsl"
-#include "SubsurfaceScatteringSettings.cs.hlsl"
+#include "../SubsurfaceScattering/SubsurfaceScattering.hlsl"
 
 // Define refraction keyword helpers
 #define HAS_REFRACTION (defined(_REFRACTION_PLANE) || defined(_REFRACTION_SPHERE))
 #define LTC_LUT_SIZE   64
 #define LTC_LUT_SCALE  ((LTC_LUT_SIZE - 1) * rcp(LTC_LUT_SIZE))
 #define LTC_LUT_OFFSET (0.5 * rcp(LTC_LUT_SIZE))
-
-// Subsurface scattering constant
-#define SSS_WRAP_ANGLE (PI/12)              // 15 degrees
-#define SSS_WRAP_LIGHT cos(PI/2 - SSS_WRAP_ANGLE)
-
-CBUFFER_START(UnitySSSParameters)
-// Warning: Unity is not able to losslessly transfer integers larger than 2^24 to the shader system.
-// Therefore, we bitcast uint to float in C#, and bitcast back to uint in the shader.
-uint   _EnableSSSAndTransmission; // Globally toggles subsurface and transmission scattering on/off
-float  _TexturingModeFlags;       // 1 bit/profile; 0 = PreAndPostScatter, 1 = PostScatter
-float  _TransmissionFlags;        // 2 bit/profile; 0 = inf. thick, 1 = thin, 2 = regular
-// Old SSS Model >>>
-uint   _UseDisneySSS;
-float4 _HalfRcpVariancesAndWeights[SSS_N_PROFILES][2]; // 2x Gaussians in RGB, A is interpolation weights
-// <<< Old SSS Model
-// Use float4 to avoid any packing issue between compute and pixel shaders
-float4  _ThicknessRemaps[SSS_N_PROFILES];   // R: start, G = end - start, BA unused
-float4 _ShapeParams[SSS_N_PROFILES];        // RGB = S = 1 / D, A = filter radius
-float4 _TransmissionTints[SSS_N_PROFILES];  // RGB = 1/4 * color, A = unused
-float4 _WorldScales[SSS_N_PROFILES];        // X = meters per world unit; Y = world units per meter
-CBUFFER_END
 
 //-----------------------------------------------------------------------------
 // Helper for cheap screen space raycasting
     bsdfData.fresnel0 = lerp(val.xxx, baseColor, metallic);
 }
 
-void FillMaterialIdSSSData(float3 baseColor, inout BSDFData bsdfData)
+void FillMaterialIdSSSData(float3 baseColor, float subsurfaceRadius, inout BSDFData bsdfData)
+    bsdfData.subsurfaceRadius = subsurfaceRadius;
-void FillTransmissionData(int subsurfaceProfile, float subsurfaceRadius, float thickness, inout BSDFData bsdfData)
+void FillTransmissionData(int subsurfaceProfile, float thickness, inout BSDFData bsdfData)
 {
     bsdfData.enableTransmission = _EnableSSSAndTransmission != 0;
 
     {
         bsdfData.subsurfaceProfile  = subsurfaceProfile;
-        bsdfData.subsurfaceRadius   = subsurfaceRadius;
         bsdfData.useThickObjectMode = transmissionMode != SSS_TRSM_MODE_THIN;
         bsdfData.thickness          = _ThicknessRemaps[subsurfaceProfile].x + _ThicknessRemaps[subsurfaceProfile].y * thickness;
 
     }
 }
 
-// Returns the modified albedo (diffuse color) for materials with subsurface scattering.
-// Ref: Advanced Techniques for Realistic Real-Time Skin Rendering.
-float3 ApplyDiffuseTexturingMode(BSDFData bsdfData)
-{
-    float3 albedo = bsdfData.diffuseColor;
-
-    if (bsdfData.materialId == MATERIALID_LIT_SSS)
-    {
-    #if defined(SHADERPASS) && (SHADERPASS == SHADERPASS_SUBSURFACE_SCATTERING)
-        // If the SSS pass is executed, we know we have SSS enabled.
-        bool enableSssAndTransmission = true;
-    #else
-        bool enableSssAndTransmission = _EnableSSSAndTransmission != 0;
-    #endif
-
-        if (enableSssAndTransmission)
-        {
-            bool performPostScatterTexturing = IsBitSet(asuint(_TexturingModeFlags), bsdfData.subsurfaceProfile);
-
-            if (performPostScatterTexturing)
-            {
-                // Post-scatter texturing mode: the albedo is only applied during the SSS pass.
-            #if !defined(SHADERPASS) || (SHADERPASS != SHADERPASS_SUBSURFACE_SCATTERING)
-                albedo = float3(1, 1, 1);
-            #endif
-            }
-            else
-            {
-                // Pre- and pos- scatter texturing mode.
-                albedo = sqrt(albedo);
-            }
-        }
-    }
-
-    return albedo;
-}
-
 void FillMaterialIdClearCoatData(float3 coatNormalWS, float coatCoverage, float coatIOR, inout BSDFData bsdfData)
 {
     bsdfData.coatNormalWS = lerp(bsdfData.normalWS, coatNormalWS, coatCoverage);
 #endif
 }
 
+SSSData ConvertSurfaceDataToSSSData(SurfaceData surfaceData)
+{
+    SSSData sssData;
+
+    sssData.diffuseColor = surfaceData.baseColor;
+    sssData.subsurfaceRadius = surfaceData.subsurfaceRadius;
+    sssData.subsurfaceProfile = surfaceData.subsurfaceProfile;
+
+    return sssData;
+}
+
 //-----------------------------------------------------------------------------
 // conversion function for forward
 //-----------------------------------------------------------------------------
     }
     else if (bsdfData.materialId == MATERIALID_LIT_SSS)
     {
-        FillMaterialIdSSSData(surfaceData.baseColor, bsdfData);
-        FillTransmissionData(surfaceData.subsurfaceProfile, surfaceData.subsurfaceRadius, surfaceData.thickness, bsdfData);
+        FillMaterialIdSSSData(surfaceData.baseColor, surfaceData.subsurfaceRadius, bsdfData);
+        FillTransmissionData(surfaceData.subsurfaceProfile, surfaceData.thickness, bsdfData);
     }
     else if (bsdfData.materialId == MATERIALID_LIT_ANISO)
     {
     }
     else if (surfaceData.materialId == MATERIALID_LIT_SSS)
     {
-        outGBuffer2 = float4(surfaceData.subsurfaceRadius, surfaceData.thickness, 0.0, PackByte(surfaceData.subsurfaceProfile));
+        // Special case: For SSS we will store the profile id and the subsurface radius at the location of the specular occlusion (in alpha channel of GBuffer0)
+        // and we will move the specular occlusion in GBuffer2. This is an optimization for SSSSS and have no other side effect as specular occlusion is always used
+        // during lighting pass when other buffer (Gbuffer0, 1, 2) and read anyway.
+        EncodeIntoSSSBuffer(ConvertSurfaceDataToSSSData(surfaceData), positionSS, outGBuffer0);
+        outGBuffer2 = float4(surfaceData.specularOcclusion, surfaceData.thickness, 0.0, 0.0); // Thickness is use for transmission
     }
     else if (surfaceData.materialId == MATERIALID_LIT_ANISO)
     {
 
     if (HasMaterialFeatureFlag(MATERIALFEATUREFLAGS_LIT_SSS))
     {
-        float subsurfaceRadius  = 0;
-        float thickness         = 0;
+        float subsurfaceRadius  = 0.0;
+        float thickness         = 0.0;
-            subsurfaceRadius  = inGBuffer2.x;
-            thickness         = inGBuffer2.y;
-            subsurfaceProfile = UnpackByte(inGBuffer2.w);
-
-            FillMaterialIdSSSData(baseColor, bsdfData);
+            DecodeSSSProfileFromSSSBuffer(inGBuffer0, positionSS, subsurfaceProfile);
+            bsdfData.specularOcclusion = inGBuffer2.r; // Reminder: when using SSS we exchange specular occlusion and subsurfaceRadius/profileID
+            thickness = inGBuffer2.g;
+            // We don't use subsurfaceRadius in deferred lighting pass, only for SSSSS, so let it to 0
+            FillMaterialIdSSSData(baseColor, subsurfaceRadius, bsdfData);
-        FillTransmissionData(subsurfaceProfile, subsurfaceRadius, thickness, bsdfData);
+        FillTransmissionData(subsurfaceProfile, thickness, bsdfData);
     }
 
     if (bsdfData.materialId == MATERIALID_LIT_STANDARD && HasMaterialFeatureFlag(MATERIALFEATUREFLAGS_LIT_STANDARD))
 // This function require the 3 structure surfaceData, builtinData, bsdfData because it may require both the engine side data, and data that will not be store inside the gbuffer.
 float3 GetBakedDiffuseLigthing(SurfaceData surfaceData, BuiltinData builtinData, BSDFData bsdfData, PreLightData preLightData)
 {
-    bsdfData.diffuseColor = ApplyDiffuseTexturingMode(bsdfData);
+    if (bsdfData.materialId == MATERIALID_LIT_SSS)
+    {
+        bsdfData.diffuseColor = ApplyDiffuseTexturingMode(bsdfData.diffuseColor, bsdfData.subsurfaceProfile);
+    }
 
     // Premultiply bake diffuse lighting information with DisneyDiffuse pre-integration
     return builtinData.bakeDiffuseLighting * preLightData.diffuseFGD * surfaceData.ambientOcclusion * bsdfData.diffuseColor + builtinData.emissiveColor;
                                 lerp(_AmbientOcclusionParam.rgb, float3(1.0, 1.0, 1.0), directAmbientOcclusion);
 #endif
 
-    float3 modifiedDiffuseColor = ApplyDiffuseTexturingMode(bsdfData);
+    float3 modifiedDiffuseColor;
+    if (bsdfData.materialId == MATERIALID_LIT_SSS)
+        modifiedDiffuseColor = ApplyDiffuseTexturingMode(bsdfData.diffuseColor, bsdfData.subsurfaceProfile);
+    else
+        modifiedDiffuseColor = bsdfData.diffuseColor;
 
     // Apply the albedo to the direct diffuse lighting (only once). The indirect (baked)
     // diffuse lighting has already had the albedo applied in GetBakedDiffuseLigthing().

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Lit.shader

     // This shader support vertex modification
     #define HAVE_VERTEX_MODIFICATION
 
+    // If we use subsurface scattering, enable output split lighting (for forward pass)
+    #if defined(_MATID_SSS) && !defined(_SURFACE_TYPE_TRANSPARENT)
+    #define OUTPUT_SPLIT_LIGHTING
+    #endif
+
     //-------------------------------------------------------------------------------------
     // Include
     //-------------------------------------------------------------------------------------
             Name "Forward" // Name is not used
             Tags { "LightMode" = "Forward" } // This will be only for transparent object based on the RenderQueue index
 
+            Stencil
+            {
+                Ref[_StencilRef]
+                Comp Always
+                Pass Replace
+            }
+
             Blend [_SrcBlend] [_DstBlend]
             ZWrite [_ZWrite]
             Cull [_CullMode]
         {
             Name "ForwardDebugDisplay" // Name is not used
             Tags{ "LightMode" = "ForwardDebugDisplay" } // This will be only for transparent object based on the RenderQueue index
+
+            Stencil
+            {
+                Ref[_StencilRef]
+                Comp Always
+                Pass Replace
+            }
 
             Blend[_SrcBlend][_DstBlend]
             ZWrite[_ZWrite]

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/LitTessellation.shader

     #define HAVE_VERTEX_MODIFICATION
     #define HAVE_TESSELLATION_MODIFICATION
 
+    // If we use subsurface scattering, enable output split lighting (for forward pass)
+    #if defined(_MATID_SSS) && !defined(_SURFACE_TYPE_TRANSPARENT)
+    #define OUTPUT_SPLIT_LIGHTING
+    #endif
+
     //-------------------------------------------------------------------------------------
     // Include
     //-------------------------------------------------------------------------------------
             Name "Forward" // Name is not used
             Tags { "LightMode" = "Forward" } // This will be only for transparent object based on the RenderQueue index
 
+            Stencil
+            {
+                Ref[_StencilRef]
+                Comp Always
+                Pass Replace
+            }
+
             Blend [_SrcBlend] [_DstBlend]
             ZWrite [_ZWrite]
             Cull [_CullMode]
         {
             Name "ForwardDebugDisplay" // Name is not used
             Tags{ "LightMode" = "ForwardDebugDisplay" } // This will be only for transparent object based on the RenderQueue index
+
+            Stencil
+            {
+                Ref[_StencilRef]
+                Comp Always
+                Pass Replace
+            }
 
             Blend[_SrcBlend][_DstBlend]
             ZWrite[_ZWrite]

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Resources/CopyStencilBuffer.shader

         [HideInInspector] _StencilRef("_StencilRef", Int) = 1
     }
 
+    HLSLINCLUDE
+
+    #pragma target 4.5
+    #pragma only_renderers d3d11 ps4 vulkan metal // TEMP: until we go further in dev
+    // #pragma enable_d3d11_debug_symbols
+
+    #include "ShaderLibrary/Common.hlsl"
+    #include "ShaderLibrary/Packing.hlsl"
+    #include "../../../ShaderVariables.hlsl"
+    #include "../../../Lighting/LightDefinition.cs.hlsl"
+
+    int _StencilRef;
+    RW_TEXTURE2D(float, _HTile); // DXGI_FORMAT_R8_UINT is not supported by Unity
+
+    struct Attributes
+    {
+        uint vertexID : SV_VertexID;
+    };
+
+    struct Varyings
+    {
+        float4 positionCS : SV_Position;
+    };
+
+    Varyings Vert(Attributes input)
+    {
+        Varyings output;
+        output.positionCS = GetFullScreenTriangleVertexPosition(input.vertexID);
+        return output;
+    }
+
+    #pragma vertex Vert
+
+    ENDHLSL
+
+            Name "Pass 0 - Copy stencilRef to output"
+
             Stencil
             {
                 Ref  [_StencilRef]
             Blend  Off
 
             HLSLPROGRAM
-            #pragma target 4.5
-            #pragma only_renderers d3d11 ps4 vulkan metal // TEMP: until we go further in dev
-            #pragma multi_compile _ EXPORT_HTILE
-            // #pragma enable_d3d11_debug_symbols
-
-            #pragma vertex Vert
-            #include "ShaderLibrary/Packing.hlsl"
-            #include "../../../ShaderVariables.hlsl"
-            #include "../../../Lighting/LightDefinition.cs.hlsl"
+            // Force the stencil test before the UAV write.
+            [earlydepthstencil]
+            float4 Frag(Varyings input) : SV_Target // use SV_StencilRef in D3D 11.3+
+            {
+                return PackByte(_StencilRef);
+            }
-            int _StencilRef;
-            RW_TEXTURE2D(float, _HTile); // DXGI_FORMAT_R8_UINT is not supported by Unity
+            ENDHLSL
+        }
-            struct Attributes
+        Pass
+        {
+            Name "Pass 1 - Write 1 if value different from stencilRef to output"
+
+            Stencil
-                uint vertexID : SV_VertexID;
-            };
+                Ref  [_StencilRef]
+                Comp NotEqual
+                Pass Keep
+            }
+
+            Cull   Off
+            ZTest  Always
+            ZWrite Off
+            Blend  Off
-            struct Varyings
+            HLSLPROGRAM
+            #pragma fragment Frag
+
+            // Force the stencil test before the UAV write.
+            [earlydepthstencil]
+            float4 Frag(Varyings input) : SV_Target // use SV_StencilRef in D3D 11.3+
-                float4 positionCS : SV_Position;
-            };
+                return float4(1.0, 0.0, 0.0, 0.0); // 1.0 for true as it passes the condition
+            }
+
+            ENDHLSL
+        }
-            Varyings Vert(Attributes input)
+        Pass
+        {
+            Name "Pass 2 - Export HTILE for stencilRef to output"
+
+            Stencil
-                Varyings output;
-                output.positionCS = GetFullScreenTriangleVertexPosition(input.vertexID);
-                return output;
+                Ref  [_StencilRef]
+                Comp Equal
+                Pass Keep
+            Cull   Off
+            ZTest  Always
+            ZWrite Off
+            Blend  Off
+            ColorMask 0
+
+            HLSLPROGRAM
+            #pragma fragment Frag
+
+                // There's no need for atomics as we are always writing the same value.
+                // Note: the GCN tile size is 8x8 pixels.
+                _HTile[positionNDC / 8] = _StencilRef;
-                #ifdef EXPORT_HTILE
-                    // There's no need for atomics as we are always writing the same value.
-                    // Note: the GCN tile size is 8x8 pixels.
-                    _HTile[positionNDC / 8] = _StencilRef;
-                #endif
+                return float4(0.0, 0.0, 0.0, 0.0);
+            }
-                return PackByte(_StencilRef);
-            }
             ENDHLSL
         }
     }

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Resources/SubsurfaceScattering.compute

 // Included headers
 //--------------------------------------------------------------------------------------------------
 
+#include "ShaderLibrary/Common.hlsl"
+#include "ShaderLibrary\Fibonacci.hlsl"
-#define UNITY_MATERIAL_LIT
-#include "../../../Material/Material.hlsl"
+#include "../../SubsurfaceScattering/SubsurfaceScattering.hlsl"
 
 //--------------------------------------------------------------------------------------------------
 // Inputs & outputs
 
     [branch] if (!passedStencilTest || isOffScreen) { return; }
 
-    PositionInputs posInput = GetPositionInput(pixelCoord, _ScreenSize.zw);    
+    PositionInputs posInput = GetPositionInput(pixelCoord, _ScreenSize.zw);
-    BSDFData bsdfData;
-    float3 unused;
-    DECODE_FROM_GBUFFER(pixelCoord, MATERIALFEATUREFLAGS_LIT_SSS, bsdfData, unused);
+    SSSData sssData;
+    DECODE_FROM_SSSBUFFER(posInput.positionSS, sssData);
-    int    profileID   = bsdfData.subsurfaceProfile;
-    float  distScale   = bsdfData.subsurfaceRadius;
+    int    profileID   = sssData.subsurfaceProfile;
+    float  distScale   = sssData.subsurfaceRadius;
     float3 shapeParam  = _ShapeParams[profileID].rgb;
     float  maxDistance = _ShapeParams[profileID].a;
 
     // divergence of execution across the warp.
     float maxDistInPixels = maxDistance * max(pixelsPerMm.x, pixelsPerMm.y);
 
-    float3 albedo = ApplyDiffuseTexturingMode(bsdfData);
+    float3 albedo = ApplyDiffuseTexturingMode(sssData.diffuseColor, profileID);
 
     [branch] if (distScale == 0 || maxDistInPixels < 1)
     {
     float4x4 viewMatrix, projMatrix;
     GetLeftHandedViewSpaceMatrices(viewMatrix, projMatrix);
 
+    // TODO: Since we have moved to forward SSS, we don't support anymore a bsdfData.normalWS.
+    // Once we include normal+roughness rendering during the prepass, we will have a buffer to bind here and we will be able to reuse this part of the algorithm on demand.
+#if SSS_USE_TANGENT_PLANE
+    #error ThisWillNotCompile_SeeComment
+#else
+    float3 normalVS = float3(0, 0, 0);
+    float3 tangentX = float3(0, 0, 0);
+    float3 tangentY = float3(0, 0, 0);
+#endif
 
 #if SSS_DEBUG_NORMAL_VS
     // We expect the normal to be front-facing.

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Resources/SubsurfaceScattering.shader

 
             #include "ShaderLibrary/Common.hlsl"
             #include "../../../ShaderVariables.hlsl"
-            #define UNITY_MATERIAL_LIT // Needs to be defined before including Material.hlsl
-            #include "../../../Material/Material.hlsl"
+            #include "../../SubsurfaceScattering/SubsurfaceScattering.hlsl"
 
             //-------------------------------------------------------------------------------------
             // Inputs & outputs
 
             float4 Frag(Varyings input) : SV_Target
             {
-                PositionInputs posInput = GetPositionInput(input.positionCS.xy, _ScreenSize.zw);                
+                PositionInputs posInput = GetPositionInput(input.positionCS.xy, _ScreenSize.zw);
-                // Note: When we are in this SubsurfaceScattering shader we know that we are a SSS material. This shader is strongly coupled with the deferred Lit.shader.
-                // We can use the material classification facility to help the compiler to know we use SSS material and optimize the code (and don't require to read gbuffer with materialId).
-                uint featureFlags = MATERIALFEATUREFLAGS_LIT_SSS;
+                // Note: When we are in this SubsurfaceScattering shader we know that we are a SSS material.
+                SSSData sssData;
+                DECODE_FROM_SSSBUFFER(posInput.positionSS, sssData);
-                BSDFData bsdfData;
-                float3 unused;
-                DECODE_FROM_GBUFFER(posInput.positionSS, featureFlags, bsdfData, unused);
-
-                int    profileID   = bsdfData.subsurfaceProfile;
-                float  distScale   = bsdfData.subsurfaceRadius;
+                int    profileID   = sssData.subsurfaceProfile;
+                float  distScale   = sssData.subsurfaceRadius;
                 float  maxDistance = _FilterKernelsBasic[profileID][SSS_BASIC_N_SAMPLES - 1].a;
 
                 // Take the first (central) sample.
                 float  halfRcpVariance = _HalfRcpWeightedVariances[profileID].a;
             #endif
 
-            float3 albedo = ApplyDiffuseTexturingMode(bsdfData);
+            float3 albedo = ApplyDiffuseTexturingMode(sssData.diffuseColor, profileID);
 
             #ifndef SSS_FILTER_HORIZONTAL_AND_COMBINE
                 albedo = float3(1, 1, 1);

ScriptableRenderPipeline/HDRenderPipeline/SceneSettings/Resources/DrawSssProfile.shader

             #define USE_LEGACY_UNITY_MATRIX_VARIABLES
             #include "../../ShaderVariables.hlsl"
         #ifdef SSS_MODEL_BASIC
-            #include "../../Material/Lit/SubsurfaceScatteringSettings.cs.hlsl"
+            #include "../../Material/SubsurfaceScattering/SubsurfaceScatteringSettings.cs.hlsl"
         #endif
 
             //-------------------------------------------------------------------------------------

ScriptableRenderPipeline/HDRenderPipeline/SceneSettings/Resources/DrawTransmittanceGraph.shader

             #include "ShaderLibrary/CommonMaterial.hlsl"
             #define USE_LEGACY_UNITY_MATRIX_VARIABLES
             #include "../../ShaderVariables.hlsl"
+            #include "../../Material/SubsurfaceScattering/CommonSubsurfaceScattering.hlsl"
 
             //-------------------------------------------------------------------------------------
             // Inputs & outputs

ScriptableRenderPipeline/HDRenderPipeline/ShaderPass/ShaderPassForward.hlsl

 #endif // TESSELLATION_ON
 
 void Frag(PackedVaryingsToPS packedInput,
-          out float4 outColor : SV_Target0
-      #ifdef _DEPTHOFFSET_ON
-          , out float outputDepth : SV_Depth
-      #endif
+        #ifdef OUTPUT_SPLIT_LIGHTING
+            out float4 outColor : SV_Target0,  // outSpecularLighting
+            out float4 outDiffuseLighting : SV_Target1,
+            OUTPUT_SSSBUFFER(outSSSBuffer)
+        #else
+            out float4 outColor : SV_Target0
+        #endif
+        #ifdef _DEPTHOFFSET_ON
+            , out float outputDepth : SV_Depth
+        #endif
           )
 {
     FragInputs input = UnpackVaryingsMeshToFragInputs(packedInput.vmesh);
         bakeLightingData.bakeShadowMask = float4(builtinData.shadowMask0, builtinData.shadowMask1, builtinData.shadowMask2, builtinData.shadowMask3);
 #endif
         LightLoop(V, posInput, preLightData, bsdfData, bakeLightingData, featureFlags, diffuseLighting, specularLighting);
+
+#ifdef OUTPUT_SPLIT_LIGHTING
+        if (_EnableSSSAndTransmission != 0)
+        {
+            outColor = float4(specularLighting, 1.0);
+            outDiffuseLighting = float4(TagLightingForSSS(diffuseLighting), 1.0);
+        }
+        else
+        {
+            outColor = float4(diffuseLighting + specularLighting, 1.0);
+            outDiffuseLighting = 0;
+        }
+        ENCODE_INTO_SSSBUFFER(surfaceData, posInput.positionSS, outSSSBuffer);
+#else
+#endif
     }
 
 #ifdef _DEPTHOFFSET_ON

ScriptableRenderPipeline/HDRenderPipeline/Material/SubsurfaceScattering/SSSProfile.meta

 fileFormatVersion: 2
 guid: a0ba759eadcfdcc44bc08adad4960ed0
 folderAsset: yes
-timeCreated: 1493162006
-licenseType: Pro
+  externalObjects: {}
   userData: 
   assetBundleName: 
   assetBundleVariant: 

ScriptableRenderPipeline/HDRenderPipeline/Material/SubsurfaceScattering/SSSProfile/SSS Settings.asset.meta

 fileFormatVersion: 2
-guid: 873499ce7a6f749408981f512a9683f7
-timeCreated: 1507649491
-licenseType: Pro
+guid: c4d57f106d34d0046a33b3e66da29a72
 NativeFormatImporter:
   externalObjects: {}
   mainObjectFileID: 11400000

ScriptableRenderPipeline/HDRenderPipeline/Material/SubsurfaceScattering/SSSProfile/SSS Settings.asset

   m_GameObject: {fileID: 0}
   m_Enabled: 1
   m_EditorHideFlags: 0
-  m_Script: {fileID: 11500000, guid: 3418a08abd15e9a49af3ccbc9e15b5ea, type: 3}
+  m_Script: {fileID: 11500000, guid: b2686e09ec7aef44bad2843e4416f057, type: 3}
   m_Name: SSS Settings
   m_EditorClassIdentifier: 
   useDisneySSS: 1
     scatterDistance1: {r: 0.3, g: 0.3, b: 0.3, a: 0}
     scatterDistance2: {r: 0.5, g: 0.5, b: 0.5, a: 0}
     lerpWeight: 1
+  - name: Profile 8
+    scatteringDistance: {r: 0.5, g: 0.5, b: 0.5, a: 1}
+    transmissionTint: {r: 1, g: 1, b: 1, a: 1}
+    texturingMode: 0
+    transmissionMode: 0
+    thicknessRemap: {x: 0, y: 5}
+    worldScale: 1
+    scatterDistance1: {r: 0.3, g: 0.3, b: 0.3, a: 0}
+    scatterDistance2: {r: 0.5, g: 0.5, b: 0.5, a: 0}
+    lerpWeight: 1
+  - name: Profile 9
+    scatteringDistance: {r: 0.5, g: 0.5, b: 0.5, a: 1}
+    transmissionTint: {r: 1, g: 1, b: 1, a: 1}
+    texturingMode: 0
+    transmissionMode: 0
+    thicknessRemap: {x: 0, y: 5}
+    worldScale: 1
+    scatterDistance1: {r: 0.3, g: 0.3, b: 0.3, a: 0}
+    scatterDistance2: {r: 0.5, g: 0.5, b: 0.5, a: 0}
+    lerpWeight: 1
+  - name: Profile 10
+    scatteringDistance: {r: 0.5, g: 0.5, b: 0.5, a: 1}
+    transmissionTint: {r: 1, g: 1, b: 1, a: 1}
+    texturingMode: 0
+    transmissionMode: 0
+    thicknessRemap: {x: 0, y: 5}
+    worldScale: 1
+    scatterDistance1: {r: 0.3, g: 0.3, b: 0.3, a: 0}
+    scatterDistance2: {r: 0.5, g: 0.5, b: 0.5, a: 0}
+    lerpWeight: 1
+  - name: Profile 11
+    scatteringDistance: {r: 0.5, g: 0.5, b: 0.5, a: 1}
+    transmissionTint: {r: 1, g: 1, b: 1, a: 1}
+    texturingMode: 0
+    transmissionMode: 0
+    thicknessRemap: {x: 0, y: 5}
+    worldScale: 1
+    scatterDistance1: {r: 0.3, g: 0.3, b: 0.3, a: 0}
+    scatterDistance2: {r: 0.5, g: 0.5, b: 0.5, a: 0}
+    lerpWeight: 1
+  - name: Profile 12
+    scatteringDistance: {r: 0.5, g: 0.5, b: 0.5, a: 1}
+    transmissionTint: {r: 1, g: 1, b: 1, a: 1}
+    texturingMode: 0
+    transmissionMode: 0
+    thicknessRemap: {x: 0, y: 5}
+    worldScale: 1
+    scatterDistance1: {r: 0.3, g: 0.3, b: 0.3, a: 0}
+    scatterDistance2: {r: 0.5, g: 0.5, b: 0.5, a: 0}
+    lerpWeight: 1
+  - name: Profile 13
+    scatteringDistance: {r: 0.5, g: 0.5, b: 0.5, a: 1}
+    transmissionTint: {r: 1, g: 1, b: 1, a: 1}
+    texturingMode: 0
+    transmissionMode: 0
+    thicknessRemap: {x: 0, y: 5}
+    worldScale: 1
+    scatterDistance1: {r: 0.3, g: 0.3, b: 0.3, a: 0}
+    scatterDistance2: {r: 0.5, g: 0.5, b: 0.5, a: 0}
+    lerpWeight: 1
+  - name: Profile 14
+    scatteringDistance: {r: 0.5, g: 0.5, b: 0.5, a: 1}
+    transmissionTint: {r: 1, g: 1, b: 1, a: 1}
+    texturingMode: 0
+    transmissionMode: 0
+    thicknessRemap: {x: 0, y: 5}
+    worldScale: 1
+    scatterDistance1: {r: 0.3, g: 0.3, b: 0.3, a: 0}
+    scatterDistance2: {r: 0.5, g: 0.5, b: 0.5, a: 0}
+    lerpWeight: 1
+  - name: Profile 15
+    scatteringDistance: {r: 0.5, g: 0.5, b: 0.5, a: 1}
+    transmissionTint: {r: 1, g: 1, b: 1, a: 1}
+    texturingMode: 0
+    transmissionMode: 0
+    thicknessRemap: {x: 0, y: 5}
+    worldScale: 1
+    scatterDistance1: {r: 0.3, g: 0.3, b: 0.3, a: 0}
+    scatterDistance2: {r: 0.5, g: 0.5, b: 0.5, a: 0}
+    lerpWeight: 1

ScriptableRenderPipeline/HDRenderPipeline/Material/SubsurfaceScattering.meta

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

ScriptableRenderPipeline/HDRenderPipeline/Material/SubsurfaceScattering/CommonSubsurfaceScattering.hlsl

+// ----------------------------------------------------------------------------
+// SSS/Transmittance helper
+// ----------------------------------------------------------------------------
+
+// Computes the fraction of light passing through the object.
+// Evaluate Int{0, inf}{2 * Pi * r * R(sqrt(r^2 + d^2))}, where R is the diffusion profile.
+// Note: 'volumeAlbedo' should be premultiplied by 0.25.
+// Ref: Approximate Reflectance Profiles for Efficient Subsurface Scattering by Pixar (BSSRDF only).
+float3 ComputeTransmittanceDisney(float3 S, float3 volumeAlbedo, float thickness, float radiusScale)
+{
+    // Thickness and SSS radius are decoupled for artists.
+    // In theory, we should modify the thickness by the inverse of the radius scale of the profile.
+    // thickness /= radiusScale;
+
+#if 0
+    float3 expOneThird = exp(((-1.0 / 3.0) * thickness) * S);
+#else
+    // Help the compiler.
+    float  k = (-1.0 / 3.0) * LOG2_E;
+    float3 p = (k * thickness) * S;
+    float3 expOneThird = exp2(p);
+#endif
+
+    // Premultiply & optimize: T = (1/4 * A) * (e^(-t * S) + 3 * e^(-1/3 * t * S))
+    return volumeAlbedo * (expOneThird * expOneThird * expOneThird + 3 * expOneThird);
+}
+
+// Evaluates transmittance for a linear combination of two normalized 2D Gaussians.
+// Ref: Real-Time Realistic Skin Translucency (2010), equation 9 (modified).
+// Note: 'volumeAlbedo' should be premultiplied by 0.25, correspondingly 'lerpWeight' by 4,
+// and 'halfRcpVariance1' should be prescaled by (0.1 * SssConstants.SSS_BASIC_DISTANCE_SCALE)^2.
+float3 ComputeTransmittanceJimenez(float3 halfRcpVariance1, float lerpWeight1,
+                                   float3 halfRcpVariance2, float lerpWeight2,
+                                   float3 volumeAlbedo, float thickness, float radiusScale)
+{
+    // Thickness and SSS radius are decoupled for artists.
+    // In theory, we should modify the thickness by the inverse of the radius scale of the profile.
+    // thickness /= radiusScale;
+
+    float t2 = thickness * thickness;
+
+    // T = A * lerp(exp(-t2 * halfRcpVariance1), exp(-t2 * halfRcpVariance2), lerpWeight2)
+    return volumeAlbedo * (exp(-t2 * halfRcpVariance1) * lerpWeight1 + exp(-t2 * halfRcpVariance2) * lerpWeight2);
+}
+
+// In order to support subsurface scattering, we need to know which pixels have an SSS material.
+// It can be accomplished by reading the stencil buffer.
+// A faster solution (which avoids an extra texture fetch) is to simply make sure that
+// all pixels which belong to an SSS material are not black (those that don't always are).
+// We choose the blue color channel since it's perceptually the least noticeable.
+float3 TagLightingForSSS(float3 subsurfaceLighting)
+{
+    subsurfaceLighting.b = max(subsurfaceLighting.b, HALF_MIN);
+    return subsurfaceLighting;
+}
+
+// See TagLightingForSSS() for details.
+bool TestLightingForSSS(float3 subsurfaceLighting)
+{
+    return subsurfaceLighting.b > 0;
+}

ScriptableRenderPipeline/HDRenderPipeline/Material/SubsurfaceScattering/CommonSubsurfaceScattering.hlsl.meta

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

ScriptableRenderPipeline/HDRenderPipeline/Material/SubsurfaceScattering/Editor.meta

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

ScriptableRenderPipeline/HDRenderPipeline/Material/SubsurfaceScattering/Editor/SubsurfaceScatteringSettingsEditor.Styles.cs.meta

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

ScriptableRenderPipeline/HDRenderPipeline/Material/SubsurfaceScattering/Editor/SubsurfaceScatteringSettingsEditor.cs.meta

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

ScriptableRenderPipeline/HDRenderPipeline/Material/SubsurfaceScattering/SubsurfaceScattering.hlsl

+#include "SubsurfaceScatteringSettings.cs.hlsl"
+#include "ShaderLibrary\Packing.hlsl"
+#include "CommonSubsurfaceScattering.hlsl"
+
+// Subsurface scattering constant
+#define SSS_WRAP_ANGLE (PI/12)              // 15 degrees
+#define SSS_WRAP_LIGHT cos(PI/2 - SSS_WRAP_ANGLE)
+
+CBUFFER_START(UnitySSSParameters)
+// Warning: Unity is not able to losslessly transfer integers larger than 2^24 to the shader system.
+// Therefore, we bitcast uint to float in C#, and bitcast back to uint in the shader.
+uint   _EnableSSSAndTransmission; // Globally toggles subsurface and transmission scattering on/off
+float  _TexturingModeFlags;       // 1 bit/profile; 0 = PreAndPostScatter, 1 = PostScatter
+float  _TransmissionFlags;        // 2 bit/profile; 0 = inf. thick, 1 = thin, 2 = regular
+// Old SSS Model >>>
+uint   _UseDisneySSS;
+float4 _HalfRcpVariancesAndWeights[SSS_N_PROFILES][2]; // 2x Gaussians in RGB, A is interpolation weights
+// <<< Old SSS Model
+// Use float4 to avoid any packing issue between compute and pixel shaders
+float4  _ThicknessRemaps[SSS_N_PROFILES];   // R: start, G = end - start, BA unused
+float4 _ShapeParams[SSS_N_PROFILES];        // RGB = S = 1 / D, A = filter radius
+float4 _TransmissionTints[SSS_N_PROFILES];  // RGB = 1/4 * color, A = unused
+float4 _WorldScales[SSS_N_PROFILES];        // X = meters per world unit; Y = world units per meter
+CBUFFER_END
+
+// ----------------------------------------------------------------------------
+// helper functions
+// ----------------------------------------------------------------------------
+
+// Returns the modified albedo (diffuse color) for materials with subsurface scattering.
+// Ref: Advanced Techniques for Realistic Real-Time Skin Rendering.
+float3 ApplyDiffuseTexturingMode(float3 color, int subsurfaceProfile)
+{
+#if defined(SHADERPASS) && (SHADERPASS == SHADERPASS_SUBSURFACE_SCATTERING)
+    // If the SSS pass is executed, we know we have SSS enabled.
+    bool enableSssAndTransmission = true;
+#else
+    bool enableSssAndTransmission = _EnableSSSAndTransmission != 0;
+#endif
+
+    if (enableSssAndTransmission)
+    {
+        bool performPostScatterTexturing = IsBitSet(asuint(_TexturingModeFlags), subsurfaceProfile);
+
+        if (performPostScatterTexturing)
+        {
+            // Post-scatter texturing mode: the albedo is only applied during the SSS pass.
+        #if !defined(SHADERPASS) || (SHADERPASS != SHADERPASS_SUBSURFACE_SCATTERING)
+            color = float3(1, 1, 1);
+        #endif
+        }
+        else
+        {
+            // Pre- and post- scatter texturing mode.
+            color = sqrt(color);
+        }
+    }
+
+    return color;
+}
+
+// ----------------------------------------------------------------------------
+// Encoding/decoding SSS buffer functions
+// ----------------------------------------------------------------------------
+
+struct SSSData
+{
+    float3 diffuseColor;
+    float subsurfaceRadius;
+    float subsurfaceProfile;
+};
+
+#define SSSBufferType0 float4
+
+// SSSBuffer texture declaration
+TEXTURE2D(_SSSBufferTexture0);
+
+void EncodeIntoSSSBuffer(SSSData sssData, uint2 positionSS, out SSSBufferType0 outSSSBuffer0)
+{
+    outSSSBuffer0 = float4(sssData.diffuseColor, PackFloatInt8bit(sssData.subsurfaceRadius, sssData.subsurfaceProfile, 16.0));
+}
+
+void DecodeSSSProfileFromSSSBuffer(SSSBufferType0 inSSSBuffer0, uint2 positionSS, out int subsurfaceProfile)
+{
+    float unused;
+    UnpackFloatInt8bit(inSSSBuffer0.a, 16.0, unused, subsurfaceProfile);
+}
+
+void DecodeFromSSSBuffer(uint2 positionSS, out SSSData sssData)
+{
+    float4 inBuffer = LOAD_TEXTURE2D(_SSSBufferTexture0, positionSS);
+    sssData.diffuseColor = LOAD_TEXTURE2D(_SSSBufferTexture0, positionSS).rgb;
+    UnpackFloatInt8bit(inBuffer.a, 16.0, sssData.subsurfaceRadius, sssData.subsurfaceProfile);
+}
+
+// OUTPUT_SSSBUFFER start from SV_Target2 as SV_Target0 and SV_Target1 are used for lighting buffer
+#define OUTPUT_SSSBUFFER(NAME) out GBufferType0 MERGE_NAME(NAME, 0) : SV_Target2
+#define ENCODE_INTO_SSSBUFFER(SURFACE_DATA, UNPOSITIONSS, NAME) EncodeIntoSSSBuffer(ConvertSurfaceDataToSSSData(SURFACE_DATA), UNPOSITIONSS, MERGE_NAME(NAME, 0))
+
+#define DECODE_FROM_SSSBUFFER(UNPOSITIONSS, SSS_DATA) DecodeFromSSSBuffer(UNPOSITIONSS, SSS_DATA)

ScriptableRenderPipeline/HDRenderPipeline/Material/SubsurfaceScattering/SubsurfaceScattering.hlsl.meta

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

ScriptableRenderPipeline/HDRenderPipeline/Material/SubsurfaceScattering/SubsurfaceScatteringManager.cs

+using UnityEngine.Rendering;
+using System;
+
+namespace UnityEngine.Experimental.Rendering.HDPipeline
+{
+    public class SubsurfaceScatteringManager
+    {
+        // Currently we only support SSSBuffer with one buffer. If the shader code change, it may require to update the shader manager
+        public const int k_MaxSSSBuffer = 1;
+
+        readonly int m_SSSBuffer0;
+        readonly RenderTargetIdentifier m_SSSBuffer0RT;
+
+        public int sssBufferCount { get { return k_MaxSSSBuffer; } }
+
+        RenderTargetIdentifier[] m_ColorMRTs;
+        RenderTargetIdentifier[] m_RTIDs = new RenderTargetIdentifier[k_MaxSSSBuffer];
+
+        public SubsurfaceScatteringManager()
+        {
+            m_SSSBuffer0RT = new RenderTargetIdentifier(m_SSSBuffer0);
+        }
+
+        // In case of deferred, we must be in sync with SubsurfaceScattering.hlsl and lit.hlsl files and setup the correct buffers
+        // for SSS
+        public void InitGBuffers(int width, int height, GBufferManager gbufferManager, CommandBuffer cmd)
+        {
+            m_RTIDs[0] = gbufferManager.GetGBuffers()[0];
+        }
+
+        // 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
+        public void InitGBuffers(int width, int height, CommandBuffer cmd)
+        {
+            m_RTIDs[0] = m_SSSBuffer0RT;
+
+            cmd.ReleaseTemporaryRT(m_SSSBuffer0);
+            cmd.GetTemporaryRT(m_SSSBuffer0, width, height, 0, FilterMode.Point, RenderTextureFormat.ARGB32, RenderTextureReadWrite.Linear);            
+        }
+
+        public RenderTargetIdentifier GetSSSBuffers(int index)
+        {
+            Debug.Assert(index < sssBufferCount);
+            return m_RTIDs[index];
+        }
+    }
+}

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

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

ScriptableRenderPipeline/HDRenderPipeline/Material/SubsurfaceScattering/SubsurfaceScatteringSettings.cs.hlsl.meta

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

ScriptableRenderPipeline/HDRenderPipeline/Material/SubsurfaceScattering/SubsurfaceScatteringSettings.cs.meta

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

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Editor/SubsurfaceScatteringSettingsEditor.Styles.cs.meta

-fileFormatVersion: 2
-guid: 95517c3b2f4a014468289c3f5eb6d03c
-timeCreated: 1507562538
-licenseType: Pro
-MonoImporter:
-  externalObjects: {}
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Editor/SubsurfaceScatteringSettingsEditor.cs.meta

-fileFormatVersion: 2
-guid: a61a2437dcee4e54393f8f65ccf726ab
-timeCreated: 1507562486
-licenseType: Pro
-MonoImporter:
-  externalObjects: {}
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/SubsurfaceScatteringSettings.cs.meta

-fileFormatVersion: 2
-guid: 3418a08abd15e9a49af3ccbc9e15b5ea
-timeCreated: 1507538042
-licenseType: Pro
-MonoImporter:
-  externalObjects: {}
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/SubsurfaceScatteringSettings.cs.hlsl.meta

-fileFormatVersion: 2
-guid: 86fe0068e2ac49e4d99882aaa40fa522
-timeCreated: 1507935155
-licenseType: Pro
-ShaderImporter:
-  externalObjects: {}
-  defaultTextures: []
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: