Merge branch 'master' of https://github.com/Unity-Technologies/ScriptableRenderLoop

Assets/BasicRenderLoopTutorial/BasicRenderLoop.cs

             var settings = new DrawRendererSettings(cull, camera, new ShaderPassName("BasicPass"));
             settings.sorting.flags = SortFlags.CommonOpaque;
             settings.inputFilter.SetQueuesOpaque();
-            context.DrawRenderers(settings);
+            context.DrawRenderers(ref settings);
 
             // Draw skybox
             context.DrawSkybox(camera);
             settings.inputFilter.SetQueuesTransparent();
-            context.DrawRenderers(settings);
+            context.DrawRenderers(ref settings);
 
             context.Submit();
         }

Assets/ScriptableRenderLoop/AdditionalLightData.cs

         }
 
         [Range(0.0F, 100.0F)]
-        private float m_innerSpotPercent = 0.0F;
+        public float m_innerSpotPercent = 0.0f; // To display this field in the UI this need to be public
 
         public float GetInnerSpotPercent01()
         {

Assets/ScriptableRenderLoop/HDRenderPipeline/Debug/Resources/DebugViewMaterialGBuffer.shader

 
             HLSLPROGRAM
             #pragma target 4.5
-            #pragma only_renderers d3d11 ps4 metal // TEMP: unitl we go futher in dev
+            #pragma only_renderers d3d11 ps4 metal // TEMP: until we go further in dev
 
             #pragma vertex Vert
             #pragma fragment Frag
 
             DECLARE_GBUFFER_TEXTURE(_GBufferTexture);
 
-            TEXTURE2D(_CameraDepthTexture);
+            TEXTURE2D_FLOAT(_CameraDepthTexture);
             SAMPLER2D(sampler_CameraDepthTexture);
             int         _DebugViewMaterial;
 

Assets/ScriptableRenderLoop/HDRenderPipeline/Debug/Resources/DebugViewTiles.shader

 
             HLSLPROGRAM
             #pragma target 4.5
-            #pragma only_renderers d3d11 ps4 metal // TEMP: unitl we go futher in dev
+            #pragma only_renderers d3d11 ps4 metal // TEMP: until we go further in dev
 
             #pragma vertex Vert
             #pragma fragment Frag
             // variable declaration
             //-------------------------------------------------------------------------------------
 
-            TEXTURE2D(_CameraDepthTexture);
+            TEXTURE2D_FLOAT(_CameraDepthTexture);
             SAMPLER2D(sampler_CameraDepthTexture);
 
             uint _ViewTilesFlags;

Assets/ScriptableRenderLoop/HDRenderPipeline/Editor/HDRenderPipeWindow.cs

         {
             CommonSettingsSingleton.overrideSettings = (CommonSettings)EditorGUILayout.ObjectField(new GUIContent("Common Settings"), CommonSettingsSingleton.overrideSettings, typeof(CommonSettings), false);
             SkyParametersSingleton.overrideSettings = (SkyParameters)EditorGUILayout.ObjectField(new GUIContent("Sky Settings"), SkyParametersSingleton.overrideSettings, typeof(SkyParameters), false);
+            SubsurfaceScatteringSettings.overrideSettings = (SubsurfaceScatteringParameters)EditorGUILayout.ObjectField(new GUIContent("Subsurface Scattering Settings"), SubsurfaceScatteringSettings.overrideSettings, typeof(SubsurfaceScatteringParameters), false);
 
             if (GUILayout.Button("Create new common settings"))
             {
             {
                 var instance = CreateInstance<ProceduralSkyParameters>();
                 AssetDatabase.CreateAsset(instance, "Assets/NewProceduralSkyParameters.asset");
+            }
+
+            if (GUILayout.Button("Create new SSS params"))
+            {
+                var instance = CreateInstance<SubsurfaceScatteringParameters>();
+                AssetDatabase.CreateAsset(instance, "Assets/NewSssParameters.asset");
             }
         }
     }

Assets/ScriptableRenderLoop/HDRenderPipeline/Editor/HDRenderPipelineInspector.cs

 using System;
 using System.Reflection;
+using System.Linq.Expressions;
 using UnityEditor;
 
 //using EditorGUIUtility=UnityEditor.EditorGUIUtility;
     {
         private class Styles
         {
+            // Global debug parameters
+            public readonly GUIContent debugging = new GUIContent("Debugging");
+            public readonly GUIContent debugOverlayRatio = new GUIContent("Overlay Ratio");
+
             public readonly GUIContent debugParameters = new GUIContent("Debug Parameters");
             public readonly GUIContent debugViewMaterial = new GUIContent("DebugView Material", "Display various properties of Materials.");
 
             public readonly GUIContent useForwardRenderingOnly = new GUIContent("Use Forward Rendering Only");
             public readonly GUIContent useDepthPrepass = new GUIContent("Use Depth Prepass");
-            public readonly GUIContent useDistortion = new GUIContent("Use Distortion");
+            public readonly GUIContent useDistortion = new GUIContent("Use Distortion");        
 
             public bool isDebugViewMaterialInit = false;
             public GUIContent[] debugViewMaterialStrings = null;
+            public readonly GUIContent sssSettings = new GUIContent("Subsurface Scattering Settings");
+
+            // Shadow Debug
+            public readonly GUIContent shadowDebugParameters = new GUIContent("Shadow Debug");
+            public readonly GUIContent shadowDebugEnable = new GUIContent("Enable Shadows");
+            public readonly GUIContent shadowDebugVisualizationMode = new GUIContent("Visualize");
+            public readonly GUIContent shadowDebugVisualizeShadowIndex = new GUIContent("Visualize Shadow Index");
-            public readonly GUIContent shadowsEnabled = new GUIContent("Enabled");
-            public readonly string[] tileLightLoopDebugTileFlagStrings = new string[] {"Punctual Light", "Area Light", "Env Light"};
+            public readonly string[] tileLightLoopDebugTileFlagStrings = new string[] { "Punctual Light", "Area Light", "Env Light"};
             public readonly GUIContent splitLightEvaluation = new GUIContent("Split light and reflection evaluation", "Toggle");
             public readonly GUIContent bigTilePrepass = new GUIContent("Enable big tile prepass", "Toggle");
             public readonly GUIContent clustered = new GUIContent("Enable clustered", "Toggle");
-
-
-            public readonly GUIContent reflectionCubemapSize = new GUIContent("Reflection cubemap size");
+            public readonly GUIContent reflectionCubemapSize = new GUIContent("Reflection cubemap size");              
         }
 
         private static Styles s_Styles = null;
             }
         }
 
-        const float k_MaxExposure = 32.0f;
+        SerializedProperty m_ShowDebug = null;
+        SerializedProperty m_ShowDebugShadow = null;
+        SerializedProperty m_DebugOverlayRatio = null;
+
+        SerializedProperty m_DebugShadowEnabled = null;
+        SerializedProperty m_DebugShadowVisualizationMode = null;
+        SerializedProperty m_DebugShadowVisualizeShadowIndex = null;
+
+        private void InitializeProperties()
+        {
+            m_DebugOverlayRatio = FindProperty(x => x.globalDebugParameters.debugOverlayRatio);
+            m_ShowDebugShadow = FindProperty(x => x.globalDebugParameters.displayShadowDebug);
+            m_ShowDebug = FindProperty(x => x.globalDebugParameters.displayDebug);
+
+            m_DebugShadowEnabled = FindProperty(x => x.globalDebugParameters.shadowDebugParameters.enableShadows);
+            m_DebugShadowVisualizationMode = FindProperty(x => x.globalDebugParameters.shadowDebugParameters.visualizationMode);
+            m_DebugShadowVisualizeShadowIndex = FindProperty(x => x.globalDebugParameters.shadowDebugParameters.visualizeShadowMapIndex);
+        }
+
+        SerializedProperty FindProperty<TValue>(Expression<Func<HDRenderPipeline, TValue>> expr)
+        {
+            var path = Utilities.GetFieldPath(expr);
+            return serializedObject.FindProperty(path);
+        }
 
         string GetSubNameSpaceName(Type type)
         {
 
             if (!attr.needParamDefines)
             {
-                return;
+                return ;
             }
 
             var fields = type.GetFields();
                 // Check if the display name have been override by the users
                 if (Attribute.IsDefined(field, typeof(SurfaceDataAttributes)))
                 {
-                    var propertyAttr = (SurfaceDataAttributes[]) field.GetCustomAttributes(typeof(SurfaceDataAttributes), false);
+                    var propertyAttr = (SurfaceDataAttributes[])field.GetCustomAttributes(typeof(SurfaceDataAttributes), false);
                     if (propertyAttr[0].displayName != "")
                     {
                         fieldName = propertyAttr[0].displayName;
                 fieldName = (isBSDFData ? "Engine/" : "") + strSubNameSpace + fieldName;
 
                 debugViewMaterialStrings[index] = new GUIContent(fieldName);
-                debugViewMaterialValues[index] = attr.paramDefinesStart + (int) localIndex;
+                debugViewMaterialValues[index] = attr.paramDefinesStart + (int)localIndex;
                 index++;
                 localIndex++;
             }
                 var valueName = (isBSDFData ? "Engine/" : "" + prefix) + names[localIndex];
 
                 debugViewMaterialStrings[index] = new GUIContent(valueName);
-                debugViewMaterialValues[index] = (int) value;
+                debugViewMaterialValues[index] = (int)value;
                 index++;
                 localIndex++;
             }
                 method.Invoke(asset, new object[0]);
         }
 
+        private void DebuggingUI(HDRenderPipeline renderContext, HDRenderPipelineInstance renderpipelineInstance)
+        {
+            EditorGUILayout.LabelField(styles.debugging);
+
+            // Global debug parameters
+            EditorGUI.indentLevel++;
+            m_DebugOverlayRatio.floatValue = EditorGUILayout.Slider(styles.debugOverlayRatio, m_DebugOverlayRatio.floatValue, 0.1f, 1.0f);
+            EditorGUILayout.Space();
+
+            DebugParametersUI(renderContext);
+            EditorGUILayout.Space();
+            ShadowDebugParametersUI(renderContext, renderpipelineInstance);
+
+            EditorGUI.indentLevel--;
+        }
+
+
+            m_ShowDebug.boolValue = EditorGUILayout.Foldout(m_ShowDebug.boolValue, styles.debugParameters);
+            if (!m_ShowDebug.boolValue)
+                return;
+
-            EditorGUILayout.LabelField(styles.debugParameters);
             EditorGUI.indentLevel++;
             EditorGUI.BeginChangeCheck();
 
                 styles.isDebugViewMaterialInit = true;
             }
 
-            debugParameters.debugViewMaterial = EditorGUILayout.IntPopup(styles.debugViewMaterial, (int) debugParameters.debugViewMaterial, styles.debugViewMaterialStrings, styles.debugViewMaterialValues);
+            debugParameters.debugViewMaterial = EditorGUILayout.IntPopup(styles.debugViewMaterial, (int)debugParameters.debugViewMaterial, styles.debugViewMaterialStrings, styles.debugViewMaterialValues);
 
             EditorGUILayout.Space();
             debugParameters.displayOpaqueObjects = EditorGUILayout.Toggle(styles.displayOpaqueObjects, debugParameters.displayOpaqueObjects);
             }
         }
 
+        private void SssSettingsUI(HDRenderPipeline pipe)
+        {
+            EditorGUILayout.Space();
+
+            EditorGUILayout.LabelField(styles.sssSettings);
+            EditorGUI.BeginChangeCheck();
+            EditorGUI.indentLevel++;
+            pipe.localSssParameters = (SubsurfaceScatteringParameters) EditorGUILayout.ObjectField(new GUIContent("Subsurface Scattering Parameters"), pipe.localSssParameters, typeof(SubsurfaceScatteringParameters), false);
+            EditorGUI.indentLevel--;
+
+            if (EditorGUI.EndChangeCheck())
+            {
+                HackSetDirty(pipe); // Repaint
+            }
+        }
+
+        private void ShadowDebugParametersUI(HDRenderPipeline renderContext, HDRenderPipelineInstance renderpipelineInstance)
+        {
+            m_ShowDebugShadow.boolValue = EditorGUILayout.Foldout(m_ShowDebugShadow.boolValue, styles.shadowDebugParameters);
+            if (!m_ShowDebugShadow.boolValue)
+                return;
+
+            EditorGUI.indentLevel++;
+            EditorGUILayout.PropertyField(m_DebugShadowEnabled, styles.shadowDebugEnable);
+            EditorGUILayout.PropertyField(m_DebugShadowVisualizationMode, styles.shadowDebugVisualizationMode);
+            if (!m_DebugShadowVisualizationMode.hasMultipleDifferentValues)
+            {
+                if ((ShadowDebugMode)m_DebugShadowVisualizationMode.intValue == ShadowDebugMode.VisualizeShadowMap)
+                {
+                    EditorGUILayout.IntSlider(m_DebugShadowVisualizeShadowIndex, 0, renderpipelineInstance.GetCurrentShadowCount() - 1, styles.shadowDebugVisualizeShadowIndex);
+                }
+            }
+            EditorGUI.indentLevel--;
+        }
+
         private void ShadowParametersUI(HDRenderPipeline renderContext)
         {
             EditorGUILayout.Space();
             EditorGUI.indentLevel++;
             EditorGUI.BeginChangeCheck();
 
-            shadowParameters.enabled = EditorGUILayout.Toggle(styles.shadowsEnabled, shadowParameters.enabled);
             shadowParameters.shadowAtlasWidth = Mathf.Max(0, EditorGUILayout.IntField(styles.shadowsAtlasWidth, shadowParameters.shadowAtlasWidth));
             shadowParameters.shadowAtlasHeight = Mathf.Max(0, EditorGUILayout.IntField(styles.shadowsAtlasHeight, shadowParameters.shadowAtlasHeight));
 
             }
         }*/
 
+        public void OnEnable()
+        {
+            InitializeProperties();
+        }
+
+            HDRenderPipelineInstance renderpipelineInstance = UnityEngine.Experimental.Rendering.RenderPipelineManager.currentPipeline as HDRenderPipelineInstance;
-            if (!renderContext)
+            if (!renderContext || renderpipelineInstance == null)
-            DebugParametersUI(renderContext);
+            serializedObject.Update();
+
+            DebuggingUI(renderContext, renderpipelineInstance);
+            SssSettingsUI(renderContext);
+
+            serializedObject.ApplyModifiedProperties();
         }
     }
 }

Assets/ScriptableRenderLoop/HDRenderPipeline/HDRenderPipeline.asset

   m_Enabled: 1
   m_EditorHideFlags: 0
   m_Script: {fileID: 11500000, guid: d440c0deec24a2f478b3e9021cb66c29, type: 3}
-  m_Name: 
+  m_Name: HDRenderPipeline
   m_EditorClassIdentifier: 
   m_CommonSettings:
     m_ShadowMaxDistance: 1000
     m_ShadowCascadeSplit2: 0.3
-  m_SkyParameters: {fileID: 11400000, guid: 12b814c3b2e53c246a0c9f1594c01532, type: 2}
+    m_SssProfileStdDev1: {r: 0.3, g: 0.3, b: 0.3, a: 0}
+    m_SssProfileStdDev2: {r: 1, g: 1, b: 1, a: 0}
+    m_SssProfileLerpWeight: 0.5
+    m_SssBilateralScale: 0.1
+  m_SkyParameters: {fileID: 0}
+  globalDebugParameters:
+    debugOverlayRatio: 0.33
+    displayDebug: 1
+    displayShadowDebug: 1
+    shadowDebugParameters:
+      enableShadows: 1
+      visualizationMode: 0
+      visualizeShadowMapIndex: 0
   m_ShadowSettings:
     enabled: 1
     shadowAtlasWidth: 4096
     directionalLightCascades: {x: 0.05, y: 0.2, z: 0.3}
+  m_SssParameters:
+    profiles: []
+    bilateralScale: 0.1
   m_TextureSettings:
     spotCookieSize: 128
     pointCookieSize: 512

Assets/ScriptableRenderLoop/HDRenderPipeline/HDRenderPipeline.asset.meta

 fileFormatVersion: 2
 guid: e185fecca3c73cd47a09f1092663ef32
-timeCreated: 1484329328
+timeCreated: 1485874614
+  mainObjectFileID: 11400000
   userData: 
   assetBundleName: 
   assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderPipeline/HDRenderPipeline.cs

             AssetDatabase.CreateAsset(instance, k_HDRenderPipelinePath);
         }
 
-        [UnityEditor.MenuItem("RenderPipeline/UpdateHDLoop")]
-        static void UpdateHDLoop()
+        [UnityEditor.MenuItem("HDRenderPipeline/UpdateHDRenderPipeline")]
+        static void UpdateHDRenderPipeline()
-                var loop = AssetDatabase.LoadAssetAtPath<HDRenderPipeline>(path);
-               // loop.m_Setup = AssetDatabase.LoadAssetAtPath<TilePassSetup>("Assets/HDRenderPipelineSetup.asset");
-                EditorUtility.SetDirty(loop);
+                var pipeline = AssetDatabase.LoadAssetAtPath<HDRenderPipeline>(path);
+                EditorUtility.SetDirty(pipeline);
             }
         }
 
             }
         }
 
-
         [SerializeField]
         private SkyParameters m_SkyParameters;
 
                     return SkyParametersSingleton.overrideSettings;
 
                 return m_SkyParameters;
+            }
-        }
+        
+        [SerializeField]
+        public SubsurfaceScatteringParameters localSssParameters;
+
+        public SubsurfaceScatteringParameters sssParameters
+        {
+            get
+            {
+                if (SubsurfaceScatteringSettings.overrideSettings != null)
+                {
+                    return SubsurfaceScatteringSettings.overrideSettings;
+                }
+                if (localSssParameters == null)
+                {
+                    localSssParameters = new SubsurfaceScatteringParameters();
+                }
+
+                return localSssParameters;
+            }
+        }
 
         [SerializeField]
         private LightLoopProducer m_LightLoopProducer;
             return new HDRenderPipelineInstance(this);
         }
 
+        // Debugging
+        public GlobalDebugParameters globalDebugParameters = new GlobalDebugParameters();
         readonly DebugParameters m_DebugParameters = new DebugParameters();
 
         public DebugParameters debugParameters
             set { m_TextureSettings = value; }
         }
 
+        public void ApplyDebugParameters()
+        {
+            m_ShadowSettings.enabled = globalDebugParameters.shadowDebugParameters.enableShadows;
+        }
+
+
             m_ShadowSettings.directionalLightCascadeCount = commonSettings.shadowCascadeCount;
             m_ShadowSettings.directionalLightCascades = new Vector3(commonSettings.shadowCascadeSplit0, commonSettings.shadowCascadeSplit1, commonSettings.shadowCascadeSplit2);
             m_ShadowSettings.maxShadowDistance = commonSettings.shadowMaxDistance;
         public Matrix4x4 invViewProjectionMatrix;
         }
 
-        public class DebugParameters
-        {
-            // Material Debugging
-            public int debugViewMaterial = 0;
-
-            // Rendering debugging
-            public bool displayOpaqueObjects = true;
-            public bool displayTransparentObjects = true;
-
-            public bool useForwardRenderingOnly = false; // TODO: Currently there is no way to strip the extra forward shaders generated by the shaders compiler, so we can switch dynamically.
-            public bool useDepthPrepass = false;
-            public bool useDistortion = true;
-
-            // we have to fallback to forward-only rendering when scene view is using wireframe rendering mode --
-            // as rendering everything in wireframe + deferred do not play well together
-        public bool ShouldUseForwardRenderingOnly()
-        {
-            return useForwardRenderingOnly || GL.wireframe;
-        }
-        }
-
         public class GBufferManager
         {
             public const int MaxGbuffer = 8;
 
         // Various set of material use in render loop
         readonly Material m_DebugViewMaterialGBuffer;
+        readonly Material m_CombineSubsurfaceScattering;
+        readonly Material m_DebugDisplayShadowMap;
-        readonly int m_CameraDepthBuffer;
+        readonly int m_CameraSubsurfaceBuffer;
+        readonly int m_CameraFilteringBuffer;
+        readonly int m_CameraDepthStencilBuffer;
+        readonly int m_CameraStencilBuffer;
+        // 'm_CameraColorBuffer' does not contain diffuse lighting of SSS materials until the SSS pass.
+        // It is stored within 'm_CameraSubsurfaceBufferRT'.
-        readonly RenderTargetIdentifier m_CameraDepthBufferRT;
+        readonly RenderTargetIdentifier m_CameraSubsurfaceBufferRT;
+        readonly RenderTargetIdentifier m_CameraFilteringBufferRT;
+        readonly RenderTargetIdentifier m_CameraDepthStencilBufferRT;
+        // 'm_CameraStencilBufferRT' is a temporary copy of the stencil buffer and should be removed
+        // once we are able to read from the depth buffer and perform the stencil test simultaneously.
+        readonly RenderTargetIdentifier m_CameraStencilBufferRT;
         readonly RenderTargetIdentifier m_VelocityBufferRT;
         readonly RenderTargetIdentifier m_DistortionBufferRT;
 
 
         ShadowRenderPass m_ShadowPass;
+        ShadowOutput m_ShadowsResult = new ShadowOutput();
+
+        public int GetCurrentShadowCount() { return m_ShadowsResult.shadowLights == null ? 0 : m_ShadowsResult.shadowLights.Length; }
 
         readonly SkyManager m_SkyManager = new SkyManager();
         private readonly BaseLightLoop m_LightLoop;
             get { return m_Owner.debugParameters; }
         }
+        private GlobalDebugParameters globalDebugParameters
+        {
+            get { return m_Owner.globalDebugParameters; }
+        }
-            m_CameraColorBuffer = Shader.PropertyToID("_CameraColorTexture");
-            m_CameraDepthBuffer  = Shader.PropertyToID("_CameraDepthTexture");
+            m_CameraColorBuffer          = Shader.PropertyToID("_CameraColorTexture");
+            m_CameraSubsurfaceBuffer     = Shader.PropertyToID("_CameraSubsurfaceTexture");
+            m_CameraFilteringBuffer      = Shader.PropertyToID("_CameraFilteringBuffer");
+            m_CameraDepthStencilBuffer   = Shader.PropertyToID("_CameraDepthTexture");
+            m_CameraStencilBuffer        = Shader.PropertyToID("_CameraStencilTexture");
-            m_CameraColorBufferRT = new RenderTargetIdentifier(m_CameraColorBuffer);
-            m_CameraDepthBufferRT = new RenderTargetIdentifier(m_CameraDepthBuffer);
+            m_CameraColorBufferRT        = new RenderTargetIdentifier(m_CameraColorBuffer);
+            m_CameraSubsurfaceBufferRT   = new RenderTargetIdentifier(m_CameraSubsurfaceBuffer);
+            m_CameraFilteringBufferRT    = new RenderTargetIdentifier(m_CameraFilteringBuffer);
+            m_CameraDepthStencilBufferRT = new RenderTargetIdentifier(m_CameraDepthStencilBuffer);
+            m_CameraStencilBufferRT      = new RenderTargetIdentifier(m_CameraStencilBuffer);
+
+            m_CombineSubsurfaceScattering = Utilities.CreateEngineMaterial("Hidden/HDRenderPipeline/CombineSubsurfaceScattering");
+            m_DebugDisplayShadowMap = Utilities.CreateEngineMaterial("Hidden/HDRenderPipeline/DebugDisplayShadowMap");
-
             m_gbufferManager.gbufferCount = m_LitRenderLoop.GetMaterialGBufferCount();
             RenderTextureFormat[] RTFormat;
             RenderTextureReadWrite[] RTReadWrite;
             m_LitRenderLoop.Cleanup();
 
             Utilities.Destroy(m_DebugViewMaterialGBuffer);
+            Utilities.Destroy(m_DebugDisplayShadowMap);
+
             m_SkyManager.Cleanup();
 
 #if UNITY_EDITOR
                 Shader.SetGlobalInt("_EnvLightSkyEnabled", 1);
             }
             else
-                    {
+            {
-                    }
+            }
 
             var cmd = new CommandBuffer {name = "Push Global Parameters"};
 
 
-                    renderContext.ExecuteCommandBuffer(cmd);
-                    cmd.Dispose();
+            renderContext.ExecuteCommandBuffer(cmd);
+            cmd.Dispose();
-                }
+        }
 
         public override void Render(ScriptableRenderContext renderContext, Camera[] cameras)
         {
             if (m_LightLoop != null)
                 m_LightLoop.NewFrame();
 
+            m_Owner. ApplyDebugParameters();
             m_Owner.UpdateCommonSettings();
 
             // Set Frame constant buffer
             RenderForwardOnlyOpaqueDepthPrepass(cullResults, camera, renderContext);
             RenderGBuffer(cullResults, camera, renderContext);
 
+            // 'm_CameraStencilBufferRT' is a temporary copy of the stencil buffer and should be removed
+            // once we are able to read from the depth buffer and perform the stencil test simultaneously.
+            using (new Utilities.ProfilingSample("Copy depth-stencil buffer", renderContext))
+            {
+                var cmd = new CommandBuffer();
+                cmd.CopyTexture(m_CameraDepthStencilBufferRT, m_CameraStencilBufferRT);
+                renderContext.ExecuteCommandBuffer(cmd);
+                cmd.Dispose();
+            }
+
-                return;
-
-            ShadowOutput shadows;
+            else
+            {
-                {
-                m_ShadowPass.Render(renderContext, cullResults, out shadows);
-                }
+            {
+                m_ShadowPass.Render(renderContext, cullResults, out m_ShadowsResult);
+            }
+            {
+                using (new Utilities.ProfilingSample("Build Light list", renderContext))
-                using (new Utilities.ProfilingSample("Build Light list", renderContext))
-                    {
-                    m_LightLoop.PrepareLightsForGPU(m_Owner.shadowSettings, cullResults, camera, ref shadows);
-                    m_LightLoop.BuildGPULightLists(camera, renderContext, m_CameraDepthBufferRT); // TODO: Use async compute here to run light culling during shadow
-                    }
+                    m_LightLoop.PrepareLightsForGPU(m_Owner.shadowSettings, cullResults, camera, ref m_ShadowsResult);
+                    m_LightLoop.BuildGPULightLists(camera, renderContext, m_CameraDepthStencilBufferRT); // TODO: Use async compute here to run light culling during shadow
+            }
 
             PushGlobalParams(hdCamera, renderContext);
 
 
             RenderDeferredLighting(hdCamera, renderContext);
 
+            // 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.
+            CombineSubsurfaceScattering(hdCamera, renderContext, m_Owner.sssParameters);
+
             // For opaque forward we have split rendering in two categories
             // Material that are always forward and material that can be deferred or forward depends on render pipeline options (like switch to rendering forward only mode)
             // Material that are always forward are unlit and complex (Like Hair) and don't require sorting, so it is ok to split them.
             RenderDistortion(cullResults, camera, renderContext);
 
             FinalPass(camera, renderContext);
+            }
+            RenderDebugOverlay(camera, renderContext);
-                cmd.SetRenderTarget(BuiltinRenderTextureType.CameraTarget, m_CameraDepthBufferRT);
+                cmd.SetRenderTarget(BuiltinRenderTextureType.CameraTarget, m_CameraDepthStencilBufferRT);
                 renderContext.ExecuteCommandBuffer(cmd);
                 cmd.Dispose();
             }
                 sorting = { flags = SortFlags.CommonOpaque }
             };
             settings.inputFilter.SetQueuesOpaque();
-            renderContext.DrawRenderers(settings);
+            renderContext.DrawRenderers(ref settings);
         }
 
         void RenderTransparentRenderList(CullResults cull, Camera camera, ScriptableRenderContext renderContext, string passName, RendererConfiguration rendererConfiguration = 0)
                 sorting = { flags = SortFlags.CommonTransparent }
             };
             settings.inputFilter.SetQueuesTransparent();
-            renderContext.DrawRenderers(settings);
+            renderContext.DrawRenderers(ref settings);
         }
 
         void RenderDepthPrepass(CullResults cull, Camera camera, ScriptableRenderContext renderContext)
             {
                 // TODO: Must do opaque then alpha masked for performance!
                 // TODO: front to back for opaque and by materal for opaque tested when we split in two
-                Utilities.SetRenderTarget(renderContext, m_CameraDepthBufferRT);
+                Utilities.SetRenderTarget(renderContext, m_CameraDepthStencilBufferRT);
                 RenderOpaqueRenderList(cull, camera, renderContext, "DepthOnly");
             }
         }
             using (new Utilities.ProfilingSample("GBuffer Pass", renderContext))
             {
                 // setup GBuffer for rendering
-                Utilities.SetRenderTarget(renderContext, m_gbufferManager.GetGBuffers(), m_CameraDepthBufferRT);
+                Utilities.SetRenderTarget(renderContext, m_gbufferManager.GetGBuffers(), m_CameraDepthStencilBufferRT);
                 // render opaque objects into GBuffer
                 RenderOpaqueRenderList(cull, camera, renderContext, "GBuffer", Utilities.kRendererConfigurationBakedLighting);
             }
 
             using (new Utilities.ProfilingSample("Forward opaque depth", renderContext))
             {
-                Utilities.SetRenderTarget(renderContext, m_CameraDepthBufferRT);
+                Utilities.SetRenderTarget(renderContext, m_CameraDepthStencilBufferRT);
                 RenderOpaqueRenderList(cull, camera, renderContext, "ForwardOnlyOpaqueDepthOnly");
             }
         }
             using (new Utilities.ProfilingSample("DebugView Material Mode Pass", renderContext))
             // Render Opaque forward
             {
-                Utilities.SetRenderTarget(renderContext, m_CameraColorBufferRT, m_CameraDepthBufferRT, Utilities.kClearAll, Color.black);
+                Utilities.SetRenderTarget(renderContext, m_CameraColorBufferRT, m_CameraDepthStencilBufferRT, Utilities.kClearAll, Color.black);
 
                 Shader.SetGlobalInt("_DebugViewMaterial", (int)debugParameters.debugViewMaterial);
 
 
         void RenderDeferredLighting(HDCamera hdCamera, ScriptableRenderContext renderContext)
         {
-            if (debugParameters.ShouldUseForwardRenderingOnly())
+            if (debugParameters.ShouldUseForwardRenderingOnly() || m_LightLoop == null)
-            if (m_LightLoop != null)
-                m_LightLoop.RenderDeferredLighting(hdCamera, renderContext, m_CameraColorBuffer);
+
+            RenderTargetIdentifier[] colorRTs = { m_CameraColorBufferRT, m_CameraSubsurfaceBufferRT };
+
+            // Output split lighting for materials tagged with the SSS stencil bit.
+            m_LightLoop.RenderDeferredLighting(hdCamera, renderContext, colorRTs, m_CameraStencilBufferRT, true);
+
+            // Output combined lighting for all the other materials.
+            m_LightLoop.RenderDeferredLighting(hdCamera, renderContext, colorRTs, m_CameraStencilBufferRT, false);
+        }
+
+        // Combines specular lighting and diffuse lighting with subsurface scattering.
+        void CombineSubsurfaceScattering(HDCamera hdCamera, ScriptableRenderContext context, SubsurfaceScatteringParameters sssParameters)
+        {
+            // Currently, forward-rendered objects do not output split lighting required for the SSS pass.
+            if (debugParameters.ShouldUseForwardRenderingOnly()) return;
+
+            // Assume that the height of the projection window is 2 meters.
+            float distanceToProjectionWindow = 1.0f / Mathf.Tan(0.5f * Mathf.Deg2Rad * hdCamera.camera.fieldOfView);
+            m_CombineSubsurfaceScattering.SetFloat("_DistToProjWindow", distanceToProjectionWindow);
+            m_CombineSubsurfaceScattering.SetFloat("_BilateralScale", 0.05f * sssParameters.bilateralScale);
+            // TODO: use user-defined values for '_ProfileID' and '_FilterRadius.'
+            m_CombineSubsurfaceScattering.SetVectorArray("_FilterKernel", sssParameters.profiles[0].filterKernel);
+            m_CombineSubsurfaceScattering.SetFloat("_FilterRadius", 3.0f);
+
+            MaterialPropertyBlock properties = new MaterialPropertyBlock();
+
+            var cmd = new CommandBuffer() { name = "Combine Subsurface Scattering" };
+
+            // Perform the vertical SSS filtering pass.
+            properties.SetFloat("_DstBlend", (float)BlendMode.Zero); // TODO: this doesn't work for some reason...
+            properties.SetFloat("_FilterHorizontal", 0);
+            cmd.SetGlobalTexture("_IrradianceSource", m_CameraSubsurfaceBufferRT);
+            Utilities.DrawFullscreen(cmd, m_CombineSubsurfaceScattering, hdCamera,
+                                     m_CameraFilteringBufferRT, m_CameraStencilBufferRT, properties);
+
+            // Perform the horizontal SSS filtering pass, and combine diffuse and specular lighting.
+            properties.SetFloat("_DstBlend", (float)BlendMode.One);  // TODO: this doesn't work for some reason...
+            properties.SetFloat("_FilterHorizontal", 1);
+            cmd.SetGlobalTexture("_IrradianceSource", m_CameraFilteringBufferRT);
+            Utilities.DrawFullscreen(cmd, m_CombineSubsurfaceScattering, hdCamera,
+                                     m_CameraColorBufferRT, m_CameraStencilBufferRT, properties);
+
+            context.ExecuteCommandBuffer(cmd);
+            cmd.Dispose();
         }
 
         void UpdateSkyEnvironment(HDCamera hdCamera, ScriptableRenderContext renderContext)
 
         void RenderSky(HDCamera hdCamera, ScriptableRenderContext renderContext)
         {
-            m_SkyManager.RenderSky(hdCamera, m_LightLoop == null ? null : m_LightLoop.GetCurrentSunLight(), m_CameraColorBufferRT, m_CameraDepthBufferRT, renderContext);
+            m_SkyManager.RenderSky(hdCamera, m_LightLoop == null ? null : m_LightLoop.GetCurrentSunLight(), m_CameraColorBufferRT, m_CameraDepthStencilBufferRT, renderContext);
-        
+
         void RenderForward(CullResults cullResults, Camera camera, ScriptableRenderContext renderContext, bool renderOpaque)
         {
             // TODO: Currently we can't render opaque object forward when deferred is enabled
 
             using (new Utilities.ProfilingSample("Forward Pass", renderContext))
             {
-                Utilities.SetRenderTarget(renderContext, m_CameraColorBufferRT, m_CameraDepthBufferRT);
+                Utilities.SetRenderTarget(renderContext, m_CameraColorBufferRT, m_CameraDepthStencilBufferRT);
 
                 if (m_LightLoop != null)
                     m_LightLoop.RenderForward(camera, renderContext, renderOpaque);
         {
             using (new Utilities.ProfilingSample("Forward Only Pass", renderContext))
             {
-                Utilities.SetRenderTarget(renderContext, m_CameraColorBufferRT, m_CameraDepthBufferRT);
+                Utilities.SetRenderTarget(renderContext, m_CameraColorBufferRT, m_CameraDepthStencilBufferRT);
 
                 if (m_LightLoop != null)
                     m_LightLoop.RenderForward(camera, renderContext, true);
 
                 var cmd = new CommandBuffer { name = "" };
                 cmd.GetTemporaryRT(m_VelocityBuffer, w, h, 0, FilterMode.Point, Builtin.RenderLoop.GetVelocityBufferFormat(), Builtin.RenderLoop.GetVelocityBufferReadWrite());
-                cmd.SetRenderTarget(m_VelocityBufferRT, m_CameraDepthBufferRT);
+                cmd.SetRenderTarget(m_VelocityBufferRT, m_CameraDepthStencilBufferRT);
                 renderContext.ExecuteCommandBuffer(cmd);
                 cmd.Dispose();
 
 
                 var cmd = new CommandBuffer { name = "" };
                 cmd.GetTemporaryRT(m_DistortionBuffer, w, h, 0, FilterMode.Point, Builtin.RenderLoop.GetDistortionBufferFormat(), Builtin.RenderLoop.GetDistortionBufferReadWrite());
-                cmd.SetRenderTarget(m_DistortionBufferRT, m_CameraDepthBufferRT);
+                cmd.SetRenderTarget(m_DistortionBufferRT, m_CameraDepthStencilBufferRT);
                 cmd.ClearRenderTarget(false, true, Color.black); // TODO: can we avoid this clear for performance ?
                 renderContext.ExecuteCommandBuffer(cmd);
                 cmd.Dispose();
             }
         }
 
+        void NextOverlayCoord(ref float x, ref float y, float overlaySize, float width)
+        {
+            x += overlaySize;
+            // Go to next line if it goes outside the screen.
+            if (x + overlaySize > width)
+            {
+                x = 0;
+                y -= overlaySize;
+            }
+        }
+
+        void RenderDebugOverlay(Camera camera, ScriptableRenderContext renderContext)
+        {
+            CommandBuffer debugCB = new CommandBuffer();
+            debugCB.name = "Debug Overlay";
+
+            float x = 0;
+            float overlayRatio = globalDebugParameters.debugOverlayRatio;
+            float overlaySize = Math.Min(camera.pixelHeight, camera.pixelWidth) * overlayRatio;
+            float y = camera.pixelHeight - overlaySize;
+
+            MaterialPropertyBlock propertyBlock = new MaterialPropertyBlock();
+
+            ShadowDebugParameters shadowDebug = globalDebugParameters.shadowDebugParameters;
+
+            if (shadowDebug.visualizationMode != ShadowDebugMode.None)
+            {
+                if (shadowDebug.visualizationMode == ShadowDebugMode.VisualizeShadowMap)
+                {
+                    uint visualizeShadowIndex = Math.Min(shadowDebug.visualizeShadowMapIndex, (uint)(GetCurrentShadowCount() - 1));
+                    ShadowLight shadowLight = m_ShadowsResult.shadowLights[visualizeShadowIndex];
+                    for (int slice = 0; slice < shadowLight.shadowSliceCount; ++slice)
+                    {
+                        ShadowSliceData sliceData = m_ShadowsResult.shadowSlices[shadowLight.shadowSliceIndex + slice];
+
+                        Vector4 texcoordScaleBias = new Vector4((float)sliceData.shadowResolution / m_Owner.shadowSettings.shadowAtlasWidth,
+                                                                (float)sliceData.shadowResolution / m_Owner.shadowSettings.shadowAtlasHeight,
+                                                                (float)sliceData.atlasX / m_Owner.shadowSettings.shadowAtlasWidth,
+                                                                (float)sliceData.atlasY / m_Owner.shadowSettings.shadowAtlasHeight);
+
+                        propertyBlock.SetVector("_TextureScaleBias", texcoordScaleBias);
+
+                        debugCB.SetViewport(new Rect(x, y, overlaySize, overlaySize));
+                        debugCB.DrawProcedural(Matrix4x4.identity, m_DebugDisplayShadowMap, 0, MeshTopology.Triangles, 3, 1, propertyBlock);
+
+                        NextOverlayCoord(ref x, ref y, overlaySize, camera.pixelWidth);
+                    }
+                }
+                else if (shadowDebug.visualizationMode == ShadowDebugMode.VisualizeAtlas)
+                {
+                    propertyBlock.SetVector("_TextureScaleBias", new Vector4(1.0f, 1.0f, 0.0f, 0.0f));
+
+                    debugCB.SetViewport(new Rect(x, y, overlaySize, overlaySize));
+                    debugCB.DrawProcedural(Matrix4x4.identity, m_DebugDisplayShadowMap, 0, MeshTopology.Triangles, 3, 1, propertyBlock);
+
+                    NextOverlayCoord(ref x, ref y, overlaySize, camera.pixelWidth);
+                }
+            }
+
+            renderContext.ExecuteCommandBuffer(debugCB);
+        }
+
         // Function to prepare light structure for GPU lighting
         void PrepareLightsForGPU(ShadowSettings shadowSettings, CullResults cullResults, Camera camera, ref ShadowOutput shadowOutput)
         {
                     int w = camera.pixelWidth;
                     int h = camera.pixelHeight;
 
-                    cmd.GetTemporaryRT(m_CameraColorBuffer, w, h, 0, FilterMode.Point, RenderTextureFormat.ARGBHalf, RenderTextureReadWrite.Linear, 1, true); // Enable UAV
-                    cmd.GetTemporaryRT(m_CameraDepthBuffer, w, h, 24, FilterMode.Point, RenderTextureFormat.Depth);
+                    cmd.GetTemporaryRT(m_CameraColorBuffer,        w, h,  0, FilterMode.Point, RenderTextureFormat.ARGBHalf,       RenderTextureReadWrite.Linear, 1, true); // Enable UAV
+                    cmd.GetTemporaryRT(m_CameraSubsurfaceBuffer,   w, h,  0, FilterMode.Point, RenderTextureFormat.RGB111110Float, RenderTextureReadWrite.Linear, 1, true); // Enable UAV
+                    cmd.GetTemporaryRT(m_CameraFilteringBuffer,    w, h,  0, FilterMode.Point, RenderTextureFormat.RGB111110Float, RenderTextureReadWrite.Linear, 1, true); // Enable UAV
+                    cmd.GetTemporaryRT(m_CameraDepthStencilBuffer, w, h, 24, FilterMode.Point, RenderTextureFormat.Depth);
+                    cmd.GetTemporaryRT(m_CameraStencilBuffer,      w, h, 24, FilterMode.Point, RenderTextureFormat.Depth);
+
-        {
+                    {
-            }
-            renderContext.ExecuteCommandBuffer(cmd);
-            cmd.Dispose();
+                    }
+
+                    renderContext.ExecuteCommandBuffer(cmd);
+                    cmd.Dispose();
+
+                    Utilities.SetRenderTarget(renderContext, m_CameraColorBufferRT, m_CameraDepthStencilBufferRT, ClearFlag.ClearDepth);
+                }
-                    Utilities.SetRenderTarget(renderContext, m_CameraColorBufferRT, m_CameraDepthBufferRT, ClearFlag.ClearDepth);
-        }
+                // Clear the diffuse SSS lighting target
+                using (new Utilities.ProfilingSample("Clear SSS diffuse target", renderContext))
+                {
+                    Utilities.SetRenderTarget(renderContext, m_CameraSubsurfaceBufferRT, m_CameraDepthStencilBufferRT, ClearFlag.ClearColor, Color.black);
+                }
+
+                // Clear the SSS filtering target
+                using (new Utilities.ProfilingSample("Clear SSS filtering target", renderContext))
+                {
+                    Utilities.SetRenderTarget(renderContext, m_CameraFilteringBuffer, m_CameraDepthStencilBufferRT, ClearFlag.ClearColor, Color.black);
+                }
-                // Clear HDR target
+                // Clear the HDR target
-        {
-                    Utilities.SetRenderTarget(renderContext, m_CameraColorBufferRT, m_CameraDepthBufferRT, ClearFlag.ClearColor, Color.black);
-            }
+                {
+                    Utilities.SetRenderTarget(renderContext, m_CameraColorBufferRT, m_CameraDepthStencilBufferRT, ClearFlag.ClearColor, Color.black);
+                }
-            {
-                    using (new Utilities.ProfilingSample("Clear GBuffer", renderContext))
-                        Utilities.SetRenderTarget(renderContext, m_gbufferManager.GetGBuffers(), m_CameraDepthBufferRT, ClearFlag.ClearColor, Color.black);
-                }
+                    using (new Utilities.ProfilingSample("Clear GBuffer", renderContext))
+                    {
+                        Utilities.SetRenderTarget(renderContext, m_gbufferManager.GetGBuffers(), m_CameraDepthStencilBufferRT, ClearFlag.ClearColor, Color.black);
+                }
                 // END TEMP
             }
         }

Assets/ScriptableRenderLoop/HDRenderPipeline/Lighting/LightLoop.cs

+using UnityEngine;
 using UnityEngine.Rendering;
 
 namespace UnityEngine.Experimental.Rendering.HDPipeline
 
         public virtual void PushGlobalParams(Camera camera, ScriptableRenderContext loop) {}
 
-        public virtual void RenderDeferredLighting(HDCamera hdCamera, ScriptableRenderContext renderContext, RenderTargetIdentifier cameraColorBufferRT) {}
+        public virtual void RenderDeferredLighting(HDCamera hdCamera, ScriptableRenderContext renderContext,
+                                                   RenderTargetIdentifier[] colorBuffers, RenderTargetIdentifier stencilBuffer,
+                                                   bool outputSplitLighting) {}
 
         public virtual void RenderForward(Camera camera, ScriptableRenderContext renderContext, bool renderOpaque) {}
 

Assets/ScriptableRenderLoop/HDRenderPipeline/Lighting/Resources/Deferred.shader

         // We need to be able to control the blend mode for deferred shader in case we do multiple pass
         _SrcBlend("", Float) = 1
         _DstBlend("", Float) = 1
+
+        _StencilRef("_StencilRef", Int) = 0
-
+            Stencil
+            {
+                Ref  [_StencilRef]
+                Comp Equal
+                Pass Keep
+            }
+
-            Blend Off
-            Blend[_SrcBlend][_DstBlend]
+            ZTest  Always
+            Blend [_SrcBlend][_DstBlend]
-            #pragma only_renderers d3d11 ps4 metal // TEMP: unitl we go futher in dev
+            #pragma only_renderers d3d11 ps4 metal // TEMP: until we go further in dev
 
             #pragma vertex Vert
             #pragma fragment Frag
             #pragma multi_compile LIGHTLOOP_TILE_DIRECT LIGHTLOOP_TILE_INDIRECT LIGHTLOOP_TILE_ALL
             #pragma multi_compile USE_FPTL_LIGHTLIST USE_CLUSTERED_LIGHTLIST
 
+            // Split lighting is utilized during the SSS pass.
+            #pragma multi_compile _ OUTPUT_SPLIT_LIGHTING
+
             //-------------------------------------------------------------------------------------
             // Include
             //-------------------------------------------------------------------------------------
             // Note: We have fix as guidelines that we have only one deferred material (with control of GBuffer enabled). Mean a users that add a new
-            // deferred material must replace the old one here. If in the future we want to support multiple layout (cause a lot of consistency problem), 
+            // deferred material must replace the old one here. If in the future we want to support multiple layout (cause a lot of consistency problem),
- 
+
- 
- 			TEXTURE2D(_CameraDepthTexture);
+
+			TEXTURE2D_FLOAT(_CameraDepthTexture);
-                float3 positionOS : POSITION;
+                uint vertexID : SV_VertexID;
             };
 
             struct Varyings
 
+            struct Outputs
+            {
+            #ifdef OUTPUT_SPLIT_LIGHTING
+            	float4 specularLighting : SV_Target0;
+            	float3 diffuseLighting  : SV_Target1;
+            #else
+                float4 combinedLighting : SV_Target0;
+            #endif
+            };
+
-                // TODO: implement SV_vertexID full screen quad
-                // Lights are draw as one fullscreen quad
-                float3 positionWS = TransformObjectToWorld(input.positionOS);
-                output.positionCS = TransformWorldToHClip(positionWS);
-
+			    output.positionCS = GetFullscreenTriangleVertexPosition(input.vertexID);
-            float4 Frag(Varyings input) : SV_Target
+            Outputs Frag(Varyings input)
             {
                 // input.positionCS is SV_Position
                 PositionInputs posInput = GetPositionInput(input.positionCS.xy, _ScreenSize.zw);
                 float3 specularLighting;
                 LightLoop(V, posInput, preLightData, bsdfData, bakeDiffuseLighting, diffuseLighting, specularLighting);
 
-                return float4(diffuseLighting + specularLighting, 1.0);
+                Outputs outputs;
+            #ifdef OUTPUT_SPLIT_LIGHTING
+                outputs.specularLighting = float4(specularLighting, 1.0);
+                outputs.diffuseLighting  = diffuseLighting;
+            #else
+                outputs.combinedLighting = float4(diffuseLighting + specularLighting, 1.0);
+            #endif
+                return outputs;
             }
 
         ENDHLSL

Assets/ScriptableRenderLoop/HDRenderPipeline/Lighting/TileLightLoopProducer.cs

 #if UNITY_EDITOR
         public const string TilePassProducer = "Assets/ScriptableRenderLoop/HDRenderPipeline/Lighting/TilePass/TilePassProducer.asset";
 
-        [UnityEditor.MenuItem("RenderPipeline/Create TileLightLoopProducer")]
+        [UnityEditor.MenuItem("HDRenderPipeline/TilePass/Create TileLightLoopProducer")]
         static void CreateTileLightLoopProducer()
         {
             var instance = CreateInstance<TileLightLoopProducer>();

Assets/ScriptableRenderLoop/HDRenderPipeline/Lighting/TilePass/LightingConvexHullUtils.hlsl

 #if 1
 	float3 maxZdir = float3(-sphCen.z*sphCen.x, -sphCen.z*sphCen.y, sphCen.x*sphCen.x + sphCen.y*sphCen.y);		// cross(sphCen,cross(Zaxis,sphCen))
 	float len = length(maxZdir);
-	float scalarProj = len>0.0001 ? (maxZdir.z/len) : len;	// since len>=(maxZdir.z/len) we can use len as an approximate value when len<=epsilon
+	float scalarProj = len>0.0001 ? (maxZdir.z/len) : len;	// if len<=0.0001 then either |sphCen|<sphRadius or sphCen is very closely aligned with Z axis in which case little to no additional offs needed.
 	float offs = scalarProj*sphRadiusIn;
 #else
 	float offs = sphRadiusIn;		// more false positives due to larger radius but works too

Assets/ScriptableRenderLoop/HDRenderPipeline/Lighting/TilePass/Resources/shadeopaque.compute

 #pragma kernel ShadeOpaque_Fptl				SHADE_OPAQUE_ENTRY=ShadeOpaque_Fptl				USE_FPTL_LIGHTLIST=1
 #pragma kernel ShadeOpaque_Clustered		SHADE_OPAQUE_ENTRY=ShadeOpaque_Clustered		USE_CLUSTERED_LIGHTLIST=1
 
+// Split lighting is required for the SSS pass.
+// Not currently possible since we need to access the stencil buffer from the compute shader.
+// #pragma multi_compile _ OUTPUT_SPLIT_LIGHTING
 
 #define LIGHTLOOP_TILE_PASS 1
 #define LIGHTLOOP_TILE_DIRECT 1
-
 
 //-------------------------------------------------------------------------------------
 // Include
 
 DECLARE_GBUFFER_TEXTURE(_GBufferTexture);
 
-TEXTURE2D(_CameraDepthTexture);
+TEXTURE2D_FLOAT(_CameraDepthTexture);
-RWTexture2D<float4> uavOutput;
+#ifdef OUTPUT_SPLIT_LIGHTING
+    RWTexture2D<float4> specularLightingUAV;
+    RWTexture2D<float3> diffuseLightingUAV;
+#else
+    RWTexture2D<float4> combinedLightingUAV;
+#endif
 
 [numthreads(TILE_SIZE, TILE_SIZE, 1)]
 void SHADE_OPAQUE_ENTRY(uint2 dispatchThreadId : SV_DispatchThreadID, uint2 groupId : SV_GroupID)
     float3 specularLighting;
     LightLoop(V, posInput, preLightData, bsdfData, bakeDiffuseLighting, diffuseLighting, specularLighting);
 
-    uavOutput[pixelCoord] = float4(diffuseLighting + specularLighting, 1.0);
+#ifdef OUTPUT_SPLIT_LIGHTING
+    specularLightingUAV[pixelCoord] = float4(specularLighting, 1.0);
+    diffuseLightingUAV[pixelCoord]  = diffuseLighting;
+#else
+    combinedLightingUAV[pixelCoord] = float4(diffuseLighting + specularLighting, 1.0);
+#endif
 }
 

Assets/ScriptableRenderLoop/HDRenderPipeline/Lighting/TilePass/TilePass.cs

                         s_DefaultAdditionalLightDataGameObject = new GameObject("Default Light Data");
                         s_DefaultAdditionalLightDataGameObject.hideFlags = HideFlags.HideAndDontSave;
                         s_DefaultAdditionalLightData = s_DefaultAdditionalLightDataGameObject.AddComponent<AdditionalLightData>();
+                        s_DefaultAdditionalLightDataGameObject.SetActive(false);
+            Material m_DeferredDirectMaterialSRT   = null;
+            Material m_DeferredDirectMaterialMRT   = null;
+            Material m_DeferredIndirectMaterialSRT = null;
+            Material m_DeferredIndirectMaterialMRT = null;
+            Material m_DeferredAllMaterialSRT      = null;
+            Material m_DeferredAllMaterialMRT      = null;
-            Material m_DeferredDirectMaterial = null;
-            Material m_DeferredIndirectMaterial = null;
-            Material m_DeferredAllMaterial = null;
-            Material m_DebugViewTilesMaterial = null;
+            Material m_DebugViewTilesMaterial      = null;
-            Material m_SingleDeferredMaterial = null;
+            Material m_SingleDeferredMaterialSRT   = null;
+            Material m_SingleDeferredMaterialMRT   = null;
-
 
             int GetNumTileX(Camera camera)
             {
 
                 s_LightList = null;
 
-                m_DeferredDirectMaterial = Utilities.CreateEngineMaterial("Hidden/HDRenderPipeline/Deferred");
-                m_DeferredDirectMaterial.EnableKeyword("LIGHTLOOP_TILE_PASS");
-                m_DeferredDirectMaterial.EnableKeyword("LIGHTLOOP_TILE_DIRECT");
-                m_DeferredDirectMaterial.DisableKeyword("LIGHTLOOP_TILE_INDIRECT");
-                m_DeferredDirectMaterial.DisableKeyword("LIGHTLOOP_TILE_ALL");
+                string[] tileKeywords = {"LIGHTLOOP_TILE_DIRECT", "LIGHTLOOP_TILE_INDIRECT", "LIGHTLOOP_TILE_ALL"};
-                m_DeferredIndirectMaterial = Utilities.CreateEngineMaterial("Hidden/HDRenderPipeline/Deferred");
-                m_DeferredIndirectMaterial.EnableKeyword("LIGHTLOOP_TILE_PASS");
-                m_DeferredIndirectMaterial.DisableKeyword("LIGHTLOOP_TILE_DIRECT");
-                m_DeferredIndirectMaterial.EnableKeyword("LIGHTLOOP_TILE_INDIRECT");
-                m_DeferredIndirectMaterial.DisableKeyword("LIGHTLOOP_TILE_ALL");
+                m_DeferredDirectMaterialSRT = Utilities.CreateEngineMaterial("Hidden/HDRenderPipeline/Deferred");
+                Utilities.SelectKeyword(m_DeferredDirectMaterialSRT, tileKeywords, 0);
+                m_DeferredDirectMaterialSRT.EnableKeyword("LIGHTLOOP_TILE_PASS");
+                m_DeferredDirectMaterialSRT.DisableKeyword("OUTPUT_SPLIT_LIGHTING");
+                m_DeferredDirectMaterialSRT.SetInt("_StencilRef", (int)StencilBits.None);
+                m_DeferredDirectMaterialSRT.SetInt("_SrcBlend", (int)BlendMode.One);
+                m_DeferredDirectMaterialSRT.SetInt("_DstBlend", (int)BlendMode.Zero);
-                m_DeferredAllMaterial = Utilities.CreateEngineMaterial("Hidden/HDRenderPipeline/Deferred");
-                m_DeferredAllMaterial.EnableKeyword("LIGHTLOOP_TILE_PASS");
-                m_DeferredAllMaterial.DisableKeyword("LIGHTLOOP_TILE_DIRECT");
-                m_DeferredAllMaterial.DisableKeyword("LIGHTLOOP_TILE_INDIRECT");
-                m_DeferredAllMaterial.EnableKeyword("LIGHTLOOP_TILE_ALL");
+                m_DeferredDirectMaterialMRT = Utilities.CreateEngineMaterial("Hidden/HDRenderPipeline/Deferred");
+                Utilities.SelectKeyword(m_DeferredDirectMaterialMRT, tileKeywords, 0);
+                m_DeferredDirectMaterialMRT.EnableKeyword("LIGHTLOOP_TILE_PASS");
+                m_DeferredDirectMaterialMRT.EnableKeyword("OUTPUT_SPLIT_LIGHTING");
+                m_DeferredDirectMaterialMRT.SetInt("_StencilRef", (int)StencilBits.SSS);
+                m_DeferredDirectMaterialMRT.SetInt("_SrcBlend", (int)BlendMode.One);
+                m_DeferredDirectMaterialMRT.SetInt("_DstBlend", (int)BlendMode.Zero);
+
+                m_DeferredIndirectMaterialSRT = Utilities.CreateEngineMaterial("Hidden/HDRenderPipeline/Deferred");
+                Utilities.SelectKeyword(m_DeferredIndirectMaterialSRT, tileKeywords, 1);
+                m_DeferredIndirectMaterialSRT.EnableKeyword("LIGHTLOOP_TILE_PASS");
+                m_DeferredIndirectMaterialSRT.DisableKeyword("OUTPUT_SPLIT_LIGHTING");
+                m_DeferredIndirectMaterialSRT.SetInt("_StencilRef", (int)StencilBits.None);
+                m_DeferredIndirectMaterialSRT.SetInt("_SrcBlend", (int)BlendMode.One);
+                m_DeferredIndirectMaterialSRT.SetInt("_DstBlend", (int)BlendMode.One); // Additive
+
+                m_DeferredIndirectMaterialMRT = Utilities.CreateEngineMaterial("Hidden/HDRenderPipeline/Deferred");
+                Utilities.SelectKeyword(m_DeferredIndirectMaterialMRT, tileKeywords, 1);
+                m_DeferredIndirectMaterialMRT.EnableKeyword("LIGHTLOOP_TILE_PASS");
+                m_DeferredIndirectMaterialMRT.EnableKeyword("OUTPUT_SPLIT_LIGHTING");
+                m_DeferredIndirectMaterialMRT.SetInt("_StencilRef", (int)StencilBits.SSS);
+                m_DeferredIndirectMaterialMRT.SetInt("_SrcBlend", (int)BlendMode.One);
+                m_DeferredIndirectMaterialMRT.SetInt("_DstBlend", (int)BlendMode.One); // Additive
+
+                m_DeferredAllMaterialSRT = Utilities.CreateEngineMaterial("Hidden/HDRenderPipeline/Deferred");
+                Utilities.SelectKeyword(m_DeferredAllMaterialSRT, tileKeywords, 2);
+                m_DeferredAllMaterialSRT.EnableKeyword("LIGHTLOOP_TILE_PASS");
+                m_DeferredAllMaterialSRT.DisableKeyword("OUTPUT_SPLIT_LIGHTING");
+                m_DeferredAllMaterialSRT.SetInt("_StencilRef", (int)StencilBits.None);
+                m_DeferredAllMaterialSRT.SetInt("_SrcBlend", (int)BlendMode.One);
+                m_DeferredAllMaterialSRT.SetInt("_DstBlend", (int)BlendMode.Zero);
+
+                m_DeferredAllMaterialMRT = Utilities.CreateEngineMaterial("Hidden/HDRenderPipeline/Deferred");
+                Utilities.SelectKeyword(m_DeferredAllMaterialMRT, tileKeywords, 2);
+                m_DeferredAllMaterialMRT.EnableKeyword("LIGHTLOOP_TILE_PASS");
+                m_DeferredAllMaterialMRT.EnableKeyword("OUTPUT_SPLIT_LIGHTING");
+                m_DeferredAllMaterialMRT.SetInt("_StencilRef", (int)StencilBits.SSS);
+                m_DeferredAllMaterialMRT.SetInt("_SrcBlend", (int)BlendMode.One);
+                m_DeferredAllMaterialMRT.SetInt("_DstBlend", (int)BlendMode.Zero);
-                m_SingleDeferredMaterial = Utilities.CreateEngineMaterial("Hidden/HDRenderPipeline/Deferred");
-                m_SingleDeferredMaterial.EnableKeyword("LIGHTLOOP_SINGLE_PASS");
+                m_SingleDeferredMaterialSRT = Utilities.CreateEngineMaterial("Hidden/HDRenderPipeline/Deferred");
+                m_SingleDeferredMaterialSRT.EnableKeyword("LIGHTLOOP_SINGLE_PASS");
+                m_SingleDeferredMaterialSRT.DisableKeyword("OUTPUT_SPLIT_LIGHTING");
+                m_SingleDeferredMaterialSRT.SetInt("_StencilRef", (int)StencilBits.None);
+                m_SingleDeferredMaterialSRT.SetInt("_SrcBlend", (int)BlendMode.One);
+                m_SingleDeferredMaterialSRT.SetInt("_DstBlend", (int)BlendMode.Zero);
+
+                m_SingleDeferredMaterialMRT = Utilities.CreateEngineMaterial("Hidden/HDRenderPipeline/Deferred");
+                m_SingleDeferredMaterialMRT.EnableKeyword("LIGHTLOOP_SINGLE_PASS");
+                m_SingleDeferredMaterialMRT.EnableKeyword("OUTPUT_SPLIT_LIGHTING");
+                m_SingleDeferredMaterialMRT.SetInt("_StencilRef", (int)StencilBits.SSS);
+                m_SingleDeferredMaterialMRT.SetInt("_SrcBlend", (int)BlendMode.One);
+                m_SingleDeferredMaterialMRT.SetInt("_DstBlend", (int)BlendMode.Zero);
 
                 m_DefaultTexture2DArray = new Texture2DArray(1, 1, 1, TextureFormat.ARGB32, false);
                 m_DefaultTexture2DArray.SetPixels32(new Color32[1] { new Color32(128, 128, 128, 128) }, 0);
                 // enableClustered
                 Utilities.SafeRelease(s_GlobalLightListAtomic);
 
-                Utilities.Destroy(m_DeferredDirectMaterial);
-                Utilities.Destroy(m_DeferredIndirectMaterial);
-                Utilities.Destroy(m_DeferredAllMaterial);
+                Utilities.Destroy(m_DeferredDirectMaterialSRT);
+                Utilities.Destroy(m_DeferredDirectMaterialMRT);
+                Utilities.Destroy(m_DeferredIndirectMaterialSRT);
+                Utilities.Destroy(m_DeferredIndirectMaterialMRT);
+                Utilities.Destroy(m_DeferredAllMaterialSRT);
+                Utilities.Destroy(m_DeferredAllMaterialMRT);
+
-                Utilities.Destroy(m_SingleDeferredMaterial);
+                Utilities.Destroy(m_SingleDeferredMaterialSRT);
+                Utilities.Destroy(m_SingleDeferredMaterialMRT);
 
                 Utilities.Destroy(s_DefaultAdditionalLightDataGameObject);
                 s_DefaultAdditionalLightDataGameObject = null;
                 var cmd = new CommandBuffer() { name = "" };
 
                 // generate screen-space AABBs (used for both fptl and clustered).
+                if (m_lightCount != 0)
                 {
                     temp.SetRow(0, new Vector4(1.0f, 0.0f, 0.0f, 0.0f));
                     temp.SetRow(1, new Vector4(0.0f, 1.0f, 0.0f, 0.0f));
             }
 #endif
 
-            public override void RenderDeferredLighting(HDCamera hdCamera, ScriptableRenderContext renderContext, RenderTargetIdentifier cameraColorBufferRT)
+            public override void RenderDeferredLighting(HDCamera hdCamera, ScriptableRenderContext renderContext,
+                                                        RenderTargetIdentifier[] colorBuffers, RenderTargetIdentifier stencilBuffer,
+                                                        bool outputSplitLighting)
             {
                 var bUseClusteredForDeferred = !usingFptl;
 
                     if (m_PassSettings.disableTileAndCluster)
                     {
                         // This is a debug brute force renderer to debug tile/cluster which render all the lights
-                        Utilities.SetupMaterialHDCamera(hdCamera, m_SingleDeferredMaterial);
-                        m_SingleDeferredMaterial.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
-                        m_SingleDeferredMaterial.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.Zero);
-
-                        cmd.Blit(null, cameraColorBufferRT, m_SingleDeferredMaterial, 0);
+                        if (outputSplitLighting)
+                        {
+                            Utilities.DrawFullscreen(cmd, m_SingleDeferredMaterialMRT, hdCamera, colorBuffers, stencilBuffer);
+                        }
+                        else
+                        {
+                            Utilities.DrawFullscreen(cmd, m_SingleDeferredMaterialSRT, hdCamera, colorBuffers[0], stencilBuffer);
+                        }
                     }
                     else
                     {
                             cmd.SetComputeTextureParam(shadeOpaqueShader, kernel, "_IESArray", IESArrayTexture ? IESArrayTexture : m_DefaultTexture2DArray);
                             cmd.SetComputeTextureParam(shadeOpaqueShader, kernel, "_SkyTexture", skyTexture ? skyTexture : m_DefaultTexture2DArray);
 
-                            cmd.SetComputeTextureParam(shadeOpaqueShader, kernel, "uavOutput", cameraColorBufferRT);
+                            // Since we need the stencil test, the compute path does not currently support SSS.
+                            cmd.SetComputeTextureParam(shadeOpaqueShader, kernel, "combinedLightingUAV", colorBuffers[0]);
                             cmd.DispatchCompute(shadeOpaqueShader, kernel, numTilesX, numTilesY, 1);
                         }
                         else
                             {
-                                Utilities.SetupMaterialHDCamera(hdCamera, m_DeferredDirectMaterial);
-                                m_DeferredDirectMaterial.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
-                                m_DeferredDirectMaterial.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.Zero);
-                                m_DeferredDirectMaterial.EnableKeyword(bUseClusteredForDeferred ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");
-                                m_DeferredDirectMaterial.DisableKeyword(!bUseClusteredForDeferred ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");
+                                if (outputSplitLighting)
+                                {
+                                    Utilities.SelectKeyword(m_DeferredDirectMaterialMRT, "USE_CLUSTERED_LIGHTLIST", "USE_FPTL_LIGHTLIST", bUseClusteredForDeferred);
+                                    Utilities.DrawFullscreen(cmd, m_DeferredDirectMaterialMRT, hdCamera, colorBuffers, stencilBuffer);
-                                Utilities.SetupMaterialHDCamera(hdCamera, m_DeferredIndirectMaterial);
-                                m_DeferredIndirectMaterial.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
-                                m_DeferredIndirectMaterial.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.One); // Additive
-                                m_DeferredIndirectMaterial.EnableKeyword(bUseClusteredForDeferred ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");
-                                m_DeferredIndirectMaterial.DisableKeyword(!bUseClusteredForDeferred ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");
+                                    Utilities.SelectKeyword(m_DeferredIndirectMaterialMRT, "USE_CLUSTERED_LIGHTLIST", "USE_FPTL_LIGHTLIST", bUseClusteredForDeferred);
+                                    Utilities.DrawFullscreen(cmd, m_DeferredIndirectMaterialMRT, hdCamera, colorBuffers, stencilBuffer);
+                                }
+                                else
+                                {
+                                    Utilities.SelectKeyword(m_DeferredDirectMaterialSRT, "USE_CLUSTERED_LIGHTLIST", "USE_FPTL_LIGHTLIST", bUseClusteredForDeferred);
+                                    Utilities.DrawFullscreen(cmd, m_DeferredDirectMaterialSRT, hdCamera, colorBuffers[0], stencilBuffer);
-                                cmd.Blit(null, cameraColorBufferRT, m_DeferredDirectMaterial, 0);
-                                cmd.Blit(null, cameraColorBufferRT, m_DeferredIndirectMaterial, 0);
+                                    Utilities.SelectKeyword(m_DeferredIndirectMaterialSRT, "USE_CLUSTERED_LIGHTLIST", "USE_FPTL_LIGHTLIST", bUseClusteredForDeferred);
+                                    Utilities.DrawFullscreen(cmd, m_DeferredIndirectMaterialSRT, hdCamera, colorBuffers[0], stencilBuffer);
+                                }
-                                Utilities.SetupMaterialHDCamera(hdCamera, m_DeferredAllMaterial);
-                                m_DeferredAllMaterial.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
-                                m_DeferredAllMaterial.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.Zero);
-                                m_DeferredAllMaterial.EnableKeyword(bUseClusteredForDeferred ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");
-                                m_DeferredAllMaterial.DisableKeyword(!bUseClusteredForDeferred ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");
-
-                                cmd.Blit(null, cameraColorBufferRT, m_DeferredAllMaterial, 0);
+                                if (outputSplitLighting)
+                                {
+                                    Utilities.SelectKeyword(m_DeferredAllMaterialMRT, "USE_CLUSTERED_LIGHTLIST", "USE_FPTL_LIGHTLIST", bUseClusteredForDeferred);
+                                    Utilities.DrawFullscreen(cmd, m_DeferredAllMaterialMRT, hdCamera, colorBuffers, stencilBuffer);
+                                }
+                                else
+                                {
+                                    Utilities.SelectKeyword(m_DeferredAllMaterialSRT, "USE_CLUSTERED_LIGHTLIST", "USE_FPTL_LIGHTLIST", bUseClusteredForDeferred);
+                                    Utilities.DrawFullscreen(cmd, m_DeferredAllMaterialSRT, hdCamera, colorBuffers[0], stencilBuffer);
+                                }
                             }
                         }
 
                             m_DebugViewTilesMaterial.EnableKeyword(bUseClusteredForDeferred ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");
                             m_DebugViewTilesMaterial.DisableKeyword(!bUseClusteredForDeferred ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");
 
-                            cmd.Blit(null, cameraColorBufferRT, m_DebugViewTilesMaterial, 0);
+                            cmd.Blit(null, colorBuffers[0], m_DebugViewTilesMaterial, 0);
                         }
                     }
 

Assets/ScriptableRenderLoop/HDRenderPipeline/Lighting/TilePass/TilePassProducer.asset.meta

 fileFormatVersion: 2
 guid: bf8cd9ae03ff7d54c89603e67be0bfc5
-timeCreated: 1485447725
+timeCreated: 1485857933
 licenseType: Pro
 NativeFormatImporter:
   mainObjectFileID: 11400000

Assets/ScriptableRenderLoop/HDRenderPipeline/Lighting/TilePass/TilePassResources.asset

   m_DebugViewMaterialGBuffer: {fileID: 4800000, guid: 439949ea1bfa91b4ba0d04269fcde33d,
     type: 3}
   m_InitPreFGD: {fileID: 4800000, guid: 123f13d52852ef547b2962de4bd9eaad, type: 3}
-
-

Assets/ScriptableRenderLoop/HDRenderPipeline/Lighting/TilePass/TilePassResources.asset.meta

 fileFormatVersion: 2
 guid: 7f2998544b2ac3848822b80ec3e6c446
-timeCreated: 1485447672
+timeCreated: 1485857936
 licenseType: Pro
 NativeFormatImporter:
   mainObjectFileID: 11400000

Assets/ScriptableRenderLoop/HDRenderPipeline/Lighting/TilePass/TilePassResources.cs

-namespace UnityEngine.Experimental.Rendering.HDPipeline
+namespace UnityEngine.Experimental.Rendering.HDPipeline
 {
     public class TilePassResources : ScriptableObject
     {
-        [UnityEditor.MenuItem("RenderPipeline/CreateTilePassResources")]
+        [UnityEditor.MenuItem("HDRenderPipeline/TilePass/CreateTilePassResources")]
         static void CreateTilePassSetup()
         {
             var instance = CreateInstance<TilePassResources>();

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/LayeredLit/Editor/LayeredLitUI.cs

             bool layerChanged = DoLayersGUI(materialImporter);
 
             EditorGUILayout.Space();
-            GUILayout.Label(Styles.emissiveText, EditorStyles.boldLabel);
+            GUILayout.Label(Styles.lightingText, EditorStyles.boldLabel);
+            m_MaterialEditor.ShaderProperty(horizonFade, Styles.horizonFadeText);
             EditorGUI.indentLevel--;
 
             CheckLayerConsistency();

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/LayeredLit/LayeredLit.shader

 
         _AlphaCutoff("Alpha Cutoff", Range(0.0, 1.0)) = 0.5
 
+        _HorizonFade("Horizon fade", Range(0.0, 5.0)) = 1.0
+
         // Blending state
         [HideInInspector] _SurfaceType("__surfacetype", Float) = 0.0
         [HideInInspector] _BlendMode ("__blendmode", Float) = 0.0
     HLSLINCLUDE
 
     #pragma target 4.5
-    #pragma only_renderers d3d11 ps4 metal // TEMP: unitl we go futher in dev
+    #pragma only_renderers d3d11 ps4 metal // TEMP: until we go further in dev
 
     #pragma shader_feature _ALPHATEST_ON
     #pragma shader_feature _DISTORTION_ON

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/LayeredLit/LayeredLitTessellation.shader

 
         _AlphaCutoff("Alpha Cutoff", Range(0.0, 1.0)) = 0.5
 
+        _HorizonFade("Horizon fade", Range(0.0, 5.0)) = 1.0
+
         // Blending state
         [HideInInspector] _SurfaceType("__surfacetype", Float) = 0.0
         [HideInInspector] _BlendMode ("__blendmode", Float) = 0.0
     HLSLINCLUDE
 
     #pragma target 5.0
-    #pragma only_renderers d3d11 ps4 // TEMP: unitl we go futher in dev
+    #pragma only_renderers d3d11 ps4 // TEMP: until we go further in dev
 
     #pragma shader_feature _ALPHATEST_ON
     #pragma shader_feature _DISTORTION_ON

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Lit/Editor/BaseLitUI.cs

             public static GUIContent distortionOnlyText = new GUIContent("Distortion Only", "This shader will only be use to render distortion");
             public static GUIContent distortionDepthTestText = new GUIContent("Distortion Depth Test", "Enable the depth test for distortion");
             public static GUIContent depthOffsetEnableText = new GUIContent("DepthOffset", "EnableDepthOffset on this shader (Use with heightmap)");
+            public static GUIContent horizonFadeText = new GUIContent("HorizonFade", "horizon fade is use to control specular occlusion");            
 
             public static readonly string[] surfaceTypeNames = Enum.GetNames(typeof(SurfaceType));
             public static readonly string[] blendModeNames = Enum.GetNames(typeof(BlendMode));
             public static GUIContent tessellationShapeFactorText = new GUIContent("Shape factor", "Strength of Phong tessellation shape (lerp factor)");
             public static GUIContent tessellationBackFaceCullEpsilonText = new GUIContent("Triangle culling Epsilon", "If -1.0 back face culling is enabled for tessellation, higher number mean more aggressive culling and better performance");
             public static GUIContent tessellationObjectScaleText = new GUIContent("Enable object scale", "Tesselation displacement will take into account the object scale - Only work with uniform positive scale");
+
+            public static GUIContent materialIDText          = new GUIContent("Material Class", "Subsurface Scattering: enable for translucent materials such as skin, vegetation, fruit, marble, wax and milk.");
+            public static GUIContent subsurfaceProfileText   = new GUIContent("Subsurface scattering profile", "A profile determines the shape of the blur filter.");
+            public static GUIContent subsurfaceRadiusText    = new GUIContent("Subsurface scattering radius", "Determines the range of the blur.");
+            public static GUIContent subsurfaceRadiusMapText = new GUIContent("Subsurface scattering radius map", "Determines the range of the blur.");
+            public static GUIContent thicknessText           = new GUIContent("Thickness", "If subsurface scattering is enabled, low values allow some light to be transmitted through the object.");
+            public static GUIContent thicknessMapText        = new GUIContent("Thickness map", "If subsurface scattering is enabled, low values allow some light to be transmitted through the object.");
         }
 
         public enum SurfaceType
             distortionOnly = FindProperty(kDistortionOnly, props);
             distortionDepthTest = FindProperty(kDistortionDepthTest, props);
             depthOffsetEnable = FindProperty(kDepthOffsetEnable, props);
+            horizonFade = FindProperty(kHorizonFade, props);
 
             // tessellation specific, silent if not found
             tessellationMode = FindProperty(kTessellationMode, props, false);
         const string kDistortionDepthTest = "_DistortionDepthTest";
         MaterialProperty depthOffsetEnable = null;       
         const string kDepthOffsetEnable = "_DepthOffsetEnable";
+        protected MaterialProperty horizonFade = null;
+        const string kHorizonFade = "_HorizonFade";
 
         // tessellation params
         protected MaterialProperty tessellationMode = null;

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Lit/Editor/LitUI.cs

 using System;
 using UnityEngine;
 using UnityEngine.Rendering;
+using UnityEngine.Experimental.Rendering.HDPipeline;
 
 namespace UnityEditor.Experimental.Rendering.HDPipeline
 {
         protected MaterialProperty detailAOScale = null;
         protected const string kDetailAOScale = "_DetailAOScale";
 
-        //	MaterialProperty subSurfaceRadius = null;
-        //	MaterialProperty subSurfaceRadiusMap = null;
-
         protected MaterialProperty emissiveColor = null;
         protected const string kEmissiveColor = "_EmissiveColor";
         protected MaterialProperty emissiveColorMap = null;
 
+        protected MaterialProperty materialID           = null;
+        protected const string     kMaterialID          = "_MaterialID";
+        protected MaterialProperty subsurfaceProfile    = null;
+        protected const string     kSubsurfaceProfile   = "_SubsurfaceProfile";
+        protected MaterialProperty subsurfaceRadius     = null;
+        protected const string     kSubsurfaceRadius    = "_SubsurfaceRadius";
+        protected MaterialProperty subsurfaceRadiusMap  = null;
+        protected const string     kSubsurfaceRadiusMap = "_SubsurfaceRadiusMap";
+        protected MaterialProperty thickness            = null;
+        protected const string     kThickness           = "_Thickness";
+        protected MaterialProperty thicknessMap         = null;
+        protected const string     kThicknessMap        = "_ThicknessMap";
-        {   
+        {
             smoothnessMapChannel = FindProperty(kSmoothnessTextureChannel, props);
             normalMapSpace = FindProperty(kNormalMapSpace, props);
             enablePerPixelDisplacement = FindProperty(kEnablePerPixelDisplacement, props);
             emissiveColor = FindProperty(kEmissiveColor, props);
             emissiveColorMap = FindProperty(kEmissiveColorMap, props);
             emissiveIntensity = FindProperty(kEmissiveIntensity, props);
+
+            materialID          = FindProperty(kMaterialID,          props);
+            subsurfaceProfile   = FindProperty(kSubsurfaceProfile,   props);
+            subsurfaceRadius    = FindProperty(kSubsurfaceRadius,    props);
+            subsurfaceRadiusMap = FindProperty(kSubsurfaceRadiusMap, props);
+            thickness           = FindProperty(kThickness,           props);
+            thicknessMap        = FindProperty(kThicknessMap,        props);
         }
 
         override protected void ShaderInputOptionsGUI()
 
             EditorGUI.indentLevel++;
             GUILayout.Label(Styles.InputsOptionsText, EditorStyles.boldLabel);
-            m_MaterialEditor.ShaderProperty(smoothnessMapChannel, Styles.smoothnessMapChannelText.text);
-            m_MaterialEditor.ShaderProperty(UVBase, enableUVDetail ? Styles.UVBaseDetailMappingText.text : Styles.UVBaseMappingText.text);
+            m_MaterialEditor.ShaderProperty(smoothnessMapChannel, Styles.smoothnessMapChannelText);
+            m_MaterialEditor.ShaderProperty(UVBase, enableUVDetail ? Styles.UVBaseDetailMappingText : Styles.UVBaseMappingText);
 
             float X, Y, Z, W;
             X = ((UVBaseMapping)UVBase.floatValue == UVBaseMapping.UV0) ? 1.0f : 0.0f;
             {
                 EditorGUI.indentLevel++;
-                m_MaterialEditor.ShaderProperty(TexWorldScale, Styles.texWorldScaleText.text);
+                m_MaterialEditor.ShaderProperty(TexWorldScale, Styles.texWorldScaleText);
-                m_MaterialEditor.ShaderProperty(UVDetail, Styles.UVDetailMappingText.text);
+                m_MaterialEditor.ShaderProperty(UVDetail, Styles.UVDetailMappingText);
             }
 
             X = ((UVDetailMapping)UVDetail.floatValue == UVDetailMapping.UV0) ? 1.0f : 0.0f;
             UVDetailsMappingMask.colorValue = new Color(X, Y, Z, W);
 
-            //m_MaterialEditor.ShaderProperty(detailMapMode, Styles.detailMapModeText.text);
-            m_MaterialEditor.ShaderProperty(normalMapSpace, Styles.normalMapSpaceText.text);            
-            m_MaterialEditor.ShaderProperty(emissiveColorMode, Styles.emissiveColorModeText.text);
-            m_MaterialEditor.ShaderProperty(enablePerPixelDisplacement, Styles.enablePerPixelDisplacementText.text);
-            m_MaterialEditor.ShaderProperty(ppdMinSamples, Styles.ppdMinSamplesText.text);
-            m_MaterialEditor.ShaderProperty(ppdMaxSamples, Styles.ppdMaxSamplesText.text);
+            //m_MaterialEditor.ShaderProperty(detailMapMode, Styles.detailMapModeText);
+            m_MaterialEditor.ShaderProperty(normalMapSpace, Styles.normalMapSpaceText);
+            m_MaterialEditor.ShaderProperty(emissiveColorMode, Styles.emissiveColorModeText);
+            m_MaterialEditor.ShaderProperty(enablePerPixelDisplacement, Styles.enablePerPixelDisplacementText);
+            m_MaterialEditor.ShaderProperty(ppdMinSamples, Styles.ppdMinSamplesText);
+            m_MaterialEditor.ShaderProperty(ppdMaxSamples, Styles.ppdMaxSamplesText);
+
+            m_MaterialEditor.ShaderProperty(materialID,          Styles.materialIDText);
+            m_MaterialEditor.ShaderProperty(subsurfaceProfile,   Styles.subsurfaceProfileText);
+            m_MaterialEditor.ShaderProperty(subsurfaceRadius,    Styles.subsurfaceRadiusText);
+            m_MaterialEditor.ShaderProperty(subsurfaceRadiusMap, Styles.subsurfaceRadiusMapText);
+            m_MaterialEditor.ShaderProperty(thickness,           Styles.thicknessText);
+            m_MaterialEditor.ShaderProperty(thicknessMap,        Styles.thicknessMapText);
+
             EditorGUI.indentLevel--;
         }
 
-            bool smoothnessInAlbedoAlpha = (SmoothnessMapChannel)smoothnessMapChannel.floatValue == SmoothnessMapChannel.AlbedoAlpha;            
+            bool smoothnessInAlbedoAlpha = (SmoothnessMapChannel)smoothnessMapChannel.floatValue == SmoothnessMapChannel.AlbedoAlpha;
             bool useDetailMapWithNormal = (DetailMapMode)detailMapMode.floatValue == DetailMapMode.DetailWithNormal;
             bool useEmissiveMask = (EmissiveColorMode)emissiveColorMode.floatValue == EmissiveColorMode.UseEmissiveMask;
 
             }
             m_MaterialEditor.ShaderProperty(emissiveIntensity, Styles.emissiveIntensityText);
             m_MaterialEditor.LightmapEmissionProperty(MaterialEditor.kMiniTextureFieldLabelIndentLevel + 1);
-
+            m_MaterialEditor.ShaderProperty(horizonFade, Styles.horizonFadeText);
             EditorGUI.indentLevel--;
 
             EditorGUILayout.Space();
 			SetKeyword(material, "_TANGENTMAP", material.GetTexture(kTangentMap));
 			SetKeyword(material, "_ANISOTROPYMAP", material.GetTexture(kAnisotropyMap));
 			SetKeyword(material, "_DETAIL_MAP", material.GetTexture(kDetailMap));
+            SetKeyword(material, "_SUBSURFACE_RADIUS_MAP", material.GetTexture(kSubsurfaceRadiusMap));
+            SetKeyword(material, "_THICKNESS_MAP", material.GetTexture(kThicknessMap));
+
 
             bool needUV2 = (UVDetailMapping)material.GetFloat(kUVDetail) == UVDetailMapping.UV2 && (UVBaseMapping)material.GetFloat(kUVBase) == UVBaseMapping.UV0;
             bool needUV3 = (UVDetailMapping)material.GetFloat(kUVDetail) == UVDetailMapping.UV3 && (UVBaseMapping)material.GetFloat(kUVBase) == UVBaseMapping.UV0;
                 material.DisableKeyword("_REQUIRE_UV2");
                 material.DisableKeyword("_REQUIRE_UV3");
             }
+
+            material.SetInt("_StencilRef", (int)material.GetFloat(kMaterialID)); // See 'StencilBits'.
          }
     }
 } // namespace UnityEditor

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Lit/Lit.cs

             public float specular; // 0.02, 0.04, 0.16, 0.2
 
             // SSS
-            [SurfaceDataAttributes("SubSurface Radius")]
-            public float subSurfaceRadius;
+            [SurfaceDataAttributes("Subsurface Radius")]
+            public float subsurfaceRadius;
-            [SurfaceDataAttributes("SubSurface Profile")]
-            public int subSurfaceProfile;
+            [SurfaceDataAttributes("Subsurface Profile")]
+            public int subsurfaceProfile;
 
             // Clearcoat
             [SurfaceDataAttributes("Coat Normal")]
             // fold into fresnel0
 
             // SSS
-            public float subSurfaceRadius;
+            public float subsurfaceRadius;
-            public int subSurfaceProfile;
+            public int   subsurfaceProfile;
 
             // Clearcoat
             public Vector3 coatNormalWS;

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Lit/Lit.cs.hlsl

 	float anisotropy;
 	float metallic;
 	float specular;
-	float subSurfaceRadius;
+	float subsurfaceRadius;
-	int subSurfaceProfile;
+	int subsurfaceProfile;
 	float3 coatNormalWS;
 	float coatPerceptualSmoothness;
 	float3 specularColor;
 	float roughnessT;
 	float roughnessB;
 	float anisotropy;
-	float subSurfaceRadius;
+	float subsurfaceRadius;
-	int subSurfaceProfile;
+	int subsurfaceProfile;
 	float3 coatNormalWS;
 	float coatRoughness;
 };

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Lit/Lit.hlsl

     else if (bsdfData.materialId == MATERIALID_LIT_SSS)
     {
         bsdfData.diffuseColor = surfaceData.baseColor;
-        bsdfData.fresnel0 = 0.028; // TODO take from subSurfaceProfile
-        bsdfData.subSurfaceRadius = surfaceData.subSurfaceRadius;
+        bsdfData.fresnel0 = 0.028; // TODO take from subsurfaceProfile
+        bsdfData.subsurfaceRadius = surfaceData.subsurfaceRadius;
-        bsdfData.subSurfaceProfile = surfaceData.subSurfaceProfile;
+        bsdfData.subsurfaceProfile = surfaceData.subsurfaceProfile;
     }
     else if (bsdfData.materialId == MATERIALID_LIT_CLEAR_COAT)
     {
     }
     else if (surfaceData.materialId == MATERIALID_LIT_SSS)
     {
-        outGBuffer2 = float4(surfaceData.subSurfaceRadius, surfaceData.thickness, 0.0, surfaceData.subSurfaceProfile / 8.0); // Number of profile not define yet
+        outGBuffer2 = float4(surfaceData.subsurfaceRadius, surfaceData.thickness, 0.0, surfaceData.subsurfaceProfile / 8.0); // Number of profile not define yet
     }
     else if (surfaceData.materialId == MATERIALID_LIT_CLEAR_COAT)
     {
     else if (bsdfData.materialId == MATERIALID_LIT_SSS)
     {
         bsdfData.diffuseColor = baseColor;
-        bsdfData.fresnel0 = 0.028; // TODO take from subSurfaceProfile
-        bsdfData.subSurfaceRadius = inGBuffer2.r;
+        bsdfData.fresnel0 = 0.028; // TODO take from subsurfaceProfile
+        bsdfData.subsurfaceRadius = inGBuffer2.r;
-        bsdfData.subSurfaceProfile = inGBuffer2.a * 8.0;
+        bsdfData.subsurfaceProfile = inGBuffer2.a * 8.0;
     }
     else if (bsdfData.materialId == MATERIALID_LIT_CLEAR_COAT)
     {
             result = surfaceData.specular.xxx;
             break;
         case DEBUGVIEW_LIT_SURFACEDATA_SUB_SURFACE_RADIUS:
-            result = surfaceData.subSurfaceRadius.xxx;
+            result = surfaceData.subsurfaceRadius.xxx;
-            result = GetIndexColor(surfaceData.subSurfaceProfile);
+            result = GetIndexColor(surfaceData.subsurfaceProfile);
             break;
         case DEBUGVIEW_LIT_SURFACEDATA_COAT_NORMAL_WS:
             result = surfaceData.coatNormalWS * 0.5 + 0.5;
             result = bsdfData.anisotropy.xxx;
             break;
         case DEBUGVIEW_LIT_BSDFDATA_SUB_SURFACE_RADIUS:
-            result = bsdfData.subSurfaceRadius.xxx;
+            result = bsdfData.subsurfaceRadius.xxx;
-            result = GetIndexColor(bsdfData.subSurfaceProfile);
+            result = GetIndexColor(bsdfData.subsurfaceProfile);
             break;
         case DEBUGVIEW_LIT_BSDFDATA_COAT_NORMAL_WS:
             result = bsdfData.coatNormalWS * 0.5 + 0.5;

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Lit/Lit.shader

         _DetailNormalScale("_DetailNormalScale", Range(0.0, 2.0)) = 1
         _DetailSmoothnessScale("_DetailSmoothnessScale", Range(-2.0, 2.0)) = 1
         _DetailHeightScale("_DetailHeightScale", Range(-2.0, 2.0)) = 1
-        _DetailAOScale("_DetailAOScale", Range(-2.0, 2.0)) = 1        
+        _DetailAOScale("_DetailAOScale", Range(-2.0, 2.0)) = 1
-        _SubSurfaceRadius("SubSurfaceRadius", Range(0.0, 1.0)) = 0
-        _SubSurfaceRadiusMap("SubSurfaceRadiusMap", 2D) = "white" {}
-        //_Thickness("Thickness", Range(0.0, 1.0)) = 0
-        //_ThicknessMap("ThicknessMap", 2D) = "white" {}
-        //_SubSurfaceProfile("SubSurfaceProfile", Float) = 0
+        [Enum(Standard, 0, Subsurface Scattering, 1, Clear Coat, 2)] _MaterialID("Material Class", Int) = 0
+        _SubsurfaceProfile("Subsurface Profile", Int) = 0
+        _SubsurfaceRadius("Subsurface Radius", Range(0.0, 1.0)) = 0
+        _SubsurfaceRadiusMap("Subsurface Radius Map", 2D) = "white" {}
+        _Thickness("Thickness", Range(0.0, 1.0)) = 0
+        _ThicknessMap("Thickness Map", 2D) = "white" {}
 
         //_CoatCoverage("CoatCoverage", Range(0.0, 1.0)) = 0
         //_CoatCoverageMap("CoatCoverageMapMap", 2D) = "white" {}
         [ToggleOff]  _AlphaCutoffEnable("Alpha Cutoff Enable", Float) = 0.0
         _AlphaCutoff("Alpha Cutoff", Range(0.0, 1.0)) = 0.5
 
+        _HorizonFade("Horizon fade", Range(0.0, 5.0)) = 1.0
+
+        // Stencil state
+        [HideInInspector] _StencilRef("_StencilRef", Int) = 0
+
         // Blending state
         [HideInInspector] _SurfaceType("__surfacetype", Float) = 0.0
         [HideInInspector] _BlendMode("__blendmode", Float) = 0.0
         [Enum(DetailMapNormal, 0, DetailMapAOHeight, 1)] _DetailMapMode("DetailMap mode", Float) = 0
         [Enum(UV0, 0, UV1, 1, UV2, 2, UV3, 3)] _UVDetail("UV Set for detail", Float) = 0
         [HideInInspector] _UVDetailsMappingMask("_UVDetailsMappingMask", Color) = (1, 0, 0, 0)
-        [Enum(Use Emissive Color, 0, Use Emissive Mask, 1)] _EmissiveColorMode("Emissive color mode", Float) = 1                
+        [Enum(Use Emissive Color, 0, Use Emissive Mask, 1)] _EmissiveColorMode("Emissive color mode", Float) = 1        
     }
 
     HLSLINCLUDE
     #pragma shader_feature _HEIGHTMAP
     #pragma shader_feature _TANGENTMAP
     #pragma shader_feature _ANISOTROPYMAP
-    #pragma shader_feature _DETAIL_MAP  
+    #pragma shader_feature _DETAIL_MAP
+	#pragma shader_feature _SUBSURFACE_RADIUS_MAP
+    #pragma shader_feature _THICKNESS_MAP
 
     #pragma multi_compile LIGHTMAP_OFF LIGHTMAP_ON
     #pragma multi_compile DIRLIGHTMAP_OFF DIRLIGHTMAP_COMBINED
             Tags { "LightMode" = "GBuffer" } // This will be only for opaque object based on the RenderQueue index
 
             Cull  [_CullMode]
+
+            Stencil
+            {
+                Ref  [_StencilRef]
+                Comp Always
+                Pass Replace
+            }
 
             HLSLPROGRAM
 

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Lit/LitData.hlsl

     float3 normalTS;
     float alpha = GetSurfaceData(input, layerTexCoord, surfaceData, normalTS);
     GetNormalAndTangentWS(input, V, normalTS, surfaceData.normalWS, surfaceData.tangentWS);
+    // Done one time for all layered - cumulate with spec occ alpha for now
+    surfaceData.specularOcclusion *= GetHorizonOcclusion(V, surfaceData.normalWS, input.tangentToWorld[2].xyz, _HorizonFade);
 
     // Caution: surfaceData must be fully initialize before calling GetBuiltinData
     GetBuiltinData(input, surfaceData, alpha, depthOffset, builtinData);
     float3 normalTS = BlendLayeredVector3(normalTS0, normalTS1, normalTS2, normalTS3, weights);
 #endif
 
-    surfaceData.specularOcclusion = SURFACEDATA_BLEND_SCALAR(surfaceData, specularOcclusion, weights);
     surfaceData.perceptualSmoothness = SURFACEDATA_BLEND_SCALAR(surfaceData, perceptualSmoothness, weights);
     surfaceData.ambientOcclusion = SURFACEDATA_BLEND_SCALAR(surfaceData, ambientOcclusion, weights);
     surfaceData.metallic = SURFACEDATA_BLEND_SCALAR(surfaceData, metallic, weights);
     surfaceData.materialId = 0;
     surfaceData.anisotropy = 0;
     surfaceData.specular = 0.04;
-    surfaceData.subSurfaceRadius = 1.0;
+    surfaceData.subsurfaceRadius = 1.0;
-    surfaceData.subSurfaceProfile = 0;
+    surfaceData.subsurfaceProfile = 0;
+    // Done one time for all layered - cumulate with spec occ alpha for now
+    surfaceData.specularOcclusion = SURFACEDATA_BLEND_SCALAR(surfaceData, specularOcclusion, weights);
+    surfaceData.specularOcclusion *= GetHorizonOcclusion(V, surfaceData.normalWS, input.tangentToWorld[2].xyz, _HorizonFade);
 
     GetBuiltinData(input, surfaceData, alpha, depthOffset, builtinData);
 }

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Lit/LitDataInternal.hlsl

     // TODO: Do something. For now just take alpha channel
     surfaceData.specularOcclusion = SAMPLE_LAYER_TEXTURE2D(ADD_IDX(_SpecularOcclusionMap), ADD_ZERO_IDX(sampler_SpecularOcclusionMap), ADD_IDX(layerTexCoord.base)).a;
 #else
-    // Horizon Occlusion for Normal Mapped Reflections: http://marmosetco.tumblr.com/post/81245981087
-    //surfaceData.specularOcclusion = saturate(1.0 + horizonFade * dot(r, input.tangentToWorld[2].xyz);
-    // smooth it
-    //surfaceData.specularOcclusion *= surfaceData.specularOcclusion;
+    // The specular occlusion will be perform outside the internal loop
     surfaceData.specularOcclusion = 1.0;
 #endif
     surfaceData.normalWS = float3(0.0, 0.0, 0.0); // Need to init this so that the compiler leaves us alone.
     // This part of the code is not used in case of layered shader but we keep the same macro system for simplicity
 #if !defined(LAYERED_LIT_SHADER)
 
-    surfaceData.materialId = 0; // TODO
+    surfaceData.materialId = _MaterialID;
 
     // TODO: think about using BC5
 #ifdef _TANGENTMAP
 
     surfaceData.specular = 0.04;
 
-    surfaceData.subSurfaceRadius = 1.0;
-    surfaceData.thickness = 0.0;
-    surfaceData.subSurfaceProfile = 0;
+    surfaceData.subsurfaceProfile = _SubsurfaceProfile;
+#ifdef _Subsurface_RADIUS_MAP
+	surfaceData.subsurfaceProfile = SAMPLE_LAYER_TEXTURE2D(ADD_IDX(_SubsurfaceRadiusMap), ADD_ZERO_IDX(sampler_SubsurfaceRadiusMap), ADD_IDX(layerTexCoord.base)).r;
+#else
+    surfaceData.subsurfaceRadius = _SubsurfaceRadius;
+#endif
+#ifdef _THICKNESS_MAP
+	surfaceData.thickness = SAMPLE_LAYER_TEXTURE2D(ADD_IDX(_ThicknessMap), ADD_ZERO_IDX(sampler_ThicknessMap), ADD_IDX(layerTexCoord.base)).r;
+#else
+    surfaceData.thickness = _Thickness;
+#endif
 
     surfaceData.coatNormalWS = float3(1.0, 0.0, 0.0);
     surfaceData.coatPerceptualSmoothness = 1.0;
     surfaceData.anisotropy = 0;
     surfaceData.specular = 0.04;
 
-    surfaceData.subSurfaceRadius = 1.0;
+    surfaceData.subsurfaceRadius = 1.0;
-    surfaceData.subSurfaceProfile = 0;
+    surfaceData.subsurfaceProfile = 0;
 
     surfaceData.coatNormalWS = float3(1.0, 0.0, 0.0);
     surfaceData.coatPerceptualSmoothness = 1.0;

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Lit/LitProperties.hlsl

 TEXTURE2D(_AnisotropyMap);
 SAMPLER2D(sampler_AnisotropyMap);
 
-//float _SubSurfaceRadius;
-//TEXTURE2D(_SubSurfaceRadiusMap);
-//SAMPLER2D(sampler_SubSurfaceRadiusMap);
-
-// float _Thickness;
-//TEXTURE2D(_ThicknessMap);
-//SAMPLER2D(sampler_ThicknessMap);
+int   _MaterialID;
+int   _SubsurfaceProfile;
+float _SubsurfaceRadius;
+float _Thickness;
+TEXTURE2D(_SubsurfaceRadiusMap);
+SAMPLER2D(sampler_SubsurfaceRadiusMap);
+TEXTURE2D(_ThicknessMap);
+SAMPLER2D(sampler_ThicknessMap);
 
 // float _CoatCoverage;
 //TEXTURE2D(_CoatCoverageMap);
 float _EmissiveIntensity;
 
 float _AlphaCutoff;
+
+float _HorizonFade;
 
 float _TexWorldScale;
 float _UVMappingPlanar;
 PROP_DECL(float4, _UVDetailsMappingMask);
 
 float _AlphaCutoff;
+
+float _HorizonFade;
 
 float _PPDMaxSamples;
 float _PPDMinSamples;

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Lit/LitTessellation.shader

         _DetailNormalScale("_DetailNormalScale", Range(0.0, 2.0)) = 1
         _DetailSmoothnessScale("_DetailSmoothnessScale", Range(-2.0, 2.0)) = 1
         _DetailHeightScale("_DetailHeightScale", Range(-2.0, 2.0)) = 1
-        _DetailAOScale("_DetailAOScale", Range(-2.0, 2.0)) = 1        
+        _DetailAOScale("_DetailAOScale", Range(-2.0, 2.0)) = 1
-        _SubSurfaceRadius("SubSurfaceRadius", Range(0.0, 1.0)) = 0
-        _SubSurfaceRadiusMap("SubSurfaceRadiusMap", 2D) = "white" {}
-        //_Thickness("Thickness", Range(0.0, 1.0)) = 0
-        //_ThicknessMap("ThicknessMap", 2D) = "white" {}
-        //_SubSurfaceProfile("SubSurfaceProfile", Float) = 0
+        [Enum(Standard, 0, Subsurface Scattering, 1, Clear Coat, 2)] _MaterialID("Material Class", Int) = 0
+        _SubsurfaceProfile("Subsurface Profile", Int) = 0
+        _SubsurfaceRadius("Subsurface Radius", Range(0.0, 1.0)) = 0
+        _SubsurfaceRadiusMap("Subsurface Radius Map", 2D) = "white" {}
+        _Thickness("Thickness", Range(0.0, 1.0)) = 0
+        _ThicknessMap("Thickness Map", 2D) = "white" {}
 
         //_CoatCoverage("CoatCoverage", Range(0.0, 1.0)) = 0
         //_CoatCoverageMap("CoatCoverageMapMap", 2D) = "white" {}
         [ToggleOff]  _AlphaCutoffEnable("Alpha Cutoff Enable", Float) = 0.0
         _AlphaCutoff("Alpha Cutoff", Range(0.0, 1.0)) = 0.5
 
+        _HorizonFade("Horizon fade", Range(0.0, 5.0)) = 1.0
+
+        // Stencil state
+        [HideInInspector] _StencilRef("_StencilRef", Int) = 0
+
         // Blending state
         [HideInInspector] _SurfaceType("__surfacetype", Float) = 0.0
         [HideInInspector] _BlendMode("__blendmode", Float) = 0.0
         _TessellationFactor("Tessellation Factor", Range(0.0, 15.0)) = 4.0
         _TessellationFactorMinDistance("Tessellation start fading distance", Float) = 20.0
         _TessellationFactorMaxDistance("Tessellation end fading distance", Float) = 50.0
-        _TessellationFactorTriangleSize("Tessellation triangle size", Float) = 100.0      
+        _TessellationFactorTriangleSize("Tessellation triangle size", Float) = 100.0
         _TessellationShapeFactor("Tessellation shape factor", Range(0.0, 1.0)) = 0.75 // Only use with Phong
         _TessellationBackFaceCullEpsilon("Tessellation back face epsilon", Range(-1.0, 0.0)) = -0.25
         [ToggleOff] _TessellationObjectScale("Tessellation object scale", Float) = 0.0
     #pragma shader_feature _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
     #pragma shader_feature _MAPPING_TRIPLANAR
     #pragma shader_feature _DETAIL_MAP_WITH_NORMAL
-    #pragma shader_feature _NORMALMAP_TANGENT_SPACE   
+    #pragma shader_feature _NORMALMAP_TANGENT_SPACE
-    #pragma shader_feature _NORMALMAP  
+    #pragma shader_feature _NORMALMAP
     #pragma shader_feature _MASKMAP
     #pragma shader_feature _SPECULAROCCLUSIONMAP
     #pragma shader_feature _EMISSIVE_COLOR_MAP
-    #pragma shader_feature _DETAIL_MAP  
+    #pragma shader_feature _DETAIL_MAP
+    #pragma shader_feature _SUBSURFACE_RADIUS_MAP
+    #pragma shader_feature _THICKNESS_MAP
-    //#pragma multi_compile VELOCITYOUTPUT_OFF VELOCITYOUTPUT_ON 
+    //#pragma multi_compile VELOCITYOUTPUT_OFF VELOCITYOUTPUT_ON
 
     //-------------------------------------------------------------------------------------
     // Define
     //-------------------------------------------------------------------------------------
     // Include
     //-------------------------------------------------------------------------------------
-    
+
     #include "common.hlsl"
     #include "tessellation.hlsl"
     #include "Assets/ScriptableRenderLoop/HDRenderPipeline/ShaderConfig.cs.hlsl"
             Tags { "LightMode" = "GBuffer" } // This will be only for opaque object based on the RenderQueue index
 
             Cull  [_CullMode]
+
+            Stencil
+            {
+                Ref  [_StencilRef]
+                Comp Always
+                Pass Replace
+            }
 
             HLSLPROGRAM
 
             HLSLPROGRAM
 
             // Lightmap memo
-            // DYNAMICLIGHTMAP_ON is used when we have an "enlighten lightmap" ie a lightmap updated at runtime by enlighten.This lightmap contain indirect lighting from realtime lights and realtime emissive material.Offline baked lighting(from baked material / light, 
+            // DYNAMICLIGHTMAP_ON is used when we have an "enlighten lightmap" ie a lightmap updated at runtime by enlighten.This lightmap contain indirect lighting from realtime lights and realtime emissive material.Offline baked lighting(from baked material / light,
-			// No tessellation for Meta pass
+            // No tessellation for Meta pass
-            #include "../../Material/Material.hlsl"            
+            #include "../../Material/Material.hlsl"
             #include "ShaderPass/LitMetaPass.hlsl"
             #include "LitData.hlsl"
             #include "../../ShaderPass/ShaderPassLightTransport.hlsl"
 
             Cull[_CullMode]
 
-            ZWrite On 
+            ZWrite On
             ZTest LEqual
 
             HLSLPROGRAM
 
             #define SHADERPASS SHADERPASS_DEPTH_ONLY
-            #include "../../Material/Material.hlsl"            
+            #include "../../Material/Material.hlsl"
             #include "ShaderPass/LitDepthPass.hlsl"
             #include "LitData.hlsl"
             #include "../../ShaderPass/ShaderPassDepthOnly.hlsl"
 
             Cull[_CullMode]
 
-            ZWrite On 
- 
+            ZWrite On
+
             HLSLPROGRAM
 
             #pragma hull Hull
-            #include "../../Material/Material.hlsl"            
+            #include "../../Material/Material.hlsl"
             #include "ShaderPass/LitDepthPass.hlsl"
             #include "LitData.hlsl"
             #include "../../ShaderPass/ShaderPassDepthOnly.hlsl"
 
             HLSLPROGRAM
 
-			// TODO: Tesselation can't work with velocity for now...
+            // TODO: Tesselation can't work with velocity for now...
-            #include "../../Material/Material.hlsl"         
+            #include "../../Material/Material.hlsl"
             #include "ShaderPass/LitVelocityPass.hlsl"
             #include "LitData.hlsl"
             #include "../../ShaderPass/ShaderPassVelocity.hlsl"
             #pragma hull Hull
             #pragma domain Domain
 
-            #define SHADERPASS SHADERPASS_FORWARD            
+            #define SHADERPASS SHADERPASS_FORWARD
             #include "../../Lighting/Forward.hlsl"
             // TEMP until pragma work in include
             #pragma multi_compile LIGHTLOOP_SINGLE_PASS LIGHTLOOP_TILE_PASS

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Lit/Resources/PreIntegratedFGD.shader

             #pragma vertex Vert
             #pragma fragment Frag
             #pragma target 4.5
-            #pragma only_renderers d3d11 ps4 metal // TEMP: unitl we go futher in dev
+            #pragma only_renderers d3d11 ps4 metal // TEMP: until we go further in dev
 
             #include "Common.hlsl"
             #include "ImageBasedLighting.hlsl"

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Unlit/Unlit.shader

     HLSLINCLUDE
 
     #pragma target 4.5
-    #pragma only_renderers d3d11 ps4 metal  // TEMP: unitl we go futher in dev
+    #pragma only_renderers d3d11 ps4 metal  // TEMP: until we go further in dev
 
     //-------------------------------------------------------------------------------------
     // Variant

Assets/ScriptableRenderLoop/HDRenderPipeline/SceneSettings/CommonSettings.cs

     {
         [Serializable]
         public struct Settings
-        { 
+        {
+            // Shadows
-
-            int m_ShadowCascadeCount;
-
+            int   m_ShadowCascadeCount;
-
-
-            public float shadowMaxDistance { set { m_ShadowMaxDistance = value; OnValidate(); } get { return m_ShadowMaxDistance; } }
-            public int shadowCascadeCount { set { m_ShadowCascadeCount = value; OnValidate(); } get { return m_ShadowCascadeCount; } }
+            public float shadowMaxDistance   { set { m_ShadowMaxDistance   = value; OnValidate(); } get { return m_ShadowMaxDistance; } }
+            public int   shadowCascadeCount  { set { m_ShadowCascadeCount  = value; OnValidate(); } get { return m_ShadowCascadeCount; } }
-            public void OnValidate()
+            void OnValidate()
-                m_ShadowMaxDistance = Mathf.Max(0.0f, m_ShadowMaxDistance);
-                m_ShadowCascadeCount = Math.Min(4, Math.Max(1, m_ShadowCascadeCount));
-                m_ShadowCascadeSplit0 = Mathf.Min(1.0f, Mathf.Max(0.0f, m_ShadowCascadeSplit0));
-                m_ShadowCascadeSplit1 = Mathf.Min(1.0f, Mathf.Max(0.0f, m_ShadowCascadeSplit1));
-                m_ShadowCascadeSplit2 = Mathf.Min(1.0f, Mathf.Max(0.0f, m_ShadowCascadeSplit2));
+                m_ShadowMaxDistance    = Mathf.Max(0.0f, m_ShadowMaxDistance);
+                m_ShadowCascadeCount   = Math.Min(4, Math.Max(1, m_ShadowCascadeCount));
+                m_ShadowCascadeSplit0  = Mathf.Clamp01(m_ShadowCascadeSplit0);
+                m_ShadowCascadeSplit1  = Mathf.Clamp01(m_ShadowCascadeSplit1);
+                m_ShadowCascadeSplit2  = Mathf.Clamp01(m_ShadowCascadeSplit2);
-
-                m_ShadowCascadeCount = ShadowSettings.Default.directionalLightCascadeCount,
-                m_ShadowCascadeSplit0 = ShadowSettings.Default.directionalLightCascades.x,
-                m_ShadowMaxDistance = ShadowSettings.Default.maxShadowDistance,
-                m_ShadowCascadeSplit1 = ShadowSettings.Default.directionalLightCascades.y,
-                m_ShadowCascadeSplit2 = ShadowSettings.Default.directionalLightCascades.z
+                m_ShadowMaxDistance    = ShadowSettings.Default.maxShadowDistance,
+                m_ShadowCascadeCount   = ShadowSettings.Default.directionalLightCascadeCount,
+                m_ShadowCascadeSplit0  = ShadowSettings.Default.directionalLightCascades.x,
+                m_ShadowCascadeSplit1  = ShadowSettings.Default.directionalLightCascades.y,
+                m_ShadowCascadeSplit2  = ShadowSettings.Default.directionalLightCascades.z,
-       
+
         [SerializeField]
         private Settings m_Settings = Settings.s_Defaultsettings;
 

Assets/ScriptableRenderLoop/HDRenderPipeline/SceneSettings/Editor/CommonSettingsEditor.cs

             public readonly int[] shadowsCascadeCountValues = new int[] { 1, 2, 3, 4 };
             public readonly GUIContent shadowsCascades = new GUIContent("Cascade values");
             public readonly GUIContent[] shadowSplits = new GUIContent[] { new GUIContent("Split 0"), new GUIContent("Split 1"), new GUIContent("Split 2") };
-
         }
 
         private static Styles s_Styles = null;
             EditorGUI.indentLevel--;
         }
 
-      /*  public override void OnInspectorGUI()
+        /*
+        public override void OnInspectorGUI()
         {
             serializedObject.Update();
 
             serializedObject.ApplyModifiedProperties();
-        }*/
+        }
+        */
     }
 }

Assets/ScriptableRenderLoop/HDRenderPipeline/ShaderPass/ShaderPassForward.hlsl

 
 #endif // TESSELLATION_ON
 
-void Frag(  PackedVaryingsToPS packedInput,
-            out float4 outColor : SV_Target
-            #ifdef _DEPTHOFFSET_ON
-            , out float outputDepth : SV_Depth
-            #endif
-        )
+void Frag(PackedVaryingsToPS packedInput,
+          out float4 outColor : SV_Target0
+      #ifdef _DEPTHOFFSET_ON
+          , out float outputDepth : SV_Depth
+      #endif
+          )
 {
     FragInputs input = UnpackVaryingsMeshToFragInputs(packedInput.vmesh);
 

Assets/ScriptableRenderLoop/HDRenderPipeline/ShaderVariables.hlsl

 CBUFFER_END
 
 // TODO: Change code here so probe volume use only one transform instead of all this parameters!
-TEXTURE3D(unity_ProbeVolumeSH);
+TEXTURE3D_FLOAT(unity_ProbeVolumeSH);
 SAMPLER3D(samplerunity_ProbeVolumeSH);
 
 CBUFFER_START(UnityProbeVolume)

Assets/ScriptableRenderLoop/HDRenderPipeline/Sky/HDRISky/Resources/SkyHDRI.shader

     #pragma fragment Frag
 
     #pragma target 4.5
-    #pragma only_renderers d3d11 ps4 metal // TEMP: unitl we go futher in dev
+    #pragma only_renderers d3d11 ps4 metal // TEMP: until we go further in dev
 
     #include "Color.hlsl"
     #include "Common.hlsl"

Assets/ScriptableRenderLoop/HDRenderPipeline/Sky/ProceduralSky/Resources/AtmosphericScattering.hlsl

 SAMPLER2D(sampler_CameraDepthTexture);
 #define SRL_BilinearSampler sampler_CameraDepthTexture // Used for all textures
 
-TEXTURE2D(_CameraDepthTexture);
+TEXTURE2D_FLOAT(_CameraDepthTexture);
 TEXTURE2D(_OcclusionTexture);
 
 float HenyeyGreensteinPhase(float g, float cosTheta) {

Assets/ScriptableRenderLoop/HDRenderPipeline/Sky/ProceduralSky/Resources/SkyProcedural.shader

 
             HLSLPROGRAM
             #pragma target 4.5
-            #pragma only_renderers d3d11 ps4 metal  // TEMP: unitl we go futher in dev
+            #pragma only_renderers d3d11 ps4 metal  // TEMP: until we go further in dev
 
             #pragma vertex Vert
             #pragma fragment Frag

Assets/ScriptableRenderLoop/HDRenderPipeline/Sky/Resources/GGXConvolve.shader

 
             HLSLPROGRAM
             #pragma target 4.5
-            #pragma only_renderers d3d11 ps4 metal  // TEMP: unitl we go futher in dev
+            #pragma only_renderers d3d11 ps4 metal  // TEMP: until we go further in dev
 
             #pragma multi_compile _ USE_MIS
 

Assets/ScriptableRenderLoop/HDRenderPipeline/Utilities.cs

 using System;
+using System.Collections.Generic;
+using System.Linq.Expressions;
+using System.Text;
-using UnityEngine.Experimental.Rendering.HDPipeline;
 
 using UnityObject = UnityEngine.Object;
 
     public enum ClearFlag
     {
-        ClearNone = 0,
+        ClearNone  = 0,
+    }
+
+    [Flags]
+    public enum StencilBits
+    {
+        None      = Lit.MaterialId.LitStandard, 
+        SSS       = Lit.MaterialId.LitSSS,
+        ClearCoat = Lit.MaterialId.LitClearCoat,
+        All       = 255 // 0xff
     }
 
     public class Utilities
 #else
                 UnityObject.Destroy(obj);
 #endif
-                obj = null;
             }
         }
 
+                buffer.Release();
+        }
+
+        public static string GetFieldPath<TType, TValue>(Expression<Func<TType, TValue>> expr)
+        {
+            MemberExpression me;
+            switch (expr.Body.NodeType)
-                buffer.Release();
-                buffer = null;
+                case ExpressionType.Convert:
+                case ExpressionType.ConvertChecked:
+                    var ue = expr.Body as UnaryExpression;
+                    me = (ue != null ? ue.Operand : null) as MemberExpression;
+                    break;
+                default:
+                    me = expr.Body as MemberExpression;
+                    break;
+            }
+
+            var members = new List<string>();
+            while (me != null)
+            {
+                members.Add(me.Member.Name);
+                me = me.Expression as MemberExpression;
+
+            var sb = new StringBuilder();
+            for (int i = members.Count - 1; i >= 0; i--)
+            {
+                sb.Append(members[i]);
+                if (i > 0) sb.Append('.');
+            }
+
+            return sb.ToString();
         }
 
         public class ProfilingSample
                 m.DisableKeyword(keyword);
         }
 
+        public static void SelectKeyword(Material material, string keyword1, string keyword2, bool enableFirst)
+        {
+            material.EnableKeyword (enableFirst ? keyword1 : keyword2);
+            material.DisableKeyword(enableFirst ? keyword2 : keyword1);
+        }
+
+        public static void SelectKeyword(Material material, string[] keywords, int enabledKeywordIndex)
+        {
+            material.EnableKeyword(keywords[enabledKeywordIndex]);
+
+            for (int i = 0; i < keywords.Length; i++)
+            {
+                if (i != enabledKeywordIndex)
+                {
+                    material.DisableKeyword(keywords[i]);
+                }
+            }
+        }
+
         public static HDRenderPipeline GetHDRenderPipeline()
         {
             HDRenderPipeline renderContext = GraphicsSettings.renderPipelineAsset as HDRenderPipeline;
             }
 
             return renderContext;
+        }
+
+        static Mesh m_ScreenSpaceTriangle = null;
+
+        static Mesh GetScreenSpaceTriangle()
+        {
+            // If the assembly has been reloaded, the pointer will become NULL.
+            if (!m_ScreenSpaceTriangle)
+            {
+                m_ScreenSpaceTriangle = new Mesh
+                {
+                    // Note: neither the vertex nor the index data is actually used if the vertex shader computes vertices
+                    // using 'SV_VertexID'. However, there is currently no way to bind NULL vertex or index buffers.
+                    vertices  = new[] { new Vector3(-1, -1, 1), new Vector3(3, -1, 1), new Vector3(-1, 3, 1) },
+                    triangles = new[] { 0, 1, 2 }
+                };
+            }
+
+            return m_ScreenSpaceTriangle;
+        }
+
+        // Draws a full screen triangle as a faster alternative to drawing a full-screen quad.
+        public static void DrawFullscreen(CommandBuffer commandBuffer, Material material, HDCamera camera,
+                                          RenderTargetIdentifier colorBuffer,
+                                          MaterialPropertyBlock properties = null, int shaderPassID = 0)
+        {
+            SetupMaterialHDCamera(camera, material);
+            commandBuffer.SetRenderTarget(colorBuffer);
+            commandBuffer.DrawMesh(GetScreenSpaceTriangle(), Matrix4x4.identity, material, 0, shaderPassID, properties);
+        }
+
+        // Draws a full screen triangle as a faster alternative to drawing a full-screen quad.
+        public static void DrawFullscreen(CommandBuffer commandBuffer, Material material, HDCamera camera,
+                                          RenderTargetIdentifier colorBuffer, RenderTargetIdentifier depthStencilBuffer,
+                                          MaterialPropertyBlock properties = null, int shaderPassID = 0)
+        {
+            SetupMaterialHDCamera(camera, material);
+            commandBuffer.SetRenderTarget(colorBuffer, depthStencilBuffer);
+            commandBuffer.DrawMesh(GetScreenSpaceTriangle(), Matrix4x4.identity, material, 0, shaderPassID, properties);
+        }
+
+        // Draws a full screen triangle as a faster alternative to drawing a full-screen quad.
+        public static void DrawFullscreen(CommandBuffer commandBuffer, Material material, HDCamera camera,
+                                          RenderTargetIdentifier[] colorBuffers, RenderTargetIdentifier depthStencilBuffer,
+                                          MaterialPropertyBlock properties = null, int shaderPassID = 0)
+        {
+            SetupMaterialHDCamera(camera, material);
+            commandBuffer.SetRenderTarget(colorBuffers, depthStencilBuffer);
+            commandBuffer.DrawMesh(GetScreenSpaceTriangle(), Matrix4x4.identity, material, 0, shaderPassID, properties);
+        }
+
+        // Draws a full screen triangle as a faster alternative to drawing a full-screen quad.
+        // Important: the first RenderTarget must be created with 0 depth bits!
+        public static void DrawFullscreen(CommandBuffer commandBuffer, Material material, HDCamera camera,
+                                          RenderTargetIdentifier[] colorBuffers,
+                                          MaterialPropertyBlock properties = null, int shaderPassID = 0)
+        {
+            // It is currently not possible to have MRT without also setting a depth target.
+            // To work around this deficiency of the CommandBuffer.SetRenderTarget() API,
+            // we pass the first color target as the depth target. If it has 0 depth bits,
+            // no depth target ends up being bound.
+            DrawFullscreen(commandBuffer, material, camera, colorBuffers, colorBuffers[0], properties, shaderPassID);
         }
     }
 }

Assets/ScriptableRenderLoop/RenderPasses/ShadowRenderPass.cs

         public int      directionalLightCascadeCount;
         public Vector3  directionalLightCascades;
 
+        static ShadowSettings defaultShadowSettings = null;
+
-                ShadowSettings settings = new ShadowSettings();
-                settings.enabled = true;
-                settings.shadowAtlasHeight = settings.shadowAtlasWidth = 4096;
-                settings.directionalLightCascadeCount = 1;
-                settings.directionalLightCascades = new Vector3(0.05F, 0.2F, 0.3F);
-                settings.directionalLightCascadeCount = 4;
-                settings.maxShadowDistance = 1000.0F;
-                return settings;
+                if (defaultShadowSettings == null)
+                {
+                    defaultShadowSettings = new ShadowSettings();
+                    defaultShadowSettings.enabled = true;
+                    defaultShadowSettings.shadowAtlasHeight = defaultShadowSettings.shadowAtlasWidth = 4096;
+                    defaultShadowSettings.directionalLightCascadeCount = 1;
+                    defaultShadowSettings.directionalLightCascades = new Vector3(0.05F, 0.2F, 0.3F);
+                    defaultShadowSettings.directionalLightCascadeCount = 4;
+                    defaultShadowSettings.maxShadowDistance = 1000.0F;
+                }
+                return defaultShadowSettings;
             }
         }
     }
         int                         m_ShadowTexName;
         const int                   k_DepthBuffer = 24;
 
+        public int shadowTexName
+        {
+            get { return m_ShadowTexName; }
+        }
 
         public ShadowRenderPass(ShadowSettings settings)
         {
             if (!m_Settings.enabled)
             {
                 ClearPackedShadows(cullResults.visibleLights, out packedShadows);
+                return;
             }
 
             // Pack all shadow quads into the texture
             commandBuffer.Dispose();
 
             // Render
-            loop.DrawShadows(settings);
+            loop.DrawShadows(ref settings);
         }
     }
 }

Assets/ScriptableRenderLoop/ShaderLibrary/API/D3D11.hlsl

 
 #define TEXTURE2D_HALF TEXTURE2D
 #define TEXTURE2D_FLOAT TEXTURE2D
+#define TEXTURE3D_HALF TEXTURE3D
+#define TEXTURE3D_FLOAT TEXTURE3D
 #define SAMPLER2D_HALF SAMPLER2D
 #define SAMPLER2D_FLOAT SAMPLER2D
 

Assets/ScriptableRenderLoop/ShaderLibrary/API/Metal.hlsl

 
 #define TEXTURE2D_HALF TEXTURE2D
 #define TEXTURE2D_FLOAT TEXTURE2D
+#define TEXTURE3D_HALF TEXTURE3D
+#define TEXTURE3D_FLOAT TEXTURE3D
 #define SAMPLER2D_HALF SAMPLER2D
 #define SAMPLER2D_FLOAT SAMPLER2D
 

Assets/ScriptableRenderLoop/ShaderLibrary/API/PSSL.hlsl

 
 #define TEXTURE2D_HALF TEXTURE2D
 #define TEXTURE2D_FLOAT TEXTURE2D
+#define TEXTURE3D_HALF TEXTURE3D
+#define TEXTURE3D_FLOAT TEXTURE3D
 #define SAMPLER2D_HALF SAMPLER2D
 #define SAMPLER2D_FLOAT SAMPLER2D
 

Assets/ScriptableRenderLoop/ShaderLibrary/Common.hlsl

     posInput.positionWS += V * depthOffsetVS;
 }
 
+
+// Generates a triangle in homogeneous clip space, s.t.
+// v0 = (-1, -1, 1), v1 = (3, -1, 1), v2 = (-1, 3, 1).
+float2 GetFullscreenTriangleTexcoord(uint vertexID)
+{
+#if UNITY_UV_STARTS_AT_TOP
+    return float2((vertexID << 1) & 2, 1.0 - (vertexID & 2));
+#else
+    return float2((vertexID << 1) & 2, vertexID & 2);
+#endif
+}
+
+float4 GetFullscreenTriangleVertexPosition(uint vertexID)
+{
+    float2 uv = float2((vertexID << 1) & 2, vertexID & 2);
+    return float4(uv * 2.0 - 1.0, 1.0, 1.0);
+}
+
 #endif // UNITY_COMMON_INCLUDED

Assets/ScriptableRenderLoop/ShaderLibrary/CommonLighting.hlsl

 }
 
 //-----------------------------------------------------------------------------
+// Lighting functions
+//-----------------------------------------------------------------------------
+
+// Ref: Horizon Occlusion for Normal Mapped Reflections: http://marmosetco.tumblr.com/post/81245981087
+float GetHorizonOcclusion(float3 V, float3 normalWS, float3 vertexNormal, float horizonFade)
+{
+    float3 R = reflect(-V, normalWS);
+    float specularOcclusion = saturate(1.0 + horizonFade * dot(R, vertexNormal));
+    // smooth it
+    return specularOcclusion * specularOcclusion;
+}
+
+//-----------------------------------------------------------------------------
 // Helper functions
 //-----------------------------------------------------------------------------
 

Assets/ScriptableRenderLoop/ShaderLibrary/Hammersley.hlsl

 #endif
 }
 
-float RadicalInverse_VdC(uint bits)
+float VanDerCorputBase2(uint i)
-    return float(ReverseBits32(bits)) * 2.3283064365386963e-10; // 0x100000000
+    return ReverseBits32(i) * rcp(4294967296.0); // 0x100000000
-    return float2(float(i) / float(sequenceLength), RadicalInverse_VdC(i));
+    return float2(float(i) / float(sequenceLength), VanDerCorputBase2(i));
 }
 
 static const float2 k_Hammersley2dSeq16[] = {

Assets/ScriptableRenderLoop/ShaderLibrary/ImageBasedLighting.hlsl

     return roughness * lerp(saturate(NdotV * 2.0), 1.0, perceptualRoughness);
 }
 
-//-----------------------------------------------------------------------------
-// Coordinate system conversion
-//-----------------------------------------------------------------------------
-
-// Transforms the unit vector from the spherical to the Cartesian (right-handed, Z up) coordinate.
-float3 SphericalToCartesian(float phi, float cosTheta)
-{
-    float sinPhi, cosPhi;
-    sincos(phi, sinPhi, cosPhi);
-
-    float sinTheta = sqrt(saturate(1.0 - cosTheta * cosTheta));
-
-    return float3(sinTheta * cosPhi, sinTheta * sinPhi, cosTheta);
-}
-
-// Converts Cartesian coordinates given in the right-handed coordinate system
-// with Z pointing upwards (OpenGL style) to the coordinates in the left-handed
-// coordinate system with Y pointing up and Z facing forward (DirectX style).
-float3 TransformGLtoDX(float3 v)
-{
-    return v.xzy;
-}
-
-// Performs conversion from equiareal map coordinates to Cartesian (DirectX cubemap) ones.
-float3 ConvertEquiarealToCubemap(float u, float v)
-{
-    float phi      = TWO_PI - TWO_PI * u;
-    float cosTheta = 1.0 - 2.0 * v;
-
-    return TransformGLtoDX(SphericalToCartesian(phi, cosTheta));
-}
-
-// Performs uniform sampling of the unit disk.
-// Ref: PBRT v3, p. 777.
-float2 SampleDiskUniform(float2 u)
-{
-    float r   = sqrt(u.x);
-    float phi = TWO_PI * u.y;
-
-    float sinPhi, cosPhi;
-    sincos(phi, sinPhi, cosPhi);
-
-    return r * float2(cosPhi, sinPhi);
-}
-
-// Performs cosine-weighted sampling of the hemisphere.
-// Ref: PBRT v3, p. 780.
-void SampleHemisphereCosine(float2   u,
-                            float3x3 localToWorld,
-                        out float3   L,
-                        out float    NdotL)
-{
-    float3 localL;
-
-    // Since we don't really care about the area distortion,
-    // we substitute uniform disk sampling for the concentric one.
-    localL.xy = SampleDiskUniform(u);
-
-    // Project the point from the disk onto the hemisphere.
-    localL.z = sqrt(1.0 - u.x);
-
-    NdotL = localL.z;
-
-    L = mul(localL, localToWorld);
-}
-
 void SampleGGXDir(float2   u,
                   float3   V,
                   float3x3 localToWorld,
                          out float    NdotL,
                          out float    weightOverPdf)
 {
-    SampleHemisphereCosine(u, localToWorld, L, NdotL);
+    float3 localL = SampleHemisphereCosine(u.x, u.y);
+
+    NdotL = localL.z;
+
+    L = mul(localL, localToWorld);
 
     // Importance sampling weight for each sample
     // pdf = N.L / PI

Assets/ScriptableRenderLoop/ShaderLibrary/Sampling.hlsl

 }
 
 //-----------------------------------------------------------------------------
+// Coordinate system conversion
+//-----------------------------------------------------------------------------
+
+// Transforms the unit vector from the spherical to the Cartesian (right-handed, Z up) coordinate.
+float3 SphericalToCartesian(float phi, float cosTheta)
+{
+    float sinPhi, cosPhi;
+    sincos(phi, sinPhi, cosPhi);
+
+    float sinTheta = sqrt(saturate(1.0 - cosTheta * cosTheta));
+
+    return float3(sinTheta * cosPhi, sinTheta * sinPhi, cosTheta);
+}
+
+// Converts Cartesian coordinates given in the right-handed coordinate system
+// with Z pointing upwards (OpenGL style) to the coordinates in the left-handed
+// coordinate system with Y pointing up and Z facing forward (DirectX style).
+float3 TransformGLtoDX(float3 v)
+{
+    return v.xzy;
+}
+
+// Performs conversion from equiareal map coordinates to Cartesian (DirectX cubemap) ones.
+float3 ConvertEquiarealToCubemap(float u, float v)
+{
+    float phi      = TWO_PI - TWO_PI * u;
+    float cosTheta = 1.0 - 2.0 * v;
+
+    return TransformGLtoDX(SphericalToCartesian(phi, cosTheta));
+}
+
+//-----------------------------------------------------------------------------
-float3 UniformSampleSphere(float u1, float u2)
+// Performs uniform sampling of the unit disk.
+// Ref: PBRT v3, p. 777.
+float2 SampleDiskUniform(float u1, float u2)
+    float r   = sqrt(u1);
-    float cosTheta = 1.0 - 2.0 * u1;
-    float sinTheta = sqrt(max(0.0, 1.0 - cosTheta * cosTheta));
+
+    float sinPhi, cosPhi;
+    sincos(phi, sinPhi, cosPhi);
+
+    return r * float2(cosPhi, sinPhi);
+}
-    return float3(sinTheta * cos(phi), sinTheta * sin(phi), cosTheta); // Light point backward (-Z)
+// Performs cosine-weighted sampling of the hemisphere.
+// Ref: PBRT v3, p. 780.
+float3 SampleHemisphereCosine(float u1, float u2)
+{
+    float3 localL;
+
+    // Since we don't really care about the area distortion,
+    // we substitute uniform disk sampling for the concentric one.
+    localL.xy = SampleDiskUniform(u1, u2);
+
+    // Project the point from the disk onto the hemisphere.
+    localL.z = sqrt(1.0 - u1);
+
+    return localL;
-float3 UniformSampleHemisphere(float u1, float u2)
+float3 SampleHemisphereUniform(float u1, float u2)
-    float phi = TWO_PI * u2;
-    float cosTheta = u1;
-    float sinTheta = sqrt(max(0.0, 1.0 - cosTheta * cosTheta));
+    float phi      = TWO_PI * u2;
+    float cosTheta = 1.0 - u1;
-    return float3(sinTheta * cos(phi), sinTheta * sin(phi), cosTheta); // Light point backward (-Z)
+    return SphericalToCartesian(phi, cosTheta);
-float3 UniformSampleDisk(float u1, float u2)
+float3 SampleSphereUniform(float u1, float u2)
-    float r = sqrt(u1);
-    float phi = TWO_PI * u2;
+    float phi      = TWO_PI * u2;
+    float cosTheta = 1.0 - 2.0 * u1;
-    return float3(r * cos(phi), r * sin(phi), 0); // Generate in XY plane as light point backward (-Z)
+    return SphericalToCartesian(phi, cosTheta);
 }
 
 void SampleSphere(  float2 u,
     float u1 = u.x;
     float u2 = u.y;
 
-    Ns = UniformSampleSphere(u1, u2);
+    Ns = SampleSphereUniform(u1, u2);
 
     // Transform from unit sphere to world space
     P = radius * Ns + localToWorld[3].xyz;
     float u2 = u.y;
 
     // Random point at hemisphere surface
-    Ns = -UniformSampleHemisphere(u1, u2); // We want the y down hemisphere
+    Ns = -SampleHemisphereUniform(u1, u2); // We want the y down hemisphere
     P = radius * Ns;
 
     // Transform to world space
                 out float3 Ns)
 {
     // Random point at disk surface
-    P = UniformSampleDisk(u.x, u.y) * radius;
+    P  = float3(radius * SampleDiskUniform(u.x, u.y), 0);
     Ns = float3(0.0, 0.0, -1.0); // Light point backward (-Z)
 
     // Transform to world space

Assets/ScriptableRenderLoop/fptl/FptlLighting.cs

             //@TODO: need to get light probes + LPPV too?
             settings.inputFilter.SetQueuesOpaque();
             settings.rendererConfiguration = RendererConfiguration.PerObjectLightmaps | RendererConfiguration.PerObjectLightProbe;
-            loop.DrawRenderers(settings);
+            loop.DrawRenderers(ref settings);
         }
 
         void RenderForward(CullResults cull, Camera camera, ScriptableRenderContext loop, bool opaquesOnly)
             if (opaquesOnly) settings.inputFilter.SetQueuesOpaque();
             else settings.inputFilter.SetQueuesTransparent();
 
-            loop.DrawRenderers(settings);
+            loop.DrawRenderers(ref settings);
         }
 
         static void DepthOnlyForForwardOpaques(CullResults cull, Camera camera, ScriptableRenderContext loop)
                 sorting = { flags = SortFlags.CommonOpaque }
             };
             settings.inputFilter.SetQueuesOpaque();
-            loop.DrawRenderers(settings);
+            loop.DrawRenderers(ref settings);
         }
 
         bool usingFptl
             var cmd = new CommandBuffer() { name = "Build light list" };
 
             // generate screen-space AABBs (used for both fptl and clustered).
+            if (numLights != 0)
             {
                 var proj = CameraProjection(camera);
                 var temp = new Matrix4x4();

Assets/ScriptableRenderLoop/fptl/LightingConvexHullUtils.hlsl

 #if 1
 	float3 maxZdir = float3(-sphCen.z*sphCen.x, -sphCen.z*sphCen.y, sphCen.x*sphCen.x + sphCen.y*sphCen.y);		// cross(sphCen,cross(Zaxis,sphCen))
 	float len = length(maxZdir);
-	float scalarProj = len>0.0001 ? (maxZdir.z/len) : len;	// since len>=(maxZdir.z/len) we can use len as an approximate value when len<=epsilon
+	float scalarProj = len>0.0001 ? (maxZdir.z/len) : len;	// if len<=0.0001 then either |sphCen|<sphRadius or sphCen is very closely aligned with Z axis in which case little to no additional offs needed.
 	float offs = scalarProj*sphRadiusIn;
 #else
 	float offs = sphRadiusIn;		// more false positives due to larger radius but works too

ProjectSettings/ProjectSettings.asset

 --- !u!129 &1
 PlayerSettings:
   m_ObjectHideFlags: 0
-  serializedVersion: 10
+  serializedVersion: 11
   productGUID: 900e9e40d20cd3e44ad40e5b00239dcc
   AndroidProfiler: 0
   defaultScreenOrientation: 4
     16:10: 1
     16:9: 1
     Others: 1
-  bundleIdentifier: com.Company.ProductName
   bundleVersion: 1.0
   preloadedAssets: []
   metroInputSource: 0
       depthFormat: 1
   protectGraphicsMemory: 0
   useHDRDisplay: 0
+  applicationIdentifier:
+    Android: com.Company.ProductName
+    Standalone: unity.DefaultCompany.dev
+    Tizen: com.Company.ProductName
+    iOS: com.Company.ProductName
+    tvOS: com.Company.ProductName
+  buildNumber:
+    iOS: 0
   AndroidBundleVersionCode: 1
   AndroidMinSdkVersion: 16
   AndroidTargetSdkVersion: 0
   iPhoneStrippingLevel: 0
   iPhoneScriptCallOptimization: 0
-  iPhoneBuildNumber: 0
   ForceInternetPermission: 0
   ForceSDCardPermission: 0
   CreateWallpaper: 0
   ps4videoRecordingFeaturesUsed: 0
   ps4contentSearchFeaturesUsed: 0
   ps4attribEyeToEyeDistanceSettingVR: 0
-  ps4IncludedModules: []
+  ps4IncludedModules:
+  - libc.prx
+  - libSceAudioLatencyEstimation.prx
+  - libSceFace.prx
+  - libSceFaceTracker.prx
+  - libSceFios2.prx
+  - libSceHand.prx
+  - libSceHandTracker.prx
+  - libSceHeadTracker.prx
+  - libSceJobManager.prx
+  - libSceNpToolkit.prx
+  - libSceS3DConversion.prx
+  - libSceSmart.prx
   monoEnv: 
   psp2Splashimage: {fileID: 0}
   psp2NPTrophyPackPath: 

Assets/ScriptableRenderLoop/HDRenderPipeline/Debug/HDRenderPipelineDebug.cs

+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using System;
+
+namespace UnityEngine.Experimental.Rendering.HDPipeline
+{
+    [Serializable]
+    public class GlobalDebugParameters
+    {
+        public float debugOverlayRatio = 0.33f;
+        public bool displayDebug = false;
+        public bool displayShadowDebug = false;
+
+        public ShadowDebugParameters shadowDebugParameters = new ShadowDebugParameters();
+    }
+
+    public class DebugParameters
+    {
+        // Material Debugging
+        public int debugViewMaterial = 0;
+
+        // Rendering debugging
+        public bool displayOpaqueObjects = true;
+        public bool displayTransparentObjects = true;
+
+        public bool useForwardRenderingOnly = false; // TODO: Currently there is no way to strip the extra forward shaders generated by the shaders compiler, so we can switch dynamically.
+        public bool useDepthPrepass = false;
+        public bool useDistortion = true;
+
+        // we have to fallback to forward-only rendering when scene view is using wireframe rendering mode --
+        // as rendering everything in wireframe + deferred do not play well together
+        public bool ShouldUseForwardRenderingOnly() { return useForwardRenderingOnly || GL.wireframe; }
+    }
+
+    public enum ShadowDebugMode
+    {
+        None,
+        VisualizeAtlas,
+        VisualizeShadowMap
+    }
+
+    [Serializable]
+    public class ShadowDebugParameters
+    {
+        public bool             enableShadows = true;
+        public ShadowDebugMode  visualizationMode = ShadowDebugMode.None;
+        public uint             visualizeShadowMapIndex = 0;
+    }
+}

Assets/ScriptableRenderLoop/HDRenderPipeline/Debug/HDRenderPipelineDebug.cs.meta

+fileFormatVersion: 2
+guid: ae82efafe32ed1042a9360276bee62e6
+timeCreated: 1485277036
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderPipeline/Debug/Resources/DebugDisplayShadowMap.shader

+Shader "Hidden/HDRenderPipeline/DebugDisplayShadowMap"
+{
+    SubShader
+    {
+        Pass
+        {
+            ZWrite Off
+            ZTest Off
+            Blend One Zero
+            Cull Off
+
+            HLSLPROGRAM
+            #pragma target 4.5
+            #pragma only_renderers d3d11 ps4 metal // TEMP: unitl we go futher in dev
+
+            #pragma vertex Vert
+            #pragma fragment Frag
+
+            #include "Common.hlsl"
+
+            TEXTURE2D(g_tShadowBuffer);
+
+            TEXTURE2D(_DummyTexture);
+            SAMPLER2D(sampler_DummyTexture);
+
+            float4 _TextureScaleBias;
+
+            struct Attributes
+            {
+                uint vertexID : SV_VertexID;
+            };
+
+            struct Varyings
+            {
+                float4 positionCS : SV_POSITION;
+                float2 texcoord : TEXCOORD0;
+            };
+
+            Varyings Vert(Attributes input)
+            {
+                Varyings output;
+                output.positionCS = GetFullscreenTriangleVertexPosition(input.vertexID);
+                output.texcoord = GetFullscreenTriangleTexcoord(input.vertexID) * _TextureScaleBias.xy + _TextureScaleBias.zw;
+
+                return output;
+            }
+
+            float4 Frag(Varyings input) : SV_Target
+            {
+                // We need the dummy texture for the sampler, but we also need to sample it in order not to get a compile error.
+                float4 dummy = SAMPLE_TEXTURE2D(_DummyTexture, sampler_DummyTexture, input.texcoord) * 0.00001;
+                return SAMPLE_TEXTURE2D(g_tShadowBuffer, sampler_DummyTexture, input.texcoord).xxxx + dummy;
+            }
+
+            ENDHLSL
+        }
+
+    }
+    Fallback Off
+}

Assets/ScriptableRenderLoop/HDRenderPipeline/Debug/Resources/DebugDisplayShadowMap.shader.meta

+fileFormatVersion: 2
+guid: ee25e539f5594f44085e0a9000c15d9b
+timeCreated: 1476053153
+licenseType: Pro
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderPipeline/DefaultCommonSettings.asset

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &11400000
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: bc357c46587fc9d4cb8f311794d7d2f3, type: 3}
+  m_Name: DefaultCommonSettings
+  m_EditorClassIdentifier: 
+  m_Settings:
+    m_ShadowMaxDistance: 1000
+    m_ShadowCascadeCount: 4
+    m_ShadowCascadeSplit0: 0.05
+    m_ShadowCascadeSplit1: 0.2
+    m_ShadowCascadeSplit2: 0.3
+    m_SssProfileStdDev1: {r: 0.3, g: 0.3, b: 0.3, a: 0}
+    m_SssProfileStdDev2: {r: 1, g: 1, b: 1, a: 0}
+    m_SssProfileLerpWeight: 0.5
+    m_SssBilateralScale: 0.1

Assets/ScriptableRenderLoop/HDRenderPipeline/DefaultCommonSettings.asset.meta

+fileFormatVersion: 2
+guid: d8980cba5cb12414ca57fe2c5fabe2f3
+timeCreated: 1485858348
+licenseType: Pro
+NativeFormatImporter:
+  mainObjectFileID: 11400000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Lit/Resources/CombineSubsurfaceScattering.shader

+Shader "Hidden/HDRenderPipeline/CombineSubsurfaceScattering"
+{
+    Properties
+    {
+        _FilterRadius("", Float) = 20
+        _BilateralScale("", Float) = 0.1
+        [HideInInspector] _DstBlend("", Float) = 1 // Can be set to 1 for blending with specular
+    }
+
+    SubShader
+    {
+        Pass
+        {
+            Stencil
+            {
+                Ref  1 // StencilBits.SSS
+                Comp Equal
+                Pass Keep
+            }
+
+            ZTest  Always
+            ZWrite Off
+            Blend  One [_DstBlend], Zero [_DstBlend]
+
+            HLSLPROGRAM
+            #pragma target 4.5
+            #pragma only_renderers d3d11 ps4 metal // TEMP: until we go further in dev
+
+            #pragma vertex Vert
+            #pragma fragment Frag
+
+            //-------------------------------------------------------------------------------------
+            // Include
+            //-------------------------------------------------------------------------------------
+
+            #include "Common.hlsl"
+            #include "Assets/ScriptableRenderLoop/HDRenderPipeline/ShaderVariables.hlsl"
+
+            //-------------------------------------------------------------------------------------
+            // Inputs & outputs
+            //-------------------------------------------------------------------------------------
+
+            #define N_SAMPLES 7
+
+            float  _BilateralScale;   // Uses world-space units
+            float  _DistToProjWindow; // The height of the projection window is 2 meters
+            float  _FilterHorizontal; // Vertical = 0, horizontal = 1
+            float4 _FilterKernel[7];  // RGB = weights, A = radial distance
+            float  _FilterRadius;     // Uses world-space units
+
+            TEXTURE2D_FLOAT(_CameraDepthTexture);
+            TEXTURE2D(_IrradianceSource);
+            SAMPLER2D(sampler_IrradianceSource);
+
+            #define bilinearSampler sampler_IrradianceSource
+
+            //-------------------------------------------------------------------------------------
+            // Implementation
+            //-------------------------------------------------------------------------------------
+
+            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;
+            }
+
+            float4 Frag(Varyings input) : SV_Target
+            {
+                PositionInputs posInput = GetPositionInput(input.positionCS.xy, _ScreenSize.zw);
+
+                float rawDepth    = LOAD_TEXTURE2D(_CameraDepthTexture, posInput.unPositionSS).r;
+                float centerDepth = LinearEyeDepth(rawDepth, _ZBufferParams);
+                float radiusScale = _FilterRadius * _DistToProjWindow / centerDepth;
+
+                // Compute the filtering direction.
+                float2 unitDirection   = _FilterHorizontal ? float2(1, 0) : float2(0, 1);
+                float2 scaledDirection = radiusScale * unitDirection;
+
+                // Premultiply with the inverse of the screen size.
+                scaledDirection *= _ScreenSize.zw;
+
+                // Take the first (central) sample.
+                float3 sampleWeight   = _FilterKernel[0].rgb;
+                float2 samplePosition = posInput.unPositionSS;
+
+                float3 sampleIrradiance = LOAD_TEXTURE2D(_IrradianceSource, samplePosition).rgb;
+                float3 centerIrradiance = sampleIrradiance;
+
+                // Accumulate filtered irradiance (already weighted by (albedo / Pi)).
+                float3 filteredIrradiance = sampleIrradiance * sampleWeight;
+
+                [unroll]
+                for (int i = 1; i < N_SAMPLES; i++)
+                {
+                    sampleWeight   = _FilterKernel[i].rgb;
+                    samplePosition = posInput.positionSS + scaledDirection * _FilterKernel[i].a;
+
+                    sampleIrradiance = SAMPLE_TEXTURE2D_LOD(_IrradianceSource,   bilinearSampler, samplePosition, 0).rgb;
+                    rawDepth         = SAMPLE_TEXTURE2D_LOD(_CameraDepthTexture, bilinearSampler, samplePosition, 0).r;
+
+                    // Apply bilateral filtering.
+                    float sampleDepth = LinearEyeDepth(rawDepth, _ZBufferParams);
+                    float depthDiff   = abs(sampleDepth - centerDepth);
+                    float scaleDiff   = _BilateralScale * _FilterRadius * _DistToProjWindow;
+                    float t           = saturate(depthDiff / scaleDiff);
+
+                    // TODO: use real-world distances for weighting.
+                    filteredIrradiance += lerp(sampleIrradiance, centerIrradiance, t) * sampleWeight;
+                }
+
+                return float4(filteredIrradiance, 1.0);
+            }
+            ENDHLSL
+        }
+    }
+    Fallback Off
+}

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Lit/Resources/CombineSubsurfaceScattering.shader.meta

+fileFormatVersion: 2
+guid: 867b36db983aa0548889a66f8d685ff6
+timeCreated: 1485184880
+licenseType: Pro
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderPipeline/SceneSettings/SubsurfaceScatteringParameters.cs

+using System;
+using UnityEditor;
+
+namespace UnityEngine.Experimental.Rendering.HDPipeline
+{
+    [Serializable]
+    public class SubsurfaceScatteringProfile
+    {
+        public const int numSamples = 7; // Must be an odd number
+        
+        [SerializeField, ColorUsage(false, true, 0.05f, 2.0f, 1.0f, 1.0f)]
+        Color       m_StdDev1;
+        [SerializeField, ColorUsage(false, true, 0.05f, 2.0f, 1.0f, 1.0f)]
+        Color       m_StdDev2;
+        [SerializeField]
+        float       m_LerpWeight;
+        [SerializeField]
+        Vector4[]   m_FilterKernel;
+        [SerializeField]
+        public bool m_KernelNeedsUpdate;
+
+        // --- Public Methods ---
+
+        public SubsurfaceScatteringProfile()
+        {
+            m_StdDev1    = new Color(0.3f, 0.3f, 0.3f, 0.0f);
+            m_StdDev2    = new Color(1.0f, 1.0f, 1.0f, 0.0f);
+            m_LerpWeight = 0.5f;
+            ComputeKernel();
+        }
+
+        public Color stdDev1
+        {
+            get { return m_StdDev1; }
+            set { if (m_StdDev1 != value) { m_StdDev1 = value; m_KernelNeedsUpdate = true; } }
+        }
+
+        public Color stdDev2
+        {
+            get { return m_StdDev2; }
+            set { if (m_StdDev2 != value) { m_StdDev2 = value; m_KernelNeedsUpdate = true; } }
+        }
+
+        public float lerpWeight
+        {
+            get { return m_LerpWeight; }
+            set { if (m_LerpWeight != value) { m_LerpWeight = value; m_KernelNeedsUpdate = true; } }
+        }
+
+        public Vector4[] filterKernel
+        {
+            get { if (m_KernelNeedsUpdate) ComputeKernel(); return m_FilterKernel; }
+        }
+
+        public void SetDirtyFlag()
+        {
+            m_KernelNeedsUpdate = true;
+        }
+
+        // --- Private Methods ---
+
+        static float Gaussian(float x, float stdDev)
+        {
+            float variance = stdDev * stdDev;
+            return Mathf.Exp(-x * x / (2 * variance)) / Mathf.Sqrt(2 * Mathf.PI * variance);
+        }
+
+        static float GaussianCombination(float x, float stdDev1, float stdDev2, float lerpWeight)
+        {
+            return Mathf.Lerp(Gaussian(x, stdDev1), Gaussian(x, stdDev2), lerpWeight);
+        }
+
+        static float RationalApproximation(float t)
+        {
+            // Abramowitz and Stegun formula 26.2.23.
+            // The absolute value of the error should be less than 4.5 e-4.
+            float[] c = {2.515517f, 0.802853f, 0.010328f};
+            float[] d = {1.432788f, 0.189269f, 0.001308f};
+            return t - ((c[2] * t + c[1]) * t + c[0]) / (((d[2] * t + d[1]) * t + d[0]) * t + 1.0f);
+        }
+ 
+        // Ref: https://www.johndcook.com/blog/csharp_phi_inverse/
+        static float NormalCdfInverse(float p, float stdDev)
+        {
+            float x;
+
+            if (p < 0.5)
+            {
+                // F^-1(p) = - G^-1(p)
+                x = -RationalApproximation(Mathf.Sqrt(-2.0f * Mathf.Log(p)));
+            }
+            else
+            {
+                // F^-1(p) = G^-1(1-p)
+                x = RationalApproximation(Mathf.Sqrt(-2.0f * Mathf.Log(1.0f - p)));
+            }
+
+            return x * stdDev;
+        }
+
+        static float GaussianCombinationCdfInverse(float p, float stdDev1, float stdDev2, float lerpWeight)
+        {
+            return Mathf.Lerp(NormalCdfInverse(p, stdDev1), NormalCdfInverse(p, stdDev2), lerpWeight);
+        }
+
+        void ComputeKernel()
+        {
+            if (m_FilterKernel == null || m_FilterKernel.Length != numSamples)
+            {
+                m_FilterKernel = new Vector4[numSamples];
+            }
+
+            // Our goal is to blur the image using a filter which is represented
+            // as a product of a linear combination of two normalized 1D Gaussians
+            // as suggested by Jimenez et al. in "Separable Subsurface Scattering".
+            // A normalized (i.e. energy-preserving) 1D Gaussian with the mean of 0
+            // is defined as follows: G1(x, v) = exp(-x� / (2 * v)) / sqrt(2 * Pi * v),
+            // where 'v' is variance and 'x' is the radial distance from the origin.
+            // Using the weight 'w', our 1D and the resulting 2D filters are given as:
+            // A1(v1, v2, w, x)    = G1(x, v1) * (1 - w) + G1(r, v2) * w,
+            // A2(v1, v2, w, x, y) = A1(v1, v2, w, x) * A1(v1, v2, w, y).
+            // The resulting filter function is a non-Gaussian PDF.
+            // It is separable by design, but generally not radially symmetric.
+
+            // Find the widest Gaussian across 3 color channels.
+            float maxStdDev1 = Mathf.Max(m_StdDev1.r, m_StdDev1.g, m_StdDev1.b);
+            float maxStdDev2 = Mathf.Max(m_StdDev2.r, m_StdDev2.g, m_StdDev2.b);
+
+            Vector3 weightSum = new Vector3(0, 0, 0); 
+
+            // Importance sample the linear combination of two Gaussians.
+            for (uint i = 0; i < numSamples; i++)
+            {
+                float u   = (i + 0.5f) / numSamples;
+                float pos = GaussianCombinationCdfInverse(u, maxStdDev1, maxStdDev2, m_LerpWeight);
+                float pdf = GaussianCombination(pos, maxStdDev1, maxStdDev2, m_LerpWeight);
+
+                Vector3 val;
+                val.x = GaussianCombination(pos, m_StdDev1.r, m_StdDev2.r, m_LerpWeight);
+                val.y = GaussianCombination(pos, m_StdDev1.g, m_StdDev2.g, m_LerpWeight);
+                val.z = GaussianCombination(pos, m_StdDev1.b, m_StdDev2.b, m_LerpWeight);
+
+                m_FilterKernel[i].x = val.x / (pdf * numSamples);
+                m_FilterKernel[i].y = val.y / (pdf * numSamples);
+                m_FilterKernel[i].z = val.z / (pdf * numSamples);
+                m_FilterKernel[i].w = pos;
+
+                weightSum.x += m_FilterKernel[i].x;
+                weightSum.y += m_FilterKernel[i].y;
+                weightSum.z += m_FilterKernel[i].z;
+            }
+
+            // Renormalize the weights to conserve energy.
+            for (uint i = 0; i < numSamples; i++)
+            {
+                m_FilterKernel[i].x *= 1.0f / weightSum.x;
+                m_FilterKernel[i].y *= 1.0f / weightSum.y;
+                m_FilterKernel[i].z *= 1.0f / weightSum.z;
+            }
+
+            m_KernelNeedsUpdate = false;
+        }
+    }
+
+    public class SubsurfaceScatteringParameters : ScriptableObject
+    {
+        const int m_maxNumProfiles = 8;
+        [SerializeField]
+        int m_NumProfiles;
+        [SerializeField]
+        SubsurfaceScatteringProfile[] m_Profiles;
+        [SerializeField]
+        float m_BilateralScale;
+
+        // --- Public Methods ---
+
+        public SubsurfaceScatteringParameters()
+        {
+            m_NumProfiles    = 1;
+            m_Profiles       = new SubsurfaceScatteringProfile[m_NumProfiles];
+            m_BilateralScale = 0.1f;
+
+            for (int i = 0; i < m_NumProfiles; i++)
+            {
+                m_Profiles[i] = new SubsurfaceScatteringProfile();
+            }
+        }
+
+        public SubsurfaceScatteringProfile[] profiles       { set { m_Profiles       = value; OnValidate(); } get { return m_Profiles; } }
+        public float                         bilateralScale { set { m_BilateralScale = value; OnValidate(); } get { return m_BilateralScale; } }
+
+        public void SetDirtyFlag()
+        {
+            for (int i = 0; i < m_Profiles.Length; i++)
+            {
+                m_Profiles[i].SetDirtyFlag();
+            }
+        }
+
+        // --- Private Methods ---
+
+        void OnValidate()
+        {
+            if (m_Profiles.Length > m_maxNumProfiles)
+            {
+                Array.Resize(ref m_Profiles, m_maxNumProfiles);
+            }
+
+            m_NumProfiles = m_Profiles.Length;
+
+            Color c = new Color();
+
+            for (int i = 0; i < m_NumProfiles; i++)
+            {
+                c.r = Mathf.Clamp(m_Profiles[i].stdDev1.r, 0.05f, 2.0f);
+                c.g = Mathf.Clamp(m_Profiles[i].stdDev1.g, 0.05f, 2.0f);
+                c.b = Mathf.Clamp(m_Profiles[i].stdDev1.b, 0.05f, 2.0f);
+                c.a = 0.0f;
+
+                m_Profiles[i].stdDev1 = c;
+
+                c.r = Mathf.Clamp(m_Profiles[i].stdDev2.r, 0.05f, 2.0f);
+                c.g = Mathf.Clamp(m_Profiles[i].stdDev2.g, 0.05f, 2.0f);
+                c.b = Mathf.Clamp(m_Profiles[i].stdDev2.b, 0.05f, 2.0f);
+                c.a = 0.0f;
+
+                m_Profiles[i].stdDev2 = c;
+
+                m_Profiles[i].lerpWeight = Mathf.Clamp01(m_Profiles[i].lerpWeight);
+            }
+
+            m_BilateralScale = Mathf.Clamp01(m_BilateralScale);
+        }
+    }
+
+    public class SubsurfaceScatteringSettings : Singleton<SubsurfaceScatteringSettings>
+    {
+        SubsurfaceScatteringParameters settings { get; set; }
+
+        public static SubsurfaceScatteringParameters overrideSettings
+        {
+            get { return instance.settings; }
+            set { instance.settings = value; }
+        }
+    }
+
+    [CustomEditor(typeof(SubsurfaceScatteringParameters))]
+    public class SubsurfaceScatteringParametersEditor : Editor
+    {
+        private class Styles
+        {
+            public readonly GUIContent sssCategory          = new GUIContent("Subsurface scattering");
+            public readonly GUIContent sssProfileStdDev1    = new GUIContent("SSS profile standard deviation #1", "Determines the shape of the 1st Gaussian filter. Increases the strength and the radius of the blur of the corresponding color channel.");
+            public readonly GUIContent sssProfileStdDev2    = new GUIContent("SSS profile standard deviation #2", "Determines the shape of the 2nd Gaussian filter. Increases the strength and the radius of the blur of the corresponding color channel.");
+            public readonly GUIContent sssProfileLerpWeight = new GUIContent("SSS profile filter interpolation", "Controls linear interpolation between the two Gaussian filters.");
+            public readonly GUIContent sssBilateralScale    = new GUIContent("SSS bilateral filtering scale", "Larger values make the filter more tolerant to depth differences.");
+        }
+
+        private static Styles s_Styles;
+
+        private SerializedProperty m_Profiles;
+        private SerializedProperty m_BilateralScale;
+
+        // --- Public Methods ---
+
+        private static Styles styles
+        {
+            get
+            {
+                if (s_Styles == null)
+                {
+                    s_Styles = new Styles();
+                }
+                return s_Styles;
+            }
+        }
+
+        public override void OnInspectorGUI()
+        {
+            serializedObject.Update();
+
+            EditorGUI.BeginChangeCheck();
+            EditorGUILayout.PropertyField(m_Profiles, true);
+            EditorGUILayout.PropertyField(m_BilateralScale, styles.sssBilateralScale);
+            if (EditorGUI.EndChangeCheck())
+            {
+                serializedObject.ApplyModifiedProperties();
+                // Serialization ignores setters.
+                ((SubsurfaceScatteringParameters)target).SetDirtyFlag();
+            }
+        }
+
+        // --- Private Methods ---
+
+        void OnEnable()
+        {
+            m_Profiles       = serializedObject.FindProperty("m_Profiles");
+            m_BilateralScale = serializedObject.FindProperty("m_BilateralScale");
+        }
+    }
+}

Assets/ScriptableRenderLoop/HDRenderPipeline/SceneSettings/SubsurfaceScatteringParameters.cs.meta

+fileFormatVersion: 2
+guid: e9493dbe9d624704d9a80a75d52835b3
+timeCreated: 1485361779
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TestScenes/HDTest/CascadedShadowsTest.meta

+fileFormatVersion: 2
+guid: ab939294412b89e49b889738eeeb844a
+folderAsset: yes
+timeCreated: 1485274537
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TestScenes/HDTest/CascadedShadowsTest.unity.meta

+fileFormatVersion: 2
+guid: e30864c7c4266b24cb1c708c206200a6
+timeCreated: 1483527925
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TestScenes/HDTest/GraphicTest/Common/Dragon.meta

+fileFormatVersion: 2
+guid: abccc9d378737eb44bf8c55fe7336190
+folderAsset: yes
+timeCreated: 1485873807
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TestScenes/HDTest/GraphicTest/Two Sided/Prefabs/Materials.meta

+fileFormatVersion: 2
+guid: 0e2aa881811d0644896d4b5a732945cc
+folderAsset: yes
+timeCreated: 1485804900
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TestScenes/HDTest/CascadedShadowsTest/Lit_Gray.mat

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: Lit_Gray
+  m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
+  m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DEPTHOFFSETENABLE_OFF _DETAIL_MAP_WITH_NORMAL
+    _DISTORTIONDEPTHTEST_OFF _DISTORTIONENABLE_OFF _DISTORTIONONLY_OFF _ENABLEPERPIXELDISPLACEMENT_OFF
+    _NORMALMAP_TANGENT_SPACE
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses:
+  - DistortionVectors
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _AnisotropyMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DistortionVectorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissiveColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SubSurfaceRadiusMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TangentMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _AlphaCutoff: 0.5
+    - _AlphaCutoffEnable: 0
+    - _Anisotropy: 0
+    - _BlendMode: 0
+    - _BumpScale: 1
+    - _CullMode: 2
+    - _Cutoff: 0.5
+    - _DepthOffsetEnable: 0
+    - _DetailAOScale: 1
+    - _DetailAlbedoScale: 1
+    - _DetailHeightScale: 1
+    - _DetailMapMode: 0
+    - _DetailNormalMapScale: 1
+    - _DetailNormalScale: 1
+    - _DetailSmoothnessScale: 1
+    - _DistortionDepthTest: 0
+    - _DistortionEnable: 0
+    - _DistortionOnly: 0
+    - _DoubleSidedMode: 0
+    - _DstBlend: 0
+    - _EmissiveColorMode: 1
+    - _EmissiveIntensity: 0
+    - _EnablePerPixelDisplacement: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _HeightAmplitude: 0.01
+    - _HeightCenter: 0.5
+    - _MaterialId: 0
+    - _Metallic: 0
+    - _Mode: 0
+    - _NormalMapSpace: 0
+    - _NormalScale: 1
+    - _OcclusionStrength: 1
+    - _PPDMaxSamples: 15
+    - _PPDMinSamples: 5
+    - _Parallax: 0.02
+    - _Smoothness: 0.5
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _SubSurfaceRadius: 0
+    - _SurfaceType: 0
+    - _TexWorldScale: 1
+    - _UVBase: 0
+    - _UVDetail: 0
+    - _UVMappingPlanar: 0
+    - _UVSec: 0
+    - _ZTestMode: 8
+    - _ZWrite: 1
+    m_Colors:
+    - _BaseColor: {r: 0.49803922, g: 0.49803922, b: 0.49803922, a: 1}
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _EmissiveColor: {r: 0, g: 0, b: 0, a: 1}
+    - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}

Assets/TestScenes/HDTest/CascadedShadowsTest/Lit_Gray.mat.meta

+fileFormatVersion: 2
+guid: 906f2e00230e2a34b832d52909cc5906
+timeCreated: 1485274548
+licenseType: Pro
+NativeFormatImporter:
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TestScenes/HDTest/GraphicTest/Common/Dragon/DragonStatue.FBX.meta

+fileFormatVersion: 2
+guid: a4ce73c115746a34ba12813555ed5d78
+timeCreated: 1480931925
+licenseType: Pro
+ModelImporter:
+  serializedVersion: 19
+  fileIDToRecycleName:
+    100000: //RootNode
+    100002: Box001
+    100004: Camera001
+    100006: Camera001.Target
+    100008: DragonGame
+    400000: //RootNode
+    400002: Box001
+    400004: Camera001
+    400006: Camera001.Target
+    400008: DragonGame
+    2300000: //RootNode
+    2300002: Box001
+    2300004: DragonGame
+    3300000: //RootNode
+    3300002: Box001
+    3300004: DragonGame
+    4300000: DragonGame
+    4300002: Box001
+    9500000: //RootNode
+  materials:
+    importMaterials: 1
+    materialName: 1
+    materialSearch: 2
+  animations:
+    legacyGenerateAnimations: 4
+    bakeSimulation: 0
+    resampleCurves: 1
+    optimizeGameObjects: 0
+    motionNodeName: 
+    rigImportErrors: 
+    rigImportWarnings: 
+    animationImportErrors: 
+    animationImportWarnings: 
+    animationRetargetingWarnings: 
+    animationDoRetargetingWarnings: 0
+    animationCompression: 1
+    animationRotationError: 0.5
+    animationPositionError: 0.5
+    animationScaleError: 0.5
+    animationWrapMode: 0
+    extraExposedTransformPaths: []
+    clipAnimations: []
+    isReadable: 1
+  meshes:
+    lODScreenPercentages: []
+    globalScale: 1
+    meshCompression: 0
+    addColliders: 0
+    importBlendShapes: 1
+    swapUVChannels: 0
+    generateSecondaryUV: 0
+    useFileUnits: 1
+    optimizeMeshForGPU: 1
+    keepQuads: 0
+    weldVertices: 1
+    secondaryUVAngleDistortion: 8
+    secondaryUVAreaDistortion: 15.000001
+    secondaryUVHardAngle: 88
+    secondaryUVPackMargin: 4
+    useFileScale: 1
+  tangentSpace:
+    normalSmoothAngle: 60
+    normalImportMode: 0
+    tangentImportMode: 3
+  importAnimation: 1
+  copyAvatar: 0
+  humanDescription:
+    serializedVersion: 2
+    human: []
+    skeleton: []
+    armTwist: 0.5
+    foreArmTwist: 0.5
+    upperLegTwist: 0.5
+    legTwist: 0.5
+    armStretch: 0.05
+    legStretch: 0.05
+    feetSpacing: 0
+    rootMotionBoneName: 
+    rootMotionBoneRotation: {x: 0, y: 0, z: 0, w: 1}
+    hasTranslationDoF: 0
+    hasExtraRoot: 0
+    skeletonHasParents: 1
+  lastHumanDescriptionAvatarSource: {instanceID: 0}
+  animationType: 2
+  humanoidOversampling: 1
+  additionalBone: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TestScenes/HDTest/GraphicTest/Common/Dragon/DragonStatue.mat.meta

+fileFormatVersion: 2
+guid: 0bf15b8de3277ad4499346f5f8494bbd
+timeCreated: 1480931890
+licenseType: Pro
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TestScenes/HDTest/GraphicTest/Common/Dragon/Dragon_H.exr.meta

+fileFormatVersion: 2
+guid: 57044228904fe56449ead7efc223e4ad
+timeCreated: 1480932183
+licenseType: Pro
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    filterMode: -1
+    aniso: -1
+    mipBias: -1
+    wrapMode: -1
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 1
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 1024
+    textureFormat: -1
+    textureCompression: 2
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 2048
+    textureFormat: 26
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 1
+  - buildTarget: PS4
+    maxTextureSize: 2048
+    textureFormat: 26
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 1
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TestScenes/HDTest/GraphicTest/Common/Dragon/Dragon_LRBC_NoLight.png.meta

+fileFormatVersion: 2
+guid: d2472fab9be6dd4479dd5895a5055413
+timeCreated: 1481113774
+licenseType: Pro
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    filterMode: -1
+    aniso: -1
+    mipBias: -1
+    wrapMode: -1
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 1
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 8192
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 8192
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TestScenes/HDTest/GraphicTest/Common/Dragon/Dragon_MSK.tga.meta

+fileFormatVersion: 2
+guid: e31d177bc8c9381439c9b327a2636d3e
+timeCreated: 1480932278
+licenseType: Pro
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    filterMode: -1
+    aniso: -1
+    mipBias: -1
+    wrapMode: -1
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 1
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 4096
+    textureFormat: -1
+    textureCompression: 2
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 4096
+    textureFormat: -1
+    textureCompression: 2
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TestScenes/HDTest/GraphicTest/Common/Dragon/Dragon_N.tga.meta

+fileFormatVersion: 2
+guid: 75bfcd5e2d2d5954ca601a85db5d1a73
+timeCreated: 1480932189
+licenseType: Pro
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    filterMode: -1
+    aniso: -1
+    mipBias: -1
+    wrapMode: -1
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 1
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 1
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 4096
+    textureFormat: -1
+    textureCompression: 2
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 4096
+    textureFormat: -1
+    textureCompression: 2
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TestScenes/HDTest/GraphicTest/Common/Dragon/DragonStatue.mat

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: DragonStatue
+  m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
+  m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DEPTHOFFSETENABLE_OFF _DETAIL_MAP_WITH_NORMAL
+    _DISTORTIONDEPTHTEST_OFF _DISTORTIONENABLE_OFF _DISTORTIONONLY_OFF _EMISSION _ENABLEPERPIXELDISPLACEMENT_OFF
+    _HEIGHTMAP _MASKMAP _NORMALMAP _NORMALMAP_TANGENT_SPACE _TESSELLATION_DISPLACEMENT
+    _TESSELLATION_OBJECT_SCALE
+  m_LightmapFlags: 1
+  m_EnableInstancingVariants: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses:
+  - DistortionVectors
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _AnisotropyMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap:
+        m_Texture: {fileID: 2800000, guid: d2472fab9be6dd4479dd5895a5055413, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DispTex:
+        m_Texture: {fileID: 2800000, guid: 57044228904fe56449ead7efc223e4ad, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DistortionVectorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissiveColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap:
+        m_Texture: {fileID: 2800000, guid: 57044228904fe56449ead7efc223e4ad, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MSK:
+        m_Texture: {fileID: 2800000, guid: e31d177bc8c9381439c9b327a2636d3e, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 2800000, guid: d2472fab9be6dd4479dd5895a5055413, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap:
+        m_Texture: {fileID: 2800000, guid: e31d177bc8c9381439c9b327a2636d3e, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap:
+        m_Texture: {fileID: 2800000, guid: 75bfcd5e2d2d5954ca601a85db5d1a73, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMapDetail:
+        m_Texture: {fileID: 2800000, guid: ad9cb02bddceb1340bc1fcb19d5f35bd, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SubSurfaceRadiusMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TangentMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _AlphaCutoff: 0.5
+    - _AlphaCutoffEnable: 0
+    - _Anisotropy: 0
+    - _BlendMode: 0
+    - _BumpScale: 1
+    - _CullMode: 2
+    - _Cutoff: 0.5
+    - _DepthOffsetEnable: 0
+    - _DetailAOScale: 1
+    - _DetailAlbedoScale: 1
+    - _DetailHeightScale: 1
+    - _DetailMapMode: 0
+    - _DetailNormalMapScale: 1
+    - _DetailNormalScale: 1
+    - _DetailSmoothnessScale: 1
+    - _Displacement: 0.008
+    - _DisplacementCenter: 0.36
+    - _DisplacementfalloffFar: 150
+    - _DisplacementfalloffNear: 30
+    - _DistortionDepthTest: 0
+    - _DistortionEnable: 0
+    - _DistortionOnly: 0
+    - _DoubleSidedMode: 0
+    - _DstBlend: 0
+    - _EmissiveColorMode: 1
+    - _EmissiveIntensity: 0
+    - _EnablePerPixelDisplacement: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _HeightAmplitude: 0
+    - _HeightCenter: 0
+    - _HorizonFade: 1
+    - _MaterialId: 0
+    - _Metallic: 0
+    - _Mode: 0
+    - _NormalDetailMul: 0.347
+    - _NormalMapSpace: 0
+    - _NormalScale: 1
+    - _OcclusionStrength: 1
+    - _PPDMaxSamples: 15
+    - _PPDMinSamples: 5
+    - _Parallax: 0.02
+    - _Smoothness: 1
+    - _SmoothnessAO: 0
+    - _SmoothnessAv: 0.499
+    - _SmoothnessTextureChannel: 0
+    - _SmoothnessVar: 0.491
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _SubSurfaceRadius: 0
+    - _SurfaceType: 0
+    - _Tess: 8
+    - _TessFar: 1
+    - _TessNear: 0.2
+    - _TessellationBackFaceCullEpsilon: -0.25
+    - _TessellationFactor: 4
+    - _TessellationFactorMaxDistance: 50
+    - _TessellationFactorMinDistance: 20
+    - _TessellationFactorTriangleSize: 100
+    - _TessellationMode: 1
+    - _TessellationObjectScale: 1
+    - _TessellationShapeFactor: 0.75
+    - _TexWorldScale: 1
+    - _Tiling: 1
+    - _TilingDetail: 6
+    - _UVBase: 0
+    - _UVDetail: 0
+    - _UVMappingPlanar: 0
+    - _UVSec: 0
+    - _ZTestMode: 8
+    - _ZWrite: 1
+    m_Colors:
+    - _BaseColor: {r: 1, g: 1, b: 1, a: 1}
+    - _Color: {r: 0.9862069, g: 0.9862069, b: 0.9862069, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _EmissiveColor: {r: 0, g: 0, b: 0, a: 1}
+    - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}

Assets/TestScenes/HDTest/Leaf.meta

-fileFormatVersion: 2
-guid: 01cfa4863006ad6499396fb0d4802c7e
-folderAsset: yes
-timeCreated: 1475755141
-licenseType: Pro
-DefaultImporter:
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: